What is LocalWrite?

LocalWrite is a native macOS desktop app for writing with AI. You paste text (or upload a document), pick a writing mode, and a local LLM rewrites it in place. Everything happens on your machine — the model, the text, the rewrite.

It started as a privacy-first alternative to cloud writing assistants. The bet: most people would rather keep their drafts local, accept a slightly slower model, and never wonder if their work is being trained on.

🔒 100% Offline

After the one-time model download, LocalWrite works without an internet connection. No API calls, no telemetry, no phoning home.

🎯 5 Writing Modes

Professional, Conversational, Scholarly, Creative, and Concise — each with a curated prompt and rewriting strategy.

🧠 5 Curated Models

Qwen 2.5 7B, Gemma 2 9B, Llama 3.1 8B, Llama 3.2 3B, Mistral 7B — open-source weights, auto-downloaded on first use.

📚 Document Chat (RAG)

Upload PDFs, DOCX, Markdown, or TXT. Ask questions, summarise, or quote — answers grounded in your documents.

✏️ Quick Refinements

One-click buttons: "More formal", "More casual", "Shorter", "Longer". Plus a custom-instruction field for anything else.

📊 Live Statistics

Word count, sentence count, reading time, grade level, tone — updated as you write.

🌗 Dark Mode

Toggle from the View menu. Respects your system theme on first launch.

📤 Export Anywhere

Output to TXT, Markdown, or DOCX. Side-by-side comparison export shows your original + enhanced.

Privacy Promise

All AI processing happens locally on your device. No data is ever sent to the cloud. We don't track anything you do. No accounts or registration. The source is open — audit it yourself.

Installation

Two ways to install: download the prebuilt .app (fastest) or run from source (most flexible).

Option 1: Download the macOS App (recommended)

Go to the v1.0.1 release page.
Download LocalWrite-1.0.1-mac.zip (355 MB — the unzipped app is ~1 GB because it bundles the Python runtime, PyQt6, and llama-cpp).
Unzip and drag LocalWrite.app to /Applications.
First launch: macOS Gatekeeper will block the app because it's ad-hoc signed. Right-click the app → Open → confirm. After the first approval it launches normally.

Gatekeeper — what to do

LocalWrite isn't signed with an Apple Developer ID (that costs $99/year), so Gatekeeper will say "cannot be opened because the developer cannot be verified". Two fixes: (1) right-click → Open → Open, or (2) System Settings → Privacy & Security → scroll down → "Open Anyway". You only do this once.

Option 2: Run from Source

Use this if you want to modify the code, run on Linux/Windows, or just don't trust prebuilt binaries (smart).

# Clone the repo
git clone https://github.com/TheSolai/LocalWrite.git
cd LocalWrite

# Create a virtual environment (Python 3.9+)
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

# Launch
python main.py

First launch will offer to install llama-cpp-python automatically (it includes the native dylibs that power the local inference). If you'd rather install manually:

pip install llama-cpp-python

# Apple Silicon — GPU acceleration via Metal
CMAKE_ARGS="-DGGML_METAL=on" pip install --force-reinstall --no-cache-dir llama-cpp-python

First Launch

On first run you'll see the main window with a clean writing workspace. The model dropdown is empty — no model is selected yet.

LocalWrite — Private AI Writing Assistant

┌─ Header ─────────────────────────────────────────────────┐
│  ✍️ LocalWrite · ★ 100% Offline   Model: [ select ▾ ]   │
│                                       Mode:  [Professional ▾] ⓘ
│                                       Creativity: ────●── 50%
└──────────────────────────────────────────────────────────┘
┌─ Input ────────────────────┐ ┌─ Enhanced Output ──────────┐
│ Paste or type your text... │ │ Enhanced text appears here │
│                           │ │                            │
│ [Upload]  [Clear]         │ │ [Copy]                     │
│                           │ │                            │
│ 0 words                   │ │ 0 words                    │
└───────────────────────────┘ └────────────────────────────┘
                [ Enhance Writing ]  [ Summarize ]  [ Expand ]

Pick a Model

Click the Model dropdown in the top right.
You'll see five options. The recommended one (★) is Qwen 2.5 7B — best general-purpose writing model for the size.
If the model isn't downloaded yet, a dialog appears and downloads it from Hugging Face (one-time, 3–6 GB depending on the model).
Once downloaded, the model loads into memory. This takes 5–15 seconds on first model load — the next runs are faster because the OS caches the model file.

Which model should I pick?

For most writing: Qwen 2.5 7B (★) — best balance of speed, quality, and instruction following. Llama 3.2 3B if you have an older Mac (8 GB RAM). Gemma 2 9B for the most creative prose. Mistral 7B if you want a different voice. Llama 3.1 8B for the cleanest business writing.

Writing Modes

Each mode is a specialised prompt strategy. Pick the one that matches the transformation you want.

Mode	Best for	Example transformation
Professional	Business emails, formal docs, anything client-facing	"Hi" → "Hello"; "ain't" → "is not"
Conversational	Slack, blog posts, anything that should sound human	"Hello" → "Hi"; "cannot" → "can't"
Scholarly	Academic prose, research summaries, papers	"use" → "utilize"; "show" → "demonstrate"
Creative	Fiction, hooks, vivid prose, anything that needs to feel alive	Flat descriptions → sensory, image-rich
Concise	Editing your own drafts, cutting filler	Long sentences → short, punchy ones

The Creativity Slider

Next to the mode dropdown is a creativity slider (0–100%). It maps to the model's temperature:

0–30% — Conservative. Stays close to your original wording, just cleans it up.
50% — Default. Balanced — keeps your voice but improves clarity.
70–100% — Loose. More rewriting, more variation, more surprises.

Your First Enhancement

Walkthrough — what actually happens when you click Enhance Writing.

Step 1: Paste your text

Drop any text into the left pane. A few sentences is enough; the model needs at least a paragraph of context to do anything useful, but the upper limit is your patience (large inputs get chunked automatically).

Step 2: Pick the mode

Click the Mode dropdown and choose Professional if you're not sure — it's the safest default.

Step 3: Click `Enhance Writing`

The button enables as soon as you have a model loaded and some text. Click it. The status bar at the bottom shows progress: "Loading model..." → "Enhancing..." → "Done".

How long does this take?

On a 2023 M2 MacBook Pro with Qwen 2.5 7B: a typical paragraph (~200 words) enhances in 3–8 seconds. Larger inputs scale linearly. Apple Silicon uses Metal GPU acceleration by default.

Step 4: Read the result

The enhanced version appears on the right. The original stays in the left pane. You can:

Copy the enhanced text to your clipboard.
Edit it inline if it's not quite right.
Quick Refine it with one of the four preset buttons below.
Custom Refine with a custom instruction (see below).

What quick refinements do

Below the output pane, four buttons apply common transformations to the current output:

More formal — Pushes toward Professional mode.
More casual — Pushes toward Conversational mode.
Shorter — Cuts filler, tightens the prose.
Longer — Adds examples, expands, elaborates.

Each takes the current output, sends it back through the model with a new instruction, and replaces the output. Iterative — you can stack refinements.

Document Chat (RAG Mode)

LocalWrite can answer questions about your own documents. Upload PDFs, Word files, Markdown, or TXT, then ask questions in natural language — the AI answers from your content, not from general knowledge.

Adding a Document

Switch to the AI Chat tab (top of the window).
Click + Add in the Document Library panel.
Select a file — supported formats: .pdf, .docx, .md, .txt.
LocalWrite parses the file, chunks it into sections, and embeds each chunk into a local vector store. For a 50-page PDF this takes ~30 seconds on a modern Mac.

Asking Questions

Toggle the 🔍 RAG: OFF button to ON in the document library panel.
Type your question in the chat input at the bottom.
LocalWrite retrieves the most relevant chunks from your documents, feeds them to the model, and answers with citations.

What "grounded" means

In RAG mode, the model can only answer from chunks it retrieved. If your documents don't contain the answer, it will say so rather than hallucinating. This is the killer feature for research, contracts, technical docs, and any situation where you need trustworthy answers.

Without RAG (regular chat)

Toggle RAG off and the AI Chat tab becomes a regular offline ChatGPT-style assistant — code help, brainstorming, explanations, anything. Conversation history persists across messages in the same session.

Summarize & Expand

Two large buttons next to Enhance Writing for the most common writing tasks.

Summarize

Condenses long text to its key points — typically 20–30% of the original length. Useful for:

Meeting notes → bullet-point summary
Long articles → TL;DR
Research papers → abstract

Expand

Takes short text and elaborates it — adds examples, explanations, and supporting details. Output is typically 2–3× the input. Useful for:

Bullet points → full paragraphs
Short summaries → detailed explanations
Quick drafts → first-pass articles

Big inputs take longer

Summarize and Expand scale with input size. A 5,000-word document can take 60–90 seconds. The progress bar at the bottom shows what's happening.

Export

Three formats, accessible from File → Export:

Export as Text (.txt) — plain UTF-8, the safe default.
Export as Markdown (.md) — preserves any markdown formatting from your input.
Export as Word (.docx) — uses python-docx for proper paragraph styles and metadata.

Comparison Export

Want to keep both your original and the enhanced version side by side? Use File → Export → Export Comparison.... This produces a single document with your original on the left and the enhanced version on the right, with differences highlighted. Useful for showing your editor what you did.

Settings & Customisation

Settings live in ~/.localwrite/settings.json. You can edit this file directly, or use the in-app Settings dialog (coming soon).

Key Settings

theme — "light" or "dark".
selected_model_id — the model to auto-load on launch (set via the dropdown).
creativity_level — 0–100, the default temperature.
n_ctx — context window size (default 4096; larger = more memory).
n_threads — CPU threads (default 4; match your core count).
n_gpu_layers — Metal GPU offload (default -1 = full).

To reset all settings: delete ~/.localwrite/settings.json and relaunch.

Privacy — How LocalWrite Stays Private

LocalWrite is designed with privacy as the foundation. The whole architecture exists so that nothing leaves your device.

Network behaviour

First-time model download — fetches .gguf files from Hugging Face (the model registry, not a private server). After that, the model lives on disk at ~/.localwrite/models/.
Everything else — runs locally. The UI, the inference, the document parsing, the vector search, all on your machine.
No analytics, no telemetry, no error reporting. The app doesn't phone home. Verify yourself: Little Snitch or lsof -i shows zero outbound connections during normal use.

Where your data lives

Models: ~/.localwrite/models/ (3–6 GB each)
Settings: ~/.localwrite/settings.json
Document library & vector store: ~/.localwrite/rag_db/
History (last 100 enhancements): ~/.localwrite/history.json

To wipe everything: rm -rf ~/.localwrite/. Models will re-download next launch.

Troubleshooting

"LocalWrite can't be opened because the developer cannot be verified"

Gatekeeper blocking the ad-hoc-signed app. Two fixes:

Right-click LocalWrite.app → Open → confirm in the dialog.
If still blocked: System Settings → Privacy & Security → scroll to the bottom → Open Anyway.

"Shared library with base name 'llama' not found"

You're running a build that doesn't bundle the llama-cpp dylibs. Either:

Download v1.0.1+ (the fix is in 1.0.1).
Or rebuild from source — the dylibs come with llama-cpp-python and PyInstaller's spec picks them up automatically.

Model download fails or stalls

Check your internet connection. The model files are 3–6 GB.
If using a corporate network, HTTPS to huggingface.co must be allowed.
Re-try from the model dropdown — partial downloads resume.

Model loads but enhancement is very slow

First load is slow (~5–15 s); subsequent runs are faster.
Check Activity Monitor — if GPU is at 0% on Apple Silicon, Metal isn't engaged. Reinstall with CMAKE_ARGS="-DGGML_METAL=on" pip install --force-reinstall --no-cache-dir llama-cpp-python.
For older Macs, switch to Llama 3.2 3B (the smallest model).

Out of memory

Each model needs roughly 1.2× its file size in RAM. 7–8 GB models need 8–10 GB free. Close other apps or switch to Llama 3.2 3B (2 GB).

Reset everything

# Wipe all settings, history, and downloaded models
rm -rf ~/.localwrite/

# Re-download models on next launch

Credits & Links

LocalWrite is open source, MIT licensed, maintained by Sol AI and Anne Marie Lee.

Source: github.com/TheSolai/LocalWrite
Releases: github.com/TheSolai/LocalWrite/releases
Latest (v1.0.1): v1.0.1 release page
Report an issue: github.com/TheSolai/LocalWrite/issues

Built with

Qt 6 / PyQt6 — cross-platform UI
llama-cpp-python — local inference with Metal acceleration
sentence-transformers — document embeddings for RAG
PyMuPDF — PDF parsing
python-docx — DOCX export

Models

Qwen 2.5 7B Instruct (Apache 2.0)
Gemma 2 9B IT (Gemma license)
Llama 3.1 8B Instruct (Llama community license)
Llama 3.2 3B Instruct (Llama community license)
Mistral 7B Instruct v0.2 (Apache 2.0)

Thank you

LocalWrite is the kind of tool we wanted to use ourselves: private, fast enough, and unencumbered by accounts or subscriptions. If it helps you write better — or just write more privately — that's the whole point.

LocalWrite 1.0.1