# Why I Built an Offline-First Writing IDE with Tauri, Angular, and a Local 9B LLM

> Source: <https://dev.to/skilful_fox_ceo/why-i-built-an-offline-first-writing-ide-with-tauri-angular-and-a-local-9b-llm-50e>
> Published: 2026-11-20 22:38:34+00:00

**Recommendation:** Constrain local 9B extraction with strict JSON schemas and route its output through human one-click approval, since the model cannot distinguish real contradictions from flashbacks or unreliable narration.
More in the playbook "Designing agent systems": <https://wpnews.pro/playbooks/agent-architecture>

When you are writing a 300-page sci-fi novel, most modern "AI writing tools" solve the exact wrong problem. They want to generate prose for you, send your unpublished manuscript to a third-party cloud API, and charge a monthly subscription for the privilege.

As a software engineer who writes fiction in the evenings, I didn't want an AI to write my chapters. I wanted a fast, offline desktop environment that keeps track of 50 characters, tangled timelines, and world-building details without leaking a single byte of my draft to the cloud.

So, over the past several months, I built Fennec—a local-first desktop writing IDE. Here is a look under the hood at the architectural choices, trade-offs, and technical hurdles behind it.

Runtime: I chose Tauri over Electron to keep the binary lightweight and memory overhead low—especially important when the user might simultaneously run a local language model on the same machine.

Frontend: Angular with strict TypeScript gave me the structured, modular architecture needed to manage complex state across multiple synchronized views (manuscript editor, entity database, and visual timeline) without turning the UI layer into spaghetti.

Storage: Everything lives locally in SQLite. No accounts, no telemetry, no cloud lock-in. Your novel is just local data on your own drive.

Instead, I wired in optional local inference (running quantized models around the 9B parameter mark, such as Qwen-3.5-9B-Instruct-Q4_K_M) for a much narrower, deterministic job: structured extraction and continuity indexing.

When you import an existing .docx manuscript or write new chapters, the local model scans the text purely offline to:

Identify recurring characters, locations, and artifacts.

Extract attributes and relationships into structured database records.

Cross-reference timeline events against chapter drafts.

The biggest engineering lesson here: Local 9B models are great at entity extraction when constrained with strict JSON schemas, but they struggle to distinguish literal plot contradictions from character dreams, flashbacks, or unreliable narration. Rather than letting the model auto-edit anything, the architecture treats AI output strictly as suggestions that the author reviews and approves in one click.

To solve this, I built a visual storyboard/timeline canvas directly tied to the manuscript entities. The tricky part wasn't rendering nodes—it was making the board useful outside the app. Writers frequently need to print out their plot structure or review it on a tablet.

That meant building a dedicated export pipeline that renders the whiteboard into a large-format PDF alongside a separate generated Legend document, mapping every visual node and color code back to the underlying chapters and entities.

Keeping the heavy lifting off the UI thread and streaming the document assembly ensured that even stress-test manuscripts around the 1,000-page mark export cleanly in seconds rather than crashing the webview.

Where It Stands Today

I recently shipped Fennec v1.0.0 for desktop. It supports five interface languages (English, German, Russian, French, and Spanish), imports existing .docx drafts, runs completely offline, and keeps local AI strictly optional.

If you're interested in local-first desktop architecture or write long-form fiction yourself, you can check out the workflow in the demo video below:

You can also take a look at the project details at [fennec.skilful-fox.com](https://fennec.skilful-fox.com).

If you've built desktop apps combining Tauri with local LLMs or heavy document exports, I'd love to hear how you handled memory budgets and model lifecycle management in the comments.
