DEV Community: paperquire

I Was Tired of Fighting Google Docs to Make a PDF Look Professional

paperquire — Thu, 09 Jul 2026 19:05:22 +0000

The report that broke me

Every Friday, I write a project status report. It has a table, some bullet points, a diagram, and a cover page. Pretty standard.

The writing takes 15 minutes. The formatting takes 30.

I'd paste my notes into Google Docs, fight with the table borders, nudge the logo into place, realize the page break moved, fix the heading sizes, export to PDF, notice the footer is wrong, go back, fix it, export again. Every. Single. Week.

One Friday I caught myself manually adjusting cell padding for the third time and thought: this is absurd. I write the content in plain text anyway. Why can't I just... keep it in plain text and get a PDF that looks good?

What I wanted

The requirements were simple:

Write in Markdown. I already think in Markdown. Every spec, every README, every set of notes — it's all Markdown.
See what it looks like. Not after export. While I'm writing. Side by side.
Pick a template once. Corporate branding, cover page, headers, footers — set it and forget it.
Export to PDF. One click. No reformatting, no surprises.
Keep everything local. I don't want my internal documents on someone else's server.

That's it. I didn't need collaboration. I didn't need comments. I didn't need a subscription to generate a PDF from my own text.

I looked around. Pandoc can do Markdown to PDF, but you need LaTeX installed, the output looks academic, and there's no preview. Obsidian is great for notes but it's not a document tool — you can't set up cover pages or branded headers. Typora is close but no templates, no diagrams in PDFs, and development has stalled.

Nothing did what I wanted. So I built it.

What PaperQuire does

PaperQuire is a desktop app. You open it, you write Markdown, you see a live preview, you click Export. That's the workflow.

Here's what makes it different from "just another Markdown editor":

Live split-pane preview. The right side shows your formatted document in real time — exactly what your PDF will look like. Tables render. Code blocks highlight. Mermaid diagrams draw. Obsidian callouts style. What you see is what you export.

Templates that actually work. Open Document Setup, pick "Executive Report" or "Technical Design" or "Minimal Clean." The template handles cover pages, headers, footers, page numbering, branding colors, typography. Your content doesn't change. The presentation does.

Mermaid diagrams. Write a mermaid code block, see a flowchart or sequence diagram in the preview. It embeds in your PDF. No screenshots, no external tools, no "paste this image here."

Export to everything. PDF, Word, HTML, Confluence. Same document, every format. The command palette lets you do it all from the keyboard.

Plugins. Auto-linking URLs, emoji shortcodes, word count, Obsidian-style callouts. Install what you want, ignore what you don't.

CLI. paperquire report.md gives you report.pdf. paperquire batch ./docs renders an entire directory. Works in scripts, CI/CD pipelines, and cron jobs.

100% offline. PaperQuire uses Chromium's built-in print engine. No server, no account, no upload. Your documents never leave your machine.

The Friday report, after

Now my Friday looks like this:

Open PaperQuire. My template is already set — "Executive Report" with company branding.
Write the report in Markdown. Tables in pipe syntax, bullets with dashes, a Mermaid diagram for the architecture overview.
Watch the preview update as I type. If something looks off, I fix the Markdown.
Click Export → PDF.

15 minutes, start to finish. The formatting is handled. The cover page is there. The footer has the page numbers. I never touch a style menu.

That 30 minutes of formatting every week? Gone. Over a year, that's 26 hours I got back. And every report looks consistent — not "close enough" but identical, because it's the same template every time.

The part I didn't expect

I built PaperQuire for myself. But the CLI changed things.

Once you can render Markdown to PDF from the terminal, you can automate it. We added a GitHub Action — now our docs repo generates fresh PDFs on every push. No one has to remember to export. No one sends a stale version. The CI pipeline handles it.

- uses: paperquire/render-action@v1
  with:
    files: 'docs/*.md'
    template: executive-report

Then came the MCP server. Claude, ChatGPT, Copilot — they can call PaperQuire directly. The AI writes the Markdown, PaperQuire renders the PDF. No copy-paste, no manual formatting step.

The tool I built to fix my Friday report turned into something bigger. But the core is still the same: write in Markdown, get a professional document. That's it.

Try it

PaperQuire is free. It runs on macOS, Windows, and Linux.

Or install via Homebrew:

brew install --cask paperquire/paperquire/paperquire

If you've ever spent more time formatting a document than writing it, give it a shot.

The 10-Minute Document: A Complete Markdown-to-PDF Workflow

paperquire — Thu, 09 Jul 2026 19:05:10 +0000

People ask us what a "real" PaperQuire workflow looks like. Not the marketing version — the actual, honest, here's-what-I-do-on-a-Tuesday version.

So here it is. Start to finish, blank file to client-ready PDF, timed.

Minute 0–2: Dump Your Thoughts

Open PaperQuire. New document. Start writing.

Don't worry about structure yet. Get the content out of your head and into the editor:

# Project Proposal: Dashboard Redesign

client wants a modernized analytics dashboard
current one is slow, hard to read, built 4 years ago

## What we'll do
- redesign the main dashboard view
- add real-time data refresh (currently manual)
- mobile responsive
- new charting library (recharts or visx)
- dark mode support

## Timeline
phase 1 - design mockups - 2 weeks
phase 2 - frontend rebuild - 4 weeks
phase 3 - data layer + API - 3 weeks
phase 4 - testing + launch - 2 weeks

## Cost
estimate around $45k for the full project
could do phase 1 standalone for $8k

team: 1 designer, 2 frontend devs, 1 backend dev

That's two minutes of typing. It's rough, but all the substance is there.

Minute 2–4: Let AI Assist Polish It

Select the entire document. Right-click, AI Assist > Rewrite with the custom prompt: "Rewrite this as a professional client-facing project proposal. Keep all the details. Use confident, clear language."

In about 10 seconds, your rough notes become:

# Project Proposal: Analytics Dashboard Redesign

## Overview

We propose a complete redesign of your analytics dashboard to
address performance limitations, improve usability, and support
modern workflows including mobile access and dark mode.

The current dashboard, built four years ago, has served its purpose
but no longer meets the speed and flexibility requirements of your
growing team. Our redesign will modernize the technology stack,
introduce real-time data refresh, and deliver a responsive
experience across all devices.

## Scope of Work

- **Dashboard redesign** — A modern, intuitive layout optimized
  for quick data comprehension
- **Real-time data refresh** — Automated updates replacing the
  current manual refresh workflow
- **Responsive design** — Full functionality on desktop, tablet,
  and mobile devices
- **Modern charting** — Migration to a performant charting library
  for faster rendering and richer visualizations
- **Dark mode** — System-aware theme switching for comfortable
  viewing in any environment

Review it, tweak a sentence or two, move on.

Minute 4–5: Add Structure

Add a few finishing touches that the AI didn't know about:

Add a pricing table using Markdown tables
Add a Mermaid diagram showing the project phases
Add a callout with the key decision point

## Investment

| Phase | Scope | Duration | Cost |
|-------|-------|----------|------|
| 1. Design | Mockups & prototypes | 2 weeks | $8,000 |
| 2. Frontend | UI rebuild | 4 weeks | $18,000 |
| 3. Backend | Data layer & API | 3 weeks | $13,000 |
| 4. Launch | Testing & deployment | 2 weeks | $6,000 |
| **Total** | | **11 weeks** | **$45,000** |

> **Standalone option:** Phase 1 can be executed independently
> for $8,000 to validate the design direction before committing
> to the full build.

## Timeline

```mermaid
gantt
    title Project Timeline
    dateFormat  YYYY-MM-DD
    section Design
    Mockups & Prototypes    :a1, 2026-08-01, 14d
    section Frontend
    UI Rebuild              :a2, after a1, 28d
    section Backend
    Data Layer & API        :a3, after a1, 21d
    section Launch
    Testing & Deployment    :a4, after a2, 14d
```

Two more minutes. Now you have a real proposal with a pricing breakdown and a visual timeline.

Minute 5–6: Apply a Template

Click the template selector. Choose Corporate. Set your branding:

Company logo (drag and drop or select from assets)
Primary color to match your brand
Subtitle: "Prepared for [Client Name]"
Author: your name
Date: today

The live preview instantly shows your content in a polished, professional layout with a branded cover page.

Minute 6–7: Final Review

Scroll through the preview. Check that:

The cover page looks right
Tables aren't breaking across pages awkwardly
The Mermaid diagram rendered correctly
Page breaks fall in sensible places
Headers and footers show the document title and page numbers

If an H1 heading is landing at the bottom of a page, toggle on H1 page breaks in document settings. Done.

Minute 7: Export

Click Export > PDF. A 6-page branded proposal downloads in about 3 seconds.

That's it. Seven minutes from a blank file to a document you'd be comfortable sending to a client worth $45,000.

Why This Matters

The traditional version of this workflow:

Write notes in a text editor (5 min)
Open Google Docs or Word (1 min)
Copy-paste and reformat everything (15 min)
Create a table manually (5 min)
Make a diagram in a separate tool, export, embed (10 min)
Apply brand colors and fonts manually (10 min)
Add a cover page (5 min)
Fix page breaks and layout issues (10 min)
Export to PDF (1 min)

Total: ~62 minutes. And you'll need to redo steps 3–8 for every similar document.

With PaperQuire, that's 7 minutes. The template is reusable. The branding is automatic. The diagrams live in your Markdown. The AI handles the prose polish.

That's not a marginal improvement — it's a fundamentally different way of working.

The Compound Effect

One document saves you 55 minutes. But teams don't produce one document.

If your team produces 10 proposals a month, that's 550 minutes saved — over 9 hours. Per month. That's more than a full working day returned to actual work, every single month.

And proposals are just one type. Add in weekly reports, project specs, SOPs, onboarding docs, and technical write-ups, and the numbers multiply fast.

Download PaperQuire and try this workflow yourself. The free plan includes everything you need to go from Markdown to PDF.

Plugins That Actually Matter: Diagrams, Math, and More Inside Your Documents

paperquire — Tue, 07 Jul 2026 22:50:15 +0000

Most document tools force a choice: write in a simple editor and lose advanced features, or use a complex tool and spend half your time fighting it.

PaperQuire's plugin system gives you a third option. Start simple, add capabilities when you need them, and everything renders cleanly in your exported PDFs.

What Plugins Do

Plugins extend what PaperQuire can render from Markdown. Without plugins, you get standard Markdown — headings, lists, tables, links, images, code blocks. With plugins, you get:

Mermaid — Flowcharts, sequence diagrams, Gantt charts, ER diagrams, and more
KaTeX — Publication-quality math equations
Syntax highlighting — Language-aware code coloring for 190+ languages
Emoji — Shortcodes rendered as native emoji in your documents
Footnotes — Proper footnotes with numbered references

Each plugin activates independently. Enable what you need, leave the rest off.

Mermaid: Diagrams That Live in Your Markdown

This is the plugin that changes workflows. Instead of drawing diagrams in a separate tool, exporting PNGs, and embedding them (and then re-doing all of that when something changes), you write the diagram in your Markdown:

```mermaid
graph LR
    A[Write Markdown] --> B[PaperQuire]
    B --> C[Professional PDF]
    B --> D[Branded DOCX]
    B --> E[Clean HTML]
```

PaperQuire renders this as a crisp vector diagram directly in your document. When you update the diagram, you edit text — not an image file.

This works for architecture docs, process flows, project timelines, database schemas, and anything else you'd normally draw in Lucidchart or draw.io.

Supported diagram types:

Flowcharts (graph TD, graph LR)
Sequence diagrams
Gantt charts
Class diagrams
Entity-relationship diagrams
State diagrams
Git graphs
Pie charts

All rendered locally. No external service, no API call, no internet required.

KaTeX: Math That Doesn't Require LaTeX

If you write technical or academic documents, you've probably wrestled with equation rendering. KaTeX gives you LaTeX-quality math without the LaTeX toolchain:

Inline math with single dollar signs: $E = mc^2$

Block equations with double dollar signs:

$$
\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}
$$

This renders beautifully in both the preview and the exported PDF. No separate compilation step, no missing fonts, no "why is this equation a blurry image."

Syntax Highlighting: Code That's Actually Readable

The syntax highlighting plugin uses Prism to color-code your code blocks. Specify the language after the opening backticks:

```python
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
```

This renders with proper color-coded syntax in your PDF — keywords, strings, comments, and functions all visually distinct. It supports 190+ languages out of the box.

For technical documentation and engineering specs, this is the difference between "readable" and "I'll just look at the repo."

How to Enable Plugins

Open PaperQuire, go to Settings > Plugins, and toggle on what you need. That's it. No package manager, no config files, no restart required.

Plugins activate immediately in the editor preview and in all future exports.

Plugins + Templates: The Full Picture

Here's where it comes together. Say you're writing a technical architecture document:

Markdown gives you the structure — headings, paragraphs, lists
Mermaid plugin gives you the system diagram and sequence flows
Syntax highlighting plugin gives you readable code samples
KaTeX plugin gives you the performance equations
Technical template gives you the professional layout, TOC, and branding

One file. One tool. One export. The output is a document that looks like it took a team of technical writers and a graphic designer to produce.

Building Custom Plugins

PaperQuire's plugin API is open and documented. If the built-in plugins don't cover your use case, you can build your own:

Markdown-it plugins — extend the Markdown parser to support new syntax
CSS plugins — add custom styles for specific content types
Transform plugins — modify the HTML output before it reaches the PDF renderer

The plugin documentation has examples and a starter template. If you've written a markdown-it plugin before, you already know how it works.

All built-in plugins are included on every plan. See the full plugin list or download PaperQuire and enable them in Settings.

Stop Formatting, Start Writing: How Templates Save Hours Every Week

paperquire — Tue, 07 Jul 2026 22:50:03 +0000

Every team has that one person who "owns" the document template. They spend hours tweaking margins, fixing font sizes, making sure the logo is in the right spot. And every time someone else creates a document, it looks... different.

Templates fix this permanently.

The Problem with Manual Formatting

Think about how much time goes into formatting a single document:

Choosing fonts and sizes for headings, body, captions
Setting margins and page breaks
Adding a cover page with the right logo and colors
Making sure tables don't break across pages in ugly ways
Getting headers and footers consistent
Adjusting all of this again when someone says "can you make the headings blue?"

Now multiply that by every document your team produces. Proposals, quarterly reports, SOPs, onboarding guides, project specs. That's hundreds of hours a year spent on work that adds zero value to the content.

How PaperQuire Templates Work

A template in PaperQuire is a combination of:

A CSS theme — fonts, colors, spacing, page layout, table styles, code block styles
Cover page settings — logo, title placement, tagline, color bar
Page setup — paper size, margins, header/footer content
Typography rules — how headings, lists, blockquotes, and images render in print

You write your content in plain Markdown. When you export, the template handles everything else.

# Q2 Business Review

## Revenue Summary

| Region    | Target | Actual | Variance |
|-----------|--------|--------|----------|
| Americas  | $4.2M  | $4.7M  | +12%     |
| EMEA      | $2.1M  | $2.0M  | -5%      |
| APAC      | $1.8M  | $1.6M  | -11%     |

> **Key takeaway:** Americas overperformance offset
> shortfalls in international markets.

That same Markdown renders differently depending on which template you apply — corporate blue for the board, minimal for the engineering team, branded for client-facing proposals. Same content, different output, zero re-formatting.

Built-in Templates

PaperQuire ships with templates designed for real work:

Corporate — Clean, professional layout with a branded cover page. Tables have alternating row colors, headings use your brand color, and page numbers appear in the footer. This is the one you send to clients and executives.

Technical — Optimized for specs, architecture docs, and engineering proposals. Code blocks are prominent, tables are compact, and there's generous spacing for readability. Supports table of contents with up to 4 levels of depth.

Minimal — Understated typography with lots of whitespace. No cover page, no color accents — just clean text on clean pages. Good for internal memos, meeting notes, and anything where the content speaks for itself.

Report — Structured for longer documents. Automatic table of contents, chapter-style H1 headings with page breaks, and running headers that show the current section. Built for 20+ page documents that need to feel organized.

Custom Templates: Your Brand, Every Time

Every template is fully customizable through the branding panel:

Primary color — applied to headings, table headers, cover page accents
Logo — embedded in the cover page, automatically scaled
Fonts — choose from system fonts or bundled professional typefaces
Margins — set independently for each side, in inches or millimeters
H1 underline — adjust thickness and color, or turn it off entirely

Change these once, and every document you export uses them. When marketing updates the brand guidelines, you update one setting — not fifty documents.

A Real Example: Proposal Workflow

Here's what a proposal workflow looks like with templates:

Open PaperQuire, start a new document
Write the proposal content in Markdown — scope, timeline, pricing, terms
Select the "Corporate" template
Set your client's name as the subtitle, your company as author
Click Export — a branded, professional PDF is ready in seconds

No switching between apps. No copying content into a Word template. No "why does page 3 look different from page 1." The template guarantees consistency from the first page to the last.

Templates + AI Assist = Speed

Combine templates with AI Assist for the fastest document workflow possible:

Dump your rough notes or bullet points into the editor
Use AI Assist to expand and polish the content
Apply a template
Export

You can go from a Slack thread to a client-ready proposal in under ten minutes. That's not a marketing claim — it's arithmetic. The writing takes five minutes, the AI polish takes two, and the export takes three seconds.

Templates are available on all plans, with custom branding on Pro. Browse the template gallery or download PaperQuire to try them with your own content.

PaperQuire v0.3.0 — Your AI Agent's PDF Tool

paperquire — Sat, 04 Jul 2026 23:23:10 +0000

AI agents can now generate PDFs

Large language models are great at producing Markdown. What they can't do is turn that Markdown into a polished, branded PDF. That's always been a manual step — copy the output, paste it somewhere, fiddle with formatting, export.

PaperQuire v0.3.0 removes that step entirely. The app now includes a built-in Model Context Protocol (MCP) server. Any MCP-compatible AI agent — Claude, ChatGPT, Copilot, or others — can call PaperQuire directly as a tool to render Markdown into professional documents.

What is MCP?

MCP is an open protocol that lets AI applications call external tools over a standard JSON-RPC interface. Think of it as "USB-C for AI tools" — one protocol, many tools. When you configure PaperQuire as an MCP server, your AI agent discovers its capabilities automatically and can call them during a conversation.

How it works

Run the MCP server as a CLI subcommand:

paperquire mcp-server

The server exposes four tools:

render — convert Markdown to PDF with full template and branding support
list_templates — discover all 8 built-in templates
show_template — inspect a template's design tokens, cover style, and page config
batch_render — render multiple documents in one call (Pro)

It also exposes a paperquire://config resource that returns your project's .paperquire.yml configuration, so the agent can discover your preferred template and branding before rendering.

Setup

Claude Desktop

Add this to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "paperquire": {
      "command": "paperquire",
      "args": ["mcp-server"]
    }
  }
}

Restart Claude Desktop, and you'll see PaperQuire's tools in the MCP panel.

Claude Code

Add to your project's .mcp.json:

{
  "mcpServers": {
    "paperquire": {
      "command": "paperquire",
      "args": ["mcp-server"]
    }
  }
}

VS Code (GitHub Copilot)

Add to .vscode/mcp.json:

{
  "mcp": {
    "servers": {
      "paperquire": {
        "command": "paperquire",
        "args": ["mcp-server"]
      }
    }
  }
}

What you can ask your agent to do

Once configured, you can ask things like:

"Write a project status report for Q2 and render it as a branded PDF."

"What templates does PaperQuire have? Show me the technical design template, then use it to render my spec."

"Render all the markdown files in my docs/ folder as PDFs with the corporate template."

The agent generates the content, calls PaperQuire's MCP tools, and reports back with the file path. No manual steps.

Architecture

The MCP server reuses PaperQuire's existing Electron-based render pipeline — the same Chromium engine behind the desktop app's live preview and PDF export. This means MCP-rendered PDFs are identical to what you'd get from the GUI or CLI.

A few design decisions worth noting:

Long-running renderer — unlike the CLI (which creates and destroys a renderer per command), the MCP server keeps one alive and reuses it across all tool calls. First render takes a few seconds; subsequent ones are fast.
Stdout isolation — MCP uses stdout exclusively for JSON-RPC. PaperQuire suppresses Chromium's startup noise on stdout so it doesn't interfere with the protocol.
Render lock — the Chromium renderer is single-threaded, so concurrent tool calls are serialized with a Promise-based mutex.

Free tier

The same daily limits apply: 3 free renders per day. Upgrade to Pro for unlimited renders and batch export.

Get it

Download v0.3.0 for macOS, Windows, or Linux
MCP setup guide for full configuration and tool reference
CLI Reference for all commands including mcp-server

Or install via Homebrew:

brew install --cask paperquire/paperquire/paperquire

How AI Assist Turns a Rough Draft into a Polished Document in Minutes

paperquire — Wed, 01 Jul 2026 00:22:08 +0000

You've got a rough draft. Bullet points, half-finished paragraphs, maybe some notes you pasted from a meeting. It needs to become a real document — but rewriting takes time you don't have.

That's exactly where AI Assist comes in.

What AI Assist Does

AI Assist lives inside PaperQuire's editor. Select any text, right-click, and choose an action:

Rewrite — Rephrase your selection for clarity and tone, keeping the meaning intact
Expand — Turn bullet points or short notes into full paragraphs
Summarize — Condense a long section into a concise summary
Fix grammar — Clean up spelling, punctuation, and awkward phrasing
Translate — Convert your text to another language
Custom prompt — Tell the AI exactly what you want ("make this more formal", "add examples", "simplify for a non-technical audience")

Every action works on your selection — you stay in control of what gets changed and what doesn't.

Bring Your Own Key

PaperQuire doesn't route your content through our servers. You plug in your own API key from any supported provider:

OpenAI (GPT-4o, GPT-4o mini)
Anthropic (Claude Sonnet, Claude Haiku)
Google (Gemini Pro)
Local models (Ollama, LM Studio — for fully air-gapped workflows)

Your documents, your key, your choice. Nothing leaves your machine unless you explicitly configure an external provider.

A Real Workflow: Meeting Notes to Executive Summary

Here's a concrete example. You come out of a 45-minute meeting with this:

- Q2 revenue up 12% vs forecast
- APAC expansion delayed, regulatory issues
- New pricing tier launching Aug 1
- Customer churn down to 3.2%, lowest ever
- Engineering headcount: 3 open roles, 2 offers out
- Board meeting moved to July 18

Select all, click Expand, and AI Assist turns it into:

Q2 revenue came in 12% above forecast, driven primarily by enterprise upsells in North America. The planned APAC expansion has been delayed due to unresolved regulatory requirements in two target markets; the team is working with local counsel to clear the path for a Q4 launch.

A new pricing tier is scheduled to go live on August 1, targeting mid-market teams who've outgrown the free plan but don't need enterprise features. Early signals are positive — customer churn dropped to 3.2% this quarter, the lowest rate on record.

Engineering is actively hiring for three open roles, with two offers currently outstanding. The next board meeting has been rescheduled to July 18.

From there, pick a template, add a cover page, and export. Five minutes from raw notes to a boardroom-ready PDF.

Tips for Getting the Most Out of AI Assist

Be specific with custom prompts. "Make this better" is vague. "Rewrite this for a technical audience, keep it under 200 words" gives the AI clear constraints.

Work in passes. Expand first, then rewrite for tone, then fix grammar. Each pass is small and reviewable.

Use it for structure, not just prose. Select a wall of text and ask "Break this into sections with H2 headings." AI Assist can reorganize, not just rewrite.

Pair it with templates. AI Assist handles the content; templates handle the presentation. Together, they take you from zero to finished document faster than any other workflow.

Privacy First

We built AI Assist with a hard rule: PaperQuire never sees your content. There's no PaperQuire backend involved — your editor talks directly to the provider you configured. If you use a local model through Ollama, your content never leaves your network at all.

AI Assist is available on all plans. Download PaperQuire and try it with your own API key — the difference in your workflow will be immediate.

Introducing PaperQuire — Markdown to Beautiful PDFs, 100% Offline

paperquire — Wed, 01 Jul 2026 00:21:51 +0000

We're excited to launch PaperQuire — a desktop app that turns plain Markdown into professional, print-ready PDFs. No cloud uploads, no accounts, no subscriptions required for personal use.

Why We Built PaperQuire

If you write in Markdown, you've probably hit this wall: your content looks great in your editor, but the moment you need to share it as a polished document — a proposal, a report, a spec — you're stuck copy-pasting into Word or fighting with LaTeX.

We wanted something simpler. Write in Markdown, click Export, and get a document that looks like a designer made it. No extra steps, no cloud dependency, no learning curve.

What PaperQuire Does

Live preview — See your formatted document side-by-side as you type. What you see is what you'll get in the PDF.

Professional templates — Choose from templates designed for technical docs, proposals, reports, and more. Every template supports custom branding: your logo, your colors, your fonts.

Offline-first — Your documents never leave your machine. PaperQuire runs entirely on your desktop — macOS, Windows, and Linux.

Plugin system — Extend PaperQuire with plugins for diagrams (Mermaid), math (KaTeX), syntax highlighting, and more.

AI Assist — Bring your own API key and get writing suggestions, grammar fixes, and content generation right inside the editor.

How It Works

Open PaperQuire and start writing Markdown — or open an existing .md file
Choose a template and customize your branding (logo, colors, fonts)
Click Export to generate a polished PDF instantly
Share your document with confidence

The entire process takes seconds, not minutes.

Free for Personal Use

PaperQuire is free for personal use with no restrictions on the core features. The Pro plan adds advanced exports (DOCX, HTML), batch processing, and priority support for teams that need more.

Get Started

Download PaperQuire for your platform:

Check out the documentation for a quick walkthrough, or just start writing — PaperQuire is designed to get out of your way.

We'd love to hear what you think. Drop us a line at paperquire@gmail.com or open an issue on GitHub.

PaperQuire v0.2.0 — CLI for Automating Your Docs Pipeline

paperquire — Mon, 29 Jun 2026 03:23:20 +0000

Your docs pipeline, from the terminal

PaperQuire v0.2.0 ships with a full command-line interface. Everything you can do in the desktop app — render, template, brand — now works from your terminal.

This means you can automate document generation, integrate PaperQuire into CI/CD pipelines, and batch-process entire directories of Markdown without opening the GUI.

Quick start

If you installed via Homebrew, the paperquire command is already on your PATH:

brew install --cask paperquire/paperquire/paperquire

Verify with:

paperquire version

The simplest render is just:

paperquire report.md

This produces report.pdf in the same directory, using the default template.

What you can do

Render with options

Apply templates, set metadata, control output:

paperquire report.md -t corporate --title "Q2 Report" --author "Jane Doe"
paperquire spec.md --page-size a4 --margins 0.75,0.75,0.75,0.75 --no-toc
paperquire draft.md --watermark "DRAFT" -o drafts/draft.pdf

All 22 flags from the desktop app's Document Setup panel are available. See the full list in the CLI Reference.

Pipe through stdin/stdout

PaperQuire works in Unix pipelines:

cat notes.md | paperquire - --stdout > out.pdf

Use - as the input file to read from stdin, and --stdout to write the PDF to stdout instead of a file.

Batch render directories

Render every Markdown file in a directory with one command:

paperquire batch ./docs -o ./out
paperquire batch ./project --glob "**/*.md" -t corporate
paperquire batch ./docs --concurrency 8 --continue-on-error

Use --dry-run to preview which files would be rendered without actually producing output.

Manage templates

List, inspect, create, and share templates:

paperquire templates list
paperquire templates show minimal-clean
paperquire templates init my-template
paperquire templates export corporate -o corporate.pqt
paperquire templates import ./shared-template.pqt

We also launched a community templates repo where you can browse all built-in templates and submit your own via pull request.

Project configuration

Drop a .paperquire.yml in your project root and every render in that directory picks up your settings automatically:

template: corporate
toc: true
h1-page-break: true
cover:
  title: "Project Documentation"
  author: "Engineering Team"
  company: "Acme Corp"
branding:
  primary-color: "#2563eb"

Config files are resolved in order: global (~/.paperquire/config.yml) then project (.paperquire.yml walked upward), then CLI flags win.

CI/CD integration

The CLI makes it straightforward to add document generation to your build pipeline. A GitHub Actions example:

- name: Generate docs
  run: |
    paperquire batch ./docs -o ./dist/docs -t corporate --continue-on-error

Use --dry-run in your CI to validate Markdown and options without producing output — useful as a pre-merge check.

What's next

This is the foundation. Future CLI updates will include watch mode for live rebuilding, PDF merge for combining multiple documents, and deeper CI integrations.

Get it

Download v0.2.0 for macOS, Windows, or Linux
CLI Reference for the full flag and command documentation
Community Templates to browse and share templates

Or install via Homebrew:

brew install --cask paperquire/paperquire/paperquire

PaperQuire Render Action — PDFs in Your CI Pipeline

paperquire — Thu, 25 Jun 2026 21:38:41 +0000

Your docs should build themselves

You write your documentation in Markdown. You keep it in a Git repo. Every time someone updates a spec or runbook, someone else has to open PaperQuire (or the CLI), render the PDF, and upload it somewhere.

That manual step is now gone. The PaperQuire Render Action generates branded, print-ready PDFs directly in your GitHub Actions workflow — on every push, every PR, or every release.

One step. That's it.

- uses: paperquire/render-action@v1
  with:
    files: 'docs/*.md'
    template: executive-report
    output: build/pdfs

Every Markdown file matching the glob is rendered to PDF using the same Chromium engine as the desktop app. Same templates, same quality, no Pandoc or LaTeX to install.

What you can build

Auto-generate docs on push

Whenever someone pushes to docs/, produce fresh PDFs and attach them as build artifacts:

name: Generate PDFs

on:
  push:
    paths:
      - 'docs/**/*.md'

jobs:
  render:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: paperquire/render-action@v1
        with:
          files: 'docs/*.md'
          template: minimal-clean
          output: build/pdfs

      - uses: actions/upload-artifact@v4
        with:
          name: pdfs
          path: build/pdfs/

Team members download the latest PDFs from the Actions tab. No Slack messages, no "can you re-export this?"

Attach PDFs to releases

Ship documentation alongside your code:

- uses: paperquire/render-action@v1
  with:
    files: 'docs/*.md'
    template: executive-report
    output: dist/

- name: Upload to release
  env:
    GH_TOKEN: ${{ github.token }}
  run: gh release upload ${{ github.event.release.tag_name }} dist/*.pdf

Every release automatically includes the latest versions of your specs, guides, and reports.

PR previews

Use the action in pull request workflows so reviewers can download rendered PDFs before merging:

on:
  pull_request:
    paths: ['docs/**']

jobs:
  preview:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: paperquire/render-action@v1
        with:
          files: 'docs/*.md'
          output: preview/
      - uses: actions/upload-artifact@v4
        with:
          name: pdf-preview
          path: preview/

Inputs and outputs

Three inputs — only files is required:

Input	Default	Description
`files`	—	Glob pattern (e.g. `docs/.md`, `/.md`)
`template`	`minimal-clean`	Any built-in template ID
`output`	`output/`	Where to write PDFs

The action outputs pdf-files — a newline-separated list of generated paths you can reference in later steps:

- uses: paperquire/render-action@v1
  id: render
  with:
    files: 'docs/*.md'

- run: echo "${{ steps.render.outputs.pdf-files }}"

How it works under the hood

The action runs in a Docker container with Node.js and all Chromium dependencies pre-installed. It globs your files, runs paperquire render for each one, and collects the output paths. No shell tricks, no external binaries to install — everything is baked into the image.

The Docker image is published to GHCR (ghcr.io/paperquire/render-action), so subsequent runs pull from cache instead of rebuilding.

Get started

Add the step to your workflow (copy the YAML above)
Push to your repo
Check the Actions tab for your PDFs

Full documentation: GitHub Action docs

Action source: paperquire/render-action

Docs as Code: Build a CI/CD Pipeline for Your Documentation

paperquire — Thu, 25 Jun 2026 21:37:07 +0000

Your code has CI/CD. Your docs don't.

Every modern engineering team has automated builds, tests, and deployments for their code. But documentation? That's still someone manually exporting a PDF, uploading it to Confluence, and hoping it's the latest version.

This post shows you how to treat documentation like code: version-controlled Markdown in a Git repo, automatically rendered to branded PDFs on every push. No manual steps, no stale documents.

The stack

PaperQuire gives you three tools that work together:

.paperquire.yml — project config that locks in your template, branding, and document options
CLI — paperquire render and paperquire batch for scripting and local builds
GitHub Action — paperquire/render-action for automated builds in CI

Each one builds on the previous. The config file means no one has to remember flags. The CLI means you can test locally. The action means it happens automatically.

Step 1: Add a project config

Drop a .paperquire.yml in your repo root. Every render — GUI, CLI, and CI — picks up these settings automatically:

template: corporate
toc: true
toc-depth: 3
h1-page-break: true
cover:
  title: "Project Documentation"
  author: "Engineering Team"
branding:
  primary-color: "#2563eb"

This is your single source of truth for how documents look. Change it once, and every PDF across every environment updates.

Step 2: Test locally with the CLI

Before committing, verify your docs render correctly:

# Render a single file
paperquire docs/architecture.md -o out/architecture.pdf

# Batch render the entire docs directory
paperquire batch ./docs -o ./out

# Dry run — validate without producing output
paperquire batch ./docs --dry-run

The CLI reads .paperquire.yml automatically. The output is identical to what CI will produce.

Step 3: Automate with the GitHub Action

Add one workflow file and your docs build themselves:

# .github/workflows/docs.yml
name: Build Documentation

on:
  push:
    paths:
      - 'docs/**/*.md'
      - '.paperquire.yml'

jobs:
  render:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: paperquire/render-action@v1
        with:
          files: 'docs/*.md'
          output: build/pdfs

      - uses: actions/upload-artifact@v4
        with:
          name: documentation
          path: build/pdfs/

Every push that touches a Markdown file or the config triggers a fresh build. PDFs are available as downloadable artifacts from the Actions tab.

Real-world patterns

Gate docs in pull requests

Catch formatting issues before they hit main. Reviewers can download the rendered PDFs directly from the PR:

on:
  pull_request:
    paths: ['docs/**', '.paperquire.yml']

jobs:
  preview:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: paperquire/render-action@v1
        with:
          files: 'docs/*.md'
          output: preview/

      - uses: actions/upload-artifact@v4
        with:
          name: pdf-preview
          path: preview/

Ship docs with releases

Attach the latest PDFs to every GitHub release automatically:

on:
  release:
    types: [published]

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: paperquire/render-action@v1
        with:
          files: 'docs/*.md'
          output: dist/

      - name: Attach to release
        env:
          GH_TOKEN: ${{ github.token }}
        run: gh release upload ${{ github.event.release.tag_name }} dist/*.pdf

Customers downloading your release get up-to-date documentation bundled right in.

Nightly builds for large doc sets

For repos with dozens of documents where you don't want to rebuild on every push:

on:
  schedule:
    - cron: '0 6 * * 1-5'  # Weekdays at 6 AM UTC
  workflow_dispatch:        # Plus manual trigger

jobs:
  render:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: paperquire/render-action@v1
        with:
          files: 'docs/**/*.md'
          output: build/docs

      - uses: actions/upload-artifact@v4
        with:
          name: nightly-docs
          path: build/docs/
          retention-days: 14

Non-GitHub CI

The CLI works in any CI system. GitLab CI, Jenkins, CircleCI, Azure Pipelines — anywhere you can run a shell command:

# GitLab CI example
build-docs:
  image: node:20
  script:
    - npm install -g paperquire
    - paperquire batch ./docs -o ./out --continue-on-error
  artifacts:
    paths:
      - out/*.pdf

Project structure

Here's what a well-organized docs-as-code repo looks like:

my-project/
├── .paperquire.yml          # Shared doc config
├── .github/
│   └── workflows/
│       └── docs.yml         # CI pipeline
├── docs/
│   ├── architecture.md
│   ├── api-reference.md
│   ├── onboarding.md
│   └── runbook.md
└── src/
    └── ...

Markdown lives alongside code. The config file and workflow are checked in. Anyone cloning the repo can render docs locally with paperquire batch ./docs, and CI handles the rest.

Why this matters

No stale docs. Every merge to main produces fresh PDFs.
No manual steps. No one has to remember to export and upload.
Consistent branding. The config file enforces the same template and style everywhere.
Auditable. Git history shows exactly when a document changed and who changed it.
Reviewable. PR previews let reviewers see the final PDF before merging.

Your documentation pipeline should be as reliable as your deployment pipeline. With PaperQuire, it takes one config file and one workflow to get there.

Get started

CLI Reference — full command and flag documentation
GitHub Action docs — inputs, outputs, and examples
Templates — browse built-in templates
Download PaperQuire