Repository avatar
AI Tools
v1.4.0
active

vyomi

io.github.vyomi-cloud/vyomi

Local AWS, GCP and Azure simulator for coding agents: service coverage, SDK env vars and status

Documentation

Vyomi — the Multi-Cloud Digital Twin Runtime

CI License: BSL 1.1 Version Docker

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.47 (2026-11-10)

Daily conformance release. 4 product fixes (AWS 1, Azure 2, all clouds 1); 2 reach Nano and 4 reach the offline appliance; 3 test and harness improvements.

  • Azure Service Bus now speaks AMQP 1.0. Azure Service Bus clients that connect over AMQP 1.0 can work against the simulator, in Nano and offline.
  • Siftly app profiles are supported. Siftly now has app profiles, and the simulator runs Postgres 16 with pgvector, in Nano and offline.
  • Azure Blob Storage behaves more like the real service. Blob fidelity improvements make Azure Blob code act more like it does in Azure, in Nano and offline.
  • EC2 launches no longer end up stopped by mistake. A list or describe call made while an instance was still launching could flip it to stopped, and that no longer happens in the offline appliance.

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

What's in v3.0.47

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

AreaWhat you get
Three clouds, real backendsAWS, 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, unchangedboto3, aws-sdk-java/go, google-cloud-*, azure-sdk-for-*; aws, gcloud, gsutil, az, terraform — only the endpoint changes
Operation depthS3 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 computeEC2 / GCE / Azure VM instances as SSH-able Docker containers (Pro and Max; WASM Edge VMs in the browser on Nano), with cloud CLIs pre-installed and working SSH + .pem connect info
API reference + SDK/CLI usageEvery service's API reference and CLI/SDK snippets (aws/boto3, gcloud/google-genai, az/azure-mgmt) are generated into the consoles - see docs/guides/api-and-sdk-reference.md
Native consoles (Nano)The AWS, GCP and Azure consoles live in Nano (https://vyomi.cloud/nano); the 4.0.0 appliance is headless. Second-level detail tabs, per-resource events, and per-service cost savings (what the same resources would cost on real cloud)
SpacesIsolated per-cloud workspaces (API/CLI; UI in Nano) with live host telemetry, per-space TTL countdowns, Renew/Force-shutdown, and enterprise/shared sandbox modes
Vyomi NanoThe 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
Two substrates: WASM Edge + DockerNano runs entirely in your browser (WASM Edge); vyomi up runs the full appliance on Docker for every paid tier. Multipass/LXD is retired as of v4.0.0
Install anywhereHomebrew (vyomi, vyomi-docker), .deb / .rpm (cloud-learn, vyomi-docker), Windows MSI, Docker Compose, source
Licensing and trialFree · Lite · Pro · Max · Enterprise, activated from the portal; offline appliances get a 14-day Pro trial, then drop to Free
EnterpriseMulti-tenant RBAC, shared cohort sandboxes, cloud sandboxes on GitHub Codespaces, SSO, Helm + air-gapped install, audit sinks
TerraformExport simulator state to HCL and import it back
Verified every releaseHourly conformance agent across Nano + offline (UI, SDK, CLI, API, cost savings), plus per-release install checks for MSI / DEB / RPM / Homebrew, a full startup + UI-status check, and a Windows end-to-end run — results on each release/vX.Y.Z branch
PrivacyAnonymous install counting; in the Nano consoles, anonymous per-view dwell times (route pattern + active seconds, never resource names or page content). Opt out with VYOMI_NO_TELEMETRY=1, localStorage vyomi.telemetry=off, or your browser's Do Not Track

Release history

3.0.x — trial, sandboxes, Nano depth
  • 3.0.47 — Azure Service Bus now speaks AMQP 1.0. Azure Service Bus clients that connect over AMQP 1.0 can work against the simulator, in Nano and offline.
  • 3.0.46 — New vyomi mcp server for AI coding agents (offline). Vyomi now ships an MCP server on all platforms, plus a Claude Code plugin, so AI coding agents can work with the simulator directly; it requires vyomi 3.0.46 or later.
  • 3.0.45 — Black-and-white Health and API reference. Health and the API reference now use a complete black-and-white theme, with no outer panels, section headers that run edge to edge, and rounded Service status tiles (Nano and offline).
  • 3.0.44 — DynamoDB bulk operations are now supported. You can start, list, describe and cancel bulk put-item jobs against DynamoDB, both in Nano and in the offline appliance.
  • 3.0.43 — Postgres is now reachable from your host apps. Apps running on your machine can connect to the simulated Postgres through the tunnel, in both Nano and the offline appliance.
  • 3.0.42 — EventBridge rules now deliver to more targets. Rules can send events to Kinesis streams, CloudWatch Logs, Step Functions state machines (which start an execution) and other event buses, in both Nano and the offline appliance.
  • 3.0.41 — Nano and the offline appliance are back in sync. This release brings the latest Nano console changes into the offline appliance, so both now behave the same way.
  • 3.0.40 — EventBridge is much more complete (Nano and offline). You can now create, describe, list and delete event buses with boto3 (it used to fail with InternalFailure), and use archives and replays, connections and API destinations (HTTP targets get the transformed event with API-key or basic auth), plus delivery to Kinesis, CloudWatch Logs, other event buses and Step Functions targets, with retries and dead-lettering to an SQS queue.
  • 3.0.39 — EC2, Compute Engine and Azure VMs now run as real in-browser VMs in Nano. You can SSH in through the vyomi-tunnel bridge, the VM image includes apk and standard CLI tools with allow-listed network access so apk, pip and npm work, and consoles show the true power state and a Connect panel that names the instance. SSH to GCE and Azure VMs also works in the offline appliance.
  • 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.
  • 3.0.28 — Amazon SNS is now available in Nano and offline. You can work with topics, subscriptions, publish, batch publish, FIFO topics, platform applications and SMS, with a matching console experience in the browser and the offline appliance.
  • 3.0.27 — Amazon Kinesis Data Streams is now available. The offline appliance includes a new Kinesis Data Streams engine, and it is wired into the console, service catalog and cost model in both Nano and the offline appliance.
  • 3.0.26 — Metrics get a shared VictoriaMetrics backend. Metrics from the simulator are now stored in VictoriaMetrics, in both Nano and the offline appliance.
  • 3.0.25 — New service: AWS API Gateway V2, in Nano and offline. It now has a working data plane with live routes, Lambda proxy (1.0 and 2.0), JWT and Lambda authorizers, throttling, CORS and HTTP proxy, plus a console, Go SDK and CLI coverage.
  • 3.0.24 — Nano relay tunnel works again. It failed to start since 3.0.18 because six Azure engines weren't loaded; external SDKs and CLIs can reach Nano through the tunnel again.
  • 3.0.8 — /api/spaces no longer 500s on binary S3 objects; EC2/GCE create no longer 500s on an unwritable deploy dir; Nano Azure home fixed; VYOMI_NO_TELEMETRY opt-out; release checks published per release.
  • 3.0.7 — 14-day Pro trial on "Activate appliance"; redesigned space cards (single status pill, icon actions); Nano tunnel fix.
  • 3.0.6 — Docker Desktop auto-start/install on macOS; console-conformance CI fixes.
  • 3.0.5 — Per-space TTL timer shows on launched cloud sandboxes.
  • 3.0.4 — Per-space TTL for enterprise/shared spaces; winget channel dropped.
  • 3.0.3 — aws s3 ls at the service root fixed; Nano second-level consoles, durable in-browser state, per-service cost savings; remote SSH/DB via Codespaces.
  • 3.0.2 — Console polish and backend warm-up.
  • 3.0.1 — Real SSH into simulated compute; honest install-globe geography.
2.x — real backends, Nano, parity, launcher
  • 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.x — launch and launcher hardening
  • 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
# headless: API/SDK/CLI only — use Nano (https://vyomi.cloud/nano) for the UI
curl http://localhost:9000/healthz

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

Appliance 4.0.0 is headless — it serves the API, SDK and CLI endpoints only (no console UI). Vyomi Nano at https://vyomi.cloud/nano is the only UI. Useful endpoints:

  • /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"
}

Use with AI coding agents (MCP)

vyomi mcp is a Model Context Protocol server, so Claude Code, Claude Desktop, Cursor or VS Code can check the simulator, see which services Vyomi emulates, scan your project and wire its SDKs to the simulator.

claude mcp add --scope user vyomi -- vyomi mcp          # Claude Code: MCP server only

Or install the Claude Code plugin (the MCP server plus a setup skill):

/plugin marketplace add vyomi-cloud/claude-plugins
/plugin install vyomi@vyomi

Then, in any project: "Set this project up to run against Vyomi." Claude scans the code for AWS / GCP / Azure usage, reports what is emulated and what isn't, and asks before writing a .env.vyomi with the local endpoints. Your production config is not touched. Tools: vyomi_status, vyomi_services, vyomi_env, vyomi_scan_repo, vyomi_write_env. Details: cmd/vyomi/README.md.

Reference apps

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

AppCloudStackServices exercised
tests/e2e/java-ordersAWSSpring Boot, Java 17RDS · S3 · SQS · EventBridge · Secrets Mgr · KMS · IAM
tests/e2e/go-inventoryGCPGo + chiCloud SQL · GCS · Pub/Sub · Eventarc · Secret Mgr · Cloud KMS · IAM
tests/e2e/azure-ticketsAzureGo + chiPostgres 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 and Max add Docker compute and the Mesh; they differ in one way: Pro gets every service on one cloud of your choice, Max gets 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 licensing@vyomi.cloud.

NPM
vyomi-tunnel
Install Command
npm install vyomi-tunnel
Runtime: npx