Use Slidev for the PyCon JP 2026 talk slide deck

Use Slidev for the PyCon JP 2026 talk slide deck#

Context and Problem Statement#

pyvista-wasm was accepted as a talk at PyCon JP 2026 — “PyVista on WebAssembly: サーバーレス3D可視化の実現”. The talk must demonstrate PyVista running live in the browser via WebAssembly, walk the audience through the TypeScript-glue architecture, and show Python/TypeScript code snippets with syntax highlighting. We need to pick a slide tool that lets us embed those live browser demos directly in the deck, keeps the source version-controllable alongside the rest of the repository, and is easy to author and review through the normal PR flow. Which slide tool should we adopt for this talk?

Decision Drivers#

  • Live web demo embedding: The talk’s centerpiece is a live, in-browser PyVista WASM demo. The slide tool must be able to run or embed that demo inside a slide without leaving the presentation context. This is a knock-out criterion.

  • Code syntax highlighting: The deck shows Python and TypeScript code; first-class syntax highlighting with line highlighting and code animations is essential for a technical audience.

  • Version-control friendliness: Slide source must be plain text that diffs and reviews well in Git, so the deck can travel through the same PR flow as code (see ADR-0000).

  • Ease of authoring: The deck must be authorable efficiently with hot-reload preview, so iteration is fast before the talk.

  • Portability: The deck should be presentable offline, exportable to PDF for sharing, and deployable as a static site.

  • Community adoption: Prefer a tool with an active community, documentation, and a healthy ecosystem to reduce risk.

Considered Options#

  • Slidev — Vue-powered presentation framework for developers

  • sphinx-revealjs — Sphinx extension to build reveal.js presentations

  • reveal.js — The HTML presentation framework

  • Marp — Markdown presentation ecosystem

  • Google Slides — Cloud-based WYSIWYG presentation tool

  • Microsoft PowerPoint — Desktop WYSIWYG presentation tool

  • JupyterLab Slides / RISE — Live Jupyter notebook slideshow extension

Decision Outcome#

Chosen option: “Slidev”, because it is the only option that satisfies the knock-out criterion — embedding live web demos — and provides best-in-class code highlighting, Markdown-based version-controllable authoring, and a developer-friendly authoring experience. Slidev is a Vue-based single-page application, so the PyVista WASM demo can be embedded as a live Vue component or iframe and run directly inside a slide.

Consequences#

  • Good, because live PyVista WASM demos can run inside slides via Vue components or iframes, making the talk fully interactive.

  • Good, because slides are authored in Markdown, diffing cleanly in Git and travelling through the same PR review flow as the rest of the repository.

  • Good, because Slidev’s Shiki-based syntax highlighting supports line highlighting, code animations, and code blocks with Monaco editor integration — ideal for a technical talk.

  • Good, because Slidev exports to PDF, PNG, and a standalone SPA, giving us portable fallbacks for offline presenting and sharing.

  • Good, because the deck can be deployed as a static site (e.g. on GitHub Pages) alongside the project documentation.

  • Bad, because Slidev requires a Node.js toolchain, adding a build dependency that the Python-only parts of the project do not need.

  • Bad, because Slidev’s community, while active, is smaller than reveal.js’s or Google Slides’s, so fewer third-party themes and integrations are available.

  • Neutral, because the deck will live in the repository under version control, which is the desired outcome but does require maintaining slide source alongside code.

Confirmation#

Compliance with this decision will be confirmed by:

  1. A Slidev project is initialised in the repository (e.g. under a slides/ directory) with a slides.md entry point.

  2. At least one slide embeds a live PyVista WASM demo (via Vue component or iframe) that renders a 3D plot in the browser during the presentation.

  3. The deck is reviewable through a PR linked to issue #278.

  4. The deck exports successfully to PDF for offline sharing.

Pros and Cons of the Options#

Slidev — Vue-powered presentation framework for developers#

See https://sli.dev/

  • Good, because it is a Vue/Vite-based SPA, so live web demos — the knock-out criterion — can be embedded as native Vue components or iframes and run inside a slide.

  • Good, because it uses Shiki for syntax highlighting with support for line highlighting, diff lines, and code animations, which is ideal for showing Python and TypeScript code.

  • Good, because slides are authored in Markdown with YAML frontmatter per slide, satisfying the version-control-friendliness driver.

  • Good, because it ships a hot-reload dev server (slidev dev) for fast authoring iteration, satisfying the ease-of-authoring driver.

  • Good, because it exports to PDF, PNG, and a standalone SPA, satisfying the portability driver.

  • Neutral, because it requires a Node.js toolchain, which is a new build dependency for this predominantly Python project.

  • Neutral, because its community (~40k GitHub stars) is active and growing but smaller than reveal.js’s.

sphinx-revealjs — Sphinx extension to build reveal.js presentations#

See attakei/sphinx-revealjs

  • Good, because it reuses the project’s existing Sphinx toolchain (docs/conf.py already configures Sphinx + MyST parser), requiring no new build dependency.

  • Good, because slides are authored in reStructuredText or MyST Markdown, which is already enabled in this project, satisfying the version-control-friendliness driver.

  • Good, because it stays within the Python ecosystem, consistent with a predominantly Python project.

  • Good, because the maintainer is a Japanese developer active in the PyCon JP community, offering natural community alignment.

  • Neutral, because it wraps reveal.js, so live demo embedding is iframe-based — functional but less seamless than Slidev’s native Vue component model.

  • Neutral, because code syntax highlighting relies on reveal.js’s highlight.js, which lacks Slidev’s Shiki features (line highlighting, code animations, Monaco integration).

  • Bad, because its community (~129 GitHub stars) is significantly smaller than Slidev’s or reveal.js’s, meaning fewer third-party themes and less community support.

  • Bad, because it lacks a dedicated hot-reload dev server comparable to Slidev’s slidev dev (only sphinx-autobuild is available, which is less tailored to slideshow authoring).

reveal.js — The HTML presentation framework#

See https://revealjs.com/

  • Good, because it can embed live web demos via iframes and custom HTML, partially satisfying the knock-out criterion.

  • Good, because it has built-in syntax highlighting via highlight.js.

  • Good, because it has the largest community (~68k GitHub stars) and a long, proven track record.

  • Good, because it is an HTML/JS framework that deploys as a static site, satisfying portability.

  • Neutral, because while a Markdown plugin exists, authoring is primarily HTML-based, which is more verbose than Markdown-first tools.

  • Bad, because embedding live Vue components is not native — iframes are the main mechanism, which is less seamless than Slidev’s component model.

  • Bad, because the HTML-centric authoring flow is less ergonomic for a Markdown-heavy project than Slidev or Marp.

Marp — Markdown presentation ecosystem#

See https://marp.app/

  • Good, because it is pure Markdown, maximally satisfying the version-control-friendliness and ease-of-authoring drivers.

  • Good, because it exports to PDF, PPTX, and HTML, satisfying portability.

  • Good, because it has built-in syntax highlighting and a clean, minimal authoring experience.

  • Neutral, because it is primarily a Markdown-to-slide converter, not an interactive runtime — live demos must be embedded as iframes.

  • Bad, because it cannot run live Vue components or interactive web content natively, making the live-demo embedding less seamless than Slidev.

  • Bad, because it lacks presenter features like code animations and live component rendering that a technical talk benefits from.

Google Slides — Cloud-based WYSIWYG presentation tool#

  • Good, because it is extremely easy to author with a WYSIWYG editor and requires no toolchain.

  • Good, because it has massive general adoption and seamless cloud collaboration.

  • Neutral, because it can embed external content via “Insert > Embed link,” but support is limited and not designed for live code execution.

  • Bad, because it has no native code syntax highlighting, requiring workarounds like images or third-party add-ons.

  • Bad, because slide source is a binary cloud document, failing the version-control-friendliness driver — the deck cannot be reviewed in a PR.

  • Bad, because embedding a live, interactive WASM demo is unreliable and constrained by the embed sandbox.

Microsoft PowerPoint — Desktop WYSIWYG presentation tool#

  • Good, because it is widely adopted and familiar to a general audience.

  • Good, because it exports to PDF and runs offline, satisfying portability.

  • Neutral, because it supports web add-ins, but these are heavyweight and not designed for live WASM demos.

  • Bad, because it has no native code syntax highlighting.

  • Bad, because slide source is a binary .pptx file, failing the version-control-friendliness driver.

  • Bad, because embedding live, interactive browser content is severely limited.

JupyterLab Slides / RISE — Live Jupyter notebook slideshow extension#

See https://rise.readthedocs.io/

  • Good, because it can execute live Python code in notebook cells during the presentation, which is appealing for a Python audience.

  • Good, because notebook code cells have syntax highlighting built in.

  • Neutral, because notebooks are JSON and can be version-controlled, but diffs are noisy when outputs are saved.

  • Bad, because embedding a live, in-browser WASM application inside a Jupyter slideshow is awkward — the WASM demo is a web app, not a notebook cell, so it would need an iframe workaround.

  • Bad, because RISE is less actively maintained and has a smaller community than the other developer-oriented options.

  • Bad, because the slideshow UX (navigation, transitions, layout control) is more limited than purpose-built slide frameworks.

More Information#

Comparison matrix#

The table below summarises how each option scores against the evaluation criteria. ✓ = strong, ~ = partial, ✗ = weak.

Criterion

Slidev

sphinx-revealjs

reveal.js

Marp

Google Slides

PowerPoint

JupyterLab/RISE

Live web demo embedding

✓

~

~

~

✗

✗

~

Code syntax highlighting

✓

~

✓

✓

✗

✗

✓

Ease of authoring

✓

~

~

✓

✓

✓

~

Portability

✓

✓

✓

✓

~

✓

~

Version-control friendliness

✓

✓

~

✓

✗

✗

~

Community adoption

~

~

✓

~

✓

✓

~