State Quarto 2026: Where the Platform Stands Today

March 13, 2026 · 6 min read ·Updated May 28, 2026

rquartopythonjuliareproducible-researchpublishingdata-science

The state Quarto achieved by 2026 is striking. What started in 2022 as a spiritual successor to R Markdown has evolved into a full-fledged scientific publishing platform that supports R, Python, Julia, and Observable JavaScript. The current state of Quarto makes it the standard bearer for reproducible research, no longer the newcomer it once was.

This guide walks through where Quarto stands today, what has changed, and why it should be your default choice for technical documents, reports, websites, and books.

Quarto in 2026: the big picture

The Quarto project reached a significant maturity milestone in late 2025 with the release of version 1.8, followed by incremental improvements in 1.9. The ecosystem has expanded dramatically, with:

Native support for multiple languages, R, Python, Julia, and Observable all work out of the box
A rich extension ecosystem, The extension catalog now hosts hundreds of community-contributed plugins
Improved publishing workflows, Direct publishing to Posit Connect Cloud, GitHub Pages, and other platforms
Better performance, Document rendering is noticeably faster, especially for large projects

If you are still using R Markdown for new projects in 2026, it is worth understanding what you are missing.

What makes Quarto different from R markdown

Configuration that scales

The most immediate improvement over R Markdown is how Quarto handles configuration. Where R Markdown scattered chunk options across your document, Quarto uses a centralized YAML file:

project:
  type: website
  output-dir: _site

format:
  html:
    theme: cosmo
    code-fold: true
    toc: true

This scales beautifully. You configure your project once, and every document respects those defaults. No more repeating setup chunks in every .Rmd file.

Cross-Language support

Quarto was built from the ground up to be language-agnostic. You can mix R, Python, and Julia code in the same document. A Python chunk creates a data frame:

import pandas as pd
df = pd.DataFrame({"x": range(10)})

The reticulate bridge, which Quarto activates automatically when it detects both R and Python code blocks in the same document, passes the Python-created data frame directly into the R runtime. This means you can use Python for tasks where its ecosystem excels, such as web scraping or deep learning, then switch to R for statistical modeling and visualization without writing explicit data transfer code. The R chunk below picks up df and plots it immediately:

library(ggplot2)
ggplot(df, aes(x = x, y = x^2)) + geom_line()

This is genuinely useful when you are bridging communities or combining tools. R users can incorporate Python libraries; Python users can tap into R unique statistical capabilities.

Superior output formats

Quarto supports more output formats with better defaults than R Markdown ever did:

HTML, Responsive, accessible, with built-in support for lightbox galleries and interactive elements
PDF, Uses LaTeX under the hood but with cleaner defaults
Word, Produces usable .docx output that colleagues can actually edit
Presentations, Reveal.js for HTML slides, Beamer for PDF slides
Websites and books, Full multi-page sites with navigation
Dashboards, Interactive dashboards with Shiny, Observable, or static HTML

New features in 2025-2026

Extension system

The extension system has matured significantly. You can now install extensions with a single command:

quarto add quarto-ext/shinylive
quarto add quarto-ext/fontawesome

Extensions add shortcodes, Lua filters, and post-processing capabilities. The community has built extensions for everything from Lightbox image galleries to interactive Shiny-in-the-browser via WebAssembly.

Posit Connect cloud

Publishing to Posit Connect just got easier. Quarto 1.9 adds direct support for Posit Connect Cloud:

quarto publish posit-connect-cloud

This simplifies the workflow for teams using Posit Team, removing the need for manual API key configuration.

Improved Python integration

The Python experience in Quarto has improved substantially. Key improvements include:

Virtual environment detection, Quarto automatically finds and uses your Python environment
Jupyter kernel selection, You can specify which kernel to use for each code cell
Better error handling, Cell errors no longer crash the entire render

Dashboard improvements

Quarto dashboards have become genuinely useful. You can now create:

Interactive dashboards with Shiny
Observable-based dashboards with no Shiny server required
Parameter-driven dashboards that respond to user input

When to still use R markdown

R Markdown is not dead. It still makes sense in a few specific situations:

Legacy projects, If you have an existing R Markdown project that works, there is no reason to migrate just for the sake of it
Package vignettes, The vignette engine in R packages still expects R Markdown
Tight RStudio integration, Some RStudio features work more smoothly with R Markdown

But for new projects, Quarto is the clear choice.

Migrating from R markdown

If you are ready to switch, the migration path is straightforward:

Rename your .Rmd files to .qmd
Add a _quarto.yml configuration file to your project root
Review chunk options, most work the same, but some syntax has changed
Test your outputs

Quarto provides a migration guide in its documentation, and the tool is forgiving. Most projects migrate in under an hour.

Building a Quarto website

One of Quarto strongest features is its website capabilities. Creating a multi-page documentation site takes minutes:

quarto create project website my-site
cd my-site
quarto serve

Your site gets automatic navigation, table of contents, search functionality, and responsive design. You can publish directly to GitHub Pages with quarto publish gh-pages.

Quarto for books

Writing a technical book? Quarto has dedicated book support that handles chapter numbering, cross-references, index generation, and multiple output formats (PDF, HTML, ePub). The Quarto documentation itself is written in Quarto, which shows it handles large documents well for large documents.

The ecosystem in 2026

What truly sets Quarto apart is the growing ecosystem. Quarto Pub offers free hosting, Posit Cloud provides full browser-based support, RStudio has native Quarto integration, and VS Code offers an excellent Quarto extension with preview, autocomplete, and debugging. JupyterLab also handles Quarto documents naturally.

The technical foundation

Quarto is built on Pandoc and executes code through knitr (for R) or Jupyter (for Python and Julia). The .qmd file format is text-based, making it version-control friendly. Output formats are controlled by YAML options and can include custom templates, CSS overrides, and extension filters. For teams that need reproducible document pipelines, Quarto’s ability to cache computation results (via freeze: true in _quarto.yml) allows rebuilding a site without re-executing every notebook.

The project format (multiple .qmd files with a shared _quarto.yml) scales from a single document to a full website with navigation, cross-references, and search. Quarto websites can be deployed as static HTML, which means they serve without a running R process, a significant operational advantage over Shiny-based reporting tools.