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
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:
| Layer | What GizApp gives |
|---|---|
| Database | The table and its migrations. A field rename with @was keeps the data. |
| Forms | An HTML form with the labels, limits and errors of the fields. |
| Validation | The same checks on the server for browsers, the API and agents. |
| API | JSON input and output with typed rejections (401, 403, 404, 409, 422). |
| Agents | A tool schema for each Action. Agents call the same Action as people. |
Pages are typed markup
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
No hydration and no client framework: a page carries one small kernel.
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.
Pages, actions, static files, gzip and realtime in one native process, a worker for each CPU.
Declarative shadow DOM from the server, with no build step.
One call makes an app installable and usable offline. The same app compiles to WebAssembly for an edge fetch handler.
Markdown collections checked by a model, navigation, llms.txt, sitemaps, drafts and review. This site runs on it.
Site headers, docs layouts, tabs, callouts, data regions with loading, empty and failed states, time ranges and log views.
Next steps
Routes, layouts, forms, streaming, static files, sessions, tests and deployment.
One record type for the table, typed queries, forms and views.
Put the app at its own address, and change it live.