TL;DR

Juggler is an open-source desktop coding agent built by Julian Storer — the same person who created JUCE (the C++ framework behind almost every serious audio plugin) and the Tracktion DAW. It launched on Hacker News on July 14, 2026, and the pitch is refreshingly honest:

“Yes, it’s another AI coding agent. The industry definitely needed one more.”

But Juggler is not another Cursor clone. Here is what makes it different:

  • Tree-based sessions, not chat scroll — every point can branch into a sub-thread, backed by a Yjs CRDT document
  • Miller-column UI — Finder-style navigation for tool calls, item properties, and nested threads
  • Plugin-first everything — every tool (read, write, bash), every strategy, every slash command is a JavaScript extension
  • Not Electron — Go backend with Wails windowing, HTML/JS frontend, no build step from source to shipped
  • Local, LAN, or remote — one session, many clients (native app + browser tabs on other machines can all attach)
  • Model-agnostic — Claude Code (CLI or API), Codex (plan or API), Gemini, Ollama, OpenRouter, Z.AI, Deepseek
  • License: AGPL-3.0 for the app, Apache-2.0 for the extension SDK and bundled extensions
  • GitHub: juggler-ai/juggler · Homepage: juggler.studio

If you have ever wanted to escape the “doom scroll” transcript of Claude Code or OpenCode without giving up the flexibility of a plugin ecosystem, Juggler is the most interesting new entrant of the summer.

Who Is Julian Storer, and Why Does It Matter?

Most Show HN posts land with an anonymous author and a landing page full of stock illustrations. This one landed with a name that music-software developers immediately recognised.

Julian Storer (julesrms on HN) has spent over 30 years shipping infrastructure that other developers build on top of:

  • JUCE — the cross-platform C++ framework that powers a large fraction of every commercial audio plugin you have ever heard. Realtime-safe, cross-platform, and mature.
  • Tracktion DAW — a full digital audio workstation, still shipping today as Waveform.
  • Cmajor — a DSP language designed specifically for audio processing.

His pattern, in his own words on the HN thread, is that all of these projects “came from me getting annoyed with something I had to use, and deciding to have a go at my own take on whatever it was.”

This matters because Juggler is not a fresh-out-of-college weekend project chasing the AI wave. It is a career UI/UX-obsessed systems programmer looking at Claude Code, Codex, and OpenCode and deciding they all lose to the terminal — and doing something about it.

One HN commenter put it plainly:

“JUCE is the standard for cross platform music plugin development and needs to work efficiently in hard realtime settings … someone like you picking up the desire to build an agentic platform really piques my interest.”

Founder credibility does not guarantee good software, but it does buy the project attention from a very specific slice of developers who care about latency, plugin architectures, and long-term maintenance.

What Juggler Actually Does Differently

The current wave of coding agents — Claude Code, Codex CLI, Gemini CLI, Aider, OpenCode, Pi — are almost all TUIs or thin GUI wrappers around a linear transcript. Juggler rejects the transcript entirely.

1. The Session Is a Tree, Not a Transcript

In Claude Code, if you want to explore an alternative approach halfway through a session, your options are basically:

  • Fork the conversation manually
  • Use /compact and pray
  • Start a new session and lose all context

In Juggler, any point in the session can branch into a sub-thread. Sub-threads can branch again. The whole structure is a Yjs document — the same CRDT technology that powers Notion-style collaborative editing — which means you can navigate, inspect, edit, and rewind the tree directly.

Storer describes it as:

“The session is a tree, not a doom-scroll. It’s a Yjs document, not a transcript. Create sub-threads, drill down, backtrack, compare, and edit.”

This maps naturally onto how experienced developers actually think — you try an approach, you back out, you branch, you compare. Chat UIs make this a manual copy-paste operation.

2. Miller Columns Instead of Collapsible Chat

If you have ever used Finder’s column view on macOS, you already understand the navigation model. The root of the session sits on the left; selecting an item expands its properties and children into the next column to the right. Selecting again drills deeper.

Everything important — tool calls, approvals, thread structure, item properties, the raw context sent to the LLM — is a first-class visible object, not a collapsed block of grey text at the bottom of a chat bubble.

For anyone who has ever spent five minutes scrolling a Claude Code session looking for the exact Edit call that broke something, this is a meaningful UX bet.

3. Plugins All the Way Down

This is the part that will decide whether Juggler becomes a real platform or just a nicer-looking client.

Almost every object in a session is defined by a JavaScript extension:

  • Context items — every item type in the conversation (read-file, replace-text, bash, etc.) controls both how it talks to the LLM and how it appears in the UI.
  • Strategies — high-level LLM loops (plan, research, TDD, or your own custom orchestrations) are plugins.
  • Commands — slash commands like /clear and /compact are plugins that manipulate the session document.

The bundled extensions and the SDK are Apache-2.0-licensed even though the core app is AGPL-3.0, so you can ship closed-source extensions on top without copyleft concerns. That is a deliberately friendly stance toward third-party plugin authors.

4. Native App, No Electron

Under the hood:

  • Backend: Go, using Wails for windowing
  • Frontend: HTML/JS served by the Go backend (no Electron, no separate Chromium runtime)
  • Session state: Yjs CRDT documents
  • Frontend language: type-checked JavaScript with JSDoc types (not TypeScript), enforced in CI

The tradeoff is refreshingly explicit: no build step between source and what ships, at the cost of not having full TypeScript-compiler-level guarantees. Given the target audience (developers who want to fork and hack extensions), this is the right call.

5. One Session, Many Clients

The desktop app is not a monolith — it is one client attached to a local webserver. That means a browser tab can be another client. A phone browser can be another. A machine on a different network can be another (with the paid WAN mode, or over LAN with the --public flag).

juggler  # prints URL + QR code for browser connection

Multiple humans can view the same session live. That is a real answer to the “coding agent for a team” problem that OpenCode users have been building bespoke harnesses for.

Installation

macOS

# Download the .dmg from juggler.studio or the GitHub Releases page
# Drag Juggler to Applications
# First launch: right-click → Open → Open (Gatekeeper unsigned dev bypass)

Windows

# Download Juggler-<version>-setup.exe from Releases
# Runs the installer; installs desktop app + juggler.exe CLI together

Linux (headless server, container, or CI)

# Download the juggler server binary from Releases
./juggler
# Connect via browser at the printed URL, or press `w` to open the desktop app

Build from source

git clone --recurse-submodules https://github.com/juggler-ai/juggler.git
cd juggler
make build

Windows binaries cross-compile from any host with make build-windows. The Linux desktop app must be built natively.

Real Code Example: A Custom Context Item

The plugin API is the whole story here. A minimal context-item extension defines both the LLM-facing shape and the UI:

// web/extensions/my-tool/context-item.js
export default {
  type: "my-shell-linter",

  // How this item is described to the LLM
  toPrompt(item) {
    return `Lint result for ${item.path}:\n${item.output}`;
  },

  // Optional custom UI in the Miller column
  ui: {
    icon: "check-circle",
    title: (item) => item.path,
    body: (item) => ({
      kind: "code",
      language: "text",
      text: item.output,
    }),
  },

  // Tool call the LLM can invoke to create one of these items
  toolCall: {
    name: "lint_shell",
    parameters: { path: "string" },
    async run({ path }, ctx) {
      const { stdout } = await ctx.bash(`shellcheck ${path}`);
      return { path, output: stdout };
    },
  },
};

That single file gives the LLM a new tool AND gives you a rich, inspectable UI card for every invocation. In Claude Code you would need to configure an MCP server, register a tool schema, and still get a plain-text card. In Juggler, tool + UI ship together.

Similarly, a custom strategy is just a JS module that decides which LLM call to make next, given the current tree:

// A trivial "plan-then-execute" strategy
export default {
  name: "plan-execute",
  async step(session, llm) {
    const plan = session.findLatest("plan");
    if (!plan) {
      return llm.ask("Write a step-by-step plan. Do not write code yet.");
    }
    return llm.ask("Execute the next unchecked step in the plan.");
  },
};

Community Reactions

The HN thread (48883305, launched July 14, 2026) is worth reading in full — the founder is deeply engaged in the comments — but a few reactions stand out:

On the founder credibility angle, from yowlingcat (audio dev):

“First of all, it’s so cool to see you on HN and creating this … someone like you picking up the desire to build an agentic platform really piques my interest. Right now I am using Opencode … but the release pace is blistering and it does feel bloated.”

On the tree-based paradigm, same commenter:

“The tree paradigm feels like the killer feature to me; not sure of anything else besides pi/omp that has it.”

On the UI cleanness, from prabhanjana_c:

“UI is clean. Could install in Mac. Adding context files at the top is clean. It worked. Currently I use zed, vscode (for UI) along with claude, codex, Hermes. Not sure if I will continue to use. But I see it is a clean and good UI.”

On honest bugs, from MomsAVoxell after a crash on a MacBook Air M5:

“Plugged in the laptop as it started processing, and then the system froze. I guess Juggler doesn’t like display/USB enumeration events while it’s busy having ollama chug up all the resources … In any case, will tinker with it some more, looks really great.”

Storer’s response to that report was to ask for more debug info immediately, which sets a good tone for a new project’s issue tracker.

One anti-hype note — the “creator of JUCE” branding is causing some confusion. Storer clarified in the thread:

“There’s no C++ in it, it’s all Go/Javascript. And all the UIs are HTML. JUCE is a great choice for some things, but this wasn’t one of them!”

So do not expect JUCE-style hard-realtime engineering under the hood. This is a modern web-stack native app that happens to be built by someone with deep systems experience.

Honest Limitations

If you are considering putting Juggler into a serious workflow, these are the current gaps worth knowing about:

1. No worktree or sandbox support yet. Storer confirmed on HN that both are on the TODO list. If you rely on git worktrees + sandboxing (as many OpenCode users do), you will need to bring your own harness or wait.

2. No skills/subagent orchestration equivalent. Superpowers-style skill loading and subagent-driven development are not built in. The plugin API is expressive enough to build them, but nobody has yet.

3. WAN access is not in the open-source repo. The AGPL build gives you localhost + LAN. Reaching your server from outside your network requires the official binaries from juggler.studio, which include closed-source components under a separate licence.

4. Unsigned binaries on macOS. First launch requires the Gatekeeper bypass dance. Enterprise-locked-down machines will not install this without help.

5. Extension ecosystem is empty. As of launch week, there is no marketplace, no discovery UI, and no third-party extensions to speak of. Everything cool it can do, you will be writing yourself.

6. AGPL-3.0 for the core. If you want to fork Juggler to build a hosted service, you must release your modifications under AGPL or contact Storer for commercial licensing. Extensions are safely Apache-2.0, so plugin authors are unaffected.

7. Not yet battle-tested at long context. The HN thread notes that some users have reached 200k–400k context sessions without issue, but that is a very small sample. Compare to Claude Code and Codex, which have millions of user-hours at those context sizes.

How It Compares to Other Coding Agents

FeatureJugglerClaude CodeOpenCodeCursorAider
UI paradigmMiller columns + treeChat scroll (TUI)Chat scroll (TUI)IDE panelsCLI
Session modelYjs CRDT treeLinear transcriptLinear transcriptLinear + tabsLinear
Plugin architectureJS extensions everywhereSkills + MCPPluginsRules + MCPNone
Model agnostic✅Anthropic-first✅✅✅
Multi-client (browser + native)✅❌❌❌❌
RuntimeGo + WailsNode.jsNode.jsElectronPython
LicenseAGPL-3.0 + Apache-2.0 SDKProprietaryMITProprietaryApache-2.0

The closest philosophical competitors are OpenCode (extensibility + model-agnostic) and Pi (tree-style navigation). Juggler is the first to combine both with a properly native GUI.

Should You Use Juggler?

Use Juggler if:

  • You dislike the terminal-transcript paradigm and want a real visual workbench
  • You want to write your own tool + UI plugins in JavaScript rather than fight MCP schemas
  • You are building an internal team tool and want browser + native clients on the same session
  • You care about not-Electron native apps and small binaries
  • You are already comfortable with unsigned macOS binaries and early-stage tooling

Skip Juggler (for now) if:

  • You need worktree isolation and sandboxing today
  • You need a mature skills ecosystem like Claude Code’s marketplace
  • You need enterprise-signed binaries for a locked-down machine
  • Your workflow is deeply invested in Cursor’s IDE integration or VS Code’s Copilot Chat
  • You need WAN access without paying for the official binary

FAQ

Is Juggler really by the creator of JUCE?

Yes. Julian Storer (julesrms on HN) confirmed his identity in the launch thread on July 14, 2026. He is also the person behind Tracktion (now Waveform) and the Cmajor DSP language. He clarified that Juggler itself uses no JUCE code — the backend is Go and the UI is HTML/JS.

Is Juggler free?

The GitHub repo is fully open source under AGPL-3.0 (with Apache-2.0 for the extension SDK). You can build and run it yourself with no restrictions for personal, local, or LAN use. WAN access ships only in the official binaries from juggler.studio, which include closed-source components under a separate licence.

Which LLMs does Juggler support?

Out of the box: Claude Code (via CLI or Anthropic API), OpenAI (Codex plan or API), Gemini, Ollama for local models, OpenRouter, Z.AI, and Deepseek. Adding a new provider is a JavaScript extension, so the list is expected to grow quickly.

How does the tree-based session compare to Claude Code’s /compact?

/compact collapses old context into a summary and moves on. Juggler’s tree lets you keep the old branch, spawn a new sub-thread with modified context, compare results side-by-side, and merge back. It is closer to git branch than to git commit --amend.

Can I run Juggler on a remote server and use it from my laptop?

Yes. Run juggler on the server; it prints a URL you can open in a browser (localhost by default; LAN with --public). For WAN access without your own tunnelling, you need the official binaries from juggler.studio.

Does it use Electron?

No. The backend is Go with Wails for native windowing, and the frontend is HTML/JS served by the Go backend. That is the main reason it ships as a small native app rather than a 300MB Chromium bundle.

Is it production-ready?

For daily coding? Yes, for developers comfortable with launch-week software. For team-critical production workflows, wait for worktree/sandbox support and a few more months of hardening. The founder is highly engaged in the issue tracker, which is a very good sign.

The Bottom Line

Juggler is the first coding agent that treats the session document as a first-class object worth exploring, editing, and branching — instead of a chat transcript to scroll through and occasionally rewind. Combine that with a plugin-first architecture where every tool call ships its own UI, a native (not Electron) Go + HTML stack, and a founder with a 30-year track record of shipping cross-platform developer infrastructure, and you have the most interesting new coding-agent entrant since OpenCode.

It is not the tool for everyone today. The extension ecosystem is empty, worktrees are on the TODO list, and macOS binaries need the Gatekeeper bypass. But the architecture is a genuinely different bet than any other agent in the space — and if the tree-based session paradigm catches on, Juggler will have been the one that shipped it first with a UI worth using.

For now, treat it as the coding agent to fork and hack on. The Julian Storer bet is that a proper visual workbench beats a terminal transcript over the long run. On the evidence of JUCE, Tracktion, and Cmajor, that is a bet worth watching.

Try it: juggler.studio · github.com/juggler-ai/juggler · HN launch thread

Sources