ned

A fast, safe code editor and Nim IDE for Termux and Linux. It runs in any terminal but looks and behaves like a desktop editor: menus, docks, tabs, tiled panes, mouse and touch support, dialogs, toasts and tooltips. It is written in Nim, uses only the standard library, and builds to a single program, with nothing else to install.

Made by Sultan Al Isaiee (@foxoman) — www.foxoman.net · sultan@foxoman.net

---

Contents

• What's new in 6.45 · 6.44 · 6.43.1 · 6.43 · 6.42.1 · 6.42 · 6.41.1 · 6.41 · 6.40 · 6.39 · 6.38 · 6.37 · 6.36 · 6.35 · 6.34 · 6.33 · 6.32 · older releases
• Features
• Installing
• First steps
• Documentation — the guides, the FAQ, the plugin tutorial
• Contributing

---

What's new in 6.45

Less memory. With a file of 7 MB open, ned and its engine worker took 155 MB; now about 90 in Termux and 66 on Linux. Sending a file to the engine worker or to a language server no longer makes several copies of it at once, and on Linux and macOS ned gives memory back to the system once it has finished with it — when a big file is closed, too. Before, what a big file or a long session had taken stayed taken until ned quit: after half an hour on ned's own source it held 79 MB and used 27.

No stutter when a file of a big project opens. Reading what the file's imports bring, for completion and for the colours, kept the keys waiting 25 to 40 ms a dozen times or more, longer the further it got. It is done in short pieces now.

Language servers get only what changed. After each pause in typing ned sent the server the whole file again. A server that takes changes — clangd, and the HTML, CSS and JSON servers, among others — now gets just the edits, and the whole file goes with a save only to a server that asks for it.

Big messages to other programs. A big file sent to a language server, an MCP server, a plugin or the engine worker, and a flood of output from gdb, a debugger or a plugin, are no longer copied over and over on the way.

If ned crashes, the terminal is yours again. A crash left the terminal in ned's modes: in Termux no scrolling, and the mouse typing codes into the shell. Now the terminal is put back as ned found it, the shell says ned stopped, and the next start says so too and offers your unsaved changes. Please report it: the details are in errors.log.

Deeply nested code. nedfmt no longer crashes on brackets nested thousands deep, the JSON check says "nested too deep" once instead of once for every bracket around it, and JSON or CSS nested more than 500 deep is left as it is rather than formatted into gigabytes.

Features

Desktop-style UI in the terminal — title bar with menus (F10), command palette (Ctrl+E, over 500 commands, most-used first), Telescope (Alt+Shift+F: every finder with a preview), a cursor that glides, left dock (files, search & replace, git, Nim, tests), right dock (AI assistant, outline, timeline), bottom panel (problems, output, terminal), tabs, breadcrumbs, minimap, sticky scroll, indent guides, rainbow brackets, tooltips, toasts, modal dialogs, context menus (right click), drop shadows, hover effects, 150 themes (VS Code dark/light, One Dark, Tokyo Night, Catppuccin, Gruvbox, Dracula, Nord, Solarized, GitHub, Rosé Pine, Kanagawa, Ayu, Monokai, Modus, Shades of Purple, Slate, Monochrome, Everforest, Night Owl, from vim Jellybeans, Iceberg, Sonokai and PaperColor, every ray.so theme, Foxoman's ClassicBlue and Nebula themes, and ned's own: Nim Crown, Frankincense, Desert Dusk, Lagoon, Mint Night, Sea Glass, Paper Ink, Rose Quartz, Amber CRT, Green Phosphor, and six easy on the eyes for OLED and LCD screens …) — or auto, following the terminal's background or the time of day, your own colours (a theme editor that checks contrast), VS Code or base16 themes imported, and Termux's own colours set to match — three icon sets (unicode, Nerd Font, ASCII), phone layout below 70 columns, an accessibility mode (ASCII, letters beside colours, high contrast), multi-root workspaces (git for each folder), remote folders over SSH (git, Run and the assistant's commands on the server; its changes come back by themselves), settings sync. → Themes and appearance · Key bindings · Settings

Editing — multi-cursor (Ctrl+D, Alt+A, Alt+J/K), selection that grows by the code's structure (a name, the call, the statement, the block, the routine), surround (brackets, quotes, a tag, a block — and vim-surround), an undo tree (Undo history… with the text at each state), next-edit suggestions (a rename's next place: Tab, Tab), move/duplicate lines, toggle comment, folding, snippets for Nim, Python, C, C++, JS/TS, Rust, Go, HTML and shell (plus your own), completion, auto-pairs, smart indentation, soft wrap, tiled panes, multibuffers, bookmarks, regex find/replace, sort/join/ case transforms, line-ending and indentation conversion, format on save (built in for Nim, JSON, Markdown, CSS, HTML, SQL, YAML and TOML; a whole project at once; or only the lines you changed, and a preview first), jump labels (Alt+Shift+J), a preview beside the file and symbol pickers, files in their encoding (UTF-16, Windows-1252 … written back as read), unsaved edits kept when you quit (hot exit), rulers at the columns you choose or where the formatter wraps ("editor.rulers": ["lineLength"]; long lines tinted), colour swatches, .editorconfig support (its max_line_length is the formatter's too), spell check, CSV and TSV files as tables (columns lined up, sort by a column, a column's sum and mean), large-file mode and a viewer for files of any size, a 3-pane merge editor, keyboard macros, vim, Emacs and Helix key bindings, operator ligatures (editor.fontLigatures: drawn by ned in any terminal — ─→ ═⇒ ≠ ≤ ≥ — or kept whole for a ligature font). → Editing · Key bindings · Search and replace · Formatting · Vim mode and zen mode

Plugins — written in NimScript (or full Nim, compiled): commands, keys, events, the text, problems with fixes, signs and highlights, languages with their completions, hover, code actions, outline and snippets, formatters, language servers (also written in NimScript, for any editor: ned --lsp-bridge), tools for the assistant, views in their dock, progress and output, vim mappings, operators and text objects, timers, how indentation looks — the NimScript ones in one process, a dock to manage them with their versions and updates, a list to install from; each asks before it runs programs, changes files or uses the clipboard. Eighty-five of ned's own come with it, off until you turn one on. → Plugins · Tutorial · API reference

Languages — syntax highlighting for Nim, C, C++, JS/TS, Rust, Go, Python, Kotlin, C#, PHP, SQL, Java, Lua, Ruby, shell, Markdown, JSON, YAML, TOML, HTML, CSS, Makefiles, diffs, Nim templates (.nimf), Jinja-style templates (Nimja's .nimja, .jinja, .j2) and more — and your own (languages); code inside strings and Markdown code blocks in its own colours (C in {.emit}, SQL, HTML, regular expressions); any language server (configure in lsp) with type definition, implementation and type hierarchy, document links, pull diagnostics and formatting as you type — and a second one beside it (a linter such as ruff), their problems and fixes merged; formatters per language; debugging through the Debug Adapter Protocol (Python, C, C++, Rust, Go, JS/TS …) with logpoints and stops when a value changes; tests for pytest, go test, cargo test, PHPUnit, dotnet test and Gradle/Maven; coverage for Nim, Python, Go, Rust, JS/TS and any lcov file; Send to REPL, and # %% cells run as a notebook (the output under each cell); Emmet for HTML and CSS; ned's own CSS, HTML, SQL, JavaScript and JSON — completion, hover and problems in their files and in Nim strings (and a page's <script>s), with your project's class names, tables and columns, the ? of a query counted against the values it is given, a script's classes and the browser's globals, JavaScript's definitions and references across its modules, and the keys and values of package.json, tsconfig.json, atlas's and nimble's files and ned's settings (web.engine). → Running, testing and debugging · Settings · Formatting

Nim IDE — a built-in Nim engine (completion with documentation beside the list, hover, go to definition, signature help, references with counts beside each declaration (operators too), rename, type hierarchy, go to implementation, change signature, inline, move to another module, fill in a constructor's fields, outline, project symbols, the types of lets, vars and loop variables shown beside them, included files and what templates and macros declare understood) that needs no language server — and serves other editors as one (nedls) — a formatter in nph's style (also on its own: nedfmt, with a pre-commit hook), errors while you type from the compiler itself and the engine's own checks at once (unused imports, field typos, argument counts, values not used, a var that can be a let, unused parameters, deprecated names and library names newer than the package's Nim) — also from the command line and in CI (ned --lint, GitHub annotations, a pre-commit hook, Nim: add a CI workflow) — nim check on save; a type's memory layout on hover (and the field order that saves bytes), what a routine can raise, the package versions the build uses (nimble.lock, nimble.paths, atlas), one Nim per project for every tool (nim.toolchain); nimlangserver if you prefer it; macro/template expansion (Alt+M), ARC/ORC view, generated C, test explorer for std/unittest with ▶ run buttons in the gutter, project symbols, nimble tasks and the dependency tree, Atlas, Nimony, gdb debugging in the terminal (logpoints, stops when a value changes), a profiler that shows each proc's and line's share of the time beside it (and a flame graph), memory checks (AddressSanitizer, UBSan, valgrind), tests written from running a proc, quick fixes from the compiler's messages, AI fixes checked by nim check, REPL (Shift+Enter sends code to inim), docs lookup, run configurations, what a proc can raise, benchmarks, nimble releases and newer dependency versions, testament, runnableExamples with a ▶, type mismatches explained argument by argument. Nim 3 (Nimony): a project built with nimony gets names matched as written, Nimony's own library, errors from nimony check and its --def/--usages, Nim 3's pragmas; Nim 2 files show what porting them needs, fixed one by one, all at once, or by the assistant checked with nimony. → Nim IDE · Formatting · Compiler Explorer

C and C++ — ned's own C engine, no clangd needed: completion (struct members after . and -> too; C++ classes with their bases, methods, namespaces after ::, templates, auto), hover with the comment that documents a declaration, go to definition through #includes (a C++ method's body outside its class), references, rename, signature help, the outline, the compiler's errors while you type and a missing #include added — in emits too (C++ when nim.backend is cpp); clangd when you prefer it. → C and C++ · Compiler Explorer

Compiler Explorer — the machine code beside your Nim, C or C++ while you type, as on godbolt.org: each line and its instructions in one colour, the cursor or the mouse on either side lighting up the other, a toolbar for the C compiler, the processor (ARM64 on a PC through zig), the options, Intel or AT&T, the compiler's assembly or a disassembled object, godbolt's filters, the program run, two builds compared, and what each instruction does on hover → Compiler Explorer

Hex editor — binary files as offset · hex · text, typed over or inserted, undo, find bytes or text, go to an offset, a data inspector, copy as hex, a Nim array or a C array; programs and libraries (ELF, Mach-O, PE) with their sections and symbols — Nim's procs by their Nim names, the bytes each module takes, a proc's Nim source; a proc decompiled to C beside it. → Hex editor, programs and the decompiler

Integrated terminal — a real pty with an xterm-compatible emulator: vim, htop, less, git, ssh all work; several terminals (two side by side), scrollback, mouse, selection and copy; with bash, zsh and fish every command is marked — Ctrl+↑/↓ go through them, failed ones show red, a command's output can be copied or it can be run again. ned FILE there opens FILE in this ned, and this ned is git's editor (git commit opens the message in a tab). → The terminal and remote work

Remote control — scripts reach the running ned: ned --remote FILE:LINE, --remote-command, --remote-message, --remote-problems (a build's output → Problems), --remote-get, --remote-list; ned --wait as GIT_EDITOR. → The terminal and remote work

The terminal it runs in, asked — the kitty keyboard protocol (Ctrl+Shift+letters, Ctrl+I apart from Tab), 24-bit colour, curly underlines in the problem's colour, emoji sequences as one character (mode 2027), light and dark following the system (mode 2031), the focus (files looked at again when you come back, background work paused while you are away), the terminal's title, progress on its tab, a transparent background.

Git — source-control dock (stage, unstage, discard, diff, commit, push, pull, log), every change not committed in one editable view (Alt+Shift+G: stage, unstage or revert each), gutter marks that follow your typing, change navigation and revert, inline blame, file timeline, AI-written commit messages, interactive rebase, cherry-pick, branch compare and graph, the history of some lines, bisect (by hand or with a command), worktrees, submodules, GitHub pull requests, issues and CI status (gh), review comments on their lines; signing in to GitHub (the GitHub CLI or an SSH key — no passwords), undo of the last commit, pull or merge, and checks before a commit (formatted, tests passing). → Git

AI — chat and agent (read, search, edit files, run commands — you approve edits and commands; its edits are checked with nim check and the like, and it is told what is wrong), a plan first and then each step with a restore point, tests it writes kept only when they pass, a failing test made to pass (kept only when it does), answers grounded in the declarations your code uses, inline edit of a selection (Alt+Shift+C), undo of the agent's changes, token and cost counter, AI review of staged changes, a local model on the device (Ollama or llama.cpp, set up for you: offline on a phone too), MCP servers for more tools, their prompts (/server:prompt) and resources (@server:uri); Anthropic, OpenAI, OpenRouter, Ollama, Groq, DeepSeek, Gemini, Mistral or any OpenAI-compatible endpoint. → The AI assistant

Installing

ned needs Nim 2.2 or newer and nothing else to build. Everything else is optional and is picked up automatically when it is on your PATH.

The quick way — ned built with nimble, on Termux too (Nim, git and clang come from Termux's packages):

curl -fsSL https://raw.githubusercontent.com/foxoman/ned/main/install.sh | sh

With nimble: nimble install https://github.com/foxoman/ned (once ned is in Nim's package list: nimble install ned) builds ned, nedfmt and nedls into ~/.nimble/bin. With Atlas: ned needs no packages, so there is nothing for Atlas to fetch to build it — clone it and build it as below; in an Atlas project that uses ned's engine as a library (import ned/nim/index), atlas use https://github.com/foxoman/ned adds it.

Updating: ned --update (or Help: update ned… in the palette) finds the newest version (its tag on GitHub) and builds it the way this ned was installed — with nimble, or a checkout pulled and built again — after saying what it will run and asking; ned --update --check only says whether there is one. A release that does carry a Termux package is installed from it, checked against the release's SHA256SUMS and its signature first. ned also looks by itself, once a day a little after it starts: when a newer version is out it says so, and a mark in the status bar opens what is new in it (Help › Check for updates looks now; "update.check": false stops the daily look).

Termux (Android)

pkg install nim git ripgrep curl            # nim to build; the rest is optional but recommended
nim c -d:release --opt:speed -d:strip -o:$PREFIX/bin/ned src/ned.nim
ned --check                                 # what ned found, and how to add the rest
ned

or, from the project folder: nimble termux (ned, with nedfmt and nedls beside it) — or a ready-made package, pkg install ./ned_6.45.0_aarch64.deb (ned, nedls, nedfmt; the example plugins in $PREFIX/share/ned/plugins): nimble termuxdeb makes it on a Linux machine (with zig).

The Nim IDE features need nothing more: the engine is built in, and nim check does the rest. Recommended extras:

nimble install inim                         # Nim REPL (formatting is built in; nph is optional)
pkg install gdb termux-api                  # debugger; clipboard (also install the Termux:API app)

Nothing stays running in the background — nimsuggest is off by default, and the checks while you type are short nim check runs — which suits a phone's memory. A save also runs the tests that cover the file and asks the compiler where ARC/ORC copies, short runs as well; "nim.testOnSave": "off" and "nim.showCopies": false leave them out to spare the battery.

Use a Nerd Font in ~/.termux/font.ttf and set "ui.icons": "nerd" for nicer icons. The extra-keys row of Termux (Esc, Ctrl, Alt, arrows, F-keys) makes every shortcut reachable; every command is also in the menus and the palette, and everything can be tapped.

Linux

nim c -d:release --opt:speed -d:strip -o:ned src/ned.nim && sudo mv ned /usr/local/bin/
# or
nimble install            # builds and installs ~/.nimble/bin/ned (and nedfmt, nedls)
nimble local              # builds into ~/.local/bin (ned, nedfmt, nedls)

A terminal with true colour and mouse reporting (kitty, WezTerm, foot, Alacritty, GNOME Terminal, Konsole, Windows Terminal, iTerm2, tmux with set -g mouse on) gives the best result.

macOS

brew install nim git ripgrep               # Homebrew (brew.sh); choosenim works too
nim c -d:release --opt:speed -d:strip -o:ned src/ned.nim && sudo mv ned /usr/local/bin/
ned --check

The clipboard uses pbcopy / pbpaste. iTerm2, WezTerm, kitty and Ghostty show true colour and pass the mouse; in Terminal.app set Use Option as Meta key (Settings › Profiles › Keyboard) so the Alt shortcuts work. The debugger panel uses gdb, which macOS only lets run once it is code-signed (brew install gdb, then its signing steps); without it, Nim: debug with gdb in the palette falls back to lldb in the terminal.

Windows

Native (experimental, since 6.21). ned builds for Windows itself — the same program, with Win32 and the C runtime behind its terminal calls: the console is its terminal (Windows Terminal, or the console of Windows 10 1809 and later — virtual-terminal input and output, UTF-8), its terminal panel is a pseudo-console (ConPTY) running PowerShell (or terminal.shell), its commands (tasks, builds, nim check) run through Git for Windows' sh when it is installed (else cmd.exe), the clipboard is the Windows clipboard, and paths are written with / (Windows takes them). It is built and checked on every push (windows-x86_64 in .github/workflows/build.yml: the command line, the formatter's tests), but used far less than the Linux, macOS and Termux builds — WSL is the tried way.

Build it, and start .\ned.exe in Windows Terminal (nim on the PATH for the Nim features; tests/build/windows.sh makes a zip of ned.exe, nedfmt.exe and nedls.exe from Linux, with zig):

scoop install nim git                       # or the official Nim zip, and Git for Windows (its sh runs ned's commands)
nim c -d:release --opt:speed -d:strip -o:ned.exe src/ned.nim
.\ned.exe --check
.\ned.exe

What it does not have there: the remote-control socket needs Windows 10 1803 or later (AF_UNIX); the formatter of nedls runs in-process instead of in a child of its own (no fork); nice is a lower priority class.

WSL. The Linux build, inside WSL (Windows Subsystem for Linux), in Windows Terminal:

wsl --install                               # once, in PowerShell as administrator; then restart and open Ubuntu

# inside Ubuntu (apt's Nim is too old — take the official build)
sudo apt install build-essential git ripgrep curl xz-utils
curl -sSfL https://nim-lang.org/download/nim-2.2.4-linux_x64.tar.xz | tar -xJ -C ~
echo 'export PATH=$HOME/nim-2.2.4/bin:$PATH' >> ~/.bashrc && . ~/.bashrc
nim c -d:release --opt:speed -d:strip -o:ned src/ned.nim && sudo mv ned /usr/local/bin/
ned --check

Copying goes to the Windows clipboard (OSC 52 in Windows Terminal, and PowerShell), pasting reads it through PowerShell, and links open in your Windows browser with wslview (sudo apt install wslu). Keep your projects inside the Linux file system (~/code, not /mnt/c/…): it is much faster there.

Ready-made binaries

The project's GitHub Actions workflow (.github/workflows/build.yml) builds ned on every push for Linux (x86_64 and arm64), macOS (Apple silicon and Intel), Termux (aarch64), Windows (native, and through WSL), runs it in a real pseudo-terminal, and attaches the binaries to the release when you push a tag such as v5.6.1 — nedfmt (the formatter) and nedls (the language server) beside each ned.

Optional tools ned uses when present

tool	what for
nimsuggest	ships with Nim; off by default — a second opinion where the built-in engine cannot infer a type ("nim.nimsuggest": true)
nimlangserver	only if you choose it ("nim.ide": "nimlangserver") instead of the built-in engine
nph, nimpretty	only if you choose one ("nim.formatter") instead of the built-in formatter
inim	Nim REPL (palette › Nim: REPL) — falls back to nim secret
clangd	C and C++ language server — for C, ned's own engine answers when it is not installed (c.engine)
cc (gcc or clang)	C errors while you type, the C in {.emit} checked, what the system's headers declare
rg (ripgrep)	fast project search (falls back to grep, then to a built-in search)
git	git dock, gutter marks, blame, timeline
curl	the AI assistant
gdb / lldb	Nim: debug with gdb
termux-clipboard-*, pbcopy, wl-copy, xclip, PowerShell (WSL)	system clipboard (OSC 52 is used too)
gh	Git › Pull request, and Create a GitHub issue from a TODO comment

First steps

ned                      # the folder you are in (reopens the files you had open)
ned src/app.nim:42:7     # a file at line 42, column 7      (also: ned +42 src/app.nim)
ned ~/code/project       # a folder (inside ned: File › Open folder…, or d on the Welcome page)
git log | ned            # what a command printed
ned --check              # what ned found on this system, and how to install what is missing

Starting ned on a file outside the current folder (say ned ~/code/app/src/x.nim from $HOME) opens that file's project (the nearest folder with .git, a .nimble, Cargo.toml …) instead of indexing your home.

• F10 opens the menus, Ctrl+E the command palette, F1 the key bindings.
• Ctrl+P finds a file — type :42 for a line, @name for a symbol, #name for a project symbol, > for commands.
• Click or tap anything: tabs, gutter markers (▶ run, ▾ fold), breadcrumbs, dock items, buttons.

Documentation

Everything ned does is described in the guides under docs/:

FAQ	short answers: installing and updating, keys a terminal does not pass on, which Nim engine, clangd or not, formatters, AI providers and offline use, where ned keeps things, speed on a phone, plugins, reporting a bug
Key bindings	every key, by what it is for
Files, folders and projects	starting ned, the project folder, the file tree, Ctrl+P, tabs, splits, sessions
Editing	cursors and selections, surround, snippets, the undo tree, macros, folding, spell check, encodings, big files
Nim IDE	the built-in engine, nedls in other editors, lint rules, quick fixes and rewrites, one Nim per project, nimsuggest and nimlangserver
C and C++	ned's own C engine, or clangd
Formatting	Nim in nph's style and its settings, C in clang-format's styles, nedfmt, the other languages
Compiler Explorer	the assembly beside the code, live
Running, testing and debugging	run configurations, tasks, tests, coverage, the debugger, the REPL, profiling
Git	the dock, the changes view, blame, history, rebase, bisect, GitHub
The AI assistant	chat, the agent, providers, local models, MCP
Search and replace	in the file and the project
The terminal and remote work	the integrated terminal, scripting a running ned, SSH folders, workspaces
Themes and appearance	the themes, your own colours, icons, accessibility
Vim mode and zen mode
Settings	where they live, projects' settings, sync — and every setting
Plugins	how they run — the tutorial and the API reference
Hex editor and programs	binary files, a program's sections and symbols, the decompiler
Safety	how ned protects your work
Files ned uses	settings, state, caches
Building, tasks and performance	building ned, its tests, run configurations, speed
Troubleshooting	when something does not work
Commands	every command of the palette

Contributing

Bug reports, ideas, themes and code are welcome — CONTRIBUTING.md explains how ned is built, laid out and tested. Security problems: please report them privately (SECURITY.md).

License

Copyright © 2026 Sultan Al Isaiee (@foxoman) — www.foxoman.net · sultan@foxoman.net.

ned is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details: the full text is in LICENSE (SPDX: GPL-3.0-or-later).

Plugins may use any licence: the plugin library they import comes with the ned Plugin Exception, an additional permission to combine a plugin with it and convey the plugin under terms of your choice.