Whichever of the four files you have open, what you are reading is one chunk – one ## heading in the source, with everything written under it. audience.html and speaker.html give a chunk the whole screen and move you from one to the next with the keyboard; print.html and print-notes.html run the same chunks on down the page, so a reader scrolls instead of pressing anything.

Two keys move you through the whole lecture, forward and back, and holding Shift jumps a whole column.

• Forward is Space, ↓, →, Enter or PageDown. It uncovers the next piece of the chunk, then moves on to the next chunk.
• Back is ↑, ←, PageUp or Backspace. It puts the last piece away, and leaves the chunk only once that chunk is back where it started.
• Shift-→ and Shift-← move a whole column, from any slide and not only the first of one. Shift-← goes to the top of the column you are in first, so returning to the start of a part and leaving it are the same key. Press forward now:

You just uncovered a segment: in the source, a line containing nothing but --- cuts a chunk into segments, as long as it is outside a block of code. The first segment is on screen when you arrive; forward uncovers the next, back puts it away. Each press that changes the slide is a beat: every --- is one, and so is each step of a figure, which later slides show. So the number of --- lines in a chunk is the number of presses it takes, and you can count them off the source.

A faint ⌄ at the foot of the slide says the next forward press will leave the column. There is nothing to click.

The speaker view shows you what comes next. With it open, look at this slide there: the segment the next forward press will reveal is already drawn in place, hatched and inside a dashed frame, so you can read ahead without the audience seeing it. Only the immediately next one; the segments behind it stay hidden.

Segments let you pace a dense slide during a talk instead of putting all of it up at once, and this third one is here so you can see them chain. In print.html and print-notes.html they run together as one flowing body, so nothing is lost on paper.

Some chunks have extra detail behind a chevron button: click one, or press 1…9 for the n-th. This chunk has two of them – try both.

print.html and print-notes.html print every expansion as an indented aside where it stood in the source, so the reading copy loses nothing.

Click any figure, block of code or formula inside the chunk you are on. It opens in a card in the middle of the screen, with the slide dimmed behind it.

# Click this block to zoom it. Useful when a line
# matters more than the slide.
def anonymity_set(observations, senders):
    return {s for s in senders if plausible(s, observations)}

Inside an opened card: drag to pan, wheel or + - to zoom, 0 to reset, Esc or a click to close. With a speaker window open, the projection follows which card you opened, how far you zoomed and where you panned, so what you are inspecting is what the audience sees.

In the projection, dragging pans instead of selecting, and holding Alt – option on a Mac – turns selection back on. Hold the key and the slide becomes selectable and the cursor changes; let go and dragging pans again. The selection survives the key release so you can reach Cmd-C, and Esc clears it.

Links behave two ways, and which one you want depends on the window you are in. A plain click follows the link in a new tab of that window. Clicked in the speaker view, that is you checking a source while the projection stays where it was. Clicked in the projection, the page opens in front of the audience.

The small QR-code symbol after the link is the second way: it puts the address on both screens, large, with a scannable code beside it, so people can open the link on their own phones. Click the address to open it anyway; Esc or the next slide clears it. Shift-clicking the link itself does the same.

Try it on this one: the group behind the tool. The symbol is what you want while an audience is watching.

The codes are drawn when the lecture is built, one per external address in the source. style: {link-codes: off} leaves them out.

Press O now – the letter O, not the digit zero, which resets the zoom instead. The view zooms out to show every chunk at once, laid out in its columns, with an outline round the one you were on.

• Drag to pan the board, wheel to zoom it.
• Click a slide to go there – one click both picks it and leaves the board.
• Arrow keys move the outline without landing, and the board follows, because the slide you want is often off screen.
• O again or Enter lands on the outlined slide; Esc leaves without moving.

The board shows the shape of the lecture, which is usually enough to find the part you want. With a speaker window open, both windows enter, pan, zoom and leave together.

The number in the corner of a slide is an address: press G, type it and press Enter, and you are there. It is the number a question from the audience names – “back on slide 14” – so it is the quickest way to answer one.

It works in either window, and the other follows. A number the lecture does not have shakes the prompt and keeps your digits, so you can correct them; Backspace takes a digit back and Esc closes the prompt without moving.

T shows a list of every named column. Click an entry to jump there; T again closes the panel.

A column with no {#id} does not appear – the unnamed opening column that holds the title slide stays out of the list. The {#id} is also what a cross-reference points at: a [text](#some-id) link anywhere in the body finds it.

Press / from anywhere – you do not have to be in overview first. A panel opens and every slide whose heading or body contains what you type is listed with the sentence it matched, the term highlighted.

↑ ↓ pick a result, Enter or a click goes there, Esc closes without moving. If you opened the search from the overview board, the board follows your pick as you move down the list, so a match on the far side of the lecture comes into view while you are still choosing.

Search is what you want when you remember a topic but not which slide it is on. It reads the whole chunk, so a word that appears only in a sentence the projection never shows still finds its slide.

Unless you say otherwise, the slide is the first sentence of every paragraph plus any **bold** phrases from the rest. This chunk is written that way – press C twice and watch what appears and disappears.

It asks two things of you. Every paragraph has to open with a sentence that stands on its own, because that sentence is the slide. After it, a bold phrase becomes a bullet of its own, so it has to read as one. Everything unbolded is for print.html and print-notes.html.

The two bullets above are that rule applied: neither is a list in the source – each is a **bold** phrase inside a sentence the projection is holding back.

Bold selects, it does not stress. A bullet is set like the sentence above it, and one word inside a bold phrase is stressed with *em*, like this one. On paper the phrase is printed bold. The decoration lecture shows how to change either look for a whole lecture.

That suits a chunk that argues, where every paragraph has a point to open with. It is the wrong fit when the chunk wants continuous explanation instead, and the next chunk shows the alternative.

You are reading the projector version of this chunk: the bullets above sit inside a ::: slide block and this paragraph does not. Press C and this paragraph appears; press C again and it goes away.

Use ::: slide when the slide wants tight bullets while the argument wants prose. A chunk with neither block behaves exactly as Option 1 does, and the next chunk shows the other half of Option 2.

Press C twice on this chunk and watch one paragraph come and go while nothing else on the slide moves. That paragraph sits inside a ::: script block, which is the reverse of the last chunk: everything outside the block is the screen, and the block alone is what you say.

Use it when the screen half is the big half: the three made-up findings below are already the whole slide, and pressing C does not touch them. Wrapping them in a ::: slide block would mean marking nearly the whole chunk in order to exclude one paragraph, so marking that paragraph is the shorter way to say the same thing.

• One request in seven is answered differently once the crawler is instrumented.
• The gap is widest on the sites that serve the most third-party script.
• It closes again if the crawler waits between requests.

A ::: slide block wins wherever a chunk has one; failing that, a ::: script block puts everything outside itself on the screen; failing both, Option 1 applies. Three rules, checked in that order, on each chunk separately, so one lecture normally uses all three.

print.html and print-notes.html are what a student reads after the lecture, so on a screen they come with a few tools. Press P and try them on this tour.

• A contents sidebar lists every slide by part and marks the one you are reading.
• Select words and press the button at the end of the selection to highlight them, with a note if you want one. A figure, a code block or a formula has a button in its corner that marks it whole.
• n and p step through your highlights, and a counter in the corner says how many there are.
• The menu at the foot of the sidebar exports them as a Markdown file and reads such a file back in.

Highlights stay in the reader's browser and nobody else sees them. They are kept per lecture, so the export is the backup and the way to take them to another machine. Printed, they come out yellow, with each note in the margin. reader: off in the frontmatter ships the two documents without any of this.

The speaker view, or cockpit, is your lectern screen, in four bands. Press S here if you have not already – it opens speaker.html as a second window, and from then on the two windows talk to each other directly.

Open audience.html and the first slide carries a small menu in its bottom-left corner: Fullscreen, Speaker cockpit and Print view, each with its key – W, S and P. They are the three things you do before a talk, there for the day you have not learnt the keys yet. The first move through the lecture folds it away, and so does its own ‹; the › beside the ? brings it back.

W puts the projection into fullscreen, and a second W takes it out. Pressed in the speaker view, W is meant for the projection, but a browser lets a window go fullscreen only in answer to a click or a key pressed in that window – so the projection shows a hint, and your next click on it enters fullscreen. Shift-W puts the speaker view itself into fullscreen, for a talk given from one screen.

The notes pane sizes itself: up to three lines of text, one line once you have emptied it, and folded away entirely on a chunk that has no notes. Once you drag it, the height stays where you put it and is remembered across lectures and reloads. The slide above gives up exactly the space the notes take, so the copy of the projection keeps the projector's proportions instead of stretching.

Put the thumbnails down the right-hand side if the screen has width to spare: they get larger and their text becomes readable, so you can read ahead in the strip instead of only reading your position off it. The strip's height and its width are remembered separately.

An annotation is public, speaker notes are private.

A talk with a written-out script and minimal slides needs the script where you can glance at it. K in the speaker view rearranges the window: your notes for this chunk as cards down a rail, the projection small in the corner, the clock in the header. Space says the next card; when the cards of this beat are said, it clicks the projector, and the clicks stand in the same column as diamonds, so you read one list from top to bottom. Backspace takes one press back, whatever it was. Enter skips to the next slide.

A paragraph in a > note: is a card, and its bold phrases are the bullets. Bold the words you want to see, not the words you want to stress. A paragraph with no bold shows whole, in smaller type. A #### Title above a paragraph titles the card, and @12:30 on it is when you meant to reach it: the drift stands beside the clock.

Where the note stands is when it is said. A note before the first --- belongs to the beat the slide opens on, a note after it to the beat that --- opens. Open the speaker view on this chunk, press K, and walk it with Space: the cards under each diamond are the notes written under the matching --- in the source. A chunk whose notes all stand at its end, below the last of its text, shows them all on the first beat.

Single keys change how the lecture reads, and each one applies to both windows at once.

• C switches between what the audience sees and the full text.
• F cycles the font: serif, then sans, then monospace, for legibility across a room.
• A cycles the theme: four light ones with different accent colours, a neutral dark one, and two green-and-amber terminal ones.
• + - 0 set the text size; # cycles auto-fit through its three modes, which is worth trying right here – this chunk is longer than the screen.
• B blanks the projection.
• Shift-T sets a countdown for an exercise or a break: 5 is five minutes, 2:30 two and a half. A bar runs along the top edge with the time left beside it, in both windows, and three beeps sound at the end unless you click the bell.
• D puts a live demo on the projection: a window or a screen of this machine, chosen in a picker. D again pauses it, and once more brings the same window back without the picker; Shift-D picks another one. The very first capture on a Mac fails while macOS asks for screen-recording rights – allow it and press D again, so do that once before the talk.
• L cycles the slide numbers: in a row (the default), stacked, or off.
• M shows or hides the + note button in the slide's left gutter – the hint for N, which opens an annotation whether the hint is drawn or not.

Shift with C, F, A or L goes backwards. # has three modes and no Shift, because it is a shifted key on some keyboards and an unshifted one on others. Font, theme, slide numbers and the note button are remembered for every lecture you open, so the preference follows you; zoom and the C setting are not remembered beyond the talk you are giving.

On a phone or a tablet with no keyboard, both windows show a small toolbar along the bottom edge. Forward, back, overview and zoom sit on it; C, F, A, #, the search and text selection are behind its ⋯ button. Attach a keyboard and the toolbar goes away again, because the keys are back.

Cmd-K – Ctrl-K off a Mac – opens the ? panel with the cursor in its search field, and that turns the reference into a command palette. Type a few letters of what you want – theme, blank, fullscreen – and the list narrows to the commands that match.

↑ and ↓ pick a row, and Enter or a click runs it, exactly as its key would have. That is the answer mid-talk to a key you cannot remember, without reading the whole reference in front of the audience. It works in both windows.

Dark mode follows your machine unless something says otherwise. If you have never pressed A and the lecture pins no theme, a machine set to dark opens the lecture dark. Press A once and your choice is remembered from then on, everywhere. An author who writes theme: in the frontmatter overrides both, by the same rule as the other opening settings.

The two C modes keep separate zoom levels. The short version holds whatever size you set with + and -; the full text picks its own so the whole chunk fits the screen, and switching back restores yours exactly.

# cycles auto-fit through three modes, and the middle one, shrink, leaves your zoom where you set it and only makes a slide that is too big fit. So the audience reads one size all hour, except on the slides that would otherwise run off the bottom. Full sizes every slide to the screen, growing a short chunk as readily as shrinking a long one, which suits a lecture whose chunks vary a lot. Off is neither.

While the audience sees black, the speaker window keeps everything. The slide, the notes and the thumbnails stay where they were, so you can move on or read ahead with nothing showing. A small BLANK · hit B to toggle marker sits at the bottom of the speaker window, or at the bottom of the projection when there is no speaker window. D has the same shape: pressed in the speaker window, it opens the browser's picker there, and the window or screen you choose fills the projection while a DEMO · hit D to end it marker sits where the blank marker would. That is what a live demo on an extended desktop needs – the demo stays on the laptop, where the pointer is, and nothing has to be mirrored.

::: cols 2 (or cols 3) flows the body across that many columns, the way a newspaper page does. Use it when several short paragraphs read better side by side than stacked – a list of features, a brief comparison, two or three parallel definitions.

Columns fold to one while the slide is short – press C here and the two above stack. Shortened, each paragraph is down to its opening sentence, and a browser will not split a paragraph across columns, so two single sentences of different lengths do not balance. The full-text mode brings them back, and so do print.html and print-notes.html.

Revealed segments – the --- lines that uncover a chunk a piece at a time – work inside ::: cols, but text uncovered piecemeal while it also flows across columns is hard to follow: pick one or the other.

::: side makes two panes side by side, and ::: flip marks where one ends and the other begins. Unlike cols, you decide what goes where: everything before ::: flip is the left pane, everything after it the right. Use it for a figure with its commentary, or for a before-and-after pair.

Code in a pane needs short lines. A code block never wraps, and a pane holds about half the line a block across the slide does. A longer line is not cut off: the projection shrinks that one slide until it fits, and the slide then reads smaller than the ones either side of it. Break the line, or put the code across the full width and keep the panes for prose.

::: marginalia sets an aside out to the right of the chunk, past the edge of the text column and into the slide's margin.

A marginalia is the one aside you can click: the frame slides right until all of it is on screen. A figure or a block of code opens in a card in the middle of the screen; a marginalia gets no card. Esc, or a click on the slide, moves the frame back. Try it on the block out to the right, the part of it the edge of the screen has cut off.

The body stays in the middle column and only the marginalia moves outward. Keep them short: a marginalia shares the chunk's height and cannot grow taller than it. One can also go inside a ::: side pane, when a tangent belongs to one half in particular – it still goes to the slide's right margin.

::: footnote puts a small grey note under the chunk, labelled and always visible – down in the flow of the text rather than out at the side. No button, no separate panel, nothing to click.

A marginalia goes out into the margin and can be brought to the centre with a click; a footnote stays under the chunk and is read where it stands. Use ::: footnote when the extra material is short and you want it on the page every time, and for ::: expand <label>, the chevron button from earlier, when it should stay behind a button until somebody asks.

Write ![Caption](fig-id) and the build looks in assets/ for fig-id.svg, .png, .jpg, .jpeg, .gif or .webp, taking the first it finds. No folder, no extension. Writing the path out in full still works when you need it.

As long as your pictures are small, the build puts them inside the HTML, so the whole lecture stays one file. The chevron has the limits, and what happens to a picture over them.

Drop clip.mp4 into assets/ and write ![](clip) – the same shorthand an image uses. The build looks for video files after image files, so an id that has both a still and a clip behind it gives you the still.

That player is a real clip embedded in this HTML file, a pan across the overview board. Press play, then check the address bar – nothing was fetched.

Play, pause and seeking are shared between the windows, so you can operate the clip at the lectern and the projection follows; freeze the projection first and it does not, which is how you check a clip before showing it.

A hosted player is written as ::: embed, and a bare link never becomes one. This is the only thing you can write that makes a lecture fetch from somebody else's server while you are teaching, so you say so in the source:

::: embed https://www.youtube.com/watch?v=aqz-KE-bpKQ
Big Buck Bunny, Blender Foundation
:::

The line under it becomes the caption. A youtu.be/… or a bare vimeo.com/123 works too; anything else has to be a full https:// address, and the build refuses what it does not recognise.

The address is always printed under the player, with a QR code on Shift-click, so people can reach the video even when the player will not run. YouTube is asked for through youtube-nocookie.com, and Vimeo is asked not to track.

A lecture with a hosted player no longer contains everything it needs: the machine showing it – often the lecture hall's own PC – contacts that company while you teach. A clip in assets/, or an .mp4 address on a server you control, needs no other server. The build tells you which of the two you have chosen.

Formulas are typeset when the lecture is built, so the finished file needs nothing at the moment you show it. Maths inside a sentence goes between single dollars – the anonymity set $S$ has size $|S|$ – and a formula on its own line goes between double ones:

A formula on its own line behaves like a figure: it stays on screen when the prose around it is shortened away, and clicking it opens it large for the audience.

This chunk carries {.blocks-left}, which is why the formula starts where this sentence starts. A code block, a figure and a display formula are centred by default, and style: {blocks: left} says otherwise for a whole lecture. Centred suits a slide where the block is the point; on a slide that argues with a formula inside it, a centred formula stands apart from the sentences around it. Maths inside a sentence follows that sentence: it is on screen when the sentence is, and cut away with it otherwise.

A lone dollar sign is safe. The delimiters are read as Markdown, not searched for in your text, so $PATH inside code, a price of $5 and $10 in prose, and a $$ inside a code block are all left alone. Write \$ if you want to be explicit.

Only the mathematical typefaces your formulas use are embedded in the file, and a lecture without formulas carries none. The build prints how much they added.

The maths follows the F key. Switch the body font to sans or monospace and the formulas change with it instead of staying serif while the text around them changes. Only the letters change: operators, relations and brackets keep their own shapes, and a character the sans face does not have falls back to the mathematical one. The projection carries a few extra faces for this; the printed document has no F key and does without them.

Everything above the one line that is exactly --- is the question, everything below it the answer. Both halves are ordinary Markdown – bold, code, a list, a formula – but no ::: block.

## definition: Digital signatures {.wide #signatures}

A key pair: the private key signs, the public key verifies.

::: pulse
What does a signature guarantee that encryption alone does not?
---
**Authenticity and integrity**: only the key holder could have made it,
and any change to the message breaks it.
:::

The question is drawn at the end of its chunk, after the speaker notes in print-notes.html. Where in the chunk you write the block does not move it.

The build refuses a block it cannot read as a question: no --- or two of them, an empty half, a > note: inside it, or a question on the title: or closing: chunk. An answer that needs a rule writes ***.

Write step blocks and the figure changes with each forward press. One step is one press of the same key that uncovers a segment, so steps and segments arrive in the order you wrote them and the speaker view reads ahead exactly as it does for text. Press forward twice here.

The last four lines of the block are the two steps: step leak shows the logfile, and step blame emphasises the leak and the box it runs to. An arrow is only as visible as the two things it joins, so showing the logfile is enough to bring its arrow with it.

The rest of the language is in the diagrams lecture: charts, tables, swim-lanes and protocols, every class and every word a step knows, each one drawn on a slide of its own. Click a figure there, and the button in the corner of its card opens the graphical editor.

Write a picture into a chunk and you get a picture in the text column – not one that fills the slide, and not three things standing side by side. What makes a slide more than that is written beside the body rather than in it.

## free: A picture behind the words {.full #deco-picture}

::: backdrop dusk {.cover .invert}

::: overlay {.bottom-left .ink .standard}
**The backdrop fills the slide.**

This block is an overlay, set in one of nine places over it.
:::

::: backdrop puts a picture behind the whole slide, edge to edge, and ::: overlay sets a block of text on top of it. Those are the lines that draw the next slide.

The decoration lecture shows the rest, one construction per slide: the ten covers and the closing slide, part dividers, rows of cards, docks and panels, and the type and colour of a whole lecture – the style: block and the typefaces.

psi-slides comes with three finished lectures. Open them, and take whatever you need out of their sources.

These are the commands you need while writing a lecture:

• node build.js --new <slug> makes a lecture folder with working frontmatter and two chunks. It builds the moment it lands on disk.
• node build.js <source.md> --watch rebuilds and reloads every open tab on every save.
• node lint.js lectures/ checks what can be checked without building: unknown types, unclosed ::: blocks, repeated ids, word budgets, too many segments, one-chunk columns, captions that repeat the heading, frontmatter keys nothing reads. --strict turns the warnings into failures.
• node build.js <source.md> --squint writes squint.txt: what the projection shows, slide by slide and beat by beat – the squint test from earlier.

One command is for after the writing rather than during it: node build.js <source.md> --slides-pdf prints slides.pdf, one page per presentation state, for a room where the HTML will not run or for someone who wants a deck to keep. --print-pdf and --print-notes-pdf print the two documents as print.pdf and print-notes.pdf, and the desktop app exports the same three.

A source file can switch one check off with <!-- linter: ignore reveal-overuse, density --> anywhere in the body. It has to be ordinary text to count: inside a code block or between backticks, as in the sentence you are reading, it is an example and not an instruction. This lecture carries a real one at the top, for density, and says there why.

A lecture can set its own starting look instead of inheriting whatever the reader last chose.

---
title: Anonymous Communication
font: mono              # serif | sans | mono
theme: terminal-green   # light-{red,teal,blue,orange}
                        # dark | terminal-{amber,green}
collapse: none          # topic-bold | none     – the C key
auto-fit: shrink        # true | false | shrink – the # key
slide-numbers: off      # vertical | horizontal | off
                        # (horizontal is the default)
print-slide-numbers: vertical
                        # the same three. Left out, it follows
                        # whatever slide-numbers says
editor: speaker         # both | speaker | none – the diagram editor
note-button: off        # on | off – the + note button in the
                        # slide's left gutter. The M key
neighbours: hidden      # dim | hidden – whether the slide
                        # before and after show through
transition: cut         # pan | cut | fade – how a slide change looks
reader: off             # on | off – the documents' contents
                        # sidebar and highlights
pitchblack: on          # on | off – the dark themes on a
                        # true black ground, for a projector
---

lang: de                # the language the lecture is written in:
                        # en, de, de-DE, fr and so on, and en
                        # when you leave it out

lang: picks the hyphenation dictionary, and by default only the two printed views use it: a long German compound breaks at the end of a line there instead of leaving a hole, while the projection and the lectern view do not hyphenate. style: {hyphenate: all} puts it into the projection too, which a German lecture at .narrow usually wants, and none takes it out everywhere. Unlike the twelve keys on the last slide, it is not a setting the reader could change: it describes the lecture.

A key you write beats whatever the reader last chose, and a key you leave out leaves that choice alone. So in a lecture that sets none of them, font, theme and slide numbers follow the reader from lecture to lecture.

slide-numbers applies to print.html and print-notes.html too, and print-slide-numbers: overrides it there when the printed document wants different numbering from the projection. A value the tool does not know stops the build and lists the ones it does.

neighbours, note-button and transition are the ones a keynote sets and a lecture does not. transition: cut lands on the next slide without the camera glide, and fade dips through the paper; both hide the neighbours unless you also write neighbours: dim. neighbours: hidden takes off the projection the faint slides above and below, which otherwise show where you are in the column. note-button: off hides the + note hint in the slide's left gutter; N still opens an annotation, and M shows or hides the hint at any time, in either window.

pitchblack: on is for a projector, which cannot show a dark grey as black. The three dark themes then stand on a true black ground instead of their own dark paper, and a light theme is left as it is. It has no key: Ctrl/Cmd-K, type pitch, Enter switches it in either window, and the choice follows you from lecture to lecture like the theme.

reader: off ships the two documents without the contents sidebar and highlights.