GizStack

The GizStack developer platform

Natively compiled TypeScript, with the whole stack built in.

A modern web framework and server, OLTP and OLAP SQL (PostgreSQL- and Oracle-compatible), vector search, key-value, distributed POSIX and S3 storage, GPU tensors, and local LLM, image and video generation. Gizlang is open source (MIT); GizStack runs your app at its own address.

A local AI app in two files

The chat app: agents and chats on the left, a plan and an answer in the middle

An agent chat in the spirit of ChatGPT: conversations, plans, sub-agents, tools that wait for your approval, file attachments, stop, and a choice of models. It runs on your computer with a local model, and every open tab shows the answer live. The program is this file, and the page is pages/index.ghtml, 90 lines of HTML with state. There is no API route, no client script and no build step.

gizlang
// A local AI chat app of agents: conversations, plans, sub-agents, tools that wait for approval, attachments and a
// choice of models. The models run on this computer, or come from your giz.ai account (`giz auth login`) or any
// OpenAI-compatible API (AI_URL, AI_API_KEY). The page (pages/index.ghtml) writes a message as a row; Chat.serve runs
// the agent and writes its answer as rows while it comes, and every open page shows them live.
// Run: giz run main.giz, then open http://127.0.0.1:8080. With TLS_DOMAINS=chat.example.com set, it gets its
// certificate and serves HTTPS with HTTP/2 and HTTP/3.
import {System} from "gizlang:system";
import * as Pages from "gizweb:pages";
import * as Chat from "gizweb:chat";
import * as Ai from "gizai:ai";
import * as Agent from "gizai:agent";
import {site} from "./pages/.routes";

/** Draws a picture. */
type Picture = {
    /** What the picture shows, in detail: the subject, the place, the light and the style. */
    prompt: string;
};
/** Films a video clip of about four seconds. */
type Clip = {
    /** What happens in the clip, in detail. */
    prompt: string;
};
/** The address of the file the tool made. */
type Made = { file: string; };

function main(sys: System): i64 {
    const app = Pages.app(sys, site, Chat.shapes());
    const ai = Ai.studio(sys);
    const draw = Agent.tool<Picture, Made>(
        "draw", (p: Picture): Made => ({ file: app.file(ai.image(p.prompt), "png") })
    );
    const film = Agent.tool<Clip, Made>("film", (c: Clip): Made => ({ file: app.file(ai.video(c.prompt), "mp4") }));
    Chat.serve(
        app, ai, Agent.agent(ai.model(), "You are a helpful assistant. Draw or film when asked to.", [draw, film])
    );
    return app.listen(8080);
}
sh
npm install -g @gizai/cli
giz init my-chat --template chat && cd my-chat
giz run main.giz                 # then open http://127.0.0.1:8080

The first answer downloads Qwen 3.5 4B from Hugging Face (about 9 GB) into ~/.cache/gizlang. It runs on the CPU, and much faster on an NVIDIA GPU. Pick another model in the page, or set AI_URL for any OpenAI-compatible API.

CloudBuild with AI

Describe an app. GizStack writes it, tests it and deploys it to a live URL.

Free during the preview. Sign in when you build.

LocalInstall the toolchain

One npm command installs giz: the compiler, GizDB, the web server and live reload. The chat template is a local AI app.

sh
npm install -g @gizai/cli
giz init my-chat --template chat && cd my-chat
giz run main.giz

Linux x86-64 (on Windows, in WSL 2), with Node.js 16 or later. macOS comes later.

All downloads →

Read the docs → · Run code in the browser →

From zero to a live app in 60 seconds

  1. Install. npm install -g @gizai/cli: no administrator account, no other dependencies.
  2. Make a project. giz init my-chat --template chat && cd my-chat
  3. Run it. giz run main.giz compiles to native code and runs.
  4. Deploy it. With your terminal token, one curl puts an app at its own https://NAME.giz.sh.
  5. Change it live. Save a file. The running app takes the new code and keeps its state.

Available Runs today, as shown. Roadmap

Measured, not promised

  • 302,589 req/s

    HttpArena profiles: baseline. actix: 212,098 req/s. Bun: 269,761 req/s. dusty: 229,754 req/s.

  • 394 tps

    pgbench: TPC-B, 1 client. PostgreSQL 16: 340 tps.

  • 1.86–1.96 s

    Live updates: Deploy to the change in an open page, in production.

  • 53 ms

    Live updates: An app of 800 lines: edit to one function body (p50).

  • 0.826 x

    TPC-H: TPC-H SF10: GizDB time over DuckDB time, geometric mean. DuckDB: 1 x.

  • 90.7

    LangArena: Runtime score. Rust: 90.6. C: 90.2.

Each number has its date, machine and method on the benchmarks page.

Gizlang: TypeScript syntax, native code

Available Runs today, as shown. Roadmap

gizlangRun
type Order = { id: i64; total: i64; paid: bool; };

function revenue(orders: Vec<Order>): i64 {
    let sum = 0;
    for (const o of orders) { if (o.paid) { sum += o.total; } }
    return sum;
}
function main(): void {
    const orders = [Order(1, 120, true), Order(2, 80, false), Order(3, 45, true)];
    print("Revenue: " + string(revenue(orders)));
}
text
Revenue: 165
  • Compiled through LLVM to one native executable. No runtime to install, no VM warm-up.
  • No garbage collector. Memory goes back when its last owner goes. No pauses.
  • Errors are values. Result and Option, and a match that must cover every case.
  • One toolchain. Compiler, tests, formatter, docs, language server and live swap in gizlang.

Learn Gizlang →

GizDB: one database for every kind of data

Available Runs today, as shown. Roadmap

sql
-- One engine: transactions, analytics, key-value and change feeds.
CREATE TABLE orders (id bigint PRIMARY KEY, city text, total numeric(10,2));
INSERT INTO orders VALUES (1, 'Seoul', 12.50), (2, 'Busan', 7.25);
SELECT city, sum(total) FROM orders GROUP BY city;
  • Speaks PostgreSQL. psql, node-postgres, psycopg and JDBC connect unchanged.
  • Speaks Redis. redis-cli on the same data, durable on every write.
  • Embedded or a server. import {open} from "gizdb" in your program, or gizdb serve.
  • Durable. 68,412 transactions acknowledged under kill -9, every one whole after restart.

Explore GizDB →

GizWeb: full-stack apps from one typed model

Available Runs today, as shown. Roadmap

gizlang
type Todo = { id: i64; title: string; done: bool; };

export function Todos(p: { todos: Vec<Todo> }): Html {
    return <ul>{each(p.todos, (t: Todo) =>
        <li><input type="checkbox" checked={t.done}/> {t.title}</li>)}</ul>;
}
  • Server HTML is the state. A 1.2 KB kernel instead of a client framework.
  • One model for the table, the form, the validation and the API.
  • Live views. Pages update when data commits. Open forms keep what people typed.
  • Measured: 1,739 req/s on one CPU where the same app on Next.js 16 does 197 req/s.

Explore GizWeb →

Storage: objects, files and volumes in one layer

Preview Runs today. The interface can still change. Roadmap

sh
giz storage bucket create photos
giz storage cp photo.jpg giz://photos/2026/photo.jpg
giz storage presign giz://photos/2026/photo.jpg 3600
  • The S3 API for the tools you have.
  • A POSIX mount for programs that read files.
  • Block volumes for databases and computers.
  • One quota and one permission model with the rest of GizStack.

Explore Storage →

The platform

  • Giz AppsAvailable

    Describe an app or start from a template, edit its code, deploy it live in about two seconds.

  • Giz ComputerComing

    Persistent computers and volumes, in our regions or on your servers.

  • Giz DriveComing

    Files and documents with versions, sharing, search and sync.

  • Giz AgentComing

    AI agents that do the work inside your rules, approvals and budgets.

  • Giz OntologyComing

    Business objects, relations and Actions, with ready industry packages.

  • Giz DataComing

    Analytics, dashboards and BI, directly on GizDB.

  • AI GatewayComing

    One metered endpoint for AI models, with budgets and caps.

All services run on one language, one database, one storage layer and one security model. How they fit together →

Built for AI agents

  • /llms.txt

    Every page of this site as Markdown, in one list. /llms-full.txt is all of it in one file.

  • Copy as Markdown

    Each docs page copies as Markdown or opens in ChatGPT and Claude with one click.

  • JSON from the compiler

    giz check --json, giz outline and giz capabilities give agents structured answers.

  • MCP

    The console's actions are MCP tools. Agents pass the same permission checks as people.

Your code stays yours

  • Signed releases

    Every release is signed with Ed25519. The installer checks each file's SHA-256 before it installs anything.

  • Free for most developers

    Gizlang is open source under the MIT license: use it, change it and ship it, commercially too, for free.

  • Isolated apps

    Apps run on their own domain, in their own process, with their own database.

Start now

Write it once. Run it everywhere. Change it live.