The file, and the platform you build on it

kinogaki

Prism is a structured file format whose whole contents are a typed model your programs and AI agents read and change directly. kinogaki is the platform on it: build one application that runs as a native app or in any browser, with agents that edit its state for free. Start here, then explore the libraries, the software, and the apps built on the stack.

What this is

Prism is a structured file format. Kinogaki is the platform you build on it. A Prism file holds documents, scenes, assets, graphs, and their links as one typed object model: a path-addressed tree of typed values that any program or AI agent reads in full, changes precisely, and writes back without losing structure. A file made by an app is usually a blob only that app understands. A Prism file is open all the way down.

On the file, Kinogaki is a full stack. Write an application once and run it as a native app on the desktop or in any browser. Its state is a Prism file behind a typed server, so an AI agent edits it through the same operations a person does. See how the pieces fit.

Explore

Build on Prism. The libraries:

• Kinogaki Core: the document model, the evaluator, the codecs, the C ABI.
• Kinogaki UI: the GPU widget toolkit. The same widgets draw natively or in the browser.
• Kinogaki Platform: windowing, input, the GPU interface, the buses, the server-driven-UI transport.

Work with Prism files. The software:

• Kinogaki CLI: check a file, convert formats through Prism, pack a directory into one file.
• Kinogaki Server: the bridge that lets agents and MCP clients edit a live document through typed operations.
• Kinogaki Editor: a native editor with the server built in. Edit alongside an agent, live.

See it built. Open-source apps:

• Kinogaki Light (generative geometry and light), Kinogaki Pixel (pixel art), Kinogaki Atlas (a novel as one structured file).

Go deeper: Architecture walks the whole system end to end. Why Prism is the problem it solves. The Quickstart opens your first file in a few lines.

One model under everything

Everything in a Prism file lives in a Document. A Document is a set of Elements (nodes of a tree) indexed by Path, each carrying typed Properties. The structure is the data: it sits in plain view as a tree, addressable by Path.

#prisma 3.0
def group "world" {
    def object "ball" {
        float3 position = (0, 1, 0)
        float  radius   = 1.5
        float3 albedo   = (1, 1, 1)
        albedo.connect  = </world/mat.out>
    }
}

Five concepts carry the whole design: the Document (the file), the Element (a node: a Path, a type token, typed properties), the Path (the identity; hierarchy lives here, so references resolve and cycles stay impossible), the Property (a typed Value, optionally varying over time), and the Value (the typed datum: a bool, number, string, or array). A 3-D scene and a text Document differ only in which type tokens and properties their Elements use; the machinery underneath stays the same. See the model.

Files that point at each other

Inside one file, a property can connect to another Element's output, so the Document is also a graph. Across files, an Element can reference another Document and pull it in: model an asset once, reference it many times, fix it in one place. Information stays linked rather than copied, so references resolve by Path.

Read and written by anything

Foreign formats are codecs, and each targets a canonical model shared by every codec of its kind. Prism sits in the middle of a conversion as the neutral form, with defined round-trips rather than lossy guesses:

kinogaki convert notes.md   notes.html     # markdown → one document model → html
kinogaki convert data.json  data.prisma    # json → a navigable Prism Document

And a whole project packs into one file: a folder is a Document, so pages, diagrams, stylesheet and images bundle into a single compressed .prism you open as one object.

A real file for tools and agents

Because the file is a typed object model rather than a blob, programs and AI agents operate on it safely. "Insert a paragraph after the third heading", "set every light's intensity to 80%": each is a precise, validated change to a named address, not a fragile text or binary edit. The Kinogaki Server is the bridge that exposes those operations to external tools, including MCP clients like Claude Code, through stable typed operations instead of raw bytes. These very docs were authored three ways onto the same model: written by hand, converted from Markdown, and built by an agent through the server.