Describe the workloads you want to run — a database, a handful of services, some storage — and Cloud Cost Estimator turns them into a production-ready Kubernetes cluster plan, then prices that plan side by side across 14 cloud and bare-metal providers. Tune the redundancy, sizing and storage assumptions and every provider's monthly total updates instantly, so you can see what each step up in robustness actually costs before committing to a provider.
A lightweight Tauri desktop app (TypeScript frontend, native OS webview — no bundled Chromium). The providers: Hetzner, Netcup, Contabo, OVHcloud, Scaleway, UpCloud, AWS, Azure, Google Cloud, DigitalOcean, Linode/Akamai, Vultr, Alibaba Cloud and Tencent Cloud — cloud VMs and bare metal, managed and self-managed Kubernetes and storage.
- Two sizing lenses — Production HA (guaranteed vCPU, HA standby replicas, N+1 spare node, 3-node minimum, dedicated control plane, HAProxy pair, 3× storage replication, headroom) or Right-sized / overcommit (sustained CPU utilisation instead of full requests, RAM overcommit). Every redundancy rule is an independent toggle.
- Storage choice — managed block storage, or self-managed Longhorn / Ceph on node disks; egress, NAT, IPv4 and backup costs are always modelled.
- Install / setup fees shown separately from monthly totals (
€X/mo + €Y one-time). - Custom costs — extra monthly or one-time lines (licenses, SaaS, support) added to every scenario.
- Saved plans — name, save, reload; export/import as JSON.
- An AI workload is defined by its input/output token volume (M tokens/month), not a GPU count. Each scenario prices it both on own GPU nodes and on a hosted API, and a rule picks API only, GPU only, the cheaper of the two, or both as separate scenario variants.
- Model presets — open-weight models carry a VRAM footprint and API €/1M-token rates; closed models (GPT, Claude, Gemini) are API-only. Alternatively pick a raw GPU class (Budget / Inference S / Inference L / Training) with optional VRAM constraints.
- GPU counts come from an editable per-GPU throughput table with separate prefill/decode rates; models too large for one node can span up to 4 nodes per replica.
- Work-hours mode — size the GPU pool for a peak window (hours/day × days/week) and let cloud nodes scale to zero off-hours.
- Commitment terms — on-demand / 1-year / 3-year, using each provider's actual savings program (AWS Savings Plans, Azure Reservations, GCP CUDs, …).
- Spot pricing — per-workload "Spot OK" flag packs tolerant workloads onto a spot worker pool; a separate toggle prices GPU nodes at spot rates. Spot scenarios show their total as a spot→on-demand range.
Uses your own LLM (CLI, API key, or any OpenAI-compatible endpoint) to:
- Analyze workloads — detect capabilities a workload already provides (observability, ingress, object store) and estimate real CPU use for the right-sized lens.
- Update pricing — refresh one or all providers to current list prices.
- Sanity-check the plan — audit sizing and every scenario's cost lines for hidden or missing costs, with one-click applicable corrections.
- Filter by provider, region (EU / US / Asia) and node type; sort as per-provider breakdowns or a flat grid by cost.
- Stacked-bar cost charts with a clickable legend that excludes whole cost groups from every total.
- Fully editable pricing catalog, including the LLM presets and GPU throughput table. Light + dark themes.
- Node.js 18+ and npm (builds the frontend with Vite).
- Rust (stable) and the Tauri CLI:
cargo install tauri-cli --version "^2". - Platform webview deps (Tauri prerequisites):
- Linux:
libwebkit2gtk-4.1-dev,build-essential,libgtk-3-dev,libayatana-appindicator3-dev,librsvg2-dev. - macOS: Xcode command-line tools. Windows: WebView2 (preinstalled on Win 11) + MSVC.
- Linux:
- For the AI features, whichever agent CLI you want on your
PATH(claude,codex,copilot,opencode) — or an API key for the Anthropic/OpenAI fallback, or any OpenAI-compatible endpoint (local or hosted) via the custom backend.
This project has no
@tauri-apps/*npm dependencies. It drives the build with the Rusttauri-cli(from crates.io) and reaches Tauri APIs through the injectedwindow.__TAURI__globals (app.withGlobalTauri = true).
Prebuilt bundles for Linux, Windows and macOS (Apple Silicon + Intel) are attached to
GitHub releases. The macOS bundles are unsigned: on first launch,
right-click the app → Open (or run xattr -d com.apple.quarantine on it).
To build from source:
npm install # frontend dev deps (vite, typescript)
# develop (hot-reload webview)
cargo tauri dev
# produce a native installer / binary for your OS
cargo tauri build # output under src-tauri/target/release/bundle/If you'd rather run it as a plain local web app (no desktop packaging), npm run dev serves the
UI in your browser — everything works except the CLI-based AI features (use an API-key backend
there, or the packaged app).
Regenerate the full platform icon set from the source icon at any time:
cargo tauri icon src-tauri/icons/icon.png.
Open AI & settings. Pick a backend:
| Backend | Command run |
|---|---|
| Claude CLI | claude -p "<prompt>" |
| Codex CLI | codex exec "<prompt>" |
| GitHub Copilot CLI | copilot -p "<prompt>" |
| opencode CLI | opencode run "<prompt>" |
| Anthropic / OpenAI API | HTTPS with your key |
| Custom OpenAI-compatible API | POST <base URL>/chat/completions (llama.cpp, vLLM, LM Studio, OpenRouter, …); API key optional |
| Ollama (local) | POST http://localhost:11434/v1/chat/completions — no key; installed models are offered as suggestions in the model field |
The program name and argument template ({prompt} placeholder) are editable, so you can adapt to
a CLI whose flags differ. Prompts are passed as a single argv item (no shell interpolation).
The custom backend takes a base URL (e.g. http://localhost:11434/v1) and model, with the API
key optional for local servers. Nothing leaves your machine until you press an AI button.
Allowed commands are pinned in src-tauri/capabilities/default.json; HTTP is limited to
HTTPS hosts and localhost.
The engine tests run against a real pricing catalog, which is not in git: generate
public/pricing.json first (fetch with AI in the app, then Export pricing JSON into
public/), or the suite will fail to load.
npm test # pure engine + LLM-parsing unit tests (tsx)
node tools/build-web.mjs # transpile the frontend to browser ESM (dist-web/)
node tools/verify.mjs # drive the real UI in headless Chromium + screenshotssrc/engine/ pure sizing + costing engine (types, pricing seed, plan.ts) — no DOM
src/platform/ Tauri/browser abstraction + pluggable LLM adapter
src/ui/ charts, saved-plans store, toasts
src/main.ts UI controller
src-tauri/ Rust host: shell + http plugins, window, capabilities, icons
tools/ local build/verify helpers (not part of the shipped app)
The repository contains no price data. At startup the app loads the catalog in this order:
- the locally persisted copy (localStorage — every edit is saved there automatically),
public/pricing.json(git-ignored, dev-server only — production builds strip it from the bundle, so installers and releases never contain price data),- nothing — the app then offers "✦ Fetch current pricing with AI", which builds the whole
catalog from scratch through your configured AI backend: per provider, all compute / GPU /
bare-metal SKUs (exact names, vCPU/RAM/disk, baseline NIC, per-GPU model/count/VRAM/class,
spot prices), managed K8s/LB fees, storage/egress/NAT/IPv4/backup rates, and spot/commitment
programs — plus the LLM model presets (API in/out rates, VRAM footprints) and the per-GPU
throughput lookup. Use Export pricing JSON afterwards to keep a
pricing.jsoncopy.
Whatever the source, prices are planning estimates — verify key numbers in each provider's cart before committing. The sizing model uses a single node type per worker pool and first-fit-decreasing bin-packing; it's a planning aid, not a quote.