Recording live input

Perform a knob, fader or controller and the moves bake onto a parameter as keyframes, ready to refine by hand.

Performing a value is often faster than authoring it. Grab a MIDI knob, or an OSC message, or a phone, press play, and twist. The live values are sampled and turned into a real keyframe curve you can clean up afterwards.

How it works

Recording happens through the Recorder node. Set it to write keyframes, point it at a target parameter, feed it the live value, and open its gate.

  1. Connect a live input. MIDI, OSC, a gamepad or a network message can all drive the recording. See Live performance for getting devices talking.

  2. Set output_mode to Keyframe. The keyframe controls appear.

  3. Pick the destination with target_node and target_param, a node's radius or a colour's brightness for example. Both are dropdowns listing what is in the graph.

  4. Wire the live value into value.

  5. Open the gate and play. Incoming values are sampled and written as keyframes on that parameter, sitting on the timeline like any hand-drawn animation.

There is no arm button. trigger_mode decides what opens the gate: Input records while the trigger input is above 0.5, which is what a button or a MIDI pad feeds it; Playing records for as long as the timeline is running; Always records every frame. Input is the default, and trigger only appears in that mode.

mode decides what happens to keyframes already there. Replace overwrites the range you record over, Overdub adds to what exists, and Punch fills only the gaps.

Do a couple of practice passes before committing. Because the result is plain keyframes, re-recording lays down a fresh take you can compare or discard. clear empties the buffer.

Keeping the curve clean

A live performance produces a lot of samples, potentially one per frame. The Recorder thins those into a smooth, editable curve rather than a dense wall of points.

sampling sets what gets captured in the first place. Adaptive, the default, skips frames where the value has not moved by more than threshold. Every Frame takes the lot, and Fixed Interval takes one every sample_interval frames.

reduce then simplifies the finished take, and is on by default. reduce_tolerance sets the trade: a higher tolerance removes more keyframes, a lower one keeps more detail. That is the difference between a handful of editable keys and an exact but unwieldy trace.

handle_type tags newly baked keyframes, with Auto Clamped the default and Auto and Linear the alternatives. It is a tag rather than a shape: the take is written with no handle offsets, which reads as an ease at both ends of every segment whichever you pick, and the tag only takes effect once something re-keys that parameter. Shape the take by hand in the curve editor if that feel is wrong for the move.

Baking a driven parameter instead

source is a second axis. Realtime, the default, is the live capture above. Offline does not listen to a performance at all: it samples the target parameter's fully resolved value over start_frame to end_frame, writes that as keyframes, then detaches whatever was driving it. Use it to freeze an expression or a live binding into editable animation. The bake trigger runs it, and appears only in this mode.

Refining after the take

The baked keyframes are ordinary keyframes. Open the curve editor to reshape the motion, drag handles, or delete an overshoot you did not mean. Nudge timing on the timeline. Re-record a section and blend it with what you already have.

Recording bakes a performance into keyframes. For a parameter that follows a controller live every time the project runs, with no baking, use a live binding instead. See Live performance.

Recorded, live and expressions

A parameter takes its value from a few sources, in order: an expression, a wired connection, keyframes, then its typed value. Recording writes into the keyframe layer, so a recorded take behaves exactly like animation drawn by hand.

That layer is third, so both an expression such as = sin($T * 2) and a wire into the same parameter will hide the take. Clear whichever is above it before recording if the performance is meant to show. Use an expression for procedural, maths-driven motion; record the feel you perform.

See also