lhtml-site, reveal.js or Quarto?
Many tools turn text into slides, and all of them show a talk in a browser or as a PDF. They differ less on the effects shown on screen, which plugins can add, than on how the slides are stored, written and checked. lhtml-site is built for slides that live for years: reused from one talk to the next, written by several people, and checked before they are shown, by you or by an AI agent.
In a nutshell
| lhtml-site | Most other tools | What you gain | |
|---|---|---|---|
| A slide is | a directory: its text, its images, its settings | a part of one file per talk | copy a slide into another talk, reuse it from year to year |
| You write | LHTML: HTML and CSS, shorter | Markdown, with HTML as an exception | all of HTML and CSS, without its length |
| The result | one plain HTML page per slide, readable without JavaScript | one page, or an application, shown by JavaScript | it opens everywhere, is indexed and linked, and lasts |
| To install | Python only | Node.js, a command of its own, or LaTeX | one pipx install; figures computed in Python |
| With others | one file per slide | one file per talk | small diffs, no conflict in git |
| Checking | every slide measured, the values written by hand listed | by eye | problems found before the talk, by you or by an AI agent |
The sections below explain each line in detail. Another tool may fit your case better: see When to choose which, at the end of the page.
1. One slide, one directory
Each slide is a directory: its source, its images and videos, and its settings.
src/
03_ik/
index.html.j2 the slide
config.yaml its settings, such as the credits of its images
assets/
arm.mp4
chain.svg
To take a slide into another talk, copy its directory: nothing is left behind. Without copying, a
deck (deck.yaml) can also list slides of other projects, show the same slide twice with other
parameters, and plan slides that do not exist yet. Fix a slide once, and every talk that shows it
gets the fix.
The other tools store a talk as a file. They can load part of it from another file (the Markdown
of reveal.js, src: in Slidev, include in Quarto, \input in Beamer), but the images stay
where they were put, and the unit you move is a piece of text, not a slide.
2. HTML and CSS, written natively
LHTML starts from HTML: what you write is HTML, and only a few symbols are read and shortened.
A class, a style or an attribute goes on any block, span or image in one line, and a line of raw
HTML, a <style> or a <script> is kept as written. Nothing to learn to go beyond the syntax:
it is the HTML and CSS you know.
Text on the left, a figure on the right. In reveal.js, the columns are written in HTML and CSS:
<section> <h2>Forward kinematics</h2> <div style="display:flex; gap:40px;"> <ul style="flex:1;"> <li>Each joint angle is set by hand</li> <li>Rotations are interpolated</li> </ul> <img src="fk.jpg" style="flex:1; max-width:50%;"> </div> </section>
In lhtml-site, the layout side of the theme places them, and the figure is fitted to its column:
{% set layout = 'side' %}
= Forward kinematics
* Each joint angle is set by hand
* Rotations are interpolated
media::
img::assets/fk.jpg
::
And when the theme has no layout for what you want, the HTML is still there: a block opened by
::[display:flex; gap:40px;] and closed by ::. The tools based on Markdown accept HTML too, but as an exception:
the Markdown inside an HTML block is read only between blank lines.
LHTML or Markdown? compares the two in detail.
3. Plain HTML as the result
Each slide is built into its own HTML page, with its address and its title. The text, the lists,
the images and the formulas are written in that page (the formulas are rendered by KaTeX at the
build when quickjs is installed, else in the browser). JavaScript only moves from one slide to
the next, opens the menu and scales the slide to the screen: four small scripts of 8.5 KB in all.
With JavaScript turned off, the slide shows whole, formulas included when they are rendered at
the build.
- Compatible: any browser shows it, and any web server hosts it: GitHub Pages, the server of your university, a folder opened from the disk.
- Indexed and linked: each slide has its own address and its own
<title>. A search engine finds the slide on inverse kinematics; an email links to slide 12. - Simple, and lasting: the result is HTML and CSS you can read, with no application to run. It will open in ten years as it opens today.
The others make other choices:
- reveal.js: the talk is one HTML page, each slide a
<section>of it, shown as slides by its JavaScript (Reveal.initialize()); its Markdown is read by a JavaScript plugin when the page loads. - Slidev:
slidev buildmakes a single-page application (SPA) in JavaScript; the slides have their own paths inside it. - Quarto: its HTML slides are a reveal.js presentation.
- Marp: the closest to lhtml-site on this point. Its HTML is static, HTML and CSS, with a template without JavaScript; but the whole talk is one file.
4. Python only
pipx install lhtml-site, and the whole tool is there: no Node.js, no npm install, no
node_modules in the project. The PDF export and the layout report download Chromium once; the formulas rendered
at the build add pipx inject lhtml-site quickjs.
Marp and Slidev run on Node.js (Marp also has a standalone binary); Quarto is a command of its own;
Beamer needs LaTeX. reveal.js needs nothing to show a talk, and Node.js to develop it.
5. Figures computed with Python
Being in Python is not only about the install: a figure can be a Python script next to its slide, run by the build.
assets/ plot.svg.py writes plot.svg, with matplotlib or numpy diagram.svg.tex a TikZ figure, compiled to diagram.svg
Change the script or a file next to it, and the next build makes the figure again (for data
read from elsewhere, delete .figures/). Quarto goes
further on this point: it runs the code of the whole document and puts its results in it.
6. Made for git and for several authors
One slide is one file: a change of a slide is a small, readable diff, and two authors who edit two
slides do not touch the same file, so they have no conflict to resolve. The order of the talk is
in deck.yaml, apart from the slides. With one file per talk, every change touches that file,
and two people who edit it at once often have to merge it by hand. Splitting a talk into files is
possible elsewhere, by hand; here, it is how a project is made.
7. A design checked automatically, ready for an AI agent
The slides themes have a design: layouts (side, stack, section), macros (gap::, small::,
media::) and tokens. A slide says what it shows, the theme decides where; a deck of 80 slides
stays consistent, and a change of the theme reaches all of them. Two commands check it:
lhtml-site --layoutopens each slide in a real browser, measures what is drawn, and lists what is wrong: text hidden under a figure, two blocks over each other, a block past the edge, an image enlarged until it blurs, a label of a figure crossed by a line. Each finding gives the line of the source to change; after an edit,changes.mdsays what was solved and what moved.lhtml-site --lintlists every size or position written by hand, with the macro or the layout that replaces it.
The other tools document no such check: reveal.js scales each slide to fit the screen, Quarto
offers .smaller and .scrollable to apply by hand, LaTeX warns of overfull boxes. You check by
eye, slide by slide.
This is what makes lhtml-site fit for an AI agent. An agent that writes slides cannot see them:
here, it measures them and reads the result. Each build writes the procedure for it
(.structure/agents.md), the design of your theme (design.md), and the report in a form a
program reads; your comments on a slide in the browser (lhtml-site --serve) name the file and
the line of the block. The agent edits, measures again, and stops when the report is clean.
Slidev has an MCP server through which an agent reads and edits the slides; it does not measure
them. Check your slides automatically shows the whole loop
on a real slide.
Also: the same sources build as slides in the browser and as a PDF in one command, and the same tool makes the course website around them, or a documentation site like this one. Quarto shares this idea; reveal.js, Marp and Slidev make slide decks.
What the others do better
- Presenting. reveal.js, Slidev and the HTML export of Marp have a speaker view, step-by-step
reveals and transitions between slides, and reveal.js and Slidev many plugins. The
slidestheme of lhtml-site shows one slide at a time, with the arrows, the wheel or a swipe, and a menu. - Maturity. reveal.js is widely used; Quarto is made by Posit. lhtml-site is young and has one maintainer.
- Running code. Quarto runs the code of a document (Python, R, Julia) and puts its tables and plots in it, with citations and cross-references.
- PowerPoint. Marp, Quarto and Slidev export to
.pptx. lhtml-site exports to HTML and PDF.
Side by side
| reveal.js | Quarto | Marp | Slidev | Beamer | lhtml-site | |
|---|---|---|---|---|---|---|
| A slide is | a <section> of the page |
a part of the .qmd file |
a part of the Markdown file | a part of the Markdown file, or a file imported with src: |
a frame of the .tex file |
a directory, with its images and settings |
| You write | HTML, or Markdown | Markdown | Markdown | Markdown and Vue | LaTeX | LHTML (HTML and CSS, shorter), or Markdown |
| The result in HTML | one page, shown by JavaScript | one reveal.js page | one static HTML file for the talk | a JavaScript application (SPA) | none (PDF) | one HTML page per slide, readable without JavaScript |
| To install | nothing to show; Node.js to develop | the quarto command |
Node.js, or a binary | Node.js | LaTeX | Python |
| Layout checked automatically | no | no | no | no | overfull box warnings | yes, with the line to fix |
| Values written by hand listed | no | no | no | no | no | yes (--lint) |
| For an AI agent | no | no | no | an MCP server, to read and edit | no | a guide at each build, and the measured report |
The tools also mix: Quarto makes its HTML slides with reveal.js, and a page of lhtml-site can hold any HTML or JavaScript, a reveal.js presentation included.
When to choose which
| Your case | The tool that fits |
|---|---|
| One talk, with transitions and step-by-step reveals | reveal.js, Slidev |
| Slides from Markdown in two minutes, also as PowerPoint | Marp |
| A document that runs code and cites a bibliography | Quarto |
| Co-authors who write only LaTeX, a PDF expected | Beamer |
| A course: slides reused from talk to talk and from year to year | lhtml-site |
| Slides written by several people, or by an AI agent, and checked automatically | lhtml-site |
Next: the recipes, from an empty directory to the result, or install lhtml-site.