$ field

The command-line DAW.

Field generates, arranges, mixes, and plays music from the terminal. A song is a folder of YAML and audio files tracked in Git; field build renders it, and field play plays it live while you edit.

macOS and Linux. Windows coming soon.

the-low — field

$ field generate the-low/drums --seed 7 --variants 2

generated 2 variants (ace-step, seeds 7–8)

$ field build the-low

built //songs/the-low/track:main → .field/out/…

$ field play the-low --loop --watch

live //songs/the-low/track:main

# from a second terminal, while it plays

$ field choose the-low/drums --variant 2

moved drums → variant 2

$ git commit -am "drums: take 2"

$ ▍

Real commands, HOWLO's songs. Output abridged.

One change

Turn up the vocal reverb.

Saved DAW sessions are hard to compare. Open yesterday's version and today's and there is no way to see what moved between them short of clicking through every channel. In Field the session is text, so the change is a diff — and the build reads the same files to decide what to re-render.

git diff — songs/the-low/tracks/lead-vocal.yaml

@@ inserts @@

- effect: eq

bands:

- type: highshelf

frequency: 8000

gain_db: 1.5

- effect: reverb

- mix: 0.2

+ mix: 0.35

decay: 2.4

The lead vocal runs an EQ into a reverb. Raising the reverb's mix is one line in the track file.

the-low — field

$ field build the-low

cached //songs/the-low/track:drums

cached //songs/the-low/track:bass

cached //songs/the-low/track:keys

built //songs/the-low/track:lead-vocal

built //songs/the-low/track:main → .field/out/…

$ field play the-low --from 42.1.1

# not it — put the old room back

$ git checkout -- songs/the-low/tracks/lead-vocal.yaml

The build re-renders the vocal stem and the sum. The drums, bass, and keys are cache hits. Reverting is a Git checkout.

▶ A recording of this walkthrough — the part, the edit, the result, the revert — is on its way. Until then the commands above are the demo.

How it works

Edit while it plays.

field play streetlights --loop --watch loops the song through Field's native audio daemon and follows the project directory. Save a track file and the change lands mid-play. An edit that doesn't move the output — a comment, a reformat — makes no sound at all, because the watcher compares output hashes rather than guessing what an edit meant.

A file that fails field check prints its diagnostics and the last good version keeps looping; a half-saved file is the normal case, not an error. field choose from another terminal swaps a generated take inside the loop, so auditioning variants is listening to the song with each one in place.

streetlights — field play

$ field play streetlights --loop --watch

live //songs/streetlights/track:main

9.3.1 (0:21.4)

# saved tracks/main.yaml: pad -6 → -8 dB

edit //songs/streetlights/track:main (sum)

# saved a comment in tracks/keys.yaml

· no audible change

# field choose streetlights/lead-take --variant 3

edit lead-take → variant 3

field build the-low

Builds that know what changed

Every stem, send, and mix is a target keyed on the content hashes of its inputs. A fader move re-runs one sum; a comment edit rebuilds nothing. Seeded SuperCollider recipes render bit-for-bit under the same SuperCollider version. Model generation does not reproduce across GPUs, so Field records the model, seed, and hash of every take instead of pretending it does.

field generate the-low/keys --variants 3

Generated parts are recipes

A generated part is a request in a track file — a SuperCollider program and seed, or a prompt for ACE-Step music or Chatterbox voice. generate fills it with numbered takes; choose repoints which one plays, in one line, and keeps the others.

field insert add the-low/lead-vocal

Effects and plugins on any track

EQ, a limiter, and three reverbs are built in and render deterministically. AU and VST3 plugins render offline and run live as inserts on any track, the master chain included; field check pins the exact plugin and its state.

Agents

Let your coding agent work on the session.

A Field project is YAML files and a CLI with text output, which is what coding agents already know how to use. An agent can read a track file, edit it, run field check and field build, and see in the output exactly what its edit re-rendered. Nothing about that is agent-specific — the same files and commands you use are the ones it uses.

Ask it for three vocal chains — the low-pass into the plate, a bright shelf into the hall, one dry with just the limiter — and it writes each to a branch and builds it. You play them, switch between the branches, keep the one you like, and delete the rest. Everything it tried is a commit you can read.

An MCP server exposing the CLI's verbs is planned. Today the agent runs the commands directly.

the-low — git

$ git branch

vocal/dry-limit

vocal/lowpass-plate

* vocal/shelf-hall

$ git diff main -- songs/the-low/tracks/lead-vocal.yaml

- - effect: reverb

- mix: 0.3

+ - effect: hall

+ mix: 0.35

+ size: 0.6

$ field play the-low --from 42.1.1

$ git checkout vocal/lowpass-plate

Status

Produce and compose in it today.

Field is a full production system in the terminal: write and generate parts, record, arrange, mix through built-in effects and your own plugins, play it live, and export. The interface and the hosting come next.

In the CLI

Nested tracks, sends, per-track tempo and sample rate
Recording into takes — every performance kept, one active
A build graph with content-addressed caching
Seeded SuperCollider rendering; ACE-Step music and Chatterbox voice generation
eq, limit, and three reverbs built in; AU and VST3 plugin hosting
Live playback with a transport, loop, and watch mode
Versioned export; check, fmt, query, and explain

Coming soon

one, a native control surface on the same engine — transport, meters, take audition, nothing in it that isn't in the files
audiofield.io, hosting for Field projects: clone howlo/chemicals, fork it, and pull-request a mix, with large audio in object storage and history in Git. Free for public projects.