# Meet the workspace (2 minutes)

Every button in this chapter **opens the surface it describes, live** — click it, look at what appeared, read the two sentences, move on. Nothing here changes your project or makes sound; it's a walk through the rooms before you start working in them. (Each button fires a registered action — the same one the AI or an MCP client would call. You'll see every click land in the Activity log later.)

## Views — six postures

The window is arranged by **views**, named after what you are doing, switched on the topbar's rail. Each holds its own panes, columns and open documents; switching never opens or closes anything, a running instrument keeps running.

| View | Posture | On screen |
|---|---|---|
| **Start** | you do not need to know anything yet | Books · a book's text · Knowledge · Assistant |
| **Build** | make a sound | Documents · the file · Inspector · **Analysis** · Keyboard |
| **Compose** | write the music | Patterns · piano roll · Mixer · Keyboard |
| **Perform** | play the set | Patterns (scene launcher) · Mixer · Modulators · Pads · Controller |
| **Hub** | get and share | the Hub, edge to edge |
| **Signal** | something is wrong | Devices · Activity · MIDI Monitor · Routing · **Analysis** |

Anything else is one click away in each column's picker, and **Arrange** mode (the topbar toggle) lets you add, pin, rename or save views of your own.

```yaml
actions:
  - action_id: view.open
    input: { view: build }
    label: "▶ Switch to Build"
  - action_id: view.list
    input: {}
    label: "▶ Every view with its panes and documents"
```

## The topbar — always visible

Across the top: the **Transport Widget** in the centre (Play, BPM, the Bar.Beat.Sixteenth counter, loop, and the red **Rec** dot) and a cluster of icon buttons on the right (Master Control, search, AI Assistant). The transport is the global heartbeat — every sequencer and every transport-following DSP wakes up when you press Play. No button for this one; it's already on screen.

## Documents — your files

```yaml
actions:
  - action_id: surface.open
    input: { surface: library }
    label: "▶ Open the Documents panel"
```

The left rail's file home: **OPEN** (tabs open right now), **PROJECT** (every file saved in this project), **NEW** (spawn a fresh Builder, Faust DSP, or authoring file). Everything you build lives here as a plain file — instruments are documents, not opaque session state.

## Patchbay — who talks to whom

```yaml
actions:
  - action_id: patchbay.toggle
    input: { open: true }
    label: "▶ Open the Patchbay"
```

The routing matrix: Sources as rows, Sinks as columns, one click per cable. FaustWave never routes anything implicitly — if the Keyboard plays your synth, it's because a cell in this matrix is filled. When something is silent, this is the first place to look.

## Sequencer — the step grid

```yaml
actions:
  - action_id: surface.open
    input: { surface: sequencer-default#roll }
    label: "▶ Open the Sequencer"
```

A multi-track piano-roll grid driven by a shared Faust master clock (sample-accurate, no JS-timer jitter). Scale-aware highlighting and a diatonic chord palette live here too — § *Your first pattern* uses both.

## Keyboard — play without hardware

```yaml
actions:
  - action_id: surface.open
    input: { surface: keyboard-default }
    label: "▶ Open the Keyboard"
```

An on-screen MIDI keyboard. It's a real MIDI Source in the Patchbay — route it to any DSP and click keys. No hardware needed to test a synth.

## Master Control — the mixer

```yaml
actions:
  - action_id: surface.open
    input: { surface: faustwave-bundled/mixer }
    label: "▶ Show Master Control"
```

The right-pinned strip: one MixerTrack per attached source (gain, mute, solo, sends), the **Master FX rack**, and the master volume + meter at the top. The **"+ ADD AUDIO"** button here is how a saved DSP gets a path to your speakers.

## Recorder — capture the master

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

Your recordings library — every WAV you capture with the topbar Rec dot, newest first, with in-app preview. Lossless 32-bit float, exactly what the speakers heard.

## Knowledge — this book lives here

```yaml
actions:
  - action_id: surface.open
    input: { surface: knowledge }
    label: "▶ Open the Knowledge Base"
```

The local knowledge base: search across Faust libraries, node kinds, music theory, and the manual you're reading right now — every shipped book is listed under *Installed Packs*. Semantic search runs on a local embedding model; nothing leaves your machine.

## Command Palette — everything by name

```yaml
actions:
  - action_id: palette.overlay.toggle
    input: { open: true }
    label: "▶ Open the Command Palette"
```

`Ctrl+K` (or `⌘K`). Every action in FaustWave is registered under a searchable id — the palette is the fastest route to anything you can't remember the location of. Press `Escape` to close it and come back.

## AI Assistant — the second operator

```yaml
actions:
  - action_id: chat.panel.toggle
    input: { open: true }
    label: "▶ Open the Assistant panel"
  - action_id: settings.open
    input: { section: ai-provider }
    label: "▶ Set up an AI provider (optional)"
```

The in-app AI (`Ctrl+L`) sees the same action registry you do — it can build instruments, route cables, fill patterns, and every move it makes lands in the Activity log for you to audit. It needs a provider (an API key, or a local endpoint like Ollama) — the second button jumps straight to that Settings section. Entirely optional: everything in this manual works without it.

## Hub — the community

```yaml
actions:
  - action_id: hub.open
    input: {}
    label: "▶ Open the Hub"
```

Publish and install instruments, sample packs, node packs, knowledge books, whole projects. Requires a (free) account for publishing; browsing installed content works offline.

## That's the map

Also on the rails, when you need them: **Audio Inputs / Audio Outputs** (device pick), **MIDI** (hardware devices), **Logs**, and the **Faust Compiler** history. You now know where everything lives — continue to § *Your first DSP* and start using it.