2025 was a big year for PDF accessibility. LaTeX and Typst both released support for PDF tagging and accessibility standards, just in time for new regulations in the EU (June 2025) and US (April 2026).

Quarto 1.9 brings this support to you as a Quarto user.

What PDF Standards Do

Currently LaTeX supports the newer UA-2 standard, and Typst supports the older UA-1 standard. Typst is likely to have UA-2 support later in 2026.

Both standards instruct the PDF renderer to provide screen readers:

• The semantic structure of the text (title, heading, paragraph, figure, etc)
• The natural reading order
• Spatial coordinates for highlighting and assistive navigation
• Required metadata such as title and language

How to enable a PDF Standard in Quarto

In Quarto 1.9, specify a PDF standard for your document or project with pdf-standard

format:
  pdf:
    pdf-standard: ua-2

format:
  typst:
    pdf-standard: ua-1

pdf-standard takes a single standard name or list of standard names. PDF version is used if provided in the list, but otherwise inferred from the standard.

If you specify a PDF standard, Quarto first instructs LaTeX or Typst to use the standard when producing the PDF, and then validates the output PDF against the standard using veraPDF, an open-source PDF validation tool. If veraPDF is not installed, you’ll get a warning but still receive a PDF – it just won’t be validated.

1

quarto install verapdf

When a document passes validation, you’ll see output like:

[verapdf]: Validating my-document.pdf against PDF/UA-2... PASSED

Creating accessible PDFs

Quarto’s Markdown-based workflow handles many accessibility requirements automatically:

• Document metadata (title, author, date, language) flows into the PDF’s built-in metadata fields.
• The semantic structure of Markdown satisfies PDF tagging requirements. For Typst this is always enabled; for LaTeX it is enabled when you specify a standard that requires it.
• Alt text for images is carried through to the PDF for screen readers.

But you do need to make sure your document has:

• A title in the YAML front matter.
• Alt text for every image, specified with fig-alt. See Figures for details.

See the LaTeX and Typst documentation for more details.

If your document fails validation

LaTeX does not perform validation during PDF generation, so if veraPDF validation fails, that’s a warning, and you still get a partially-accessible PDF as long as you use pdf-standard: ua-2.

Typst fails and does not produce a PDF if its built-in validation fails during PDF generation. However, in Typst all accessibility features are on by default, so you can generate a partially-accessible PDF by rendering without pdf-standard.

Current limitations

We ran our test suite – 188 LaTeX examples and 317 Typst examples – to find where Quarto PDFs do not yet pass UA-1 or UA-2, and where users will need to change their documents.

LaTeX

Margin content is the biggest structural blocker. If you use .column-margin divs, cap-location: margin, reference-location: margin, or citation-location: margin, the resulting PDF will not pass UA-2. The underlying sidenotes and marginnote LaTeX packages do not cooperate with PDF tagging .

(Margin content does work with Typst and passes UA-1 – see Typst Article Layout .)

There are smaller upstream issues in Pandoc, LaTeX, and LaTeX packages, documented here .

Typst

In our tests, Typst catches every UA-1 violation, and fails to generate the PDF. veraPDF did not detect any violation that Typst did not.

Typst also seems to do a very good job of generating UA-1 compliant output by default – almost all errors were due to missing titles or missing alt text.

However, we did discover that Typst books are not yet compliant. There is a structural problem with the Typst orange-book package and we’ll work with the maintainers to correct it.

Conclusion

Although Typst currently targets an the earlier UA-1 standard, today it seems to offer better PDF accessibility than LaTeX.

We expect PDF accessibility support to improve through the LaTeX ecosystem throughout 2026 as awareness of UA-2 and the new regulations spreads.

If you run into accessibility issues with PDF output, please search the Quarto discussions and open a new one with the accessibility label for any issues you discover.

Talks included in the playlist, broken up into a few categories for easier browsing, are as follows:

Quarto Extensions & Advanced Features

Speakers	Title	Thumbnail
Carlos Scheidegger (Quarto Team)	What we’re doing to make Quarto fast(er)
Christophe Dervieux (Quarto Team)	Beyond the Basics: Expanding Quarto’s Capabilities
Garrick Aden-Buie	Theming Made Easy: Introducing brand.yml
Gordon Woodhull (Quarto Team)	Brand YML and Dark Mode in Quarto
JooYoung Seo	maidr: Empowering Accessible, Multimodal Data Science with Quarto

Workflow Automation & Reporting

Speakers	Title	Thumbnail
Becca Krouse	Instant Impact: Developing {docorator} to Simplify Document Production
John Paul Helveston	surveydown: A Markdown-Based Platform for Interactive Surveys
Keaton Wilson	Using Quarto to Improve Formatting and Automation

Teaching & Education

Speakers	Title	Thumbnail
Claus Wilke	Teaching data visualization with R entirely in Quarto
Mine Çetinkaya-Rundel (Quarto Team)	Leveraging LLMs for student feedback in introductory data science courses
Ted Laderas	Empowering Learners with WebR, Pyodide, and Quarto

Business, Collaboration & Publishing

Speakers	Title	Thumbnail
Andrew Heiss and Gabe Osterhout	Election Night Reporting Using R & Quarto
Bill Pikounis	Quarto for Business Collaboration and Technical Documentation in Word docx format
Timothy Keyes	Trust, but Verify: Lessons from Deploying LLMs

We hope you enjoyed this look back at the Quarto sessions from posit::conf(2025). Every year the community brings new ideas, new tools, and new ways of working — and we’d love to see your voice added to the mix. We hope to see you next year, and maybe even see you up on stage sharing your own work at posit::conf!

All materials from both workshops are available online. You can access the full workshop websites, source code, and exercises to learn at your own pace or adapt them for your own teaching; they are both released with a CC BY-SA 4.0 license.

Branded Websites, Presentations, Dashboards, and PDFs with Quarto

Workshop website Source Exercises

Led by Isabella Velásquez , Posit, PBC and Sara Altman , Posit, PBC.

Designed for data scientists, analysts, and content creators, this immersive session will teach you how to craft cohesive reports and presentations while refining your workflow with Quarto’s latest features.

You will learn how to create dynamic websites, professional PDF documents, engaging presentations, and interactive dashboards using Quarto. This workshop highlights Quarto’s powerful theming capabilities, including the new support for brand.yml, which ensures that your work maintains a professional and cohesive style across all formats.

By the end of the session, you’ll be equipped to:

• Build and deploy Quarto websites.
• Generate professional presentations and PDF reports.
• Create interactive dashboards for data visualization and reporting.
• Use brand.yml to define and apply consistent theming across all outputs.

Whether you’re looking to enhance your personal projects or streamline organizational outputs, this workshop will equip you with the tools to create polished, professional results.

Extending Quarto

Workshop website Source Exercises

Led by Mine Çetinkaya-Rundel , Posit, PBC + Duke University and Charlotte Wickham Posit, PBC.

In this workshop, we will dive deep into ways of customizing your Quarto outputs with tooling beyond built-in features. This workshop is designed for data scientists, analysts, and technical writers looking to extend Quarto’s capabilities to suit their unique workflows better.

Participants will learn how to create custom extensions, including new formats, templates, and filters, to enhance their document production process. Through hands-on exercises and real-world examples, you’ll gain practical skills in:

• Developing and integrating custom formats to support diverse outputs while reducing repetition across projects.
• Substituting Quarto’s templates with your own to customize formats beyond the built-in options.
• Implementing filters to automate and streamline content transformation.

By the end of the workshop, you will be able to leverage Quarto’s extensibility to create powerful, tailored solutions for your documentation needs. Whether you have just worked on a few Quarto projects or are an everyday user, this workshop will equip you with the tools and knowledge to take your document workflows to the next level.

I’m absolutely thrilled to announce Quarto Wizard 1.0.0, a groundbreaking extension for Visual Studio Code and Positron that transforms how you interact with the Quarto ecosystem. If you’ve ever found yourself wrestling with command-line extension management or struggling to discover the perfect template for your project, this tool is about to become your new best friend.

Install it today from the VS Code marketplace or Open VSX Registry :

Quarto has revolutionised scientific and technical publishing by enabling reproducible documents that seamlessly blend code, narrative text, and visualisation. However, one persistent friction point has been managing the rich and ever-growing ecosystem of extensions and templates—until now.

Quarto Wizard: Your GUI for Quarto extensions

I designed Quarto Wizard to address a fundamental challenge I’ve observed in the community: whilst Quarto’s command-line interface is powerful, many users prefer visual interfaces for discovering, installing, and managing extensions.

Seamless IDE integration

Quarto Wizard integrates beautifully with both the VS Code and Positron ecosystems, appearing as a dedicated icon in the Activity Bar alongside your other development tools. This provides instant access to extension management without disrupting your coding flow, whether you’re in Microsoft’s VS Code or Posit’s new Positron IDE.

The solution is multi-modal installation: you can now install extensions through multiple pathways that suit your workflow: from the command line, through the web directory, or via the Quarto Wizard GUI in your IDE.

Intelligent extension management

The “Recently Installed Extensions” feature helps track your workflow and easily reproduce project setups across different environments. This is invaluable for researchers collaborating across multiple machines or teaching workshops where consistent setups are essential, regardless of whether team members use VS Code or Positron.

What makes this particularly powerful is that Quarto Wizard tracks which extensions were installed through its interface by adding source metadata to the _extensions.yml file, enabling seamless updates and removals.¹ This source tracking transforms extension maintenance from manual archaeology into an effortless workflow. The extension maintains detailed metadata about installed extensions, enabling batch operations and dependency tracking. The Explorer View provides a comprehensive overview of all installed extensions with visual indicators for updates and management options.

Template workflow simplified

Beyond extension management, I’ve designed Quarto Wizard to ease the process of discovering and using document templates. Once you’ve selected a template, Quarto Wizard lets you customise and save the document. The file is not created until you confirm, allowing you to adjust the filename and location.

Powered by a comprehensive extension directory

A curated catalogue of 250+ extensions

At the heart of Quarto Wizard lies the Quarto Extensions directory (m.canouil.dev/quarto-extensions/) , a comprehensive listing I maintain that catalogues extensions from across the entire Quarto ecosystem.

To date, it includes over 250 extensions contributed by the community, covering a vast array of functionalities from citation management to interactive visualisations. This directory powers Quarto Wizard’s discovery features, providing rich metadata about each extension including descriptions, licensing, version tags, and GitHub stars. The directory is continuously updated through GitHub’s API, ensuring you always have access to the latest extensions from the community.

One-click installation from the web

What’s particularly exciting is that you can install extensions or use templates directly from the website itself. Each extension listed at m.canouil.dev/quarto-extensions/ includes multiple installation options: traditional command-line via terminal, or one-click installation through Quarto Wizard in VS Code, Positron, or VSCodium. Simply browse the directory, find the extension you need, and choose your preferred installation method. The website generates the appropriate commands or launches your IDE directly. This flexibility means teams with mixed technical backgrounds can all access the same powerful extensions.

For example, you might want to add the Iconify extension to access over 200,000 open source vector icons in your documents, or the Animate extension to bring your presentations to life with CSS animations. Perhaps the Spotlight extension for Reveal.js catches your eye for creating dramatic Reveal.js presentations that highlight your mouse position. All of these extensions (and hundreds more) are just a click away.

Template discovery made easy

Additionally, the Quarto Extensions directory excels at template discovery and deployment which is enhanced with powerful filtering options: you can sort by recently updated, filter by popularity, browse by categories (i.e., Shortcodes, Filters, Formats, Projects, Reveal.js Plugins), or search for specific functionality. Each extension clearly indicates whether it’s a template with “Use” buttons alongside “Install” options.

Whether you’re crafting an academic paper using journal-specific formats, creating professional invoices with my Invoice extension template, or building stunning presentations with themed templates like my Reveal.js Coeos extension, browsing available templates becomes as simple as scrolling through a curated gallery.

This directory creates a seamless experience: instead of manually searching GitHub repositories or memorising command-line syntax, you can browse hundreds of extensions with detailed information at your fingertips. This transforms extension discovery from a treasure hunt into a curated shopping experience.

Addressing real workflow friction

I designed Quarto Wizard and the extension directory at m.canouil.dev/quarto-extensions to directly tackle several persistent Quarto pain points I’ve encountered:

• Discovery challenges: Finding relevant extensions in the growing ecosystem becomes intuitive through the visual browser interface powered by the comprehensive extensions directory.

• Command-line intimidation: Users who prefer graphical interfaces no longer need to memorise terminal commands.

• Document setup complexity: Template-based document initialisation eliminates manual YAML configuration.

• Extension maintenance: Updates, removals, and dependency management become point-and-click operations rather than command-line archaeology.

• Source tracking: Quarto Wizard automatically adds source metadata to installed extensions, enabling future updates and proper version management.

• Stable installations: Quarto Wizard installs extensions from GitHub releases/tags by default instead of the potentially unstable default branch, ensuring more reliable installations and more replicable environments.

Perfect for diverse use cases

The extension shines across multiple scenarios:

• Academic researchers can quickly install citation management tools, bibliography extensions like Multibib or Section Bibliographies , and journal-specific formatting, whether they’re using VS Code or Positron for their analysis work.

• Data scientists gain easy access to computational extensions like WebR , visualisation tools, and interactive notebook capabilities. This is particularly powerful in Positron, which is designed specifically for data science workflows.

• Technical writers can browse and install extensions for enhanced typography with for example the Highlight Text extension for multi-format text highlighting, code highlighting, and advanced formatting options of their Reveal.js presentations with Reveal.js Editable extension in their preferred IDE.

• Workshop instructors can ensure all participants have consistent extension setups through guided installation processes, regardless of whether attendees prefer VS Code or Positron.

Future-ready architecture

I’ve built Quarto Wizard on robust foundations that ensure long-term reliability. The extension integrates with GitHub’s API through the Quarto Extensions directory for real-time metadata, includes attestation verification for security, and maintains full compatibility with both VS Code and Positron environments.

The modular architecture allows for future enhancements whilst maintaining backwards compatibility. As the Quarto ecosystem continues expanding and as Positron evolves alongside VS Code, Quarto Wizard will support new extension types and project management workflows in both environments.

Getting started today

Begin your Quarto Wizard journey by installing the extension from the VS Code marketplace, the Open VSX Registry, or directly through your IDE’s Extensions view. Once installed, the Quarto Wizard icon appears in your Activity Bar, providing immediate access to extension management and project tools.

You have multiple paths to explore Quarto extensions:

1. Through Quarto Wizard: Click the Quarto Wizard icon in your IDE’s Activity Bar and browse the integrated catalogue.
2. Via the web directory: Visit m.canouil.dev/quarto-extensions where you can browse all extensions and install them directly from the website. Each extension offers installation buttons for Quarto Wizard, VS Code, Positron, VSCodium, or traditional terminal commands.
3. Traditional command-line: Use the familiar quarto add commands if you prefer.

Try installing your first extension: perhaps Iconify extension for comprehensive icon support or GitHub for seamless GitHub linking. Whether you click “Install” on the website, use Quarto Wizard’s interface, or type commands in the terminal, the choice is yours. The difference in experience compared to traditional command-line installation is immediately apparent, especially when browsing the visual catalogue with its filtering options, popularity indicators, and rich metadata.

I believe Quarto Wizard represents a significant step forward in making Quarto’s powerful publishing capabilities accessible to users regardless of their comfort level with command-line tools or their choice of IDE. By providing intuitive visual interfaces for complex operations, Quarto Wizard democratises access to the rich Quarto ecosystem whilst maintaining the flexibility and power that makes Quarto exceptional.

The future of reproducible publishing is here, and it’s more accessible than ever in whichever modern development environment you prefer.

Quarto 1.8 improves support for light and dark brand colors and logos, brand extensions for sharing brands across Quarto projects, HTML accessibility checks powered by Axe-core, and access to more information about execution context from your code cells. You can read about these improvements and some other highlights below. You can find all the changes in this version in the Release Notes .

Dark and light colors and logos in brand

You can now specify light and dark versions of any colors or logo in a brand specification:

_brand.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

color:
  foreground:
    light: "#333333"
    dark: "#EEEEEE"
  background:
    light: "#EEEEEE"
    dark: "#333333"
logos:
  medium:
    light: logo.png
    dark: logo-white.png         

This works in _brand.yml files as well as brand specified directly in document metadata. You can also present in dark mode by specifying brand-mode: dark in your format: revealjs presentations.

Read more in the updated Guide > Brand :

• Light and dark colors
• Light and dark logos
• Brand mode

Brand extensions

Share brand definitions and assets across Quarto projects with a brand extension.

Get started with:

Terminal

quarto create extension brand

Read more in Extensions > Brand , and keep an eye out for other ways to reuse and share your brand in future releases.

Accessibility checks for HTML

You can add accessibility checks using the Axe-core engine to HTML documents (format: html, revealjs and dashboard) with the new axe option.

For example, you can get a summary of violations right in your document preview:

Read about your options in HTML Accessibility Checks

We know accessability is a big concern for many of our users, and more improvements will be coming in future releases.

Accessing execution information

Quarto sets the QUARTO_EXECUTE_INFO environment variable, which allows you to access information about execution context from code cells.

Read the JSON file located at QUARTO_EXECUTE_INFO and access properties such as document-path, format, metadata and more:

1
2
3

library(jsonlite)
execute_info <- read_json(Sys.getenv("QUARTO_EXECUTE_INFO"))
execute_info$`document-path`

1
2
3
4
5
6

import json
import os

with open(os.getenv("QUARTO_EXECUTE_INFO")) as f:
    execute_info = json.load(f)
execute_info["document-path"]

1
2
3
4

using JSON

execute_info = JSON.parsefile(ENV["QUARTO_EXECUTE_INFO"])
execute_info["document-path"]

Read more in Access execution settings from code cells .

Other Highlights

• Access metadata and variables in filters and shortcodes: Use the new quarto.variables.get() and quarto.metadata.get() APIs.

• The default LaTeX engine is now lualatex.

Dependency updates:

• mermaidjs updated to 11.6.0.
• Bootstrap icons updated to v1.13.1
• QuartoNotebookRunner in julia engine updated to 0.17.3

Acknowledgements

We’d like to say a huge thank you to everyone who contributed to this release by opening issues and pull requests:

Aariq , AndreasThinks , ArthurData , Blake-Madden , ColinFay , DCEW , DanStuder , Data-Wise , EllaKaye , EmilHvitfeldt , FrankwaP , GabrielCoffee9 , GeorgRamer , Gewerd-Strauss , GuillaumeDehaene , HarunCelikOtto , HayesJohnD , Joao-O-Santos , MateusMolina , MichaelHatherly , PeteArm , Selbosh , SergeCroise , SrShelo , VisruthSK , Vistales , abhiaagarwal , aborruso , adamblake , adamiturabi , alastairrushworth , albertomercurio , alecloudenback , alex-r-bigelow , allefeld , alyst , andrewheiss , andrewpbray , austin-hoover , batpigandme , bauerj , benkeks , benz0li , bkowshik , blackerby , boshek , brandonmontez , bryce-carson , carschandler , christopherkenny , cl-roberts , cmadland , co1emi11er2 , coatless , cpcloud , daxkellie , dixslyf , dkapitan , econmaett , edavidaja , edvinsyk , ethanwhite , fermarsan , fredguth , fuhrmanator , gadenbuie , georgestagg , ghisvail , ghost , github-actions[bot] , glin , gregswinehart , gwbrck , halleysfifthinc , hansfn , hchulkim , holtzy , htbunn , hturner , hugetim , hutch3232 , iagopinal , ihrke , jameslairdsmith , jdfoote , jeremy9959 , jfy133 , jkrumbiegel , jmgirard , jonpeake , jvcarli , jxpeng98 , kandolfp , kapsner , kathsherratt , kazuyanagimoto , kevinah95 , kippandrew , koldle , lachlansimpson , lbm364dl , leovuong , lostmygithubaccount , lu-kas , lukmanaj , lwjohnst86 , maelle , mahmudstat , masud90 , melaniewalsh , mfisher87 , mipmip , mpr1255 , multimeric , musvaage , mvuorre , nathanj3 , nessan , nichtich , odysseu , ofkoru , olivroy , oyvindbso , pagiraud , parmsam , peter-gy , pm-gusmano , produnis , rabyj , raffaem , randyzwitch , rben01 , rossbowen , rundel , ryanzomorrodi , ryjohnson09 , s2t2 , salim-b , samcarter , serialc , sgelzenleuchter , skriptum , spaette , stragu , sun123zxy , sverrirarnors , tecosaur , temospena , thatchermo , topepo , tylere , winniehell , wklimowicz , yogabonito , youcc , yves-amevoin , yyzeng .

The lightbulb emoji in the listing and social card image for this post comes from OpenMoji– the open-source emoji and icon project. License: CC BY-SA 4.0

GitHub Codespaces is a cloud-powered, on-demand development environment that runs either in your browser or in Visual Studio Code via the GitHub Codespaces extension . It eliminates the need for lengthy local setup by providing a fully configured development container, complete with all necessary dependencies and tools. This means that whether you’re an instructor or a developer, you can start coding immediately with a consistent environment tailored to your specific project, right on your web browser.

More importantly, the participants of your workshops can use GitHub Codespaces just as easily as you can. With Codespaces, you and your participants all work on identical environments, minimising the “it doesn’t work on my machine” problems we are all too aware of.

In this post, I am assuming the case of a workshop instructor and a room full of participants with different laptops and operating systems. Codespaces are also useful for development, though, as you will notice reading on.

The Power of Combining Quarto CLI with Codespaces

Imagine a world where your participants are instantly equipped with the same environment with all the tools, libraries, and sample projects ready to go in the cloud. That’s the magic of using Codespaces:

1. Immediate Onboarding: Workshop participants or students can bypass the hassle of local setup. They simply launch a Codespace (running on their web browser of choice, independently of operating system), and the pre-configured environment is available immediately.

2. A Consistent Environment: Ensuring that everyone has the same tools and dependencies can be challenging. Codespaces lets you pre-define your environment with container configurations, reducing the risk of discrepancies in software versions or settings.

3. Reproducible Workflows: Whether you’re teaching a data science workshop or collaborating on a research paper, reproducibility is crucial. Because GitHub Codespaces uses the Dev Container specification , you can ensure that your code can be run in the same environment. When participants are ready to run their projects locally, they can use Codespace to build an equivalent Docker container.

GitHub provides “deep link” to Codespaces, allowing you to create a link you can share with your students or workshop participants.

For example, the quarto-codespaces repository provides several Dev Container / Codespaces configurations. The following link will create a new Codespace using the .devcontainer/universal/devcontainer.json configuration file instead of the default .devcontainer/devcontainer.json file.

1

[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/mcanouil/quarto-codespaces?quickstart=1&devcontainer_path=.devcontainer%2Funiversal%2Fdevcontainer.json)

The link can include a specific branch, a particular file, or even a specific line in a file, allowing you to guide participants directly to the relevant content and setup. By doing nothing more than clicking that one link, participants create or resume an existing execution environment.

Setting Up Your Own Quarto-Codespaces Environment

If you’re considering using Codespaces with Quarto CLI for your next workshop or teaching module, here’s how to get started:

Leverage the example provided by the quarto-codespaces repository or create your own Codespaces using the default .

Use an Existing Docker Image

The easiest way to get started is to use an existing Docker image that has Quarto CLI and all the dependencies you need. There are several pre-built images available with or without the Quarto CLI:

• Official Docker images:
  • ghcr.io/quarto-dev/quarto
  • ghcr.io/quarto-dev/quarto-full
• Community Docker images:
  • ghcr.io/mcanouil/quarto-codespaces
• Default Codespaces image:
  • mcr.microsoft.com/devcontainers/universal

You can use any of these images as a base for your Codespace. Inside the .devcontainer/devcontainer.json file, you can specify the image you want to use. The .devcontainer/devcontainer.json file serves as the blueprint for your Codespace.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

{
  "name": "My Workshop Setup",
  "image": "ghcr.io/mcanouil/quarto-codespaces:latest",
  "remoteUser": "vscode",
  "customizations": {
    "vscode": {
      "extensions": [
        "quarto.quarto",
        "mcanouil.quarto-wizard"
      ]
    },
    "codespaces": {
      "openFiles": [
        "exercises/intro-to-quarto.qmd",
        "exercises/computation.qmd"
      ]
    }
  }
}

Line 3

The Docker image is specified in the image field. It’s built using a Dev Container specification that you can find in .github/.devcontainer .

Line 8

The quarto extension for Visual Studio Code / Positron to provide support for Quarto documents.

Line 9

The quarto-wizard extension for Visual Studio Code / Positron to provide assistance in managing Quarto extensions

Line 13

The openFiles field specifies the files to open when the Codespace is created. This is useful for guiding participants to the right files or folders. See the Codespaces documentation for more information.

Configure the Development Container

You can fork the quarto-codespaces repository as a starting point for your own Codespaces. This repository includes the Dev Container configuration file (i.e., .devcontainer/devcontainer.json) that instruct Codespaces on how to set up an environment complete with Quarto CLI and other essential tools.

The .devcontainer/devcontainer.json configuration file ensures that every instance of your Codespace is identical, capturing everything from the Quarto CLI version to additional libraries or extensions you might need.

The quarto-codespaces repository is a great starting point as it provides a prebuilt Docker image with the latest Quarto CLI, Python, R, and Julia installed (i.e., ghcr.io/mcanouil/quarto-codespaces using .github/.devcontainer/devcontainer.json ).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

{
  "name": "Quarto",
  // "image": "buildpack-deps:jammy-curl",
  "build": {
    "dockerfile": "./Dockerfile",
    "context": ".",
    "args": {
      "VARIANT": "jammy"
    }
  },
  "remoteUser": "vscode",
  "features": {
    "./quarto-computing-dependencies": {
      "rDeps": "rmarkdown,languageserver,nx10/httpgd@v2.0.3,prompt,lintr",
      "pythonDeps": "jupyter,papermill",
      "juliaDeps": "IJulia"
    },
    "./uv": {
      "version": "latest"
    },
    "ghcr.io/rocker-org/devcontainer-features/quarto-cli:1": {
      "version": "release",
      "installTinyTex": "true",
      "installChromium": "false"
    }
  },
  "customizations": {
    "vscode": {
      "extensions": [
        "quarto.quarto",
        "mcanouil.quarto-wizard",
        "REditorSupport.r",
        "Posit.air-vscode"
      ],
      "settings": {
        "r.rterm.option": [
          "--no-save",
          "--no-restore-data",
          "--quiet"
        ],
        "[r]": {
          "editor.defaultFormatter": "Posit.air-vscode",
          "editor.formatOnSave": true
        }
      }
    }
  }
}

Line 3

The image field specifies the base image for the container. You can customise this to suit your needs.

Line 12

The features section allows you to add additional tools or libraries. See the Dev Container Features available for a comprehensive list of available features.

Line 13

The quarto-computing-dependencies feature is a “local” custom feature that installs the computing dependencies: R, Python, and Julia. This is a great way to ensure that your Codespace has everything it needs to run Quarto documents.

Line 18

The uv feature installs the uv tool to manage Python packages and project dependencies.

Line 21

The quarto-cli feature installs the Quarto CLI. You can specify the version you want to install, and it will be automatically downloaded and installed in your Codespace. You can see the code for this feature in the source repository: https://github.com/rocker-org/devcontainer-features/tree/main/src/quarto-cli .

Line 27

The customizations section allows you to specify settings and extensions for Visual Studio Code.

You can also add additional features to the devcontainer.json to suit your needs or start directly using the image as is as shown in Use an Existing Docker Image .

For example, you might want to add additional R packages or Python libraries. You can do this by using the quarto-computing-dependencies custom feature and changing the rDeps, pythonDeps, and juliaDeps fields to include the packages you want to install globally, or by using the postStartCommand field to run a script that installs the packages you need.

1
2
3
4
5
6

{
  "name": "My Workshop Setup",
  "image": "ghcr.io/mcanouil/quarto-codespaces:latest",
  "remoteUser": "vscode",
  "postStartCommand": "uv venv && source .venv/bin/activate && uv pip install -r requirements.txt"
}

You can also use the postStartCommand field to run a script that installs the packages you need.

1
2
3
4
5
6

{
  "name": "My Workshop Setup",
  "image": "ghcr.io/mcanouil/quarto-codespaces:latest",
  "remoteUser": "vscode",
  "postStartCommand": "bash ./init-env.sh --what all --force"
}

Line 5

The postStartCommand field specifies a command to run after the Codespace is started. In this case, it runs the init-env.sh script from quarto-codespaces repository with the --what all and --force options.

Benefits for Workshops and Teaching

When it comes to educational sessions, consistency and ease-of-use are paramount. Pairing Codespaces with Quarto CLI brings many direct benefits to a teaching environment:

• Streamlined Onboarding: Students and workshop attendees can get right to work without spending time installing and configuring local environments.
• Live, Interactive Sessions: Instructors can demonstrate live edits to Quarto documents. Changes can be rendered instantly and reflect in each participant’s environment: perfect for a hands-on, interactive learning experience.
• Collaboration and Version Control: All changes can be recorded in Git, making it easy to track progress, handle peer reviews, and manage collaborative projects, all within a single hosted environment.
• Elimination of “Dependency Hell”: With containerised development, all attendees work from the same baseline, ensuring that version conflicts or missing libraries don’t derail a session.

Final Thoughts and Future Directions

Whether you’re running a workshop, teaching a class, or collaborating on research, using Codespaces can reduce setup hassles, foster reproducibility, and encourage interactive learning.

In addition to the benefits mentioned above, other features further enhance your experience with Codespaces and Quarto CLI:

• Automated Pipelines: Integrating CI/CD tools to automatically validate Quarto document renders and catch errors using the exact same environment. See GitHub Actions: Running jobs in a container
• Real-Time Co-Editing Features: Enhancing collaborative sessions with simultaneous multi-user editing directly in Codespaces. See GitHub Codespaces: Real-time collaboration

This post covered the basics of using Codespaces and Quarto together, but there’s much more to Codespaces. Learn more by consulting their documentation .

Happy teaching!

Disclaimer

GitHub Codespaces is a product of GitHub, Inc. and comes with a quota of free usage, including CPU hours and storage. Be sure to check the GitHub Codespaces billing documentation and your current GitHub plan to avoid unexpected charges. If you are a student or an educator, you can explore the GitHub Education program and GitHub Classroom .

Acknowledgements

Thanks to Carlos Scheidegger , Julia Silge , and James J. Balamuta for their feedback and suggestions on this post.

We are especially enthusiastic about the improvements 1.7 brings to dark mode: you can now specify light and dark themes via brand, map computational outputs to themes, and have your website theme follow your viewer’s preference. To celebrate these changes, this site, quarto.org , now has a light and dark mode. Toggle the switch in the navigation bar () to see the difference.

You can read about these improvements and some other highlights below. You can find all the changes in this version in the Release Notes .

Dark Mode Improvements

Specify light and dark themes via brand.yml

You can now specify a light and dark brand. For example, at a project-level you can provide two brand files:

_quarto.yml

1
2
3

brand:
  light: light-brand.yml
  dark: dark-brand.yml

Standalone HTML pages, websites, and dashboards will gain a light switch toggle allowing viewers to switch between the light and dark themes.

By default Typst documents will use the light brand, but you can set the brand-mode option to use the dark brand instead:

document.qmd

1
2
3
4
5

---
format:
  typst:
    brand-mode: dark
---

Read about other ways to set a light and dark brand in Guide > Brand .

Map computational outputs to themes

A new code cell option, renderings, allows you to indicate which computational outputs should be displayed in light and dark mode. Create light and dark versions of your outputs in a single code cell, and add the option renderings to specify the order of the outputs. For example, this cell creates a light version of a plot, then a dark version:

1
2
3
4
5
6
7

```{r}
#| renderings: [light, dark]
plot(1:10) # Shown in `light` mode

par(bg = "#000000", fg = "#FFFFFF", col.axis = "#FFFFFF")
plot(1:10) # Shown in `dark` mode
```

Both outputs are produced, but you’ll only see the one corresponding to the current state of the light switch. Toggle the switch in the navigation bar to see the image change to reflect the theme.

Respect user color scheme

Set the new html format option respect-user-color-scheme to true if you would like your site to honor the viewer’s operating system or browser preference for light or dark mode:

_quarto.yml

1
2
3

format:
  html:
    respect-user-color-scheme: true

Other Highlights

• Typst updated to 0.13.0

• Pandoc updated to 3.6.3

• New version shortcode to insert the version of Quarto used to build your document:

  Rendered with Quarto {{</* version */>}}

  Rendered with Quarto 1.9.30

• Updated LaTeX and Beamer template partials:

  • LaTeX partials
  • Beamer partials

  These changes reflect the updates made in Pandoc 3.5 to separate the LaTeX and Beamer document templates and introduce some additional partials for both. If you have custom formats that provide custom templates or partials, you may need to update them to work with the new partials.

• Improvements to the julia engine:

  • juliaup integration : Use specific versions of Julia in your notebooks.

  • R and Python support : Include {r} and {python} executable code cells via the RCall and PythonCall packages.

  • Caching : Save time rendering long-running notebooks by caching results.

  • Revise.jl integration : Automatically update function definitions in Julia sessions.

Acknowledgements

We’d like to say a huge thank you to everyone who contributed to this release by opening issues and pull requests:

AndreasThinks , ArthurData , BrendonChau , DanStuder , DavidFirth , Eli-78-fas , EllaKaye , EmilHvitfeldt , EvoArt , FMKerckhof , FrankwaP , JanPalasek , Jocarnail , MHellmund , MichaelHatherly , Noghpu , PeneLoopy , Rafnuss , SergeCroise , TonyFly3000 , actuaristai , alex-r-bigelow , andrewheiss , ant-durrant , antoine4ucsd , arnaudgallou , aronatkins , arthurgailes , bkowshik , boshek , cbrnr , cl-roberts , cmadland , coatless , deepayan , devmcp , dhimmel , dkapitan , dmenne , eamcvey , edavidaja , fredguth , fuhrmanator , gadenbuie , github-actions[bot] , glin , gwbrck , hchulkim , hguturu , hturner , ihrke , jdutant , jenslaufer , jkrumbiegel , jmgirard , joelostblom , kandolfp , kapsner , kazuyanagimoto , kdheepak , kingo55 , knuesel , kubu4 , kv9898 , kylie-foster , loneguardian , lwjohnst86 , ma2048 , markjholmes , maurosilber , mipmip , mroavi , mroberts1 , msh855 , mvuorre , nathanj3 , odysseu , parmsam , peter-gy , pvelayudhan , raffaem , robmcd , ryanzomorrodi , stragu , sun123zxy , t-kalinowski , temospena , tjni , torven-schalk , turcotte , wenyaoliu , yhkee0404 .

Additional links:

• Quarto 1.6 release post
• Download Positron
• Quarto’s _brand.yml documentation

There may be times when you would like to single-source content across multiple pages/files to reduce the risk of errors, produce consistent content that is easy to maintain, and ultimately save valuable time. Quarto (an open-source technical publishing system), provides an Includes feature (the equivalent of an R Markdown “child” document) that allows you to reuse content across multiple documents/files/pages.

To achieve this, simply create chunks of content (text, tables, code, callouts, images, etc.) and then insert it using the Include shortcode: {{< include _content.qmd >}}.

Typically, you must keep your content general enough so it can be reused in several places. In other words, if you needed to add a name or an image that is specific to that file, you would assume that you wouldn’t be able to use an include, or you would have to use several smaller includes sewn into uniquely written content.

But what if you need your single-sourced content to be more specific? You can use Includes with meta shortcode (variables) to add precise values defined at the file level.

Walkthrough example

Let us walk you through an example of how to achieve this.

Before you begin:

• Quarto version 1.5+ was used for this walkthrough example.
• This has been tested with both new and existing Website projects.
• A var shortcode enables you to insert content from the project or file level.
• The meta shortcode allows you to insert content from Pandoc metadata (e.g., YAML at the top of the document and/or in _quarto.yml).
• As you preview your site, pages will be rendered and updated. However, if you make changes to global options (e.g. _quarto.yml or included files) you need to fully re-render your site to have all of the changes reflected. Consequently, you should always fully quarto render your site before deploying it, even if you have already previewed changes to some pages with the preview server.

Create the content:

Here is an example of a file with content we want to reuse across several pages.

1

In this document, we cover facts that are unique to the state, like the state's population, its flower, and animal.

This content is general enough to use as each state’s introduction but lacks the facts that are unique to each state. So, we could insert the Include into each state’s file and then add specific content that is unique to the state:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

---
title: New York
---

{{< include _snippets/state-intro.qmd >}}

New York has a geographical size of 54,555, making it the 27th largest state with an estimated population size of 19.8 million.

The state's flower is the Rose, as shown below:

![](images/ny/flower.png)

Why are we doing this?

Instead of copying and pasting this content into each file, and then updating it with each state’s fact (which introduces a higher risk of making an error), we can use meta variables to insert specific values.

Let’s execute

First, I create a file within my _snippets directory named facts.qmd. Throughout the file, I am going to insert a unique meta variable for each occurrence that I want the content to be specific to the state:

1

{{< meta state >}} covers approximately {{< meta square-miles >}} making it the {{< meta size-rank >}} largest state in the United States. As of 2023, {{< meta state >}} has an approximate population of about {{< meta population >}}.

I can define each of the meta variables within the individual file that I plan on reusing this content. So, in my ny.qmd file, I define each variable in the YAML metadata. Then, insert the facts.qmd file with the undefined meta shortcodes using an include:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

---
title: New York
state-abbr: ny
state: New York
size-rank: 27th
square-miles: 54,555
population: 19.8 million
---


{{< include _snippets/facts.qmd >}}

As you can see, the rendered file has the meta shortcodes populated with the definitions that you assigned to each value in the file’s YAML.

But, I would also like to add the state’s flower and animal with images of each. You can achieve this by editing the document to add this information and images:

1
2
3
4
5
6
7
8
9

{{< include _snippets/facts.qmd >}}

New York's official flower is the Rose:

![](../images/ny/flower.png)

And the official animal is the Beaver:

![](../images/ny/animal.png)

Or, you can get creative and use meta shortcodes in your image paths so you can continue to manage all of the content in a single file:

1
2
3
4
5
6
7

{{< meta state >}}'s official flower is the {{< meta flower >}}, pictured below:

![The official {{< meta state >}} state flower, the {{< meta flower >}}](../images/{{< meta state-abbr >}}/flower.png)

Lastly, {{< meta state >}}'s official animal is the {{< meta animal >}}, pictured below:

![The official {{< meta state >}} state animal, the {{< meta animal >}}](../images/{{< meta state-abbr >}}/animal.png)

As you can see, my image paths have {{< meta state-abbr >}} which is defined in the new-york file as “ny”.

When we render the project, the image path updates to /images/ny/flower.png pointing to the existing flower image in the ny directory:

In theory, you could do this for each state as long as each directory follows the same naming conventions, i.e., pa/flower.png and vt/flower.png.

This does require an organized and scalable approach since the images will have to follow the same directory and file-naming conventions, but in doing so, you can create individualized pages and images using a single include.

The rendered example

Here is New York’s page:

Here is Pennsylvania’s page:

Each page was built using a single (shared) file:

1

{{< include _snippets/facts.qmd >}}

Learn more about Quarto Includes

Quarto’s Includes feature allows you to improve your content creation process by reducing redundancy and maintaining consistency across multiple documents. Whether you’re managing technical documentation, educational materials, or any other content, this approach can help you save time, reduce errors, and deliver polished results.

Learn more with these resources:

• Get Started - Quarto
• Quarto - Includes
• Quarto - meta Variables
• An overview of Single Source Authoring

YouTube Playlist

Quarto Websites 1: Build your homepage

In this video, you’ll get a running start by using a template we’ve designed to be functional and attractive, and that will serve as a foundation for the rest of the video series. You’ll customize the content of your homepage, and how it looks, and along the way learn about the two key files in a Quarto website index.qmd and _quarto.yml. Finally, you’ll learn one way to publish your website so other people can see it.

Links: About pages | YAML appearance options

Code: Starter | Final

Quarto Websites 2: Add pages and navigation

Now you’ve got a homepage, you’ll likely want to add some other pages. In this video, learn how to add pages to your website, and help people find them, by adding them to your website navigation.

Links: Bootstrap icons | Navigation bar options | Quarto website navigation

Code: Starter | Final

Quarto Websites 3: Customize appearance with CSS/SCSS

You now have a set of content you are happy with on your website, but how do you customize the look and feel of your site beyond options set in YAML? In this video, you’ll start by learning the basics of CSS and SCSS and how to make good design choices. Then, you’ll see how to apply these choices to your Quarto website.

Links: Color contrast checker | Google fonts

Code: Starter | Final

Quarto Websites 4: Add lists of content with listings

Adding a listing page to your website is a great way to showcase your projects, talks, publications or blog posts. In this video you’ll learn how to create a listing page in Quarto and see two ways to populate it with content: Quarto documents, or a yaml file.

Links: Listings | Andrew Heiss’ teaching listing

Code: Starter | Final

We are particularly excited about:

• Support for brand.yml—a single file that defines your organization’s branding and style preferences across formats.

• RevealJS updates, including the new navigation features: scroll mode and jump to slide.

• The contents shortcode for reordering your content.

• landscape blocks for placing content on a landscape page.

• Improvements in how you can specify subpanels of cross-references from code blocks.

You can read about these new features and a couple of breaking changes in the sections below. You can find all the changes in this version in the Release Notes .

Cross-format theming with brand.yml

brand.yml is a Posit project outside Quarto that defines brand information using a simple YAML file. Quarto is a flagship adopter of brand.yml and supports brand-themed output for html, dashboard, typst and revealjs formats.

As an example, consider the following _brand.yml file:

_brand.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

color:
  palette:
    dark-grey: "#222222"
    blue: "#ddeaf1"
  background: blue
  foreground: dark-grey
  primary: black

logo: 
  medium: logo.png

typography:
  fonts:
    - family: Jura
      source: google
  base: Jura
  headings: Jura

When this _brand.yml is placed in a project, webpages, presentations, PDF reports, and dashboards will share a common appearance:

View the example: Source | Live website

Get started by reading the Quarto Guide to Brand .

RevealJS update

Quarto v1.6 updates RevealJS to v5.1.0. With the update comes two notable features:

Jump to Slide : Quickly navigate to a slide. Press G to activate, type a slide number or ID, and hit Enter/Return.

Scroll Mode : Scroll rather than click to advance slides. Press R, add ?view=scroll to your URL, or use the Navigation menu to activate. Automatically activated on small screens.

Contents shortcode

The contents shortcode lets you compose content in one location in your document and then display it in another. For example, you might use a code cell to generate a plot:

1
2
3
4
5
6

```{python}
#| echo: false
#| label: a-cell
import matplotlib.pyplot as plt
plt.plot([1,2,3])
```

Then use the contents shortcode to display that plot in a callout by referencing its label, a-cell:

1
2
3
4
5
6

::: callout-note
## Note the following plot

{{< contents a-cell >}}

:::

Find all the details on our guide page on the contents shortcode .

Landscape mode

In pdf, docx, and typst formats, you can now put content on a landscape page by placing it inside a landscape block :

1
2
3
4
5

::: {.landscape}

This will appear in landscape.

:::

Cross-reference improvements

It should now be easier to get Quarto to recognize subfloats (subtables, subfigures, etc) when they’re emitted by code cells. If the subcap attribute of a code cell has as many entries as the number of outputs from your code cell, Quarto knows to accept those as subfloats. See #10328 for details.

Minimal example:

1
2
3
4
5
6
7
8
9

```{{r}}
#| label: tbl-example
#| tbl-cap: I want these images to be interpreted as Tables.
#| tbl-subcap:
#|   - This is the subcaption for the first subtable
#|   - This is the subcaption for the second subtable
plot(1:10)
plot(11:20)
```

Breaking Changes

We try very hard to keep Quarto backward compatible. However, in this release, there are a couple of breaking changes due to upstream dependencies. You may be affected if:

• You have TypeScript files (*.ts) that you use either with pre- or post-render scripts, or with quarto run, that import Deno standard libraries.

  The import syntax has changed. Please see Deno Scripts for the necessary changes.

• You override the LaTeX graphics.tex partial, or you have a completely custom LaTeX template that doesn’t use the graphics.tex partial.

  A Pandoc change means some images are now wrapped in \pandocbounded. Consequently, your graphics.tex partial, or your template, needs to define \pandocbounded. You can look at our source code for graphics.tex to see the necessary changes and read more about the upstream change in Pandoc commit 26b25a4.

Acknowledgments

We want to say a huge thank you to everyone who contributed to this release by opening issues and pull requests:

ArthurData , Blake-Madden , Coding4Sec , EricMarcon , Fgazzelloni , GeorgRamer , Gewerd-Strauss , GuillaumeDehaene , HarunCelikOtto , IULibScholComm , IndrajeetPatil , LeoLuongVuong , MarcellGranat , Mavoort , Nenuial , PeteArm , ShixiangWang , Steinthal , Walser52 , Xinenomine , abbyruthe , aborruso , adamblake , albert-ying , alecloudenback , allefeld , aronatkins , arthur-shaw , astrowonk , avras , baker-jr-john , bcm0 , blackerby , boshek , brandonmontez , brianmsm , bryanhanson , carschandler , castedo , chaz-clark , christopherkenny , coatless , d-morrison , danieltomasz , daxkellie , ddlawton , debruine , dsbitor , e-miz , eculler , edavidaja , edvinsyk , eitsupi , ethanwhite , fermarsan , floesche , fradav , fredguth , gadenbuie , georgestagg , github-actions[bot] , halleysfifthinc , hamelsmu , hansfn , harrylojames , hodgesmr , holtzy , hugetim , hurak , iagopinal , isabelizimm , itsmevictor , jameslairdsmith , javajon , jchiquet , jdfoote , jido , jimjam-slam , jkrumbiegel , jmgirard , jmhammond , joelostblom , johannes-menzel , juliantao , jvcarli , kazuyanagimoto , kbvernon , kdheepak , kjohnsen , lballabio , leovan , loneguardian , longapalooza , lucacasonato , lukmanaj , lwjohnst86 , machow , maelle , masud90 , melaniewalsh , mfisher87 , mipmip , mitzimorris , mpr1255 , nessan , neuwirthe , nichtich , njericha , nsarang , olivroy , ozanozbeker , paciorek , pagiraud , parmsam , pedrohbraga , peteole , produnis , raffaem , ryarazi , ryjohnson09 , s2t2 , salim-b , samlalwani , sgelzenleuchter , skriptum , snhansen , stragu , sun123zxy , sverrirarnors , topepo , truecluster , tylere , winniehell , xtimbeau , yogabonito , yurivict , yves-amevoin .

The palette emoji in the listing and social card image for this post comes from OpenMoji– the open-source emoji and icon project. License: CC BY-SA 4.0

Materials: YouTube playlist | Slides | Starter code

1. Hello, Quarto Dashboards

Start by getting to know Quarto dashboards and make your very first dashboard using either R or Python and share it online. Slides

2. Quarto Dashboards Components

Then, build up your arsenal of dashboard components to add navigation, sidebars, tabsets, value boxes, and fine-tune layout. Slides

3. Quarto Dashboards Theming and Styling

Finally, make your dashboard pop by adding a theme and making styling tweaks. Slides

Talks included in this playlist are as follows:

• Updates from Posit, with Hadley Wickham, Charlotte Wickham, George Stagg, and James Blair
• Andrew Bray - Closeread: bringing Scrollytelling to Quarto
• Meghan Hall - Designing and Deploying Internal Quarto Templates
• David Keyes - Report Design in R: Small Tweaks that Make a Big Difference
• Mine Çetinkaya-Rundel - Reproducible, dynamic, and elegant books with Quarto
• Cynthia Huang - Quarto for Knowledge Management
• Regina Lionheart - Making Waves with R, Python, and Quarto
• Joshua Cook - Quarto: A Multifaceted Publishing Powerhouse for Medical Researchers
• Tyler Morgan-Wall - Quarto, AI, and the Art of Getting Your Life Back
• Sean Nguyen - Beyond Dashboards: Dynamic Data Storytelling with Python, R, and Quarto Emails
• Richie Moluno - JSquarto: Bridging JavaScript Documentation with Quarto’s Power
• Mika Braginsky - DataPages for interactive data sharing using Quarto
• Brennan Antone - Democratizing Organizational Surveys with Quarto and Shiny

Below, we’ll highlight the improved Typst support, website enhancements like draft handling and announcement bars, the native Julia engine, and a couple of shortcodes for generating placeholder content. You can see all the changes in the Release Notes .

Typst CSS

We’ve already blogged about one feature that is now available in 1.5: Beautiful Tables in Typst . The CSS properties from HTML tables produced in your code are translated to Typst properties, so the tables you lovingly craft for HTML should look just as good in PDFs produced using format: typst.

Beyond tables, CSS properties on divs and spans are also translated to Typst properties. So, for example, you could get text with a green background like this:

1

Here is a [span with a green background]{style="background-color:green"}.

You can read more about using CSS in Typst at Typst Basics: Typst CSS .

Improved Website Draft Support

Quarto 1.5 brings improved support for workflows involving draft posts and pages:

• Adds the drafts option to the website key offering new ways to specify drafts: directly in _quarto.yml, and via metadata includes and profiles.

• Introduces the draft-mode option to the website key to control how drafts are rendered. Drafts can be gone, unlinked or visible.

• Adds a draft banner to draft pages that are rendered.

• Improves the linking behavior of draft documents. Now, in addition to being excluded from search results, listings, and the sitemap, drafts will not appear in navigation, or be linked from in-text hyperlinks when draft-mode is gone or unlinked.

• Changes the behavior of quarto preview for drafts. Drafts will be visible in previews regardless of the draft-mode setting. In particular, this allows an easier way to preview the appearance of draft content in navigation and listings.

Read more at Website Drafts .

Website Announcements

You can now use an announcement option to add a customizable banner at the top of your website. You can set an icon, make it dismissable, and include markdown formatted content like bold text:

Read about your options at Website Tools: Announcement Bar .

Native Julia Engine

Prior to 1.5, Julia code cells were executed through the Jupyter engine. Now you can opt-in to a native Julia engine:

1
2
3
4

---
title: Julia without Jupyter
engine: julia
---

Read about the details in Using the julia engine .

Part of the reason we are excited about this feature is that it was an external contribution. Thank you @jkrumbiegel !

Placeholder Shortcodes

We’ve also added a couple of shortcodes that add placeholder content: lipsum for text, and placeholder for images:

1
2

{{< placeholder 400 200 format=svg >}}
{{< lipsum 1 >}}

This example produces a 400px x 200px SVG image, and one paragraph of Lorem Ipsum text:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis sagittis posuere ligula sit amet lacinia. Duis dignissim pellentesque magna, rhoncus congue sapien finibus mollis. Ut eu sem laoreet, vehicula ipsum in, convallis erat. Vestibulum magna sem, blandit pulvinar augue sit amet, auctor malesuada sapien. Nullam faucibus leo eget eros hendrerit, non laoreet ipsum lacinia. Curabitur cursus diam elit, non tempus ante volutpat a. Quisque hendrerit blandit purus non fringilla. Integer sit amet elit viverra ante dapibus semper. Vestibulum viverra rutrum enim, at luctus enim posuere eu. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

Read more about their options at Placeholder Images and Placeholder Text .

Acknowledgements

Finally, we’d like to give a huge high five to everyone who contributed to this release by opening issues and pull requests:

AaronGullickson , abduazizR , aborruso , AdaemmerP , adamalfredsson , adamulrich , aghaynes , ALanguillaume , AlbertRapp , allefeld , AndreiBiziuk , andrie , anhi , aravezskinteeth , arnaudgallou , aronatkins , ArthurAndrews , arvindvenkatadri , AshleyHenry15 , averms , awhol1 , batpigandme , bcdavasconcelos , bhattmaulik , bhogan-mitre , billgeo , BradyAJohnston , cameronraysmith , CeresBarros , christian-million , cpcloud , daslu , davidkane9 , debdagybra , dfolio , dhodge180 , dmbates , drtingtp , eitsupi , eyayaw , FabienSe , fernandortdias , fkgruber , ForceBru , gcgbarbosa , gimmiereddy , gl-eb , gregswinehart , guilhermegarcia , GuillaumeDehaene , hadley , has2k1 , Hemken , hervyqa , hewag1975 , hughjonesd , iandol , IULibScholComm , j-horak , jackgerrits , jasonpott , jcheng5 , jdossgollin , jebyrnes , jimgar , jimjam-slam , jkrumbiegel , jobrachem , jolars , jonpeake , jrob95 , jrtheobald , juliantao , JulienGAMartin , justinaskav , kadykov , KaiWaldrant , kdheepak , kkaja123 , kletts , kompre , krishaamer , lamurian , Lextuga007 , li-yq , libjohn , liyongg , loreabad6 , Luc-UMass , lwjohnst86 , m-clark , m-delem , MarcoPortmann , marklhc , martinscripts , memeplex , MHellmund , mhollanders , mine-cetinkaya-rundel , MKDJr , mroberts1 , mvuorre , mwouts , ncclementi , ncworstell , nealrichardson , Nesper94 , nickvigilante , nmalkin , NMarkgraf , nrichers , olivroy , ozanozbeker , pagiraud , pastorn , pbousquets , pem725 , petrbouchal , pgseye , pingumops , pmoris , pschloss , rafaelorozco , rastrau , RegalPlatypus , rgaiacs , Robinlovelace , robolyst , royfrancis , rpchastain , sapphire008 , schrammelj , sinamoghimi73 , statik , stevengogogo , sun123zxy , szsctt , teecrow , the-solipsist , TomBener , ttalVlatt , tvroylandt , tylermorganwall , Unco3892 , Vinnie-Palazeti , WardBrian , wjschne , wklimowicz , xiaoxl , ycrouin

The balloon emoji in the listing and social card image for this post comes from OpenMoji– the open-source emoji and icon project. License: CC BY-SA 4.0

It does this by translating CSS properties into Typst properties. You can read about the feature in the Guide .technical details in the Advanced Docs

Let’s look at 6 HTML tables using a variety of CSS properties also supported by Typst in Quarto.

You can click on the links below the examples to see the full documents, with source code.

Confusion Matrix (Pandas / Python)

This example uses a dashed border to draw attention to two cells.

Typst

HTML

Cars heatmap (gt / R)

This example uses cell background colors to encode ranges of values.

Typst

HTML

Oceania (Great Tables / Python)

Borders can show the structure of grouped rows.

Typst

HTML

Islands (gt / R)

Font sizes and minimal borders make this table stand out.

Typst

HTML

Solar Zenith (Great Tables / Python)

Another cool heatmap.

Typst

HTML

Acting on Data (Pandas / Python)

Applying colors and transparency based on data.

Typst

HTML

We can’t wait to see what you do with this new feature!

Introduction to Quarto

• Led by Andrew Bray , Berkeley University

• Ideal for beginners looking to create rich documents

Build-a-Dashboard Workshop (with Quarto, R, and/or Python)

• Led by Mine Çetinkaya-Rundel , Posit, PBC, Duke University

• Perfect for those familiar with computational notebooks in R and/or Python who want to create eye-catching dashboards

Quarto Websites

• Led by Charlotte Wickham and Emil Hvitfeldt , Posit, PBC

• Great choice for those wanting to build a website from scratch with Quarto

Introduction to Quarto

This workshop will prepare you to author a rich array of documents in Quarto, the next generation of R Markdown. Quarto is an open-source scientific and technical publishing system that offers multilingual programming language support to create dynamic and static documents, books, presentations, blogs, and other online resources.

This workshop focuses on single documents. You will learn to create static documents, add interactivity to them with Shiny and HTML widgets, or steer them toward sophisticated scientific documents.

In the afternoon, you’ll use the same authoring approaches to create slide presentations in various formats, such as reveal.js, Beamer, and PPTX.

This workshop is for you if you:

• Have a basic knowledge of how to use the RStudio IDE,

• Have some familiarity with Markdown, or

• Are excited to author flexible single documents like technical reports and slide presentations.

Build-a-Dashboard Workshop (with Quarto, R, and/or Python)

You already analyze and summarize your data in computational notebooks with R and/or Python. What’s next? 

You can share your insights or allow others to make their own conclusions in eye-catching dashboards and straight-forward to author, design, and deploy Quarto Dashboards, regardless of the language of your data processing, visualization, analysis, etc. With Quarto Dashboards, you can create elegant and production-ready dashboards using a variety of components, including static graphics (ggplot2, Matplotlib, Seaborn, etc.), interactive widgets (Plotly, Leaflet, Jupyter Widgets, htmlwidgets, etc.), tabular data, value boxes, text annotations, and more. Additionally, with intelligent resizing of components, your Quarto Dashboards look great on devices of all sizes.

And importantly, you can author Quarto Dashboards without leaving the comfort of your “home” – in plain text markdown with any text editor (VS Code, RStudio, Neovim, etc.) or any notebook editor (JupyterLab, etc.). This workshop will walk you through building an increasingly complex dashboard using various layout options and deploying them as static web pages (with no special server required), as well as with a Shiny Server on the backend for enhanced interactivity.

This workshop is for you if you:

• Do data analysis in computational notebooks,

• Share your results with your audience in static or interactive dashboards and

• Want to improve the design, user interface, and experience of your dashboards.

Quarto Websites

Do you need a professional website to showcase your work? Or have you got an idea for a website at work, but it needs to reflect your organization’s brand? If you’ve used Quarto to produce a document, you’ve already got the technical skills to create a Quarto website. In this workshop, you’ll learn everything else you need to build a website and customize its appearance.

You’ll get a running start by using a template we’ve designed to be functional and attractive but also act as a guide for your learning. Then you’ll:

• Add pages and navigation, and learn best practices for structuring your content.

• Master the basics of SCSS and CSS and how they apply to Quarto websites to customize your site’s visual appearance.

• Use listings, a special kind of page, to showcase related content like blog posts, projects, or talks.

By the end of the workshop, you’ll have built and published (if you want) a personal website, but the same tools and techniques will apply to any kind of website you might like to build.

We’ll assume you’ve used Quarto to produce documents, but we won’t assume you have any HTML, CSS/SCSS, or Git/GitHub experience, nor will we assume any particular programming language (R, Python, etc.) or level of programming experience.

This workshop is for you if you:

• Have used Quarto to generate documents (e.g., HTML, PDF, MS Word, etc.)

• Are comfortable editing plain text documents (e.g., `.qmd`) in your IDE (e.g., RStudio, Visual Studio Code, etc.) and

• Want to walk away with your own personal website.

Learn more about posit::conf(2024)

Want to explore the complete catalog of posit::conf(2024) workshops and talks?

• Workshops on August 12: Head over to our workshop listing to discover detailed information about the courses and instructors.

• Talks on August 13 and August 14: Peruse the conference agenda .

  • Tip: For a quick view of all Quarto talks, filter for “Quarto” under topics.

Ready to secure your spot? Visit the conference website for comprehensive details on pricing and the agenda, and register today !

Some highlights from the webinar include:

• Step-by-step instructions for getting started with a new manuscript project

• Obtaining multiple formats from one source

• An overview of the rich front matter

• Embedding computations from supplementary notebooks

  • Note that I demoed embedding computations in R from .qmd files however it’s also possible to embed computations from Jupyter notebooks and computations done in Python.

• A live-coding demo of authoring Quarto manuscripts with RStudio and all the bells-and-whistles of the visual editor, including:

  • cross referencing
  • citations
  • inline code

• Ability to actually interact with code from a manuscript with Binder

• And a rich Q&A, thanks to the audience!

The slides (also written in Quarto!) and their source code can be found at the links below:

• Slides: https://mine.quarto.pub/quarto-manuscripts-rmed

• Source code for slides: https://github.com/mine-cetinkaya-rundel/quarto-manuscripts-rmed

In addition, the webinar featured a reproduction of a medical manuscript with Quarto.² Materials from this reproduction can be found at the links below:

• Manuscript homepage: https://mine-cetinkaya-rundel.github.io/indo-rct

  • This is an HTML page but you can also access PDF and MS Word versions of the manuscript by clicking on their respective links.
  • You can also find a link to the Binder instance for this manuscript.³

• Source code for manuscript: https://github.com/mine-cetinkaya-rundel/indo-rct

Ready to get started writing a manuscript with Quarto? Go to https://quarto.org/docs/manuscripts for more info and a step-by-step tutorial. Happy authoring!

About Hugging Face

Hugging Face is the most used open platform for AI, where the machine learning community has shared more than 500,000 models, 115,000 datasets, and 160,000 ML apps, including Stable Diffusion, Llama, GPT-J, and open-source ChatGPT alternatives.

These apps enable the community to explore models, replicate results, and lower the barrier of entry for ML. At Posit, we’ve been extremely impressed with the Hugging Face community and their commitment to supporting open-source machine learning models.

What does Quarto add?

We think that Quarto is one of the best frameworks for scientific writing, making it a perfect tool for the Hugging Face community. With Quarto, you can interleave code and text to produce accurate, reproducible, and beautiful documents. You use simple markdown or Jupyter notebook files to generate presentations , manuscripts , dashboards , and more .

Conclusion

Our mission at Posit is to support open-source scientific software, and so we’re very proud to support Hugging Face’s effort to build advanced AI models under open-source licenses. We can’t wait to see what people build with this integration.

This release has tons of new features. Some of the big ones we want to spotlight are: Dashboards, Typst, Inline Code Syntax, Cross-References and Manuscripts.

Dashboards

Quarto Dashboards streamline the creation of interactive dashboards, giving you an effortless way to lay out interactive components, visualizations, tabular data, and annotations. Here are some examples (click on the image to visit the live version):

For the source code of these dashboards and additional examples see the examples gallery . When you are ready to build your own Quarto dashboard head to our guide on Dashboards .

Typst

Typst is a new open-source markup-based typesetting system that is designed to be as powerful as LaTeX while being much easier to learn and use. Typst creates beautiful PDF output with blazing fast render times.

Quarto 1.4 includes the Typst CLI, so all you need to get started creating PDFs via Typst is to use format: typst:

hello-typst.qmd

1
2
3
4
5
6

---
title: "Hello Typst!"
format: typst
---

My first Typst document

We are particularly excited about how easy it is to make templates for journal articles, conference posters, newsletters and more with Typst. Here are some examples you can use in Quarto as custom formats :

Start your Typst journey with Quarto in our guide on Typst Basics .

Inline Code Syntax

Quarto 1.4 introduces a unified syntax for including computed values inline. The syntax for inline code is similar to code blocks, except you use a single tick (`) rather than triple ticks (```), and you can use it in the middle of markdown:

```{python}
radius = 5
```

The radius of the circle is `{python} radius`

```{r}
radius <- 5
```

The radius of the circle is `{r} radius`

```{ojs}
radius = 5
```

The radius of the circle is `{ojs} radius`

And don’t worry if you are used to using `r ` that syntax remains fully supported. Read more at Inline Code .

Cross-References

Cross-references have been overhauled in Quarto 1.4, enabling you to do things like:

• Flexibly define the content of float cross-references (e.g. figures, tables and code listings) with the new Cross-Reference Div Syntax . For example, Table 1 is an image treated like a table:

  ::: {#tbl-table}  An image treated like a table :::

  And notice if you hover over the reference as it appears in the text, e.g. hover over this link to Table 1, you’ll get a floating preview of the content—that’s new too.

• Define custom types of float cross-reference , which you could use to create cross-references to Videos, Diagrams or Supplemental Figures .

• Cross-reference executable code cells , callouts and remarks and solutions .

Manuscripts

Quarto manuscript projects provide a framework for writing and publishing scholarly articles. You can use notebooks (.qmd or .ipynb) as the source of content and computations, and then publish these computations alongside the manuscript, allowing readers to dive into your code.

The output of a manuscript project is a website containing the article in multiple formats (e.g. LaTeX, MS Word) along with rendered versions of the notebooks in the project:

Read more about manuscripts and how to get started in our guide to Manuscripts .

Other Highlights

Some other highlights include:

• Shiny for Python —Support for using Shiny for Python within Quarto documents.

• Script Rendering —Render specially formatted .py, .jl and .r script files.

• Easy Binder Configuration for Quarto Projects —Support for generating files required to deploy a Quarto project to Binder.

• Connect Email Generation—Extends the html output format so that HTML/text emails can be created and selectively delivered through Posit Connect.

• Publish to Posit Cloud —Adds posit-cloud as a venue for quarto publish.

• Lightbox Treatment for Images and Figures —Support for zooming into images and figures as well as grouping multiple images into a gallery.

If you build Quarto extensions, you should also be aware of some developer-facing changes:

• Lua changes —New Support for crossreferenceable elements in filters, extensible renderers of quarto AST nodes such as FloatRefTarget and Callout, the use of relative paths in require() calls, and more precise specification of where a filter will be inserted.

• AST processing changes —Improvements to the HTML table processing added in v1.3 and a way for LaTeX raw blocks to include Quarto-compatible markdown for processing.

You can find all the other changes in 1.4 in the Release Notes .

Acknowledgements

We’d like to say a huge thank you to everyone who contributed to this release by opening issues and pull requests:

AaronGullickson , abichat , abigailhaddad , aborruso , abraver , acebulsk , aghaynes , ajay333a , ajsmit , ALanguillaume , AlbertRapp , aletroux , alex-vinogradov , alexCardazzi , allefeld , am-lh , andlekbra , andrefmello91 , AndreiBiziuk , andrewheiss , anielsen001 , apsteinmetz , AQLT , arnaudgallou , aronatkins , atsyplenkov , b-rodrigues , Balaika , baptiste , barryrowlingson , batpigandme , bcongelio , benabel , benjaminschlegel , bfordAIMS , blacksqr , boshek , BradyAJohnston , brtarran , bryanhanson , bweatherson , c-zippel , cadojo , camilogarciabotero , cbrnr , ccamara , cermak-consulting , chendaniely , ChrisJefferson , ChristopherBarrington , christopherkenny , chrisvoncsefalvay , chuxinyuan , cjber , coatless , coltongearhart , CorradoLanera , csgroen , dalejbarr , DamonCharlesRoberts , Damonsoul , daniel-smit-haw , danieltomasz , danmackinlay , daranzolin , darthlite , das-g , davidfoxcroft , davidpomerenke , ddotta , declann , dense-set , dfolio , dgkf , dkapitan , dlakelan , dloss , dmkaplan2000 , DOSull , dpabon , dpprdan , DriesSchaumont , drscotthawley , dschief001 , dweng0 , e-miz , EconomiCurtis , edavidaja , edibotopic , eeenilsson , ehudkr , eitsupi , EllaKaye , emdelponte , emilBeBri , EmilHvitfeldt , emitanaka , epruesse , ercbk , EricJC24 , ericvmai , erikerhardt , espinielli , Eugloh , fecet , Felixmil , FeralFlora , finkelshtein , fkohrt , fradav , fuhrmanator , fulem , gadenbuie , garrettgman , GegznaV , Gewerd-Strauss , gimmiereddy , gl-eb , grantmcdermott , gregmacfarlane , gregoireurvoy , gregswinehart , gshotwell , GuillaumeDehaene , gvelasq , gyansinha , hamelsmu , harrelfe , harrylojames , harrysw1729 , HelenaLC , helmingstay , HenrikBengtsson , homerhanumat , icarusz , ig0101 , ijlyttle , ijmitch , irmoodie , isabelizimm , IULibScholComm , ivelasq , jack-davison , Janidai , jarbet , jasonaris , jatalah , JauntyJJS , jb-leger , jcheng5 , jdonland , jdutant , jeremy9959 , jeroenjanssens , jfb-h , jfunction , JGobeil , jgomezdans , jgostick , jhchou , jhk0530 , jhunter-aof , jimgar , jimjam-slam , jmbuhr , jmcvw , Joda66 , joelostblom , joelvonrotz , johngoldin , jonassmedegaard , jpatteet , jrowen , jthomasmock , jtr13 , juba , juliantao , jurjoroa , justanothergithubber , jzelner , KaiWaldrant , kbvernon , kcarnold , kdheepak , kdzhang , kejaed , kendonB , knuesel , Kodiologist , kompre , koushikkhan , krishaamer , ksreyes , kwangkim , kyleGrealis , lcnbr , leeroyaus , leonardblaschek , Lextuga007 , lidavidm , lillemets , lnnrtwttkhn , luifrancgom , Lulliter , lyndondrake , m-clark , m-guggenmos , machow , maelle , magnusnosnes , MarieEtienne , marklhc , martinfleis , Martinomagnifico , masud90 , matanhakim , Matoyatapika , matthew-brett , matthewfinkbeiner , maxdrohde , mfenner , mfisher87 , MichaelPascale , mikabr , milanmlft , mine-cetinkaya-rundel , Minh-AnhHuynh , miwojc , mloubout , msarahan , msh855 , mslynch , murattasdemir , mvanaman , nanxstats , netique , netw0rkf10w , nickriches , njbart , noahmf , nqt2022 , nwisn , nwvhb , OlexiyPukhov , olivroy , ollyhensby , pastorn , pat-s , patgd , petrbouchal , petzi53 , phongphuhanam , pieterprovoost , piotr-kaczmarski , pjastr , pommevilla , prosoitos , ptram , qiushiyan , ratnanil , ravicodelabs , rcannood , rchaput , regob , remlapmot , resmartiZH , rgaiacs , rmcd1024 , rmflight , rnd195 , robolyst , rogerbramon , ronblum , ropeladder , rowanc1 , RoyiAvital , rsenft1 , salim-b , samcarter , sceptri , sda030 , sebacea , sebastian-c , sebastianrowan , sebffischer , seeM , Serenade600 , Servinjesus1 , shafayetShafee , sharon-wang , shirdekel , simonjackman , sje30 , sjspielman , skaltman , smithbn , snhansen , Sparrow0hawk , sswam , stefanbringuier , stephan-koenig , steveguil , Sumidu , sun123zxy , tegorman13 , tflexs , th0ger , the-solipsist , TheGoodCartman , TheisFerre , thomascwells , TLouf , tobydriscoll , tom67 , tonyaseverson , topepo , tpoisot , TrainedMusician , TS-CUBED , ttalVlatt , Tutuchan , tylermorganwall , ulyngs , ute , vfacta , vitpetrik , VivaldoMendes , VladimirAlexiev , Walser52 , warrickball , wch , weihuangwong , wilcar , willingc , wjdenny , wklimowicz , XiangyunHuang , xtimbeau , yoyo25 , YuanchenZhu2020 , yuxi-liu-wired , yyzeng , zenggyu , Zeno-of-Elea , zief0002 , Zuline

The party popper emoji in the listing and social card image for this post comes from OpenMoji– the open-source emoji and icon project. License: CC BY-SA 4.0