See every page side by side: jandira-tech.github.io/neurotic_docx_bench
jubarte vs Microsoft Word, docxide-pdf, LibreOffice, PyMuPDF Pro, MiniPdf, rdocx and office2pdf on 808 documents, DOCX to PDF, scored per page.

jubarte-redlines (Python)

Word-faithful DOCX redline engine: compare two Word documents into a tracked-changes document that opens cleanly in Microsoft Word; list, accept, or reject revisions; render DOCX to PDF.

Python bindings (PyO3 + maturin) for the Rust jubarte-redlines engine. Pure compute, no Word/LibreOffice dependency, no network, no temp files — documents go in and come out as bytes (whole DOCX/PDF packages), revision metadata comes back as parsed records (get_revisions → list[dict], get_revisions_json → JSON string), and the GIL is released while the engine runs.

Install

pip install jubarte-redlines
# or: uv add jubarte-redlines

Prebuilt wheels are abi3 (one wheel per platform, CPython ≥ 3.10).

Command line

The native jubarte binary offers --keep-nested-comment on accept, reject and convert --track-changes accept|reject. These bindings do not yet dispatch that option or return its kept-thread receipts; use the native binary when retention is needed.

The wheel installs a jubarte-redlines command; uvx runs it without installing anything:

uvx jubarte-redlines redline original.docx modified.docx -o redline.docx --author Legal
uvx jubarte-redlines changes redline.docx
uvx jubarte-redlines accept redline.docx -o clean.docx --kind formatting
uvx jubarte-redlines reject redline.docx -o original-again.docx --id r12
uvx jubarte-redlines convert redline.docx --revisions word
uvx jubarte-redlines read contract.docx
uvx jubarte-redlines read contract.docx --json
uvx jubarte-redlines edit contract.docx -p p12 --anchor "thirty" --content "sixty"
uvx jubarte-redlines edit contract.docx --plan plan.json --out-dir review --pdf
uvx jubarte-redlines capabilities
uvx jubarte-redlines --help

redline is an alias of compare; python -m jubarte_redlines runs the same commands. changes lists what a document tracks, one change per line with its short id (r12; --json for one object per line); accept and reject take repeatable --id (r12, r1+2, header1.r1), --author and --kind to resolve a selection and keep the rest tracked, or everything when none is given; read prints the agent view with the <!-- p12 --> ids edits use (--json the snapshot); edit and add write FILE_modified.docx, or with --out-dir the bundle (clean copy, redline, patch.diff, report.jsonl, optional PDF/PNG pages); capabilities reports what the build can do (--json the manifest). Exit codes: 0 success, 1 error, 2 usage, 3 edit plan refused. Inputs are .docx: save a Word 97-2003 .doc as .docx first.

Library

from pathlib import Path
from jubarte_redlines import (
    compare_documents,
    get_revisions,
    accept_revisions,
    reject_revisions,
    docx_to_pdf,
)

original = Path("original.docx").read_bytes()
modified = Path("modified.docx").read_bytes()

# Word-mode compare → tracked-changes DOCX (w:ins / w:del)
redline = compare_documents(original, modified, author="Reviewer")
Path("redline.docx").write_bytes(redline)

# List revisions (the library's own records; `jubarte changes --json` is the CLI's listing)
for rev in get_revisions(redline):
    print(rev["type"], rev["author"], repr(rev.get("text")))

# Accept / reject every tracked revision, package-wide
clean = accept_revisions(redline)   # ≙ modified content
base = reject_revisions(redline)    # ≙ original content

# Render to PDF (Word-style layout)
Path("redline.pdf").write_bytes(docx_to_pdf(redline))

compare_documents(original, modified, author="Redline", date=None) stamps revisions with a fixed epoch date by default so output is deterministic; pass an ISO-8601 date to override. Errors raise jubarte_redlines.JubarteError.

Both inputs are admitted under a size budget before anything is inflated (512 MiB per file and per part, 2 GiB inflated, 10,000 entries, XML depth 256). input_limits overrides it key by key, for example compare_documents(a, b, input_limits={"max_uncompressed_bytes": 256 << 20}); the keys are max_compressed_bytes, max_entries, max_part_bytes, max_uncompressed_bytes and max_xml_depth. A package past the budget raises JubarteError with INPUT_LIMIT, and an unknown key raises invalid input limits. get_revisions_json and CompareOptions(input_limits=...) take the same mapping.

read() returns a Document — an immutable snapshot, path I/O done once, no operation mutating it or writing files:

from jubarte_redlines import read, EditPlan, diff

doc = read("contract.docx")
doc.markdown()    # body and every header/footer/notes story, <!-- pN --> id lines
doc.inspect()     # Snapshot: summary + paragraphs (ids, style, spans, limitations) + tables
doc.sha256()      # the source_sha256 guard an edit plan carries
doc.changes()     # each tracked change, with the id accept/reject and plans take
doc.accept(ids=["r12"])           # or reject(...): resolve a selection,
                                  # keep the rest tracked (no selection = all)
result = doc.render(pdf=True, png_dpi=144)  # Rendered: pdf, pngs, page report

The snapshot uses schema_version: 3. changes lists logical changes: a change Word wrote as several marks is one entry with its members, and a deletion and an insertion by one author that touch, in either order, are one replacement. summary.tables and tables[] count top-level body tables only; each index is the view's tN. Every table has a nested array (empty for a leaf), containing its cell tables. A nested entry has parent (for example t0.row2.cell0) and no index. A deeper parent includes the cell-local table ordinal, for example t0.row2.cell0.t0.row0.cell1. Paragraph ids and edit-plan schemas are unchanged.

Python nested grids are Table(index=None, parent=CELL_PATH, nested=(...)); top-level grids retain integer indices.

doc.compare(other, author=...) is compare_documents; doc.to_pdf() and doc.to_png(dpi=...) are the one-shot renderers.

An EditPlan builds the tracked-changes transaction doc.edit(plan) applies — all-or-nothing: a refused plan raises EditPlanError (stable code, the failed operation, every operation's outcome) and produces nothing. doc.preview(plan) resolves and reports without applying:

plan = (
    EditPlan(author="Reviewer")
    .for_document(doc)             # bind to this snapshot; STALE_SOURCE if it changed
    .replace("p3", find="30 days", replacement="45 days", format={"bold": True})
    .comment("p3", text="Check with the client", find="45 days")
    .insert_paragraph("p3", runs=["New sentence."], like="p3")
)
out = doc.edit(plan)               # EditResult: clean, redline, report, diff

replace, insert, delete, comment and format_run edit run text; insert_paragraph, delete_paragraph, format_paragraph, merge_paragraphs and rewrite work on whole paragraphs; insert_table(paragraph, rows=[[...], ...]) adds a table and list_paragraphs([...], kind_of_list="decimal") (wire kind list) numbers paragraphs; insert_footnote adds a footnote after an anchor; insert_image adds a picture paragraph; page_setup changes the page size, orientation and margins; resolving(accept={...}, reject={...}) settles existing tracked changes first. plan.to_json() is exactly what edit --plan reads.

diff(old, new) shows the changed paragraphs between two documents — or a document and Markdown text — as [-old-]{+new+} marks (format="critic" for CriticMarkup). When a side is a Word document, the comparer writes the changes, and a replacement inside a paragraph keeps Word Compare's order, the insertion first: {+new+}[-old-].

print(diff(read("v1.docx"), read("v2.docx")))

doc.append(other) puts other after doc on a new page and returns Appended(document, warnings): images, links, headers, styles, lists and notes come along. Comments are dropped (COMMENTS_DROPPED in warnings) unless comments="carry", which brings the comments other's body anchors with their threads and resolution. section_break="continuous" joins on the same page and keep_sections=True keeps other's page setup, headers and footers.

Before a document goes out, or after an agent edited it:

doc.validate()        # Word-validity findings beyond the schema; () is a pass
fixed = doc.repair()  # Repaired: document, repaired, remaining
doc.audit_tracked(read("original.docx"), author="Reviewer")  # untracked or foreign edits
doc.audit("a11y,structure")  # accessibility, style and structure findings by paragraph id
out = doc.scrub()     # authors as "Author", no rsids, document properties or comments
doc.update_fields()   # PAGEREF, REF, NUMPAGES, SEQ and TOC results from jubarte's layout

from_markdown(text, author=..., track_changes="all") writes Markdown as a Word document, CriticMarkup becoming tracked changes and comments, as jubarte convert draft.md does; reference= lends a document's styles and page setup. A change or comment that names no author or date takes author and date when you pass them, else the front matter's author: and last_modified:/modified:/date:/created:, else Redline and the fixed epoch, so the same Markdown writes the same bytes (the CLI falls back to --reference-doc's creator and creation time, then Redline and now). diff_render(a, b, dpi=100) says which pages of two documents look different, pixel for pixel, with magenta overlays on the changed pages.

Document.from_bytes(data) holds bytes you already have and to_bytes() returns them; inspect_json() is the engine's inspect snapshot as JSON text, unchanged (inspect() decodes it). scrub takes author_alias, rsids, docprops and comments to choose what goes.

Also available as

• Rust crate: jubarte-redlines (this engine, plus a CLI)
• npm / WebAssembly: jubarte-wasm (Node and browser builds)
• MCP server: pip install 'jubarte-redlines[mcp]' then jubarte-mcp --root . (setup for Claude Code, Codex and Gemini CLI)

Text comparisons

jubarte-redlines diff a.docx b.docx --format github
jubarte-redlines diff a.docx b.docx --format github -U0 --accept-changes
jubarte-redlines diff a.docx b.docx --format word

Line views (github, normal, context, side-by-side) retain each input’s tracked marks. Word comparison accepts all changes in both inputs first, then creates fresh CriticMarkup; earlier revision provenance disappears. critic remains a representation of document content with its marks. Long lines use a 70-character review window; --full-lines shows all text. Text views support DOCX and Markdown and write stdout or an explicit -o text file. CLI help and usage errors come from the shared clap-derived grammar.

Rendering and fonts

The PDF engine reconstructs Word-oriented layout directly; it does not call Microsoft Word or LibreOffice.

The documented rendering surface includes:

• tracked changes, and comments as Word's balloons in the markup pane (a resolved comment faded, a reply numbered under its thread);
• paragraph/run formatting and advanced line layout;
• CJK and RTL/complex-script text;
• installed and embedded fonts;
• merged, vertically merged, autofit and floating tables;
• DrawingML/VML graphics, text boxes, charts and SmartArt;
• raster and EMF/WMF images;
• headers, footers and floating frames;
• sections, columns, backgrounds and page borders;
• footnotes and selected fields.

Rendering fidelity still depends on fonts and on document features. WebAssembly has no installed fonts: docxToPdf paints with the fonts a document embeds and the bundled Carlito and Liberation faces, so Chinese, Japanese or Korean text without an embedded font is not painted (see KNOWN_ISSUES.md, item 9).

Supplemental font lookup can be configured with:

export JUBARTE_FONT_DIR=/path/to/jubarte/fonts
export JUBARTE_FONT_INDEX=/path/to/font-index.tsv

Set:

export JUBARTE_FONT_INDEX=off

to disable the persistent font index.

Default per-user font directories are documented in the installation section of this repository.

For known Word-layout differences, see:

• docs/WORD_LAYOUT_RULES.md
• docs/WORD_DIFFERENCES.md
• docs/WORD_COMMENT_BALLOONS.md

Comparison modes

The default comparison mode is:

--mode word

It targets Word-like comparison behavior.

Classic PowerTools behavior is available with:

--mode powertools

Choose explicitly if exact comparison semantics matter to a regression test or downstream workflow.

Supported environments

Release assets can vary by tag. Check the release page before scripting a binary download.

A Word 97-2003 .doc converts to .docx with the native binary's jubarte convert old.doc (or jubarte::legacy_doc::doc_to_docx in Rust): text, headings, lists, bold, italic and tables. Every other command, and the Python and JavaScript packages (the npm command line too), refuse a .doc (or an encrypted document of any Word version) with LEGACY_DOC and the hint to save it as .docx without a password, and RTF with UNSUPPORTED_PACKAGE. Convert them to .docx first.

Troubleshooting

License

jubarte-redlines is licensed under GNU Affero General Public License v3.0 only (AGPL-3.0-only).

Review the license requirements before embedding or deploying the software in a product or network service.

Links

Engine comparison site · jandira.tech · arthur.law · Cicero · LinkedIn · contact@arthur.law

• GitHub
• crates.io
• docs.rs
• PyPI
• npm
• Releases
• npm CLI