novelWriter: Why Pro Authors Ditch Word for This Plain Text Secret

novelWriter: Why Pro Authors Ditch Word for This Plain Text Secret

Your novel is broken. Not your story—your tools. You're wrestling with Microsoft Word's bloated formatting, screaming at Scrivener's proprietary lock-in, or losing hours to Google Docs' distraction factory. Meanwhile, your manuscript fragments across folders, versions blur together, and that brilliant plot twist from chapter three? Buried in a sea of untagged paragraphs, never to be found again.

What if the most powerful writing tool wasn't designed by a corporation hunting your subscription dollars, but by a developer who actually understands how novels are built?

Enter novelWriter—the open-source plain text editor that's quietly becoming the weapon of choice for technical writers, indie authors, and anyone who's ever thought, "There has to be a better way than this." Built on Python^{↗ Bright Coding Blog} and Qt6, novelWriter treats your novel like the complex software project it actually is: modular, version-controlled, and ruthlessly organized. No cloud dependencies. No format lock-in. Just pure, portable, future-proof text.

Ready to see why developers and authors are converging on the same solution? Let's pull back the curtain.

What is novelWriter?

novelWriter is an open-source plain text editor purpose-built for writing novels assembled from many smaller text documents. Created by Veronica Berglyd Olsen (vkbo on GitHub), this Python-powered application strips away the cruft of traditional word processors and replaces it with a minimalist, Markdown^{↗ Smart Converter}-inspired syntax that keeps your focus where it belongs: on the words.

But here's the twist that makes novelWriter genuinely different: it's designed like a developer's IDE, not a secretary's typewriter.

The project emerged from a simple, painful observation: novels are complex, hierarchical documents that span months or years of work. Yet the tools we use treat them like single-file essays. novelWriter flips this paradigm by embracing document assembly—breaking your manuscript into discrete, manageable pieces (chapters, scenes, notes) that you can rearrange, reference, and version-control with surgical precision.

Built on Python 3 with Qt6/PyQt6 for the interface, novelWriter runs natively on Linux, Windows, and macOS. Its storage format? Plain text files with a lightweight markup syntax. This means your work is human-readable without the application, plays nicely with Git and other version control systems, and syncs effortlessly across devices using whatever cloud solution you prefer (or none at all).

The project's explicit stance against "AI slop" in its development process signals something rare: genuine craft over automation hype. Every feature exists because a real writer needed it, not because a product manager demanded it.

Key Features That Transform Your Writing Workflow

Modular Document Architecture

novelWriter treats your novel as a project, not a file. Create hierarchical structures with folders for acts, chapters, and scenes. Drag-and-drop to reorder. This mirrors how developers organize codebases—and for good reason. Complex creative works benefit from the same modularity.

Minimal Markup Syntax

Inspired by Markdown but optimized for fiction, the syntax handles:

• Headings for structure (#, ##, ###)
• Emphasis with *italics* and **bold**
• Meta data blocks for tags, references, and synopses
• Comments that won't appear in compiled output

No hidden formatting. No "what you see is what you get" lies. Just explicit, portable markup.

Built-in Novel Organization Tools

• Outline View: See your entire novel's structure at a glance
• Novel Tree: Navigate scenes and chapters hierarchically
• Document Labels & Status: Track draft status (Draft, Revised, Finished, etc.)
• Tags & References: Cross-reference characters, locations, plot threads across documents

Version Control Native

Because files are plain text, Git integration is seamless. Track every revision. Branch experimental plotlines. Collaborate with co-authors using pull requests. Your novel's history becomes as navigable as your code's.

Multi-Platform & Future-Proof

Qt6 ensures native performance across operating systems. The GPLv3 license guarantees the tool remains free and open forever. No vendor lock-in. No subscription cliff.

Export & Compilation

Assemble your scattered documents into polished manuscripts. Export to standard formats for agents, editors, or self-publishing platforms.

Real-World Use Cases Where novelWriter Dominates

1. The Serial Novelist Managing Epic Series

Writing a five-book fantasy saga? Traditional tools force you into monolithic files or chaotic folder structures. novelWriter's project-based organization lets you maintain consistent character references, world-building notes, and cross-book plot threads. Tags ensure your protagonist's eye color stays consistent across 500,000 words.

2. The Technical Writer Who Demands Git

You're already comfortable with version control. Why abandon it for creative work? novelWriter's plain text format means git diff shows exactly what changed between drafts. Branch a chapter rewrite without fear. Merge when satisfied. Your writing process gains the same safety net as your code.

3. The Distraction-Resistant Minimalist

Every toolbar button, notification badge, and auto-format "help" steals cognitive load. novelWriter's intentionally sparse interface eliminates decision fatigue. Open the editor. Write in plain text. The formatting syntax is learnable in minutes, mastered in an afternoon.

4. The Multi-Device Nomad

Dropbox, Syncthing, Nextcloud, rsync—your choice. Because novelWriter uses standard files and folders, synchronization is trivial. Work on your laptop at the café, tablet on the train, desktop at home. No proprietary cloud service required. No internet connection needed for core functionality.

5. The Collaboration-Ready Writing Team

Co-authoring a thriller? novelWriter's file-based structure enables true collaborative editing through Git branches, or simple shared folders with conflict-resolution at the document level. No more fighting over who has the "master" document open.

Step-by-Step Installation & Setup Guide

Method 1: pip Installation (Recommended for Most Users)

novelWriter is available on PyPI, making Python-savvy installation straightforward:

# Ensure Python 3.10+ and pip are installed
python --version

# Install novelWriter
pip install novelwriter

# Launch the application
novelwriter

Method 2: Linux Package Managers

For Debian/Ubuntu-based distributions, check if your repository includes novelWriter:

# Search availability
apt search novelwriter

# Install if available
sudo apt install novelwriter

For Arch Linux users, check the AUR for novelwriter or novelwriter-git packages.

Method 3: Windows & macOS Installers

Pre-built installers are available from the releases page. Download the appropriate .exe (Windows) or .dmg (macOS) file for your architecture.

Method 4: Running from Source

For developers or those wanting the bleeding edge:

# Clone the repository
git clone https://github.com/vkbo/novelWriter.git
cd novelWriter

# Install dependencies (requires Python 3.10+)
pip install -r requirements.txt

# Run directly
python novelwriter.py

Initial Project Setup

Upon first launch:

1. Create New Project: File → New Project → Choose location
2. Configure Structure: Add folders (Acts, Chapters, Scenes, Notes)
3. Set Status Labels: Draft → Revised → Finished (customizable)
4. Importance Tags: Character, Location, Object, Plot Point

The project saves as a folder containing your documents and a .nwx project file—both transparent and portable.

REAL Code Examples from the Repository

novelWriter's power lies in its lightweight markup syntax. Here are actual patterns derived from the project's documentation and design philosophy:

Example 1: Basic Document Structure with Headings

# My Awesome Novel

## Chapter One: The Beginning

### Scene 1: Awakening

The morning light filtered through curtains that hadn't been washed in *decades*.

**Something was wrong.** The silence held weight—unnatural, expectant.

She reached for the knife she kept under her pillow, finding only empty sheets.

Explanation: The heading hierarchy (#, ##, ###) defines your novel's structure. novelWriter's Outline View parses these automatically, giving you instant navigation. Notice the Markdown-style emphasis: *italics* for internal thought or emphasis, **bold** for strong emphasis. This syntax is universal—readable in any text editor, transformable by any Markdown processor.

Example 2: Meta Data Blocks for Organization

@% This is a comment that won't appear in exports

@synopsis: Protagonist discovers the hidden door in her grandmother's house

@pov: Eleanor Vance
@location: Thornfield Manor, East Wing
@time: October 14, 1987, 3:47 AM

@tag: Eleanor_Vance
@tag: Thornfield_Manor
@tag: hidden_door_mystery

The door hadn't been there yesterday. She was certain of it.

Explanation: This is where novelWriter transcends simple Markdown. The @ syntax creates machine-readable metadata that's invisible in exports but powers the application's organizational features. @synopsis feeds your outline view. @pov, @location, @time enable filtering and cross-referencing. @tag creates linkable references—click any tag to find all documents mentioning it. For series writers, this is game-changing: track every appearance of a character or location across dozens of documents.

Example 3: Cross-Referencing Between Documents

## Scene 5: The Revelation

Eleanor recalled the warning her grandmother had whispered decades ago.
The words echoed as she faced the entity behind the door:

> "When the clock strikes thirteen, the boundary wears thin."

@tag: grandmother_warning
@ref: Eleanor_Vance
@ref: Thornfield_Manor
@ref: chapter_3_clock_mechanism

The mechanism from Chapter 3—she finally understood its purpose.

Explanation: Cross-references (@ref) create bi-directional links between documents. Clicking @ref: Eleanor_Vance shows every scene from that character's perspective. This transforms novelWriter from a text editor into a knowledge management system for your fictional world. The blockquote syntax (>) handles dialogue or remembered text cleanly.

Example 4: Project Configuration (XML-Based)

novelWriter stores project metadata in human-readable XML. Here's the conceptual structure:

<?xml version="1.0" encoding="utf-8"?>
<novelWriterXML appVersion="2.5" hexVersion="0x020500f0" fileVersion="1.5" timeStamp="2024-01-15T09:23:17Z">
  <project>
    <name>Thornfield Legacy</name>
    <title>Thornfield Legacy</title>
    <author>Your Name</author>
    <saveCount>847</saveCount>
    <autoCount>12</autoCount>
    <editTime>1847293</editTime>
  </project>
  <settings>
    <doBackup>True</doBackup>
    <language>en_GB</language>
    <lastHandle>0000000001234</lastHandle>
  </settings>
</novelWriterXML>

Explanation: The .nwx project file is fully transparent—parse it with standard XML tools, back it up with standard utilities, version it with Git. The saveCount and editTime metrics satisfy the data-curious writer. Crucially, your actual content lives as separate .nwd files (novelWriter documents)—plain text with the markup syntax shown above.

Advanced Usage & Best Practices

Git Integration Workflow

# Initialize repository in your novel's project folder
cd ~/novels/thornfield-legacy
git init
git add .
git commit -m "Initial project structure"

# Daily writing session
git add -A
git commit -m "Chapter 7 scene 3: Eleanor confronts the entity"

# Experimental branch for alternate ending
git checkout -b alternate-ending
# ... write freely ...
git checkout main  # Return to canonical version anytime

Synchronization Strategy

Use Syncthing for peer-to-peer sync without cloud servers, or Nextcloud for self-hosted storage. The key: novelWriter's file-based approach means any sync tool works. Avoid simultaneous edits on the same document (use Git for true collaboration).

Custom Status Labels

Beyond Draft/Revised/Finished, create granular states: Needs Research, Awaiting Feedback, Proofread Complete. Your novel's pipeline becomes as trackable as a software sprint.

Backup Discipline

The project explicitly recommends enabling backups (doBackup: True). Combine with Git for 3-2-1 compliance: 3 copies, 2 media types, 1 offsite. Your years of work deserve it.

Comparison with Alternatives

The Verdict: Scrivener matches novelWriter's novel-specific features but locks you into proprietary formats. Obsidian offers similar flexibility but requires extensive plugin configuration for fiction workflows. novelWriter hits the sweet spot: purpose-built for novels without sacrificing openness.

FAQ

Is novelWriter suitable for non-fiction or academic writing?

While optimized for fiction, the modular structure and Markdown export work for any long-form writing. However, citation management (Zotero integration, etc.) isn't native—consider Quarto or R Markdown for heavily referenced academic work.

Can I import my existing Scrivener or Word manuscript?

Plain text export from any source works. For Scrivener, compile to plain text or Markdown, then import documents into novelWriter's structure. Some manual reorganization of meta data will be needed.

Does novelWriter support collaboration in real-time?

Not natively—this is intentional. Real-time collaboration creates version chaos. Instead, use Git branches for structured collaboration, or shared folders with document-level locking for simpler workflows.

What happens if development stops?

GPLv3 ensures the code remains available forever. Your files are plain text—readable without the application. This is maximum future-proofing, impossible with proprietary alternatives.

Is there mobile support (iOS/Android)?

No native mobile apps yet. However, plain text files mean you can edit with any mobile text editor (iA Writer, Markor, etc.) and sync via your preferred method. Reopen in novelWriter for organization.

How does the Markdown syntax differ from standard Markdown?

novelWriter uses a subset of CommonMark for formatting, plus custom @ directives for meta data. Standard Markdown renderers will ignore the @ syntax harmlessly—your files remain portable.

Can I customize the appearance?

Qt6 enables theme customization including light/dark modes, editor colors, and font choices. The focus stays on content, but visual comfort is configurable.

Conclusion

The writing tools we choose shape the work we produce. Microsoft Word trains us to fuss with margins. Scrivener tempts us into endless organizational rabbit holes. Cloud platforms hold our words hostage to subscription renewals and internet connectivity.

novelWriter offers something radical: respect for the writer. Respect for your time, your ownership, your future access to your own creative work. By treating novels as the complex, interconnected documents they are—while preserving the simplicity and portability of plain text—it bridges the gap between creative freedom and technical robustness.

Whether you're a developer who craves Git integration, a minimalist fleeing feature bloat, or simply someone who believes your novel should outlive any single company's business model, novelWriter deserves your attention.

The manuscript of your dreams is waiting. Stop wrestling with the wrong tools.

👉 Get started today: Visit https://github.com/vkbo/novelWriter to download, explore the documentation at docs.novelwriter.io, and join the community of writers who've discovered that the best writing environment is the one that gets out of your way—and stays out forever.

100% free. 100% open. 100% yours.