What you are reading is one chunk P, S and ? reach the rest of the lecture

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.

Expansions 1–9, or a click on the chevron, opens one

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.

Zoom into a figure or code block click it, drag to pan, Esc to close

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.

Option 1 – the default the slide is worked out from your prose: first sentences, plus the bold phrases

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.

Option 2 – explicitly set by you you mark which block is the screen

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.

Option 2, the other way round ::: script marks the narration instead

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.

The long version has tools for its reader contents, highlights and notes in print.html

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.

Speaker view the second window, the one S opens

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.

Before the talk starts the start menu, and W for fullscreen

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.

Arranging the speaker view resizing the panes, and where the thumbnails sit

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.

Two kinds of note one the audience sees, one only you see

An annotation is public, speaker notes are private.

Your notes as cue cards K, and what to write so it reads from the corner of an eye

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.

Changing how the lecture reads C F A and zoom

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.

The same controls without a keyboard the toolbar on a phone or tablet

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.

A key you have forgotten Cmd-K runs any command by name

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.

What the keys remember themes, the two zooms, auto-fit and blanking

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.

Text across two columns ::: cols 2 and ::: cols 3

::: 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.

Two panes you fill yourself ::: side and ::: flip

::: 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.

Images ![Caption](fig-id) resolves against assets/

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.

Video ![](clip-id), the same shorthand an image uses

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.

Hosted players ::: embed for YouTube and Vimeo

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.

Math $inline$ and $$display$$

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.

Writing a question the question, a line of ---, the answer

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 ***.

A slide can be more than a column of text and what makes it one is not written inside the text

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.

Read more three finished lectures to open

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

Writing your own --new, --watch, lint.js

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.

Deciding how a lecture opens twelve frontmatter keys, and lang: beside them

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
---

The language, and which setting wins lang:, and the rule for the twelve keys

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.