The Atlantis Gazette

Nothing here is one big app. Each machine is a web page that does one thing, and they talk the way Unix programs do: over simple, published protocols that anything else can join.

The idea

A rig built like a shell pipeline

Melody, harmony, drums and control signals are separate machines. What joins them is not a framework but a handful of wires.

From the reef · Triggerfish and Atlantis

Triggerfish is a set of musical machines, each living in its own browser tab. Odonus writes melodic figures, Vetula grows harmony, Balistes plays drums, and Selene makes control signals for a modular synthesiser. None of them knows how the others work inside. What they share are wires: MIDI to reach instruments, OSC between the programs that run the rig, a WebSocket to reach the rig's engine, and a BroadcastChannel so that pages can hear one another.

“Write programs that do one thing and do it well. Write programs to work together.”Doug McIlroy, as summarised by Peter H. Salus

That is the Unix idea, moved from text to sound. A pipe in a shell carries text; these wires carry notes, clocks and control voltages. Because each piece does one thing, each can be understood, replaced or simply left out. Someone new can open one page and play Ableton with it. Someone with a eurorack case can add the small programs that reach it. Nothing in between is needed until it is wanted.

Every machine is a web page, and every page is served from one origin, localhost:3023. So the pages share the routing table and the mode through the browser's own storage, and talk on a tab bus. The dashboard is one more page on that bus: it shows which machines are open, starts and stops them, sets the mode for all of them at once, and holds the routing: two matrices, in the manner of AUM, for the notes and the drums, while the harmony is patched on the chart itself, from Vetula to Odonus. In Atlantis its X-ray shows the rig: each of its programs, whether it is running, and a button to restart it. Close the dashboard, and each machine still plays on its own.

Text is a page like any other. Limulus is one editor in front of Tidal, and the machines answer to it too: drums $ s "bd*2 sn" plays the drum kit, odonus $ scale "dorian" moves Odonus, Q $ vetula "cow-umbrella-bell" is a Vetula voice playing a progression saved by name, conspicillum $ … a grain cloud, and odonus $ loop 2 plays back a stretch of what Odonus played, and selene $ ochd es9main sets eight LFOs running on the modular. Each machine is also open in its own page, and the rig keeps the two in step.

Every page is now laid out the same way: a browser on the left for what the machine keeps, the instrument in the middle, and Limulus on the right. Both drawers slide out when wanted (backtick for Limulus) and shut again, so the instrument gets the width. The pages are instruments; Limulus, with Tidal++, is where they are combined.

The same discipline runs underneath. The sequencer engines are written once, in PureScript, and compiled twice: to JavaScript for the page and to Erlang for the rig, with conformance tests holding the two to the same behaviour. A pattern does not change its mind when it moves from the browser to the rig.

The wires, at a glance
MIDI	Notes and controllers, to instruments. From the page by Web MIDI in Solo; from Diaphus by CoreMIDI in Atlantis.
The rig socket	A WebSocket from each page to Architeuthis: what to play (a machine's patch, its edits, its cues), its marks and loops, Selene's rack, and the stage, the rig's record of what each machine is playing.
OSC	Between the rig's own programs: Architeuthis to Diaphus, SuperDirt and es9-daemon, and the beat back from Diaphus.
The tab bus	A BroadcastChannel between pages of one origin: which machines are open; play, stop and panic; Vetula's scale for Odonus.
Ableton Link	Tempo and phase, shared over the local network with anything else that speaks Link.
Bosun's HTTP	Which of the rig's programs are up, and the requests to restart one or to raise and lower them all. The dashboard reads it every few seconds.

Two ways to play

Solo or Atlantis: who plays the notes?

One switch, on the dashboard, sets it for every page.

In Solo, the page plays. Each machine sends MIDI itself, through the browser's Web MIDI, to whatever port the routing table names. The base case is one sequencer into Ableton. It needs a Chromium browser and a MIDI port (on a Mac, the IAC bus, switched on in Audio MIDI Setup), and nothing else installed. Each page keeps its own time.

SoloOdonus notes page MIDI IAC MIDI Ableton audio ears

In Atlantis, the rig plays. Odonus, Vetula and Balistes tell Architeuthis, the rig's engine, what to play: their patterns, their edits, their cues, over the rig socket. The engine runs the same sequencer the page would, makes the notes itself, and passes each one, stamped with its time, to Diaphus, which delivers it through CoreMIDI on Ableton Link's beat. So the rig shares one tempo and phase with every other Link peer. The same engine sends samples to SuperDirt and control voltages to the modular through es9-daemon.

AtlantisOdonus control page rig socket Architeuthis OSC Diaphus MIDI Ableton audio ears

Loops are the rig's in either mode. While the rig answers, it keeps each machine's recent playing in a record buffer; a mark sets a window on it, and loop 2 plays that window back on the next downbeat, even with the page closed. Choosing Atlantis also raises the rig if it is being held down; choosing Solo leaves it running.

Selene is not sequenced by the rig, but it is kept there. Its signals run in es9-daemon and on the FH-2; a selene $ line or a drop on Selene's page reaches them through Architeuthis, which keeps the rack, so they can be hushed and resumed with the page closed. Quadrat is not played by the rig: it drives its instrument through the Friends server and records through Itajara.

In this issue

Dashboardthe chart; routing; the rig
Odonusmelody, four playheads
Vetulaharmony, grown by ear
Balistesdrums
Selenesignals for the modular, by line or by drag
Conspicillumthe sample loupe
Quadratsamples an instrument
LimulusTidal, by the line

Soundings

Surface	A Chromium browser, nothing installed. Explore Vetula's harmony and hear it in the browser's own electric piano; copy a progression out as plain Tidal; MIDI to Ableton or any synth. Nothing is kept.
Keeping	Amphora, the store. Progressions kept by name, with every version.
The trunk	Diaphus and Architeuthis. The rig plays, on Link's beat: Limulus's voices and lines, Vetula shaping Odonus. Every rig path needs both.
Branches	Each independent of the others: SuperDirt · samples ES-9 · Selene's ES-9 banks FH-2 · gates, envelopes Itajara · Quadrat's takes Continuo · a piano

How deep you need to go depends on what you want to reach. Each daemon has to pay for itself in what it adds; past the trunk it is a branching tree, not a ladder.

News in brief

Voices name progressions. Q $ vetula "cow-umbrella-bell" # arpup 8 plays a progression saved in Vetula; save it again and every voice naming it follows. Vetula's + voice writes the line for you. Q $ hush removes a voice, and Vetula's drawer lists the ones playing, since a REPL never shows you which lines are live.

Letters for voices, numbers for channels. Vetula's voices are P to W, clear of the note names; a number is only ever a MIDI channel (ch3). The dashboard's chart and Odonus say the same letters.

Vetula shapes Odonus from a line. route $ odonus.out <- vetula Q colours Odonus's melody with voice Q's chords as they change; a muted voice still shapes it. Odonus names where its harmony comes from, and shows the chords once round.

Harmony at every zoom. Vetula's Explore zooms from the key's own chords through the ones popular music uses to every four-note chord, at sixty frames a second. Click to hear a chord, shift-click to take it into a progression, named with three glyphs, saved with ⌘S, kept in versions.

Selene learns Tidal++. One line sets a bank of eight outputs, all on the same instant: selene $ lfo es9main # rate "0.5 1 2 4". A list wraps across the outputs, as Tidal's lists do. The rig applies it with Selene's page shut.

Selene, by drag and drop. Every output group is a row, always; drop a module on one to replace what it plays. A row that cannot take it turns red and says why. Racks are kept in the drawer, and a click puts one on the rig, with undo.

A drawer on every page. The machines keep their presets, beats, scenes and racks in a browser that slides out from the left. Odonus recalls a preset as saved or in key, running or frozen. Balistes keeps its beats by name and by machine, and Vetula's Perform is Limulus.

The chart, three ways. Flow is the music; X-ray is the rig's skeleton, with a restart on every program; Storage shows what each part keeps, and for how long. The columns now order themselves by their wiring, to cross as little as they can.

The cast

Who's Who on the Reef

Each machine is drawn as a fish beside its name; the processes of the rig are creatures of deeper water.

The Triggerfish machines

OdonusOdonus niger, the red-toothed triggerfish

A harmelodic step sequencer. Sixteen cells are read by four playheads, each taking its own path through them, and the result is held to a scale, to chords, or to Vetula's progression. It can generate its own material, and a playhead can step on the clock or at the pace of its own notes. odonus.html

VetulaBalistes vetula, the queen triggerfish

Grows harmony by ear: a palette of chords that you widen by revoicing, inverting, suspending and extending. Chords you take become a progression, saved by name. A voice is a line in Limulus naming one (Q $ vetula "name"), lettered P to W; its key, or a voice's chords, can feed Odonus, by a route $ line or on the dashboard's chart. vetula.html

BalistesBalistes capriscus, the grey triggerfish

Drums, two ways: a port of Mutable Instruments' Grids, for morphing between drum maps; and a library of patterns programmed step by step. Beats are kept by name, with the machine they run on, and combined in Tidal. Real Tidal plays the same kit from Limulus (drums $ …), down the same routes. balistes.html

SeleneSelene vomer, the lookdown

Polysignals for the modular: LFOs, clocks, Euclidean rhythms and notes, eight to a bank of outputs on the ES-9, FH-2 and their expanders. Set by dragging a module onto a row, or by a selene $ line; kept as racks (tied to outputs) and modules (free of them). selene.html

Beside them

ConspicillumBalistoides conspicillum, the clown triggerfish

The sample loupe. Look closely at a collection of samples (waveform, loupe, laboratory, library) and play it, through SuperDirt. Its presets are in a drawer on the left, Limulus in one on the right. /conspicillum/

Quadrata boxfish, square in body and name

Samples an instrument at chosen points. Curves over its parameters trace a path through it; the rig plays every point into one take, which Quadrat divides by its own schedule, measures, and keeps as a set. A set is already a SuperDirt bank. Named for the square frame a field survey lays down. /quadrat.html

Itajarathe goliath grouper

The looper engine: a Rust daemon that records, overdubs in layers, undoes, and keeps time with Link. The pedalboard app and Friends of Itajara play it; Quadrat records its takes through it.

LimulusLimulus polyphemus, the horseshoe crab

Text in, sound out: one editor in front of Tidal, sending each block to Haskell Tidal or to Architeuthis, to show they are the same. The machines answer to it too, loops and all; it is the same editor, with the same text, on every machine's page, sliding out from the right; folds its blocks, and its cheatsheet lists everything the rig adds to Tidal. Not a fish, and not a machine: the editor that plays them. It took over from Calypso, the boat, now laid up. /limulus/

The rig

ArchiteuthisArchiteuthis dux, the giant squid

TidalCycles, ported to PureScript and run on Erlang's virtual machine; once purerl-tidal. The rig's engine: the pages reach it over the rig socket, it runs every machine's sequencer under its own supervisor, keeps their record buffers and plays their loops, and its arms reach Diaphus, SuperDirt and es9-daemon.

DiaphusDiaphus effulgens, the headlight lanternfish

Ableton Link, in Rust: the beat; once link-spike. It shares tempo and phase with Architeuthis and es9-daemon, and delivers the rig's MIDI through CoreMIDI at the time each note was stamped with. Link runs with or without Ableton.

es9-daemonCV over audio

A Rust program that opens the Expert Sleepers ES-9 as an audio device and drives its sixteen buses as control voltages and gates. The ES-9 is DC-coupled, so an audio signal can hold a voltage steady.

SuperDirtplays samples

The sample player of the TidalCycles world, running in SuperCollider. Architeuthis sends it OSC; it plays Conspicillum's collections and Quadrat's sets.

Bosunthe lighthouse

Keeps the processes running. It brings a group of daemons up and restarts whatever crashes; for Atlantis it holds the rig ready, to be raised deliberately, from Bosun's Chair or the dashboard's Atlantis page. Its lamps are the ones on the chart.

The dashboard

Follow a Note to Your Ears

The dashboard opens on one chart. It is the map of the rig, the state of the rig, and the explanation of the rig, all at once.

The chart is a Sankey diagram, read left to right: machine, page, loop, engine, the rig's outputs, interface, instrument, and your ears. Columns with nothing in them close up. A stream starts where its notes are made: at the page in Solo, at the engine in Atlantis, where the page's own line is grey, because it carries instructions and not notes.

Colour is the signal on each hop: note events, the rig socket, MIDI, OSC, CV and gates, audio, samples. It changes wherever the signal changes form, so the colours are the architecture.

Width is the number of streams, meaning distinct wires, not rows of the routing table. Sixteen drum lanes all sent to channel 10 are one stream; four Odonus playheads on four channels are four.

Only what you use is drawn. Nothing on the chart is chosen for it: it is read from the routing table, the MIDI ports that exist, and the pages that are open. One sequencer playing Ableton in Solo is five nodes in a line. The whole rig, with the modular and the samples, is drawn only when the whole rig is in use.

Loops have a column of their own. Each mark is a bubble in its machine's colour, fed a thin line by the machine that recorded it; a playing loop fills, pulses on the beat, and feeds the engine. A loop that nobody can hear wears a stop sign.

Diaphus is the beat, above the chart, and gold marks pulse on everything it times. It does carry every MIDI note the rig sends; a switch, Relays, draws it on that path too.

Three lenses. Flow is the music. X-ray is the rig's skeleton: every program has a node, its name coloured by what Bosun says of it, with ↻ to restart it. Storage stands on the same skeleton and names what each part keeps, and for how long: memory, disk, this browser, or Amphora. What is mostly storage is ghosted in place in the other two, so nothing moves.

The order is the wiring’s. The columns after the engine sort themselves by what they are joined to, to cross as few lines as they can, and move only when the routing does, never when something starts or stops.

Hover over a machine to light its streams; click it to split it into its voices, or switch on Every voice for all of them at once. A missing port is still drawn, with only the hop into it marked in red, and a stopped machine is shown ghosted. The key is a filter: click a kind of signal to hide it. Machines not on the chart wait in a dock beneath it; one the rig plays with no page open is drawn anyway, and can be stopped from its fish.

note events control rig socket MIDI OSC CV / gate audio samples

SoloThe base case: one sequencer into Ableton, five nodes in a line. Schematic, after the dashboard's chart.

AtlantisThe same sequencer, played by the rig. The page only tells it what to play (the grey line); the notes begin at Architeuthis, which sends the MIDI (Diaphus carries it to the port, on the beat), and gold marks show what the beat times.

Also in the water

Amphora: The artefact store: content addressed, so every revision stays reachable. Optional everywhere; pages fall back to the browser's own storage.
Continuo: A headless host for one instrument plugin, playing incoming MIDI to the speakers. Point it at a grand piano and the rig has a piano.
Binnacle: What a page needs to play in time with the rig: a clock that locks to Link, a lookahead scheduler, and the tab bus.
Littorina: Tidal's own engine, patterns and mini-notation, as one source for the browser and the rig, held to Haskell Tidal by an oracle. A periwinkle of the intertidal zone.
Acropora: What the modular is: the specifications of its modules and interfaces, the rig's layout, and which output can drive which input. A reef coral; it was called Selene until the name went to the signal page alone.
Reef & Harmonia: The engines, and now Selene's language and its blocks, written once and compiled to both JavaScript and Erlang; and beneath them the theory: chords, scales, voicings and voice leading.
DeepStar: The rig doctor: checks what code is actually running, and runs the calibrations the modular needs.
Friends of Itajara: An open-source looper for someone with one sample-playing module and no pedalboard. Quadrat lives in the same repository.

Colophon

The Atlantis Gazette is the About page of Triggerfish, served with the machines at localhost:3023/about.html. It is plain HTML, with no script.

Masthead. A. E. Verrill, Architeuthis dux (syn. A. princeps), 1882, from his work on the giant squids in the Transactions of the Connecticut Academy of Arts and Sciences. Public domain, via Wikimedia Commons; the credit is kept beside the image in img/CREDITS.md.

The fish are the app's own, from the identity study, and each machine's name is set in its nameplate face: Syne, Cormorant, Big Shoulders Stencil, Michroma, Instrument Serif and Major Mono.

The lanternfish of Diaphus is drawn after a plate of Myctophum punctatum, public domain, via Wikimedia Commons.

Type. Nameplate in UnifrakturMaguntia; headlines in Playfair Display; text in Source Serif 4; labels in Archivo, the app's own face.

Licence. Every Atlantis machine is to be open source: MIT throughout, except Littorina and Architeuthis, which are GPL-3.0 as Tidal is, and Diaphus, which is GPLv2+ by way of Ableton Link. Triggerfish is handing the last of its Tidal to the rig, so that it can be MIT.

❦

Small Programs, Plain Wires