supacode pins its terminal library to a Zig version, which pins it to the Xcode before your macOS
worktree coding agents command center.
At a glance
- What is it?
- supabitapp/supacode is a native macOS application for running several coding agents in parallel, each in its own git worktree and its own terminal, with sessions persisted by a separate daemon. The most instructive file in the repository is the workaround for a system library stub that a newer macOS release removed, which costs a pinned compiler, a pinned IDE and three first-run commands.
- Who is it for?
- This is worth trying if you run several agents at once on a Mac and have been managing worktrees and terminals separately, because the per-task worktree plus a persisted session is the combination that makes parallel work survivable rather than merely possible. Three things to know before you commit.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly Swift, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- supabitapp/supacode2,399 ★ · +8
| Repository | 2026-10-01 | 2026-11-15 |
|---|---|---|
| supabitapp/supacode | 2.4k | 2.4k |
8 Stars in the last 45 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The newest release by date is a nightly from February
The three most recent tags are not in the order you would expect.
One is the nightly channel, named for the tip of the branch and dated the eleventh of February. Two are ordinary version tags: one from the third of August and one from the thirty-first of July.
So the most recent thing by date is a February nightly, and the most recent stable is nearly six months older. For anyone reading the tag list to decide what to install, that ordering is a trap: a script that picks the newest release gets a rolling tip channel rather than a stable build.
The likely cause is how a rolling tag behaves. A tag that always points at the branch head keeps its original creation date, so it sorts by when the channel was created rather than by what it currently contains. The August tags are newer in substance and older in nothing.
This matters more than a version-sorting curiosity because the application itself has a selectable update channel. The in-app channel picker corresponds to these tags, so a user choosing the stable channel gets a stable build and someone reading the tag list programmatically does not get the same answer.
A pinned Zig needs a pinned Xcode, because one SDK slice disappeared
The most instructive thing in this repository is a workaround, and it is worth tracing end to end because it shows how deep a native dependency goes.
The application embeds a terminal component built from Zig source, and that component requires an exact Zig version, pinned at 0.15.2. That compiler's linker cannot link against the SDK shipped with the newest macOS point release. The reason is precise: that SDK removed one slice from the system library stub, and the upstream language tracker has an issue for it. The symptom is a build that fails with a wall of undefined symbol errors, which is a confusing way to learn that a stub went missing.
The fix is to install the previous version of the IDE, which ships the SDK that still has the slice. Two details make this tolerable rather than awful. You do not have to switch your default developer directory globally: the build detects a compiler-linkable IDE on its own and pins it for that build only. And once it is installed, three commands finish the job, each pointed at that developer directory:
sudo DEVELOPER_DIR=/Applications/Xcode_26.3.app/Contents/Developer xcodebuild -license accept
sudo DEVELOPER_DIR=/Applications/Xcode_26.3.app/Contents/Developer xcodebuild -runFirstLaunch
sudo DEVELOPER_DIR=/Applications/Xcode_26.3.app/Contents/Developer xcodebuild -downloadComponent MetalToolchainThe third of those exists because the runtime needs a component that the newer Xcode no longer installs by default.
So the chain is: a Swift application, a terminal component written in Zig, a Zig version pinned by the terminal's own requirement, an IDE version pinned by a removed SDK slice, and three administrative commands. Every link in that chain is exact rather than approximate, which is either the price of shipping a native terminal or the reason this app does not build for everyone.
The diagnostics target is also a preflight for every build
There is a make target whose only job is to tell you what is wrong with your machine, and it is unusually thorough.
It verifies the toolchain manager, the initialised submodules, whether an installed IDE can be linked by the pinned compiler, the presence of the Metal Toolchain, and the pinned tools generally. When something is missing it prints the exact command that fixes it, not just the name of the missing thing.
It is also wired in as a preflight. The ordinary build targets run the checks automatically and quietly, and there is an environment variable that skips the whole thing when you know your machine is fine. That is the right arrangement: the check is not optional for a newcomer because they cannot miss it, and it is escapable for someone iterating.
The makefile itself is configured to be unforgiving. Every target runs in a single shell, that shell is bash with error-on-failure, unset-variable-is-an-error and pipe-failure-is-an-error, targets delete their outputs when they fail rather than leaving partial artefacts behind, undefined variables produce a warning, and the builtin rules are switched off. So a typo in a variable name fails the build rather than silently expanding to nothing, which is the failure mode that wastes an afternoon in a large build system.
A new test file can silently run in no bundle
The build file documents its own sharpest edge in a comment, and the comment is worth reading before you add a test.
Test targets use explicit source globs that are expanded when the project is generated, not when the tests run. The build therefore maintains a stamp file per configuration, four of them, and a list of the inputs that should trigger regeneration. That input list includes the project definition, the workspace definition, the toolchain manifest, the pinned package resolution file, a build configuration file, the toolchain file, two dependency build scripts, and a wildcard over the test sources.
So adding a test file does not itself invalidate anything unless the rest of the list also changed or the stamp is removed. And the consequence, in the comment's own words, is that the new test would silently run in no bundle. That is the worst shape of test failure: green, and wrong.
The test runner configuration is otherwise modern: parallel execution by default, combining in-process execution for the newer testing framework with one process per test bundle, and a documented variable to turn parallelism off when a test is not safe under it. Two variables exist purely to get text into a script: version, build number, title and body are exported rather than passed as command-line arguments, so that markdown containing quotes and backticks reaches the script without a shell re-parsing it. That is a small decision that will save someone an afternoon.
Sessions live in a daemon, and so must the far side of an SSH session
The persistence claim is architectural rather than a feature toggle, and it is worth understanding precisely.
Sessions do not run as children of the application. They run inside a separate lightweight session daemon. Quit the application and relaunch it, and every session reattaches where it was, scrollback included. There is a quit option that tears everything down when you want a clean start instead, which is the honest counterpart: persistence is the default and total teardown is one choice away.
The same daemon is what makes the remote feature work, and the dependency runs in the opposite direction than you would guess. Point the application at a repository on a remote host and it manages that host's worktrees like a local one. Every git probe and the terminal share one multiplexed SSH connection, so you authenticate once, or touch your security key once, rather than per operation. And when the remote host also runs the session daemon, a dropped connection or a laptop going to sleep results in a retry and a reattach rather than a restart. Without the daemon on the far side, the session restarts.
So the remote feature is not really an SSH feature; it is a daemon-provisioning feature with an SSH front end. It is labelled beta, with some local-only features reduced, which is consistent with a capability that depends on how the remote host was set up.
Six toolchain pillars, three of them pinned exactly
The technical stack is three items long, and the tree shows what that actually means.
A functional architecture framework from a well-known Swift shop provides the app's structure. A third-party terminal library renders every session, with tabs, splits, per-surface backgrounds and theme synchronisation with the app's appearance. The session daemon provides persistence. On top of those sit three more that the stack summary does not mention: a toolchain manager that pins the developer tools, a project generator that produces the Xcode workspace from source-of-truth files, and the Swift package resolution that ties the dependencies together.
Each of the six leaves a trace in the repository. The toolchain manager has its own configuration file and the readme tells you to put a local directory on your path. The project generator contributes two source-of-truth files and a generation stamp directory. The package resolution is listed among the inputs that trigger regeneration. The terminal library is the thing that needs the pinned compiler. And the requirements list recursive submodule initialisation, with a recursive clone in the quick start, plus a patches directory and directories for third-party code, frameworks and binaries.
The quick start is five lines and every one earns its place. Recursive clone, change directory, install the pinned toolchain, run the diagnostics, then build and launch the debug application. There is no script that hides any of it.
An issue before a pull request, and a human as the accountable author
The contributing policy is stated more firmly than most projects bother to state theirs.
Contributions are reviewed personally, line by line. A clear issue is worth more than a large pull request, which is a direct instruction not to arrive with a thousand lines. The process is: open an issue, wait for a label saying it is ready, then open a focused pull request that links it. So the issue tracker is a queue, not a suggestion box, and a pull request opened before the label is out of order.
The clause that will catch people's attention is the last one. The contributing guide contains a rule that a human, and never an AI agent, is the accountable author. That is stated plainly, in parentheses, in the readme's own summary.
It is worth setting beside what the software does. This is an application whose purpose is running three coding agents in parallel, which it detects by installing hooks and badges live as busy, awaiting input or idle, and whose sidebar sorts the worktrees that need you to the top. The tree also carries three separate instruction surfaces for assistants. None of that is in tension with the rule, and the rule is about authorship of a commit rather than about what the tool runs. But a project built on agent orchestration, stating a human-authorship requirement as its contribution gate, has made a deliberate choice about where the accountability sits, and it has written it down.
Editorial conclusion
This is worth trying if you run several agents at once on a Mac and have been managing worktrees and terminals separately, because the per-task worktree plus a persisted session is the combination that makes parallel work survivable rather than merely possible. Three things to know before you commit. It needs a specific older IDE installed alongside your current one, which is a real prerequisite rather than a suggestion. The newest tag by date is a nightly from February rather than the August release, so anything that installs the most recent release automatically will get the wrong thing. And contributions are gated behind an issue label with a human named as the accountable author, so plan for that review loop rather than assuming a pull request is the first move.
Frequently asked questions
how to use supacode
Supacode is a native macOS command center for running several coding agents in parallel. Each task gets its own git worktree and its own real terminal, and a worktree can be created from the sidebar, a hotkey, the command palette, a command-line tool, or a deeplink. Sessions persist in the background so quitting the app loses nothing.
is supacode good
The requirements narrow the answer. The README states macOS 26.0 or newer, a pinned toolchain manager, initialised git submodules, and a specific older Xcode on the newest macOS point releases. Within that, sessions are rendered by a third-party terminal library and persisted by a session daemon, and remote SSH repositories are labelled beta with some local-only features reduced.
What are Supacode's system requirements?
macOS 26.0 or newer, a toolchain manager installed with the user's local bin directory added to the path, git submodules initialised recursively, and Xcode 26.3 if you are on macOS 26.4 or later.
Why does the Supacode build fail with undefined symbol errors on a new macOS?
Because the embedded terminal component is built from Zig source with a compiler version pinned by that component, and that compiler cannot link against the SDK shipped with the newer macOS point release, which dropped a slice from the system library stub. The build needs the older Xcode, which it detects and pins for that build only rather than switching your global developer directory.
How does Supacode keep sessions alive when I quit the app?
Sessions run inside a separate lightweight session daemon rather than as children of the app, so they reattach on relaunch with scrollback intact. Over SSH, the same daemon running on the remote host is what makes a dropped connection or a sleeping laptop retry and reattach instead of restarting the session.
How do you contribute to Supacode?
Open an issue first and wait for the ready label, then open a focused pull request linking it. The project says contributions are reviewed personally line by line, that a clear issue is worth more than a large pull request, and that the accountable author must be a human and never an AI agent.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/supabitapp-supacode)Star history chart for your README
[](https://hysenlabs.com/projects/supabitapp-supacode)Was this useful?