Nimbalyst: A visual layer over Claude Code, Codex, and other coding agents

What Nimbalyst actually is

Nimbalyst is a desktop application, built with Electron and TypeScript, that sits on top of coding agents like Claude Code and Codex. It does not replace those agents. It gives you a visual workspace where you and the agent edit the same files. The README lists WYSIWYG editors for markdown, mockups, Mermaid, Excalidraw, CSV, data models, and code in Monaco. You can run several agents in parallel, each in its own git worktree, and track their sessions on a kanban board. The target user is someone who finds terminal-only agent interaction too raw and wants a review layer with rendered output. The app is free and MIT-licensed, with installers for macOS, Windows, and Linux. There is also an iOS companion, but it is a separate native SwiftUI app in the monorepo, not part of the desktop binary.

The core mechanism: visual diff acceptance

The central workflow is red/green diff review. The agent proposes edits, and you step through them in the rendered document, accepting or rejecting each one. This is not a terminal diff. The README says you see the changes in the rendered markdown, mockup, or diagram, which means you review the semantic result, not just the raw text. The same file is edited by both you and the agent, so there is no export/import cycle. This design assumes you trust the rendered view as a faithful representation of the file. For markdown and Mermaid that works. For code in Monaco, the diff is still a text diff, just inside a familiar editor. The mechanism is simple: the agent writes to the file, the app detects the change, and the editor renders it with accept/reject controls.

Parallel sessions and git worktrees

Each agent session runs in its own git worktree, which is how Nimbalyst isolates parallel agents. The README lists git branch and worktree management, staging, and AI-drafted commits as built-in features. This means you can run Codex on one feature and Claude Code on another without them stepping on each other. The session kanban tracks each session, links it to the files it touched, and lets you search and resume. The practical consequence is that you must be comfortable with git worktrees. If your project does not use git, or your team has a convoluted branching strategy, this isolation model will fight you. The app also embeds a ghostty terminal, so you can fall back to raw commands when the visual layer is not enough.

Getting it running: download and build commands

The fastest path is to download a platform installer from the releases page. macOS Apple Silicon and Intel builds require macOS 12 or later, Windows needs Windows 10+, and Linux gets an AppImage. After install, you create a document with Cmd/Ctrl+N, write in markdown, and invoke the AI assistant. To run from source, the README gives three commands: npm install, then cd packages/electron && npm run dev, and for a local Mac binary, npm run build:mac:local. The monorepo uses npm workspaces and requires npm 7+. The major workspaces are packages/electron, packages/ios, packages/runtime, packages/collab-protocol, packages/extension-sdk, and packages/extensions. The runtime package contains the Lexical editor and sync services, which suggests the app is not a thin shell but has a real editing core.

The extension system and EditorHost contract

Nimbalyst does not ship a fixed set of editors. Every editor, including the built-in ones, goes through the same EditorHost contract. The README says a custom editor you build is first-class. There is an extension SDK workspace and a set of built-in extensions that include an Astro website editor, a visual git log, a mindmap, slides, and a 3D object editor. The idea is that you can ask your coding agent to build an editor for a file type Nimbalyst does not ship. This is a genuinely different approach from most agent UIs, which treat output as text. The trade-off is that the extension system is only as good as its documentation, and the README does not show a single example of the EditorHost API. You will need to read the extension-sdk package source to understand the contract. That is a real adoption cost for teams that want custom editors.

Telemetry and the sync server: two things to verify

Nimbalyst sends anonymous usage analytics to PostHog. The README lists what is not collected: no usernames, emails, IP addresses, file contents, file paths (only categorized buckets), API keys, or document content. A random ID correlates events, and you can opt out in Settings → Advanced → Analytics. The project publishes a full event list in docs/POSTHOG_EVENTS.md and privacy rules in docs/ANALYTICS_GUIDE.md. That is more transparent than most. The bigger architectural point is the collaboration sync server. The README says it is a separate project, talked to at wss://sync.nimbalyst.com. The iOS companion and any real-time collaboration depend on that server. The desktop app can probably work without it for local sessions, but the README does not say that explicitly. If you need full control over your data flow, you must either run your own server (which is not documented in the README) or accept the hosted endpoint.

Limitations and when it is the wrong tool

The most obvious limitation is that Nimbalyst is not an agent itself. It orchestrates agents you already have. If you do not use Claude Code, Codex, or OpenCode, the app has nothing to drive. The alpha status of OpenCode, Copilot, and a Gemini provider means those integrations may be unstable. The README warns that alpha builds are rougher and may break, but that warning is about release channels, not agent integrations. Another limitation is the worktree model: every parallel session needs a separate git worktree, which can be expensive for large repositories. The app also assumes you want to review changes visually. For a developer who prefers reading raw diffs in a terminal, the red/green rendered view adds a layer of indirection. Finally, the iOS companion is a separate native app, so you are maintaining two codebases if you adopt the mobile side. The desktop app is the core; the mobile experience is an add-on.

A real alternative: the terminal-plus-editor combo

The closest alternative is not another visual workspace but the default setup most agent users have today: run Claude Code or Codex in a terminal, and review changes in your regular editor with git diff. That approach has no extra install, no sync server, and no telemetry. The difference in approach is that the terminal gives you raw text output and you rely on your editor's diff view, which is also red/green but not rendered as markdown or Mermaid. Nimbalyst's value is the rendered, semantic diff and the session kanban. If you do not need those, the terminal combo is simpler and has fewer moving parts. Another alternative is to use the agents' own UI, such as the Claude Code web interface, but that is proprietary and does not give you a local file store. Nimbalyst's plain-files-on-disk approach is its main differentiator: content and status live in markdown in your git repo, with no proprietary store to migrate out of.

Maintenance and upgrade cost

The project is actively maintained, with recent releases v0.75.5, v0.75.4, and v0.75.3 in late August 2026. The app has auto-updates, with a stable channel by default and an alpha channel under Settings → Advanced → Release Channel. That means you get updates without manual intervention, but it also means you are trusting the maintainers' release promotion. The MIT license is permissive: you can fork and modify, including the Electron app and the extension SDK. The sync server, however, is a separate project and its license is not stated in the README. The iOS app is in the same repo but is a separate native codebase, so upgrading it involves the App Store. For a team adopting Nimbalyst, the upgrade cost is low for the desktop app, but you must track the sync server's status and the alpha agent integrations. The telemetry opt-out is a simple settings toggle, but you should verify the event list in docs/POSTHOG_EVENTS.md before deploying in a sensitive environment.

Editorial conclusion

Adopt Nimbalyst if you already live inside Claude Code or Codex and want a visual review layer, a kanban for sessions, and a way to edit agent output in markdown or Mermaid without leaving the desktop. Skip it if you need a fully self-hosted stack, because the collaboration sync server at wss://sync.nimbalyst.com is a separate project and the iOS companion requires that server. Before adopting, verify which of the alpha agent integrations (OpenCode, Copilot, Gemini) you actually need, confirm your git worktree workflow tolerates the app's built-in branch management, and read docs/POSTHOG_EVENTS.md to see exactly what telemetry events are sent. The core judgement: Nimbalyst is a pragmatic, MIT-licensed front-end for agent orchestration, but its dependency on a remote sync server and a separate mobile codebase means it is not a single-binary solution.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes