# Your first recording (5 minutes)

You have a sequencer pattern driving your Builder (§ *Your first pattern*). Now capture it to a WAV file you can share, archive, or re-import as a sample.

## Step 1 — Find the Rec button

In the master Transport Widget at the top centre, the **Rec** button is the small red dot — second from the right, just left of the Panic button (the one that cuts every note; don't reach for that one mid-take). Hover it; the tooltip confirms *"Start recording the master output to a WAV file"*.

## Step 2 — Start the recording

You can record while the transport is stopped or while it's playing — the Rec button toggles independently. The classic workflow:

1. Stop the transport (if it's playing).
2. Click **Rec**. The button pulses red — recording is armed.
3. Click **Play** (the leftmost transport button). Playback starts; the recording captures from this point.
4. Let it run for as many bars as you want.
5. Click **Stop**. Playback halts.
6. Click **Rec** again. Recording ends; the WAV file is written to disk.

> 🟦 **WHAT GETS RECORDED**: the Recorder taps the master bus output — exactly what your speakers hear. That includes every MixerTrack, every send to a master FX slot, after the master volume + softclip stage. It does NOT include muted tracks. Want to record only one source? Solo its mixer track before pressing Rec.

## Step 3 — Find your recording

```yaml
actions:
  - action_id: surface.open
    input: { surface: recorder-default }
    label: "▶ Open the Recorder panel"
```

Open the **Recorder** rail panel (right rail; the recording-dot icon — or the button above). The Recorder panel opens, showing every file in your recordings library — newest first. Your fresh take is at the top.

Each row shows: name (timestamped), duration in seconds, file size, and three actions: **Play** (preview in-app), **Reveal** (open the folder in your OS file manager), **Delete** (hard-delete, no trash).

> 🟦 **WHERE THE FILES LIVE**: the recordings folder is OS-dependent.
>
> - **Windows**: `%APPDATA%\FaustWave IDE\recordings\`
> - **macOS**: `~/Library/Application Support/FaustWave IDE/recordings/`
> - **Linux**: `~/.config/FaustWave IDE/recordings/`
>
> Files are named by timestamp + a random suffix, format `<ISO-date>_<suffix>.wav`. Format is lossless 32-bit float WAV at your project's sample rate.

Click **Play** on your row. The file plays back in-app via the audio system. (The transport doesn't restart; the Recorder uses its own playback path.)

## Step 4 — Re-import as a sample

The round-trip — record → re-import — is one of FaustWave's bread-and-butter moves. The just-recorded WAV is sitting on disk. Bring it into the sample store:

1. Open your Builder canvas. Right-click the pane, search `soundfile`. Add a Soundfile node.
2. Either drag the WAV from your file manager onto the Soundfile node, OR run `samples.import { file_path: "<path>" }` (the assistant can do this for you).
3. The sample's sha256 binds to the Soundfile node; on the next compile your Builder plays back the recording instead of synthesizing.

> 🟦 **WHY SHA256?** FaustWave stores samples by content hash, not by path. This means importing the same bytes twice is a no-op (returns the existing entry); and a DSP that references a sample by sha is portable across machines as long as the bytes are available locally. The `.builder` file carries denormalised metadata (file name, channel count) so a recipient who doesn't have the bytes gets a "browse for the file" prompt instead of a silent compile.

## What you've built (Getting Started, complete)

- A Faust DSP (osc + midi_note + gain → output).
- A MIDI-driven sequencer pattern in A minor with arpeggio + chord stabs.
- A lossless WAV recording of the loop on disk.
- A sample that re-enters the same Builder via a Soundfile node.

You've touched every major subsystem: Builder, Sequencer, Patchbay routing, Mixer, Master, Recorder, and the Documents / sample library. Everything from here is depth.

## Where to go next — the rest of the manual

Each button opens the book in its own Reader tab; the full library also lives in the **Knowledge** rail panel under *Installed Packs*.

```yaml
actions:
  - action_id: book.open
    input: { book_id: faustwave-builder }
    label: "📖 Builder — the visual graph editor in depth"
  - action_id: book.open
    input: { book_id: faustwave-sequencer }
    label: "📖 Sequencer — grid, slots, scenes"
  - action_id: book.open
    input: { book_id: faustwave-mixer-master }
    label: "📖 Mixer & Master — tracks, sends, FX rack"
  - action_id: book.open
    input: { book_id: faustwave-reference }
    label: "📖 Reference — shortcuts, MCP catalog, formats"
```

- **FaustWave — Builder** — the canvas + node-kinds + lifecycle + samples + the `.dsp` workflow.
- **FaustWave — Sequencer** — multi-track grid, slots, scenes, the full action catalog.
- **FaustWave — Keyboard** — chords, hold-mode, channel filtering.
- **FaustWave — Recorder** — the tap model, file format, parameter-sweep capture chains.
- **FaustWave — Mixer & Master** — tracks, sends, the Master FX rack, master volume + softclip.
- **FaustWave — Patchbay & Routing** — the routing model + matrix + the `routing.*` MCP surface.
- **FaustWave — Hub** — publishing instruments, sample-packs, books, projects.
- **FaustWave — AI Assistant** — the in-app AI, the Command Palette, MCP for external clients.
- **FaustWave — Reference** — keyboard shortcuts, MCP catalog, file formats, themes.
- **FaustWave — Node-Pack Authoring** — writing + publishing your own node kinds.