rdocx

rdocx gives Rust applications one Document for the complete Word workflow. Create a business document, open and edit a customer template, retain producer content you do not model, lay out the result, and deliver DOCX, PDF, page images, HTML, or Markdown without starting Microsoft Word or LibreOffice.

This is an integrated native document stack, not only a DOCX writer. The same engine powers Rust, the command line, Python, and a locally built browser package. Project-owned layout and bundled fonts make deterministic output possible without an Office installation or conversion service.

Built for complete document workflows

Most applications need only rdocx. Specialist crates expose the OPC, WordprocessingML, layout, HTML, and fixed-output layers for applications that already own one of those boundaries.

Measured footprint and speed

Archive size is regenerated from tracked package contents. The performance rows are the enforced release-mode bounds plus one dated observation.

Examples

Create a document

use rdocx::{Document, Length};

let mut document = Document::new();
document.add_paragraph("Quarterly report");

let mut summary = document.add_paragraph("");
summary.add_run("Status: ").bold(true);
summary.add_run("approved");

let mut table = document.add_table(1, 2);
assert!(table.set_column_width(0, Length::inches(2.0)));
assert!(table.set_column_width(1, Length::inches(4.0)));

document.save("report.docx")?;
# Ok::<(), rdocx::Error>(())

Read and update a document

use rdocx::Document;
use std::collections::HashMap;

let mut document = Document::open("template.docx")?;
for paragraph in document.paragraphs() {
    println!("{}", paragraph.text());
}

let mut replacements = HashMap::new();
replacements.insert("{{status}}", "Approved");
document.replace_all(&replacements);
document.save("approved.docx")?;
# Ok::<(), rdocx::Error>(())

Create and manage styles

use rdocx::{Alignment, Document, Length, StyleBuilder, StyleType};

let mut document = Document::new();
document.add_style(
    StyleBuilder::paragraph("Callout", "Callout")
        .based_on("Normal")
        .alignment(Alignment::Center)
        .space_before(Length::inches(0.125))
        .space_after(Length::inches(0.125))
        .indent_left(Length::inches(0.25))
        .font("Aptos")
        .size(12.0)
        .bold(true)
        .color("245A81"),
)?;
document.add_paragraph("Important").set_style("Callout");
assert_eq!(document.style("Callout").unwrap().name(), Some("Callout"));
assert!(document.styles().iter().any(|style| style.style_id() == "Callout"));
document.set_style(StyleBuilder::paragraph("Callout", "Callout").size(13.0))?;
document.set_default_style(StyleType::Paragraph, "Callout")?;
document.add_style(StyleBuilder::paragraph("Unused", "Unused"))?;
assert!(document.remove_style("Unused")?);

document.save("styled.docx")?;
# Ok::<(), rdocx::Error>(())

save writes the package class that a .docx, .docm, .dotx, or .dotm path names, so a .dotx template saved as .docx declares a document. A package that carries a VBA project cannot change to a macro-free extension.

Render and export

use rdocx::Document;

let document = Document::open("report.docx")?;
document.save_pdf("report.pdf")?;
let first_page_png = document.render_page_to_png_deterministic(0, 150.0)?;
let html = document.to_html();
let markdown = document.to_markdown();

assert!(first_page_png.as_ref().is_some_and(|png| !png.is_empty()));
assert!(!html.is_empty());
assert!(!markdown.is_empty());
# Ok::<(), rdocx::Error>(())

Installation

Most Rust applications need only the facade:

[dependencies]
rdocx = "0.15.0"

Bundled metric-compatible fonts are always available through deterministic rendering. The default feature also discovers system fonts. Disable default features when an application must use only the bundled set:

[dependencies]
rdocx = { version = "0.15.0", default-features = false }

Native encryption and signing APIs are opt-in:

[dependencies]
rdocx = { version = "0.15.0", features = ["agile-encryption", "digital-signatures"] }

The workspace requires Rust 1.93 or newer and uses edition 2024.

CLI

Install the CLI version from the same stable family:

cargo install rdocx-cli --version '^0.15.0'

Common commands:

rdocx inspect report.docx
rdocx text report.docx
rdocx convert report.docx --to pdf -o report.pdf
rdocx convert report.docx --to html -o report.html
rdocx convert report.docx --to md -o report.md
rdocx replace report.docx --placeholder "Draft" --value "Final" -o final.docx
rdocx diff before.docx after.docx

Surfaces

The binding specification defines where Python, WebAssembly, and CLI intentionally expose less than native Rust.

Community Claude plugin

Contributor hadim maintains rdocx-skills, a Claude plugin with DOCX and PPTX skills built on the rdocx and rpptx CLIs and Python bindings. Its repository documents installation, pinned builds, acceptance tests, and current capability gaps.

Evidence-based alternatives

Comparison checked 2026-09-09. ND means the capability was not documented in the official sources linked below. It does not mean the capability is impossible. Native layout means a page-layout engine implemented by the library, rather than conversion through Microsoft Office, a hosted service, or another renderer.

Among these reviewed projects, rdocx alone documents the complete combination of a native Rust API, project-owned Word layout, fixed and flow outputs, a CLI, Python, and a browser surface. That statement is bounded to the official evidence set and review date. See the official python-docx document guide, docx-rs project, docx4j PDF paths, docx4j Markdown module, Aspose fixed-page documentation, Aspose format table, and Aspose load behavior.

Honest boundaries

rdocx preserves safe unmodeled XML, but it does not execute VBA, ActiveX, OLE, add-ins, or embedded applications. Binary DOC and Word 2003 XML are permanent non-goals. Exact authoring, reading, rendering, and preservation coverage lives in the modern DOCX capability matrix.

License

Licensed under either of:

• MIT license (LICENSE or https://opensource.org/licenses/MIT)
• Apache License, Version 2.0 (https://www.apache.org/licenses/LICENSE-2.0)

at your option.