Your Mac has connections.

Think Big.
Stack small.

Your next idea shouldn’t wait for a test suite. Send reviewed checks to spare Macs. Keep your editing Mac for what’s next.

In development · Apple silicon · macOS 26 or later

Your editing MacRoom to think.
Your spare MacsReady for the heavy lifting.
A little less waiting. A little more making.

Think outside the box.

Put the other boxes to work.

Choose a reviewed check. Save your files. Let another Mac run it. Every result records exactly which saved files it checked.

Your filesCaptured from disk
Your checksReviewed by you
Your MacsWorkers you choose

One check. A clear path.

Keep your flow. Move the work.

You choose the check. Stackintosh moves the saved files. The result keeps the record.

Workflow illustration · Each check runs on one worker.

01 / Choose

Your checks. Your say.

Choose a named check from a configuration you reviewed. The executable, arguments and environment are explicit. Stackintosh runs that profile; the source project never chooses the command.

Type checks, linters, tests. The tools you already use.

02 / Send

Save. Send. Keep creating.

Save your files. Stackintosh captures the saved work—including uncommitted changes—and sends the snapshot objects a configured worker needs over SSH. The check gets its own workspace. You keep yours.

Your worktree stays yours. Unsaved editor buffers aren’t included.

03 / Follow

Every result. The exact files.

Follow the output in the app or terminal. Each result identifies the saved files it checked. You and your coding agents can follow the same run, and closing a client doesn’t stop accepted work.

Later edits don’t rewrite the result. Save and run again to check them.

Spare capacity. On your terms.

Room to run. Rules you choose.

Workers check their available slots, memory and current conditions before admitting work. When a required reading is unknown, the check waits.

Your editing Mac comes first.

Heavy checks stay off the editing Mac by default. You can explicitly approve one queued check to run there, one at a time.

Room first. Then run.

Fresh capacity readings and your configured power, thermal and memory rules help decide when work can start.

No connection. No assumptions.

A worker going quiet doesn’t prove its check has stopped. Stackintosh marks the attempt unknown until it can reconcile what happened.

One check, one worker. Stackintosh does not pool memory, move running processes or distribute an AI model.

AI workflows. A hardware-aware stack.

Know your stack. Choose your muscle.

The right work deserves the right hardware. See the NVIDIA, AMD, Apple and Intel GPUs your workers report, the drivers behind them, and the capacity available for your reviewed checks.

Apple
NVIDIA
AMD
Intel

Conceptual silicon illustrations. Hardware and driver reporting depend on the host.

See it. Match it. Reserve it.

Detected GPUInstalled driverServing driverReviewed profileOne device. One check.

Illustration · Matching a GPU to one reviewed check.

See the GPU kind and the drivers the worker reports. Installed and serving are different states.

Driver reporting and matching details

See the GPU, its name, and every driver the worker detects—including which one is serving it. Metal appears when detected. Tiny CPU readiness depends on a supported architecture and an available clang or LLVM toolchain. Driver installation stays with you.

Your coding agents can run the same reviewed checks you do. A profile can request a GPU kind and, optionally, a serving driver. Stackintosh reserves a matching device. If none is available, that check waits while other eligible work can continue.

More workers. Separate checks.

Editing Mac + serviceConfigured workers

Illustration · Independent checks, each running on one worker.

Worker capacity and compatibility

Start with a spare Mac. Configure up to 255 remote workers. Stackintosh tracks capacity and routes independent checks to available workers. Each check runs on one worker, using that worker’s CPU and memory.

Workers must match the coordinator’s operating system and architecture. GPU detection alone doesn’t establish workload or compute-backend compatibility.

At home on your Mac.

One service. Every way you work.

A native Mac app for projects, reviewed checks, workers and results. A command line for your terminal and coding agents. One service keeps the work together.

A service that stays with the work.

The app, command line and Swift clients talk to the same service. Your checks can keep running when a client closes.

An explanation, when you ask.

On supported Macs, request an Apple Intelligence summary of finished output. Processing stays on that Mac; the original log and recorded result remain authoritative.

Shortcuts that fit your day.

Create custom Mac shortcuts for Run Reviewed Check, Check Status and Show Workers, then ask Siri to run them by name.

A little setup. More breathing room.

Start with two Macs. Make room for more.

Stackintosh is in development. Start with the source and setup guide; a public app download is not available here yet.

  1. Choose your Macs.

    Use an editing Mac and one or more compatible workers. Install the matching service and the tools your checks need on each worker.

  2. Make the connection.

    Verify SSH host identity and name your workers in macbridge.toml. Bonjour can find nearby candidates; pairing is configured manually.

  3. Review, save, run.

    Register a Git project, review its allowed check profiles, save your files and submit a check. Follow the output while you keep working.

A few things to know.

Does this combine the memory of my Macs?

Each check runs on one worker with that worker’s CPU and memory. Stackintosh does not combine memory, migrate a running process or move your IDE’s language server. Distributed model inference is a separate future plan, not a current feature.

Do I need to commit before running a check?

No. Checks use saved files on disk, including staged and unstaged changes and untracked files Git does not ignore. Unsaved buffers aren’t included. Ignored inputs are included only when the reviewed task profile explicitly lists them. Unsupported repository layouts are refused.

Can a check still access the network?

Yes, depending on the reviewed command and its environment. A command, dependency or tool can make its own network requests. Use trusted workers and profiles, and review what your tools can access. Stackintosh does not make an arbitrary command a network-isolated sandbox.

Why is the app connected but my worker unavailable?

Connected describes the app’s connection to the service on the same Mac. The separate Ready status in Workers describes a worker’s availability. Confirm the configured host, SSH trust, matching service, tools and capacity readings. A nearby Mac is only a candidate until configured.

What if the app cannot reach its service?

Open Settings and check Background operation. Enable it if needed, approve any macOS request in System Settings, then choose Check again. Folder allowances for projects, tools and SSH key files apply when the service next starts. Let accepted work finish before restarting.

Where does my source code go?

Snapshots stay in the service’s local state and are transferred over SSH to workers you configure. Check results and output are retained there according to configuration. The current app has no developer-operated source upload or analytics service. Review the privacy draft for data flows, retention and your choices.

A human on the other end.

Great ideas deserve a little backup.

Need a hand with setup or a check that won’t start? Send your app and macOS versions, the status you see and the relevant error.

Email Brandon

Please remove private source code, passwords, SSH keys and tokens before sending.