Meet Tuim: A Blazing-Fast TUI IDE Built with Zig and Neovim

If you spend your days writing code, you've almost certainly faced the classic editor dilemma:

1. Modern GUI IDEs (VS Code, Cursor, JetBrains): Feature-complete, great mouse support, intuitive file trees, out-of-the-box LSP. But they run on heavy runtimes, eat RAM like candy, and create a wall between your editor and your actual terminal environment.
2. Neovim & Terminal Multiplexers (tmux, zellij): Blazing fast, pure keyboard muscle memory, deeply customizable, and lightweight. But getting a cohesive workspace with an integrated terminal, file tree, Git manager, and LSP often requires days of tweaking Lua dotfiles—and one broken plugin update can break your entire workflow.

For the past few months, I've been building Tuim (pronounced "twim"): a modern, vertically-integrated terminal workspace written in Zig, with Neovim as its embedded editing engine.

The tagline is simple: Your editor. Your terminal.

Here is the story behind why Tuim exists, how it works under the hood, and what makes it unique.

The Philosophy: Accessible Outside, Beast Inside

The central idea behind Tuim is: refuse to compromise.

You shouldn't have to choose between accessibility and terminal power:

• If a junior developer or a VS Code native opens Tuim, they should feel right at home immediately—clicking files in the explorer, selecting text with the mouse, and using standard Ctrl+S, Ctrl+P, Ctrl+C, and Ctrl+V.
• If a seasoned Vim power user opens Tuim, they get pure modal editing, instant startup times, Treesitter syntax highlighting, and their beloved hjkl motions without bloat.

Three Distinct Editing Modes

Tuim provides three modes you can toggle instantly with a click or via F11:

Under the Hood: Why Zig + Neovim?

A lot of terminal workspace experiments try to do everything inside Neovim via complex Lua plugins, or write an entire text editor from scratch in Rust or Go. Both approaches have serious trade-offs:

• Lua in Neovim shares the single-threaded editor runtime; heavy file tree scans or git diffs can drop frames.
• Writing a text editor from scratch means spending years re-implementing undo-trees, syntax grammars, LSP clients, and text-buffer invariants.

Tuim solves this by splitting responsibilities cleanly:

+-------------------------------------------------------------+
|                         TUIM (Zig)                          |
|  - Native TUI Renderer & Reactor (Damage-based repaints)    |
|  - Custom Native Widgets (Explorer, Git, Mason, Extensions) |
|  - Terminal Panel & Event Loop Management                   |
+-------------------------------------------------------------+
               │                                │
      MessagePack-RPC                   MessagePack-RPC
        (Multigrid UI)                  (Terminal Shell)
               ▼                                ▼
+-----------------------------+   +---------------------------+
|    Embedded Neovim (Core)   |   |  Embedded Neovim (Term)   |
|  - Buffers, Windows, Undo   |   |  - Isolated Shell Panel   |
|  - Treesitter, LSP, Plugins |   |  - Zero plugin overhead   |
+-----------------------------+   +---------------------------+

1. Zig Owns the Frontend and Chrome

Tuim's outer frame, layout engine, event loop reactor, and sidebar widgets are written in Zig 0.16.0.

• Damage-based rendering: Instead of redrawing the entire screen every frame, Tuim's renderer tracks cell changes and emits minimal ANSI escape sequences.
• Background Tasks: Git operations and directory indexing run on background threads (task_runner.zig), meaning file trees never lock up your keystrokes.

2. Neovim Owns the Editing Engine

Tuim launches Neovim as an embedded headless child process using NVIM_APPNAME=tuim and --clean.

• It communicates via Neovim’s binary MessagePack-RPC protocol using Neovim's ext_multigrid UI extension.
• Neovim handles buffer management, Treesitter highlighting, LSP servers, and code folding.
• Zero Dotfile Pollution: Tuim runs in its own sandboxed XDG directory (~/.local/share/tuim and ~/.config/tuim). It never touches or alters your personal ~/.config/nvim.

3. Dual-Engine Terminal Isolation

When you open Tuim's integrated terminal panel (Ctrl+T), it doesn't just spawn a naive subshell. It communicates with a second, dedicated lightweight Neovim instance optimized solely for terminal PTY buffering, keeping editor state and terminal output completely separate.

Standout Features

1. Native Zig Widgets for Neovim's Best Tools

Instead of rendering Neovim's default floating windows for plugin management, Tuim includes native TUI widgets for:

• Lazy.nvim: A custom visual package dashboard showing loaded, lazy, and updating plugins.
• Mason.nvim: A native package browser for LSP servers, DAP debuggers, linters, and formatters.
• Git Panel: An interactive staging panel where you can inspect hunks, stage files with Space, write commits, and inspect git history.
• Extension Shop: Integrated search across thousands of Neovim plugins powered by the community catalog, installable with one click.

2. Out-of-the-Box Batteries Included

When you install Tuim, you don't spend an afternoon configuring plugins:

• 19 Treesitter Parsers Pre-compiled: C, C++, Rust, Zig, Go, Python, TypeScript, JavaScript, Lua, Bash, and more are verified on install.
• Modern LSP & Completion: Pre-wired with blink.cmp, friendly-snippets, and nvim-lspconfig.
• Fuzzy Finder: Interactive file and project-wide search (Alt+G) powered by ripgrep and telescope.nvim.
• Themes: Shipped with 10 beautiful themes (defaulting to VS Code Dark Modern, alongside Tokyo Night, Catppuccin, Gruvbox, Nord, Rosé Pine, Cyberdream, and Kanagawa).

3. Integrated AI Assistant Workspace

AI terminal tools have exploded recently (Claude Code, Gemini CLI, Google Antigravity, Copilot CLI, etc.).
Tuim includes a dedicated AI Panel:

• It auto-detects installed CLI assistants in your $PATH.
• Launch or switch between assistant sessions in the terminal with one click.
• Use context actions: Send Selection, Send File Content, or Review Working Tree Changes to feed code directly into your AI chat session without tedious copying and pasting.

🚀Getting Started in 30 Seconds

Tuim is designed for frictionless installation on Linux and macOS(Still testing for macOS). Release bundles include a private, pre-packaged Neovim runtime—so you don't even need Zig or Neovim pre-installed to try it.

curl -fsSL https://raw.githubusercontent.com/Tuim-editor/Tuim/main/setup.sh | bash
tuim

Or, if you prefer building from source using Zig:

git clone https://github.com/Tuim-editor/Tuim.git
cd Tuim
zig build -Doptimize=ReleaseFast
./zig-out/bin/tuim

On first launch, Tuim presents a friendly onboarding guide letting you choose between IDE and Normal mode so you can get to work right away.

Credits

Tuim would not exist without the open-source ecosystem it builds upon. Huge credit goes to:

• The Neovim team for creating one of the most capable RPC-driven editing backends in the world.
• The Tree-sitter authors for blazing fast AST parsing.
• The Zig community for a language that makes building bulletproof, low-latency TUIs a joy.
• Plugin authors like Folke Lemaitre (lazy.nvim, tokyonight), William Boman (mason.nvim), Saghen (blink.cmp), ThePrimeagen (harpoon), Alex Popov (store.nvim.crawler), and many others.

🌟 Try It and Join In!

Tuim is fully open-source under the MIT License.

• 🐙 GitHub: https://github.com/Tuim-editor/Tuim
• 🌐 Website & Docs: https://rouboufy.github.io/Tuim/

If you try it out, I'd love to hear your feedback:

• What editing mode feels most natural to you?
• What terminal workflow or plugin would you love to see integrated next?

Drop your thoughts in the comments below, or open an issue on GitHub! ⭐