Binions is light on hardware. The entire platform — every daemon, its database, object storage, and routing — runs comfortably on a small machine and scales up by giving one host more CPU and RAM. This page covers the numbers that matter for sizing: memory, processor, and disk. For the wider picture (operating system, runtime, and prerequisites) see System requirements.
The short version. If your host has 2 GB of RAM, 2 CPU cores, and a few gigabytes of free disk, you can run Binions. More of each simply gives you more headroom for heavier workloads.
The figures below are for one complete Binions installation (one set) running on a single host. The minimums reflect the smallest hardware Binions is known to run on; the recommended column is a practical suggestion for a comfortable production deployment.
| Resource | Minimum | Recommended |
|---|---|---|
| RAM | 2 GB | 4 GB or more |
| CPU | 2 cores, x86_64 | 4 or more cores, x86_64 |
| Disk (free) | A few GB | More, sized for your data & object storage |
About the recommended column. The minimums are measured: the platform has been verified running within 2 GB of RAM. The recommended figures are a practical extrapolation for production comfort — they are not a hard requirement, and many deployments will be happy at or near the minimum.
Binions is written in Rust, so the daemons are small native programs with no heavy runtime behind them. In a real measurement on an 8 vCPU / 16 GiB host, the entire stack running at once used about 629 MB of RAM — roughly 3.7% of that host’s memory. Here is where that memory goes:
| Rust daemons (all of them) | ~216 MB total — about 18 MB each |
| Redis instances | ~184 MB total (one small instance per daemon) |
| PostgreSQL | ~84 MB |
| MinIO (object storage) | ~83 MB |
| Jaeger (tracing, optional) | ~37 MB |
| Traefik (routing) | ~26 MB |
| Whole platform | ~629 MB |
On disk the daemons are equally modest — each Rust binary is roughly 6–20 MB. The largest items are the bundled third-party infrastructure tools (Traefik, Jaeger, and MinIO), which together account for most of the install size.
Tip. Because the full stack fits in well under a gigabyte of RAM, Binions uses only a small fraction of a typical server — leaving the rest of the machine free for your own data and workloads.
The same packages run unchanged across a wide range of hardware. There are no separate “editions” or crippled tiers — what you install on a small board is what you install on a rack server.
Crucially, you scale Binions vertically: when you need more capacity, you give the single host more RAM and CPU rather than spreading the platform across a cluster. There is no Kubernetes and no multi-node setup to manage. If your needs grow, see Scaling, and for running several independent sets see Multi-host installation.
The baseline above is the idle, full-stack footprint. A few factors push your real-world needs higher:
Good to know. Because the daemons are written in Rust, there are no garbage-collection pauses. Latency stays predictable as load rises, and internal health checks answer in well under a millisecond — so a busy host behaves consistently rather than stalling unexpectedly.
* Raspberry Pi and other 64-bit ARM hardware are supported from the public 1.0 release. Binions is currently in alpha, and the alpha packages are for 64-bit x86 (amd64) only.