"Motion development environment" is a phrase that means nothing until you see the panels. This is a tour of what is actually in the Exode editor, what each surface is for, and how the pieces share one document. No feature dump — I will explain the reasoning behind the layout.
The premise: three roles, one canvas
Most toolchains assume three different people with three different files:
- A designer draws the screen.
- An animator makes it move.
- A developer makes it work.
The handoffs between those three are where time and fidelity die. An MDE's bet is that all three can work on one artefact because the artefact is structured enough to hold all three kinds of intent.
That is why the panels look the way they do. Each one is a different lens on the same scene graph.
The canvas
An infinite viewport with frames (artboards) for screens and components. It is vector-based, with a pen tool, a curvature pen, shapes, text, images, masks, gradients, effects and blend modes — the baseline you expect from any design tool.
What is different is underneath. Frames use flexbox and grid constraints, not absolute positioning with duplicated artboards per breakpoint. When you drag a card in a row, siblings reflow because the layout engine reflowed them, the same way a browser would. Breakpoints are properties of the layout, not copies of the frame.
That single decision is why exporting is possible at all. You cannot compile four hand-positioned artboards into one responsive component; you can compile layout rules.
The hierarchy panel
The layer tree: nesting, groups, lock, hide, and badges that tell you what a node is — text, shape, master bone, child bone, runtime text variable, dynamic data, trigger.
Those badges are doing quiet work. They are the editor's way of saying "this node is not just visual". A text node bound to a runtime variable will compile to a prop, not a string. A node with a trigger will compile to a callback. Seeing that in the tree is how you catch the mismatch between what you drew and what you meant.
The panel also holds the design system: components, variants, and the variables that feed logic — booleans, numbers, strings, colours.
The inspector
Transform, appearance, typography, corner radius, masks and constraints on one side; physics, interactions and animation properties on the other.
The physics block is the part designers do not have in a static tool, and it is where the mental model shifts. A rigidbody has a type (dynamic, static, kinematic), a mass, friction, restitution and damping. You are not setting "bounce: 20%". You are setting the properties of an object that will be simulated, and the bounce is a consequence.
The interaction block is the other shift: event listeners (click, hover, drag, pointer enter/leave) mapped to actions (play animation, set state, navigate, trigger webhook). This is the bridge between "a thing that looks alive in a prototype" and "a thing that does something in an app".
The timeline
Tracks, keyframes, a playhead, snapping, multiple animation layers that can blend, and an ease creator with linear, ease in/out, custom cubic Bézier and spring.
Two details worth calling out:
Record changes (Alt+R). Hit record and manipulate objects; the editor writes keyframes from what you did. It is the fastest way to capture a motion you can feel but cannot describe in numbers.
Trajectory tools. You can draw a motion path and bind an object to follow it, or use a circular trajectory, or apply a gestural spin. These are motion authoring tools, not timeline editors, and they are much closer to how an animator thinks than keyframing x/y.
Springs sit alongside curves in the same editor because they answer different questions. A curve says "be at this value at 300ms". A spring says "get there with this stiffness and damping, and let me interrupt you". For interaction, the second is usually right; for a choreographed sequence, the first is.
The logic surface
This is the panel that makes it an MDE rather than an animation tool.
States, transitions, typed inputs and listeners, plus a node graph for flow. A state machine can own application-level states (idle, validating, submitting, error, success) and drive multiple objects, not just one artwork.
You can also attach reusable behaviours and rules — min/max limits, alpha bounds — so an object cannot be dragged into an invalid state by a careless transition.
The important architectural choice: the logic is data, not embedded script. There is no JavaScript eval in the file. That is why it can run in a sandboxed WASM runtime, why it can be validated by a schema, and why an AI agent can safely edit it. It is also why some very custom logic has to live in your app instead — a trade I will take every time for a format that ships to eight platforms.
Tokens and the design system
Colour, type and spacing tokens live in the document and are exportable. Components have variants. The lint pass can fail a build on a hardcoded colour or a contrast violation, which turns "design system" from a sticker sheet into a gate.
This is a less glamorous panel and it is the one that decides whether the artefact survives a year.
Publish and export
Two exits:
-
Export a runtime bundle — a
.exodefile plus assets that plays in the embedded runtime. - Compile a component — React, Vue, Svelte, Solid, Angular, Swift, Kotlin, React Native, or a framework-agnostic web component.
Plus media: MP4, WebM, GIF for the cases where the output is a video, not an interface.
The same file feeds the canvas, the runtime and the codegen. That is the whole trick, and it only works because the layout, the logic and the motion are all modelled rather than baked.
What this layout is bad at
Honesty section.
The three-lens model is more cognitive load than a single drawing canvas. A brand designer who only wants to move a rectangle will find it heavier than Figma, because the inspector is asking questions they did not ask.
The logic panel assumes you are willing to think in states. If your team is not, it will sit unused, and then you have a more complicated drawing tool.
And it is a young product. The vector tooling is good, not Figma-deep. The plugin ecosystem is early. If you need both of those today, use the mature tool and keep an eye on this category.
The one-sentence version
An MDE is what you get when you stop treating motion as something applied to a design after the fact, and start treating layout, logic and movement as three views of the same structured document.
Priya works on the editor at Exode. You can open the canvas without installing anything at exodeui.com — the free tier covers a real project.
Top comments (0)