GizStack

GizApp

Full-stack apps from one typed model.

Declare a record type once. GizApp derives the table, the form, the validation, the JSON API and the agent tool from it. Pages render on the server, a small kernel (about 10 KB compressed) adds interaction, and open pages update when the data commits.

The same pages run on a terminal through gizapp/tui or in a desktop window through gizapp/window. gizapp/host owns their run. Pages, components, actions and front ends are one package.

Available Runs today, as shown. Roadmap

One model, every layer

gizlang
import {Table, Key, Label, Min, Max, Trim} from "gizmodel/model";

@Table("todos")
export type Todo = {
    @Key id: i64;
    @Label("Title") @Min(1) @Max(200) @Trim title: string;
    @Label("Done") done: bool;
};

Model.shape<Note>() reads the Shape of a type from its declaration at run time: no generated file. From it you get:

LayerWhat GizApp gives
DatabaseThe table and its migrations. A field rename with @was keeps the data.
FormsAn HTML form with the labels, limits and errors of the fields.
ValidationThe same checks on the server for browsers, the API and agents.
APIJSON input and output with typed rejections (401, 403, 404, 409, 422).
AgentsA tool schema for each Action. Agents call the same Action as people.

Pages are typed markup

gizlang
import {Html} from "gizlang/html";

type ListProps = { todos: Vec<Todo>; };
export function TodoList(p: ListProps): Html {
    return <ul>
        <li each={t of p.todos} data-k={string(t.id)}><input type="checkbox" checked={t.done}/> {t.title}</li>
    </ul>;
}

Markup in .giz files has TSX syntax. It compiles to escaped HTML, so an injection needs an explicit raw.

Why GizApp

  • Server HTML is the state

    No hydration and no client framework: a page carries one small kernel.

  • Live views

    A page subscribes to its data. When a row commits, the server sends a patch for the changed elements only. Typed text and focus stay.

  • Actions for people, APIs and agents

    One typed Action handles the page's form, the JSON call and the agent tool call, with the same checks and the same Gate.

  • One process on every core

    Pages, actions, static files, gzip and realtime in one native process, a worker for each CPU.

  • Web Components

    Declarative shadow DOM from the server, with no build step.

  • Offline and edge

    One call makes an app installable and usable offline. The same app compiles to WebAssembly for an edge fetch handler.

  • A CMS built in

    Markdown collections checked by a model, navigation, llms.txt, sitemaps, drafts and review. This site runs on it.

  • Components and design tokens

    Site headers, docs layouts, tabs, callouts, data regions with loading, empty and failed states, time ranges and log views.

Next steps

  • Build web apps

    Routes, layouts, forms, streaming, static files, sessions, tests and deployment.

  • Model your data

    One record type for the table, typed queries, forms and views.

  • Deploy to GizStack

    Put the app at its own address, and change it live.