Why Quarto Stuck: Four Years from a Biostatistician’s Desk

Skip to main content

After four years of using Quarto every day, I want to explain why it stuck as my go-to for reports, slides, websites, and books. Before Quarto, that work was spread across R Markdown, bookdown, xaringan, and distill. Quarto folded all of that into one command line tool, and I have not looked back since the early days before v1.

NoteAt a Glance

• Four years of daily Quarto use.
• Close to 14,000 contributions on quarto-dev/quarto-cli across discussions, issues, and pull requests.
• One CLI replaced a fragmented R Markdown toolchain for reports, slides, websites, and books.
• The extension system turned Quarto into a platform: more than 40 extensions built and maintained.
• Typst for PDF: fast compilation, readable programming model, no more LaTeX friction.
• Gribouille: a grammar of graphics in pure Typst, so plots compile where the document does.

It Started by Helping Out

My time with Quarto began before v1: back-and-forth between the issue/discussion tracker and real document use in my research on the genetics of type 2 diabetes and obesity, when the CLI was still finding its shape. I still spend time in the quarto-dev/quarto-cli repository, answering questions, helping people troubleshoot, surfacing gaps in the documentation, and guiding the same R Markdown and bookdown migration I once made myself.

The figure below (Figure 1) traces that involvement month by month, split across discussions, issues, and pull requests, and it is itself drawn with Gribouille through the quarto-typst-render extension.¹

Figure 1: Monthly contributions to quarto-dev/quarto-cli from mid-2022 to mid-2026, split across discussions, issues, and pull requests.

The totals still catch me off guard. Close to 14,000 contributions in all: comments, replies, pull requests, issues, and discussions across four years.

Close to 14,000 contributions across discussions, issues, and pull requests: that is a lot of people who were stuck and then were not.

Working through those threads deepened my understanding of what Quarto does well and where it falls short, which shaped how I use it for my own work today.

From R Markdown to One CLI

The first thing that won me over was the scope of a single tool. With R Markdown I kept a small mental map of which package produced which output. With Quarto I write quarto render, and the same project gives me an HTML report, a PDF through Typst, a Reveal.js deck, a website, or a book. The fragmented toolchain became one CLI, and that alone changed how I work.

The defaults are also less surprising. Format options live under a single format: key, so an HTML and a PDF variant of the same document sit side by side instead of fighting each other. Even the format names are more intuitive: html, pdf, revealjs, website, and book are easier to remember than the R Markdown equivalents (also way less typing), and they are consistent across formats, so I do not have to remember that html_document is for HTML but pdf_document is for PDF. A project/directory-level _metadata.yml sets shared options once, and conditional content with {.content-visible when-format="html"} reads far more clearly than the output checks I used to scatter through R Markdown code cells. None of this is magic, it is just less surprising, and after years of small surprises that matters.

Multi-language support is also native in Quarto. I move between R and Python in the same workflow, even if not yet in the same document (I have strong hopes for Quarto 2 ongoing developments).

Note

R and Python still live in separate documents within a project, not in one shared session. For my work that boundary has never been a real problem. When both languages were needed, I relied on reticulate to call Python from R.

The look and feel out of the box is, in my opinion, simply better, especially for HTML. And because R is no longer mandatory, writing notes or plain prose is a first-class use case, not an afterthought. That is also what makes Quarto easy to recommend: I have helped colleagues and clients move from R and bookdown, without asking them to change how they think.

Building My Own

If one feature made Quarto really stick, it is the extension system. An extension adds shortcodes, filters, formats, or whole project types without forking or hacking the core. That single idea turned Quarto from a better R Markdown² into a platform I build on.

I know this because I keep building on it with tools that began as solutions to my own needs but that I share in the spirit of open source.

1. 2022 Q3Storybook, Coeos, Iconify, Letter, Animate, and Elevator, my first handful while learning the format.
2. 2022 Q4Masonry.
3. 2023 Q1Lua Env and Spotlight.
4. Preview Colour shows an inline swatch next to a hex, RGB, or HSL code. Also Version Badge.
   2023 Q2
5. Invoice is a Typst template I actually send to clients.
   2023 Q4
6. Highlight Text highlights text across HTML, Typst, Reveal.js, and Docx.
   2024 Q2
7. 2024 Q3GitHub, later replaced by Git Link.
8. Quarto Wizard manages extensions from VS Code and Positron.
   2024 Q4
9. 2025 Q1Div Reuse and Language Cell Decorator.
10. quarto-mcanouil brings brand.yml theming to HTML, Typst, and Reveal.js, and Git Link turns issue, pull request, and commit references into links. Also External, Modal, and TOC Depth.
    2025 Q3
11. Extensions Updater updates a project's extensions automatically, like Dependabot. Also Collapse Output, Remember, Tabset, and Offcanvas.
    2025 Q4
12. Code Window dresses code blocks as macOS or Windows windows, and Typst Render compiles Typst blocks to images for any format. Also A11y.
    2026 Q1
13. Prism attaches format-specific values to a single Div, Span, or CodeBlock. Also Fragmention, Cascade, and Code Annotation Fragments.
    2026 Q2

The extension system is the real unlock: it let me shape the authoring experience around my work instead of waiting for the core to grow a feature.

The same mechanism scales up. Embedding a Quarto format extension inside an R package gives a large organisation branded, client-ready HTML, PDF, and Reveal.js with its corporate identity baked in. My needs as a biostatistician and consultant drove most of this, and some of it the community adopted. Quarto Wizard manages extensions from VS Code and Positron, and the Quarto Extensions directory lists more than 300 of them through the GitHub API. I also maintain that directory as a community resource that stands apart from the core team, so anyone can find an extension without knowing it exists first. I have written before about the Wizard (1.0.0 and 2.0.0), about keeping extensions updated, and about the Lua behind Quarto extensions.

Then Came Typst

Building all of this kept pulling me toward one format in particular, and that format is Typst. It has become my most recent rabbit hole, both standalone with typst compile and through Quarto’s native typst output. For PDF it is a genuine step up from LaTeX: compilation is fast, the programming model is readable, and layout control is far more direct. I no longer dread a page that needs precise placement.

Out of that work came Gribouille, a grammar of graphics written in pure Typst, so I can draw a plot where the document is compiled rather than importing a rendered image. The chart above (Figure 1), the one tracing my time on quarto-cli, is one of its outputs. The non-obvious lesson, for me, was how little I missed LaTeX once the small frictions were gone. The other was that Typst’s documentation is remarkably easy to search: the model is consistent enough that the right page turns up before I have finished typing the query. My tutorials on building Typst templates for Quarto (Part 1 and Part 2) document those experiments, from document dispatching to the Gribouille releases, and most recently building LinkedIn carousels with Typst, which showed that the same source-to-output loop works for social content as well as technical documents.

Four Years On

Quarto stuck for a plain reason: it stopped getting in my way. What began as answering other people’s questions turned into building my own tools, and then into a new way to make PDFs altogether. Four years on, that is still why I open it every day.

There is also something coming I’m excited about, namely Quarto 2, a ground-up rewrite in Rust: faster compilation, a tree-sitter parser with real error messages, and a collaborative editor built on Automerge. I cannot wait, even though backwards compatibility is one of the main goals, some breaking changes are likely to occur in favour of a better experience, and I am sure it will be worth it.

Happy publishing!

Footnotes

1. The counts come from my own quarto-cli-activity data for quarto-dev/quarto-cli.

2. To be fair, R Markdown supports templates and filters, but to me they always felt like afterthoughts, not first-class features.