Vyomi — the Multi-Cloud Digital Twin Runtime

Build for the cloud, without the cloud. Vyomi is a multi-cloud digital twin runtime — a faithful, running replica of your AWS, GCP, and Azure environment on your own machine. Real services, real SDKs, real backends; no cloud account, no cloud bill, no network required.

Often searched for as a local multi-cloud simulator or a LocalStack alternative — Vyomi goes further: a real digital twin on real backends across all three clouds, not single-cloud mocks.

Point your existing SDKs/CLIs — boto3, aws-sdk-java, google-cloud-*, azure-sdk-for-*, plus aws / gcloud / gsutil / az / terraform — at http://localhost:9000, and your code runs unchanged. When you're ready, one-click Terraform export promotes the same stack to production cloud.

Why a digital twin, not a mock? (vs LocalStack / Moto / Azurite)

LocalStack mocks AWS; Moto, Azurite, and the GCP emulators each cover a single cloud. Vyomi runs all three major clouds on real backends (Postgres, MySQL, MinIO/S3, DynamoDB, Vault, NATS, Azurite, the Firestore emulator) with native multi-cloud NoSQL — DynamoDB, Firestore, and Cosmos DB — so the twin behaves like the real thing while you build and test cross-cloud apps locally. Full head-to-head: vyomi.cloud/compare/localstack.

The CLI is vyomi (with a cloud-learn deprecation shim through v2.x), the Docker image is vyomi/appliance, and the brew tap is vyomi-cloud/tap. Upgrading from v1.x? Read docs/MIGRATION-v2.md first.

Latest release: v3.0.38 (2026-11-01)

Daily conformance release. 3 product fixes (all clouds 3); 3 reach Nano and 3 reach the offline appliance.

• Deleted resources now stay deleted. Resources you delete no longer reappear when you switch between Nano tabs or work through the tunnel, in Nano and the offline appliance.
• Cost savings no longer shows deleted resources, and VPCs can be deleted. Items you removed stay gone from the Cost savings view, and you can now delete VPCs.
• gcloud compute works through the tunnel. You can run gcloud compute commands against the simulator through the tunnel, in Nano and offline.

Full release notes · CHANGELOG · upgrade: vyomi update · Nano: reload vyomi.cloud

What's in v3.0.38

Everything below is cumulative — every capability shipped from v1.0 through v3.0.38

Area	What you get
Three clouds, real backends	AWS, GCP and Azure — 35+ services backed by real engines: Postgres, MySQL, MinIO (S3/GCS), DynamoDB Local, ElasticMQ (SQS), Vault (KMS + secrets), NATS (eventing), Azurite, fake-gcs, the Pub/Sub and Firestore emulators
Native SDKs and CLIs, unchanged	boto3, aws-sdk-java/go, google-cloud-*, azure-sdk-for-*; aws, gcloud, gsutil, az, terraform — only the endpoint changes
Operation depth	S3 multipart + CopyObject, DynamoDB transactions + GSIs, SQS FIFO + DLQ redrive, KMS rotation, API Gateway (MOCK + Lambda proxy), VPC with a reachability analyzer, Azure Service Bus topics + Azure SQL, Cosmos queries
Real compute	EC2 / GCE / Azure VM instances as SSH-able Docker containers (Pro) or LXD VMs (Max), with cloud CLIs pre-installed and working SSH + .pem connect info
Native consoles	/console/aws, /console/gcp, /console/azure with second-level detail tabs, per-resource events, and per-service cost savings (what the same resources would cost on real cloud)
Spaces	Isolated per-cloud workspaces (/clouds) with live host telemetry, per-space TTL countdowns, Renew/Force-shutdown, and enterprise/shared sandbox modes
Vyomi Nano	The whole simulator in the browser (no install) at vyomi.cloud — Pyodide + PGlite + IndexedDB persistence, with a local (vyomi-tunnel) or cloud relay so external SDKs/CLIs reach it
One launcher, two substrates	vyomi up runs Docker for Free/Lite/Pro and Multipass for Max; compiled vyomi binary on Windows
Install anywhere	Homebrew (vyomi, vyomi-docker), .deb / .rpm (cloud-learn, vyomi-docker), Windows MSI, Docker Compose, source
Licensing and trial	Free · Lite · Pro · Max · Enterprise, activated from the portal; offline appliances get a , then drop to Free

Release history

• 3.0.38 — Deleted resources now stay deleted. Resources you delete no longer reappear when you switch between Nano tabs or work through the tunnel, in Nano and the offline appliance.
• 3.0.37 — New "How Nano works" videos in Nano. Each cloud console Home in Nano now has a slim banner that opens a pop-up player with a short video explaining how Nano works for that cloud.
• 3.0.36 — A redesigned console, on Nano and offline. The appliance has a new vyomi wordmark, a light theme, rounded panels and cards, and a side menu that is now the same on Nano and offline. Refreshing the page also keeps you on the current view instead of sending you back to Spaces.
• 3.0.35 — GCP projects now work the same in gcloud and the console. Each GCP space has a single project, which you can address by ID or number, and gcloud and the console both show it. The old project ids (cloudlearn, demo, gcp-dev) now refer to other projects.
• 3.0.34 — Detail tabs now show real data across all three clouds. About 34 resource tabs and blades in AWS, GCP and Azure now read the resource's actual state instead of placeholder content, in both Nano and the offline appliance.
• 3.0.33 — Metrics tabs now show real traffic. In AWS and Azure (Nano and offline), Metrics and Monitoring tabs chart the requests, errors and latency your own calls produce instead of made-up sparklines, and AWS detail tabs are no longer cut off at 10 (VPC Metrics and Flow logs were hidden).
• 3.0.32 — Metrics tabs now show real data on all three clouds. AWS Monitoring and Azure Metrics tabs draw the requests, errors and latency your app actually made, replacing the seeded sparklines and random EC2 CloudWatch values. This works in Nano and offline, and VPC Metrics and Flow logs tabs are no longer hidden.
• 3.0.31 — Cloud Scheduler now runs jobs for real (GCP, Nano + offline). In the offline appliance, jobs fire on their own about every 15 seconds without needing a read, and HTTP-target jobs send an actual request (method, headers, body, bearer token) and report success, failure or timeout on the job; Nano still only records them.
• 3.0.30 — GCP Cloud Monitoring is now a Vyomi service. The offline appliance includes a Cloud Monitoring engine, so you can develop against it without a real GCP project.
• 3.0.29 — A GCP container registry is now available in Nano and offline. You can docker push images to it and they show up in the simulator, and the console catalog's sub-blades now merge correctly.

• 2.9.0 — Compiled vyomi launcher (Go) for Windows; console data-plane integration.
• 2.8.1 — All parity work reachable on every tier; Azure SQL + Azure IAM live.
• 2.8.0 — VPC data plane with a reachability analyzer.
• 2.7.0 — API Gateway data plane (MOCK + Lambda proxy).
• 2.6.0 — Parity finish: S3 multipart, DynamoDB GSIs, SQS FIFO + DLQ, KMS rotation, Azure SQL.
• 2.5.0 — Parity close-out: Azure Service Bus topics, S3 CopyObject, DynamoDB transactions, richer Cosmos queries.
• 2.4.0 — Tri-cloud on every tier: anti-drift conformance gate; MinIO/Postgres/Vault-backed stores.
• 2.3.2 — Nano sign-in to save; stable relay URL; install analytics once per machine.
• 2.3.1 — In-app Swagger and SDK/CLI usage views.
• 2.3.0 — Free tier = Vyomi Nano in the browser; Cloudflare + local relay tunnels.
• 2.2.2 — Tier-aware launcher: Docker for Free/Lite/Pro, Multipass for Max.
• 2.2.1 — vyomi-docker packages (.deb / .rpm / brew).
• 2.2.0 — Pro Docker compute (SSH-able containers); Lite/Nano/Micro tiers; cloudlite compose.
• 2.1.0.2 / 2.1.0.1 / 2.1.0 — Windows MSI, VirtualBox NAT port-forward, readiness fixes.
• 2.0.9.2 / 2.0.9.1 / 2.0.9 — Compose as a front door; native-SDK Secrets/KMS/Messaging conformance; Azure Storage Queue.
• 2.0.8 — Progressive startup (console usable in ~30–60 s); Azure/GCP object stores in the consoles.
• 2.0.7 — Fresh-install regression fixed; disk cleanup; launch progress.
• 2.0.6 — Real-SPA conformance 35/35; install funnel from every package manager; version + update check.
• 2.0.5 — Cloud CLIs bundled into every compute instance.
• 2.0.4.1 / 2.0.4 — /clouds workspaces dashboard, live host telemetry, Docker inside Vyomi EC2.
• 2.0.1 — Zero-config first launch (localhost bridge, auto browser open).
• 2.0.0 — The Vyomi rebrand (CLI, image, tap, license BSL 1.1); HTTPS via mkcert + Caddy.

• 1.2.5 — Default spaces aws-default / gcp-default / azure-default.
• 1.2.4 / 1.2.3 — Every install path reachable at vyomi.local:9000 (mDNS).
• 1.2.2 / 1.2.1 — Launcher installs Multipass when missing (macOS, Linux, Windows).
• 1.2.0 — Activation and EC2 state-refresh fixes.
• 1.1.11 → 1.1.1 — Launcher hardening: health probes, bundle verification, tar+transfer sync, phase counters, failure banners, logs.
• 1.1.0 — Console-actions conformance 100% (253/253) across AWS/GCP/Azure.
• 1.0.0 — First GA: 29 services across AWS/GCP/Azure, 8 real backends, native SDKs/CLIs, consoles, tiers, Terraform export, reference apps.

Full details: CHANGELOG.md · per-release checks: the release/vX.Y.Z branches.

Quick start

Homebrew (macOS / Linux)

brew install vyomi-cloud/tap/vyomi
vyomi up

Docker Compose (development)

git clone https://github.com/vyomi-cloud/appliance && cd appliance
docker compose up -d
open http://localhost:9000/clouds

From source

git clone https://github.com/vyomi-cloud/appliance && cd appliance
pip install -r requirements.txt
uvicorn server:app --host 0.0.0.0 --port 9000

Open http://localhost:9000/clouds (your spaces). From there:

• /console/aws · /console/gcp · /console/azure — native cloud consoles
• /api/runtime/tier — current tier policy
• /api/runtime/backends — health of all 8 real backends
• /docs — auto-generated OpenAPI swagger

Using your existing cloud SDKs

# Python (boto3) — AWS
import boto3
s3 = boto3.client("s3", endpoint_url="http://localhost:9000",
                  aws_access_key_id="test", aws_secret_access_key="test",
                  region_name="us-east-1")
s3.create_bucket(Bucket="my-bucket")
s3.put_object(Bucket="my-bucket", Key="hello.txt", Body=b"world")

# AWS CLI — dummy creds + region are required; AWS_PAGER="" stops CLI v2's
# pager from swallowing short output
export AWS_ACCESS_KEY_ID=test AWS_SECRET_ACCESS_KEY=test AWS_DEFAULT_REGION=us-east-1 AWS_PAGER=""
aws --endpoint-url http://localhost:9000 s3 ls
aws --endpoint-url http://localhost:9000 rds describe-db-instances

// Java (aws-sdk-java-v2)
S3Client s3 = S3Client.builder()
    .endpointOverride(URI.create("http://localhost:9000"))
    .region(Region.US_EAST_1)
    .credentialsProvider(StaticCredentialsProvider.create(
        AwsBasicCredentials.create("test", "test")))
    .build();

// Go (google-cloud-go)
client, _ := storage.NewClient(ctx,
    option.WithEndpoint("http://localhost:9000"),
    option.WithoutAuthentication())
bucket := client.Bucket("my-bucket")

# Terraform
provider "aws" {
  endpoints {
    s3 = "http://localhost:9000"
  }
  skip_credentials_validation = true
  skip_requesting_account_id  = true
  region = "us-east-1"
}

Reference apps

Three minimal web apps that exercise each cloud's 7 core services through real SDKs:

App	Cloud	Stack	Services exercised
tests/e2e/java-orders	AWS	Spring Boot, Java 17	RDS · S3 · SQS · EventBridge · Secrets Mgr · KMS · IAM
tests/e2e/go-inventory	GCP	Go + chi	Cloud SQL · GCS · Pub/Sub · Eventarc · Secret Mgr · Cloud KMS · IAM
tests/e2e/azure-tickets	Azure	Go + chi	Postgres Flex · Blob · Service Bus · Event Grid · KV-secrets · KV-keys · RBAC

Each has its own api_pass_test.go / ApiPassTest.java that round-trips against a live simulator.

Architecture

┌──────────────────────────────────────────────────────────────────────┐
│                            FastAPI (port 9000)                        │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐                        │
│  │ /aws/* (S3)│ │ /v1/* (GCP)│ │ /sub/* (Az)│   ← provider routes    │
│  └─────┬──────┘ └─────┬──────┘ └─────┬──────┘                        │
│        │              │              │                                │
│  ┌─────┴──────────────┴──────────────┴────────┐                       │
│  │  Middleware: rate-limit → SSO → tier-gate │                       │
│  │             → Cedar → custom-domain       │                       │
│  └─────┬──────────────────────────────────┬──┘                       │
│        │                                  │                          │
│  ┌─────┴─────┐   ┌──────────────┐   ┌─────┴─────┐                    │
│  │  CloudSim │   │ tier_policy  │   │   state   │                    │
│  │  backbone │   │   (4 tiers)  │   │ (SQLite)  │                    │
│  └─────┬─────┘   └──────────────┘   └───────────┘                    │
└────────┼─────────────────────────────────────────────────────────────┘
         │
   ┌─────┴───────────────────────────────────────────────────────┐
   │                  Real backends (sidecar containers)          │
   │  Vault  NATS  MinIO  DDB-local  ElasticMQ  PG  MySQL  Cedar │
   └──────────────────────────────────────────────────────────────┘

Full design: docs/architecture/CLOUDLEARN_FULL_ARCHITECTURE.md Production deployment: docs/PRODUCTION_DEPLOYMENT.md

Tiers

Tier middleware enforces the gates server-side; standard SDKs work natively on every tier. Current pricing: vyomi.cloud/pricing (USD, billed in INR).

• Free — Vyomi Nano in your browser, no install, plus the self-hosted appliance on the Free tier.
• Lite ($9/mo), Pro ($19/mo), Max ($29/mo) — self-hosted appliance tiers: more services, spaces and storage; Pro adds Docker compute, Max adds VM compute (Multipass) and every service on all three clouds. New offline activations start with a 14-day Pro trial.
• Enterprise — cloud sandboxes for teams on GitHub Codespaces, pay per use; multi-tenant RBAC, SSO, audit sinks, air-gapped install.

Conformance & testing

# Run the conformance harness against a live simulator
python tests/conformance/run_conformance.py \
  --endpoint http://localhost:9000 \
  --isolate-spaces \
  --fail-under 85.0

CI workflows in .github/workflows/:

• ci.yml — lint + conformance (≥85% gate) + tier-middleware smoke + 3-cloud refapp build matrix on every PR
• release.yml — tag-triggered release artifact build
• conformance-hourly.yml — hourly conformance agent (UI + SDK/CLI/API, Nano + offline); report on the conformance-report branch
• msi-validate.yml, release-startup-validate.yml, release-checks.yml — per-release MSI / startup / DEB·RPM·Homebrew checks → RELEASE-CHECKS.md on release/vX.Y.Z

Contributing

• Adding a service: update the per-provider catalog + tier_policy category mapping. See docs/architecture/CLOUDLEARN_LLD.md.
• Adding a tier feature: extend core/tier_policy.py and add an _enforce_tier_feature("X") gate at the endpoint.
• Footguns + design decisions documented in docs/architecture/.

License

Source-available under the Business Source License 1.1 with a Vyomi-specific Additional Use Grant. Auto-converts to Apache 2.0 four years after each release.

What this means in plain English:

• You can: read the source, use Vyomi non-commercially, run it internally at your company, audit the licensing/tier code, send pull requests
• You can't (without a separate commercial agreement): offer Vyomi as a hosted multi-cloud simulator service, modify/bypass the tier-enforcement code, or rebrand and resell it

See LICENSE for the full text. For commercial hosting, white-label, or OEM arrangements, contact [email protected].