SciPy 2026 is soon, and we are psyched! We have a whole troupe of Posit folks heading to Minneapolis to celebrate open source, scientific computing, and Python tooling.

If you are preparing for your next talk (whether at SciPy or another conference), you might be looking for the most effective way to showcase code and its output in your deck. And, if we do say so ourselves, Quarto is the premier tool for creating polished presentations that shine in scientific contexts.

Why? Because Quarto was designed just for this purpose! As an open-source scientific and technical publishing system, Quarto allows you to craft dynamic content that weaves your narrative together with Markdown and Python code, and then renders them into a single file that elegantly showcases your results. By using a single source file, you don’t have to manually copy and paste code or its outputs. Any changes you make are reflected in the latest version by rerendering the document.

Hopefully, this has piqued your interest! Curious how it looks? We built the deck below in Quarto; keep reading to learn how.

Navigating slides

To advance through the slides, hit Space or →. To go back, hit ←. Click the hamburger menu () in the slide deck to see other options.

Get started with slides in Quarto#

Install Quarto#

We recommend using Positron as your editor, since Quarto is preinstalled. If you are using VS Code, install the Quarto CLI and the Quarto VS Code Extension .

Create a new document#

Open a new folder, enter the Command Palette (Cmd+Shift+P) and search for Quarto: New Quarto document (qmd). Save the file as index.qmd.

Change the format to revealjs#

Your new document will include a YAML header for managing your document’s metadata. You’ll see that the default is set to HTML via format: html:

index.qmd
---
title: "Untitled"
format: html
---

However, Quarto is incredibly versatile, and it can render your work into PDFs, Word documents, and much more! We recommend the reveal.js format for creating aesthetically pleasing code-centric slides. reveal.js also provides a variety of useful features tailored for displaying scientific results and technical workflows.

You can switch your document from HTML to reveal.js by updating the format in your YAML header to format: revealjs:

index.qmd
---
title: "Untitled"
format: revealjs
---

Click the Preview button () at the top left of your editor to see what your presentation looks like!

You can also preview from the command line:

Terminal
quarto preview index.qmd

Build the slides#

From here, we can move on to the fun part: building our slides!

Edit metadata#

As alluded to earlier, we edit the metadata document by modifying the YAML header. You can change the title, add yourself as an author, and add your presentation date:

index.qmd
---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format: revealjs
---

Those values then set up your title slide.

Add your first slide#

Below the YAML header is where you write your slides. Quarto uses Markdown, a text formatting language, for text:

index.qmd
---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format: revealjs
---

Slides are just Markdown and code:

- Write your narrative in **Markdown**
- Weave in **Python** code and its output
- Render it all to one reproducible file

You can control aspects of your presentation by nesting options under revealjs in the YAML header. For example, you can make any list display incrementally by adding incremental: true:

index.qmd
---
title: "Make your SciPy presentation in Quarto"
author:
  - Isabella Velásquez
  - Charlotte Wickham
date: 2026-07-14
format:
  revealjs:
    incremental: true
---

Now as you advance the slides, the bullets appear one at a time.

Add a new slide#

To add a new slide, add a new heading. A Level 1 heading adds a new section, while a Level 2 heading adds a new slide.

index.qmd
# Features for showing code

## Add Python code cells

Continue adding new slides until you’re done!

Add Python code cells#

To add Python code to your slide, put it within a code cell, which is delineated by three backticks ``` and python within curly braces. By default, Quarto reveal.js presentations do not show your code cells, because they assume you are presenting just your output. If you do want to show your code, you can add a cell option, designated by a special comment, #|, followed by the option using YAML syntax. In this case, echo: true lets Quarto know to show the code.

index.qmd
## Add Python code cells

```{python}
#| echo: true
from plotnine import *
from plotnine.data import anscombe_quartet
```

Code output is included#

When you render, Quarto runs the code cells and includes their output right below the code:

index.qmd
## Code output is included

```{python}
#| echo: true
anscombe_quartet.head()
```

Show code without running it#

Some code only makes sense to run live — like %view, which opens your data in Positron’s Data Explorer. To show such code without running it, add the eval: false cell option, which tells Quarto to show the cell but not evaluate it:

index.qmd
## You can show code without running it

```{python}
#| echo: true
#| eval: false
%view anscombe_quartet
```

Add a theme#

The Quarto default look is great, but say you want to add your own theming. You can do that in a single YAML file using brand.yml .

In your root directory, create a file called _brand.yml. Add specifications as listed on the brand.yml documentation site . You can edit the font, colors, and more (add as much or as little as you’d like). Next time you render your slides, the brand will be automatically picked up!

If you’d like a _brand.yml file to get you started, here is one that mimics the SciPy conference style . Put it in the root directory of your presentation, and it will look like this:

Features for showcasing Python code#

You may be thinking, this is great, but I can make slides in any old software! True, but Quarto has specific features that really elevate your audience’s experience.

Code line highlighting#

Sure, you can show a block of code on your slide. But you’re usually talking about a specific line or lines of code at a time. If you want to draw your audience’s attention to a specific section of your code, you can use code line highlighting .

For example, if you want to first highlight line 2, then lines 3 through 4, then line 5, you can add the code-line-numbers cell option:

index.qmd
```{python}
#| echo: true
#| code-line-numbers: "2|3-4|5"
(
    anscombe_quartet
    .groupby("dataset")[["x", "y"]]
    .apply(lambda g: g["x"].corr(g["y"]))
    .round(2).to_frame("correlation")
)
```

Scroll through to see what it looks like:

Show code output in a new slide#

When rendered, the slides will automatically resize based on the content. However, this means if you have a lot of code and a large output (like an image), it will be hard to see both in a single slide.

Luckily, the Quarto developers have thought of this and have the output-location cell option where you designate where the output should show up. For example, to show the output on the new slide, set output-location to slide:

index.qmd
```{python}
#| echo: true
#| output-location: slide
(
    ggplot(anscombe_quartet, aes("x", "y"))
    + geom_point(color="sienna", fill="orange", size=3)
    + geom_smooth(method="lm", se=False, fullrange=True,
                  color="steelblue", size=1)
    + facet_wrap("dataset")
    + labs(title="Anscombe’s Quartet")
    + scale_y_continuous(breaks=(4, 8, 12))
    + coord_fixed(xlim=(3, 22), ylim=(2, 14))
    + theme_tufte(base_family="Futura", base_size=16)
    + theme(
        axis_line=element_line(color="#4d4d4d"),
        axis_ticks_major=element_line(color="#00000000"),
        axis_title=element_blank(),
        panel_spacing=0.09,
    )
)
```

Add a filename and extension#

A subtle (but very helpful) feature of Quarto is the ability to specify the filename and extension of a code block, which you can use if you are talking about different files or programming languages and want to visually distinguish them. Add filename= to your code block:

index.qmd
```{.bash filename="Terminal"}
pip install pandas
```

<br>

```{.python filename="script.py"}
import pandas as pd
```
Code blocks vs. code cells

The . in front of the language in the code above (e.g. .python) signals these are code blocks, not executable code cells. Quarto doesn’t attempt to execute code blocks, but you get nice syntax highlighting based on the language specified.

Extensions for scientific presentation#

So far, we’ve just mentioned features that are built into Quarto; however, one of the most powerful features of Quarto is its extension system . Both the Posit developers and the community have built an incredible ecosystem of extensions that augment what Quarto can do. There are hundreds of extensions (see the Quarto gallery by Mickaël Canouil), but here are a curated few.

QuartoLive extension for interactive Python code blocks#

You no longer have to switch between your slides and your IDE to run code! Using QuartoLive , you can embed interactive Python code blocks. Run the code, edit it, and rerun, all within your Quarto reveal.js presentation.

Usually, the first question asked during a presentation is, “Will the slides be provided?” Evade that question by using the QR code extension , which adds a QR code that the audience can easily scan while they watch so they can find the slides after the presentation is over.

Add accessibility features#

For your audience to be able to read the text on your slides, the font size should probably be larger than you anticipate .

The reveal.js A11y extension provides accessibility features for your slide deck. One nifty feature is the ability to increase the font size on the fly. Enter the menu by pressing A, and then zoom in to what you need.

Publish and share your slides#

After you’ve done the fun work of creating your slides, you’ll want to publish and share them with others. We recommend Posit Connect Cloud , which has a generous free tier for Quarto documents, Streamlit and Shiny apps, and much more.

If you’re working in Positron, the Posit Publisher extension is built in and gives you push-button deployment to Posit Connect Cloud right from your editor (in VS Code, grab it from the Marketplace ).

If not, you can also publish from the command line with quarto publish, which renders your slides and uploads them:

Terminal
quarto publish posit-connect-cloud index.qmd

The slides for this very post are published at cwickham-make-your-scipy-presentation-in-quarto.share.connect.posit.cloud .

Press F to enter full screen, and you’re ready to present!

Welcome to the wonderful world of Quarto slidecrafting#

We hope that this post inspired you to give Quarto presentations a try!

We’ve only scratched the surface — the Quarto reveal.js documentation covers the full set of features for building presentations.

If you are completely new to Quarto, Charlotte’s YouTube video is a great introduction to setting it up, creating a document from scratch, and rendering it.

If you want to see what else is possible, Emil Hvitfeldt is working on a book called Slidecrafting on creating functional and beautiful Quarto reveal.js presentations through theming, layout, interactivity, and extensions.

And definitely look through Mickaël’s Quarto extension gallery to see if other extensions are useful to you. His blog post, Quarto Reveal.js Extensions to Sharpen Your Slides , also has more advanced tricks you can apply to your scientific and technical publications.

Do let us know what you end up creating!