Inside JitWord: How One Open-Sourced .doc Converter Proves Enterprise Online Word Is a Hard, Real Problem
We've been tinkering with AI products at our company – things like 1:1 document assistants, AI documents, and PyCharts super tables. We've also shared quite a few open-source projects before. But today I want to talk about something different: JitWord, which has been popping up in enterprise document circles recently.
JitWord is not another "Notion-like" skin. It's genuinely targeting desktop Word, and its core .doc import chain is open-sourced.
What is this project, exactly?
In one sentence: JitWord is an enterprise-grade online collaborative Word that can be deployed privately.
Sounds unremarkable, right? But think about it – products that satisfy all three of these conditions at once are rare:
First, typesetting must be as rigorous as Word. Not a "good enough" online editor, but one that truly carries over Word's formatting system, solving the problem where documents still need a pile of formatting work after being written.
Second, collaboration must be as smooth as online docs. When several people edit the same document simultaneously, entries must not conflict or lose text.
Third, data must be secure and controllable, and it must meet 信创 (informatization application innovation) requirements. Many SaaS products on the market won't even consider this need.
Feishu Docs has decent collaboration among document libraries, but try asking it to typeset an official document. As for Word, its layout is beyond reproach, but collaboration basically means sending files back and forth – not convenient at all. As for private deployment, most products just tell you "not supported."
JitWord aims to solve these problems directly. So it built a self-developed Docx parsing engine, added CRDT-based real-time collaboration, embedded AI throughout the workflow, and supports private deployment plus domestic ecosystem adaptation.
What surprised me most is that they open-sourced the hardest chain, .doc to .docx, called doc2docx, under the BSD license. A commercial product willing to open-source its hardest bone to share with the community earns my respect.
Why build this?
Honestly, over the years in tech and products, I've repeatedly stepped on the pain points of document tools.
With Word, versions get sent back and forth; you finish V3 only to find V2 was the right one. Collaborative editing becomes detective work. With Feishu or DingTalk docs, daily collaboration is fine, but ask it to typeset an official document or a contract and the formatting alone will drive you to question life.
And let's not even mention the piles of historical Word documents – many enterprises have this pain point. Those Word files embed Visio diagrams, flowcharts, and old formulas. Trying to move them all online for collaboration? On import, they all become blank boxes. Without even fixing the contents, just fixing the formatting can drive a team mad.
I once saw a team spend two full months fixing formatting just to migrate a few hundred historical Word documents to online collaboration. In the end, the fixed documents still had various discrepancies and minor issues – tables breaking, fonts missing, numbering scrambled – endless.
So the market doesn't need "another online editor." It needs something that genuinely brings Word's typesetting ability into the browser, while adding collaboration and AI.
That's the route JitWord is taking.
Core features, one by one
Word parsing engine – the hardest bone
This is where JitWord differentiates itself from other online documents.
It didn't take the "simplify formatting, good enough" path. Instead, it tackles Word's complete formatting system head-on: from multi-level numbering to complex tables, from headers/footers to embedded objects, down to minor import/export issues – it works to keep formatting intact.
What "tough problems" can it handle? Let me pick a few:
Multi-level numbering. Word's nested numbering like "一、→1.1→1.1.1" stays intact after import. Anyone who's built document products knows what a pit numbering systems are. I previously used an online doc that, on importing a Word file with multi-level numbering, scrambled everything and I spent an afternoon fixing it manually.
Complex tables. This pain also plagues many online documents: merged cells, cross-page tables, irregular reports – widths and alignment all restore.
Section page settings. Formal documents where the cover, table of contents, and body use different margins need each section's settings preserved separately so pages don't bleed into each other.
Embedded object restoration. OLE objects inserted in Word – Visio vector images, embedded Excel tables, even old formulas – display as-is after import. Shadows and gradients in vector images don't lose detail.
Native flowcharts. Flowcharts and org charts drawn by hand with Word's drawing canvas – shapes, connectors, and text all come through, and can be scaled and moved as a group.
Comments and revisions interop. Track changes and comments from Word import directly and can continue reviewing; exporting back to Word preserves them.
Honestly, each of these features isn't "sexy" on its own, but every one is a hard requirement for enterprise users. And they open-sourced the trickiest legacy binary .doc import chain – a Node.js library on npm called doc2docx, under the BSD license.
Real-time collaboration
Multiple people editing the same document simultaneously sounds simple but is brutal to implement.
What if two people type the same paragraph at once? After a disconnect and reconnect, will someone's changes be wiped out?
JitWord uses a conflict-free merge technology. The core idea: every edit is a traceable operation, and the system automatically merges conflicts instead of "the last save overwrites earlier ones."
In practice it feels decent. Cursor responsiveness is high – you see others typing and moving cursors in real time. Different collaborators are distinguished by color, showing who is changing what. If two people write in the same paragraph simultaneously, the system smart-merges without "my text just vanished." Reconnecting after a disconnect requires no manual action; changes sync back automatically.
It's not just Word documents – spreadsheets also support multi-user editing. It's said a company-wide meeting with hundreds of people editing meeting minutes concurrently can be handled, though I haven't stress-tested that.
How good is the AI?
JitWord's AI isn't a bolt-on "chat box on the side." It's embedded in the writing flow.
How do you invoke it? There's an AI creation panel at the top, an AI sidebar on the right to ask questions while writing, and double-clicking Ctrl on selected content calls up AI continuation, polish, and error correction in place.
There's also a "smart formatting" button that normalizes headings, paragraph/line spacing, lists, and numbering across the entire document in one click. For messy long documents this is a lifesaver.
The model support is fairly complete: DeepSeek, Kimi, Qwen, Zhipu GLM, Doubao, MiniMax – basically all the mainstream ones. Enterprises can also connect their own private large models, keeping data off the public network.
公文 (official document) engine – the killer feature for government and enterprise
Honestly, I've only seen JitWord build such a complete official-document feature among domestic collaborative documents.
The standard red-head format elements – document number, secrecy level, urgency, dispatch number, signatory, copy-to list, and layout notes – all have corresponding typesetting rules.
There's also an AI official-document assistant: say "write a notice about launching X work," pick a reference template, and the system automatically generates a full draft following official-document structure, then routes it through internal review and approval.
Add on seal insertion, handwritten signatures, and text/image watermarks, and the full flow for government and enterprise customers to write and review official documents is basically covered.
Template engine and batch document generation
For standardized documents like contracts, notices, and official documents, the worst part is starting from zero every time.
JitWord has a template system: fix common documents as templates with placeholders – text fields, looping table rows, seal positions, and image slots can all be variables.
More practically, it exposes an API. A business system calls one endpoint, passes in a batch of data, and the system generates the corresponding number of documents. For sending offer letters in batches, generating contracts in batches, or producing monthly reports in batches, what used to take hundreds of manual fills now happens with one API call.
OFD and 信创 (informatization application innovation)
It supports import and online preview of OFD (the national standard fixed-layout format), with editing directly in the browser and viewing on mobile. For government, military, and finance sectors, this is a hard requirement – non-negotiable.
Large document rendering is also optimized. It uses virtual DOM with on-demand loading – no need to render the whole document at once, so long documents of hundreds of pages open quickly.
A few words on the technical architecture
Looking at the product form and version iterations, several points are worth noting.
Self-developed format parsing engine. High-precision Word compatibility is JitWord's technical moat. To keep import/export formatting intact, you're essentially reimplementing Word's typesetting engine in the browser. How fonts calculate line height, how multi-level numbering nests, how table widths are allocated, how headers/footers split by section – each is a deep pit. Many online document products get stuck precisely here. But JitWord's team didn't give up; they've steadily polished this direction for more than a dozen versions, from basic docx parsing to multi-level numbering optimization, table precision improvements, and recently Visio chart and flowchart parsing. Every step fills a historical pit left by Word's format.
Collaboration sync layer. JitWord uses a conflict-free merge approach, not "whoever saves last overwrites the others." They also reworked the sync state mechanism specifically to fix subtle issues like inaccurate online-user counts after a browser refresh. That shows they're really stepping on and filling pits in collaboration, not just wrapping an open-source library.
On-demand rendering. The OFD editor and large documents use a combination of virtual DOM and Canvas. No matter how long the document, the browser only renders the few screens currently visible, so hundred-page documents open quickly.
Multi-model integration. JitWord built a unified AI abstraction layer that connects over a dozen mainstream models, and enterprises can also connect their own private models via a standard protocol. You're not locked into a single model; different tasks can use different cost models, keeping costs controllable. The latest version adds enterprise-level AI control – admins configure once, the whole team uses it, and keys never leak.
Open API + source delivery. JitWord isn't just SaaS; document capability is made into embeddable components. It offers a full server-side API, two integration methods (iframe embedding and JS SDK), and source-level delivery for deep secondary development, with data fully under your control during private deployment. This is a three-layer business model – "product + SDK + source code" – with a higher ceiling than pure SaaS.
Who is it for?
From an industry perspective, here's my take:
Official documents and contracts: Red-head official document parsing, collaborative bid preparation, contract review with comments, legal approval workflows. This is JitWord's strongest differentiation.
Financial reporting: Complex table and chart parsing, intelligent splitting of insurance terms, AI summarization of long documents.
Academic research: Thesis caption cross-references, reference formatting, equation editing, reviewer comments.
Government and enterprise: Private deployment on internal networks, 信创 adaptation, version auditing of institutional documents.
Manufacturing and energy: Mixed text-and-image equipment maintenance manuals, SOP templating, multi-site collaborative maintenance.
R&D teams: Technical documentation, API docs, requirement review, version comparison.
Pros and cons – being honest
The good:
JitWord's Word compatibility is indeed high. Our self-developed parsing engine achieves bidirectional comment/revision conversion, red-head formatting that doesn't break, and even Visio charts and native flowcharts parse correctly. Many online docs on the market look flashy and intimidating, but when you feed in a real contract, they fall apart.
The official document engine is the most authoritative "judge" of collaborative documents. Among domestic collaborative docs, it's rare to have such complete official-document capability – red head, layout notes, copy-to list, secrecy levels, the whole set – plus an AI official-document assistant. Government and enterprise customers basically have no other choice.
Private deployment is quite thorough. Source-level delivery, containerized one-click deployment, support for domestic servers and operating systems. Data is fully controllable.
Collaboration performance is good. Conflict-free merge, sub-second sync, multi-user collaboration for both documents and spreadsheets.
AI features are not gimmicks. They're genuinely embedded in the writing flow – double-click Ctrl to edit, continue, fix, with a dozen models to choose from.
The most sincere move is JitWord's open source. doc2docx is BSD-licensed, and jitword-sdk is also open-sourced.
Cost-effectiveness is extremely high. The enterprise co-build edition is about ¥30,000 for a permanent license, compared to Feishu's enterprise plan with per-seat, per-year fees – long-term costs are much lower.
The downsides:
Brand awareness is still early-stage. Compared to Feishu, DingTalk, and Notion, the ecosystem and third-party plugins are far behind.
Very large documents (hundreds of thousands of words) may experience rendering pressure; the system warns in advance and recommends splitting.
With many features comes a steep learning curve. Advanced capabilities like review, version comparison, and API integration take time to get familiar with on first use.
E-signatures are display-only, with no legal effect; formal signing still requires integrating a CA/e-signature system.
Iteration path
Looking at the iteration cadence from early versions to v4.3, JitWord is likely moving on three tracks in parallel:
First, continue deepening Word compatibility and official-document capabilities.
Second, move toward AI agents – from "helping write documents" to "automatically generating + automatically reviewing + automatically archiving."
Third, build an ecosystem – using SDK and API to embed document capability into more business systems, becoming the enterprise "document middle platform."
Long-term, JitWord will keep digging into the document application market.
Final words
Our team has long been searching for a document tool that "can take on Word, supports online collaboration, offers private deployment, and handles official documents and OFD." Honestly, it took a long time.
JitWord has done the most essential things for enterprises solidly: formatting that doesn't drift, collaboration that doesn't stall, data that stays inside, AI that actually works, and official documents that get done.
For teams with data-security requirements, a fixation on Word layout, and a need for online collaboration efficiency, JitWord is genuinely worth a serious look.
As an AI entrepreneur and tech enthusiast, I think this kind of domestic project that combines "enterprise document needs" with "AI efficiency tools" is worth paying attention to.
If you've hit pitfalls with any document tool, or you're interested in JitWord, tell us in the comments!