About This Game

You don't manage a datacenter from a spreadsheet. You walk it.

Uptime drops you onto the floor of your own cloud provider - first person, hands on the hardware. You buy the servers, carry them to the rack, and seat them with a satisfying click. You run the cable yourself: pull it off the spool, find the port, watch it lay across the floor. Power it on. Bring it online. Sign your first customer.

And underneath all of it is a real simulation. Every server, switch, cable and port is a live entity in a deterministic engine - not set dressing, not a bar filling up. The network actually switches and routes; power and cooling are real budgets; capacity is real hardware that fills up. When something breaks, it breaks because the model says it should, and the fix is the one a real engineer would reach for. That's the bet: a tycoon sim you build with your hands, running on a simulation that holds up to the people who do this for a living.

Then keep it up. Because the moment traffic hits, the simulation starts pushing back.

You're not running a server room. You're running the cloud.

You own the whole stack - the metal, the network, the services you sell, and the customers who bet their product on staying up. From one box in a garage to a fleet other companies depend on: you're not just renting out floor space, you're the cloud they build on, and everything running on you is yours to keep alive.

Your customers bet their business on you.

These aren't income tickers. They're named tenants who put their product in your hands, and the relationship carries weight. Reputation is the currency it all runs on - slow to earn, gone in a moment when you break a promise, and the bigger the customer the harder the fall. Sign the wrong deal, pack one host too tight, miss an SLA at 2am, and it isn't just money you lose - it's the trust that was about to bring the next customer to your door.

So every yes is a bet: can you really carry this without breaking what you've already got? Sometimes the smart move is to turn business away. And the ones you keep don't sit quietly - they come back with surges to survive, offers to match, deadlines to hit. Keep them happy and they'll say so, loudly, and bring others with them.

What you sell is real infrastructure you run.

Your customers don't rent "a server." They spin up what a real cloud sells - virtual machines, object storage, managed databases, Kubernetes, load balancers - and every one is infrastructure you actually operate, not a billing line. Behind each service runs a control plane you have to keep alive and agents on every host that serves it, all competing for the same real compute your customers are paying for.

That gives the network teeth. Cut a service off from its brain and it starts to fail; lean on one too hard and it buckles. Capacity is finite, the network can partition the very services you sell, and how you lay it all out is what separates a provider that holds from one that falls over.

The simulation is real.

This is where Uptime earns the word "simulation." Every device on your floor is a real entity in a deterministic engine, and every LED you see is reading live state. When a link saturates, it's because the math says it saturated. When a rack goes dark, it's because a fault domain you didn't think about turned out to be a single point of failure.

Ports, cables, power draw, fault domains, oversubscription, link aggregation, spanning tree, BGP, mean-time-between-failures - they're not labels on a progress bar. They're the model. Cable a redundant link the wrong way and either spanning tree saves you, or - if you got it wrong - the whole floor drowns in a broadcast storm. You can ignore the depth and still win. Or you can lean all the way in.

The channel is the customer.

And they talk to you, in a chat channel that reads like the ops Slack you've lived in. They onboard, they ask for capacity, they complain when latency spikes, and they tell you, in their own words, when something you did three minutes ago just took their service down.

Incidents aren't scripted severity tags. Severity emerges from how many customers you're actually hurting and how badly. A flapping link nobody depends on is a shrug. The same link under your biggest tenant is a 2am page.

Two ways to read the same machine.

Never touched a rack? Diegetic NPC mentors walk you in, and a single key toggles jargon mode - flip the whole interface between plain language and the real terminology, on the same underlying systems. "Spread these across separate failure zones" and "fix this single-AZ SPOF" are the same instruction. You learn the real words by playing, not by reading a manual. Know exactly what oversubscription means? The depth was always there. Turn the training wheels off.

Set the difficulty. The hard runs won't let you off.

A single difficulty setting - Easy, Standard, Hard - re-tunes the entire simulation from one neutral baseline, and you can move it mid-run. Crank it up and the reputation ledger gets crueller: slower to earn, faster to lose, less forgiving of every incident. And the authored hard scenarios floor the challenge - the slider can make them tougher, never softer.

Garage-to-Glory is one story. It isn't the only one.

The campaign takes you from a single server in a garage to a hyperscale fleet - but that's one scenario among many. Run the hard-mode variant. Survive Data-Loss Day. Hold the line through Under Attack. Drop into open sandbox and build with no rails at all. And because scenarios are plain, readable files, the community can write their own - new starts, new disasters, new constraints - and drop them straight in.

For the engineers.

You already know whether we mean it. Here's what's under the hood:

• Typed ports and cables; real LAG / link-aggregation with member links

• Managed L2 and L3 switches - a real switching fabric, not one abstract "network" stat

• RSTP that converges, elects a root bridge, and blocks redundant ports - loop the network and it storms

• Oversubscription that bites when you cheap out on uplinks

• Fault domains and single-points-of-failure that are computed, not cosmetic

• Reachability chains: host -> switch -> demarc -> uplink, gating every allocation

• Every service split into a control plane and per-host data-plane agents - partition them and it goes headless

• Power draw and wear modelling; hardware ages and degrades, it doesn't tick a random death timer

• Capacity modelled as workload shapes fitting host shapes - not a scalar resource bar

• Reputation as an asymmetric ledger, with a capacity-fit check before you ever sign

• A deterministic engine: same seed, same run, every time - headless-testable, replay-stable

Built honestly.

A deterministic Rust engine does the simulation; the renderer only ever shows you what the engine already decided. Nothing is faked for the camera. Scenarios and mods are human-readable files. Windows, macOS, and Linux from day one.

Uptime is in Early Access: the full game loop - campaign, sandbox, hard modes, the customer and service simulation - is here and playable now. Early Access is where we plan to add breadth and depth on top of it - more places to play, more hardware, more scenarios, and ongoing polish across art, audio and onboarding - with the direction shaped by what players (especially the infra crowd) push on.

Features

• First-person, hands-on - walk the floor, carry the hardware, run the cable. You're in the room, not above it.

• Cabling as a hero mechanic - run every link by hand: typed connectors, enforced reach and bend radius, and a live edge that carries traffic - pull it and something goes dark. The way Factorio makes belts feel good.

• Customers as commitments - reputation you earn slowly and can lose in an instant; every signup a bet against visible capacity.

• A real cloud to run - VMs, storage, databases and more, each with a control plane and data-plane agents on your hosts.

• A simulation that pushes back - ports, power, fault domains, spanning tree, oversubscription and BGP are the actual model.

• Emergent incidents - severity comes from real customer impact, not scripted labels.

• Readable for anyone, honest for the pros - one-key jargon toggle over the same systems; no manual required.

• Difficulty you control - live Easy/Standard/Hard that re-tunes everything; hard scenarios that won't soften.

• Breadth of play - campaign, scenario variants, open sandbox, and drop-in community scenarios.

• Deterministic & mod-friendly - same seed, same run; plain-text scenario files.