Documentation
Node Reference & User Guide
Getting Started
grafer is a visual node graph for algorithmic composition. You build musical structures by placing nodes on a canvas, connecting their ports, and letting data flow from source to output. Every connection carries typed musical data — pitches, rhythms, curves, dynamics — and updates in real time as you change parameters.
The Canvas
The canvas is your workspace. Right-click or use the node palette to add nodes. Drag from an output port to an input port to create a connection. Pan by dragging empty space; zoom with the scroll wheel. Nodes can be freely repositioned, grouped, and labeled. Every change triggers an immediate recalculation of downstream nodes so you always hear and see the current state of your composition.
Port Types
Each node has typed input and output ports. The main types you will encounter are:
| Type | Description |
|---|---|
| midicents | Pitch values in midicents (integer, 100 per semitone). 6000 = middle C (C4), 6100 = C#4, 7200 = C5. |
| rhythm-tree | Nested proportional rhythm structure. A tree of lists where each sub-list divides its parent beat proportionally. |
| bpf | Break-point function — a piecewise-linear curve defined by (x, y) coordinate pairs. Used for envelopes, contours, and control signals. |
| chord | A vertical sonority: a list of midicents values with an associated velocity. |
| voice | A complete musical line combining a rhythm-tree with a sequence of chords. This is what gets exported to MusicXML. |
| number | A single numeric value (integer or float). |
| list | An ordered sequence of numbers or pitch-classes. |
| pc-set | A pitch-class set — integers 0–11 representing the twelve chromatic pitch classes. |
| velocity | Dynamic values in MIDI velocity range (0–127). |
| articulation | A named articulation marking (staccato, tenuto, accent, etc.). |
Basic Workflow
A typical composition chain flows left to right through three stages:
Source nodes generate raw material — pitch collections, rhythmic structures, harmonic series, stochastic sequences. Transform nodes modify that material — transposing, inverting, filtering, quantizing, morphing. The Voice node combines a rhythm-tree with a sequence of chords to produce a playable musical line. The output can be previewed with MIDI playback or exported as MusicXML for notation in Dorico, Sibelius, Finale, or MuseScore.
Understanding Midicents
Midicents are the pitch representation used throughout grafer, inherited from the IRCAM tradition. One midicent equals one hundredth of a MIDI semitone. This gives you cent-level microtonal precision while staying compatible with MIDI note numbers (multiply by 100).
| Midicents | Note | Explanation |
|---|---|---|
| 6000 | C4 (middle C) | MIDI note 60 × 100 |
| 6050 | C4 + quarter-tone | 50 midicents = 50 cents above C4 |
| 6100 | C#4 / Db4 | One semitone above C4 |
| 6900 | A4 (440 Hz) | MIDI note 69 × 100 |
| 7200 | C5 | One octave above middle C |
| 4800 | C3 | One octave below middle C |
Quick reference: each semitone is 100 midicents. Each octave is 1200. A quarter-tone is 50. To convert a MIDI note number to midicents, multiply by 100.
Preplan Tools
Preplan is a three-tool sketchpad for everything that happens before you place cells in the score. Idea boards capture concepts as free-form visual notes, polymetric loops lay down the rhythmic architecture, and harmonic progressions sketch pitch content as a sequence of scale circles. Each tool stands on its own, and every one can send its output into the Compose view when the sketch feels right.
Open Preplan with the P tab in the top navigation, or press 1 on the keyboard. The left sidebar is split into three collapsible sections — Idea boards, Polymetric loops, Harmonic progressions — stacked in the order most composers reach for them.
Idea Boards — Visual Sketchpad
Idea boards are visual-only scratchpads. Drop nodes onto a canvas, give each a title, colour and short description, and draw arrows between them to map how the ideas relate. Nothing is executed — an idea board is pure thinking-in-public. A project can hold any number of boards, each independently named and saved.
Adding a node. Click + Idea in the floating toolbar. A new card appears on the canvas with an editable title, a colour swatch, and a multi-line description area.
Changing colour. Click the round swatch in the coloured header. A palette popover appears — pick any of the six shared grafer colours (ochre, teal, lavender, sage, rose, golden).
Connecting nodes. Every node has four ports (top, right, bottom, left), each acting as both source and target. Drag from one port onto another node to draw a bezier arrow. Connections are forgiving — the grab radius is generous, so you don't have to land precisely on a port. Click an arrow to cycle its direction: forward →, reverse ←, both ↔. Hover an arrow to reveal a × button at its midpoint for deletion.
Multiple boards. Add more boards from the left sidebar's + New idea board button. Rename by double-clicking, duplicate or delete via the row icons. Boards persist with the project file.
Idea Boards — Drawing Pad & Handwriting Recognition
Each idea node has a pen icon in its header. Click it to open the drawing pad — a pressure-aware canvas that accepts pen, touch or mouse. Pen pressure drives stroke width. The pad supports undo, clear, and close-to-save; strokes persist on the node across project save / load.
Recognize handwriting. Click Recognize to run the strokes through an open-source TrOCR model (Xenova/trocr-small-handwritten) hosted by the Hugging Face CDN. The first call downloads ~80 MB of model weights; subsequent calls are instant because the browser caches them. Recognised text is appended to the node's description field. Best results come from writing one line at a time in reasonably clean print.
Polymetric loops — rhythmic architecture. Each track carries its own meter sequence and loops independently at a shared base tempo. The proportional timeline shows exactly how downbeats across the tracks align in absolute time. Send a sketch to Compose as a new movement where each track becomes a moment carrying a meter.sequence node.
Core Concepts
Preplan uses a small vocabulary. Everything derives from two numbers — the base tempo and the beat unit — and the meter sequences you assign to each track.
| Term | Meaning |
|---|---|
| Base tempo | Shared tempo across all tracks, in beats per minute. This anchors every track to a common pulse. |
| Beat unit | The note value that receives the tempo beat (♩=2, ♩=4, ♩=8, ♩=16). Determines how absolute bar durations are calculated from the time signature. |
| Window | The total length of the sketch in seconds. Tracks loop until they fill this window. |
| Track | One independent metric lane. A track has a name, a color, and an ordered list of segments. Tracks loop side by side under the shared base tempo. |
| Segment | One block inside a track: count bars of num/den. Written 4x5/8 — four bars of 5/8. A track is a comma-separated sequence of segments. |
| Loop period | The time it takes to play all of a track's segments once. Shown next to the track name (e.g. 0:39.23) together with how many times that loop fits inside the window. |
| Coincidence | A downbeat where two or more tracks land within 15 ms of each other. Marked with a bright filled dot on the timeline — these are the rhythmic "breath" points across layers. |
| Composite click | The merged set of every track's downbeats into a single lane at the bottom. Useful for imagining a shared click track that respects every layer. |
Building a Sketch
1. Set the global controls. At the top of the page, set your base tempo in bpm, select a beat unit, and set the window length in seconds. A typical starting point is ♩ = 52, ♩=4, 60 sec.
2. Work on the tracks. The left sidebar lists your tracks. Click + add track to create a new layer. Each track is given a distinct color from the Preplan palette (ochre, teal, lavender, sage, rose, golden) and an auto-generated name like "Voice A". Rename a track by clicking into its name field.
3. Author segments. Inside each track, each card represents one segment with three fields: count × num / den. Change numbers directly, or pick the denominator from the dropdown (1, 2, 4, 8, 16, 32). Reorder segments with the up/down arrows, remove with the trash button, and add more with + add segment. The readout below the card shows the bar duration in milliseconds and the segment's cumulative contribution to the loop.
4. Read the timeline. The right pane shows every track as a horizontal lane. Downbeat ticks appear in the track's color; loop boundaries are tall ticks labeled with their time signature (e.g. 5/8). Hover over any tick to see a readout below: track name, bar number, time signature, absolute start time, and bar duration in milliseconds.
5. Inspect the loop periods. Scroll down below the timeline to see a card for each track listing its period length and how many times the loop fits in the window. This is where you diagnose whether your layers settle into a long common cycle or drift continuously.
Reading the Timeline
The proportional timeline is the heart of Preplan. Every visual element carries meaning:
| Mark | Meaning |
|---|---|
| Thin colored tick | Downbeat of a regular bar in that track. |
| Tall tick with label | Start of a loop iteration for that track; the label (e.g. 7/8) shows the time signature of the upcoming bar. |
| Bright dot at the bottom of a lane | Coincidence — another track has a downbeat within 15 ms. |
| Ticks in the click lane | Every downbeat from every track, merged. Coincidences appear brighter and taller. |
| Time ruler at the bottom | Absolute time in minutes:seconds. Spacing is proportional to real time, not to bar count. |
The readout row under the timeline reports either a live inspection of the hovered tick (track, bar number, time signature, absolute time, bar length in ms, loop number) or a summary (total composite clicks and total coincidences in the window).
Export and Send
The action bar along the top of the controls row offers five ways to capture a sketch:
| Action | Result |
|---|---|
| send to Compose | Creates a new movement in the current score named Polymetric Sketch N. Each track becomes a moment containing one cell, colored to match its track and pre-populated with a meter.sequence node carrying the segment string. The app then switches to the Compose view so you can see the result. |
| copy TSV | Copies a tab-separated table of every bar (track, bar number, time signature, beat duration in ms, bar duration in ms, absolute start time, loop number) to the clipboard. Paste into Excel, a sketchbook, or any text editor. |
| XML linear | Downloads a MusicXML file with all tracks concatenated end-to-end in a single part. Each track section is introduced by a rehearsal mark. Good for reviewing one voice at a time in Dorico, Sibelius, Finale or MuseScore. |
| XML score | Downloads a MusicXML file with one part per track, simultaneously. Barlines from every track are merged into a common grid and coincidences are marked with a filled dot. This is the score as a performer would read the polymetric alignment. |
| print A3 | Opens the browser print dialog with an A3 landscape worksheet: all tracks on a proportional timeline, followed by three empty staves per track aligned to the timeline above. Useful for pencil-and-paper sketching with exact barlines already drawn. |
Send to Compose is the usual bridge between sketching and composition. Once the sketch is in the score, open any cell in the Graph view and wire the meter.sequence output into whatever rhythm and pitch chain you want — the metric skeleton is already there.
Example 1 — 3 against 4 (classical polyrhythm)
The simplest polymetric pattern. Voice A plays twelve bars of 3/4; Voice B plays twelve bars of 4/4 at the same tempo. Voice A's loop completes in 36 quarter-note beats; Voice B's loop completes in 48. The two lines realign every 144 beats (the LCM).
In the timeline you will see Voice A's downbeats land three-for-every-four of Voice B's. Coincidences appear at every bar of Voice B that also happens to be a bar of Voice A — which, for this combination, is every fourth bar of A and every third bar of B. Set the window to 60 seconds and watch the coincidence density thin out as the layers drift.
This is a useful warm-up sketch: it tells you how long a full polyrhythmic cycle actually takes before you commit to any pitches.
Example 2 — Asymmetric loops (7/8 against 5/8)
Two tracks with complementary irrational meters. Voice A's loop is 35 eighth-notes long; Voice B's loop is also 35 eighth-notes long — so the two layers realign exactly at each full loop. Between realignments they drift through an evolving sequence of offsets.
Set the beat unit to ♩=8 so the eighth-note gets the tempo beat. You should see a coincidence at every loop boundary plus a few internal ones where the 7-grouping and 5-grouping briefly line up. This is the engine behind a lot of Balkan-tinged and post-minimal writing.
To make it breathe, add a third track with an unrelated length — try Voice C: 3x11/8. The three-way realignment cycle is now much longer, and the coincidence map becomes a compositional feature in itself.
Example 3 — Layered meters (Ligeti style)
This is the default sketch that loads with Preplan. Each track is itself a meter sequence — not a single repeating bar but a through-composed cycle that restarts after all segments have played. The two voices have different total durations so they gradually shift against each other every time one loop completes before the other.
Look at the loop-start markers (tall ticks with time signatures) — you will see Voice A announce 4/4, then 7/8 four bars in, then 5/8 seven bars in, then restart with 4/4. Voice B does the same with its own segment sequence. The two tracks slide in and out of alignment across the whole window.
This is the architecture Ligeti used in San Francisco Polyphony and the first book of Pétudes — independent metric lines that share a pulse but never settle into a common bar. Use send to Compose to turn the sketch into a movement, then develop each voice's pitch content independently in the Graph view.
Example 4 — Accelerating density (segment ramp)
A single-track sketch used to plan an accelerating surface. The base pulse stays the same (♩=60) but the bar length shrinks progressively: four bars of 4/4, then four of 3/4, then 2/4, then 1/4. Downbeat density doubles by the end of the loop.
Use the readout to see bar durations drop from 4000 ms (4/4) to 1000 ms (1/4). This is a compositional strategy for notating a gradual acceleration as a meter ramp instead of a tempo change — players count the same beat throughout, but the music gets denser because bars arrive more frequently.
Mirror the ramp on a second track with the reverse sequence (4x1/4, 4x2/4, 4x3/4, 4x4/4) to create a converging-then-diverging density pattern across two voices — a useful texture for duo passages.
Example 5 — Long coincidence cycle (minimalist pulse)
A minimalist-style pair where both tracks reuse the pair of numbers {7, 11} but in swapped positions. Voice A's loop is 7 × 11 = 77 eighth-notes; Voice B's loop is 11 × 7 = 77 eighth-notes. They realign every 77 eighths — roughly every 24 seconds at this tempo — but the barline patterns inside that cycle are completely different.
The coincidence dots at the bottom of the timeline will be sparse in the middle of each cycle and clustered at the loop boundaries. This is the effect Reich and Adams exploit when two lines share an overall period but differ in their internal bar groupings.
Once the sketch feels right, send to Compose. Add a third voice in a related meter (say Voice C: 5x7/8, 5x11/8) to introduce a drifting contramotion on top of the realigning pair.
Harmonic progressions — pitch content over time as a sequence of scale circles. Each circle is a set of selected pitch steps inside a chosen EDO, visualised as a polygon inscribed in a pitch-class ring. Progress through circles, analyse their dissonance and spectral content, play them back, then send the whole sequence to Compose — optionally paired with a polymetric sketch to produce a time-and-pitch grid.
Harmonic Progressions — Core Concepts
A progression holds one EDO setting and a sequence of circles. Each circle is a selection of pitch steps drawn from that EDO. Steps run from 0 (the tonic) to edo−1, placed clockwise around the perimeter starting at 12 o'clock.
| Term | Meaning |
|---|---|
| EDO | Equal divisions of the octave. Supported values: 12, 19, 24, 31, 48, 72. Twelve is the default; higher EDOs unlock microtonal palettes. |
| Circle | One harmonic state. A named set of selected steps, visualised as dots on the ring and connected into a polygon in numerical order. |
| Rotation | Transpose the whole pattern by ±1 step using the rotate left / right buttons under each circle. Rotation wraps modulo the EDO so the shape is preserved. |
| Sequence | The left-to-right ordering of circles in a progression. Reorder by dragging in the left sidebar; playback walks through them in this order. |
Harmonic Progressions — Editing a Circle
1. Pick the EDO. Use the EDO dropdown in the header. Switching away from a higher EDO drops steps that no longer exist (e.g. going from 31 → 12 keeps only steps 0–11).
2. Toggle steps. Tap any dot on the ring to select / deselect it. Hit targets are generous (14 px) — pen and finger friendly. Selected dots fill in with the progression's accent colour; the polygon between them redraws automatically.
3. Rotate. The two circular arrow buttons below the circle rotate the pattern by −1 / +1 step. Great for auditioning modal rotations of the same shape.
4. Name, duplicate, delete. The text field below the circle is the circle's name (used in playback and when sent to Compose). Hover the card to reveal duplicate and delete icons.
5. Add more circles. The + Add circle placeholder at the right of the strip inserts a new empty circle at the end of the sequence.
Harmonic Progressions — Analysis Panels
Each circle card stacks four live analysis views underneath. Together they give you a read on tension, pitch-class content, interval distribution, and spectral fingerprint — all updated as you toggle steps.
| Panel | What it shows |
|---|---|
| Dissonance meter | A 0–1 scalar using the Plomp–Levelt / Sethares sensory-dissonance model applied pairwise across selected pitches. 0 ≈ single pitch; 1 ≈ dense chromatic cluster. EDO-independent — tuning is baked into the frequency calculation. |
| Interval vector | A classical interval-class vector: for each IC from 1 to ⌊EDO/2⌋, the number of pairs in the set at that interval. Shown as a bar chart with the raw array [n1, n2, …] printed alongside. |
| Spectral strip | Horizontal band of EDO cells colour-coded by pitch class (rainbow hue around the octave). Selected cells light up; unselected are dim. Reads at a glance as the chord's pitch-class content. |
| Tension map | Per-interval-class heat strip where each cell's intensity is the interval's count × its individual dissonance contribution. Shows where the tension lives — seconds-heavy chords light the left, fifth-heavy chords the right. |
| Spectral heatmap | Canvas-rendered frequency-domain view (30 Hz–5 kHz, log scale) matching the Graf analysis panel. Each selected step is mapped to a microtonal MIDI pitch and six partials per pitch are drawn as gold bands. Stretches to fill the remaining height of the card. |
Harmonic Progressions — Playback
Click Play in the header to hear each circle as a block chord. Circles play in sequence, holding for the duration you set in the Sec field (defaults to 2.0 seconds). The currently sounding circle gets a glowing border so you always see which one is active.
| Output | Behaviour |
|---|---|
| Synth | Browser Web Audio — triangle-wave voicing with a short envelope. Supports fractional MIDI, so microtonal EDOs (19, 24, 31…) play accurately. No setup required. |
| MIDI | Sends block-chord note-on / note-off messages to whichever MIDI output you've configured elsewhere in the app. MIDI is semitone-quantised, so non-12-EDO progressions are rounded — a warning strip appears under the header when that happens. |
Stop returns to the start. Switching progressions or leaving the view stops playback automatically.
Harmonic Progressions — Send to Compose
Two handoffs live in the progression header — one for pure harmonic content, and one that combines the active polymetric sketch with the active progression into a single score movement.
| Button | Result |
|---|---|
| Send to Compose | Creates a new movement named after the progression. One moment per circle, each containing one cell whose graph holds a pre-populated om.pitch-field node with the circle's pitches converted to midicents (anchored at C4, stepped by 1200 ÷ EDO). |
| Send × {sketch} | Combined send. Enabled when a polymetric sketch is active; shows its name inline. Creates an N×M grid — one moment per circle, one cell per polymetric track within each moment. Each cell carries both a meter.sequence node (the track's segment at that moment index) and an om.pitch-field node (the circle's pitches). Trailing moments reuse the track's final segment when the polymetric is shorter than the progression. |
Both actions flash a Sent confirmation and auto-navigate to the Compose view, so you can immediately see the new movement on the timeline and open cells in Graf to wire up rhythm and voice chains.
Node Reference
All 90+ composition nodes organized by category. Click a category to expand the full reference with inputs, outputs, and algorithm descriptions.
Pitch — 26 nodes
Nodes for generating, transforming, and organizing pitch material — from simple transposition to Boulez-style pitch multiplication and Ferneyhough gestural ornaments.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Transpose | midicents pitches number interval (default: 0) |
midicents | Shifts every pitch by a fixed interval in midicents. Use 100 for a semitone, 1200 for an octave, or any value for microtonal transposition. |
| Invert | midicents pitches number pivot (default: 6000) |
midicents | Mirrors pitches around a pivot point. Each pitch is reflected so that its distance above the pivot becomes the same distance below, and vice versa. Classic twelve-tone inversion when the pivot is the axis of the row. |
| Pitch Field | midicents pitches text label (default: "") |
midicents | Creates a named, reusable pitch collection. Use it to define a harmonic field, a scale, or any fixed set of pitches that you reference from multiple places in your graph. |
| Spectral Field | number fundamental (Hz, default: 131) number num-partials (default: 16) number deviation (cents, default: 0) |
midicents | Generates a pitch collection from the harmonic series of a given fundamental. Computes N partials (fundamental × 1, 2, 3, ..., N), converts each frequency to midicents, and optionally adds random deviation in cents for spectral “blur.” |
| PC Set | list pitch-classes (0–11) | pc-set | Defines a pitch-class set — an unordered collection of pitch classes from 0 (C) to 11 (B). The foundation for set-theory operations: you can compute the normal form, prime form, interval vector, or Forte number from any PC set. |
| Tone Row | list row (12 pitch-classes) | pc-set P (prime) pc-set R (retrograde) pc-set I (inversion) pc-set RI (retrograde-inversion) |
Defines a twelve-tone serial row and automatically derives all four canonical forms: Prime, Retrograde, Inversion, and Retrograde-Inversion. Each output can be fed into Transpose or PC Transpose for further manipulation. |
| Interval Expand | midicents pitches number factor (default: 1.0) number anchor-index (default: 0) |
midicents | Scales all intervals by a multiplicative factor relative to an anchor pitch. Factor > 1 expands intervals (wider); factor < 1 contracts them (narrower). A factor of 2 doubles every interval from the anchor; 0.5 halves them. |
| PC Transpose | pc-set set number interval (0–11, default: 0) |
pc-set | Transposes a pitch-class set in the mod-12 domain. Each pitch class has the interval added modulo 12. Equivalent to T_n in pitch-class set theory. |
| PC Multiply | pc-set set number multiplier (default: 5) |
pc-set | Multiplies each pitch class by a constant modulo 12. M5 (multiply by 5) maps the circle of semitones to the circle of fourths; M7 maps it to the circle of fifths. These are the two non-trivial multiplicative operations in mod-12 pitch-class space. |
| Pitch List | midicents pitches (manual entry) | midicents | A static, manually entered sequence of pitches in midicents. Use this as a simple source node when you want to specify exact pitches rather than generate them algorithmically. |
| Pitch Multiply | pc-set set-A pc-set set-B |
midicents | Boulez-style pitch multiplication: each pitch of Set A is transposed by every interval derived from Set B. The result is the union of all transpositions — a larger pitch field that preserves the intervallic DNA of both source sets. A cornerstone technique in post-serial composition. |
| Grace Notes | midicents main-pitches number density (1–8, default: 3) number range (midicents, default: 400) number mode (0=chromatic, 1=spectral, default: 0) |
midicents (with grace-note flags) | Generates Ferneyhough-style gestural ornament clouds around main pitches. Each main pitch receives a cluster of grace notes drawn from a chromatic or spectral field within the specified range. Density controls how many grace notes surround each main pitch, creating proliferating ornamental gestures. |
| Tension | midicents pitches (default: C major triad) | number score number max number category (1–4) string label list tension-by-IC list IC-vector |
Persichetti Ch 1 interval-tension classifier. Takes a chord, emits an overall 0–5 tension score plus the four-category chord bucket (I soft / II neutral / III tense / IV strident) and a per-interval-class tension histogram. The rich editor is a live teaching view: toggle notes on a keyboard and watch the tension dial, category badge and IC breakdown update. The score output wires cleanly into BPF-style density automation so your chord's tension can drive dynamics. |
| Counter-line | midicents cantus number species (1–5) list scale (PC set) number tonic (mc) number position (above/below) number dissonance (0–1) number contrary (0–1) number seed |
midicents counter rhythm-tree rhythm number ratio list intervals number violations |
Seeded, mode-aware species 1–5 counterpoint generator. Species 1 = 1:1 (note vs note); 2 = 2:1; 3 = 4:1; 4 = suspensions (tied + step-down resolve); 5 = florid (mixed density per bar). The dissonance dial pushes the output from strict Fux (0) through modal CP (≈0.3) to Hindemith/Messiaen/dissonant CP (0.7+). Works with any PC scale — major, dorian, octatonic, Messiaen modes, hand-built sets. Editor has 11 scale presets and 6 style presets (Fux strict, Palestrina, Hindemith, Messiaen 2, Dissonant, Suspensions). |
| CP Check | midicents upper midicents lower list scale (optional) number tonic |
number score (0–1) string label number violations (total) list breakdown (8 categories) list intervals list tension list motions number pairs |
Two-voice counterpoint analyser. Walks the pair-aligned voices and emits counts for parallel 5ths, parallel 8ves, voice-crossings, unresolved strong-beat dissonances, hidden (exposed) perfects, oversized leaps, tritones, and out-of-scale notes. The 0–1 score grades Fux-strict to modernist. The tension output is a per-pair 0–5 curve — wire it to a BPF and your dynamics will breathe with your voice-leading density. |
| Imitation | midicents source number transform (P/I/R/RI) number interval (semitones) number pivot (mc) number delay (steps) list scale (optional) number tonic |
midicents dux midicents comes rhythm-tree rhythmDux rhythm-tree rhythmComes number overlap list intervals string label |
Canon / imitation at any interval + delay. One primitive covers Bach fugue answer (P at P5 delay 2), Palestrina imitation (P with tonal scale snap), 20th-c inversion canon (I at any interval), Webern-style RI, Bartók tritone canon. Rhythm trees have the delay baked in as leading/trailing rests so wiring dux+rhythmDux and comes+rhythmComes into two Voice nodes produces a playable canon directly. 9 canon presets: Bach 5th, Bach 8ve, Unison, Inv. unison, Inv. 5th, Crab, Webern RI, Bartók TT, Tonal oct. |
| Double CP | midicents upper midicents lower number interval (semitones of swap) number mode (raise lower / drop upper / split) |
midicents newUpper midicents newLower list origIntervals list newIntervals number flagged count number score string label |
Double (invertible) counterpoint: swap two voices at any interval so upper/lower exchange registers. At the 8ve (N=12): 3rds ↔ 6ths, 5th ↔ 4th (the classic trap). At the 10th (N=16): parallel 3rds become parallel 8vas — avoid them. At the 12th (N=19): parallel 3rds survive as parallel 10ths (Bach's favourite). Editor shows stacked original + inverted rolls with ⚠ flags on every pair that would break voice-leading after inversion. |
| Stretto | midicents subject number voice count (1–4) list delays per voice list intervals per voice (semitones) list transforms per voice (P/I/R/RI) number pivot (mc) list scale (optional) number tonic |
midicents voice1-4 rhythm-tree rhythm1-4 number totalLength string label |
Multi-voice canonic entrance helper. One subject in, 2–4 voices out, each with its own delay / transposition / transform. Covers fugal stretto (close imitative entries), mirror canon (I / RI transforms against the dux), and Palestrina imitation points (tonal scale-snap). All voice rhythms share the same total length via leading + trailing rests, so wiring voicen+rhythmn straight into a Voice Layer gives a playable stretto at the correct offsets. 6 presets: Classical 4-vc, Close 2-vc, Bach fugue, Webern mirror, Palestrina, Bartók TT. |
| Phase | midicents pattern (negative values = rests) number cycles number voice count (1–4) number shift per cycle list start offsets per voice |
midicents voice1-4 rhythm-tree rhythm1-4 number totalLength number patternLen string label |
Reich-style progressive phasing. Takes a short repeating pattern and emits 2–4 voices: voice 0 anchors, voice i rotates by i × shiftPerCycle notes per cycle. Voices start unified, drift apart, and (if cycles × shift is a multiple of patternLen) re-align at the end. Shift=1 reproduces Clapping Music exactly. Pattern entries ≤ 0 are rests — so you can encode percussive patterns like X X X . X X . X . X X . directly. 6 presets: Clapping, Piano Phase, Drumming, Fast drift, Full 4-vc, Re-align. |
| Chord Progression | list circles (pitch-class set cards) number root (mc, default 6000) number edo (12/24/31/48/72) number octave offset |
any chords (Chord[]) midicents pitches (flat) number stride |
Sequence of chord cards (pitch-class sets), transposed by a root and realised in an EDO. Emits stacked Chord[] for block-chord playback or flat midicents for arpeggiation. Edit visually through the same circular HarmonicCircle UI as the Preplan view — drag degrees on the circle to build each chord, re-order cards, toggle EDO. |
| Polychord | list bottom-pcs list top-pcs number interval (semitones between units, 0–11) number edo number bottom-root (mc) |
any chord midicents pitches (flat) number resonance rating (0–6) |
Two stacked chord units separated by a controlled interval (Persichetti Ch 7). The top unit is transposed up by the interval parameter. Emits Persichetti's resonance rating (cycle-of-5ths distance between the roots — 0 = consonant fusion, 6 = tritone-distant maximum tension). Editor shows two HarmonicCircles stacked vertically plus an interval slider and 6 presets (Petrushka, Fifth stack, Tritone stack, etc.). |
| Mirror | midicents pitches number pivot (mc) midicents moving pivot (optional wire) |
midicents mirror midicents doubled (contrary) midicents interleaved |
Pivot-based inversion (Persichetti Ch 8). Each pitch p is mapped to 2 × pivot − p. Scalar pivot for stationary axes (6250 = between D4 and E♭4, 6600 = F♯4 fixed point). Wire the moving-pivot input for per-note axes — useful for mirroring against a second melodic line. Three outputs: mirror only, original-then-mirror concatenated (contrary motion), and interleaved [p, mirror(p), p, mirror(p)…]. Editor is a chromatic wheel with a draggable axis and 24 keyboard-pivot presets. |
| Quartal | number root (mc) list qualities (per-layer semitones, default [5,5,5]) number 3rd below (0 / 3 / 4) number 3rd above (0 / 3 / 4) |
any chord midicents pitches number stride |
Stack of fourths (Persichetti Ch 4). Each layer is an interval in semitones added on top of the previous pitch — 5 = P4, 6 = A4/tritone, 7 = P5. Optional compound-quartal 3rd additions below the root or above the top thicken the stack without abandoning its quartal character. The classic Bill Evans "So What" chord is qualities [5,5,5] plus a major 3rd above. Editor is a tap-to-cycle brick tower with 8 presets. |
| Compound | number root (mc) list intervals (per-layer semitones, bottom to top) |
any chord midicents pitches (flat) list tensions (per-layer 0–5) number stride |
Mixed-interval chord stack with a tension curve (Persichetti Ch 8). Every layer can be any interval, and the chord's character comes from the shape of tensions from bottom to top. Pyramidal = intervals strictly decrease (M7 base, m2 apex); arch = consonant-dissonant-consonant. The graphical editor colours each layer by its Persichetti tension class (0 = gold, 5 = bright red) and overlays a live tension curve so the shape reads at a glance. 8 shape presets. |
| Pandiatonic | list scale (PC set) number root (mc) number octaves number chords number notes per chord boolean fresh (no-repeat constraint) number seed |
any chords (Chord[]) midicents pitches (flat) |
Seeded stochastic chord draws from a scale pool (Persichetti Ch 10). Generates N chords of M notes each, all drawn from the scale; the fresh flag enforces no pitch appearing twice in the same chord. Deterministic under a seed. Editor has a piano-key PC strip for scale entry, chord preview piano-roll, 11 scale presets, and a regenerate button. |
| Telescope | midicents pitches (typically a tone row) number size (notes per chord) number advance (step between chords) |
any chords midicents topRow midicents bottomRow |
Row → chord telescoping (Persichetti Ch 12). Partition a row into overlapping groups of size adjacent pitches, advancing by advance each step, and sound each group as a chord. Also emits the top-of-chord and bottom-of-chord derived rows. Editor shows the input row with partition colouring, chord preview piano-roll, and 7 size / advance presets. |
Rhythm — 15 nodes
Nodes for building, transforming, and combining rhythmic structures — from simple tuplets to deeply nested rhythm trees and stochastic rest insertion.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Rhythm Tree | list tree structure number time-signature (default: 4/4) |
rhythm-tree | The core rhythm node. Defines a nested proportional rhythm structure where each level subdivides its parent proportionally. For example, (1 (1 2 1)) divides a beat into three parts with durations in ratio 1:2:1. Negative values indicate rests. Supports arbitrary nesting depth for complex metric subdivisions. |
| Tuplet Tree | number tuplet-type (default: 3) number beats (default: 1) number measures (default: 1) |
rhythm-tree | Generates a pre-built rhythm tree for a standard tuplet division, using MusicXML-compatible notation. Specify the tuplet type (3 for triplet, 5 for quintuplet, etc.) and how many beats and measures to fill. |
| Subdivide | rhythm-tree tree number beat-index list divisions |
rhythm-tree | Subdivides a specific beat within an existing rhythm tree. Targets a beat by its index and replaces it with a new set of proportional divisions. Use this to add rhythmic complexity to particular moments within a larger structure. |
| Tuplet | number n (default: 3) number in-space-of (default: 2) |
rhythm-tree | Creates a simple tuplet: n equal notes in the space of a given number of regular notes. A triplet is 3-in-2; a quintuplet is 5-in-4. The simplest way to introduce irregular subdivisions. |
| Mixed Tuplet | list divisions number in-space-of (default: 2) |
rhythm-tree | Combines regular and tuplet divisions within a single beat group. The divisions list can contain both simple integers (regular subdivisions) and nested tuplet specifications, producing rhythms that mix binary and ternary divisions. |
| Dotted Rhythm | number dots (1–3, default: 1) number beats (default: 4) |
rhythm-tree | Generates long-short dotted rhythm pairs. A single dot produces a 3:1 ratio; double dot produces 7:1. The pattern repeats to fill the specified number of beats, creating the characteristic uneven pulse of dotted rhythms. |
| Rhythm Repeat | rhythm-tree cell number measures (default: 4) |
rhythm-tree | Repeats a rhythmic cell across N measures, maintaining the original proportional structure. Use this to create ostinato patterns or to extend a rhythmic idea across a longer time span. |
| Insert Rests | rhythm-tree tree list mask (binary, e.g. [1,0,1,1,0]) |
rhythm-tree | Applies a binary mask to selectively silence events in a rhythm tree. A 1 in the mask keeps the event sounding; a 0 turns it into a rest. Inspired by Ferneyhough's approach to rhythmic filtering — the underlying proportional structure is preserved but events are selectively removed, creating patterns of presence and absence. |
| Rest Density | rhythm-tree tree bpf density-curve |
rhythm-tree | Controls rest placement through a BPF curve. At each time point, the curve value (0.0–1.0) determines the probability of an event being replaced by a rest. A rising curve gradually silences events; a falling curve gradually reveals them. Provides smooth, continuous control over rhythmic density. |
| Augment/Diminish | rhythm-tree tree number ratio (default: 1.0) |
rhythm-tree | Scales all durations in a rhythm tree by a multiplicative ratio. Ratio 2.0 doubles all durations (augmentation); ratio 0.5 halves them (diminution). Fractional ratios produce proportional stretching or compression of the entire rhythmic structure. |
| Rhythm Retrograde | rhythm-tree tree | rhythm-tree | Reverses the temporal order of all events in a rhythm tree. The first event becomes the last and vice versa, while preserving the proportional structure of each sub-tree. The rhythmic equivalent of playing a tape backwards. |
| Rhythm Rotate | rhythm-tree tree number steps (default: 1) |
rhythm-tree | Cyclically rotates event order by N steps, like a phase shift. Events that fall off one end wrap around to the other. Useful for creating rhythmic canons or exploring different starting points of a rhythmic pattern. |
| Duration Series | list durations (numeric series) number unit (default: 1/16) |
rhythm-tree | Maps a number series to a sequence of durations. Each number in the input list is multiplied by the unit value to produce a duration. Used in integral serialism to derive rhythms from the same numeric series that generates pitches and dynamics — the Darmstadt approach of total organization. |
| Quantize Rhythm | list free-durations number grid (default: 1/16) number time-signature (default: 4/4) |
rhythm-tree | Snaps free (non-metric) durations to the nearest value on a metric grid. Converts continuous time values into a notatable rhythm tree by rounding each duration to the nearest grid division. Essential for turning algorithmic output into performable notation. |
| Polyrhythm | number stream-A (default: 3) number stream-B (default: 4) number measures (default: 1) |
rhythm-tree stream-A rhythm-tree stream-B |
Creates two independent tuplet streams running simultaneously — for example 3-against-4 or 5-against-7. Each stream is output as a separate rhythm tree that can be paired with different pitch material and combined in a Voice Layer node for true polyrhythmic notation. |
Spectral — 9 nodes
Nodes for spectral composition — working with harmonic series, frequency-to-pitch conversion, microtonal quantization, spectral morphing, and formant-based filtering.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Harmonic Series | number fundamental (Hz, default: 131) number num-partials (default: 16) |
list frequencies (Hz) | Generates N partials of the harmonic series from a given fundamental frequency. Partial N has frequency = fundamental × N. The output is a list of frequencies in Hz, which can be converted to midicents with the Freq to MC node. |
| Freq to MC | list frequencies (Hz) | midicents | Converts a list of frequencies in Hz to midicents using the formula: mc = 100 × (69 + 12 × log2(freq / 440)). This bridges the frequency domain (spectral analysis, harmonic series) and the pitch domain (notation, transposition). |
| Interval Vector | midicents pitches | list intervals (midicents) | Computes all intervals between adjacent pitches in a list. The output has one fewer element than the input. Useful for analyzing the intervallic content of a melody or pitch sequence and for feeding into transformation nodes. |
| Microtonal Quantize | midicents pitches number divisions (default: 24) |
midicents | Snaps each pitch to the nearest step in an equal division of the octave. Divisions = 12 gives standard semitones; 24 gives quarter-tones; 48 gives eighth-tones; 72 gives twelfth-tones. Any integer division is supported for exploring non-standard equal temperaments. |
| Scale Quantize | midicents pitches list scale-degrees (midicents offsets) |
midicents | Snaps pitches to the nearest degree of a custom tuning system. The scale is defined as a list of midicents offsets within the octave (e.g., a just-intonation major scale). Pitches are quantized to the nearest scale degree across all octaves. |
| Spectral Round | midicents pitches number fundamental (Hz, default: 131) |
midicents | Rounds each pitch to the nearest harmonic partial of the given fundamental. The result is a set of pitches that all belong to the same harmonic series, creating spectral coherence from arbitrary pitch material. |
| Spectral Morph | midicents field-A midicents field-B number morph (0.0–1.0, default: 0.5) |
midicents | Interpolates between two harmonic fields. At morph = 0.0 the output is identical to Field A; at 1.0 it is Field B; intermediate values produce pitch sets that smoothly transition between the two spectral worlds. A core technique in the spectral composition tradition, enabling continuous harmonic transformation. |
| Harmonic Distance | midicents pitches number fundamental (Hz, default: 131) |
list distances | Measures the consonance or roughness of each pitch relative to a fundamental by computing its distance from the nearest harmonic partial. Low values indicate near-harmonic (consonant) pitches; high values indicate inharmonic (rough) pitches. Use this to analyze or sort pitch material by spectral tension. |
| Formant Filter | midicents pitches list formants (Hz centers, default: [800, 1200, 2500]) number bandwidth (Hz, default: 200) |
midicents | Filters a pitch collection through vocal formant regions. Only pitches whose frequencies fall within the bandwidth of one of the specified formant center frequencies are retained. Inspired by spectral techniques for filtering harmonic fields through the resonance characteristics of vowel sounds, creating timbral associations between instrumental pitch and vocal quality. |
Score — 2 nodes
The final assembly nodes that combine pitch and rhythm into playable, exportable musical structures.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Chord | midicents pitches velocity velocity (default: 80) |
chord | Creates a chord (vertical sonority) from a list of pitches with an associated velocity. Multiple pitches at the same time point become a simultaneous chord in the notation. A single pitch produces a monophonic note. |
| Voice | rhythm-tree rhythm chord chords (list) velocity velocities (optional) articulation articulations (optional) |
voice | The essential output node. Combines a rhythm tree with a sequence of chords to produce a complete musical voice. Chords are assigned to rhythm tree events in order; if there are fewer chords than events, the chord list cycles. The resulting voice can be previewed with MIDI playback and exported to MusicXML. |
Control — 9 nodes
Curve generators and control signal nodes for shaping musical parameters over time — break-point functions, waveform generators, and metric modulation calculators.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| BPF | list x-points list y-points |
bpf | Defines a break-point function from lists of x and y coordinates. The BPF is a piecewise-linear curve that can control any parameter over time — dynamics, density, register, morph position. This is the primary control signal in grafer. |
| Sample BPF | bpf curve number num-samples (default: 16) |
list values | Samples a BPF at N evenly-spaced points, producing a list of numeric values. Use this to convert a continuous curve into a discrete sequence that can drive pitch lists, velocity sequences, or any parameter that requires a fixed number of values. |
| Gen Sine | number num-samples (default: 64) number periods (default: 1) number phase (0.0–1.0, default: 0) |
bpf | Generates a sine wave as a BPF. Specify the number of sample points, how many complete periods to produce, and the starting phase. Useful for smooth, periodic control curves — oscillating dynamics, register undulation, or morph position cycling. |
| Gen Triangle | number num-samples (default: 64) number periods (default: 1) number phase (0.0–1.0, default: 0) |
bpf | Generates a triangle wave as a BPF — linear ramps up and down. Produces straight-line crescendi and diminuendi when used as a velocity curve, or linear register sweeps when applied to pitch contour. |
| Gen Sawtooth | number num-samples (default: 64) number periods (default: 1) number phase (0.0–1.0, default: 0) |
bpf | Generates a sawtooth wave as a BPF — a linear ramp followed by an immediate drop. Useful for repeating crescendo-to-subito-piano gestures, cyclically ascending register, or asymmetric periodic control. |
| Gen Square | number num-samples (default: 64) number periods (default: 1) number duty-cycle (0.0–1.0, default: 0.5) |
bpf | Generates a square wave as a BPF — alternating between high and low values. The duty cycle controls the ratio of high to low. Useful for binary alternation patterns: loud/soft, dense/sparse, high/low register. |
| Gen Noise | number num-samples (default: 64) number seed (default: random) |
bpf | Generates a random noise signal as a BPF. Each sample point gets a random value between 0 and 1. Provide a seed for reproducible randomness. Use for stochastic control of any parameter — chaotic dynamics, irregular register jumps, random density modulation. |
| Gen Fourier | list amplitudes list phases (default: all 0) number num-samples (default: 64) |
bpf | Generates a BPF by summing harmonics with specified amplitudes and phases — additive synthesis of a control curve. The first amplitude controls the fundamental; subsequent values control the 2nd, 3rd, etc. harmonics. Create complex, smooth periodic curves by combining simple sinusoidal components. |
| Metric Modulation | number tempo-A (BPM, default: 120) number note-value-A (default: 1/4) number note-value-B (default: 1/4 triplet) |
number tempo-B (BPM) | Calculates the new tempo resulting from a metric modulation — where a note value in the old tempo becomes the beat in the new tempo. For example, if a triplet eighth at tempo 120 becomes the new quarter-note beat, this node computes the resulting BPM. Essential for Carteresque metric modulation passages. |
Dynamics — 3 nodes
Nodes for shaping and sequencing velocity (dynamic) values applied to musical events.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Velocity Curve | bpf curve number num-events |
velocity (list) | Samples a BPF to generate a list of velocity values shaped by the curve. The BPF is sampled at as many points as there are events, then values are scaled to the MIDI velocity range (0–127). Use any waveform generator or hand-drawn BPF to create smooth, complex dynamic contours. |
| Velocity Sequence | list pattern (velocities) number mode (0=cycle, 1=cresc, 2=dim, default: 0) |
velocity (list) | Generates dynamics from a repeating pattern. In cycle mode, the pattern loops unchanged. In cresc mode, each repetition is progressively louder. In dim mode, each repetition is progressively softer. Useful for creating regular dynamic accents, metric stress patterns, or graduated dynamic processes. |
| Cresc/Dim | number start-velocity (default: 30) number end-velocity (default: 110) number num-events number curve-exp (default: 1.0) |
velocity (list) | Generates a simple crescendo (start < end) or diminuendo (start > end) over a specified number of events. The curve exponent shapes the trajectory: 1.0 is linear, < 1.0 gives a fast start (logarithmic), > 1.0 gives a slow start (exponential). The most direct way to add a dynamic shape. |
Articulation — 3 nodes
Nodes for assigning and sequencing performance articulations and timbral mappings.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Articulation Seq | list pattern (articulation names) | articulation (list) | Defines a cycling sequence of articulations applied to successive events. For example, ["staccato", "tenuto", "accent"] repeats across all events in the voice. Supported articulations include staccato, staccatissimo, tenuto, accent, marcato, portato, fermata, and harmonic. |
| Articulation | text name (default: "staccato") | articulation | Outputs a single named articulation to be applied uniformly to all events in a voice. The simplest way to set articulation when every note should have the same marking. |
| Noise-Tone Axis | bpf curve number num-events |
articulation (list) | Maps a BPF to a continuum of articulations along the tone-to-noise axis. Low curve values produce pure-tone articulations (ordinario, sul tasto); mid values give transitional techniques (sul ponticello, half-harmonic); high values produce noise-dominated techniques (col legno, overpressure). Implements the timbral continuum concept used in spectral composition for controlling the gradual transition between tone and noise through instrumental technique. |
Stochastic — 6 nodes
Nodes for generating musical material through controlled randomness and probability-weighted selection.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Random Pitches | number low (midicents, default: 4800) number high (midicents, default: 8400) number count (default: 16) number quantize (divisions, default: 12) number seed (default: random) |
midicents | Generates N random pitches within a given range, quantized to the nearest division of the octave. Divisions = 12 gives semitones; 24 gives quarter-tones. Use a seed for reproducible results. The simplest stochastic pitch generator. |
| Random Walk | number start (midicents, default: 6000) number max-step (midicents, default: 300) number count (default: 16) number low-bound (midicents, default: 4800) number high-bound (midicents, default: 8400) number seed (default: random) |
midicents | Generates a constrained melodic random walk. Starting from an initial pitch, each step moves randomly by up to max-step midicents in either direction, staying within the specified bounds. Produces melodic lines that wander organically within a defined ambitus — stochastic but with local coherence. |
| Weighted Choice | list values list weights number count (default: 16) number seed (default: random) |
list | Selects N values from a list according to probability weights. Higher weights make a value more likely to be chosen. For example, values [6000, 6400, 6700] with weights [5, 2, 1] will produce mostly C4, some E4, and occasional G4. Use this to create probabilistic pitch or rhythm distributions with controlled tendencies. |
| Brownian Walk | number low (midicents, default: 4800) number high (midicents, default: 8400) number step (midicents, default: 200) number count (default: 16) number seed (default: 42) |
midicents | Bounded random walk — SuperCollider's Pbrown analogue. Each step is uniform in [-step, +step], reflecting off the bounds so the path stays inside [low, high] with even density. Compared to Random Walk, the reflection (rather than clamping) keeps the distribution flat across the range instead of piling up at the edges — closer to musically usable melodic contours. |
| Gaussian / Cauchy | number mean (midicents, default: 6000) number sigma (midicents, default: 200) number distribution (0=Gaussian, 1=Cauchy, default: 0) number count (default: 16) number seed (default: 42) |
midicents | Sample pitches from a Gaussian (bell-curve) or Cauchy (fat-tailed) distribution centred on mean. Gaussian uses Box-Muller transform — symmetric bell, ~99% of values within 3σ. Cauchy has the same centre but heavy tails: most pitches hover near the mean with occasional dramatic leaps, which is exactly the contour you want for a melody that mostly sits then suddenly takes flight. |
| Markov Chain | midicents states (pitch alphabet) list transitions (row-major N×N weights) number start (state index, default: 0) number count (default: 24) number seed (default: 42) |
midicents | First-order Markov chain — SuperCollider's Pmarkov. Each row of the transition matrix gives the relative weights for the next state out of the current state; rows are normalised before sampling so weights need not sum to one. The classic stochastic-melody tool: pour different aesthetics into the matrix shape and dial Ligeti, Xenakis, or generative folk pastiche. A row that sums to zero falls back to a uniform draw so the chain never dead-ends. |
Chaos — 2 nodes
Mathematical chaos generators that produce deterministic yet unpredictable sequences for driving pitch, rhythm, and dynamics simultaneously.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Logistic Map | number r (3.57–4.0, default: 3.8) number x0 (0.0–1.0, default: 0.5) number iterations (default: 64) |
list values (0.0–1.0) | Iterates the logistic map equation x(n+1) = r * x * (1 - x). For r values between 3.57 and 4.0, the system exhibits chaotic behavior — deterministic yet effectively unpredictable sequences. The output values (0.0–1.0) can be mapped to any musical parameter using Map Range. Small changes in r or x0 produce radically different sequences. |
| Henon Map | number a (default: 1.4) number b (default: 0.3) number x0 (default: 0) number y0 (default: 0) number iterations (default: 64) |
list x-values list y-values |
Iterates the Henon map, a 2D chaotic attractor defined by x(n+1) = 1 - a*x(n)^2 + y(n) and y(n+1) = b*x(n). Produces two correlated chaotic sequences — map X to pitches and Y to durations (or any other pair of parameters) for material where pitch and rhythm are derived from the same deterministic process. |
Transform — 2 nodes
General-purpose list transformation nodes for reordering pitch sequences.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Retrograde | midicents pitches | midicents | Reverses the order of a pitch list. The first pitch becomes the last and vice versa. A fundamental serial operation and a tool for creating palindromic or mirror structures in any compositional context. |
| Rotate | midicents pitches number steps (default: 1) |
midicents | Cyclically rotates a pitch list by N positions. Elements that fall off one end wrap around to the other. Positive steps rotate left (forward); negative steps rotate right (backward). Use for creating phase-shifted melodic variants or exploring all rotational permutations of a pitch sequence. |
Combine — 3 nodes
Nodes for merging, filtering, and reordering multiple pitch sequences.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Interleave | midicents list-A midicents list-B |
midicents | Alternates elements from two lists: A1, B1, A2, B2, A3, B3... If one list is longer, its remaining elements are appended at the end. Use for creating composite melodies from two sources, Hoquetus-style alternation, or interleaving pitch material from different compositional strata. |
| Sieve | midicents pitches list moduli (e.g. [3, 5]) list residues (e.g. [0, 1]) |
midicents | Applies Xenakis-style modular sieve filtering. A pitch passes through only if its index satisfies at least one of the modular congruences (index mod modulus = residue). Multiple modulus/residue pairs are combined with logical OR. This produces irregular, non-periodic selections from a pitch sequence — the sieve theory that Xenakis developed for pitch and temporal structuring. |
| Permute | midicents pitches list index-sequence (e.g. [2, 0, 3, 1]) |
midicents | Reorders a pitch list according to a given index sequence. The index sequence specifies which element of the input appears at each position of the output. For example, [2, 0, 3, 1] means: take the 3rd element first, then the 1st, then the 4th, then the 2nd. A direct way to impose a specific permutation on any material. |
Sequence — 6 nodes
Nodes for repeating, concatenating, and progressively transforming pitch material over time.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Seq Repeat | midicents pitches number repetitions (default: 4) number transpose-step (midicents, default: 0) number rotate-step (default: 0) |
midicents | Repeats a pitch sequence N times with cumulative transposition and/or rotation applied to each repetition. If transpose-step is 100 and repetitions is 4, the sequence appears at its original pitch, then +100mc, +200mc, +300mc. Combine with rotation for evolving melodic cycles that transform progressively. |
| Chain | midicents list-1 midicents list-2 midicents list-3 (optional) midicents list-4 (optional) |
midicents | Concatenates up to 4 pitch lists end to end into a single sequence. The simplest way to combine pitch material from different sources into a longer melody or extended pitch line. |
| Accumulate | midicents pitches number steps (default: 4) number mode (0=transpose, 1=expand, 2=rotate, default: 0) number amount (default: 100) |
midicents | Applies a progressive transformation N times, accumulating the result at each step. In transpose mode, each step transposes the previous result. In expand mode, each step expands intervals further. In rotate mode, each step rotates the sequence. The output is the concatenation of all intermediate stages, documenting the transformation process as it unfolds. |
| Stutter | midicents pitches number times (default: 2) |
midicents | Repeat each pitch in the input N times in place. SuperCollider's Pstutter / Pdup. [60, 64, 67] stuttered by 3 becomes [60,60,60, 64,64,64, 67,67,67]. Useful for arpeggio elaboration, polyrhythmic doublings against a rhythm cell, or just thickening a thin line. |
| Take | midicents pitches number count (default: 4) |
midicents | Keep only the first N pitches of the input. SuperCollider's Pfin. Pairs with stochastic generators (Brownian, Markov, Random Walk) to clip an open-ended stream down to the length you actually want, without re-tuning the generator's count. |
| Drop | midicents pitches number count (default: 1) |
midicents | Skip the first N pitches of the input and emit the rest. SuperCollider's Pdrop. Combine with Take to slice out a window of a stream — e.g. Drop 8 then Take 16 gives you bars 9–24 of a longer generator. |
Profile — 2 nodes
Nodes for shaping musical material according to continuous contour curves.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Apply Profile | midicents pitches bpf contour number range (midicents, default: 2400) |
midicents | Reshapes a pitch list to follow a BPF contour. The curve maps the register of each pitch: when the curve is high, pitches are pushed to the top of the specified range; when low, to the bottom. The original intervallic content is preserved as much as possible within the contour constraint. Use to impose a directional shape (arch, descent, wedge) on any pitch material. |
| Density Profile | bpf density-curve number total-events (default: 32) number measures (default: 4) |
rhythm-tree | Generates a rhythm tree where event density follows a BPF curve. Where the curve is high, events are closely spaced (dense); where low, events are widely spaced (sparse). The total number of events is distributed across the measures according to the curve shape. Use the same BPF for both Apply Profile and Density Profile to achieve tight spectral-temporal integration. |
Math — 4 nodes
General-purpose numeric operations for manipulating lists of values.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Arithmetic | list values number operand text operation (+, -, *, /, default: +) |
list | Applies a basic arithmetic operation (+, -, *, /) to every element in a list. Useful for simple transposition (add), interval scaling (multiply), or any uniform numeric transformation of pitch or rhythm data. |
| Map Range | list values number in-low (default: 0) number in-high (default: 1) number out-low (default: 4800) number out-high (default: 8400) |
list | Linearly remaps values from one numeric range to another. Essential for converting normalized chaos/stochastic output (0.0–1.0) into musically meaningful ranges — midicents, velocities, durations, or any parameter. For example, map [0, 1] to [6000, 7200] for a one-octave pitch range starting at middle C. |
| Repeat | list values number times (default: 2) |
list | Repeats a list N times by concatenating it with itself. The input [A, B, C] repeated 3 times becomes [A, B, C, A, B, C, A, B, C]. Use for creating cyclic patterns from short cells. |
| Slice | list values number start (default: 0) number end (default: -1) |
list | Extracts a contiguous portion of a list from start index to end index. Use -1 for end to take everything from start to the end of the list. Useful for isolating segments of generated material or trimming sequences to a specific length. |
Integer Sequences — 8 nodes
Classic natural-number sequences composers reach for — Fibonacci, Lucas, Tribonacci, Primes, Triangular, Squares, Powers of 2, and Thue–Morse. Each node shares the same four knobs so they swap interchangeably:
| Knob | Purpose |
|---|---|
| count | How many terms to generate. |
| offset | Skip the first N terms — which Fibonacci term to start from, which prime, etc. |
| modulo | Fold the sequence via x mod N. Set to 12 to keep Fibonacci pitches inside one octave; 0 disables. |
| scale | Multiply each term. Use 100 to convert step counts into semitone midicents for direct wiring into a Pitch Field. |
All eight nodes output number[], which plugs straight into Pitch Field, Rhythm Tree, Arithmetic, Map Range, Slice, Repeat — anywhere a number list is accepted.
| Node | First terms | Typical use |
|---|---|---|
| Fibonacci | 0, 1, 1, 2, 3, 5, 8, 13, 21, 34… | Golden-ratio proportions — Bartók, Stockhausen, Xenakis. Fold mod 12 to land on a cyclic Pisano pitch pattern; scale by 100 for semitone midicents. |
| Lucas | 2, 1, 3, 4, 7, 11, 18, 29, 47… | Fibonacci's sibling, starting 2, 1. Same golden-ratio limit; yields a different pitch palette when folded. |
| Tribonacci | 0, 0, 1, 1, 2, 4, 7, 13, 24, 44… | Each term is the sum of the previous three. Grows faster than Fibonacci — good for rhythmic expansions. |
| Primes | 2, 3, 5, 7, 11, 13, 17, 19, 23, 29… | Non-periodic, non-arithmetic. Classic source for Xenakis-style durations or irregular pitch intervals. |
| Triangular | 0, 1, 3, 6, 10, 15, 21, 28, 36… | n(n+1)/2. Accumulating growth — sometimes used for compound meter sequences. |
| Squares | 0, 1, 4, 9, 16, 25, 36, 49… | n2. Even more aggressive expansion. Mapped onto durations gives accelerating-retardation shapes. |
| Powers of 2 | 1, 2, 4, 8, 16, 32, 64, 128… | The metric ladder — whole, half, quarter, eighth… natural for nested subdivisions. |
| Thue–Morse | 0, 1, 1, 0, 1, 0, 0, 1, 1, 0… | Parity of set-bits in n. Perfectly non-repeating binary sequence — drives on/off gates, "fair sharing" distributions, and morphological splits. |
Morphologie — 3 nodes
Analytical and organizational nodes for sorting, deduplicating, and measuring pitch material.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Sort | midicents pitches number direction (0=ascending, 1=descending, default: 0) |
midicents | Sorts a pitch list in ascending or descending order. Use ascending sort to arrange pitches from lowest to highest for chord voicing analysis; descending for top-down arpeggio figures. Sorting transforms a melodic sequence into a registral stack. |
| Unique | midicents pitches | midicents | Removes duplicate pitches, preserving the order of first occurrence. Useful after operations like Pitch Multiply or Interleave that may produce repeated values. Returns the smallest set of distinct pitches present in the input. |
| Ambitus | midicents pitches | number low number high number range (midicents) |
Computes the pitch range (ambitus) of a list: the lowest pitch, the highest pitch, and the total range in midicents. Use for analysis or to feed range information into other nodes that need to know the registral extent of the material. |
Compose — 4 nodes
Higher-level structural nodes for building multi-section and multi-voice compositions.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| Voice Chain | voice v1 through v8 (up to 8 voice inputs) | voice | Chains up to 8 voice segments in temporal succession. Voice 1 plays first, followed by Voice 2, and so on. Use this to build multi-section forms from independently composed segments — an A-B-A structure, a through-composed sequence, or any temporal ordering of pre-built sections. |
| Section | text section-id | voice | References a pre-composed section by its ID. Sections are complete sub-graphs (their own source-transform-voice chains) that can be referenced multiple times from different places. Use Section references with Voice Chain to reuse and reorder compositional blocks without duplicating the underlying graph. |
| Voice Layer | voice voice-1 voice voice-2 voice voice-3 (optional) voice voice-4 (optional) |
voice (polyphonic) | Stacks up to 4 voices as simultaneous polyphony. Unlike Voice Chain (sequential), Voice Layer makes voices sound at the same time — producing multi-staff notation in MusicXML export. Use for counterpoint, polyrhythmic textures, or any music requiring independent simultaneous voices. |
| Isorhythm | list talea (rhythm cells, integer weights) midicents color (pitch cycle) number events (output length in note-steps) |
rhythm-tree tree midicents pitches number taleaLen number colorLen number cycle (= LCM of talea and color lengths) |
Machaut-style isorhythm (Persichetti Ch 10): a repeating rhythmic pattern (talea) combined with a repeating pitch cycle (color) of a different length. Because the two cycles are usually coprime, they drift against each other and only realign after LCM(taleaLen, colorLen) events. Emits both a matched-length pitch list and a rhythm tree, ready to wire into a Voice. Editor shows talea bars, color chips, and a drift grid with per-event colour tinting so you can see the cycle alignment at a glance. |
Integration — 1 node
Bridge a Voice on the canvas to external synthesis — SuperCollider, Max, Pure Data, or anything that listens for OSC over UDP.
| Node | Inputs | Outputs | Description |
|---|---|---|---|
| OSC Send | voice voice text host (default: 127.0.0.1) number port (default: 57120) text address (default: /grafer/note) |
voice (pass-through) | Send the wired Voice as OSC messages over UDP. Each note becomes one message of the form <address> <onset_s:f> <duration_s:f> <pitch_mc:i> <velocity:f>. The dedicated editor exposes the Send button, host/port/address fields, a live preview of the message count, and a copy-paste SuperCollider receiver snippet. Host is restricted to loopback and private-network ranges by default (override with OSC_ALLOW_ANY_HOST=1 server-side). The voice passes through unchanged so the OSC node can sit inline in a chain. |
SuperCollider receiver snippet — paste once at boot, then click Send on any OSC Send node:
OSCdef.new(\graferNote, { |msg|
var onset = msg[1], dur = msg[2], pitchMc = msg[3], vel = msg[4];
SystemClock.sched(onset, {
Synth(\default, [
\freq, (pitchMc / 100).midicps,
\sustain, dur,
\amp, vel,
]);
nil
});
}, "/grafer/note");
The same pattern works in Max (udpreceive 57120 → route /grafer/note) and Pure Data (netreceive -u -b 57120). Microtonal pitches in midicents (6000 = C4, 6050 = quarter-tone above C4) survive intact — cents-level resolution from Grafer's tuning system arrives at the synth as a continuous value.
Composition Chains
Practical workflows showing how to connect nodes into complete compositional chains. These are the patterns that working composers use most frequently — each one demonstrates a specific aesthetic or technical approach.
Spectral Composition (Saariaho style)
Start with a Harmonic Series node set to your chosen fundamental (e.g., 131 Hz for C3). Generate 16 or more partials to create a rich harmonic field. Connect this to one input of a Spectral Morph node, and connect a second Harmonic Series (with a different fundamental) to the other input. The morph parameter (0.0–1.0) controls continuous interpolation between the two harmonic worlds — automate it with a BPF for gradual harmonic transformation over time.
Feed the morphed output through a Formant Filter to impose vowel-like resonance characteristics on the pitch material. Set formant centers to approximate vowel frequencies (e.g., [270, 2300, 3000] for an "a" vowel, [400, 2000, 2600] for an "e" vowel). This creates a timbral connection between the abstract pitch material and the human voice, a hallmark of spectral composition.
Connect the filtered pitches to a Chord node, pair it with a Rhythm Tree, and assemble everything in a Voice node for notation export. For additional refinement, use the Noise-Tone Axis node to map a BPF to articulation markings that trace the tone-to-noise continuum across the passage.
Serial Technique (Schoenberg/Webern)
Begin with a Tone Row node and enter your twelve pitch-classes (0–11). The node automatically generates all four canonical forms: Prime (P), Retrograde (R), Inversion (I), and Retrograde-Inversion (RI). Each form appears as a separate output port.
Connect any form to a PC Transpose node to produce transposed versions (P0, P1, P2... through P11). Use Chain nodes to concatenate different row forms into longer pitch sequences. For integral serialism, pair the row with a Duration Series node that derives rhythms from the same or a related numeric series, ensuring that pitch, rhythm, and dynamics are all governed by unified serial logic.
For Webern-style pointillistic textures, spread the row across wide registral leaps using Interval Expand with a large factor, then assign sparse rhythms with many rests using Insert Rests. For denser Schoenberg-style writing, keep the row in a compact register and use flowing rhythm trees.
Counterpoint Workflow (Fux to Hindemith)
Feed a cantus firmus (a Pitch List or any pitch source) into a Counter-line node. Start with Species 1 (note-vs-note) and the default dissonance at 0.2 — Fux-strict territory. The output counter port is a complete counter melody conforming to your scale. For modal CP, pick a Dorian or Phrygian preset; for modernist writing, push the dissonance slider to 0.5+ and pick the Hindemith style preset.
Wire the Counter-line's counter output and the original cantus into a CP Check node as upper and lower voices. The 0–1 score grades strictness; the breakdown output lists violations by category (parallel 5ths, unresolved dissonances, etc.). Use CP Check's tension output — a per-pair 0–5 curve — as a BPF source to drive dynamics that breathe with your voice-leading density.
For canon, route the Counter-line into an Imitation node. Pick Transform P (prime) and Interval 7 for Bach-style canon at the fifth, with Delay 2. The node emits dux, comes, and pre-built rhythm trees with the delay baked in as leading/trailing rests. Pair each voice with its rhythm in a Voice node and stack them in Voice Layer for a complete playable canon. Try transform I for inversion canon, R for crab canon, or RI for Webern-style retrograde-inversion.
For invertible (double) counterpoint, feed any working two-voice pair into a Double CP node. Pick the swap interval — 12 (at the octave), 16 (at the 10th), or 19 (at the 12th, Bach's favourite). The editor shows stacked original and inverted rolls with ⚠ flags on every pair that breaks after the swap, so you can see at a glance whether the passage is truly invertible or needs rewriting.
Minimalist Phase (Reich)
Start with a short repeating pattern in a Pitch List — typically 8–12 notes. For Clapping Music, encode rests as negative midicent values inside the pattern (e.g. -1): cp.phase treats any non-positive entry as a rest slot. For melodic phasing (Piano Phase, Violin Phase), use 8–12 pitches from the piece's scale.
Feed the pattern into a Phase node. Set cycles to how many pattern repeats you want — 12 is the classic one-traversal length, 48 gives a ~5-minute extended realisation. Set voice count to 2 (for Clapping / Piano Phase), 3 (for Drumming), or 4 for a richer cascade. Leave shift per cycle at 1 for Reich-authentic drift. Voice 0 anchors; voice i rotates by i × shift notes per cycle. When cycles × shift is a multiple of the pattern length, the voices re-align at the end — the editor lights up a "voices re-align at end" indicator when this is true.
Each voice output pairs with its matching rhythm output (voice1 + rhythm1, voice2 + rhythm2, etc.). The rhythm trees are pre-padded to identical total lengths, so wiring each (pitch, rhythm) pair into its own Voice node and stacking everything in a Voice Layer produces a playable phased texture with no alignment math. For Clapping Music specifically, both voices use the same pitch (say, A4) — the music is the phase relationship. For Piano Phase, transpose one voice up an octave via the Voice node's clef or add a Transpose node before the Voice.
Boulez Pitch Multiplication
Define two pitch-class sets using PC Set nodes. Set A might be a trichord like [0, 1, 4] and Set B another trichord like [0, 3, 7]. Connect both to a Pitch Multiply node. The multiplication works by transposing each pitch of Set A by every interval derived from Set B, then taking the union of all resulting pitches.
The result is a larger pitch field that contains the intervallic DNA of both source sets. Run the output through Sort to arrange pitches registrally, or through Unique to remove duplicates. This technique, developed by Boulez for works of the 1950s and beyond, produces harmonically rich fields from small generating cells — the compositional equivalent of multiplying two numbers to get a product that contains both factors.
Experiment with different set combinations: multiply a whole-tone fragment by a chromatic cluster, or multiply two segments of a tone row. The results vary dramatically depending on the intervallic content of the source sets.
Ferneyhough Rhythmic Complexity
Build a deeply nested Rhythm Tree with multiple layers of tuplet subdivision — for example, a quintuplet where individual beats are further divided into septuplets or nested triplets. This creates the characteristically dense notational surface of new-complexity writing.
Feed the rhythm tree through Insert Rests with a binary mask (e.g., [1,0,1,1,0,1,0,0,1,1]) to selectively silence events. The proportional structure is preserved but certain attacks are removed, creating rhythmic patterns of presence and absence that break up the regularity of the underlying subdivisions.
Then apply Rest Density with a BPF curve to add an additional layer of time-varying rest probability — perhaps beginning dense and gradually thinning out, or the reverse. Finally, connect Grace Notes to add Ferneyhough-style gestural ornament clouds around the surviving main pitches, with density and range parameters controlling the proliferation of ornamental material. The result is a richly layered rhythmic surface where structural rhythm, rest patterning, and gestural ornamentation interact.
Xenakis Stochastic/Sieve
Start with stochastic raw material: Random Pitches for uniformly distributed pitches across a range, or Random Walk for a melodic line that wanders organically with constrained step sizes. Set the range and quantization to match your desired ambitus and temperament.
Filter the result through a Sieve node with modular congruence conditions. For example, moduli [3, 5] with residues [0, 1] retains only pitches at indices that are either divisible by 3 or have remainder 1 when divided by 5. This produces the irregular, non-periodic pitch distributions characteristic of Xenakis's sieve-based compositions — asymmetric scales and pitch selections that sound neither tonal nor uniformly chromatic.
Optionally pass the sieved material through a Permute node with a specific index sequence to impose a particular ordering. Combine with stochastic rhythms for fully Xenakis-inspired textures, or pair with structured rhythm trees for a hybrid approach.
Spectral-Rhythmic Integration
The key insight: use the same BPF curve to drive both pitch contour and rhythmic density simultaneously. Create a BPF node with a shape that describes the energy profile of your passage — for example, a slow ascent followed by a rapid descent.
Connect this BPF to an Apply Profile node to shape your pitch material: where the curve is high, pitches are pushed to the upper register; where low, to the lower register. Simultaneously connect the same BPF to a Density Profile node: where the curve is high, rhythmic events are densely packed; where low, they are sparse.
The result is tight spectral-temporal integration — high pitches coincide with dense rhythms, low pitches with sparse rhythms (or vice versa if you invert one of the curves). This creates a unified gestural quality where register, density, and energy move together as a single compositional parameter, a technique used extensively in spectral and post-spectral composition.
Chaos-Driven Composition
Use a Logistic Map node (r between 3.57 and 4.0 for chaotic behavior) or a Henon Map to generate deterministic chaotic sequences. These are not random — they are fully determined by the initial parameters — but they produce sequences that are effectively unpredictable and never repeat.
The output values (typically 0.0–1.0 for Logistic Map) need to be mapped to musical ranges. Connect to a Map Range node to convert to midicents (e.g., map [0, 1] to [4800, 8400] for a 3-octave range). Then pass through Microtonal Quantize to snap to your desired temperament (12 for semitones, 24 for quarter-tones).
The Henon Map is especially powerful because it outputs two correlated sequences (X and Y). Map X to pitches and Y to rhythm durations (via Map Range and Quantize Rhythm) so that both dimensions of the music emerge from the same chaotic process. Small changes to the initial parameters (r, a, b, x0, y0) produce radically different musical results, making these nodes excellent for generating variations.
Dynamic Shaping
Use waveform generators to create smooth, periodic dynamic contours. A Gen Sine node produces undulating dynamics that cycle between loud and soft. Gen Triangle gives linear ramp-up and ramp-down patterns. Gen Sawtooth creates repeated crescendo-to-subito-piano gestures. Gen Square alternates abruptly between two dynamic levels.
Connect the waveform output to a Velocity Curve node, which samples the BPF at the number of events in your rhythm and maps the values to MIDI velocities (0–127). For simpler cases, the Cresc/Dim node provides a direct crescendo or diminuendo with adjustable curve shape — linear, logarithmic, or exponential.
For complex dynamic shapes, combine Gen Fourier (additive synthesis of control curves) with Velocity Curve. Or draw a completely free BPF by hand and sample it. Connect the resulting velocity list to the velocity input of the Voice node to apply the dynamics to your composition.
Microtonal Techniques
Two approaches to microtonal quantization. The first uses Microtonal Quantize with any equal division of the octave: 24 for quarter-tones (the most common microtonal system in contemporary Western notation), 36 for sixth-tones, 48 for eighth-tones, or any other integer. This snaps free-pitched material to a regular microtonal grid.
The second approach uses Spectral Round, which snaps each pitch to the nearest harmonic partial of a given fundamental. This produces just-intonation-like tunings derived from the harmonic series — the pitches are irregular (not equally spaced) but acoustically coherent. Combine with Harmonic Series and Formant Filter for a fully spectral approach to microtonality.
For custom tuning systems (Turkish makam, gamelan slendro, just intonation scales, etc.), use Scale Quantize with a list of scale degrees defined in midicents offsets within the octave. Any tuning system that can be described as a set of pitches within one octave can be used as a quantization target.
Multi-Section Form
For large-scale compositions, build each section as a separate sub-graph with its own source-transform-voice chain. Each sub-graph produces a complete Voice output. Name each section with a unique ID using the Section node.
At the top level of your composition, use Section reference nodes to point to your pre-composed sections. Feed these into a Voice Chain node (which accepts up to 8 inputs) to arrange them in temporal order. An A-B-A form, a rondo, or a through-composed sequence can all be assembled this way. You can reference the same section multiple times, with different transformations applied each time (e.g., transposed, with different dynamics, or with modified rhythms).
For polyphonic textures, use Voice Layer to stack multiple voices simultaneously, then chain layered sections using Voice Chain for the full temporal structure of a multi-voice piece. This hierarchical approach — building small cells, combining them into sections, and assembling sections into forms — mirrors the way many composers think about large-scale structure.
Beethoven Fate Motif (Symphony No. 5)
The opening of Beethoven’s Fifth Symphony is built entirely from one four-note rhythmic cell — eighth-rest, three short notes, one long note — stamped at different pitch levels. That maps directly onto Grafer’s Pitch List + Rhythm Repeat + Voice chain. Enter the fate rhythm as proportional weights [−1, 1, 1, 1, 4] (the negative weight is the pickup rest, the final 4 is the held note), and set Measures to however many motif statements you want.
For the exact opening (bars 1–4), feed the Pitch List node the midicent sequence [6700, 6700, 6700, 6300, 6500, 6500, 6500, 6200] — that is G4, G4, G4, E♭4, F4, F4, F4, D4, the two famous fermata statements. In 4/4 time at 𝅝=108, two Rhythm Repeat measures cover them both. The Voice node maps each pitch to the next non-rest leaf of the rhythm tree, so the one rhythmic cell is silently repeated for every motif.
For the development that follows, feed eight motif statements of pitches into the same rhythm with Measures = 8. Each statement keeps the fate rhythm but drops its starting triplet by a step of the C-minor scale, with the long note landing a minor third below — so the motif cascades F→E♭, E♭→D, D→C, and so on, mirroring Beethoven’s sequential descent. The same technique works for any motivic piece: pick a distinctive rhythmic cell, supply a stream of pitches, and let the Voice node pour the pitches through the rhythm.
Score View
The Score view engraves your evaluated voices as real notation using the Verovio engine — the same open-source engraver used by RISM and Humdrum. Beyond simply rendering, it is an interactive score: click any note to hear it and inspect its pitch, zoom and paginate the layout, download the output, and play the whole score back through the browser synth or an external MIDI device.
Open the Score view with the S tab in the top navigation.
Viewer Toolbar
The toolbar stretches across the top of the Score view. Each group is self-contained:
| Control | Purpose |
|---|---|
| Play / Stop | Starts and stops playback of the full score. The button toggles its label. |
| Output (Synth / MIDI) | Picks the playback backend. Shared with Harmonic Progressions — your choice persists across sessions. |
| Zoom | − and + step the zoom by 5%. Click the percentage label to reset to 35%. |
| Responsive / Document | Layout toggle. Responsive = one tall scrolling page sized to content. Document = real A4 pages you navigate one at a time. |
| Page navigation | Only visible in Document mode. Arrow buttons plus N / total readout. Disabled when on the first / last page. |
| ↓ SVG | Downloads the current page as a standalone SVG file, named after the score title. |
| ↓ MusicXML | Downloads the generated MusicXML — the same engraving source fed to Verovio, ready to open in Dorico, Sibelius, Finale or MuseScore. |
Click-to-Audition
Click any notehead in the rendered score. The note lights gold, a small tooltip pops up showing its pitch name, MIDI number, and duration, and the Web Audio synth plays the pitch briefly. Clicking a rest shows Rest with no audio. Click anywhere outside a note to dismiss. Press Esc to dismiss the tooltip without clicking.
Because the feature uses the Verovio toolkit's MIDI-value lookup, the audition respects the exact notated pitch — useful when you're verifying a microtonal spelling came out right.
Playback Engine
Playback is driven by Verovio's timemap — every note ID in the rendered SVG is linked to a start and end time. When playback is running, a cursor walks through the score in real time, highlighting each note as it sounds. The cursor follows the audio backend independently, so even a silent MIDI setup still shows the correct visual progression.
| Backend | How it sounds |
|---|---|
| Synth | Web Audio triangle-wave synth. All notes scheduled sample-accurately up front, so tempo stays perfect even if the browser tab is backgrounded. Supports fractional MIDI — microtones play accurately without rounding. |
| MIDI | Uses the existing midiOut scheduler to send note-on / note-off messages to your configured MIDI port (hardware synth, DAW, Kontakt, etc.). MIDI is semitone-only, so non-12-EDO scores are approximated. |
Keyboard shortcuts for quick transport and layout while the Score view is focused:
| Key | Action |
|---|---|
| Space | Toggle play / stop. |
| + / = | Zoom in by 5%. |
| − | Zoom out by 5%. |
| 0 | Reset zoom to 35%. |
| ← / → | Previous / next page (Document mode only). |
| Esc | Dismiss the note-info tooltip. |
Settings
Click the cog icon in the top right to open Settings. The dialog exposes the rendering options that Verovio uses to engrave your score — organised into named presets plus fine-grained groups (Layout, Spacing, Typography, Beams & slurs). Every setting saves automatically to your browser so your visual preferences persist across sessions.
Rendering Presets
Four curated presets that set all twenty Verovio knobs in one click. Tweaking any individual knob afterwards switches the indicator to Custom, preserving whatever you dialled in.
| Preset | Character |
|---|---|
| Modern | Balanced defaults — Bravura font, moderate spacing, standard beam slopes. A good starting point. |
| Compact | Tighter margins and staff spacing using the Leipzig font. More music per page; good for long scores on screen. |
| Contemporary | Open, airy layout with French-style beams. Suits dense rhythmic and microtonal notation where readability at dense textures matters. |
| Engraved | Publication-quality output using the Leland font with vertical justification. Best for PDF export and print. |
Option Groups
Below the preset row, four collapsible groups expose the individual Verovio options. Each option is a slider paired with a direct-entry number field.
| Group | Knobs |
|---|---|
| Layout | Margin left / right / top / bottom, breaks (auto / smart / line / encoded / none), landscape, adjust page height. |
| Spacing | Staff spacing, system spacing, linear / non-linear spacing factors, justify vertically. |
| Typography | Music font (Leipzig / Bravura / Gootville / Petaluma / Leland), lyric size, staff-line width, barline width, stem width. |
| Beams & slurs | Beam max slope, French-style beams, slur curve factor. |
The Reset to defaults button at the top of the Score rendering section restores the Modern preset.
Ready to compose with algorithms?