Skip to content
/
Tier A A12 UI passthrough

Nimbalyst

nimbalyst · nimbalyst/nimbalyst · ★ 604 · last commit 2026-05-25

Replace terminal-switching and raw diff review with a WYSIWYG visual editor and session manager where humans and AI coding agents collaborate on the same documents.

Best whenThe review interface should be WYSIWYG — reading a raw diff is the wrong level of abstraction for human review.
Skip ifSwitching between multiple terminal windows, Reviewing code as raw text diffs when rendered output is available
vs seeds
kiro(both are graphical environments for AI coding agent management with rich editing), but Nimbalyst is a free open-source …
Primitive shape
No installable primitives
00

Summary

Nimbalyst — Summary

Nimbalyst is a free local desktop application (Electron/Tauri, cross-platform: macOS, Windows, Linux) and session manager for building with Codex, Claude Code, Opencode, and Copilot. Like Vibe Kanban, it is a UI-layer framework — but with a WYSIWYG-first philosophy: instead of a diff viewer, it provides built-in visual editors (markdown, mockups with annotations, Mermaid diagrams, Excalidraw, CSV, data models, code with Monaco) where users and agents collaborate in real time. The agent's changes appear as red/green WYSIWYG diffs that users approve, edit, or annotate inline. It includes session management with kanban board, parallel session support, worktrees and git management, AI-generated commits, a Ghostty terminal, an extension system with a marketplace, and a mobile app (iOS/Android) for managing sessions on the go. Nimbalyst also ships a .claude/commands/ set of 25 slash commands and one agent (e2e-runner) for its own development, which are not user-facing prompting frameworks.

Compared to seeds, Nimbalyst is closest to kiro (both are graphical environments for AI coding agent management with built-in editing), but Nimbalyst is: (1) free/open source vs. kiro's $0–$200/mo pricing; (2) a local desktop app rather than an IDE fork; (3) extensible via a plugin marketplace rather than locked to one tool; and (4) a session+file manager rather than a spec-format-imposing IDE.

01

Overview

Nimbalyst — Overview

Origin

Created by the nimbalyst team (11 contributors, v0.33.1). Fork/successor of stravu/crystal — the stravu/crystal repo now redirects: "(Crystal is now Nimbalyst) Run multiple Codex and Claude Code AI sessions in parallel git worktrees." MIT license. 604 stars.

Philosophy

"Nimbalyst is a free, local, interactive visual editor & session manager where builders maximize speed, bandwidth, and context with Codex, Claude Code, Opencode, Copilot by collaborating visually on files, sessions, and tasks."

Key principles:

  1. WYSIWYG-first: Approve agent changes as red/green diffs in the actual rendered document (not raw text diff)
  2. Parallel sessions: Manage multiple concurrent agent sessions without terminal-switching
  3. Open storage: Content and status in markdown/plain files on disk or in git — not in proprietary DBs

Key Features (from README)

"Iterate visually with coding agents in your markdown, mockups, diagrams, csv, Excalidraw, data models, and code. Approve the coding agent's changes in red/green WYSIWYG, edit, annotate."

"Manage multiple sessions in parallel and in kanban. Search, resume, link sessions to files and files to sessions."

"Mobile app. Start, manage, and respond to your Codex and Claude Code sessions while on the go."

"Extend Nimbalyst. Build your own custom editors and visual interfaces integrated with the rest of Nimbalyst and your agents."

Notable Distinction from Vibe Kanban

Nimbalyst was announced as a successor/alternative to the sunsetting Vibe Kanban. The two share the kanban+workspace pattern but Nimbalyst adds: WYSIWYG visual editors, mobile app, extension marketplace, worktree git management, AI-generated commits, and Ghostty terminal integration.

02

Architecture

Nimbalyst — Architecture

Distribution

  • Type: Desktop app (downloadable DMG/EXE/AppImage) + optional npm
  • Install: Download from GitHub releases (DMG for macOS, EXE for Windows, AppImage for Linux)
  • License: MIT
  • Version: 0.33.1
  • Language: TypeScript monorepo

Technology Stack

  • Main app: Electron with TypeScript (packages/electron/)
  • Runtime: Nimbalyst runtime (packages/runtime/)
  • Frontend: Custom SvelteKit/React (Monaco for code editing, Excalidraw for diagrams)
  • Terminal: Ghostty (embedded terminal emulator)
  • Extension SDK: packages/extension-sdk/ — public API for custom editors
  • Mobile: iOS (packages/ios/) + Android (packages/android/)
  • Collaboration: packages/collab-protocol/
  • Browser extension: packages/browser-extension/

Directory Structure

packages/
  electron/         ← Main desktop app
  runtime/          ← Agent runtime integration
  extension-sdk/    ← Public extension API
  extension-sdk-docs/
  extensions/       ← Built-in extensions
  ios/              ← Mobile app
  android/          ← Mobile app
  collab-protocol/  ← Collaborative editing protocol
  marketplace/      ← Extension marketplace
  opencode-plugin/  ← OpenCode integration
  shared/           ← Shared utilities

.claude/
  commands/         ← 25 slash commands (for Nimbalyst's own dev, not end-user framework)
  agents/           ← 1 agent (e2e-runner.md) for Nimbalyst dev
  rules/            ← Development guidelines

.nimbalyst/
  trackers/         ← Internal tracking files

Platform Support

Platform Download
macOS Apple Silicon Nimbalyst-macOS-arm64.dmg
macOS Intel Nimbalyst-macOS-x64.dmg
Windows Nimbalyst-Windows.exe
Linux Nimbalyst-Linux.AppImage

Supported Agents

  • Codex (primary)
  • Claude Code (primary)
  • Opencode (alpha)
  • Copilot (alpha)
03

Components

Nimbalyst — Components

Nimbalyst's user-facing components are UI features and the extension system, not prompt primitives.

Built-in Visual Editors

Editor Purpose
Markdown (WYSIWYG) Write and review markdown with WYSIWYG red/green diffs
Mockups with annotations Visual mockup creation with agent + human annotations
Mermaid Diagram editing (agent-generated, human-approved)
Excalidraw Freeform diagramming
CSV Tabular data editing
Data Models Entity-relationship diagrams
Code with Monaco Code editing with VS Code's Monaco editor

All editors implement the same EditorHost contract — custom extensions are first-class.

Session Management Features

  • Parallel session management with kanban board
  • Link sessions to files and files to sessions
  • Search and resume sessions
  • Group files touched by a session

Developer Features

  • Git state management
  • AI-generated commits (one click)
  • Embedded Ghostty terminal
  • Git worktrees

Extension System

  • Extensible via EditorHost contract
  • Extension marketplace (community extensions)
  • Built-in extensions: Astro website editor, visual git log, mindmap, slides, 3D object editor
  • Extension SDK: packages/extension-sdk/

Mobile App

  • Session dashboard (see which agents need you)
  • Text/voice reply to agent questions
  • Visual diff review (swipe to approve/reject)
  • Queue next tasks
  • Push notifications

Slash Commands (Development Use Only)

The .claude/commands/ directory contains 25 commands and 1 agent used for Nimbalyst's own development — not a user-facing prompting framework. Notable commands:

  • implement.md — Execute a plan document with progress tracking
  • design.md — Design workflow for Nimbalyst features
  • review-branch.md — Review branch changes
  • release-alpha.md, push-and-release.md — Release automation
  • mockup.md, tooltip.md — UI-specific development commands

Plan Files

The implement.md command reveals a Nimbalyst-internal plan format with YAML frontmatter (status: draft | ready-for-development | in-development | complete, progress, startDate, updated).

05

Prompts

Nimbalyst — Prompt Excerpts

The only prompt content in the Nimbalyst repo is in .claude/commands/ — used for Nimbalyst's own development, not as end-user framework prompts.

Excerpt 1: implement.md — Plan-Driven Implementation

Source: .claude/commands/implement.md

---
description: Execute a plan document while keeping progress synchronized.
---

# /implement Command

Execute a plan document while maintaining progress tracking.

## Overview

The `/implement` command reads a plan file and begins implementation while keeping the plan
document synchronized with actual progress. It extracts tasks from the plan's acceptance
criteria and implementation details, tracks them as markdown checkboxes at the top of the plan,
and checks them off as work is completed.

## Execution Steps

1. **Read the plan file** — Parse the YAML frontmatter, extract implementation details,
   acceptance criteria, and goals

2. **Generate task list** — Create markdown checkboxes from acceptance criteria; insert after
   plan title

3. **Update plan frontmatter**
   - Set `status` to `in-development` (if currently `ready-for-development` or `draft`)
   - Set `startDate` to today if not already set
   - Update `updated` timestamp

4. **Begin implementation** — Use TodoWrite to track tasks internally; work through each task
   systematically; check off corresponding checkbox in the plan file; update `progress`
   percentage in frontmatter

Prompting technique: File-driven state machine — the plan file's YAML frontmatter serves as the task state store. Status transitions (draft → ready-for-development → in-development → complete) are enforced by the command.

Excerpt 2: review-branch.md Review Command (minimal)

Source: .claude/commands/review-branch.md — not fetchable in full, but by name suggests a standard branch diff review pattern.

Note: Nimbalyst provides no end-user prompting framework. Its philosophy is that the visual editor IS the interface — users don't need to write prompts to interact with agents in the WYSIWYG model.

09

Uniqueness

Nimbalyst — Uniqueness

Differs From Seeds

Nimbalyst is closest to kiro among the seeds (both are graphical environments designed for AI coding agent management with rich editing features), but the architectural delta is substantial: kiro is a closed IDE fork with $0–$200/mo pricing, its own spec format, and proprietary hook events; Nimbalyst is a free open-source desktop app with an extension marketplace, open file storage, and support for 4 different agents. Among the batch-19 frameworks, it is a direct functional successor to vibe-kanban (which is sunsetting) with richer editing features. Neither Nimbalyst nor vibe-kanban defines a spec format or prompt framework — both are UI layers.

Positioning

  • "WYSIWYG-first" vs. vibe-kanban's "diff-review-first"
  • Free + open source vs. kiro's paid model
  • Extension-first: any file type can have a custom editor
  • Mobile-first management: the mobile app is a genuine first-class feature

Notable Patterns

  1. EditorHost contract: All editors (including built-ins) go through the same extension interface — custom editors are first-class, not plugins
  2. Voice reply: Mobile app supports voice input to respond to agent questions — the only voice interaction in this batch
  3. Open storage philosophy: "Plain files on disk or in git" — unlike vibe-kanban's SQLite-heavy architecture
  4. Crystal lineage: Successor to stravu/crystal — the parallel worktree workflow originates there

Observable Failure Modes

  1. No prompting framework: Provides no guidance on how to write good agent prompts — relies entirely on user skill
  2. Agent breadth vs. depth: Supporting 4 agents at alpha/beta quality may mean none work perfectly
  3. Extension ecosystem immaturity: Marketplace has community extensions but no quality review
  4. No spec format: Users who want structured SDD must combine Nimbalyst with another framework from this batch
04

Workflow

Nimbalyst — Workflow

Nimbalyst does not define a spec-driven development workflow for end users. Its workflow is the session management + visual editing loop.

Typical User Workflow

  1. Create or open a document in a visual editor
  2. Write/edit in WYSIWYG mode
  3. Ask AI to research, edit the document, or work across files
  4. Accept/reject AI changes via red/green WYSIWYG diffs
  5. Switch to Agent Manager — run multiple agent sessions in parallel
  6. Search and resume sessions via kanban board
  7. Review git state, make AI-generated commits
  8. Respond to agent questions via mobile app (if away from desktop)

Internal Development Workflow (Nimbalyst's own dev)

From .claude/commands/implement.md:

  1. Read plan file (YAML frontmatter + implementation details + acceptance criteria)
  2. Generate task list (markdown checkboxes from acceptance criteria)
  3. Update plan frontmatter (status: in-development, startDate, progress)
  4. Implement systematically, checking off tasks as completed
  5. Update progress percentage in frontmatter as work proceeds

This is the workflow Nimbalyst's own developers use to build Nimbalyst — not a pattern Nimbalyst imposes on its users.

Approval Gates

None defined by the framework. The WYSIWYG diff approval loop is informal (user clicks approve/reject per change).

06

Memory Context

Nimbalyst — Memory & Context

State Storage

  • Open storage philosophy: "Content and status in markdown, workflow in slash commands, and plain files on disk or in git"
  • Session metadata: SQLite or equivalent local DB (internal to the app)
  • File content: plain files on disk (not proprietary format)
  • Session links to files: stored in app DB

Per-Plan State (Internal Dev)

Plan files use YAML frontmatter for state:

  • status: draft | ready-for-development | in-development | complete
  • progress: percentage integer
  • startDate, updated: timestamps

No Framework Memory Layer

Unlike Claude Code plugins in this batch, Nimbalyst does not inject CLAUDE.md, spec files, or any context into agent sessions. The user is responsible for what context the agent has. The app provides the editing surface; the user provides the prompts.

Cross-Session Continuity

  • Kanban board shows all sessions — which are running, which are waiting, which need human response
  • Mobile app provides push notifications when agents need input
  • Sessions can be searched and resumed from the session management view
07

Orchestration

Nimbalyst — Orchestration

Multi-Agent Pattern

Yes — parallel agent sessions managed by the UI (kanban + session manager), but with no programmatic orchestration protocol. The user is the orchestrator.

  • Orchestration pattern: none (human-driven via kanban)
  • Coordination surface: Session kanban board
  • Isolation: Git worktrees (one per session/workspace)

Execution Mode

Interactive-loop — user decides when to start/stop/respond to sessions.

Agent Communication

Via the mobile app or desktop chat: users can respond to agent questions via text or voice, agents resume immediately. This is the most mobile-friendly agent management pattern in this batch.

No Programmatic Orchestration

Nimbalyst does not:

  • Chain agent outputs automatically
  • Route tasks between agents
  • Define any consensus or handoff protocol

Extension System Orchestration

Extensions can integrate with the runtime API. The collab-protocol package suggests collaborative editing support — potentially multiple agents editing the same document with conflict resolution, but details are not public at analysis time.

Multi-Model

Yes — different sessions can use different agents (Codex, Claude Code, Opencode, Copilot), but there is no programmatic routing.

08

Ui Cli Surface

Nimbalyst — UI / CLI Surface

CLI Binary

No end-user CLI binary. The app is launched by double-clicking the downloaded executable.

Local Desktop App

Yes — this is the primary interface.

Property Value
Type Desktop application
Framework Electron + custom runtime
Platform macOS (arm64 + x86), Windows, Linux
Tech stack TypeScript, Electron, Monaco, Excalidraw, Ghostty terminal, SvelteKit/React

Features

Feature Description
WYSIWYG editors Markdown, mockups, Mermaid, Excalidraw, CSV, data models, Monaco code
Red/green diffs Agent changes shown as WYSIWYG diffs with approve/reject
Session kanban Parallel session management in kanban board
Session linking Link sessions to files and files to sessions
Git management Git state visualization + AI-generated commits
Worktrees Git worktree management for parallel work
Ghostty terminal Embedded Ghostty terminal
Extension system EditorHost contract + marketplace

Mobile App

iOS and Android apps:

  • Session dashboard
  • Text/voice reply to agent questions
  • Visual diff review (swipe gestures)
  • Queue next tasks
  • Push notifications when agent needs input

Extension Marketplace

Community extensions available:

  • Astro website editor
  • Visual git log
  • Mindmap
  • Slides
  • 3D object editor
  • lean-canvas, social extensions, theme extensions (from community)

Observability

  • Session kanban shows all running/paused sessions
  • Mobile push notifications when agent needs response
  • No structured audit log

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

Vibe Kanban ★ 27k
A12 UI passthrough

Eliminate the overhead of planning, switching between agent terminals, and reviewing diffs by providing a single web dashboard…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

AgentsMesh ★ 2.1k
A12 UI passthrough

Multi-tenant workforce platform that gives every team member a squad of AI coding agents coordinated through channels, pod…