Export an asset that keeps running
Most tools hand Roblox a finished mesh. AxoGeo hands it a model and the logic that drives it — a generated Luau runtime where every parameter is a live Instance Attribute you can tune in Studio while the game is playing.
A live AxoGeo graph — mesh particles, evaluated per frame. Exported to Roblox, this keeps moving: the motion is transpiled into Luau, not baked into a mesh.
What actually lands in your game
.rbxmx model + generated Luau runtime
Geometry is built once when the script initialises, so re-triggering an effect costs nothing. Drop it in, and one PivotTo on the root moves the whole thing — every part composes onto the root frame each frame rather than writing absolute world coordinates.
Live Instance Attributes
Every runtime parameter is exposed as an Attribute and re-read every frame. Change a colour, a radius, a rate in the Properties panel and watch it update — no re-export, no round trip through the browser. Your game code writes the same Attributes to drive it.
Loud, and partial
Each set builds inside its own pcall and the script reports how many succeeded. If one piece of an effect fails, you get the rest plus a line telling you what broke — instead of an empty Workspace and no explanation.
Mesh particles the native emitter cannot do
Roblox's ParticleEmitter is billboard-only — flat sprites that always face the camera. AxoGeo emits real geometry on a deterministic slot model, so a particle can be a shard, a rock, a rune, a leaf, tumbling in 3D with its own orientation. Because every instance is a pure function of index and frame, playback is exact, loops are seamless, and the export matches the editor frame for frame.
| Capability | Roblox |
|---|---|
| Mesh geometry | Supported |
| MaterialsA Roblox BasePart has no emissive channel, so glow is approximated: the part colour is tinted toward the emissive colour (capped at 35%) and flips to Neon at intensity 0.5 and above - except glass, which never becomes Neon because Neon is unlit. (Real emissive exists on the platform via MeshPart + SurfaceAppearance, but that needs uploaded texture assets; this target rebuilds geometry at runtime with no uploads, so it is not a path we take.) Roblox Glass also renders nothing non-opaque behind it, so a multi-part set (shards, particle pools) drops to SmoothPlastic to sort correctly; a single-part set keeps real refractive Glass. | Supported, with a caveat |
| Vertex coloursA Color-Ramped assembly exports as one combined mesh with crisp per-face boundaries. Instance-coloured bakes and animated Set Position are still single-mesh. | Supported, with a caveat |
| Textures (Color Ramp gradient strips, projected UVs)Color Ramp texture mode is not carried - a texture needs an uploaded asset, and this target rebuilds geometry at runtime with none. The export falls back to the baked face/vertex-colour path and says so in the preflight warnings, so the palette LOOK survives; the per-pixel gradient does not. The documented-trade kind, like Neon. | Not supported |
| Keyframed animation | Supported |
| Live parameters after exportExpose a node (the ◉ header toggle - the same knobs the editor’s knob panel shows) and every runtime parameter on it becomes an Instance Attribute, re-read every frame. Live Rate and Lifetime clamp to the particle pool baked at export. Note the animation CLOCK is client-local: each client accumulates its own elapsed time from when its script started, so two players who loaded at different moments see the same shape at different points in the animation. Determinism covers inputs, not time - anything two players must agree on should be driven by an attribute the server writes. | Supported |
| Mesh particles / emittersThe closed-form emitter transpiles into a Luau update loop with seed parity, so the effect matches the editor frame for frame. | Supported |
| Fracture and shatter | Supported |
| Per-instance variationMap Range cannot yet drive a per-instance value on a LIVE Roblox chain - the export raises an actionable error rather than silently exporting uniform. Static bakes are unaffected. | Supported |
| Published values (computed numbers game code reads)A Publish Value node ships as a read-only model Attribute holding the number the graph computed at export - game code reads GetAttribute instead of re-measuring the asset. | Supported |
| Collision (a declared physics hull)A Collision Proxy node ships its hull as an invisible CanCollide MeshPart (Hull fidelity) - the only colliding part in the model, since render parts deliberately never collide on this target. Verified in Studio 2026-08-20: characters collide at the hull, pass through render-only geometry, and the collider follows model moves and Model_Scale. | Supported |
| Simulation (State / Input)State and Input are a simulation, not an animation: their value depends on which frames you visited, not on the frame number, so there is no frame N to bake and nothing to transpile. A graph using them does not export at all on this target - the frontier refuses it and names the simulation nodes. Simulation runs in the editor, which ships the engine itself. | Not supported |
Questions Roblox developers actually ask
- Do I need to be a scripter?
- No. The generated script drives the asset on its own. If you are a scripter, the Attributes are your API — set one from your own code and the asset responds.
- Is this a MeshPart I can move around?
- It is a model containing real parts, so yes — but the point is that it is more than that. A static mesh export exists too if that is all you need; the reason to use this target is the parts that keep moving after you place them.
- What about the triangle budget?
- The Decimation node dials a mesh down before you export, in the browser. Low-poly is the native idiom here rather than a compromise — flat-shaded geometry is what the whole node vocabulary is tuned for.
- Anything I have to switch on in Studio?
- One setting: Game Settings → Security → Allow Mesh & Image APIs. Without it, meshes render as a pink and blue checkered placeholder. The generated script says so in its header and errors with the same message.
- Are the parts server-side?
- No — the runtime is client-local, so server code cannot reach the generated parts directly. Drive them through Attributes on the model instead.
- Do I need an account?
- Trying the editor is free and needs no account. See pricing for what each plan exports.
Other engines
Roblox and Godot both have a full runtime mirror today — the same graph, transpiled into Luau and GDScript respectively. That is the hard part, and it is done twice: the engine analyses which parts of a graph can bake and which must run live, and a target only needs to supply its own translation of the live half. More engines get easier from here, not harder.
Everything else exports through standard glTF, which opens in Unity, Unreal, Blender, three.js and any DCC — as baked geometry, with the parameters left behind. Tell us which engine you want a live runtime for — that is how the order gets decided.