Cadaclysm opens STEP, IFC, 3DM, IGES, ACIS (SAT), OpenCASCADE .brep and OpenSCAD files while your project runs: no import, no cooking, no assets. A document draws as a single primitive, either from triangles or by evaluating its trimmed surfaces on the GPU every frame.

The plugin is free to download, develop and test with. A product that runs in production needs a licence from the official website, one per product, yearly (or monthly on the Startup plan) and royalty-free. Students and schools pay nothing.

Reading, not modelling, for now. The plugin opens, draws and queries CAD files. Cadaclysm's modelling kernel (booleans, fillets, sweeps, lofts and writing STEP files) is not part of the plugin yet. Creating and editing CAD geometry inside Unreal (as well as Mac and iOS support) is coming in a future release.

Join the Discord server: https://discord.gg/XuhmdKapxP

Drawing

A document is one primitive, whatever its part count. Parts that share a placement and a material are merged into runs, so a whole assembly costs a handful of draw calls rather than one per part: on one sample document, 3,739 draws a frame became 63. Nothing is spawned or ticked per part, and every part remains addressable by index: transform, visibility, colour, hit results, and selection through a query language.

UCadaclysmComponent meshes each part once, at load. UCadaclysmSurfaceComponent does not mesh at all. It keeps the trimmed surfaces the file describes and evaluates them on the GPU each frame, at a density set in screen pixels (r.Cadaclysm.Surface.SagittaPx, 0.3 by default) rather than in model units. A part drawn this way has no triangles anywhere: its bounds come from its surfaces, a click is answered against its faces, and its outline is drawn from its trim curves. If a frame needs more vertices than its budget allows, it is tessellated again, coarser, within the same frame, so a new view never draws with faces missing. The drawing path is chosen by the component's class.

Edges, free curves and isocurves are drawn from the document's own curves, not from the triangles of a mesh, and isocurves are clipped to the trims of each face. Lines are a constant width in pixels, anti-aliased, and stay steady under TAA and TSR without trailing behind a moving camera. Colour and width are set per kind and can change at run time. The same renderer is available for your own lines: UCadaclysmLineComponent draws grids, gizmos, bounding boxes and paths, either hidden by the scene or drawn on top of it.

Lighting

A meshed document is lit like any static mesh. Its distance field is built by the plugin at run time instead of being cooked: a resolution scale sets the detail, and the build runs in the background, within a time budget per submission, optionally on the async compute queue.

A surface-drawn document casts ordinary shadow-map shadows, because each shadow view is tessellated in its own pass at its own density. Ray-traced shadows, Lumen's hardware path and distance-field effects need triangles, which a surface-drawn part does not have. For those systems alone, Surface Proxy Mesh Cells builds a coarse mesh: each face is gridded into that many cells a side and kept inside its trims. That mesh is never drawn.

Static meshes and Nanite

ACadaclysmStaticMeshActor gives each part its own UStaticMeshComponent instead. It trades the merged runs for what the engine does per component: a rigid body per part, per-part culling and occlusion, and motion vectors. One UStaticMesh is built per distinct geometry rather than per placement, so a block placed seventy-four times is built once. Building a few thousand of them still takes seconds and real memory. ACadaclysmPartBodiesActor covers the middle ground: one drawn primitive, with a rigid body per part.

Nanite is an option on the static mesh actor. Each part's geometry is encoded in the background by the plugin's own encoder, and a part switches to Nanite when its encode is ready; a part that cannot be encoded keeps drawing as before. The encoder has no editor dependency, so this works in a packaged build: no editor, no cooking, no asset. It is off by default and still experimental. It costs frame time on documents of this size, and is worth enabling for what it brings to a scene, not for speed.

Interfaces

Everything above is available from both Blueprint and C++. Per-part colour, transform and visibility can change at run time; the settings that decide what a load builds cannot, and are documented as such.

Features

• Opens STEP, IFC, 3DM, IGES, ACIS (SAT), OpenCASCADE .brep and OpenSCAD files at run time

• No import, no cooking, no assets: packaged builds open files that did not exist at build time

• Each document is one primitive; parts are addressed by index, not by actor

• Draws from triangles, or from the exact trimmed surfaces evaluated on the GPU each frame

• Parts merged into runs: a whole assembly in a handful of draw calls

• The first frame at a new view draws every face, even over the vertex budget

• Shadow-map shadows cast from surfaces, with no triangles built

• Distance fields built at run time in the background, never cooked

• Lumen and ray tracing supported through an optional coarse proxy mesh

• A static mesh actor for per-part rigid bodies, culling and occlusion

• Experimental Nanite, encoded at run time by the plugin: no editor, no cooking, no asset

• Edges, free curves and isocurves drawn from the document's curves: pixel-wide, anti-aliased and steady under TAA and TSR

• A line component for your own grids, gizmos, boxes and paths, drawn by the same renderer

• Per-part colour, transform and visibility, all changeable at run time

• Per-part hit results; parts selected with a query language

• Collision fitted per part at load: a box, sphere, capsule or convex hull

• Blueprint and C++ interfaces

• Licence set from Blueprint, from a file, or from the environment

Technical details

• Modules: Cadaclysm (Runtime)

• Supported platforms: Windows 64-bit, Linux x86-64, Android arm64

• Plugin version: 0.9.0, matching the Cadaclysm release it ships

• Engine version: 5.8

• Native library: ships as a shared library inside the plugin and is loaded at startup; no editor-only dependency at run time

• Documentation: https://cadaclysm.blitter.studio/engines/unreal.html

• SDK and issues: https://github.com/rdeioris/cadaclysm-sdk

• Community support (Discord): https://discord.gg/XuhmdKapxP

Important notes

• Surfaces need shader model 6. The surface path is built on compute shaders compiled for SM6 and above (DirectX 12, or Vulkan SM6 on desktop). Below that, including DirectX 11 and every Android renderer, the plugin logs this once and draws documents from their triangles instead.

• Edge and isocurve lines need shader model 5. Android's mobile renderer (Vulkan ES 3.1) draws documents without them; a project set to Vulkan SM5 on Android draws them.

• Pick CAD File has no dialog on Android. Load by path there. On Windows and Linux it opens the desktop's own file chooser. Everything else is the same library on all three platforms.

• Ray tracing needs the coarse proxy. Parts drawn from their surfaces have no triangles, so without the optional proxy mesh they are missing from ray-traced shadows, Lumen's hardware path and the distance field. One setting turns it on.

• Materials. A document drawn from surfaces uses the plugin's own material; the two drawing paths do not share a material graph.

• Collision is one fitted shape per part. It is computed at load: the best-fitting box, sphere, capsule or convex hull. Concave parts are not decomposed.

• Licensing. The plugin is free; the library it loads is covered by the Cadaclysm EULA, and a product in production needs a licence.