Skip to content
RESONON

Rendering

Live coding is the heart of Resonon, but eventually you’ll want to capture a loop as a file — to drop into a DAW, hand to a collaborator, or release. Rendering bounces your patterns to stereo WAV offline: Resonon runs the audio graph as fast as your CPU allows rather than in real time, so a few cycles render in a fraction of their playback length.

Here’s a complete house beat bounced to disk:

use "std/instruments" { Sampler, Kit };
use "std/effects" { Lowpass, Delay, Highpass };


project_title("House Beat");
project_artist("RESONON");


let kicks = AudioTrack("kicks");
kicks.load_instrument(Sampler(Kit("CR-78")));
kicks << [bd*4];
kicks.load_effect(Lowpass(600));


let snares = AudioTrack("snares");
snares.load_instrument(Sampler(Kit("CR-78")));
snares << [_ cp].fast(2);
snares.load_effect(Delay(0.2, 0.3));


let hats = AudioTrack("hats");
hats.load_instrument(Sampler(Kit("CR-78")));
hats << [_ hh].fast(4);
hats.load_effect(Highpass(3000));


render(#[kicks, snares, hats, master], 4);

The last line renders four cycles of each track and the combined master mix, writing one WAV per stem plus a full mixdown. Everything else is the ordinary track setup you’ve already seen — rendering captures your session exactly as it sounds.

Project Metadata

Section titled “Project Metadata”

Set a title (and optionally an artist) before you render. The title decides the output folder name; if you don’t set one, renders land under untitled.

project_title("House Beat");
project_artist("RESONON");

What to Render

Section titled “What to Render”

render() is flexible about what it bounces. Pass a cycle count alone for the master mix, a single track, or a list (#[...]) to get separate stems:

CallOutput
render(cycles)Master mix
render(track, cycles)A single track
render(#[tracks], cycles)Each listed track as its own WAV
render(#[tracks, master], cycles)Each track plus the master mixdown
render_master(cycles)Master mix (a shorthand for render(cycles))
use "std/instruments" { Sampler, Kit };
let drums = AudioTrack("drums");
drums.load_instrument(Sampler(Kit("CR-78")));
drums << [bd*4];


render(4);                       // master mix, 4 cycles
render(drums, 4);                // just the drums track
render(#[drums], 4);             // each listed track as its own file
render(#[drums, master], 4);     // stems + master mixdown
render_master(4);                // master mix shorthand

Stems and a master in one call is the usual move — you get mixable parts and a reference mix together.

Where Files Land

Section titled “Where Files Land”

Renders are written under a timestamped folder named after your project, so repeated renders never overwrite each other:

renders/{project}/{project}_{YYYY-MM-DD_HH-MM-SS}/
  kicks.wav
  snares.wav
  hats.wav
  master.wav

The folder name is derived from project_title(): lowercased, with spaces and special characters collapsed into underscores and the result capped at 50 characters. "Track #1 (Final)" becomes track_1_final; an empty or all-symbols title falls back to untitled.

The files themselves are always 24-bit, 48 kHz stereo PCM WAV — fixed defaults, no configuration needed.

What Happens During a Render

Section titled “What Happens During a Render”

Because rendering is offline, a few things differ from live playback:

  • It runs at full speed, not locked to real time, so it finishes as quickly as your machine can manage.
  • Live output pauses while the render runs and resumes automatically when it’s done — you won’t hear the bounce.
  • A progress bar shows the current cycle, the total, and an ETA.

Next Steps

Section titled “Next Steps”

You can now produce finished audio. Go deeper by building your own sound, or send your notes to other software and hardware.