dxpdf — Fast DOCX to PDF Converter in Rust

Convert Microsoft Word DOCX files to PDF without Microsoft Office, LibreOffice, or any cloud API.

dxpdf is an open-source, standalone DOCX-to-PDF conversion engine written in Rust and powered by Skia. It reads .docx files and produces high-fidelity PDF output — preserving text formatting, tables, images, headers, footers, hyperlinks, and page layout. Available as a CLI tool, a Rust library, and a Python package.

Built by nerdy.pro.

Key Features

• Blazing fast — converts typical business documents in well under a second, most in tens of milliseconds
• High fidelity — parse → resolve → layout → paint pipeline with pixel-accurate baseline positioning
• Compact output — embedded fonts are subsetted to the glyphs actually used, so PDFs stay small
• Type-safe — compile-time dimensional type system (Twips, Pt, Emu) prevents unit mixing bugs
• Standalone — no Office installation, no LibreOffice, no external services needed
• Cross-platform — runs natively on macOS, Linux, and Windows
• Three interfaces — use as a CLI tool, Rust library (use dxpdf;), or Python package (import dxpdf)
• Unicode-aware — complex-script shaping via HarfBuzz, plus full-color emoji including ZWJ, skin-tone, keycap and flag sequences
• ISO 29500 compliant — validated against the Office Open XML specification

Installation

Command-Line Tool

cargo install dxpdf

Rust Library

Add to your Cargo.toml:

[dependencies]
dxpdf = "0.3.1"

Python Package

pip install dxpdf

Usage

CLI — Convert DOCX to PDF from the Terminal

dxpdf input.docx                  # produces input.pdf
dxpdf input.docx -o output.pdf    # specify output path
dxpdf input.docx --image-dpi 300  # embed images at 300 DPI (default 220; range 1–2400)

Embedded raster images are downsampled to --image-dpi pixels per inch (default 220, matching Word). Raise it for print-quality output (e.g. 300) or lower it for smaller files (e.g. 96); images are never upsampled past their source resolution.

Rust — Convert DOCX to PDF Programmatically

let docx_bytes = std::fs::read("document.docx")?;
let pdf_bytes = dxpdf::convert(&docx_bytes)?;
std::fs::write("output.pdf", &pdf_bytes)?;

To customize rendering — e.g. the embedded-image resolution (default 220 DPI) — use convert_with_options:

use dxpdf::RenderOptions;

let options = RenderOptions::default().with_image_dpi(300.0);
let pdf_bytes = dxpdf::convert_with_options(&docx_bytes, &options)?;

You can also inspect or transform the parsed document model before conversion:

use dxpdf::{docx, model, render};

let document = docx::parse(&std::fs::read("document.docx")?)?;

for block in &document.body {
    match block {
        model::Block::Paragraph(p) => { /* inspect paragraph content */ }
        model::Block::Table(t) => { /* inspect table structure */ }
        model::Block::SectionBreak(props) => { /* inspect section properties */ }
    }
}

let pdf_bytes = render::render(&document, &dxpdf::RenderOptions::default())?;

Python — Convert DOCX to PDF in Python

import dxpdf

# Bytes in, bytes out
pdf_bytes = dxpdf.convert(open("input.docx", "rb").read())

# File path to file path
dxpdf.convert_file("input.docx", "output.pdf")

# Customize embedded-image resolution (default 220 DPI)
pdf_bytes = dxpdf.convert(open("input.docx", "rb").read(), image_dpi=300)
dxpdf.convert_file("input.docx", "output.pdf", image_dpi=300)

Supported DOCX Features

dxpdf handles the most common DOCX features found in real-world business documents, reports, and forms:

Performance Benchmarks

Measured on Apple M3 Max with hyperfine (20 runs, 3 warmup) at v0.1.5:

These figures predate later pipeline work (font subsetting, emoji rendering, paragraph splitting) and have not been re-measured since. Treat them as an order-of-magnitude guide rather than current numbers. To measure your own workload, run cargo bench for the Criterion suites, or use the release binary with RUST_LOG=debug for a per-phase breakdown of parse, resolve, layout, subset and paint.

dxpdf is designed for batch processing, server-side conversion, and CI/CD pipelines.

Building from Source

Prerequisites

• Rust 1.95.0 — pinned via rust-toolchain.toml, so rustup selects it automatically

• clang (required by skia-safe for building Skia bindings)

• Linux only: libfontconfig1-dev and libfreetype-dev

  sudo apt-get install -y libfontconfig1-dev libfreetype-dev
  

Build

cargo build --release

The release binary will be at target/release/dxpdf.

The subset-fonts feature (font subsetting) is on by default; build with --no-default-features to skip it.

Run Tests

cargo test --all

Architecture

dxpdf follows a parse → resolve → layout → subset → paint pipeline, with a measure-then-position model inspired by Flutter's rendering approach:

DOCX (ZIP) → Parse → Document Model → Resolve → Layout → Subset → Paint → PDF
             Twips/Emu/HalfPoints        ←──── Pt throughout ────→      Skia

Type-safe dimensions flow through the entire pipeline: OOXML units (Twips, Emu, HalfPoints) in the parsed model, Pt (typographic points) in layout, and f32 only at the Skia rendering boundary.

1. Parse — declarative serde schemas over the DOCX XML parts, producing an immutable document model
2. Resolve — flatten the style cascade, split sections, pre-load images, generate shape geometry
3. Layout — measure text, fit lines, and position content into pages; runs first so total page count is known before headers/footers resolve PAGE/NUMPAGES
4. Subset — reduce each embedded typeface to the glyphs actually painted
5. Paint — emit draw commands in order (shading → content → borders) through Skia's PDF backend

Module Overview

OOXML Feature Coverage

Validated against ISO 29500 (Office Open XML). 53 entries fully implemented, 10 partial, 10 not yet supported.

Text Formatting (w:rPr)

Paragraph Properties (w:pPr)

Styles

Tables

Images

Page Layout

Headers & Footers

Lists

Fields

Other

Dependencies

Frequently Asked Questions

How do I convert a DOCX file to PDF?

Install dxpdf with cargo install dxpdf, then run dxpdf input.docx. The PDF will be created in the same directory. You can also specify an output path with -o output.pdf.

Does dxpdf require Microsoft Office or LibreOffice?

No. dxpdf is a standalone converter that reads DOCX files directly and renders PDF output using Skia. No Office installation or external service is needed.

Can I use dxpdf as a library in my Rust or Python project?

Yes. In Rust, add dxpdf as a dependency and call dxpdf::convert(&docx_bytes). In Python, install with pip install dxpdf and call dxpdf.convert(bytes) or dxpdf.convert_file("input.docx", "output.pdf").

What DOCX features are supported?

dxpdf supports text formatting, paragraphs, tables (including nested and merged cells), inline and floating images, styles with inheritance, headers/footers, lists, hyperlinks, section breaks, and automatic pagination. See the full feature matrix above.

How fast is dxpdf?

Fast enough that conversion is rarely the bottleneck: on an Apple M3 Max a typical multi-page business document converts in tens of milliseconds, and a 24-page image-heavy document in a few hundred. See Performance Benchmarks for measured figures and how to benchmark your own workload.

What platforms does dxpdf support?

dxpdf runs on macOS, Linux, and Windows. On Linux, you need libfontconfig1-dev and libfreetype-dev installed.

Used By

• nerdy.pro
• formtastic.de

Contributing

Contributions are welcome. Please open an issue before submitting large PRs.

Implementation notes for the rendering engine — organized by OOXML spec section, covering the style cascade, pagination, table layout, fonts and emoji — live in docs/. Build commands and project conventions are in AGENTS.md.

Before opening a PR, run what CI runs:

cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test --all

Built by nerdy.pro.

License

MIT