auditorium 1!3.2.0

Python-scripted live slide framework

Auditorium

The presentation framework for people who think in code.

Auditorium lets you build live technical presentations as Python scripts. Each slide is an async def function. Animate algorithms step by step, render live-computed plots, run numerical demos — anything Python can do, your slides can do. No PowerPoint. No Markdown. Just code.

from auditorium import Deck

deck = Deck(title="My Talk")

@deck.slide
async def sorting_demo(ctx):
    """Explain how the algorithm builds the sorted prefix."""
    await ctx.md("## Bubble Sort, Step by Step")
    data = [5, 3, 8, 1, 2]
    for i in range(len(data)):
        for j in range(len(data) - 1 - i):
            if data[j] > data[j + 1]:
                data[j], data[j + 1] = data[j + 1], data[j]
            await ctx.md(f"`{data}`")
            await ctx.sleep(0.5)
    await ctx.step()
    await ctx.md("**Sorted!**")

pip install auditorium
auditorium run talk.py

Why Auditorium?

Most presentation tools treat slides as static documents. Auditorium treats them as programs.

• Run algorithms live — sort arrays, traverse graphs, train models, all animated on stage
• Compute content — generate plots, tables, or LaTeX from data, not screenshots
• Use any Python library — numpy, matplotlib, pandas, whatever you import works
• Share with students worldwide — presenter mode syncs your slides to every connected browser in real time
• Export everywhere — record to video, export to PDF, or share as a self-contained HTML that replays your talk with original timing

If you've ever wished you could await inside a PowerPoint slide, this is for you.

Quick Start

pip install auditorium    # or: uv add auditorium

Create talk.py:

from auditorium import Deck

deck = Deck(title="My Talk")

@deck.slide
async def intro(ctx):
    """Notes for the presenter — only visible in presenter view."""
    await ctx.md("# Welcome!")
    await ctx.md("*Press right arrow to continue*")

@deck.slide
async def demo(ctx):
    """Show progressive reveals and timed content."""
    await ctx.md("## Key Points")
    await ctx.step()
    await ctx.md("- First point")
    await ctx.step()
    await ctx.md("- Second point")
    await ctx.sleep(1)
    await ctx.md("*(that one appeared automatically)*")

Run it:

auditorium run talk.py

Features

	Feature	Description
Code	Imperative Python slides	Each slide is an async def — loops, conditionals, imports, anything
Reveal	Progressive reveals	await ctx.step() pauses for keypress, await ctx.sleep(n) auto-advances
Math	LaTeX math	KaTeX bundled — $inline$ and $$display$$ in any markdown
Code	Syntax highlighting	Fenced code blocks with highlight.js (bundled)
Layout	Flexible layouts	columns, rows with "auto" sizing, arbitrarily nested
Presenter	Presenter mode	--presenter opens a second tab with notes, timer, next-slide preview
Sync	Shared navigation	Presenter drives all audience tabs — students see what you show
Late join	Mid-slide sync	Late-joining viewers see the full slide state immediately
Export	PDF / HTML / PNG	auditorium export — vector PDF, self-contained interactive HTML, or PNG per slide
Record	Video capture	auditorium record — headless or live recording via Playwright
Step export	Step-by-step	--step-by-step captures each reveal as a separate frame with original timing
Reload	Hot reload	Edit your .py and the browser updates — stays on the same slide
Offline	Fully bundled	All assets (fonts, KaTeX, highlight.js) ship with the package — zero CDN, zero internet
Reconnect	Server restart	Client auto-reconnects and resumes at the same slide

Presenter Mode

Start with --presenter to sync all audience tabs to your navigation:

auditorium run talk.py --presenter

Two tabs open: your presenter view (notes + timer + slide mirror) and the audience view (projected/shared). Navigate from the presenter tab — every connected browser follows in real time.

• Docstrings become speaker notes (never shown to the audience)
• Late-joining tabs catch up instantly (full slide state replayed)
• Audience keyboards are locked — only the presenter navigates

Without --presenter, each tab navigates independently.

Layouts

@deck.slide
async def layout_demo(ctx):
    """Layouts nest freely."""
    await ctx.md("## Two Columns")
    left, right = await ctx.columns([2, 1])

    async with left:
        await ctx.md("Main content (2/3 width)")

    async with right:
        await ctx.md("Sidebar (1/3)")

Use "auto" for natural-size regions:

header, body, footer = await ctx.rows(["auto", 1, "auto"])

Recording & Export

Requires pip install auditorium[record] and playwright install chromium.

# Record to video
auditorium record talk.py -o talk.webm

# Export to PDF (vector), HTML (interactive), or PNG
auditorium export talk.py -f pdf -o talk.pdf
auditorium export talk.py -f html -o talk.html
auditorium export talk.py -f png -o slides/

# Step-by-step: one frame per reveal, with original timing in HTML
auditorium export talk.py -f html --step-by-step -o talk.html

Navigation

Key	Action
Right arrow / Space	Advance step or next slide
Page Down	Skip to next slide
Left arrow	Previous slide
r	Restart current slide
Digits + Enter	Jump to slide N

Example

See examples/demo_deck.py for a full 11-slide deck exercising every feature.

auditorium run examples/demo_deck.py

License

MIT