LIVE CODING
Archean can be played through a terminal. Type a line, press Enter, and the sound changes immediately — no recompiling, no reflashing. This is live coding: the instrument's behavior is written and rewritten while it's playing.

Archean's live-coding layer is called Strata. It's a small language built specifically for this instrument: patterns of notes, modulation lanes for any parameter, and a handful of musical conveniences — scales, probability, randomness — that make typed music feel less like programming and more like playing.

CONNECTING
Plug Archean into your computer over USB and open any serial terminal (115200 baud — the exact speed doesn't matter over USB): the Arduino Serial Monitor, screen, picocom, PuTTY, anything that can send and receive plain text. On first connection you'll see:

archean-live -- type 'help'

From here, every line you type is a command.

YOUR FIRST SOUND

hit a3 500

This plays the note A3 for 500 milliseconds. Try a few different notes, then move on to something that keeps going on its own:

tempo 100
mel = c3 e3 g3 c4
play mel

"mel" is now a pattern — a short named sequence. "play mel" starts it looping. While it's playing, redefine it:

mel = c3 d3 e3 g3 a3

The new melody takes over on the next loop, without the sound ever stopping. This redefine-while-it-plays loop is the whole idea of live coding.

PATTERNS
A pattern is a sequence where each item is one step, and the whole thing loops. Steps are written space-separated.

c3, d#4, eb2, a — a note (c4 is middle C; no octave given means octave 3)
~ or . — a rest
_ — a tie, holds the previous note one step longer
[c3 e3 g3]— subdivide: all three notes share a single step
c3*2— repeat: plays twice within its own step
<c3 e3 g3> — alternate: a different note each time the pattern loops
(c3 or e3 or g3)— random choice: a different note at random, every time
c3? or c3?25 — a 50% (or 25%) chance of playing at all

These combine freely:

mel = c3 ~ [c4 e4]*2 <g3 b3> (c3|e3) d3?

PLAYING WITH FEEL, NOT JUST PITCH
A melody alone can sound flat. Modifiers after a pipe symbol ( | ) shape it:

play mel | rev | tr 12 | fast 2 | q minor d

rev plays the pattern backwards
tr 12 transposes up 12 semitones (an octave); oct -1 does the same in octaves
fast 2 / slow 2 speeds up or slows down the pattern relative to the main tempo
q minor dquantizes every note into D minor — useful combined with random choice, so generative melodies always land in key

Available scales: major, minor, dorian, phrygian, lydian, mixo, harmin, penta, minpenta, blues, whole, chrom.

BEYOND NOTES: EVERY PARAMETER IS A LANE
Archean's other controls — oscillator wave, LFO, envelope, Element, glide — can all be driven the same way notes are, each on its own independent lane:

lane sustain "1 .6 .8 .5" | slow 2
lane wave "morph land tri" | slow 8

Type "params" at any time for the full, current list of what's available. As of this writing:

wave — morph, tri, land, sine, saw, square, noise — oscillator waveform. The last four exist only in code; the panel's 3-position slider reaches just morph/tri/land.
lfo.rate — 0 to 100 Hz — LFO speed
lfo.wave — sine, tri, saw, pulse, rand — LFO shape
lfo.amp — 0 to 1 — LFO output depth
elem — 0 to 1 — Element CV output
glide — 0 to 5000 ms — portamento between notes
attack, decay, release — 1 to 5000 ms — envelope stages
sustain — 0 to 1 — envelope sustain level
fine — plus/minus 2 semitones — pitch trim
morph — 0 to 1 — how fast the landscape wave evolves (only audible with wave morph)

Any of these can also be set directly, without a pattern:

wave morph
attack 5
fine -0.5

Wave noise behaves differently: instead of repeating a looped table like every other wave, each sample of noise is freshly random. That means the note you play into it doesn't set a pitch — it sets how often the noise updates, which you hear as brightness: a low note gives a dull thud, a high note gives a bright hiss. Useful for faking percussion on a monophonic voice.

Taking a parameter away from its knob, and giving it back: the moment you set a parameter from code, it stops listening to its physical knob. "free attack" hands it back explicitly — or just turn the knob yourself; once it moves noticeably, it reclaims control automatically. "free all" (or "hush", which also stops all sound) releases everything at once.

MODULATION — BIND
Beyond fixed lanes, sources can modulate destinations continuously:

bind pitch lfo 0.08
bind elem env 1.0

Destinations: pitch (semitones), elem (0 to 1), lfo.rate (octaves), morph (speed multiplier, octaves)
Sources: lfo (the LFO itself, bipolar), env (the current envelope, 0 to 1), in (Element CV in), dist (the distance sensor), noise (fresh random value every tick)

Up to 8 binds at once. "unbind all" clears them.

A CLASSIC TRICK: SELF-MODULATING PITCH
Analog percussion synths (Moog DFAM among them) get their characteristic "thump" from the envelope briefly bending the oscillator's own pitch. The same trick works here:

adsr 1 90 0 40
bind pitch env 30
wave noise ; hit c2 60

The pitch jumps up right as the envelope opens, then falls as it closes — giving even a single monophonic voice real percussive punch.

EXAMPLES
A generative, never-repeating melody in a sorrowful key:

tempo 66 ; root a
wave morph ; glide 0
adsr 20 350 0.35 650
mel = (a2|e3|c4)?40 ~ ~ (f2|a3|d3)?30 ~ (g#3|e4|b2)?25 ~ ~ ~ (c3|f4|a3)?35 ~ (d4|a2|e3)?20 ~ ~
play mel | q harmin a

A dark, slow drone with the LFO patched out to an external filter:

tempo 55 ; root d
wave morph ; glide 1500
adsr 2500 2000 0.8 3500
mel = d2 _ _ _ _ _ _ _ a1 _ _ _ _ _ _ _
play mel
lfo.wave sine ; lfo.rate 0.04 ; lfo.amp 1

Patch the LFO CV output to the filter's cutoff input with a cable — the filter breathes on its own, once every 25 seconds.

A broken, music-box-like melody:

tempo 68 ; root a
wave tri ; glide 0
adsr 5 250 0.2 350
gate 0.25
mel = a3 ~ ~ c4 ~ e4 ~ ~ ~ d4 ~ c4 ~ ~ ~ ~ b3 ~ a3 ~ ~ ~ ~ ~ ~
play mel | q minor a

COMMAND REFERENCE, AT A GLANCE
name = <pattern> — define or redefine a pattern
play name | mods — play it as the melody
play "c3 e3 g3" — or play an inline pattern directly
lane <parameter> "..." | mods — modulate any parameter
<parameter> VALUE — set a parameter directly
hit NOTE [ms]— one-shot note
tempo N, quant N, root NOTE, gate F, seed N — global settings
stop / free [target or all] — release a lane back to its knob
hush — stop all sound immediately
ls — list defined patterns
del NAME— delete a pattern
status — show what's currently running
params — list every controllable parameter
help — show this list in the terminal

Command arguments accept arithmetic, for example: tempo 60*2. The hash symbol ( # ) starts a comment.

FURTHER READING
Strata's full, instrument-agnostic language reference, and its source, are on GitHub:
github.com/nakedboards/strata

The complete Archean Live firmware — what actually runs on the board — is here:
github.com/nakedboards/archean-live