Turn every computer you have, or that friends share with you, into one cloud.
Free · open source · public domain · every OS
Website · Get started · Documentation · Roadmap · Issues
Most computers sit idle most of the day. sys1 pools that spare power (CPU, memory, disk and GPU) from all your machines into one place, and runs websites, media servers, backups, AI models, game servers and more on it. You control everything from one dashboard.
It comes as two apps, everywhere:
| App | What it is | What you see |
|---|---|---|
| sys0: the client | Installed on every machine that lends its spare power. Runs at the lowest priority the OS offers, so your apps and games always come first. | A friendly graphical installer, then nothing: it disappears into the background. |
| sys1: the node | The hub machines join. It schedules work, moves it when machines go away, and hosts the marketplace. | A full dashboard, all the time. It's the input and output for the whole pool. |
┌─────────┐ ┌─────────┐ ┌─────────┐
│ sys0 │ │ sys0 │ │ sys0 │ every machine, every OS,
│ Windows │ │ Linux │ │ macOS │ lowest priority, invisible
└────┬────┘ └────┬────┘ └────┬────┘
│ TLS 1.3, pinned certificate │
└─────────────┬───────────────┘
┌────┴────┐
│ sys1 │ ← dashboard, marketplace, scheduler,
│ node │ crash-safe journal, GitHub + Cloudflare
└─────────┘
- ✅ Joins machines in one paste. The node shows two join codes, one for your own machines and one to share; paste one into the sys0 installer.
- ✅ Lowest priority on every OS.
nice 19+ idle I/O on Linux, background QoS on macOS,IDLE_PRIORITY_CLASS+ background mode on Windows,nice 19on BSD/UNIX. Containers get the minimum CPU weight too. - ✅ Places work on the best machine by spare CPU, memory and GPU, and skips busy machines and laptops on battery.
- ✅ Watchdog. Crashed apps restart with backoff. After 5 crashes in a row it stops, uploads the app's fast-saved checkpoint to the node, and the node moves the app to another machine, which resumes from that checkpoint.
- ✅ Machine goes offline? Its work is resent to a replacement within ~15 seconds, with the cached checkpoint.
- ✅ Pooled storage. Spare disk on every machine becomes one encrypted store. App data is snapshotted every minute and moves with the app to a new machine; folders are backed up with N copies on different machines and restore anywhere. Machines holding copies can't read them, and lost copies are re-made automatically. See Storage.
- ✅ Batch jobs and AI across machines. Split work into N pieces spread over the pool, with results collected into one folder; run one AI model split across several machines (llama.cpp); schedule by free GPU memory on NVIDIA, AMD, Intel and Apple. See Batch jobs, groups and GPUs.
- ✅ Internet-scale. Machines join from anywhere: join codes carry every address, and the node can open its own port on your router. Run 3 nodes as a cluster and any one can fail. Pieces of work can be checked on several machines, and apps on machines lent by others reach only the websites they declare, never the lender's network. See Clusters and the security model.
- ✅ Virtual machines and desktops. Whole operating systems as apps (QEMU, hardware-accelerated), whose disks move with them; their screens open in the browser. A Linux desktop in the browser, and an experimental game streaming host for Moonlight. See VMs, desktops and gaming.
- ✅ Fast save. The node's state and each client's undelivered results live in an fsync'd, checksummed write-ahead journal. Pull the plug at any moment and nothing acknowledged is lost.
- ✅ Marketplace with Jellyfin, Plex, Audiobookshelf, Ollama (AI), Syncthing (backups), websites, Cloudflare Tunnel, GitHub Actions runners, any container… and it only offers what your connected machines can actually run.
- ✅ Signed packages. Third-party packages must be Ed25519-signed by a key you chose to trust.
- ✅ Safe for strangers. Machines shared by other people only run hardened, sandboxed containers. Native programs run only on machines whose owner said "this is mine".
- ✅ Builds for 21+ OS/CPU combinations from one codebase: Windows, macOS, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, Solaris, illumos, AIX, Android…
- ✅ Phones and tablets: an Android app (lends only while charging and idle), a Magisk module, a sideloaded iPhone/iPad app and a jailbreak package. Never the App Store.
See the roadmap for what's next (automatic updates, crash reports, integrations…).
1. Start a node on the machine that will be the hub:
sys1The dashboard opens in your browser. That machine is already part of the pool.
2. Add more machines. Install sys0 on each one and paste a join code from the dashboard's Add a machine tab: one for your own machines, one to share with other people. Or from a terminal:
sys0 join sys1-join:eyJh…3. Deploy something from the Marketplace tab. Done.
Full walkthrough: docs/GETTING-STARTED.md.
brew install a-hackers-guide/tap/sys1 # macOS, Linux
curl -fsSL https://a-hackers-guide.github.io/sys1/install.sh | sh # Linux, macOS, BSDscoop bucket add a-hackers-guide https://github.com/A-Hackers-Guide/scoop-bucket
scoop install a-hackers-guide/sys1 # Windows, with Scoop
irm https://a-hackers-guide.github.io/sys1/install.ps1 | iex # Windows, withoutOr grab an installer from Releases: macOS .pkg, Windows .msi, .deb, .rpm, .apk, Arch, AppImage, snap, FreeBSD .pkg, OpenWrt .ipk, and archives for 21 OS/CPU combinations. The node also runs as a container: ghcr.io/a-hackers-guide/sys1. Packages for package managers are being rolled out; see docs/DISTRIBUTION.md for the status of each one.
Build from source (needs Go 1.26+):
git clone https://github.com/A-Hackers-Guide/sys1
cd sys1
go build ./cmd/sys0 && go build ./cmd/sys1| Getting started | Install, join, deploy, in plain words |
| Architecture | How the pieces fit together |
| Reliability | Fast save, watchdog, failover: exactly what "no data loss" means |
| Storage | Pooled, encrypted, replicated storage; app data and backups |
| Batch, groups, GPUs | Splitting work and AI models across machines |
| VMs, desktops and gaming | Virtual machines, screens in the browser, game streaming |
| Clusters and reaching the node | Joining from anywhere; several nodes so none is a single point of failure |
| GitHub | Deploy a repository, redeployed on every commit; Actions runners |
| Monitoring | Machine health on the dashboard, sys0 doctor, Prometheus metrics |
| Automatic updates | How sys0 and sys1 update themselves, verified, with rollback |
| Crash reports | What a crash report contains (nothing personal) and where it goes |
| Security model | Trust levels, sandboxing, what a malicious node or client can and cannot do |
| Marketplace packages | Package format, signing, publishing |
| Protocol | The client ⇄ node API |
| Platforms | Support for every OS, including Android, iPhone and iPad |
| Distribution | Every package manager we target, and their status |
| Roadmap | Where this is going |
| FAQ | Questions people ask |
Everyone is welcome. Please read CONTRIBUTING.md. In short: open an issue for anything (bugs, ideas, packages, platforms) and we'll take it from there. Development happens on branches, not pull requests.
Public domain (The Unlicense). Use it, change it, sell it, close it, anything, anywhere. No warranty, no responsibility taken. All we ask, and it's only a request: share issues and improvements with us, and share sys1 with other people. We respect you; please respect us.