JMUX: waarom ik mijn eigen terminal multiplexer bouwde

Ik draai dagelijks meerdere Claude Code sessies tegelijk. Vier projecten, per project twee of drie terminals, en tussendoor nog een James agent die iets uitzoekt. Dat zijn tien tot vijftien terminals die open staan. Probeer dat maar eens bij te houden in een standaard terminal.

Bestaande tools beloofden dit probleem op te lossen. Solo, Maestro, Conductor. Allemaal geprobeerd. Allemaal dezelfde fout: ze voegen een laag abstractie toe die meer kost dan oplevert. Dus bouwde ik mijn eigen oplossing: JMUX, een native macOS terminal multiplexer in Swift en SwiftUI.

Waarom bestaande tools niet werken

Solo, Maestro, Conductor, ze klinken goed op papier. Een orchestratie-laag die meerdere Claude Code sessies aanstuurt. Maar in de praktijk lopen ze tegen hetzelfde probleem aan.

Ze eten je context window op. Elke orchestratie-laag voegt prompts toe. Die prompts kosten tokens. Tokens die je liever besteedt aan je eigenlijke werk.
Ze verbergen terminal output. Je ziet niet wat Claude doet. Je ziet een samenvatting, een status, een progress bar. Maar niet de echte output. Als iets misgaat, moet je gaan graven.
Ze voegen complexiteit toe. Extra configuratie, extra prompts, extra failure modes. In ruil waarvoor? Een laag bovenop iets dat al werkt.

Wat ik wilde was simpel: meerdere echte terminals, gegroepeerd per project, met net genoeg informatie in de sidebar om te weten wat er speelt. Geen extra prompts, geen context overhead, volledige zichtbaarheid.

Wat is JMUX

JMUX is een native macOS applicatie voor het beheren van meerdere James/Claude Code sessies, gegroepeerd per project. Het is geen wrapper, geen Electron app, geen web view. Het is Swift + SwiftUI met echte pseudo-terminals onder de motorkap.

De naam is bewust simpel. J van James, MUX van multiplexer. Het doet wat het zegt.

De kern: echte terminals, geen abstractie

Dit is het belangrijkste verschil met alle alternatieven. JMUX gebruikt SwiftTerm, de terminal emulator library van Miguel de Icaza. Elke sessie krijgt een eigen PTY (pseudo-terminal). Dat betekent:

Volledige terminal functionaliteit, kleuren, scrollback, interactieve programma's
Geen informatie die verloren gaat in een abstractielaag
Wat je ziet is wat er daadwerkelijk draait

Als Claude Code een foutmelding geeft, zie je die. Als een test faalt, zie je de output. Als een subagent iets onverwachts doet, kun je direct meekijken. Geen samenvatting, geen interpretatie, de echte terminal.

Features die het verschil maken

Project groepering

Elke terminal hoort bij een project. In de sidebar zie je je projecten, en per project de actieve sessies. Klik op een project, zie alle terminals. Geen tabbladen zoeken, geen "welke terminal was dit ook alweer?"

Per project kun je een kleur, icoon, quick links, web links, en Obsidian notities instellen. Alles bij de hand zonder te switchen.

Busy/idle detectie

JMUX weet of een sessie bezig is of idle. Dat doet het op drie manieren: shell hooks, pgrep, en Claude's eigen JSONL state files. Je ziet in een oogopslag welke sessies nog aan het werk zijn en welke klaar zijn.

Nog beter: als een sessie klaar is, krijg je een macOS notificatie. Geen polling, geen checken of Claude al antwoord heeft gegeven. Je werkt door in een ander project en wordt getipt wanneer iets afgerond is.

Git status in de sidebar

Per project zie je de huidige branch, dirty state, en gewijzigde bestanden. Zonder een git command te typen. Je weet precies wat de status is voordat je switcht naar dat project.

File browser

Ingebouwde file browser met automatische editor detectie. PhpStorm, Xcode, VS Code: JMUX opent bestanden in de editor die bij het project hoort. Drag-and-drop van file paths naar de terminal werkt ook.

Dashboard: alles op een plek

JMUX heeft meer dan alleen terminals. Het dashboard geeft per project een overzicht met tabs:

Health: de status van je project in een oogopslag
Tasks: actieve taken en hun voortgang
Patrol: monitoring van lopende processen
Memory: wat James onthouden heeft over dit project
Skills: welke skills actief zijn
Prompt: snelle toegang tot veelgebruikte prompts

Daarnaast: Chrome pinned tabs beheer, Spotify controls, en een activity feed die laat zien wat er in alle sessies gebeurt. Het klinkt als veel, maar het punt is dat alles op een plek zit. Geen zes apps open om te weten wat er speelt.

Swift + SwiftUI: waarom native

Ik had dit in Electron kunnen bouwen. Sneller op de markt, cross-platform, makkelijker te prototypen. Maar ik wilde het niet.

Performance. Tien terminals tegelijk openhouden in Electron is een recept voor memory leaks en hoog CPU gebruik. Native Swift met SwiftTerm is lightweight.
macOS integratie. Notificaties, keyboard shortcuts, menu bar, het werkt allemaal zoals je verwacht op een Mac. Geen "bijna native" ervaring, maar echt native.
Geen WebView overhead. Elke Electron app is een Chromium browser. Dat is 200+ MB aan runtime voor iets dat geen browser hoeft te zijn.
SwiftUI. De sidebar, het dashboard, de settings, het bouwt snel en ziet er goed uit. Geen CSS gefrustratie, geen component libraries.

De trade-off is dat het alleen macOS 14+ ondersteunt. Dat is prima. Ik bouw het voor mezelf, en ik draai macOS.

"Ik hoef de applicatie niet meer uit"

Het moment dat ik wist dat JMUX werkte: ik realiseerde me dat ik de applicatie niet meer sluit. Het is de hele dag open. Elke terminal, elk project, alles op een plek.

Vroeger was mijn workflow: open iTerm, maak tabs, onthoud welke tab bij welk project hoort, check git status in de terminal, wissel naar browser voor Linear, terug naar terminal. Nu open ik JMUX en alles is er.

Dat is het hele punt. Geen revolutionaire AI feature, geen magie. Gewoon een tool die meerdere Claude Code sessies beheersbaar maakt door ze te groeperen, zichtbaar te maken, en net genoeg context te tonen zonder in de weg te zitten.

Wat ik geleerd heb

Drie dingen die ik meeneem uit het bouwen van JMUX:

Bouw tools voor je eigen workflow. Bestaande tools zijn gebouwd voor de gemiddelde developer. Jouw workflow is niet gemiddeld. De beste tool is de tool die precies past bij hoe jij werkt.
Minder abstractie is meer. De kracht van JMUX is wat het niet doet. Het stuurt Claude niet aan, het interpreteert geen output, het voegt geen prompts toe. Het toont terminals. Dat is genoeg.
Native maakt verschil. Het verschil tussen een Electron app met tien terminals en een Swift app met tien terminals is merkbaar. Elke dag, de hele dag.

Als je dagelijks meerdere Claude Code sessies draait en je verdrinkt in tabs en terminals, dan snap je het probleem. JMUX is mijn antwoord erop. Niet het enige mogelijke antwoord, maar wel het antwoord dat bij mijn manier van werken past.

Vragen over JMUX of benieuwd hoe het in jouw workflow zou passen? Neem contact op, ik denk graag mee.