> ## Documentation Index
> Fetch the complete documentation index at: https://docs.decktalk.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> Install DeckTalk with uv, pipx, or pip, build the scaffold video without an API key, then add an ElevenLabs voice and build the narrated mp4.

<Steps>
  <Step title="Install">
    DeckTalk needs Python 3.12 or later. Everything else arrives through Python packages
    and one download. Playwright's package carries its own browser driver, and
    `static-ffmpeg` carries ffmpeg and ffprobe for your platform. You do not need Node.

    <Tabs>
      <Tab title="uv">
        ```console theme={null}
        uv tool install decktalk
        ```

        `uv` is a Python package manager from Astral. The command `uv tool install` puts a
        command-line tool in its own environment and on your PATH.
      </Tab>

      <Tab title="pipx">
        ```console theme={null}
        pipx install decktalk
        ```
      </Tab>

      <Tab title="pip">
        ```console theme={null}
        python -m venv .venv && source .venv/bin/activate
        pip install decktalk
        ```
      </Tab>
    </Tabs>

    Then fetch the tools DeckTalk drives, once per machine, and confirm that they work.

    ```console theme={null}
    decktalk setup     # headless Chromium, ffmpeg, and KaTeX, into a per-user cache
    decktalk doctor    # reports each tool and exits 1 when one is missing
    ```

    ```text theme={null}
    python    ok      3.13 (.venv/bin/python3)
    chromium  ok      <version>
    ffmpeg    ok      .venv/lib/python3.13/site-packages/static_ffmpeg/bin/darwin/ffmpeg
    ffprobe   ok      .venv/lib/python3.13/site-packages/static_ffmpeg/bin/darwin/ffprobe
    katex     ok      ~/Library/Caches/decktalk/katex/<version>
    ```

    Run `setup` before `init`, because `init` copies the cached KaTeX into the project so
    that equations render with no network.
  </Step>

  <Step title="Scaffold and build">
    ```console theme={null}
    decktalk init my-lesson && cd my-lesson
    decktalk build --silent          # every stage with placeholder narration, no key
    ```

    The `--silent` flag runs every stage with a silent placeholder track and estimated
    word times. It needs no account and costs nothing, so use it to prove that a project
    builds before you spend credits. Each stage prints a table, and the build ends with
    the path of the video.

    ```text theme={null}
    sec    start    probe   YAVG   YMAX  result
     01     0.00     0.20     29    206  ok
     02    10.16    10.36     28    166  ok
     03    32.08    32.28     28    155  ok
     04    69.56    69.76     28    162  ok
    total 113.92s; 0 black section start(s)

    built build/out/my-lesson.mp4
    ```

    <Tabs>
      <Tab title="macOS">
        ```console theme={null}
        open build/out/my-lesson.mp4
        ```
      </Tab>

      <Tab title="Linux">
        ```console theme={null}
        xdg-open build/out/my-lesson.mp4
        ```
      </Tab>

      <Tab title="Windows">
        ```console theme={null}
        start build\out\my-lesson.mp4
        ```
      </Tab>
    </Tabs>

    The scaffold is a short lesson in four sections: a title, three labeled lines, a
    derivation that reveals line by line, and a prompt before-and-after. All four are page
    sections, which DeckTalk records from `deck/index.html` and cuts to the narration. A
    commented-out section 0 shows how to open with a clip of your own, and
    [Add a clip section](/guides/clip-section) walks through it.
  </Step>

  <Step title="Add your voice">
    Copy `.env.example` to `.env` and replace the two placeholders.

    ```dotenv .env theme={null}
    ELEVENLABS_API_KEY=sk_...        # Profile, then API keys, on elevenlabs.io
    ELEVENLABS_VOICE_ID=...          # the id on a voice's card under Voices
    ```

    Both values can also come from the environment. A value left as `<placeholder>`
    counts as unset. DeckTalk never prints the key and never writes it under `build/`.
    Then build the project again.

    ```console theme={null}
    decktalk build
    ```

    <Note>You need an ElevenLabs plan with API access. The [FAQ](/help/faq#what-does-it-cost)
    names the plan and gives the arithmetic.</Note>
  </Step>

  <Step title="Change a sentence">
    Edit any sentence in `script.md` and run `decktalk build` again. DeckTalk hashes each
    section by its text, so only the section you touched is synthesized and recorded
    again. The rest comes from the cache.
    [Rebuild one section](/guides/rebuild-one-section) explains what is reused.
  </Step>

  <Step title="Review">
    Open `deck/index.html` in any browser with no query string. The page shows an index of
    every scene and step. Add `?scene=2` to play a scene, `?step=2.1` to freeze one step
    with everything revealed, or `&hud=1` to overlay the clock.

    ```console theme={null}
    decktalk shots                          # one PNG per step, under build/shots/
    decktalk shots --section 3 --at 4.5     # a frame from section 3 as it plays with its real cues
    decktalk verify 3:3.1c                  # measures when the cue changed the picture in the mp4
    decktalk status                         # the timeline and what is built
    ```
  </Step>
</Steps>

## What is in a project

| Path            | What it holds                                                                                                                                                       |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `decktalk.toml` | The plan. One `[[section]]` per script section, the voice, the transitions, the mix, the soundscape prompts, and any tuning. [Reference](/reference/decktalk-toml). |
| `script.md`     | The narration. Each `## N. Title` heading starts a section, and text in square brackets is a stage direction that is not spoken. [Reference](/reference/script-md). |
| `cues.json`     | The phrase that each visual lands on. [Reference](/reference/cues-json).                                                                                            |
| `deck/`         | Your pages, with `decktalk-runtime.js` and a vendored copy of KaTeX beside them. [Runtime reference](/reference/runtime).                                           |
| `media/`        | Your own clips and the underscore markers.                                                                                                                          |
| `.env`          | The ElevenLabs key and voice id. Git ignores it.                                                                                                                    |
| `build/`        | Everything DeckTalk generates, including the video, captions, and chapters. Git ignores it. [Artifacts](/reference/artifacts).                                      |

<Tip>Write numbers and symbols in the script the way you want them spoken. A cue matches
the spoken words "two x", while the slide shows the symbols.</Tip>

## Next

[Your first deck](/guides/first-deck) writes one section from scratch and shows how the
four files refer to each other. [Writing for the ear](/guides/writing-for-the-ear) is the
craft of a script that cues well.
