About This Game

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

Uptime puts you on the floor of your own cloud provider, first person, hands on the hardware. You buy the servers and carry them to the rack. You seat them with a click. You run the cable off the spool yourself, find the port, watch it lay across the floor, and power the thing on. Then you sign your first customer and find out whether any of it holds.

Underneath the floor is a real simulation. Every server, switch, cable and port is a live entity in a deterministic engine, and the network genuinely switches and routes traffic across it. Power and cooling are budgets you can blow. Capacity is hardware that fills up. When something breaks, it breaks because the model says it should, and the fix is usually the one a real engineer would reach for. That was the whole goal: a build-it-with-your-hands tycoon sim that still holds up if you do this for a living.

Get it running, then keep it running. The moment traffic arrives, the simulation starts pushing back.

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

You own the full stack. The metal, the network, the services you sell, and the customers whose product lives on your kit. You're the thing they build on, so everything running on you is yours to keep alive, from the single box in the garage to a floor other companies depend on.

Your customers bet their business on you.

The tenants have names, and they hand you their product expecting it to stay up. Reputation is the currency underneath all of it. You earn it slowly and you can lose it in one bad night, and the bigger the customer, the harder that fall lands. Sign a deal you can't carry, pack one host too tight, sleep through an SLA breach at 2am, and the cost isn't only the money. It's the trust that was about to send you the next customer.

So every yes is a wager on whether you can carry the new weight without dropping what you already hold. Turning business away is sometimes the correct call. The tenants you keep won't sit quietly either. They surge, they haggle, they show up with deadlines. Keep them happy and they say so out loud, and they bring friends.

What you sell is infrastructure you actually run.

Customers don't rent "a server." They spin up the things a real cloud sells: virtual machines, object storage, managed databases, Kubernetes, load balancers, serverless functions. Each one is a service you operate. Behind every service is a control plane you have to keep alive and an agent on each host that does the work, and all of it competes for the same compute your customers are paying for.

That's where the network grows teeth. Cut a service off from its control plane and it starts to fail. Lean on one too hard and it buckles. Capacity runs out, the network can partition the very services you're selling, and the way you lay it all out is what separates a provider that holds from one that tips over.

The simulation is the game.

This is where the word "simulation" gets earned. Every device on your floor is a real entity in a deterministic engine, and every LED you see is reading its live state. A link saturates because the math saturated it. A rack goes dark because a fault domain you never thought 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. These are the model, not labels stuck on a progress bar. Cable a redundant link the wrong way and spanning tree either saves you or, if you got it backwards, the whole floor drowns in a broadcast storm. You can ignore the depth and still win. You can also lean all the way into it.

The customers talk to you.

They live in a chat channel that reads like the ops Slack you've spent years in. They onboard, ask for more capacity, complain when latency spikes, and tell you in their own words when the change you made three minutes ago just took their service down.

Incidents don't ship with severity tags attached. Severity comes out of how many customers you're hurting and how badly. A flapping link nobody depends on is a shrug. That same link under your biggest tenant is a page in the middle of the night.

Two ways to read the same machine.

Never touched a rack? NPC mentors walk you in, and one key toggles jargon mode, flipping the whole interface between plain language and the real terminology over the exact same systems. "Spread these across separate failure zones" and "fix this single-AZ SPOF" are the same instruction. You pick up the real words by playing instead of reading a manual. Already know what oversubscription costs you? The depth was there the whole time. Turn the training wheels off.

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

One difficulty setting, Easy, Standard or Hard, re-tunes the entire simulation from a single neutral baseline, and you can move it mid-run. Push it up and the reputation ledger turns crueller: slower to earn, quicker to lose, less willing to forgive an incident. The authored hard scenarios set their own floor, so the slider can make them tougher but never softer.

Garage-to-Glory is one story, not the only one.

The campaign takes you from a single server in the garage to your own data center floor, growing through a basement build-out and into a room you fill and defend. That's one scenario. Run the hard-mode variant. Survive Data-Loss Day. Hold the line through Under Attack. Or drop into open sandbox and build with no rails at all. Scenarios are plain, readable files, so the community can write their own starts, disasters and constraints and drop them straight in.

This is Early Access. The data center floor is built to grow: add rows and cages to expand it, spread your customers across separate zones, and build real multi-region resilience by hand. More hardware, bigger scenarios and hyperscale scale are on the road ahead.

For the engineers.

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

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

• Managed L2 and L3 switches forming an actual 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 painted on

• Reachability chains from host to switch to demarc to 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, so hardware ages and degrades instead of tripping a random death timer

• Capacity modelled as workload shapes fitting host shapes rather than a scalar 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 and replay-stable

Built honestly.

A deterministic Rust engine runs the simulation, and the renderer only ever shows you what the engine already decided. Nothing gets 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 loop is here and playable now: campaign, sandbox, hard modes, and the customer and service simulation underneath them. Early Access is where the breadth grows on top of that, more places to build, more hardware, more scenarios, and steady polish across art, audio and onboarding, with the direction shaped by what players push on, the infra crowd most of all.

Features

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

• Cabling as a hero mechanic - run every link by hand, with 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 earned slowly and lost in an instant, every signup a bet against the capacity you can see.

• A real cloud to run - VMs, storage, databases, Kubernetes, load balancers and functions, 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, and hard scenarios that won't soften.

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

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