A workspace for Claude Code, Codex and the other coding agents, on the Mac or Linux box you leave on.
Treacle is a visual layer over the coding-agent sessions on your Mac or Linux box. Every worktree and every session on one screen, a lamp that says who is working and who is waiting, and the questions as cards you answer in place. tmux and git worktrees underneath, so nothing is hidden from you. A Chrome app at the desk, the same app on your phone, so nothing is tied to a device.
Treacle is a visual layer over the coding-agent sessions on your Mac or Linux box. Every worktree and every session on one screen, a lamp that says who is working and who is waiting, and the questions as cards you answer with a tap. tmux and git worktrees underneath, so nothing is hidden from you. The same app you use at the desk, on the phone in your pocket.
$ curl -fsSL https://treacle.dev/install | sh
macOS on Apple silicon, or Linux on x64 or arm64. Needs tmux and an agent you already run. Self-hosted, one signed binary, no account; the installer checks its checksum and signature before it lands. Then treacle setup on the machine that stays on.
Prefer a Mac window to a Chrome tab? Treacle for Mac is the same app in its own window, signed and notarized. Install it on any Mac and pair it from Host → add a device.
See everything. One worktree per ticket, one agent per worktree, and you are cycling through six tmux windows to find the one that stopped. Treacle puts them on one screen: a lamp per session, a subject line per worktree, the ticket and the PR, how much context and quota is left. The sessions waiting on you go to the top, with the question and its options as buttons.
Keep control. Every card has a box for answering in your own words. The mode chip cycles plan and auto. Send becomes stop while the agent works. Deleting a worktree with uncommitted changes makes you type CLOSE. And the raw tmux pane is one clicktap away, because it is the same pane: quit treacle and your shells are exactly where you left them.
Any device. Install it as a Chrome app and it lives in the Dock with a badge that counts the inbox. Open the same address on your phone and it is the same app, with push notifications for when you are away from the desk. Served from your own Mac; the phone pairs with it and talks over a sealed link, so nothing in between can read it.
Any device. Add it to the home screen and the icon counts the inbox; a push finds you when a session needs you. Back at the desk it is a Chrome app in the Dock, the same app at the same address. Served from your own Mac; the phone pairs with it and talks over a sealed link, so nothing in between can read it.
The same session, twice. On the left, what tmux shows. On the right, what treacle shows: tool calls as one-line rows, edits as real diffs, the agent's reply as rendered markdown, and the question as a card you can answer. Both are live. Type in either and the other follows.
Claude Code's hooks tell treacle the instant a session is waiting on you, so the lamp flips to needs-you before you would have noticed in the terminal. The question lands in the inbox with its options as buttons, and as a push notification with the same buttons if the app is closed.
Start a session with TREACLE_REMOTE_PERMISSIONS=1 and gated shell commands arrive as an Allow or Deny card with the full command shown. Ignore it and the terminal prompt takes over after two minutes, as it always did. Nothing is ever auto-approved.
An agent can also ask on purpose. Over MCP it can put up a choice, or a whole proposal with Approve and Reject, and block until you answer. Dismiss the card and it is told it was dismissed, not answered.
bun test packages/web
Split the folders table. Move quiet-folder state into its own table so a collapse never rewrites a repo row.
Two migrations, both reversible. No data moves.
Name a branch the Linear way and the session links its ticket, with the ticket's title and status once you add an API key. The PR comes from gh and shows its checks and review state. A plan the agent publishes pins under the header and ticks off in place as it works.
The strip at the bottom is the part you usually have to squint at: the model, the account, how many files changed and by how much, how full the context is, and how much of the five-hour and seven-day usage windows is gone. It turns amber past 80%.
Cursor-true tmux mirroring over control mode, in the same window. Select, Paste and Copy for the things a browser is bad at, and a key bar for esc, tab, the control keys and the arrows for when there is no keyboard. Interactive commands open here on their own. It is the same pane you would attach to from a shell, so nothing treacle shows you is a summary of something you can't see.
Cursor-true tmux mirroring over control mode. A key bar for esc, tab, the control keys and the arrows, because a phone keyboard has none of them. Select, Paste and Copy for the rest. Interactive commands open here on their own. On an iPad with a keyboard it is a place you can work from, not just check on.
The status line at the bottom is Claude Code's own. The key bar underneath is treacle's, and matters most on a tablet.
A session is a conversation. A task is a thing that has to be finished. The board holds the second kind, and it will not take a wish: every task needs a definition of done and, ideally, a command that proves it. Flip between sessions and board with one button in the header.
ClickTap start on a ready task and treacle creates a worktree from the base ref, writes the brief to .treacle/task.md, launches the agent you chose and sends the opening message. Watch it in the session feed or go and do something else.
The agent reports back over MCP: a note, a link, or done. Done runs the task's check command in the worktree and moves the task to review, where it waits for you with the evidence and a diff against base. Accept, or send it back with a reason.
Tasks can wait on other tasks, be blocked with a reason, and be given grants: things the agent may see. The board runs left to right: proposed, next up, in progress, needs you, blocked, done today. On a phone it is one list, most urgent first, and a card opens its session while the pane is still there.
Open a task and you get what it is for, what would count as finished, the check that proves it, and every attempt with what it produced. The changes tray shows the files against base with a diff you can unfold.
Drafting one takes a title, a done-when, an intent, a check command, an agent and a base ref. The hint under done-when says it plainly: the board is not for wishes.
Every registered repo lists its worktrees as cards with a colour, the branch, the ticket and PR pills, and a one-line subject a small model writes about what is going on in there. Tabs are tmux sessions, busiest first, each with a lamp. Merged work shows purple at a glance.
Add a worktree with a branch name and a base. Add a tab with Terminal, Claude or Codex, and pick the account if you have more than one. Codex sessions get a feed and question cards of their own.
Deleting refuses while anything is running or uncommitted in there, says which, and makes you type CLOSE to override it. Folders with nothing going on for a day fold away behind one row.
The feed is where most of the day goes, so most of the small things live there. None of them hides the pane: each one is a shortcut for something you could also do in the terminal.
Every message has a fork button. The conversation up to that point becomes a new tab, here or in a new worktree cut from main. The original transcript is only read.
The changes sheet opens a hunk's whole file with the added lines marked. ClickTap a line to comment; the comments go back to the session as one message, each naming its file and line.
"→ main" on a branch worktree lists the commits main does not have, lets you pick, and cherry-picks them onto a clean main. A conflict leaves main as it was. Nothing is pushed.
A preset is an agent, an account, a model, an effort and a permission mode under one name. It sits at the top of every launch sheet. The server expands the name, so nothing typed on a phone reaches the shell.
Add a second Claude or Codex login from the app. For Claude accounts, the sidebar shows each one's live 5-hour and 7-day headroom, the picker starts on the roomiest, and when one hits its limit a card offers the others and resumes the conversation there.
An agent idle for two hours, with nothing uncommitted and nothing running, quits to free memory. The tab and the conversation stay, and opening it or sending it a message resumes it. The three most recent stay warm.
Sub-agents a session launches get a strip of their own: what each is doing now, its calls and tokens, and its transcript as a feed. The session says working until the last one finishes. A Workflow run gets its phases as a stepper.
Plans and docs an agent writes or shows open in a reader you can copy from or save. Images, HTML reviews, audio and video it points at render in place. Dev-server previews show inline and go full screen when asked.
A command Claude suggests runs with one tap. A finished turn that hands a decision back offers its options as replies. A queued message can be sent now without cancelling what is running.
Paste an API key into a message and the treacle mod stores it in the Keychain and passes Claude a placeholder. Claude uses it through a tool that hands the value over on stdin, and tool output is scrubbed of it.
Hold the mic and speak. whisper.cpp on your Mac transcribes it, or add a Deepgram key and words stream in as you say them. + uploads photos, files and video up to 2GB to the host.
"+ term" opens a shell in the session's worktree, split beside the feed or under it. Every pane boundary drags. The worktree's other tabs switch in place.
"+ term" opens a shell in the session's worktree, one tap from the feed. The raw pane of the agent itself is behind "term" in the header.
The desk is one Claude Code session treacle keeps for itself, outside every worktree. It reads the board and the live sessions, tells you what matters, and drafts tasks for work that is missing. It starts nothing, types into nothing and closes nothing without a card you answer. Asking it in plain words counts as answering.
On a clock you set, the desk reads the board and writes a digest. It leads with the one thing to do next, adds at most three more, and sends nothing when nothing has moved. Snooze an item until Monday, or mark it known until it changes.
Loose ends arrive on one tidy card with a tick per item: a review task whose PR merged, a run that has gone quiet for days, a merged worktree nobody removed, an old draft. Each is checked against the board again before it runs.
It names sessions, tasks, PRs and Linear tickets as links you can open. On a desktop its chat sits on the right of the desk view, beside an overview, the board or the host, whichever you switch to.On a phone the desk tab switches between its chat, an overview, the board and the host.
Each of these is off until you turn it on. The docs have the setup for every one.
treacle slack connectTalk to the desk from a Slack channel. One bot token, no public address: the host polls the channel. Setup opens a prefilled app manifest, picks the channel and waits for you to say something, so only you reach the desk. Digests post the most blocking item, with reply words (accept, close, snooze, more) and quiet hours.
scheduled jobsAn instruction to the desk plus a daily time, some weekdays, or an interval. Set them from the board's scheduled fold or by asking the desk. A job never types into the desk mid-turn; it waits up to 30 minutes, then tells you it gave up.
/hooks/linear · /hooks/githubA new Linear issue, a GitHub review request, a failed Actions run or a new GitHub issue can draft a board task or tell the desk in one line. Every call is signature-checked, replays are dropped, and the event text is marked as untrusted wherever it lands.
hostA minute-by-minute record of memory, swap, CPU and disk on the Mac, with each process attributed to the session that started it. One push when things get tight, another when they recover. Suggestions, such as removing merged worktrees or clearing a cache, come as cards and are re-checked before they run.
second opinionWhen a task reaches review, a different agent reads its diff read-only and pins its concerns to the card, each with a severity, file and line, and sends them to the session that wrote the change to act on. Codex reviews Claude's work and Claude reviews Codex's, by default. Nothing waits on it.
⌘⇧DDelegate. The selection or clipboard becomes a task, drafted, promoted and started from the worktree on screen, after one confirm sheet. The Dock menu has "Delegate from clipboard" too.
task model and skillsA task can pick its model, carry screenshots into its session and grant it global skills. When its work lands, its worktree is offered for removal.
An agent is a set of instructions you write once and run whenever you want: a dependency sweep, a release-notes draft, a triage pass over new issues. Each run is a real session in a worktree of its own, or in a scratch folder when the agent works on no repo, so you can open it, watch it and stop it like any other. A Claude Code or Codex run ends by filing a report, which goes to the desk, your phone or both, as you set it.
The Agents page shows what is running, what ran in the last day and what failed, with a red line at the top for any agent that is paused or whose last run failed. A run waiting on you is marked in its row. Each agent has its trigger, what it runs as, its last fourteen runs as a spark, and when it last went.
Open one and its definition reads as one sentence of pickers: which agent, which account, how much it may do on its own, which repo, where its output goes, and for Claude Code which model and how hard it thinks. Under that are the instructions, with {{variables}} filled in at run time.
Every save is a new version and every run records the version it ran, so "it worked last week" is something you can check. Run it from the page, and ask the desk when you want a one-off of its own.
A run starts the way a board task does: a worktree of its own (or a scratch folder for an agent with no repo), the agent CLI you picked, and a brief it reads first, kept out of git. Open its session, stop it or rerun it, and read its diff when it ran in a worktree.
A Claude Code or Codex run ends with agent_report: an outcome, a summary and links. A run that times out, ends a turn without reporting, or loses its session is marked as such by a supervisor, never left looking busy.
Whatever a run is handed goes into its brief as a fenced block of data the input can't break out of. An agent only gets the grants you gave it, such as web access, and nothing that asks is pre-allowed.
A run uses the launcher you choose and its account, and on Claude Code its model and effort too. Beyond Claude Code and Codex, treacle's sessions take Gemini, OpenCode and Copilot through the Agent Client Protocol, each with a timeline, a status lamp and its permission asks as cards.
Ask the desk for something that doesn't belong to a repo, like a check across every project, and it runs it as a one-off and hears the report when it lands.
The Agents page is a tab on the phone. A run that needs you sends a push like any session, and an agent set to report by push sends its report as a notification you can open.
Every session used to start from nothing. Now a Claude Code session in a project you have filed under a context (personal, work or a client) starts with a short brief of what was decided and learned there, and looks up the rest as it needs it. The memory is a folder of Markdown notes on your own machine, and nothing goes into it until you say yes.
The vault lives in ~/.treacle/memory: plain Markdown with [[wikilinks]], so Obsidian opens it as it is. Notes link to the project they belong to, the decision they rest on, and the note they replace, and sessions walk those links when they need more than the brief.
A session can offer what is worth keeping: a decision and why, a fact about the project, a preference you stated. When a board task finishes, treacle also reads its conversation and drafts offers of its own. Each offer is a card. Yes files it, no drops it.
Notes are kept by context: personal, work, and one per client. A session sees the general notes and its own context, never another client's. Offers are checked for keys and tokens, and one that looks like a secret is refused. The check is best-effort, so the card is still where you catch anything else.
It is one web app on your own machine. Chrome installs it as a desktop app with its own window and a Dock badge, Treacle for Mac gives it a native window, and your phone adds it to the home screen. They all reach the same server, through your own Cloudflare domain or your tailnet, so you can pick up on one exactly where you left off on another.
On the phone, the whole app. The inbox and its buttons, every session's feed, the board, worktrees, the terminal. The compose box types straight into the pane, so iOS dictation just works, and a mic button sends audio to whisper.cpp on the host.
A push finds you, and only when it should. Web Push from your own host, only while the app is closed, only for a session flipping to needs-you, a decision opening, or an agent calling notify. It carries the question and its options. Tapping it opens that session. While the app is open it chimes instead.
Talk to it. Tap the mic, speak, tap again, and the words land in the compose box for a glance before you send. Audio goes to the host over the sealed link and whisper.cpp transcribes it there. One command installs the model.
At the desk, a Chrome app. Its own window next to your editor, no address bar, the same inbox and feed and board. Wider, so the worktree cards carry their actions and the terminal view has room.
In the Dock, with a badge. The icon counts the inbox the same way the phone's does, and Chrome delivers the same push notifications when the window is closed.
One click to install. The icon at the end of Chrome's address bar. No download, nothing to update by hand: the app updates itself whenever the server does.
The app, the board, the desk's conversation and each session's recent history are kept on the device. A cold open draws your last screen at once, dimmed, and the live state replaces it as the host answers, without moving where you were reading or losing what you were typing.
The same app in a Mac window of its own, signed and notarized. It pairs from Host → add a device and reaches the host over the same sealed link a phone uses, so it works from anywhere, not only on your network.
A phone or a laptop pairs once with a QR and then talks to the host over a sealed link through your own Cloudflare domain. The route in between only ever sees ciphertext, and the app is never on the internet.
The Mac you sit at doesn't have to be the only one doing the work. Join a Linux server or a second Mac to it, and its sessions show up in the same window, grouped under its name.
treacle joinPairs another machine with this one over a sealed link, through the route this host uses: your Cloudflare domain or your tailnet. The route is checked end to end before the join command is shown. A joined machine that falls behind this one's build is marked behind, and treacle hosts update brings it up to date.
Linux, x64 or arm64The same signed binary for Linux, running as a systemd user service that leaves tmux and every session alone across restarts and updates. The installer checks its signature before it lands.
one window, every machineFolders and the left navigation group by machine, and you can start a tab on any of them from the app. The host page reads memory, swap, load and disk on Linux as on a Mac, with health ratings sized to the machine.
Setup is a walkthrough, not a checklist. It ticks off what it can do itself, asks about the two things that edit Claude Code's config, and does not call the host reachable until a device of yours has actually loaded the app. Re-run it after every update; it only changes what changed.
One file. It is the server, the CLI, the MCP server and the hooks. The installer puts it in ~/.treacle/bin, links it into /usr/local/bin when it can, and otherwise adds it to your shell's PATH once.
treacle setupSix things happen on their own: an access token, a tmux config, the web app, and a background service (launchd on a Mac, systemd on Linux) that keeps the server up across reboots. Then it asks which repos to manage and whether to wire up Claude Code. The last step is the only one that can fail, and when it does, setup walks you through fixing it.
The way in from your phone comes last. With your own Cloudflare domain, setup signs you in to Cloudflare, makes one tunnel and one DNS record, and you get an address that never changes. Without one, a temporary address works until the Mac restarts. Already on Tailscale? That works too. Either way it ends with a QR: scan it and the phone pairs. If the Mac you are sitting at is the host, you can skip this and open it on localhost.
Setup ends with the URL, the token, and a QR code that carries the token in the URL fragment, so the token never reaches an access log and there is nothing to type on a phone. Then it waits, for up to two minutes, until a device of yours has loaded the app, and names the device that did.
In Chrome, the install icon at the end of the address bar puts Treacle in the Dock with its own window and a badge that counts the inbox. On the phone, Share then Add to Home Screen does the same. ClickTap the bell in the header once to allow notifications. The app updates itself whenever the server does.
Chrome on the Mac: one click, its own window, a Dock icon.
Safari on the phone: Share, then Add to Home Screen.
Bell on. The first session to stop shows up here.
TREACLE_REMOTE_PERMISSIONS=1 claudePer session. Gated Bash calls become Allow or Deny cards in treacle, with the command shown in full.
treacle voice installDownloads the whisper.cpp base model, about 148MB, into ~/.treacle/models. Needs ffmpeg and whisper-cpp from Homebrew.
treacle updateChecks treacle.dev for a newer build and installs it, hash and signature verified. The previous binary stays for treacle update --rollback.
treacle doctorSays where every step stands, including which route your phone uses to get in and whether any device has reached the host.
~/.treacle/config.jsonAdd linearWorkspace and a personal linearApiKey and ticket pills show the ticket's title and status.
Treacle is a single Bun binary that owns a tmux server and the git worktrees under the folders you register. Agents run in tmux panes it created. The app talks to it over WebSockets and REST with a bearer token, on localhost, inside your tailnet, or from a paired phone over a sealed link. Nothing needs installing beyond it (Treacle for Mac is optional), and there is no server of ours.
One binary, one directory. The server, CLI, MCP server and hooks are the same executable. State lives in ~/.treacle.
Survives the things that happen. Restart the server and the tmux sessions are still there; the app reconnects and the timeline replays from SQLite.
Honest lamps. With hooks, a lamp flips to needs-you the moment Claude waits. Without them, the pane heuristics still give you working and idle.
Subject lines by a small model. Each active worktree carries one line about what is going on, written from the newest session, refreshed at most every half hour.
Files in. The + in the compose bar uploads a photo or file to the host and types its path into the prompt. You press Enter.
Previews out. An agent can proxy a dev server on the host into the session feed as a capability URL that lives for about six hours.
Several good tools run coding agents in parallel or put them on your phone. They make different bets. Here is where each one stands, from their own documentation, as of October 2026.
| Treacle | Claude Code Remote Control | Conductor | Vibe Kanban | Claude Squad | Happy | |
|---|---|---|---|---|---|---|
| What it is | A web app over the tmux and worktrees on your Mac or Linux box | Anthropic's way to continue a local Claude Code session from the Claude app | A native Mac app for parallel agents | A kanban board that runs agents, in the browser | A terminal UI over tmux and worktrees | A mobile and web client that wraps the agent CLI |
| Agents | Claude Code, Codex; Gemini, OpenCode and Copilot over ACP; anything else in a terminal tab | Claude Code | Claude Code, Codex, Cursor, OpenCode | Claude Code, Codex, Gemini CLI, OpenCode and more | Claude Code, Codex, Aider, Gemini and more | Claude Code, Codex |
| Every session on one screen | Yes, grouped by repo and worktree, with an inbox of what needs you | A list; one session at a time | Yes | Yes, as cards | Yes, in the terminal | A list; one session at a time |
| A worktree per task, made for you | Yes | No | Yes | Yes | Yes | No |
| Sessions are tmux panes you can attach to | Yes, on a tmux server treacle owns | No | No | No | Yes | No |
| Answer questions and permissions from a phone | Yes, as cards, with push | Yes | No | No | No | Yes, with push |
| A task board | Yes: a definition of done, a check command, review with a second opinion | No | Workspaces with a diff to review and merge | Yes: cards move the agent through the work | No | No |
| An agent that watches the rest | The desk: digests, Slack, scheduled jobs, webhooks; plus agents that run on their own and report | No | Not documented | Exposes the board over MCP to other agents | No | No |
| How a phone reaches it | Paired with your Mac, end-to-end sealed, through your own Cloudflare domain (or your tailnet) | Through Anthropic's servers | Not built for it | Not built for it | SSH | Through Happy's end-to-end encrypted relay |
| Host | macOS (Apple silicon), Linux (x64, arm64) | Wherever Claude Code runs | macOS | macOS, Linux, Windows | macOS, Linux | Wherever the agent CLI runs |
| Source and price | Free binary, source closed | Part of a Claude plan | Free locally, paid cloud workspaces | Open source, community-maintained since 2026 | Open source | Open source |
● yes ◐ partly ○ no. These tools move fast. If a row is out of date, tell us and it will be fixed.
Pick Remote Control if you run one Claude Code session at a time and want to keep it going from the Claude app, with nothing to install.
Pick Conductor if you want a native Mac app at the desk for parallel agents, including Cursor's, and do not need them on your phone.
Pick Vibe Kanban or Claude Squad if you want open source, a Linux host, or a board or TUI you can change yourself.
Pick Happy if you want one agent session on your phone from any OS, and are happy with a relay in the middle.
Pick treacle if you run several agents at once on a Mac or Linux box that stays on, and want them on one screen at the desk and on your phone. You get a board that holds work to a definition of done, and the real terminal stays one tap away.
No. Most days it is a Chrome app in the Dock next to your editor. The phone is the same app at the same address, which matters when a session needs you and you are not at the desk. Nothing about it needs a phone.
No, it sits on top of it. Every tab is a tmux session on a server treacle runs, and the raw pane is one clicktap away in the app or one attach away in a shell. Anything the app cannot express, you do in the pane, and the feed catches up.
No. The server runs on your own machine, your devices reach it over localhost, your tailnet, or a link sealed end to end with keys only your phone and your Mac hold, and treacle.dev serves this page and the download. The phone's route runs through your own Cloudflare account (or a temporary Cloudflare address), which carries ciphertext; it sees that your phone and Mac talk, and when, not what they say. The page the phone opens first is served through that route too. Push notifications travel through the browser vendor's push service, encrypted end to end as Web Push requires; the payload is opaque to anyone but your device. A second machine joined to your desk talks to the host over a link sealed end to end with keys only the two machines hold, so the tunnel that carries it, Tailscale Funnel or Cloudflare, sees ciphertext. The integrations you can turn on talk to their own services only once you connect them: Slack for the desk's channel, Deepgram for streamed dictation, and Linear or GitHub sending webhooks in, which needs a public route such as tailscale funnel. Your agents talk to their model providers as they always do.
treacle update asks treacle.dev for a newer build and installs it. The download is checked against its published hash and its signature before it replaces anything, and the previous binary is kept, so treacle update --rollback puts it back. The app shows a one-line banner when a newer build exists; on the phone, updating is one tap. "updates": "ask" | "auto" | "off" in ~/.treacle/config.json decides what happens. ask, the default, tells you and waits. auto installs it and restarts the server, but only when no agent is mid-turn. The check is a GET for a public file on treacle.dev that carries no token or identifier, and off turns it off entirely.
No. On the host itself it works on localhost with no network setup at all. To reach it from your phone, setup offers your own Cloudflare domain first (a free account and a domain; the address never changes), then a temporary address that needs nothing, then Tailscale if you already use it. No ports get opened on any of them: the Mac dials out, and only its pairing door is reachable.
Claude Code gets the most: status hooks, permission cards, the MCP tools and the transcript-backed feed. Codex sessions have a feed and their questions become cards. Gemini, OpenCode and Copilot run through the Agent Client Protocol, with a timeline, a status lamp and their permission asks as cards. Anything else runs in a plain Terminal tab with the raw tmux mirror. With both installed, each one gives a second opinion on the other's work when a task reaches review.
On the docs page: every command, every config.json key, the MCP tools agents get, the webhook formats, and the limits. The source is closed, so the docs are the reference.
Every card has an "answer in your own words" box, and the compose bar types into the pane. A multi-part question opens in the session and is answered part by part. Interactive commands open the terminal instead.
After two minutes, or if no treacle client is connected, the normal terminal prompt takes over. Nothing is auto-approved. Dismissing a question tells the agent it was dismissed, not answered.
Linux, yes: x64 or arm64, a cloud VM or a Raspberry Pi on a 64-bit OS, as a host or as a machine joined to your desk. It runs as a systemd user service, and keys you paste are kept in a file only your user can read instead of a keychain. Intel Macs, no. Windows, through WSL 2 with systemd turned on; there is no native build. The client side is any browser that can install a web app.
Nothing. Treacle is free to use, personal or commercial, on machines you own or administer. The source is not open and the binary may not be rehosted. Point people here instead.
Your code never leaves your machines, because there is nothing for it to leave to.
Treacle has no backend, no accounts, no telemetry. treacle.dev serves this page and the download. That is everything it can see.
$ curl -fsSL https://treacle.dev/install | sh