A tool from Excelano

waddle

DoclingDocument to office documents.

docling reads some forty formats into a DoclingDocument and writes Markdown, JSON, DocLang and LaTeX from it, but no office format. waddle is the missing direction: DocLang, a DocLang archive or docling JSON goes in, and an OpenDocument or Office Open XML package comes out, offline, in pure Rust, with nothing overwritten.

The missing direction

The route from a DoclingDocument back to Word today runs through Markdown and then Pandoc, which drops the structure DocLang carries, headers and spans and captions among it, and adds a Haskell binary to a Rust pipeline. waddle writes the office document straight from the model instead. It takes the formats docling produces that carry structure — DocLang, a DocLang archive, or docling JSON — and writes an ODT or DOCX document, an ODS or XLSX workbook of the tables, or an ODP deck.

The model docling builds is semantic and flat: headings with levels, paragraphs with runs, lists with numbering, tables with spans and header rows, pictures with captions, code, checkboxes. That is enough to write a plain, well-structured office document directly, the one a careful Markdown file would give you opened in Writer or Word under a stock style sheet. The construct waddle chooses for each node is the one docling.rs's own reader for that format recognises, so a package it writes reads back into the document it was written from.

See it in action

Point it at a file and name the target format. waddle writes the package and stops; it does not overwrite what is already there.

$ waddle report.dclg --to odt
report.odt

$ waddle report.json --to docx -o out/
out/report.docx

The plainness is the design. The model carries no styles, page geometry, fonts or themes, so waddle does not try to reproduce how the source looked; there is nothing to reproduce it from. What it does is put every node into the construct the format has for it, and say on stderr what it could not carry. --dry-run shows that before writing a byte, and --strict turns it into a refusal.

$ waddle report.dclg --to odt --dry-run
would write report.odt
waddle: 3 nodes would be dropped or degraded:
  furniture: dropped, on the furniture layer (2)
  picture: written as a placeholder

Install

waddle is packaged for Debian, Ubuntu and Windows, and published as a crate that cargo builds anywhere else, macOS included.

On Debian or Ubuntu

Add the Excelano apt repository once, so apt upgrade keeps it current:

curl -fsSL https://excelano.com/apt/setup.sh | sudo sh
sudo apt install waddle

On Windows

With WinGet, so winget upgrade keeps it current:

winget install Excelano.waddle

With cargo

From crates.io, on macOS or anywhere else you have a Rust toolchain:

cargo install waddle

waddle ships a Claude Code skill that teaches the agent when to reach for it; add it beside the binary with waddle --install-skill, or leave it out. The tool does not need it.

Part of the DocLang ecosystem

waddle is a command line and a Rust library, waddle-core, and the library is how Duckling writes its office formats from a desktop window. docling.rs reads a document into DocLang; Segler lets a person correct that DocLang beside the page it came from; waddle writes it back out as an office file. The ecosystem map shows where each tool fits.

For technical users

waddle is open source under the MIT license, written in pure Rust with no runtime dependency on Python or Pandoc. The source, the mapping from each node to each format, and the design notes on what it carries and what it degrades live at github.com/excelano/waddle, with the design in DESIGN.md and the security policy in SECURITY.md.