Flagship - now in production

One language. Every surface.

GaiaLang is the authoring substrate underneath everything Gaia ships. Write a source once. The compiler can emit the web page, terminal UI, agent prompt, policy row, typed clients, services, workers, or runtime modules. The same compact source stays readable for humans and token-efficient for LLMs.

Request alpha access See it work

Targets

HTML / SSRTerminal UIAgent promptKernel registryLanguage backendsLLM context

launch-control-room.gaia

page "Product/launch-control-room"
  section: Product
  kind: reference
  title: "Launch Control Room"
  status: Draft
  summary: "One source for the page, agent prompt, workflow policy, and launch checklist."

section "What the user asks for"
  A founder describes the product in plain language.
  Gaia turns the explanation into specs, tasks, code, review gates, and release notes.

section "Workflow"
  | Step | Human-readable output | Gaia output |
  | Plan | scope, risks, approvals | work items + policy checks |
  | Build | feature page + dashboard | code + tests + deploy plan |
  | Review | checklist + decision log | reviewer queue + audit trail |
  | Ship | release note | routed deployment event |

section "Language targets"
  | Target | Example output |
  | TypeScript | typed UI client |
  | Python | workflow worker |
  | Go | service adapter |
  | Rust | runtime module |

section "Guardrail"
  Keep the source readable. Every generated surface must trace back to this page.

|
v

Wiki Prompt TypeScript Python Go Rust

Same source. Many compiled targets. Zero hand-translation.

GaiaLang syntax

The source is readable before it compiles.

GaiaLang pages use a small, highlighted authoring grammar: page metadata, section blocks, lists, tables, wiki links, and embedded script only where logic is needed. That keeps wiki pages, product specs, prompts, and policy rows understandable to people before the compiler emits them for Gaia services.

Language backends

One source can lower into whatever runtime the job needs.

GaiaLang is not tied to one output language. The source stays human-readable while emitters can generate TypeScript for apps, Python for workflow glue, Go for services, Rust for runtime modules, or another target when the platform needs it.

Built for LLMs

Token-efficient context by design.

GaiaLang gives agents compact structure instead of dumping loose docs into the prompt. Stable sections, typed metadata, tables, and explicit links let Gaia load only the slice a task needs, preserve cache-friendly prefixes, and turn the same source into prompts, policies, UI, and code.

Why this exists

Most stacks have four sources of truth. We have one.

Documentation drifts from code. Policies drift from the kernel that enforces them. The UI string differs from the agent prompt that explains it. GaiaLang treats this as a category error. The component, the rule, the prompt, and the page are not separate things that need to stay in sync. They are one source the compiler lowers into whatever target the job needs.

Emit targets

Write once. Ship everywhere Gaia runs.

gaia-web

HTML / SSR

Pre-rendered pages plus hydration. Wiki ships as 128 typed pages today.

gaia-cli

Terminal UI

JSON render tree consumed by Gaia terminal clients; other runtime backends can be emitted from the same source.

gaia-cli

Agent prompt

The same source the humans read becomes the system prompt the agents use.

gaia-kernel

Kernel registry

Policies become rows. Decisions cite the same lines humans see.

services

Language backends

Emit TypeScript, Python, Go, Rust, or another target when a workflow needs a different runtime.

agents

LLM context

Compact structure, typed metadata, and stable sections keep prompts small and cache-friendly.

Hard and soft tiers

Prose hot-patches. Behavior gates.

Not every diff carries the same weight. A typo in a policy paragraph is not a behavior change. A new rule on the kernel is. GaiaLang classifies every change and routes it accordingly. The compiler is the gatekeeper, not a meeting.

Soft tier

Prose inside <Soft> regions

Live-patch broadcast. No image rebuild. No deploy. Clients pick up the signed patch and hot-swap.

Hard tier

Behavior, structure, or kernel rules

PR + database ratification. CI lockstep check flags it. Nothing runs until it is signed off.

The four principles

What makes GaiaLang different.

One source. Many targets.

The compiler owns the lowering. The wiki page, agent prompt, terminal UI, policy row, typed client, worker, and service adapter can all come from the same source.

Wiki is code.

Docs and code do not drift because they are the same artifact. A diff to a policy paragraph either ratifies as soft text or fails the lockstep check.

Tighten-only inheritance.

Soft overrides may narrow a rule, never loosen it. The compiler enforces the direction.

Owned compiler.

Gaia owns the authoring substrate. Product specs, wiki pages, prompts, policies, and emitted artifacts move together under one compiler.

Shipping today

Not a roadmap. A build.

128 wiki pages compiled

6 target families

14 compiler integration tests

0 broken links at build

Try GaiaLang

Describe the product. The substrate carries the rest.

The same compiler powering the page you are reading powers every product Gaia ships. Start a project and you are on it from the first line.

Request alpha access