The whole cloud,collapsed into memory.
Point real SDKs and CLIs at AWS, Azure & GCP running entirely on your machine. No accounts, no bills, no network — answers straight from RAM.
Every resource is live in RAM, on the real wire.
The collapse isn't marketing — it's the architecture. Each bucket, instance and table you create is a struct in an in-memory store, reachable over the actual cloud wire protocols. That's why it answers in single-digit milliseconds.
Wire it into a running app. One endpoint override.
To integrate cloudemu with an existing app, run it in server modeand point your SDK's endpoint at it. That exercises your real code path end to end — no throwaway test harness, no code changes beyond the one endpoint.
Run it, point real code at it
Start the binary or Docker image and aim your already-running app, CLI, or SDK — any language — at the printed endpoints. The real wire path runs end to end, exactly as production would.
$ docker run -p 4566:4566 -p 4568:4568 -p 4569:4569 ghcr.io/stackshy/cloudemu
↳ Writing Go unit tests inside cloudemu-aware code? Skip the server and take an in-process handle — cloud := cloudemu.NewAWS(). That's the library path, not how you wire an existing app.
Override the SDK endpoint. Production points at the real cloud; in front of cloudemu you flip one endpoint — every SDK exposes the same seam, nothing else changes.
Not a mock. A cloud you can push until it breaks.
It enforces lifecycle, throttles under load, injects outages and bends time — the failure paths your retries otherwise never run.
Chaos engineering
Schedule outages, latency spikes and throttling inside real time windows. Your backoff code runs for real, every test.
State machines
VMs walk pending → running → stopping → stopped. Start a terminated instance and you get an error, not a shrug.
Error injection
Fail every call, every Nth, the first N, or at a fixed probability — scoped to one operation or a whole service.
Recording & replay
Every call is recorded — inputs, outputs, timing — then asserted against with a fluent API. No spies to wire up.
Fake clock
A clock you advance by hand. TTL expiry, dedup windows and alarms fire on command, not on wall time.
Zero dependencies
The in-process library is standard-library only. It runs anywhere your test suite already runs.
One binary. Three clouds.
Not just mocks. Real backends.
The in-memory default stays instant and dependency-free. When a test needs the real thing, opt in — and point real Infrastructure-as-Code straight at it.
Real engines
A database, cache, function, VM, container, or bucket you create does the real thing — real SQL, real Redis, your code, real bytes. Wire one line; the rest stays in memory.
cloud := cloudemu.NewAWS(config.WithDatabaseEngine(pg))
Terraform & OpenTofu
Real apply / plan / destroy against cloudemu, proven idempotent in CI. The cloudemu-tf wrapper needs only an empty provider block.
$ cloudemu-tf apply
Freeze the whole cloud. Bring it back.
Snapshot cloudemu's entire state — across AWS, Azure, GCP and OCI — to one file, then restore it identity-preserving: every ARN, resource ID and cross-reference survives. Seed a baseline, branch from it, reset in an instant. The in-memory default stays ephemeral; persistence is opt-in.
$ cloudemu snapshot save state.json
Point real code at it.
Standalone / Docker
A long-lived local cloud. Point any app, CLI or SDK — any language — at it. The default for integration & E2E.
$ docker run -p 4566:4566 cloudemu
In-process HTTP
Wrap it in httptest and aim real SDK clients straight at the handle — for Go tests.
ts := httptest.NewServer(…)
Typed Go API
Skip the wire entirely — call the in-memory drivers directly in unit tests.
cloud := cloudemu.NewAWS()
Bring a cloud up in one line.
Point your existing tests at it today — no credentials, no network, no cleanup. A clean cloud on every run.