Publish to Posit Connect Cloud

You can now publish documents and websites to Posit Connect Cloud directly from the command line. For example, publish your Quarto website project with:

Terminal

quarto publish posit-connect-cloud

Posit Connect Cloud is a hosted platform for sharing data applications and documents without managing your own infrastructure. It includes a free tier for unlimited static document publishing. Read more in Publishing > Posit Connect Cloud.

Improvements to Typst Support

Quarto 1.9 brings substantial improvements to Typst output:

• Book projects can now render to Typst via the bundled orange-book extension, with chapter numbering, cross-references, and professional textbook styling.
• Article layout support lets you place content in the margins, create full-width figures, or add side notes.
• New options: mathfont, codefont, linestretch, linkcolor, citecolor, filecolor, thanks, and abstract-title.
• Theorem styling with four appearance options: simple, fancy, clouds, or rainbow.

We’ll have a detailed blog post on all the Typst improvements soon.

PDF Accessibility (Experimental)

We’re rolling out experimental support for PDF accessibility standards in 1.9. The new pdf-standard option enables PDF/A archival formats and PDF/UA accessibility compliance for both LaTeX and Typst outputs. Alt text from fig-alt attributes now passes through to PDF for screen reader support, and Typst gains support for alt text on cross-referenced equations.

Read more in our PDF Accessibility and Standards blog post or the documentation for LaTeX and Typst.

Output for LLMs

Quarto can now generate llms.txt format output for your website, making your content more accessible to large language models and AI-powered tools.

Enable it in your website configuration:

_quarto.yml

website:
  title: "My Documentation"
  llms-txt: true

When you render your site, Quarto creates:

• An llms.txt index file at the root of your site listing all pages
• A .llms.md markdown file alongside each HTML page (e.g., guide.html gets guide.llms.md)

The markdown files contain clean versions of your content—navigation, sidebars, and scripts are stripped out; tables, code blocks, and callouts are converted to standard markdown.

Read more, including how to customize what appears in LLM output, in Websites > Output for LLMs.

quarto use brand Command

Keep your project’s brand assets in sync with an external source using the new quarto use brand command:

Terminal

quarto use brand myorg/shared-brand

The command copies brand files from a GitHub repository, local directory, or zip archive into your project’s _brand/ directory. Quarto walks you through each step—confirming trust for remote sources, creating the directory if needed, and asking whether to overwrite or remove files.

See Guide > Brand for --dry-run, --force, and other options.

List Tables

List tables provide a new syntax for creating tables with complex content—multiple paragraphs, code blocks, or nested lists—using familiar bullet syntax instead of grid table formatting:

::: {.list-table}
- - Function
  - Description

- - `sum()`
  - Add values:

    ```python
    sum([1, 2, 3])
    ```

- - `len()`
  - Count items:

    - Works on lists
    - Works on strings
:::

sum([1, 2, 3])

Each top-level bullet represents a row; nested bullets represent cells. This syntax is much easier to maintain than grid tables, especially when cells contain code or other block elements.

List tables support all the usual table features: captions, cross-references, column widths, and alignment. Thanks to Martin Fischer for the original development, with contributions from Albert Krewinkel and William Lupton.

Find all the details in Guide > Tables.

Other Highlights

• Search Result Highlighting: Improved highlighting of search terms on destination pages, with persistent marks, automatic tab activation for matches inside tabsets, and cross-element highlighting for multi-word searches.

• Privacy-focused features for websites:

  • A privacy-first default for cookie consent: The default for cookie consent has changed to type: express, providing opt-in consent that blocks cookies until users explicitly agree. This privacy-conscious default is designed with modern privacy regulations in mind.

  • Algolia Search Insights avoids cookies: Use Algolia Insights now uses persistent cookies only if cookie-consent is active, and the user has opted-in.

  • Use Plausible Analytics: Add privacy-friendly Plausible Analytics to websites via the plausible-analytics configuration option.

• aria-label for videos: Improve accessibility of embedded videos by providing custom descriptive labels for screen readers instead of the default “Video Player” label.

• New syntax-highlighting Option: Replaces the deprecated highlight-style (Pandoc 3.8). Supports style names, custom .theme files, none, or idiomatic for format-native highlighting.

• Metadata and brand extensions now work without a _quarto.yml project. A temporary default project is created in memory.

• Engine extensions allow replacement of the execution engine:

  • Julia is now a bundled extension instead of being built-in.
  • quarto-marimo will soon change from a filter extension to an engine extension.
  • New quarto create extension engine command.
  • New quarto call build-ts-extension command.
  • New Quarto API for engine extensions to use. (This is in flux and will not be documented for the next few releases, but there is a dev blog post about it.)

Dependency updates:

• pandoc updated to 3.8.3
• typst updated to 0.14.2
• esbuild updated to 0.25.10
• deno updated to 2.4.5
• mermaid updated to 11.12.0

Acknowledgements

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

CoryMcCartan, DanChaltiel, Data-Wise, FrankwaP, Joao-O-Santos, LukasDSauer, MBe-iUS, MarcoPortmann, MariaBarrioSchez, MateusMolina, Selbosh, ThePurox, TucoFernandes, aecoleman, amirhome61, andrewheiss, azankl, bensoltoff, bruvellu, byzheng, cbrnr, chendaniely, chi-raag, christopherkenny, coatless, cynthiahqy, darwindarak, davidskalinder, dmenne, fconil, fkgruber, fkohrt, fredguth, gadenbuie, github-actions[bot], gsathler-vi, hamgamb, herosi, icarusz, idavydov, jeremy886, jkrumbiegel, jmcphers, jonas37, jorherre, jreades, jromanowska, jtbayly, juleswg23, juliasilge, kathsherratt, kusnezoff-alexander, lrrichter, lwjohnst86, maelle, matthiasbaitsch, mipmip, mstrms2000, multimeric, mvuorre, mykolaskrynnyk, nichtich, nithinmkp, nrichers, orbsmiv, paytonej, petrelharp, phongphuhanam, pm-gusmano, posit-snyk-bot, prosoitos, rabyj, sasja-san, sbwiecko, serialc, spaette, spraetor, stragu, szimmer, the-solipsist, thomasp85, yyzeng, zhe00a.

The airplane departure 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

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.

Terminal

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.

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.

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!

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.

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.

Powered by a comprehensive extension directory

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.

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

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:

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

import json
import os

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

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

What’s New

Install the latest version from CRAN:

install.packages("quarto")

Major features in this release include:

• Pass R values to Quarto metadata - Set metadata programmatically based on computed values from knitr engine
• Insert Markdown in HTML tables for Quarto processing - Include Markdown content (equations, links, formatting) in HTML tables
• Apply Light and Dark Themes to Plots and Tables - Change the background and foreground colors of plots and tables based on light & dark themes
• Work with R scripts and Quarto - Extract R code from Quarto documents or prepare R scripts for Quarto rendering
• Build paths from Quarto Project - Build paths relative to Quarto project root within R cells
• Automate Quarto CLI from R - New and improved wrappers around Quarto CLI features for easier automation

Pass R Values to Quarto Metadata

Set metadata dynamically based on R computations with write_yaml_metadata_block(). For example, you could check a parameter value, and conditionally include content based on it:

#| output: asis

write_yaml_metadata_block(
  is_france = params$country == "france"
)

This will write the following (e.g., when quarto render report.qmd -P country:france):

---
is_france: true
---

Then use Quarto’s conditional features:

::: {.content-visible when-meta="is_france"}
## Fun fact about France

In 2025, France is the most visited country in the world, attracting over 89 million tourists annually!

:::

# These octal-like values are automatically quoted to prevent errors
write_yaml_metadata_block(
  code1 = "0888",    # Without quoting: YAML 1.2 interprets as 888 (invalid octal ignored)
  code2 = "0999"     # Without quoting: YAML 1.2 interprets as 999 (invalid octal ignored)
)

# Parameters with octal-like codes are now handled correctly
quarto_render("report.qmd", 
  execute_params = list(
    site_code = "0888",
    permission = "0755"
  ))

# Force specific values to be quoted in YAML output
metadata <- list(
  code1 = yaml_quote_string("1.0")
)
write_yaml_metadata_block(.list = metadata)

Insert Markdown in HTML Tables for Quarto Processing

Quarto can parse Markdown content in HTML tables, enabling rich formatting like math equations, links, and text styling. The new tbl_qmd_*() functions make this powerful Quarto feature easier to use from R:

data.frame(
  Feature = c("Formatting", "Math", "Links"),
  Example = c(
    tbl_qmd_span("**Bold**, *italic*"),
    tbl_qmd_span("$E = mc^2$"),
    tbl_qmd_span("[Quarto docs](https://quarto.org)")
  )
) |>
  knitr::kable(format = "html", escape = FALSE)

These helper functions wrap content in HTML spans with data-qmd-base64 attributes that Quarto recognizes for Markdown processing. They work with any table package that supports raw HTML (knitr, kableExtra, DT). For content that only works in Quarto, use the display argument for graceful fallback. See more examples in the Markdown in HTML tables vignette, including comparisons of Markdown support in HTML tables across different packages.

Apply Light and Dark Themes to Plots and Tables

The theme_colors_flextable(), theme_colors_ggplot2(), theme_colors_gt(), theme_colors_plotly(), theme_colors_thematic() helper functions change the background and foreground colors of six popular plot and table packages. These can be used to produce light and dark renderings to match the plot or table with themes in light and dark mode.

The usage of the the results of these functions depends on the package. See the Theme Helpers article for usage examples of theme_colors_*.

The theme_brand_flextable(), theme_brand_ggplot2(), theme_brand_gt(), theme_brand_plotly(), theme_brand_thematic() helper functions change the background and foreground colors of these packages using corresponding brand.yml colors. See the Light & Dark Renderings Examples for usage examples of theme_brand_*.

Work with R Scripts and Quarto

# Extract R code from a Quarto document
qmd_to_r_script("analysis.qmd")  # Creates "analysis.R"

# Specify custom output
qmd_to_r_script("analysis.qmd", script = "extracted-code.R")

# Add metadata for rendering
add_spin_preamble("analysis.R", 
                  title = "Analysis Report",
                  preamble = list(author = "Data Team"))

# Now render the script with Quarto
quarto_render("analysis.R")

#' ---
#' title: Analysis Report
#' author: Data Team
#' ---
#'

# Your original R code follows...

Build Paths from Quarto Project

Quarto sets environment variables during rendering that identify the project root, but knitr doesn’t have direct access to this information by default. The new project navigation functions bridge this gap:

# Build paths relative to the Quarto project root
data_file <- project_path("data", "analysis.csv")

# Explicitly find the project root (searches for _quarto.yml)
root <- find_project_root()

project_path() intelligently handles different execution contexts:

• During quarto render, it uses QUARTO_PROJECT_ROOT or QUARTO_PROJECT_DIR environment variables
• In interactive sessions, it automatically detects the project root by searching for _quarto.yml.
• Falls back to the current working directory with a warning if no project is found.

This ensures your paths work consistently without hardcoding or manual adjustments. For example, you can read a CSV file relative to your project root:

# In posts/2025/analysis/report.qmd, this resolves to ../../../data/results.csv
results <- read.csv(project_path("data", "results.csv"))

For more explicit control, consider using here::i_am() and here::here() as an alternative approach. Follow r-lib/usethis Issue #128 for improved support in next versions of here.

Automate Quarto CLI from R

The quarto R package has always been designed as a comprehensive wrapper for the Quarto CLI, enabling seamless integration of Quarto into R workflows and pipelines. This release strengthens that foundation with improved wrappers and new helpers.

# Add an extension
quarto_add_extension("quarto-journals/jss")

# List installed extensions
quarto_list_extensions()

# Remove an extension
quarto_remove_extension("jss")

# Create projects from templates
quarto_create("article", name = "my-analysis")

# Check if a newer version of Quarto is available
check_newer_version()

# Check if a document has parameters (uses quarto inspect internally)
if (has_parameters("report.qmd")) {
  quarto_render("report.qmd", execute_params = list(year = 2025))
}

Additional Improvements

# Create a new blog post with automatic date prefix and YAML frontmatter
new_blog_post("my-first-quarto-post", dir = "posts")

# Scan your bookdown project for cross-references
detect_bookdown_crossrefs("my-bookdown-project/")

> detect_bookdown_crossrefs("~/Documents/DEV_R/bookdown/inst/examples", verbose = FALSE)
ℹ Scanning for bookdown cross-references in 12 .Rmd files...
! Found 110 bookdown cross-references that should be converted:

• 01-introduction.Rmd: 3 references
- 3 Sec

• 02-components.Rmd: 52 references
- 5 Eq
- 7 Fig
- 1 Lem
- 1 Lemma Div
- 7 Numbered Equation
- 17 Sec
- 5 Tab
- 5 Theorem Div
- 4 Thm

• 03-formats.Rmd: 20 references
- 4 Fig
- 16 Sec

• 04-customization.Rmd: 5 references
- 5 Sec

• 05-editing.Rmd: 8 references
- 3 Fig
- 5 Sec

• 06-publishing.Rmd: 8 references
- 3 Fig
- 5 Sec

• 08-usage.Rmd: 3 references
- 3 Sec

• index.Rmd: 11 references
- 11 Sec

ℹ Summary of conversion requirements:
• 5 Eq reference
• 17 Fig reference
• 1 Lem reference
• 1 Lemma Div reference
• 7 Numbered Equation reference
• 65 Sec reference
• 5 Tab reference
• 5 Theorem Div reference
• 4 Thm reference

ℹ Manual conversion requirements:
• Section headers: 65 references need manual attention
• Figure labels: 17 references need manual attention
• Table labels: 5 references need manual attention
• Equation structure: 7 references need manual attention
• Theorem blocks: 6 references need manual attention

ℹ For detailed conversion guidance, run: quarto::detect_bookdown_crossrefs("~/Documents/DEV_R/bookdown/inst/examples", verbose = TRUE)

# Convert {r label, option=value} to YAML-style chunk options for a single file
knitr::convert_chunk_header("analysis.Rmd", output = NULL)

# To process multiple files in a directory, you need to iterate:
rmd_files <- list.files("my-bookdown-project/", pattern = "\\.Rmd$", 
                        full.names = TRUE, recursive = TRUE)
lapply(rmd_files, knitr::convert_chunk_header, output = NULL)

Breaking Changes

# Sets output-file metadata (like having 'output-file: report.html' in YAML)
quarto_render("doc.qmd", output_file = "report.html")

# Use CLI flag directly
quarto_render("doc.qmd", quarto_args = c("--output", "report.html"))

# Create an empty directory first
dir.create("my-article")
quarto_use_template("quarto-journals/jss", dir = "my-article")

Learn More

Explore the new features and improvements:

• Documentation for R package: https://quarto-dev.github.io/quarto-r/
• Full changelog: https://quarto-dev.github.io/quarto-r/news/index.html
• Report issues: https://github.com/quarto-dev/quarto-r/issues

For detailed examples and workflows, check out the new vignettes:

• Dynamic metadata
• Markdown in HTML tables
• Working with R scripts
• All vignettes

Acknowledgments

Special thanks to all contributors that helped make this release:

@asadow, @caiolivf, @caocloud, @cderv, @coatless, @ColinFay, @cwickham, @davidrsch, @DillonHammill, @eitsupi, @GeorgeBatten, @gordonwoodhull, @jennybc, @jeroen, @joanbadia, @JosephBARBIERDARNAL, @LiNk-NY, @llrs-roche, @milanmlft, @papayoun, @petermacp, @remlapmot, @salim-b, @saudiwin, @smzimbo-bayer, @srvanderplas, and @wjschne.

Happy Quarto-ing with R!

The Problem: Repetitive Reporting

Would you rather read a generic “Climate summary” or a “Climate summary for exactly where you live”? Reports that are personalized to a specific situation increase engagement and connection. But producing many customized reports manually is tedious and error-prone.

Quarto solves this with parameterized reports—you create a single document template, then render it multiple times with different parameter values to generate customized outputs automatically.

A great example is the customized soil health reports from Washington Soil Health Initiative’s State of the Soils Assessment, presented at posit::conf(2023) by Jadey Ryan (watch on YouTube). Jadey demonstrated this approach using R and plain text Quarto files (.qmd).

This post shows you how to apply the same principles using Python: we’ll walk through converting a Jupyter notebook (.ipynb) into a parameterized report, then automating the generation of multiple customized outputs. Then I’ll give you some tips for making your reports look polished.

Pretty Reports: Brand and Typst

The steps above to produce parameterized reports apply to any output format supported by Quarto. However, if you are targeting typst you can take advantage of additional features to create beautiful PDF reports.

_brand.yml

color:
  palette:
    forest-green: "#2d5a3d"     
    charcoal-grey: "#555555"    
  foreground: charcoal-grey    
  primary: forest-green       
typography:
  fonts:
    - family: Open Sans
      source: google
  base:
    family: Open Sans
logo:
  medium: logo.png

jupyter vs knitr

The steps for creating a parameterized report above are specific to documents that use the jupyter engine. With a Jupyter notebook (.ipynb), or a plain text Quarto document (.qmd) with only Python code cells, Quarto will default to the jupyter engine. As described above, the jupyter engine uses cell tags to identify parameters.

If you are working in a .ipynb file, your IDE will likely provide a way to add these tags through the cell toolbar. If you are working in a .qmd file, you can add tags as a code cell option:

```{python}
#| tags: [parameters]
city = "Corvallis"
```

With the jupyter engine, parameters can then be accessed directly as variables, e.g. city, in later code cells.

If you are working in a Quarto document (.qmd) with R code cells, Quarto will default to the knitr engine. With the knitr engine, you set parameters in the document header under params:

---
params:
  city: "Corvallis"
---

In knitr, parameters are accessed as elements of params, e.g. params$city.

You can read more about setting and using parameters in Guide > Computations > Parameters.

Wrapping Up

Parameterized reports turn one notebook into many customized outputs. You’ve seen the process of going from a notebook with a hardcoded value to a parameterized report that can be rendered with different values. You can then automate the rendering in any way you choose to generate dozens of reports at once.

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.

[![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.

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

{
  "name": "Quarto",
1  // "image": "buildpack-deps:jammy-curl",
  "build": {
    "dockerfile": "./Dockerfile",
    "context": ".",
    "args": {
      "VARIANT": "jammy"
    }
  },
  "remoteUser": "vscode",
2  "features": {
3    "./quarto-computing-dependencies": {
      "rDeps": "rmarkdown,languageserver,nx10/httpgd@v2.0.3,prompt,lintr",
      "pythonDeps": "jupyter,papermill",
      "juliaDeps": "IJulia"
    },
4    "./uv": {
      "version": "latest"
    },
5    "ghcr.io/rocker-org/devcontainer-features/quarto-cli:1": {
      "version": "release",
      "installTinyTex": "true",
      "installChromium": "false"
    }
  },
6  "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
        }
      }
    }
  }
}

{
  "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"
}

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

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!

Dark Mode Improvements

_quarto.yml

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

document.qmd

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

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

_quarto.yml

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

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

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.

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

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

{{< 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 >}}.

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


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

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

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

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

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

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:

```{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:

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

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

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

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

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:

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:

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

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

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

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

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!