Convert RTF to DOCX

Nobody sits down to write an RTF. They arrive, emitted by something: a dictation or transcription platform returning a draft, a case or practice management system exporting a letter, a mail-merge engine producing a run of documents, a report generator in a piece of line-of-business software, a colleague on a Mac who wrote it in TextEdit without noticing what TextEdit saves. In each case the format was chosen by a program written when rich text was the safe common denominator.

The moment that brings you here is the moment the document stops being an output and starts being work. You have to comment on it, redline it, drop it into the house template, generate a table of contents, or hand it to three colleagues who will each add something. Word will open the RTF perfectly well and will be a slightly worse tool for all of that, and the file will be strangely large. Converting once, at the start, is cheaper than fighting the format on every save.

RTF is from 1987 and the registry marks it legacy. It is plain text: the words are there in the file surrounded by backslash-prefixed control words describing a font table, a colour table, a style sheet and the formatting of each run. Anything can generate one with string concatenation, which is exactly why so many programs do. Microsoft stopped developing the specification in 2008.

DOCX is from 2007, standardised as ECMA-376, and is a ZIP archive containing XML parts with a relationship graph between them. The practical difference for you is not elegance but validation: a malformed part in a DOCX makes Word refuse the file, while an RTF that is slightly wrong usually opens slightly wrong. That is the trade the older format made for its universality, and it is the reason a clean-looking RTF is not evidence of a clean RTF.

Expect the DOCX to be a fraction of the RTF, and expect the ratio to depend almost entirely on pictures. A DOCX is a ZIP, so its XML is deflated before it ever reaches disk; RTF has no compression whatsoever and every control word is stored literally, so even a text-only document is several times larger than it needs to be.

Images are the dramatic case, because an RTF stores an embedded picture as hexadecimal text — roughly two characters in the file per byte of image. A document with half a dozen screenshots in it can be an order of magnitude larger as an RTF than as a DOCX holding the same pictures. If the file you were sent seemed absurdly big for what it contains, that is the explanation, and the conversion fixes it as a side effect rather than as a feature.

More than the format’s age suggests, because RTF was built precisely to move formatted documents between programs. The style sheet comes across as styles rather than as direct formatting, which is the single most important thing for anyone who intends to restyle the document afterwards. Tables keep their cells, borders and merged regions; lists keep their numbering; headers, footers, page numbering, footnotes, endnotes, hyperlinks, bookmarks and page setup all have direct representations on both sides.

The work is done by LibreOffice, which treats both formats as first-class filters rather than as an afterthought, and the machine it runs on carries metric-compatible substitutes for Arial, Times New Roman, Courier New, Calibri and Cambria. Those substitutes have the same character widths as the originals, so line breaks land in the same place and a document laid out to fit a page still fits it. An RTF names its fonts and cannot carry them, so anything outside the common set was already being substituted by whatever opened the file.

This is the honest limit of the conversion and it catches people who assume a round trip restores what a one-way trip removed. If the document started as a DOCX with content controls, structured document tags, SmartArt, a document theme or embedded fonts, all of those were flattened when it was written out as rich text. Converting back gives you the flattened version in a modern container, not the original.

The failure is silent, which is what makes it worth checking rather than assuming. A content control that became ordinary text still looks exactly right and no longer does anything; a field that was calculating — a date, a page count, a cross-reference — is now the value it held at the moment of export. If the document came out of a template and somebody expects to fill it in again, the template is what you need, not this conversion.

RTF does have representations for revision marks and annotations, and simple cases survive a trip through it. It is much less dependable than a modern format, though, because the two models are decades apart and every mapping between them is an approximation made by whichever program is doing the reading.

So the working order matters. Convert first, then turn on tracked changes and start the review in the DOCX, where Word’s own model is being used natively and every reviewer sees the same thing. If the RTF you received already contains revision marks — an e-discovery export, a redline sent by another firm — check them against the source before you rely on them, and resolve them before circulating rather than carrying an uncertain audit trail into a new document.

An RTF declares a character set and escapes anything outside plain ASCII against it, which was a reasonable design in 1987 and is a recurring source of mangled text now. A file written by an old program on a system with different regional settings can name a code page that does not match what it actually contains, and the result is names with question marks or the wrong accents in them.

A conversion cannot repair that, and it is important to know before you spend an afternoon looking for a setting. If the RTF already displays incorrectly in Word or LibreOffice, the characters in the file are wrong and the DOCX will faithfully carry the same wrong characters. The fix is at the source: have the system that produced the file emit it again with the correct encoding, or correct the affected names by hand once, in the DOCX, where they will stay correct.

This runs on a server rather than in your browser. Converting between two full word-processing formats needs an office engine, and this page says so plainly instead of implying that everything here happens on your own device. The file travels over an encrypted connection to a container running LibreOffice headless, and that container cannot make outbound connections of its own.

Each job gets its own scratch directory and its own LibreOffice profile — two `soffice` processes sharing one profile corrupt it, and the symptom is a conversion that never returns rather than an error — and the directory is deleted when the job finishes regardless of the outcome. Anything still running after sixty seconds is terminated. The free tier accepts 25 MB per uploaded file, which given how large RTFs are is a real ceiling on an illustrated document.

Open the result and compare it against the RTF side by side rather than reading it on its own. Three places carry almost all of the risk: tables with merged cells, anything that used to be a form field, and the point where a long document breaks between pages. Numbering is the fourth if the document uses multi-level lists, because restarting and continuing numbers is an area where two implementations can legitimately disagree.

If the document is going into a shared template afterwards, do that next and check it again, because applying a template to a converted document is where imported styles collide with the house ones. It is worth resisting the urge to delete the RTF straight away: it is the only record of what the originating system actually produced, and if a question comes up about what the transcription or the export said, the file that came out of that system is the answer rather than your edited copy of it.