Notepatra

The first code editor built for the AI era.

C++ + Rust · ~13 MB bare native executable · Zero Electron · 238 file types · 82 language lexers · Local AI formatters · MCP server

MCP: notepatra-mcp now ships a prebuilt signed Windows sidecar and a one-click Claude Desktop bundle — connect Claude Desktop, Claude Code, OpenAI Codex, and any MCP client to the running editor. 49 tools (Git, read-only SQL, saved-connection queries, charts, Noter notes); every write human-approved in-window; nothing leaves your machine.

Website · Download · MCP · Features · The Story · Install · Plugins · AI · Contributing · Security · Changelog

The Story

I'm Prateek Singh. A developer who spent years on Linux wanting a small, fast, free native code editor that could fix things in seconds — broken JSON, messy SQL, tangled HTML — and finding only Wine hacks or bloated Electron editors eating 500 MB of RAM to show a text file.

Every text editor told me to pick two of three: fast, powerful, native. Vim is fast and native but cryptic. Modern Electron editors are powerful but heavy. The truly tiny native ones either don't have AI or don't run cross-platform.

So I built Notepatra.

Not a port. Not a wrapper. Something new — for everyone.

I asked: what would a small native code editor look like if it was built today, in 2026, when AI is part of every developer's workflow, and ran natively on Linux + macOS + Windows from one codebase?

The answer: a tiny native executable — ~13 MB bare (~13.4 MB on Linux x64) on every platform — with a Rust-powered core, Scintilla editing engine, and local-first AI integration (cloud backends optional). v0.1.129 downloads: 4.7 MB Linux x64 (tarball, Qt from the system), 28.0 MB on macOS (DMG with bundled Qt), 32.8–43.9 MB on Windows (MSI/zip/setup.exe with bundled Qt DLLs). An editor that can fix your broken JSON with regex in milliseconds — and when regex isn't enough, it asks your AI to figure it out — local by default, six cloud backends one click away when you want a frontier model. No telemetry. No subscription. No mandatory API key.

Notepatra started on Linux — because that's where the gap was. But great tools shouldn't have borders. Notepatra runs on Linux, Windows, and macOS. Same codebase. Same features. No one gets left behind.

Notepatra is what I wish had existed — on every platform.

Features

Editor — Battle-tested basics done right

• 238 file extensions mapped to 82 language lexers — Python, C/C++, C#, Java, Kotlin, JavaScript, TypeScript, Rust, Go, Swift, Dart, Solidity, Zig, Vala, Hack, Julia, R, Protobuf, F#, HCL/Terraform, Thrift, GraphQL, GDScript, Nim, Cython, Mojo, Crystal, Elixir, Scala, Groovy, Apex, SQL (6 dialect presets), HTML, CSS, JSON, JSON5, YAML, TOML, Markdown, Bash, Fish, Nushell, Fortran, VHDL, Verilog, MATLAB, LaTeX, BibTeX, Jinja, Liquid, Twig, Dockerfile, DotEnv, Gitignore, and more. Rust / Go / Swift / Kotlin / TypeScript / PowerShell ship as Notepatra-local lexers (not just C-family fallbacks)
• Tabbed editing — drag, reorder, middle-click close, double-click empty area for new tab
• Tab right-click menu — Close, Close All BUT This, Close All to the Left/Right, Close All, Save, Save As, Rename, Copy Full Path, Copy Filename, Copy Directory Path, Open Containing Folder, Open Terminal Here, Read-Only toggle, Color Tag (7 named colors + custom + Remove)
• 3 themes — Light, Dark, Monokai (Settings > Theme)
• Session persistence — close Notepatra, reopen tomorrow, same files, same cursor positions, same window size
• Crash recovery — if Notepatra crashes (it shouldn't, but life happens), your unsaved work is recovered on next launch
• File change detection — someone else edits your file? Notepatra asks: reload or keep yours?
• 2 GB file support — memory-mapped I/O via Rust; files up to ~1.86 GB load fully, larger open truncated + read-only
• Double-click word highlight — double-click any word, all occurrences light up in orange
• Ctrl+B brace matching — jump between matching {} [] (), highlights both braces + selects everything between
• Macro recording — Start Recording (Ctrl+Shift+M), Stop, Playback (Ctrl+Shift+P), Run Multiple Times, Save/Load macros
• Code folding, bookmarks, auto-complete, indent guides, line numbers
• Custom scrollbars — clean, modern, rounded

Search — Find anything, anywhere

• Project Search (Ctrl+Shift+G) — recursive search across file names AND file contents in any text-based file. Any size, any language (Python, SQL, C/C++, JS/TS, Rust, Go, HTML, JSON, YAML, Markdown, logs, config). Streams line-by-line so a 2 GB log searches the same as a 2 KB script. Each match shows exact line:col coordinates — double-click to jump the caret to the character.
• 5-tab Find/Replace dialog — Find, Replace, Find in Files, Mark, Go to
• 3 search modes — Normal, Extended (\n, \r, \t, \xNN), Regular expression
• Find All in Current Document — results appear in bottom panel, double-click any result to jump to that exact line
• Find All in All Opened Documents — search across every open tab at once
• Replace All in All Opened Documents — one click, every file updated
• Find in Files — search entire directories recursively with file filters
• Mark All — highlight every occurrence with visual indicators
• Aho-Corasick search engine (Rust) — faster than regex for literal patterns

Plugins — The real power

Every plugin opens in its own tab. Real UI, not just a menu click.

JSON Tools (inbuilt)

HTML Tools (inbuilt)

Bracket Tools (inbuilt)

SQL Formatter (inbuilt)

• Format with UPPERCASE or lowercase keywords
• Configurable indent width
• Supports T-SQL, PL/SQL, MySQL, PostgreSQL, SQLite

Compare / Diff (inbuilt)

• Pick any two tabs or any tab vs file on disk
• Side-by-side Scintilla editors with a ComparePlus-style overview/nav bar
• + green for added, - red for deleted, # amber for changed
• Word-level LCS intra-line diff — within a changed line, the specific tokens that were removed are highlighted in red on the left pane; the tokens that were added are highlighted in green on the right pane. Works on actual word boundaries, not just common-prefix/suffix.
• Dark-mode aware — colours track your Notepatra theme (Light / Dark / Monokai) so diffs stay readable on both black and white backgrounds.
• Prev/Next diff navigation, inline overview-bar jump
• Ignore whitespace, ignore case, ignore empty lines checkboxes
• Unlock for editing mode — edit either pane and re-diff in place
• Powered by Rust Myers diff (line-level) + C++ LCS (word-level)
• Visual UX inspired by ComparePlus by Pavel Nedev — credit where credit is due.

Git Integration (inbuilt)

• Staged / Unstaged trees — porcelain v2 parser, inline + / − buttons per row to stage/unstage
• Branch chip with ahead/behind — shows main ↑3 ↓1 when diverged
• Commit box (Ctrl+Enter) — line-count indicator, blocks commit when nothing's staged
• Sync row — one-click Pull / Push / Fetch with live ahead/behind refresh
• Collapsible history + stash menu — recent commits expandable; stash / pop / list / drop
• Git gutter — green/yellow/red markers in editor margin for changed lines

AI Powered — local-first, cloud-optional

Backend dropdown ships 6 entries — Ollama (local default · localhost:11434), llama.cpp (GGUF) (local · localhost:8080), OpenRouter (cloud · 100+ models), Ollama Cloud (cloud · gpt-oss:120b / qwen3-coder:480b / deepseek-v3.1:671b), OpenAI (cloud · GPT-4o / GPT-5 / o-series), Azure OpenAI (enterprise). Per-provider key slots — no cross-provider bleed. The llama.cpp entry also accepts a user-configured base URL via Settings → Preferences → AI, so you can route it to any OpenAI-compatible HTTP server you have installed separately. Local backends keep code on your machine; cloud backends are opt-in. No telemetry. No subscription. No mandatory API key.

AI Assistant — side-dock (Ctrl+Shift+A)

The AI chat lives in a persistent right-side dock, not an editor tab. One conversation, preserved across tab switches. Tick Coding Mode to open the 3-column coding layout (file tree · editor · AI chat) 3-pane layout.

Workspace awareness. Every prompt carries:

• the selection (or full file if no selection is active)
• the full text of the current file
• excerpts of every other open editor tab
• a flat listing of all files under the workspace root (.git, node_modules, target, dist, etc. filtered out)

So the model can reason about files you haven't opened yet — "import from utils.py" works even when utils.py isn't in a tab. Budget-capped so small local models (3B, 4K–8K context) don't overflow.

One-click actions (hidden by default, click "▸ Quick actions" to reveal): Explain · Find Bugs · Refactor · Write Tests · Add Comments · Generate Docs · Optimize · Translate. Or type a custom prompt. Responses stream in, each has a Copy link, and the last response can be inserted at the cursor or replace the selection with one click.

Speech-to-text — optional mic button, uses local arecord + whisper CLI when installed. No audio ever leaves the machine.

AI Setup

# Easiest path: Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5-coder:3b   # 2 GB, best for code on CPU-only / 16 GB RAM
ollama serve

Notepatra auto-detects the running Ollama and picks the most CPU-friendly model installed. For llama.cpp / OpenRouter / Ollama Cloud / OpenAI / Azure OpenAI, pick the backend from the dropdown at the top of the AI panel; base URL and API key are editable inline. The llama.cpp entry also accepts a user-configured base URL via Settings → Preferences → AI, so you can route it to any OpenAI-compatible HTTP server you have installed separately.

🔐 Password Generator — passwords, passphrases and SSH keys, with an honest entropy figure (Tools > Password Generator — Passwords / Passphrases / SSH keys)

A generator built into the binary, opened from the Password button on the Built-in Tools toolbar (third, immediately after AI) — press it again while the tab is focused and the tab closes. A left rail switches between three pages: Password, Passphrase and SSH key (Alt+1 / Alt+2 / Alt+3). It ships in every build, including the default Lite binary and works fully offline: no network, no download, no backend, no AI.

• Password — random characters, 4–256 (default 20) from a-z / A-Z / 0-9 / a 27-character symbol set, plus a free-text field for any extra characters you want, with optional exclude look-alikes (drops 0 O 1 l I) and at least one from each set (on by default). The symbol set deliberately omits the quotes, backslash, backtick, pipe and space — the characters that break a password pasted into a shell command, a YAML file or a database connection string.
• Passphrase — 3–24 words (default 6) from a 2,048-word list compiled into the binary (no dictionary file is read at runtime), so each word is worth exactly 11 bits and six words is 66 bits; pick a hyphen / period / underscore / space / no separator, optionally capitalise each word or append two digits. Both text modes generate 1 to 100 independent values at once, with Generate · Copy · Insert into editor · Open in new tab.
• SSH key — a real OpenSSH key pair, generated locally: Ed25519 (recommended), ECDSA P-256 / P-384, RSA 3072 / 4096, and RSA 2048 marked legacy. An optional passphrase encrypts the private key with aes256-ctr + bcrypt-pbkdf, the same construction ssh-keygen uses. The comment field is empty by default, on purpose: ssh-keygen defaults it to user@host, which copies your username and machine name into every authorized_keys file the key is ever pasted into. The public line and its SHA256 fingerprint are shown immediately; the private key stays hidden until you tick Show private key. Save private key… creates the file, sets it to 0600, then writes it, refuses to overwrite an existing file, and writes the .pub companion (0644) beside it. Generation runs off the GUI thread, so the window stays responsive while RSA-4096 takes its 1.6–5.9 s. Interoperability is checked against the system ssh-keygen in the test suite — -y reproduces the public line, -lf the fingerprint, and -y -P opens the encrypted key and rejects the wrong passphrase. The pure-Rust crypto (RustCrypto ssh-key) costs about 0.6 MB of binary.
• The bits number is a count, not a score — it is the base-2 logarithm of how many distinct values your current settings can produce, not a heuristic guess at how complicated the output looks, which is what most meters show. Tick at least one from each set and the figure drops slightly: it is recomputed by inclusion–exclusion over the selected sets, because the guarantee rules out every password that misses a set, so fewer passwords exist. Most generators advertise the unconstrained number while enforcing the constraint, which overstates the result. Default settings read 129 bits.
• Real randomness, and nothing kept — every draw comes from the OS random source (getrandom on Linux, the platform equivalent elsewhere) through the Rust core. Qt's QRandomGenerator::system() is now only the fallback, not the source — it was the source before v0.1.129, and on x86-64 that meant the CPU's RDRAND instruction first, which is a different provenance than most readers assume. SSH keys come from the same OS source. Draws use rejection sampling so no character is favoured just because the alphabet size doesn't divide 2^32, and the set guarantee is enforced by drawing again until it holds, not by placing one character per set and shuffling — placement would make some strings likelier than others and turn the bits figure into a lie. The panel is a plain widget rather than an editor, and session save/restore, the AI-context sweep and the MCP read verbs are all gated on the tab being an editor, so a generated value never lands in session.json, never reaches an AI backend, and is not readable by a connected MCP client. Copy takes the value back off the clipboard after 30 seconds — but only if the clipboard still holds it, so it never clobbers something you copied since. The 30-second wipe arms for the private key only, never for the public line. Nothing is written to disk unless you choose Save private key….

👁 AI Interaction Log — see exactly what your AI did (Features → AI Interaction Log…)

Total transparency, on by default. Every request and response to any AI backend — local (Ollama / llama.cpp) or cloud (OpenRouter / OpenAI / Azure / Ollama Cloud), including Noter's Extract — is written to a local SQLite log you can open and read: timestamp, backend, model, mode, full prompt + full response, token counts, latency. It never leaves your machine (zero network egress), entries auto-prune after 7 days, and a built-in credential scrubber masks API keys / bearer tokens / PEM private keys before anything is stored. The viewer has backend/model/mode filters, Export JSON, Prune now, and a one-click opt-out toggle. You are never guessing what got sent to a model — you can audit every byte. Privacy as transparency, not as a promise.

📝 Noter — meeting notes that turn into reminders (Ctrl+Alt+N)

A local-first, two-pane meeting workspace (notes list · editor) — no accounts, no bots; notes live under ~/Documents/Notepatra/Noter/.

• Write fast — a top toolbar drops in Action Items / What I plan / To-dos headers and checkbox bullets; check a line to strike it through.
• Extract (Ctrl+Alt+E) runs your AI backend over the note and returns a summary plus action items / decisions / questions / risks. A task that mentions a time ("ship the build 10am tomorrow") comes back with that date/time pre-filled.
• Reminders — set one on a note (right-click) or schedule action items straight from Extract; they all collect in a central Reminders list grouped Overdue / Today / This week / Later, with desktop notifications at the due time while Notepatra is running (missed ones arrive as one summary at next launch). Click to open the note, pencil to reschedule, ✕ to delete. Re-running Extract flags what's already scheduled so you never pile up duplicates.

📐 Diagram tool — flow / ER / system diagrams from text (.npd)

A first-class diagramming surface that renders in the default binary on every platform (incl. macOS Apple Silicon and the Windows installer — native Qt renderer, no WebEngine), opened from the toolbar next to Noter. The tiny .npd text DSL is the source of truth; the canvas is a live projection of it (so undo/redo and version control just work).

• Create three ways — AI Generate describes it in plain English and a local model writes the .npd, shown in a review pane before it touches the canvas (undo/redo after); or start from a Flow / ER / System template; or write .npd directly. Import Mermaid converts an existing flowchart, now mapping -.-> to a dashed edge and subgraph … end to a group.
• Why not just Mermaid? — Mermaid needs a browser or JS runtime; .npd renders natively, offline, in the Lite binary, with AI Generate, node-pinned notes, legends, built-in icons, theme-following palettes, and an export_diagram MCP tool. Mermaid still wins on diagram types (sequence, class, Gantt) and on GitHub rendering it inline — the full comparison is in the docs.
• Drawn flat, like an engineering diagram — no gradients, no drop shadows: a 1.5 px border, the app's own font, and a tighter grid. Two light palettes ship — paper and slate — alongside the older dark ones (clay / ocean / forest / mono / default), and the new default palette auto follows the app theme: light theme → paper, dark theme → default.
• Rich visuals — 5 shapes (pill / box / decision diamond / database cylinder / icon), ~55 hand-drawn icons (~150 aliases) for system / ER / flowchart, directed + labelled + bidirectional arrows, dashed edges (a -.-> b, a <.-> b) for the async / optional / best-effort hop, label-overflow→hover, infinite pan/zoom canvas. A per-node colour renders as a tint on a light palette (soft wash, full-strength border, normal dark text) and as a solid fill with auto-contrast text on a dark one.
• Say what a picture can't — direction LR lays the diagram out left-to-right (TB is the default), group "Edge tier" : cdn api draws a labelled container behind those nodes, note api "Rate-limited to 100 rps" pins a small card beside one, and legend dashed "async" / legend #cc785c "hot path" build a legend box (which appears only if you write at least one legend line). group, note, legend, direction and layout are now reserved words — an existing file that uses one as a node id needs the id renamed.
• Export — PNG / JPEG / PDF on every build, plus SVG / HTML where the Qt Svg module is present and WebP where the Qt WebP image plugin is present (the menu shows exactly what your build supports). A Help button has the full cheat-sheet; samples/diagram_showcase.npd shows every element; the npd_render CLI renders any .npd to an image headless.

More Features

Keyboard Shortcuts

AI assistants (MCP) — new in v0.1.118

From v0.1.118, Notepatra ships notepatra-mcp — a stdio JSON-RPC 2.0 Model Context Protocol server that connects external AI assistants (Claude Desktop, Claude Code, OpenAI Codex, the OpenAI Agents SDK, and any spec-compliant MCP client) to the running editor over a local socket. Nothing leaves your machine: stdio to the client, local socket to the editor, no network connections.

49 tools in three tiers:

find_in_tab and search_project also take an optional regex flag. run_sql is SELECT-only (rejected by the SQL classifier otherwise) and, on the Full/DuckDB edition, runs in an engine sandbox — the target file is materialized into an in-memory table, then DuckDB's external filesystem access is disabled (enable_external_access=false) before the untrusted query runs, so it cannot read host files. Since v0.1.119 the sidecar also supports Windows over a named pipe.

Hook it up in one line each (from v0.1.118):

# Claude Code (Anthropic)
claude mcp add notepatra -- notepatra-mcp --socket

# Codex CLI (OpenAI) — ~/.codex/config.toml
[mcp_servers.notepatra]
command = "notepatra-mcp"
args = ["--socket"]

Full tool reference, Claude Desktop / Agents SDK snippets, security model, and honest limitations (editor must be running; prebuilt Windows sidecar zip + one-click .mcpb bundle ship from the next release — until then Windows uses cargo install notepatra-mcp; cloud-only connector surfaces can't reach a desktop editor): docs/mcp.html / notepatra.org/mcp.html.

Architecture

┌──────────────────────────────────────────────┐
│            C++ Layer (Qt5 + QScintilla)       │
│   UI · Menus · Tabs · Dialogs · Editor       │
│   Terminal · AI Panel · Compare · Plugins     │
├──────────────────────────────────────────────┤
│                C FFI boundary                 │
├──────────────────────────────────────────────┤
│            Rust Core Library                  │
│   File I/O (mmap) · Search (Aho-Corasick)    │
│   Diff (Myers) · JSON/HTML/SQL Formatters    │
│   Bracket Fixer · Hash · Base64 · Encoding   │
└──────────────────────────────────────────────┘

Why this hybrid?

• C++ because Qt and QScintilla are C++ — zero friction for UI
• Rust because file I/O, text processing, and parsing must never crash — Rust's ownership system guarantees memory safety
• Result: the speed of C++, the safety of Rust. The bare executable is ~13 MB on every platform (~13.4 MB Linux x64, similar on macOS / Windows). Latest v0.1.129 download sizes: 4.7 MB Linux x64 tar.gz · 4.4 MB Linux ARM64 tar.gz · 28.0 MB macOS DMG (with bundled Qt) · 43.9 MB Windows MSI · 33.0 MB Windows NSIS · 37.8 MB Windows portable zip. Installed footprint on Windows is ~75-85 MB after the MSI extracts bundled Qt + QScintilla DLLs — normal for any Qt-based installer.

Install

One-command install

Linux / macOS:

curl -fsSL https://notepatra.org/install.sh | sh

Windows (PowerShell):

irm https://notepatra.org/install.ps1 | iex

That's it. Auto-detects your OS, downloads the right binary, installs it, adds to PATH, creates shortcuts.

Or download manually — Latest release: v0.1.129

⚠ Download size vs. installed size are different. The numbers above are download sizes — the .msi / .dmg / .tar.gz files you grab from GitHub Releases. After install, the on-disk footprint is larger because the installer extracts the bundled Qt DLLs, QScintilla DLL, and Rust core library out of the compressed payload. Typical installed size on Windows: ~75-85 MB. Linux installs are still tiny (~13 MB on disk) because Qt5 comes from your distro repo, not the tarball. macOS Notepatra.app on disk is ~50-60 MB after xattr removal.

Lite vs Full. The downloads above are the default Lite build. Each release also ships an opt-in Full variant (-full) that bundles the DuckDB query engine on every platform — plus, on Linux and Windows, the QtWebEngine inline Vega-Lite chart renderer (the generate_chart tool). macOS Full is DuckDB-only: Homebrew qt@5 no longer ships QtWebEngine and there is no Apple-Silicon Qt5 WebEngine, so inline Vega charts are a Linux/Windows Full feature. The native fenced ```chart (QtCharts) renderer and the .npd diagram tool work on every platform in both flavors.

Why are the download sizes different? Bare notepatra executable is ~13 MB on each platform (~13.4 MB Linux x64 — slightly smaller on Windows/macOS than on Linux because clang + MSVC emit denser code than gcc). On Linux, Qt5 is a standard system package (apt install qtbase5-dev libqscintilla2-qt5-dev), so the download is just the binary (~4.7 MB compressed). On macOS and Windows, Qt isn't pre-installed, so we bundle the Qt frameworks / DLLs alongside the executable for portability — same approach Krita, Kdenlive, and every cross-platform Qt app uses. Even with Qt bundled, Notepatra installs at ~12–85 MB depending on platform vs 300+ MB for VS Code.

macOS Intel: not shipped pre-built. Apple stopped selling Intel Macs in 2023 and the GitHub Actions macos-13 runner has been unreliable. Intel Mac users — git clone and run ./build.sh. Builds in ~3 minutes.

Admin / Fleet install — for IT, DevOps, and regulated teams

For one-time-install-then-every-user-sees-it on a shared machine, or silent push to a fleet via SCCM / Jamf / Ansible / Salt, every supported platform has a per-machine artefact:

All artefacts ship with cosign .sig + .pem for keyless Sigstore verification and SLSA build provenance. See Verify your download below.

🔒 notepatra-local-ai — cloud-free build for regulated environments

For teams that can't or won't send code to public LLM endpoints — regulated industries (finance, healthcare, legal, gov), data-sovereignty regions (EU GDPR, India RBI, China), air-gapped networks, or anyone who wants by-construction privacy — there's a dedicated cloud-free build, available for Linux and Windows:

The binary physically cannot reach api.openai.com, api.anthropic.com, openrouter.ai, api.mistral.ai, generativelanguage.googleapis.com, or any other public LLM endpoint. Every QNetworkAccessManager request goes through an allowlist that only accepts:

• localhost / 127.0.0.1 / [::1]
• RFC1918 (10.x, 172.16-31.x, 192.168.x)
• CGNAT range (100.64.0.0/10 — covers Tailscale, corp VPN)
• IPv6 unique-local (fc00::/7)
• DNS suffixes .local, .lan, .internal, .intranet, .corp, .home

Local Ollama, local llama.cpp, self-hosted Ollama on the LAN, and any other OpenAI-compatible server you have installed locally or on your private network — all continue to work in the cloud-free build. Only public-cloud LLM endpoints are blocked. The cloud-URL paste box is stripped from the UI as well, so users can't even type a public host. Auditors can confirm by running strings notepatra | grep -c openai.com — zero hits.

On Linux the two flavors share the same notepatra binary name on disk; apt Conflicts ensures only one of notepatra / notepatra-local-ai is installed at a time, swap transactionally with sudo apt install ./notepatra-local-ai_0.1.129_amd64.deb. On Windows the two MSIs are independent products (different UpgradeCode + ProductName + install dir) so they can coexist if needed; admins typically push one or the other based on policy. notepatra --version self-identifies the build by name — only the bare lite build carries an edition suffix: Notepatra Lite v0.1.129 for the lite build and Notepatra v0.1.129 for the full build (DuckDB bundled), plus Notepatra Local AI Lite v0.1.129 / Notepatra Local AI v0.1.129 for the cloud-free (local-ai) builds; the same name shows in the window title bar and the About dialog.

Verify your download

Every release ships with SHA-256 checksums, Sigstore (cosign) signatures, and SLSA build provenance. The install.sh and install.ps1 scripts above already verify SHA-256 automatically and refuse to install on mismatch — but if you downloaded manually you should verify yourself.

# Linux / macOS — checksum
curl -sL -O https://github.com/singhpratech/notepatra/releases/latest/download/SHA256SUMS
sha256sum -c SHA256SUMS --ignore-missing

# Anywhere — cosign verify (Sigstore)
# Replace `linux-x64` with `linux-arm64` if you downloaded the ARM64 build.
cosign verify-blob \
  --certificate-identity-regexp '^https://github.com/singhpratech/notepatra/' \
  --certificate-oidc-issuer 'https://token.actions.githubusercontent.com' \
  --certificate notepatra-linux-x64.tar.gz.pem \
  --signature  notepatra-linux-x64.tar.gz.sig \
  notepatra-linux-x64.tar.gz

# Anywhere — SLSA build provenance
# Replace `linux-x64` with `linux-arm64` if needed.
gh attestation verify notepatra-linux-x64.tar.gz --owner singhpratech

Full instructions, threat model, and disclosure policy in SECURITY.md.

Stay up to date — safe in-app updater

Notepatra checks github.com/singhpratech/notepatra/releases/latest on launch (silent on no-match) and pops a "A new version is available" dialog when something newer exists. Click Download and the updater will:

1. Pick the right artifact for your OS + architecture — Linux x64 / ARM64 tar.gz, macOS DMG, Windows MSI (with NSIS .exe and portable .zip as fallbacks).
2. Stream-download it to ~/Downloads/*.part with a cancellable progress dialog.
3. Fetch the release's SHA256SUMS and verify the download's hash. If the hash does not match, the .part file is deleted and you are shown an error — nothing on your system is modified.
4. Atomic-rename .part → final name once verified.
5. Hand off to the OS installer — msiexec /i on Windows, open <dmg> on macOS (Finder drag to Applications), xdg-open on the Downloads folder on Linux so you replace the binary yourself.

Safety contract — the updater will never leave you with a broken install:

The Notepatra process never rewrites or replaces the running binary. Only the OS installer you explicitly clicked through may do that, and those installers all have their own transactional rollback (MSI MajorUpgrade, DMG copy-on-drag, user-driven file-manager swap on Linux).

Check manually: Help → Check for Updates or ? menu. The check is also visible on first launch (silent if up to date).

Windows: refresh "Open with" entry after upgrading from v0.1.23 → v0.1.24

If you upgraded from v0.1.23 or earlier and your right-click → Open with menu still shows Notepatra â€" native code editor (mojibaked text) and/or a red ❌ overlay on the icon, that's Windows shell-cache lag, not a Notepatra bug. Windows' MuiCache permanently caches the FileDescription string the first time it reads an executable's VERSIONINFO, and never re-reads it on upgrade. The new v0.1.24 binary embeds clean ASCII; Windows is just showing the cached old string.

One-time fix — open PowerShell (no admin needed, all changes are HKCU-scoped) and paste this whole block. Tested and confirmed working on Windows 11:

# 1. Wipe Notepatra's stale entries from MuiCache (the cache that has the â€" text)
$mui = "HKCU:\Software\Classes\Local Settings\Software\Microsoft\Windows\Shell\MuiCache"
Get-Item $mui | Select-Object -ExpandProperty Property | Where-Object { $_ -match "notepatra" } | ForEach-Object {
    Remove-ItemProperty -Path $mui -Name $_ -Force
    Write-Host "Cleared MuiCache: $_" -ForegroundColor Green
}

# 2. Wipe stale "Open with" associations pointing to old notepatra.exe paths
Remove-Item "HKCU:\Software\Classes\Applications\notepatra.exe" -Recurse -Force -ErrorAction SilentlyContinue
$exts = @(".txt",".log",".md",".json",".py",".cpp",".js",".html",".css",".xml",".sql",".sh",".yml",".yaml",".ini",".conf",".csv",".rs",".go",".java",".rb",".php",".c",".h",".hpp",".tsx",".ts",".jsx")
foreach ($ext in $exts) {
    Remove-Item "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\$ext\OpenWithList" -Recurse -Force -ErrorAction SilentlyContinue
    Remove-Item "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts\$ext\OpenWithProgids" -Recurse -Force -ErrorAction SilentlyContinue
}
Write-Host "Cleared OpenWithList for $($exts.Count) extensions" -ForegroundColor Green

# 3. Force shell to rebuild association cache
ie4uinit.exe -show
ie4uinit.exe -ClearIconCache
Write-Host "Rebuilt shell cache" -ForegroundColor Green

# 4. Restart Explorer (drops in-memory cache)
Stop-Process -Name explorer -Force
Start-Process explorer
Write-Host "Restarted Explorer — right-click any file now to verify" -ForegroundColor Cyan

What it does — line by line:

Verify it worked: right-click any .txt or .json file → Open with → the Notepatra entry should now read Notepatra native code editor for the AI era with a clean icon. If you still see the old text after this, log out and back in (forces every kernel-side cache layer to flush).

New v0.1.24 installs on a clean machine never see this — it only affects upgrades from v0.1.23 or earlier where the mojibaked string was first cached.

Build from source

sudo apt install cmake qtbase5-dev libqscintilla2-qt5-dev
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
git clone https://github.com/singhpratech/notepatra.git
cd notepatra
cd rust-core && cargo build --release && cd ..
mkdir build && cd build && cmake .. && make -j$(nproc)
./notepatra

brew install qt@5 cmake
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
git clone https://github.com/singhpratech/notepatra.git
cd notepatra
# Build QScintilla from source (brew's version links Qt6)
./build.sh

git clone --depth 1 https://github.com/farleyrunkel/QScintilla.git $env:TEMP\qsci-src
cmake -S $env:TEMP\qsci-src -B $env:TEMP\qsci-src\build -G "Visual Studio 17 2022" -A x64 `
  -DCMAKE_BUILD_TYPE=Release `
  "-DCMAKE_PREFIX_PATH=C:\Qt\5.15.2\msvc2019_64" `
  "-DCMAKE_INSTALL_PREFIX=$env:TEMP\qsci-install"
cmake --build $env:TEMP\qsci-src\build --config Release
cmake --install $env:TEMP\qsci-src\build --config Release

git clone https://github.com/singhpratech/notepatra.git
cd notepatra
cd rust-core; cargo build --release; cd ..
mkdir build; cd build
cmake .. -G "Visual Studio 17 2022" -A x64 `
  "-DCMAKE_PREFIX_PATH=C:\Qt\5.15.2\msvc2019_64" `
  "-DQSCINTILLA_INCLUDE=$env:TEMP\qsci-install\include" `
  "-DQSCINTILLA_LIB=$env:TEMP\qsci-install\lib\qscintilla2_qt5.lib"
cmake --build . --config Release

mkdir notepatra-win
copy build\Release\notepatra.exe notepatra-win\
windeployqt notepatra-win\notepatra.exe
copy $env:TEMP\qsci-install\bin\qscintilla2_qt5.dll notepatra-win\
.\notepatra-win\notepatra.exe

Plugin System

Drop a shared library in ~/.config/notepatra/plugins/ and restart.

• Linux: .so files
• macOS: .dylib files
• Windows: .dll files

Write your own plugin in 30 seconds:

// myplugin.cpp
extern "C" {
    const char* notepatra_plugin_name()    { return "My Plugin"; }
    const char* notepatra_plugin_version() { return "1.0"; }
    const char* notepatra_plugin_author()  { return "Your Name"; }

    char* notepatra_plugin_run(const char* text, int len) {
        // Your magic here — transform text, return malloc'd result
        // Return NULL to keep text unchanged
    }
}

# Linux
g++ -shared -fPIC -o myplugin.so myplugin.cpp

# macOS
clang++ -shared -o myplugin.dylib myplugin.cpp

# Windows
cl /LD myplugin.cpp /Fe:myplugin.dll

Why not just use...?

Notepatra download sizes are Linux x64 tar.gz / macOS DMG / Windows MSI from v0.1.120. Linux is just the binary (Qt is system-installed). macOS and Windows include bundled Qt. The bare notepatra executable inside is ~13 MB on every platform (Linux 13.4 MB, similar on macOS / Windows). Compressed download is much smaller because tar.gz / DMG / MSI all compress the binary plus shared libraries.

Tests

Focused automated regression tests are wired through CMake + CTest and run in CI — 79 test suites on the Full build (76 on Lite, which omits the two DuckDB suites and the WebEngine-gated Noter-export suite); all green, each with many assertions. A representative sample:

• test_lexers — verifies every shipped QScintilla lexer produces real styling
• test_palette — verifies the canonical 9-hue palette colors and bold/italic styles
• test_fmtpanel_diff — verifies formatter panels keep diff state and emit signals
• test_compare_widget — verifies the inbuilt Compare panel diff/edit/close paths
• test_sqlfmt — 33 assertions across 11 SQL dialects through the AST pretty-printer
• test_updater — verifies pickAssetForPlatform, SHA256 parsing, and asset scoring (18 assertions)
• test_projectsearch — verifies the Rust-backed project search streaming path
• test_projectsearch_ui — verifies the Project Search UI bindings
• test_ollama — verifies live Ollama model detection (skips cleanly when offline)
• test_aifix — exercises the AI-fix cleanup path against a real Ollama daemon (skips cleanly when offline)
• test_llamacpp — exercises the llama.cpp backend path
• test_ai_context — verifies the AI workspace-context summarizer

Run them locally with:

./build.sh --tests

The Ollama / llama.cpp / AI-fix tests skip cleanly when no inference backend is running, so local and CI runs stay deterministic.

Releases

Notepatra follows Keep a Changelog and Semantic Versioning. Every release is tagged, signed, and published to GitHub Releases with binaries for Linux x64, Linux ARM64, macOS Apple Silicon, and Windows x64.

_{v0.1.4 and v0.1.6 were tagged but never published a GitHub Release — both had CI failures (NSIS macro bug + Windows MSVC C2666). Their content shipped in v0.1.5 and v0.1.7 respectively.}

See the full CHANGELOG for every change in every release, or browse the version history on notepatra.org.

Acknowledgments

Notepatra is an original product. This section names the open-source libraries and runtimes it depends on — the people maintaining them deserve credit.

• Qt — the cross-platform C++ GUI framework.
• Scintilla / QScintilla (Neil Hodgson, Riverbank Computing) — the text-editing control.
• Rust + Cargo — the language and toolchain for the Rust core (search, diff, formatters, hashing, encoding).
• aho-corasick (BurntSushi) — the literal-search engine behind Project Search.
• regex, sqlformat, sqlparser — regex and SQL dialect handling.
• Ollama, llama.cpp, OpenRouter, OpenAI, Azure OpenAI — AI inference backends Notepatra speaks to over standard HTTP APIs.
• Sigstore / Cosign / SLSA — keyless signing and build provenance for every release.
• Claude (Anthropic) — co-authored the implementation inside Claude Code.

Thanks also to the ~200 transitive crates in rust-core/Cargo.lock and the broader Qt / QScintilla ecosystem maintainers.

Envisioned by Prateek Singh. Built with Claude.

"I didn't build Notepatra because the world needed another text editor.
I built it because every developer — on Linux, Windows, or Mac — deserves one that's fast, free, and smart."

© 2026 Prateek Singh. All rights reserved.
Source code licensed under GNU General Public License v3.0.

License, warranty, and liability

Notepatra is licensed under the GNU General Public License v3.0. The full legal text lives in the LICENSE file at the root of this repo. The short version, in plain English:

You are free to:

• Run Notepatra for any purpose, commercial or personal, on any number of machines.
• Read, study, and modify the source code.
• Redistribute the source or your modified versions, provided you also distribute them under GPL-3.0 and provide the source.

You must:

• Keep the copyright notice intact when redistributing.
• License any derivative work under GPL-3.0 (the "copyleft" requirement).
• Make the source code available to anyone you distribute a binary to.

You may not:

• Distribute Notepatra (or anything based on it) under a proprietary license.
• Strip out or sue over the no-warranty / no-liability clauses below.

Disclaimer of warranty (GPL §15, plain English)

Notepatra is provided "AS IS", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. The entire risk as to the quality and performance of the program is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair, or correction.

In other words: I built this in good faith, CI runs focused smoke and regression tests on pushes and pull requests, and every release is checksummed and signed — but I am one person on the internet shipping a free editor. Verify your downloads, back up your work, and don't blame me if something breaks.

Limitation of liability (GPL §16, plain English)

In no event will Prateek Singh, contributors, or anyone else who modifies or conveys Notepatra be liable to you for any damages — general, special, incidental, or consequential — arising from the use or inability to use the program, including but not limited to loss of data, data being rendered inaccurate, losses sustained by you or third parties, or a failure of the program to operate with any other program — even if I have been advised of the possibility of such damages.

In other words: if Notepatra eats your file, crashes during a deadline, or fails to highlight your YAML — that's on you. The whole point of the GPL is that you can read the source, fix it, and ship the fix back to everyone. There is no SLA, no support contract, no money changing hands.

What this means in practice

Third-party components and their licenses

Notepatra links against several open-source libraries. None of them ask for money. Their licenses live in the source trees they ship from:

The combination is GPL-3.0 because QScintilla is GPL-3.0 and the GPL is contagious. If you don't like that, the alternative would be to pay Riverbank Computing for a commercial QScintilla license — Notepatra doesn't.