Performance

This page presents performance benchmarks for Panache, comparing its formatting and linting speed against popular alternatives like Prettier, Pandoc, rumdl, mdformat, Yamark, mado, markdownlint, and markdownlint-cli2 on real Quarto and Markdown documents, and its language-server memory use against Marksman. The benchmarks highlight Panache’s efficiency and suitability for editor and repository-wide work.

Overview

Panache is designed for speed without compromising on correctness. Built in Rust and compiled to native code, it delivers fast formatting with zero startup overhead. In this document, we present benchmarks comparing Panache’s formatting and linting performance against popular alternatives like Prettier, Pandoc, rumdl, mdformat, Yamark, mado, markdownlint, and markdownlint-cli2 on a realistic corpus of Quarto and Markdown documents. R Markdown is outside the current benchmark corpus.

We have split the benchmarks into two suites: per-document benchmarks that run each formatter on each document in the corpus individually, and repository-wide benchmarks that run formatters on entire repositories of tracked documents. The former highlights raw formatting speed on a variety of real-world documents; the latter captures the overhead of processing multiple files in a single run, which is more representative of on-save formatting or large-scale linting. Caches are disabled for all benchmarks to show worst-case performance.

Yamark runs with an empty configuration and external code formatters disabled (--config /dev/null --skip-embedded-formatters). Its default wrapping and style settings apply. Tools differ in supported syntax and formatting policy, so these timings compare their respective workloads. Failed repository runs have null timings in the data and are excluded from the plots.

The numbers on this page are produced by the scripts in benches/ and read from the JSON files written next to this document. The benchmark chunks on this page are intentionally not executed during preview or render, so small content edits reuse the existing JSON files instead of rerunning the benchmarks. Refresh the benchmark data explicitly with the commands at the bottom of this page, then delete docs/_freeze/guide/performance/ and re-render if you want the page to pick up newly generated results.

data = FileAttachment("performance_data.json").json();

documentMeta = new Map(data.documents.map((d) => [d.id, d]));

panacheByDoc = d3.rollup(
    data.results.filter((r) => r.formatter === "panache"),
    (v) => v[0].mean_ms,
    (r) => r.document,
);

records = data.results.map((r) => ({
    formatter: r.formatter,
    document: r.document,
    documentName: documentMeta.get(r.document)?.name ?? r.document,
    mean_ms: r.mean_ms,
    runs: r.runs,
    ratio: r.mean_ms / panacheByDoc.get(r.document),
}));

formatters = Array.from(
    d3.rollup(
        records,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.formatter,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);

documentIds = data.documents.map((d) => d.id);

formatterRanges = d3.rollup(
    records.filter((r) => r.formatter !== "panache"),
    (v) => {
        const lo = Math.round(d3.min(v, (d) => d.ratio));
        const hi = Math.round(d3.max(v, (d) => d.ratio));
        return `${lo}\u2013${hi}x`;
    },
    (d) => d.formatter,
);

prettierRange = formatterRanges.get("prettier") ?? "n/a";
pandocRange = formatterRanges.get("pandoc") ?? "n/a";
rumdlRange = formatterRanges.get("rumdl") ?? "n/a";
mdformatRange = formatterRanges.get("mdformat") ?? "n/a";

html`<div class="callout-note">
  <div class="callout-header" style="font-weight: 600">Test Environment</div>
  <ul style="margin: 0">
    <li>Generated: ${new Date(data.meta.generated_at).toUTCString()}</li>
    <li>Host: ${data.meta.host.cpu} (${data.meta.host.os}/${data.meta.host.arch})</li>
    <li>Minimum runs: ${data.meta.min_runs}</li>
    <li>panache ${data.meta.tools.panache.version}, prettier ${data.meta.tools.prettier?.version ?? "n/a"}, pandoc ${data.meta.tools.pandoc?.version ?? "n/a"}, rumdl ${data.meta.tools.rumdl?.version ?? "n/a"}, mdformat ${data.meta.tools.mdformat?.version ?? "n/a"}, yamark ${data.meta.tools.yamark?.version ?? "n/a"}, mado ${data.meta.tools.mado?.version ?? "n/a"}, markdownlint ${data.meta.tools.markdownlint?.version ?? "n/a"}, markdownlint-cli2 ${data.meta.tools["markdownlint-cli2"]?.version ?? "n/a"}</li>
  </ul>
</div>`;

Formatting

Single-Document

In Figure 1, we compare formatting time per document across panache, Prettier, Pandoc, rumdl, mdformat, and Yamark. Each dot is one document; the y-axis shows time relative to panache (×, lower is faster). Panache sits at 1× by construction (dashed baseline); points above it are slower. Hover a point to see the absolute wall-clock time in milliseconds. Formatters are ordered left-to-right from fastest to slowest on average.

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 360,
    x: { label: null, domain: formatters },
    y: {
        label: "Mean time relative to panache (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: documentIds,
        tickFormat: (id) => documentMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(records, {
            x: "formatter",
            y: "ratio",
            fill: "document",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                document: "documentName",
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 1: Formatting time per document, comparing panache to Prettier, Pandoc, rumdl, mdformat, and Yamark. Each dot is one document; the y-axis shows time relative to panache (×, lower is faster).

prepareRepoSuiteRows = (data, toolLabels) => {
    const repoMeta = new Map(data.repos.map((r) => [r.id, r]));
    const baselineByRepo = new Map(
        data.results
            .filter((r) => r.tool === "panache" && !r.failed && r.mean_ms != null)
            .map((r) => [r.repo, r.mean_ms]),
    );

    return data.results
        .filter((r) => !r.failed && r.mean_ms != null && baselineByRepo.has(r.repo))
        .map((r) => {
            const repo = repoMeta.get(r.repo);
            const repoLabel = repo?.name ?? r.repo;
            const toolLabel = toolLabels[r.tool] ?? r.tool;
            return {
                ...r,
                repoLabel,
                toolLabel,
                fileCount: repo?.file_count ?? null,
                totalBytes: repo?.total_bytes ?? null,
                barLabel: `${repoLabel} — ${toolLabel}`,
                ratio: r.mean_ms / baselineByRepo.get(r.repo),
            };
        });
};

Repository-Wide

repoMarkdownFormat = FileAttachment(
    "performance_repo_markdown_format_data.json",
).json();

repoMarkdownFormatResults = prepareRepoSuiteRows(repoMarkdownFormat, {
    panache: "panache",
    prettier: "prettier",
    rumdl: "rumdl",
    mdformat: "mdformat",
    yamark: "yamark",
});
repoMarkdownFormatTools = Array.from(
    d3.rollup(
        repoMarkdownFormatResults,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.toolLabel,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);
repoMarkdownFormatRepos = repoMarkdownFormat.repos.map((r) => r.id);
repoMarkdownFormatRepoMeta = new Map(
    repoMarkdownFormat.repos.map((r) => [r.id, r]),
);

In Figure 2, we compare formatting time across panache, Prettier, rumdl, mdformat, and Yamark on tracked Markdown files from several repositories.

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 320,
    x: { label: null, domain: repoMarkdownFormatTools },
    y: {
        label:
            "Mean time relative to panache within each repo (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: repoMarkdownFormatRepos,
        tickFormat: (id) => repoMarkdownFormatRepoMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(repoMarkdownFormatResults, {
            x: "toolLabel",
            y: "ratio",
            fill: "repo",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                repo: "repoLabel",
                tool: "toolLabel",
                files: (d) => d.fileCount,
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 2: Repository-wide formatting benchmarks on standard Markdown repos, comparing panache to Prettier, rumdl, mdformat, and Yamark. Each dot is one repo/tool pair; the y-axis shows time relative to panache within that repo (×, lower is faster).

repoQuartoFormat = FileAttachment(
    "performance_repo_quarto_format_data.json",
).json();

repoQuartoFormatResults = prepareRepoSuiteRows(repoQuartoFormat, {
    panache: "panache",
    rumdl: "rumdl",
    yamark: "yamark",
});
repoQuartoFormatTools = Array.from(
    d3.rollup(
        repoQuartoFormatResults,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.toolLabel,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);
repoQuartoFormatRepos = repoQuartoFormat.repos.map((r) => r.id);
repoQuartoFormatRepoMeta = new Map(
    repoQuartoFormat.repos.map((r) => [r.id, r]),
);

In Figure 3, we compare formatting time across panache, rumdl, and Yamark on tracked .qmd files from several Quarto repositories.

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 320,
    x: { label: null, domain: repoQuartoFormatTools },
    y: {
        label:
            "Mean time relative to panache within each repo (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: repoQuartoFormatRepos,
        tickFormat: (id) => repoQuartoFormatRepoMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(repoQuartoFormatResults, {
            x: "toolLabel",
            y: "ratio",
            fill: "repo",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                repo: "repoLabel",
                tool: "toolLabel",
                files: (d) => d.fileCount,
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 3: Repository-wide formatting benchmarks on Quarto repos. Each dot is one repo/tool pair; the y-axis shows time relative to panache within that repo (×, lower is faster).

Each dot is one repo/tool pair. Panache sits at 1× by construction (dashed baseline), and points above it are slower on that repository. Hover a point to see the absolute wall-clock time in milliseconds and the corpus size.

Linting

Single-Document

lintSingleData = FileAttachment("performance_lint_single_data.json").json();

lintDocumentMeta = new Map(lintSingleData.documents.map((d) => [d.id, d]));
lintPanacheByDoc = d3.rollup(
    lintSingleData.results.filter((r) => r.tool === "panache"),
    (v) => v[0].mean_ms,
    (r) => r.document,
);
lintSingleRecords = lintSingleData.results.map((r) => ({
    tool: r.tool,
    document: r.document,
    documentName: lintDocumentMeta.get(r.document)?.name ?? r.document,
    mean_ms: r.mean_ms,
    runs: r.runs,
    ratio: r.mean_ms / lintPanacheByDoc.get(r.document),
}));
lintTools = Array.from(
    d3.rollup(
        lintSingleRecords,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.tool,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);
lintDocumentIds = lintSingleData.documents.map((d) => d.id);

In Figure 4, we compare linting time per document across panache lint, rumdl check, mado check, markdownlint, and markdownlint-cli2. Each dot is one document; the y-axis shows time relative to panache lint (×, lower is faster). Panache sits at 1× by construction.

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 300,
    x: { label: null, domain: lintTools },
    y: {
        label: "Mean time relative to panache lint (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: lintDocumentIds,
        tickFormat: (id) => lintDocumentMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(lintSingleRecords, {
            x: "tool",
            y: "ratio",
            fill: "document",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                document: "documentName",
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache lint": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 4: Linting time per document, comparing panache lint to rumdl check, mado check, markdownlint, and markdownlint-cli2. Each dot is one document; the y-axis shows time relative to panache lint (×, lower is faster).

Repository-Wide

This suite benchmarks linting on the same standard Markdown repositories as the formatting comparison, using panache lint, rumdl check, mado check, markdownlint, and markdownlint-cli2. In Figure 5, each dot is one repo/tool pair; the y-axis shows time relative to panache lint within that repo (×, lower is faster).

repoMarkdownLint = FileAttachment(
    "performance_repo_markdown_lint_data.json",
).json();

repoMarkdownLintResults = prepareRepoSuiteRows(repoMarkdownLint, {
    panache: "panache lint",
    rumdl: "rumdl check",
    mado: "mado check",
    markdownlint: "markdownlint",
    "markdownlint-cli2": "markdownlint-cli2",
});
repoMarkdownLintTools = Array.from(
    d3.rollup(
        repoMarkdownLintResults,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.toolLabel,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);
repoMarkdownLintRepos = repoMarkdownLint.repos.map((r) => r.id);
repoMarkdownLintRepoMeta = new Map(
    repoMarkdownLint.repos.map((r) => [r.id, r]),
);

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 300,
    x: { label: null, domain: repoMarkdownLintTools },
    y: {
        label:
            "Mean time relative to panache lint within each repo (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: repoMarkdownLintRepos,
        tickFormat: (id) => repoMarkdownLintRepoMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(repoMarkdownLintResults, {
            x: "toolLabel",
            y: "ratio",
            fill: "repo",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                repo: "repoLabel",
                tool: "toolLabel",
                files: (d) => d.fileCount,
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache lint": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 5: Repository-wide linting benchmarks on standard Markdown repos, comparing panache lint to rumdl check, mado check, markdownlint, and markdownlint-cli2. Each dot is one repo/tool pair; the y-axis shows time relative to panache lint within that repo (×, lower is faster).

In Figure 6, we compare linting time across panache and rumdl on tracked .qmd files from several Quarto repositories.

repoQuartoLint = FileAttachment(
    "performance_repo_quarto_lint_data.json",
).json();

repoQuartoLintResults = prepareRepoSuiteRows(repoQuartoLint, {
    panache: "panache lint",
    rumdl: "rumdl check",
});
repoQuartoLintTools = Array.from(
    d3.rollup(
        repoQuartoLintResults,
        (v) => d3.mean(v, (d) => d.ratio),
        (d) => d.toolLabel,
    ),
)
    .sort(([, a], [, b]) => a - b)
    .map(([k]) => k);
repoQuartoLintRepos = repoQuartoLint.repos.map((r) => r.id);
repoQuartoLintRepoMeta = new Map(repoQuartoLint.repos.map((r) => [r.id, r]));

Plot.plot({
    marginLeft: 60,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 20,
    height: 320,
    x: { label: null, domain: repoQuartoLintTools },
    y: {
        label:
            "Mean time relative to panache lint within each repo (×, lower is faster)",
        grid: true,
    },
    color: {
        legend: true,
        domain: repoQuartoLintRepos,
        tickFormat: (id) => repoQuartoLintRepoMeta.get(id)?.name ?? id,
        scheme: "tableau10",
    },
    marks: [
        Plot.ruleY([1], {
            stroke: "#2a9d8f",
            strokeWidth: 2,
            strokeDasharray: "4 3",
        }),
        Plot.dot(repoQuartoLintResults, {
            x: "toolLabel",
            y: "ratio",
            fill: "repo",
            r: 6,
            fillOpacity: 0.85,
            stroke: "white",
            strokeWidth: 1,
            channels: {
                repo: "repoLabel",
                tool: "toolLabel",
                files: (d) => d.fileCount,
                "time (ms)": (d) => d.mean_ms.toFixed(1),
                "× panache lint": (d) => d.ratio.toFixed(2),
            },
            tip: true,
        }),
    ],
});

Figure 6: Repository-wide linting benchmarks on Quarto repos. Each dot is one repo/tool pair; the y-axis shows time relative to panache lint within that repo (×, lower is faster).

Language-Server Memory

This Linux-only benchmark compares the complete process-tree memory used by Panache and Marksman. It opens the five largest tracked Markdown files in a pinned revision of the Rust Book, requests diagnostics and navigation features, and then performs 1,000 fixed-width reference-label renames. Each rename is followed by a definition request, which forces the server to observe the updated label index.

The runner samples RSS and proportional set size (PSS) from /proc every 150 milliseconds. It records a milestone after the process tree remains below 5% of one CPU core for five seconds, and reports medians from three fresh server processes run in alternating order.

lspMemory = FileAttachment("performance_lsp_memory_data.json").json();

lspMemoryMilestones = [
    { key: "baseline", label: "Baseline" },
    { key: "settled", label: "Files open" },
    { key: "edited", label: "After edits" },
    { key: "peak", label: "Peak" },
];

lspMemoryRows = lspMemory.servers.flatMap((server) =>
    lspMemoryMilestones.map((milestone) => ({
        server: server.label,
        milestone: milestone.label,
        rss: server.aggregate.milestones[milestone.key].rss_mb,
        pss: server.aggregate.milestones[milestone.key].pss_mb,
    })),
);

lspMemoryTable = lspMemory.servers.map((server) => ({
    server: server.label,
    settledRss: server.aggregate.milestones.settled.rss_mb,
    editedRss: server.aggregate.milestones.edited.rss_mb,
    editedPss: server.aggregate.milestones.edited.pss_mb,
    peakRss: server.aggregate.milestones.peak.rss_mb,
    ratio: server.aggregate.relative_to_panache.edited_rss,
}));

html`<div class="callout-note">
  <div class="callout-header" style="font-weight: 600">Test Environment</div>
  <ul style="margin: 0">
    <li>Generated: ${new Date(lspMemory.meta.generated_at).toUTCString()}</li>
    <li>Host: ${lspMemory.meta.host.cpu} (${lspMemory.meta.host.os}/${lspMemory.meta.host.arch}, ${lspMemory.meta.host.memory_gb} GiB RAM)</li>
    <li>Corpus: ${lspMemory.corpus.name} at ${lspMemory.corpus.revision.slice(0, 12)}; ${lspMemory.session.file_count} open files (${(lspMemory.session.opened_bytes / 1024).toFixed(1)} KiB)</li>
    <li>Workload: ${lspMemory.meta.edit_count.toLocaleString()} edits; ${lspMemory.meta.runs} fresh processes per server</li>
    <li>${lspMemory.servers.map((server) => `${server.label}: ${server.version.replace(/^panache /, "")}`).join(", ")}</li>
  </ul>
</div>`;

Plot.plot({
    marginLeft: 55,
    marginRight: 20,
    marginBottom: 40,
    marginTop: 25,
    height: 320,
    x: { label: null },
    y: { label: "Median process-tree RSS (MB)", grid: true },
    fx: { label: null, domain: lspMemoryMilestones.map((d) => d.label) },
    color: { legend: true, domain: ["Panache", "Marksman"], scheme: "tableau10" },
    marks: [
        Plot.barY(lspMemoryRows, {
            fx: "milestone",
            x: "server",
            y: "rss",
            fill: "server",
            tip: true,
        }),
        Plot.text(lspMemoryRows, {
            fx: "milestone",
            x: "server",
            y: "rss",
            text: (d) => d.rss.toFixed(1),
            dy: -7,
        }),
        Plot.ruleY([0]),
    ],
});

Figure 7: Median whole-process-tree RSS during the language-server workload. Each milestone is measured after quiescence, except peak, which is the largest 150 ms sample from the complete session.

Inputs.table(lspMemoryTable, {
    columns: [
        "server",
        "settledRss",
        "editedRss",
        "editedPss",
        "peakRss",
        "ratio",
    ],
    header: {
        server: "Server",
        settledRss: "Files-open RSS (MB)",
        editedRss: "Post-edit RSS (MB)",
        editedPss: "Post-edit PSS (MB)",
        peakRss: "Peak RSS (MB)",
        ratio: "Post-edit RSS vs Panache",
    },
    format: {
        settledRss: (value) => value.toFixed(1),
        editedRss: (value) => value.toFixed(1),
        editedPss: (value) => value.toFixed(1),
        peakRss: (value) => value.toFixed(1),
        ratio: (value) => `${value.toFixed(1)}×`,
    },
});

Marksman used 8.2 times as much RSS as Panache after the files were open and 7.5 times as much after edit churn. Panache’s median RSS rose from 16.8 MB to 21.5 MB during the 1,000 edits; the three runs finished within 0.2 MB of one another. This workload therefore did not reproduce unbounded growth in Panache.

The comparison measures default architecture, not identical internal work. Marksman indexes the Markdown workspace eagerly, while Panache analyzes open documents and discovers project relationships lazily. Both servers receive the same open, edit, and navigation sequence, while diagnostics use each server’s advertised pull or push mode. Their memory totals reflect those different strategies.

Reproducing

All benchmarks are reproducible. The formatting and linting comparisons require hyperfine; the language-server memory comparison requires Linux with /proc and Marksman. The scripts in benches/ are designed to be run from the repository root:

# Download test documents (idempotent)
cd benches/documents && ./download.sh && cd ../..

# Outside devenv: install Yamark and record its version
# The development environment already provides both.
uv tool install yamark==0.3.0
export PANACHE_BENCH_YAMARK_VERSION=0.3.0

# Run comparison benchmark and write JSON
bash benches/compare_all.sh --json --out docs/guide/performance_data.json

# Run repository-wide Markdown formatting benchmark
bash benches/compare_repo_suite.sh --mode format --track markdown --out docs/guide/performance_repo_markdown_format_data.json

# Run repository-wide Quarto formatting benchmark
bash benches/compare_repo_suite.sh --mode format --track quarto --out docs/guide/performance_repo_quarto_format_data.json

# Run repository-wide Markdown lint benchmark
bash benches/compare_repo_suite.sh --mode lint --track markdown --out docs/guide/performance_repo_markdown_lint_data.json

# Run repository-wide Quarto lint benchmark
bash benches/compare_repo_suite.sh --mode lint --track quarto --out docs/guide/performance_repo_quarto_lint_data.json

# Run per-document lint benchmark
bash benches/compare_lint_single.sh --out docs/guide/performance_lint_single_data.json

# Run the Linux language-server memory benchmark
task bench:lsp-memory

# Or run the human-readable text variant
bash benches/compare_all.sh

# Re-render this page (uses freeze cache by default)
quarto render docs/guide/performance.qmd

# Force the benchmark to re-run by invalidating the freeze cache
rm -rf docs/_freeze/guide/performance
quarto render docs/guide/performance.qmd