Expression Alchemist: Nodes for AE Expressions

Expression Alchemist is a visual expression-building extension for Adobe After Effects, developed by Guilherme Ferraz. It lets motion designers assemble procedural animation, rigging and mathematical relationships from connected nodes, then compiles the result into native After Effects JavaScript expressions. The point is to make the logic visible without replacing the expression system that already runs the animation.

A great many After Effects rigs begin with a small, innocent-looking expression. A wiggle here, a JavaScript calculation there, and suddenly an artist is debugging brackets while the client asks whether the bounce could feel “a little more premium.” Expression Alchemist gives that work a node graph. Connect the operations, inspect what they do, and send the resulting expression back to the After Effects property. No new animation religion required.

The graph does the talking

The extension offers more than 100 mathematical, vector, procedural and physics-oriented nodes, alongside 30 ready-made graphs called Arcane Spells. A Distance node can measure proximity, a Range Mapper converts that measurement into another interval, and the result can drive rotation, opacity or scale. Oscillators, noise, time inputs, springs and inertial bounce nodes provide more ingredients. This is procedural animation built from familiar relationships, with the wires making the dependencies visible instead of hiding them in a narrow text field.

For a single wiggle(3,50), typing may still win. The advantage appears when several calculations work together, such as proximity-driven movement combined with time offsets and damping. You can adjust parameters, inspect curves and reuse the graph rather than reverse-engineering last month’s “temporary” expression. We all know how permanent those become.

Proper After Effects expressions, not a new runtime

The interesting engineering choice is also the reassuring one. Expression Alchemist uses an Abstract Syntax Tree (AST) compiler to produce native JavaScript for After Effects properties. The node editor is the authoring tool; the resulting expression is evaluated by the host application’s own modern JavaScript expression engine. A colleague receiving the project does not need the node editor merely to evaluate those generated expressions, although ordinary project assets and dependencies still matter. That makes the extension much easier to place within an established After Effects workflow.

Its type-aware connections can reject incompatible values and detect circular dependencies while a graph is assembled. That is useful structural protection, not a guarantee that the mathematics makes artistic sense. The developer also describes compiler optimisation, but comparative expression-evaluation benchmarks are not available here. Compiling a graph is one task; evaluating its expression on every frame remains After Effects’ job.

Sliders, previews and practical handoffs

The system can expose graph inputs as native Effect Control sliders, giving another artist sensible parameters such as amplitude, frequency or decay without asking them to explore the network. Graphs can be saved as presets and exported as JSON to preserve their editable structure. A separate JSX export provides a script-based route for distributing setups, while Bake to Keyframes converts procedural results into sampled keyframes when that is preferable for handoff or a locked animation.

The preview panel plots numerical values, vectors, oscillations and motion curves directly in the editor. It cannot fully impersonate After Effects: composition-dependent calls, paths, masks and footage still need the application’s context. This is a mathematical preview, not a miniature render engine wearing a fake moustache. Baking also changes the nature of a rig, trading live procedural relationships for sampled animation; whether that improves performance depends on the project.

AI is a side entrance, not the building

Yes, there is an AI-friendly feature. The Custom Code node can accept mathematical JavaScript written elsewhere, including code from an LLM. The developer describes extracting simple numeric variables into node inputs and promoting them to sliders. That’s a handy bridge for an expression you would rather inspect and control than paste blindly. It is not what powers the ordinary node graph, and it does not turn an LLM into the animation engine.

The main workflow remains deterministic visual scripting: established After Effects expressions, familiar property relationships and editable parameters. The AI import is optional. If a language model supplies dubious spring physics, the node interface may make the mistake easier to spot, but it cannot grant the equation a degree in mechanics.

Where iExpressions and Automation Blocks fit

mamoworld’s iExpressions approaches the expression problem with a library of prepared behaviours, from spring systems and layer placement to linking and audio-responsive animation. That is convenient when an existing recipe does the job. Expression Alchemist instead invites you to build the recipe from smaller operations, useful when the relationship is specific to a project.

Automation Blocks works at a different level: visually composed automation for tasks involving layers, compositions, properties and project operations in After Effects and Premiere Pro. As Digital Production’s earlier Automation Blocks coverage explains, its role includes project setup and repeated editing operations. An expression continuously calculates a property’s value; a script can manipulate the project that contains that property. They’re neighbours, not substitutes, and no direct integration between these tools has been established.

Compatibility, cost and the small print

The developer lists After Effects 2021 through 2026, Windows 10/11 and macOS 11 or later on Intel and Apple Silicon. Installation uses a ZXP extension package, and generated code targets the modern JavaScript expression engine rather than Legacy ExtendScript. The release is offered as free or pay-what-you-want through Gumroad, with the full feature set and no paid Pro tier or subscription.

A rather nice idea

What makes Expression Alchemist appealing is its respect for the system already in place. It is a visual workbench for motion graphics and rigging, with the actual animation logic handed back to After Effects. Experienced expression writers may be quicker in text for simple jobs. For complicated, reusable animation rigs, seeing the relationships, promoting controls and keeping the final output native is a genuinely useful proposition. We have not independently tested long-term stability or comparative performance, but this is a tool worth exploring for its engineering rather than for an AI label pasted on the box.