|
| 1 | +# Atom++ — Build Plan |
| 2 | + |
| 3 | +**An AI-native, hackable, Notepad++-powered code editor for macOS, forked from Code-OSS.** |
| 4 | + |
| 5 | +> Decisions locked: foundation = fork VS Code / Code-OSS · your role = direct, AI writes most code · v1 must-haves = Atom-style hackability, native AI, Notepad++ power-editing. (Polished Mac UX rides along but is not a v1 gate.) |
| 6 | +
|
| 7 | +--- |
| 8 | + |
| 9 | +## 1. The strategy in one paragraph |
| 10 | + |
| 11 | +We don't rebuild an editor — we stand on the most battle-tested editor core in existence (the same Monaco-based engine that powers VS Code, Cursor, Windsurf, and Void) and bend it into *your* editor. That gives us, on day one: a fast text engine that handles huge files, full Language Server Protocol support, debugging, Git, the extension model, multi-cursor, and column editing. Our job is then four things stacked on top: (1) **rebrand and de-Microsoft** the build so it's legally a clean product called Atom++, (2) **add the Notepad++ power-editing** that VS Code lacks, (3) **build a native AI layer** that is first-class rather than a bolted-on plugin, and (4) **restore the Atom "hackable" soul** — everything themeable, scriptable, and yours. Void (a YC-backed open-source Cursor alternative, also a VS Code fork) proves this exact path works and, crucially, is open source we can read. |
| 12 | + |
| 13 | +--- |
| 14 | + |
| 15 | +## 2. Read this first — the legal constraints that bite every forker |
| 16 | + |
| 17 | +These are not optional. Getting them wrong means a takedown or a broken editor. |
| 18 | + |
| 19 | +**Code-OSS itself is MIT-licensed** — free to fork, modify, ship, even commercially. Good. |
| 20 | + |
| 21 | +**But "VS Code" the product is not Code-OSS.** Microsoft takes the MIT `vscode` repo and lays down a proprietary `product.json` plus closed-source bits (telemetry, branding, marketplace gallery). When you build the raw repo you get an unbranded editor. To make Atom++ you replace `product.json` with your own (name, icons, URLs, gallery endpoint). VSCodium is the reference example of doing exactly this cleanly. |
| 22 | + |
| 23 | +**The Microsoft Extension Marketplace is off-limits.** Its terms of service legally restrict use to Microsoft products only. Atom++ must point its gallery at **Open VSX** (the Eclipse-run open marketplace VSCodium, Gitpod, and others use). Practical consequence: a handful of popular extensions are Microsoft-proprietary and *cannot* be redistributed or used outside official VS Code — notably the C/C++ extension, Pylance, the Remote-SSH/Containers/WSL pack, the official Python debugger, and the Live Share service. We either find open equivalents (clangd, the open Python LSP, Open Remote SSH) or build our own. **This is the single most important thing to internalize before writing code.** |
| 24 | + |
| 25 | +**Trademark — "Atom".** "Atom" was GitHub's trademark for the sunset editor. Reusing the exact name and logo carries IP risk. We should treat "Atom++" as a working codename and plan a final name + original logo before any public release. (We can keep the spirit and feel without the protected mark.) This is a release-blocker, not a build-blocker. |
| 26 | + |
| 27 | +--- |
| 28 | + |
| 29 | +## 3. Architecture — what we keep, change, and add |
| 30 | + |
| 31 | +**Keep wholesale (the reason we forked):** the Monaco text engine, LSP/DAP infrastructure, the extension host and API, multi-cursor and box-selection, Git integration, search, settings/keybindings/theming systems, the task and terminal infrastructure. |
| 32 | + |
| 33 | +**Change / strip:** swap `product.json` for Atom++ branding; remove Microsoft telemetry; repoint the gallery to Open VSX; restyle the shell (title bar, activity bar, color tokens) toward the Atom aesthetic; set sensible Atom++ defaults. |
| 34 | + |
| 35 | +**Add (our four pillars):** |
| 36 | +- a **native AI subsystem** living in the core, not the extension sandbox, so it can stream completions, edit across files, and run agentic tasks with full editor access; |
| 37 | +- a **Notepad++ power-editing pack** for the gaps (macros, column-mode quality-of-life, encoding/EOL controls, big-file mode); |
| 38 | +- a **hackability layer** (user init script, live config, package authoring, theme studio); |
| 39 | +- **Mac-native polish** (proper traffic-light integration, native menus, fast cold start). |
| 40 | + |
| 41 | +Architectural rule we adopt from Void: **no proprietary middle-man backend.** AI requests go directly from the user's machine to whatever model provider they choose (their own API key, or a local model via Ollama). This is a privacy and trust feature, and it keeps us out of the business of running inference servers. |
| 42 | + |
| 43 | +--- |
| 44 | + |
| 45 | +## 4. The AI layer — design |
| 46 | + |
| 47 | +This is what makes it *AI-native* instead of "VS Code with a chat plugin." Four capabilities, built into the core: |
| 48 | + |
| 49 | +1. **Inline completions / tab-autocomplete** — ghost-text suggestions as you type, accept with Tab. Driven by a fast model. |
| 50 | +2. **Chat with your codebase** — a side panel that has read access to the open project, can be given files/symbols as context, and answers grounded in your actual code. |
| 51 | +3. **AI edits & refactors** — select code (or a whole file) and instruct a change; Atom++ applies it as a reviewable diff you accept or reject. Multi-file edits supported. |
| 52 | +4. **Agentic tasks** — give it a goal ("add a setting that does X"), it plans, edits across files, runs commands, and reports back — gated behind your approval. |
| 53 | + |
| 54 | +**Model strategy:** bring-your-own-key by default (Anthropic/Claude, OpenAI, Google, plus OpenAI-compatible and Ollama for local). Native support for Claude is a first-class target since AI-native is the whole point. Users see and can edit the actual prompts sent — transparency as a feature (another Void idea worth stealing). |
| 55 | + |
| 56 | +**What we study, not reinvent:** Void is open source and is the same fork lineage — we read its AI integration for the wiring patterns. Continue.dev (open source) is a second reference for context-gathering and provider abstraction. We don't copy code blindly (license check first), we learn the architecture. |
| 57 | + |
| 58 | +--- |
| 59 | + |
| 60 | +## 5. Notepad++ parity — the feature matrix |
| 61 | + |
| 62 | +What you love about Notepad++, mapped to effort. Much already exists in the core; the real work is a focused list. |
| 63 | + |
| 64 | +**Already native in the fork (just expose/tune defaults):** multi-cursor; column/box selection (Shift+Alt+drag); powerful regex find/replace (Rust regex — ~95% compatible with NPP's Boost; differences are fixed-width lookbehind and some slash-escaping); find-in-files; minimap; bracket matching; split views; session restore. |
| 65 | + |
| 66 | +**Needs building or a first-party pack:** |
| 67 | +- **Macro record & replay** — VS Code dropped keystroke macros on purpose; NPP users genuinely miss them. We build a first-party record/replay so it's reliable, not a flaky third-party extension. |
| 68 | +- **Big-file mode** — a read-optimized path for 300 MB–1 GB+ files (disable tokenization/extensions, virtualized rendering). NPP's signature strength; we make Atom++ not choke. |
| 69 | +- **Encoding & line-ending controls** — one-click convert encoding (UTF-8/16, codepages) and EOL (CRLF/LF/CR), always visible in the status bar. |
| 70 | +- **Column-mode quality of life** — column insert, fill, incrementing number insertion (NPP's column editor extras), beyond raw box-select. |
| 71 | +- **NPP-flavored extras** — block comment toggles, "mark all" highlighting, sorting/dedup lines, convert case, on-the-fly language detection — bundled as one "Notepad++ Pack" that ships on by default. |
| 72 | + |
| 73 | +--- |
| 74 | + |
| 75 | +## 6. Atom hackability — the soul |
| 76 | + |
| 77 | +Atom's draw was that *everything* was editable and it felt like yours. We restore that explicitly: |
| 78 | + |
| 79 | +- **Live config** — a human-readable settings file plus a real Settings UI; changes apply without restart where possible. |
| 80 | +- **User init script** — an Atom-style "run my code at startup" hook so power users can script the editor itself. |
| 81 | +- **Packages** — first-class package authoring with a generator, hot-reload during development, and one-click publish to Open VSX. |
| 82 | +- **Theme studio** — themes as data, a live preview, easy color-token overrides, and import of community themes. Atom's beautiful default themes (One Dark / One Light) are open source we can adapt for the signature look. |
| 83 | +- **Keymaps** — fully remappable, with a built-in "Notepad++ keymap" and "Atom keymap" preset so muscle memory transfers instantly. We also ship migration that imports existing VS Code keybindings/settings/themes (Void does this; it dramatically lowers switching cost — including *your own* switching cost). |
| 84 | + |
| 85 | +--- |
| 86 | + |
| 87 | +## 7. Roadmap — phased, milestone-gated |
| 88 | + |
| 89 | +Each milestone is a thing you can actually run and judge. Because AI writes most of the code and you direct, every milestone ends in a review gate where you try the build and we course-correct. |
| 90 | + |
| 91 | +**M0 — It builds and it's ours (foundation).** |
| 92 | +Clone/fork Code-OSS, get a reproducible macOS build, replace `product.json` with Atom++ branding, strip MS telemetry, repoint gallery to Open VSX, ship custom icon + title bar. *Exit test: a signed Atom++.app launches on your Mac, installs an extension from Open VSX, and has zero Microsoft branding.* |
| 93 | + |
| 94 | +**M1 — Notepad++ power-editing.** |
| 95 | +Build the Notepad++ Pack: macro record/replay, big-file mode, encoding/EOL controls, column-mode extras, line ops. Add the NPP keymap preset. *Exit test: open a 500 MB log, record a macro to reformat lines, replay it, switch encoding — all smooth.* |
| 96 | + |
| 97 | +**M2 — Native AI core.** |
| 98 | +Provider abstraction + BYO-key (Claude first), inline completions, codebase chat, accept/reject AI diffs. Direct-to-provider, no backend. *Exit test: tab-complete a function, ask the chat about your repo, refactor a file via AI diff — using your own API key.* |
| 99 | + |
| 100 | +**M3 — Hackability + Atom feel.** |
| 101 | +Settings UI, user init script, package generator + hot reload, theme studio, One Dark-derived default theme, VS Code/Atom settings import. *Exit test: import your current VS Code setup, write a tiny package, restyle a color live.* |
| 102 | + |
| 103 | +**M4 — Agentic AI + Mac polish + release prep.** |
| 104 | +Agentic multi-file tasks with approval gates; native menus, traffic-light polish, cold-start optimization; auto-update channel; final name + original logo + trademark check; first public/personal release. *Exit test: give it a multi-file goal and approve its plan; the app feels native and updates itself.* |
| 105 | + |
| 106 | +A realistic ordering note: M0→M2 is where you stop wanting to switch editors. M3–M4 is what makes it *award-worthy* and shareable. |
| 107 | + |
| 108 | +--- |
| 109 | + |
| 110 | +## 8. How we actually work (AI builds, you direct) |
| 111 | + |
| 112 | +Because you're directing rather than typing, the process is spec-and-review, not line-by-line: |
| 113 | + |
| 114 | +For each milestone we write a short spec (what it does, how you'll test it), the AI implements it on a branch, you run the build and try the exit test, and we iterate from your feedback. We keep a clean rebase relationship with upstream VS Code so we can pull their improvements — **this ongoing rebase is the single biggest long-term maintenance cost of any fork, and we design our changes to minimize merge conflicts** (isolate Atom++ code into clearly separated modules rather than scattering edits through core files). Each milestone gets its own verification: build succeeds, exit test passes, and for the AI/editing features, automated tests where practical. |
| 115 | + |
| 116 | +--- |
| 117 | + |
| 118 | +## 9. Risks, honestly |
| 119 | + |
| 120 | +The fork **rebase treadmill** is real — VS Code moves fast; we minimize pain by isolating our code. **Proprietary-extension gaps** (C/C++, Pylance, Remote) will frustrate some workflows; we line up open replacements up front. **Building the editor from source** is heavy (large toolchain, long builds) — M0 exists precisely to de-risk this before we invest in features. **Trademark** on "Atom" must be resolved before public release. And **scope** — the temptation is to do everything; the milestone gates exist to keep each step shippable. |
| 121 | + |
| 122 | +--- |
| 123 | + |
| 124 | +## 10. Immediate next steps |
| 125 | + |
| 126 | +1. Confirm we can locate your synced Atom and Notepad++ sources from the build environment (they'll be our reference for feel and feature behavior). |
| 127 | +2. Stand up M0: fork Code-OSS, first clean build, Atom++ branding via `product.json`, Open VSX gallery. |
| 128 | +3. In parallel, I read Void's source to lock the AI-layer architecture before we write ours. |
| 129 | +4. Pick a working repo + license (MIT, matching Code-OSS) and a codename so we're not blocked on the final name. |
| 130 | + |
| 131 | +When you're ready, say the word and I'll start M0. |
0 commit comments