Open source Free forever · runs 100% on your machine

Build real apps from a prompt. Entirely on your machine.

Cascade is a local-first AI app builder powered by your own Ollama models. An agent writes the code, runs it in a sandboxed container, and shows you a live preview — no cloud, no API keys, no lock-in.

Download for Windows Star on GitHub

No sign-up. No telemetry. Bring your own model — ollama pull qwen2.5-coder and go.

Cascade velocarta× ─▢✕
Cascade ▼
New project
Home
Projects
Chats
Connectors
Settings
Recent projects
velocarta
saas-dashboard
portfolio-site
Ollama · connected
Act as an expert UX/UI designerqwen2.5-coder
continue where we left off ▼
Act as an expert UX/UI designer. Build "Velocarta" — a premium bike accessories store.
Tasks0/4
✓Scaffold Vite + React app
✓Build hero, categories & cart
✓Install dependencies in the sandbox
✓Run dev server & verify green
›Thought process
▶ CreatedLandingView.tsxcomponents +175
▶ CreatedCatalogView.tsxcomponents +115
Reading src/App.tsx
The views ship hardcoded NavBars that don't accept cartCount / addLine. Updating each view's interface:
▶ EditingLandingView.tsxcomponents ✕
▶ head -35 src/components/Landi… ✓
Tabs — the file uses tabs, not spaces. Retrying with a targeted edit:
▶ EditedApp.tsxsrc +4 −1
▶ npm install· sandbox ✓
▶ npm run dev· :4320 ✓
Done — Velocarta is live: serif hero, four collection categories and cart wired. Build is green. Want a bestsellers row next?
Ask Cascade… qwen2.5-coder ▾↑
Preview Code Versions Terminal
▼src
▶assets
▼components
▶blocks
▶ui
CartView.tsx
CatalogView.tsx
LandingView.tsx
ProductDetailView.tsx
▶hooks
▼lib
TSdata.ts
TSphotos.ts
TSstorage.ts
TStypes.ts
TSuseHistoryView.ts
TSutils.ts
▶themes
App.tsx
#fonts.css
#index.css
main.tsx
TSvite-env.d.ts
·.gitignore
M↓AI_RULES.md
{}components.json
<>index.html
{}package.json
M↓PLAN.md
{}tsconfig.json
LandingView.tsx
import { useMemo } from 'react'
import type { ComponentType } from 'react'
import * as Lucide from 'lucide-react'
import { Button } from '@/components/ui/button'
import { Badge } from '@/components/ui/badge'
import { NavBar } from '@/components/blocks/NavBar'
import { Hero } from '@/components/blocks/Hero'
 
import { Section } from '@/components/blocks/Section'
import { MediaCard } from '@/components/blocks/MediaCard'
import { StatStrip } from '@/components/blocks/StatStrip'
import { Footer } from '@/components/blocks/Footer'
import { Photo } from '@/components/blocks/Photo'
import { photo } from '@/lib/photos'
import { PRODUCTS, CATEGORIES, BESTSELLERS } from '@/lib/data'
import type { View as AppView } from '@/lib/types'
 
type View = AppView
 
interface LandingViewProps {
cartCount?: number
addLine?: (productId: number, qty?: number) => void
setView: (v: View) => void
onOpenProduct: (id: number) => void
}
 
function FeatureIcon(name: string): ComponentType<{ className?: string }> {
const map: Record<string, keyof typeof Lucide> = {
Durability: 'ShieldCheck', Warranty: 'BadgeCheck', Design: 'Palette', Shipping: 'Truck'
}
return (Lucide as any)[map[name] ?? 'Star']
}
 
export function LandingView({ setView, onOpenProduct, cartCount = 0 }: LandingViewProps) {
const featuredCategories = CATEGORIES.slice(0, 4)
const bestsellerProducts = useMemo(() => PRODUCTS.filter(p => BESTSELLERS.includes(p.id)), [])
 
return (
<main className="min-h-screen bg-background text-foreground">
<NavBar
variant="floating"
brand="Velocarta"
links={
<>
<span
className="cursor-pointer text-sm text-muted-foreground transition-colors hover:text-foreground"
onClick={() => setView('landing')}
>
⎇ main · +512 −0 ● sandbox healthy · node:20-alpine ollama · qwen2.5-coder 100% local
Providers

Bring your own key.

Cascade speaks the OpenAI wire protocol, so it points at whatever you already pay for — or at nothing at all, and stays local. Your key, your account, called directly; nothing proxies through us.

Ollama OpenAI Groq OpenRouter NVIDIA vLLM
Any OpenAI-compatible endpoint Paste a base URL and Cascade talks to it — no adapter to write.
Keys never leave your machine They live in your shell or .env, never in committed settings.
Models

Bring your own model.

Whatever Ollama can run, Cascade can drive — swap per project, no re-install.

If Ollama runs it, Cascade runs on it
qwen2.5-coderAlibaba · 1.5B–32B llama3.3Meta · 70B deepseek-r1DeepSeek · 1.5B–671B gpt-ossOpenAI · 20B–120B devstralMistral · 24B gemma3Google · 1B–27B qwen3Alibaba · 0.6B–235B mistral-smallMistral · 24B codellamaMeta · 7B–70B

Nine of the models people run most — the full Ollama library works the same way.

100%Local & private

Prompts, code and data never leave the machine.

0API keys required

Nothing to sign up for. Add your own key later only if you want cloud.

Apache-2.0Open source

Every line public — read it, fork it, ship with it.

Any modelOllama-native

Swap models per project — 7B laptop to 70B workstation.

Customization

Tune every model.
Down to the token.

Cascade ships a full model manager — curate your picker, set the context window and output cap per model, dial sampling, and manage provider keys. Changes apply live, on the next turn.

Your models

Curate what shows in the picker — add by name or straight from a provider's catalog, then switch in one click.

Parameters

Context window, max output tokens, temperature and top-p — per model, with Auto to defer to the backend default.

Providers & keys

Ollama runs local; OpenAI, Groq, OpenRouter and NVIDIA take your key. Set it for the session or persist it in .env.

Applies live

No restart, no re-index. Save and the very next turn uses the new model and settings.

Models & providers

Curate the models in your picker, add models manually or from a provider's catalog, and tune each model's context window, output cap, and sampling. Changes apply live — no restart.

Your models11
gpt-5.6-lunaopenai
gpt-4.1openai · 63K ctx
qwen36-agenticollama · 128K ctx
gemma4:latestollama
gpt-oss:20bollama · 128K ctx
qwen3.6:27bVAST AI · 128K ctx
＋ Add model
Providers
Ollamalocal
Openaikey set
Nvidiakey set
Groqno key
Openrouterno key
gpt-5.6-lunaActive
Openai
TOOLSVISION
Parameters
Context windowAuto
4K8K16K32K64K128K256K512K1M
Model max: 1M.
Max output tokensAuto
256128,000
Cap on tokens generated per turn (num_predict / max_tokens).
TemperatureAuto
0.001.00
Higher = more random.
Top PAuto
0.001.00
Nucleus sampling.
Save parameters Auto = backend default. Applies live to the next turn.
OpenAI API key
Key set — enter a new one to replace Save
Applies to the running server this session. For persistence set it in .env.
Observability

Every turn, on the record.
Nothing extra to run.

Local models fail in ways you have to see to fix — a loop that never converges, a cache miss that doubles every call, a plan the model quietly ignored. Cascade ships its own trace viewer, writing to a file on your disk. No collector, no Python service, no account.

The whole turn, nested

One message is one trace — every model call, every tool call and every sub-agent it delegated to, in the order they happened.

The prompt, in full

Not a preview. The entire message list as sent, the reasoning kept as reasoning, every tool's input and output — stored uncapped.

Where the time went

Tokens per call and real context occupancy. On local backends prefill and decode split out — a cold cache reads nothing like a slow model.

Search across every run

Every failed command, every turn that touched a file, every loop breaker that fired — across your whole history, not one trace at a time.

Cascade's Observatory: the span waterfall for one agent turn, with a nested planner sub-agent, beside the selected model call's full prompt, reasoning and token counts.

Already have Phoenix, Langfuse or another OTLP collector? Point Cascade at it with one environment variable — the same traces, exported as OpenTelemetry spans, with nothing to change.

Why Cascade

Everything the cloud builders do.
Nothing they take from you.

The full prompt-to-running-app loop — chat, code, sandbox, preview — rebuilt from first principles to run on your hardware, with your models.

Yours, entirely

Your prompts, your code, your data — none of it leaves your machine. No accounts, no telemetry, no usage caps. Work on a plane, in a lab, or behind an air gap.

$ cascade — starting…
✓ engine ready · 0 network calls
✓ model: qwen2.5-coder · local

Sandboxed by design

Every project gets its own Docker container. The agent's shell commands and dev server run inside it — it can build anything without ever touching your machine.

▸ Bash npm run dev
container: sneaker-store · node:20-alpine
✓ host untouched

Live preview, instantly

The dev server runs in the sandbox and streams straight into the builder. Prompt, watch the diff, see it running — one loop, no deploys.

A real agent engine

Not a prompt wrapper — a full agentic loop with tools, permissions, subagents, 3-tier memory, context compaction and error recovery.

ReadWriteEditGlobGrepBashSubagentMCP

Watch it think

An activity-first timeline shows every file written, every command run, live — then the answer lands whole. No wall of streaming tokens.

One engine, everywhere you work

The same headless core drives every frontend over one protocol — use the app builder in your browser, the agent inside VS Code, or the native Windows app.

Web builder
VS Code extension
Windows appSoon
How it works

Prompt to running app in three steps.

01

Describe what you want

Start from a template and tell the agent what to build — a store, a dashboard, a game. Plain words, no boilerplate.

› build a sneaker store with cart & checkout
02

The agent builds it

It plans, writes files, installs dependencies and fixes its own errors — every step visible in the live activity timeline.

✓ 9 files written · npm install · self-check passed
03

See it run. Keep going.

The dev server spins up in the project's container and appears in the preview pane. Iterate by chatting — every change is git-tracked.

● live on localhost:5173 — ask for changes

Ready when you are.

Your models. Your machine. Your apps.

Get Cascade
Open source

Built in the open,
from the first commit.

Every line, publicThe whole engine — agent loop, tools, sandbox, builder UI — lives in one repo you can read, fork and audit.
From scratch, not a forkCascade re-derives the agent algorithm phase by phase — a codebase you can actually learn from, not a wrapper around someone's API.
Free means freeApache-2.0. No pro tier holding features hostage, no seat licenses, no "contact sales". Run it, ship with it, build on it.
abhis / cascade Public
A local-first, Ollama-native AI coding agent and app builder. One headless engine, many frontends.
TypeScript React Apache-2.0