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 switches and routes real 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 money is the cheap part. You lose 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, and they come back asking for more capacity, expecting a yes. The yes costs iron. One eats bandwidth. The next wants far more memory than its size suggests, and the one after that wants CPU nobody else is allowed to touch. 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.

Then the internet notices you.

Floods arrive, and they arrive more often the bigger you get. Attack volume scales with how many tenants you host, how well known you are and how much line there is to fill. The garage is where you meet the mechanic. On a colo floor it starts to hurt. An attack can't come down the wire faster than the wire allows, so a consumer fibre and a carrier circuit get attacked in completely different shapes.

Your gateway and its add-ons scrub what they can absorb, and the traffic you absorbed still filled your pipe on the way in. Your servers are protected. Your line is not. At most four fifths of a circuit can be taken, so a flood squeezes you for a while instead of switching you off. Buy more inspection capacity, or buy more line. There's an intrusion feed to read while it happens, and a bill afterwards, because security hardware carries monthly fees and licences that show up in your burn rate.

Yes, it has a /metrics endpoint.

Every running game serves a read-only HTTP API on localhost, and the ops console tells you the port. Curl it. Scrape it. Hosts, racks, cables, switches, tenants, incidents, work orders, quests: a couple of dozen collections in all, handed back as JSON in the same shapes the game's own renderer reads. There's a generated OpenAPI spec and a Swagger page served out of the binary too, so you can click through the lot without reading a word of documentation.

The /metrics half speaks Prometheus, so your second monitor can be a real Grafana board. Cash and reputation. Heat load against cooling capacity. Uplink egress climbing while a flood comes in, and an alert rule that fires when your own SLO goes red. Scrape it as hard as you like: the engine hands the HTTP side a copy on a fixed cadence and never waits on it, so no amount of hammering costs you a frame, and every response carries its own age so you know how fresh the number is.

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. When you don't know what to do about one, the console carries runbooks, and a codex that fills in as hardware lands on your floor. The answer is in the room with you.

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, and 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. Garage to Glory: Hard runs the same climb on half the cash and half the leads, with steeper targets on every rung and a stretch about two and a half times as long. Arm Race is its own start. 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 sites are on the road ahead.

Multiplayer is coming.

One floor, several people standing on it, and one shared set of customers who don't care which of you laid the cable. Someone racks, someone cables, someone watches the graphs and starts shouting. Invite a friend off your Steam list and they walk in through the door. It's in beta testing now, and it's the next thing we finish.

For the engineers.

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

• Typed cages and connectors - RJ45, SFP, QSFP, LC - with media rules that refuse the wrong lead

• Real LAG across member links, and breakout cables with honest lane arithmetic, so a 100G trunk fanned to 4x25G is four legs sharing the trunk's lanes

• 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

• Two-sided patch panels: couplers with a front face and a rear face, front-to-rear pass-through, rear runs bundled at rack depth

• Cable management with finite capacity - side holes, roof cutouts and vertical managers fill up and say no

• 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, overload one and it relocates itself to iron that fits

• Power draw and wear modelling: an ageing machine loses disk speed and burns more watts, and never loses the memory or cores you paid for, and nothing dies on a random timer

• Capacity modelled as workload shapes fitting host shapes rather than a scalar bar

• Finance that behaves: burn rate, runway, per-customer cost attribution, upstream transit billed on what you shift, and capital hardware that stops depreciating once it's written off

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

• A read-only local HTTP API, a Prometheus /metrics endpoint and a generated OpenAPI spec with Swagger UI, served by the game itself on loopback

• 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, Steam Deck included. English is the language the game is written in, with Czech, Danish, French, German, Polish, Spanish and Brazilian Portuguese available and still being refined.

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, real patch panels and cable management that fills up. Pull a cable 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.

• Under attack - floods that scale with your size and can never outrun the line they arrive on. Scrub them with hardware you chose and paid for.

• It has a /metrics endpoint - a read-only local API and a Prometheus scrape target, so your second monitor can be a real Grafana board.

• 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, plus runbooks and a codex in the console. 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, a hard-mode variant, alternate starts, open sandbox, and drop-in community scenarios.

• Multiplayer, coming soon - share one floor and one set of customers with friends from your Steam list. In beta testing now.

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