How does Quarto relate to R Markdown?

Updated

Quarto is a next-generation version of R Markdown from Posit. It keeps the core R Markdown workflow — write markdown, embed code, render to a document — but broadens it into a multi-language publishing system. According to Quarto's own documentation, it "uses knitr to execute R code, and is therefore able to render most existing Rmd files without modification." So if you already have R Markdown documents, you can often point Quarto at them and get output without rewriting anything.

What stays the same

  • Authoring model. You write Pandoc markdown with embedded code chunks, then render to a final format. The YAML header still controls title, author, date, and output format.
  • R execution path. Quarto runs R code through knitr, the same engine R Markdown uses. Existing R chunks and most R-specific behavior carry over.
  • Output formats. Both target HTML, PDF, Word, and more, so the publishing destinations you already use remain available.

What changes

Language scope

R Markdown is centered on R. Quarto is explicitly multi-language: the documentation describes dynamic content with Python, R, Julia, and Observable, and notes it supports Python, R, Julia, and JavaScript. The same document structure works across engines, so a team using both R and Python doesn't need two separate toolchains.

Engine options

For R, Quarto uses knitr as described above. For Julia, the documentation says Quarto executes code either via the julia engine using QuartoNotebookRunner.jl or via the jupyter engine using the IJulia Jupyter kernel. That engine choice is a Quarto concept — you can author in plain text or render existing Jupyter notebooks.

Authoring surface

You can author using Jupyter notebooks or plain text markdown in your editor. R Markdown is primarily a plain-text markdown workflow, so notebook-based authoring is a wider option in Quarto.

Markdown features

Quarto's Pandoc markdown includes equations, citations, crossrefs, figure panels, callouts, and advanced layout. Some of these (crossrefs, callouts, panels) are Quarto additions rather than things you'd get from a stock R Markdown setup.

Should you migrate?

Situation Reasonable choice
You have working Rmd files and only use R Try rendering them with Quarto first; migrate only if you want its newer features
You mix R and Python (or Julia) in one project Quarto, because it's multi-language by design
You want notebook-based authoring alongside markdown Quarto, which supports both
You need crossrefs, callouts, or figure panels Quarto, since these are part of its markdown feature set
Your Rmd relies on R Markdown-specific output or package behavior Test a render before committing; "most" files work, not all

How to check compatibility on a real document

  1. Take one existing .Rmd file.
  2. Render it with Quarto instead of rmarkdown::render().
  3. Compare the output against your current version — check figures, tables, cross-references, and the YAML header behavior.
  4. If it renders as expected, you can migrate incrementally; if not, keep that file on R Markdown while you move the rest.

The expected result is that a typical R-only Rmd renders without edits. The common sticking point is anything tied to R Markdown-only options or packages, which is why testing one representative file beats migrating everything at once.

Bottom line

Quarto is not a replacement you must adopt immediately — it's a superset built on the same R execution path. If your work is R-only and stable, staying on R Markdown is fine. If you want multi-language support, notebook authoring, or the newer markdown features, Quarto is the forward path, and your existing Rmd files are the starting point rather than a rewrite.