{"id":6110,"date":"2026-10-16T02:35:47","date_gmt":"2026-10-16T05:35:47","guid":{"rendered":"https:\/\/tucumandevelopers.com\/index.php\/2026\/10\/16\/guml-let-the-model-write-24-lines-and-the-compiler-write-the-other-229\/"},"modified":"2026-10-16T02:35:47","modified_gmt":"2026-10-16T05:35:47","slug":"guml-let-the-model-write-24-lines-and-the-compiler-write-the-other-229","status":"publish","type":"post","link":"https:\/\/tucumandevelopers.com\/index.php\/2026\/10\/16\/guml-let-the-model-write-24-lines-and-the-compiler-write-the-other-229\/","title":{"rendered":"GUML: Let the Model Write 24 Lines and the Compiler Write the Other 229"},"content":{"rendered":"
\n
<\/div>\n

Read it once and you know the whole app: a typed resource with three mutations (two of them optimistic), a text draft, a three-way filter, a live count in the heading, a form, tabs, and a list with an empty state.<\/p>\n

Here it is compiled in the browser. This is the docs playground running the Rust compiler as WebAssembly:<\/p>\n

<\/a><\/p>\n

Notice the small line under the input: tabs \u2014 not lowered by this compiler version<\/code>. The in-browser preview renderer doesn’t draw tabs<\/code> yet, and it says so instead of drawing something approximate. That’s one of the project’s four invariants, and it’ll come up again.<\/p>\n

<\/a> A tour of the language <\/h2>\n

The whole syntax fits in a paragraph, which is the point: the full spec plus the vocabulary costs a model about 2,935 estimated tokens<\/strong> of prompt, and the spec file states a budget of 3,000.<\/p>\n

Lines are structure.<\/strong> Indentation is nesting, 2 spaces per level. No closing tags, no braces for blocks, no imports. A tab is an error (GUML0001<\/code>).<\/p>\n

Directives<\/strong> declare the data model: <\/p>\n

\n
page Counter title=\"Clicks\" \/\/ name -> component type Task {id, title, done:bool} \/\/ fields default to string state count=0 \/\/ type inferred from the initial value state filter=all|open|done \/\/ an enumerated domain; first value is initial data tasks:Task[] GET \/api\/tasks \/\/ a resource add POST \/api\/tasks {title} optimistic:prepend on {filter} >tasks.list \/\/ an effect: re-runs when filter changes <\/code><\/pre>\n
\n<\/p><\/div>\n<\/p><\/div>\n
Elements<\/strong> are tag [positionals] [name=value] [>action]<\/code>. Positionals can be a label, a modifier, a {binding}<\/code>, a \/route<\/code> or an #anchor<\/code>. The action comes last because ><\/code> swallows the rest of the line.<\/p>\n
Bindings<\/strong> are read-only expressions: paths, comparison, boolean logic, arithmetic, and a fixed set of aggregates (.count .sum .open .done .trim .lower .upper<\/code>). {tasks.open.count}<\/code> is “how many rows have the bool field unset”. It works on invoices too, where the bool is paid<\/code>, because the compiler reads the flag from the row type rather than from a name it hoped for.<\/p>\n
Actions<\/strong> are statements separated by ;<\/code>: >count++<\/code>, >count=0<\/code>, >tasks.add{title:draft}; draft=\"\"<\/code>.<\/p>\n
The vocabulary is closed.<\/strong> There are 49 primitives in a registry (card row col section nav hero form tabs list table btn input select metric modal toast<\/code>\u2026), 24 modifiers (primary ghost quiet danger sm lg center between<\/code>\u2026), and 12 global attributes. There is no class<\/code> attribute<\/strong>: presentation belongs to the theme.<\/p>\n
def<\/code><\/strong> declares a user component. It’s a compile-time macro with parameters and one slot<\/code>, and by the time codegen runs there’s no trace of it.<\/p>\n
Two conformance levels.<\/strong> core<\/code> is markup only: no I\/O, no state, meant to be safe to render from an untrusted agent. app<\/code> adds state<\/code>, data<\/code>, actions and the repeaters. An app construct at the core level is GUML0091<\/code>.<\/p>\n
Escape hatches.<\/strong> js<\/code> and raw<\/code> blocks pass through verbatim and unchecked. Each one emits a GUML0090<\/code> note, so the escape-hatch rate<\/em> stays countable. That rate is one of the things the research measures.<\/p>\n
  <\/a> Inside the compiler <\/h2>\n
The compiler is a Rust workspace of 14 crates, about 33,000 lines. The heaviest are guml-compiler<\/code> (about 10.7k lines, the analysis passes) and guml-codegen<\/code> (about 9.1k lines, the backends).<\/p>\n
<\/a><\/p>\n
The driver is short enough to quote. From crates\/guml-compiler\/src\/lib.rs<\/code>: <\/p>\n
\n
let<\/span> parsed<\/span> =<\/span> guml_parser<\/span>::<\/span>parse<\/span>(<\/span>src<\/span>,<\/span> reg<\/span>);<\/span> \/\/ ...<\/span> expand<\/span>::<\/span>expand<\/span>(<\/span>&<\/span>mut<\/span> program<\/span>,<\/span> &<\/span>mut<\/span> diagnostics<\/span>);<\/span> \/\/ def macros<\/span> sema<\/span>::<\/span>analyse<\/span>(<\/span>&<\/span>program<\/span>,<\/span> reg<\/span>,<\/span> &<\/span>mut<\/span> diagnostics<\/span>);<\/span> \/\/ scope + accessibility<\/span> validate<\/span>::<\/span>validate<\/span>(<\/span>&<\/span>program<\/span>,<\/span> reg<\/span>,<\/span> &<\/span>mut<\/span> diagnostics<\/span>);<\/span> \/\/ structure, methods, unused<\/span> types<\/span>::<\/span>check<\/span>(<\/span>&<\/span>program<\/span>,<\/span> &<\/span>mut<\/span> diagnostics<\/span>);<\/span> \/\/ expression types, aggregates<\/span> <\/code><\/pre>\n
\n<\/p><\/div>\n<\/p><\/div>\n
<\/a><\/p>\n
Diagram from the original<\/a>.<\/em><\/p>\n
All the analysis passes always run, even after an error, so diagnostics accumulate. Codegen runs only on an error-free program. There’s no separate IR: the AST, guml_ast::Program<\/code>, is what every backend consumes, and each backend lowers expressions through one shared function.<\/p>\n
The type checker is the newest stage and, according to the docs, the one that paid for itself most directly. It found a live bug in a published example where {invoices.open.count}<\/code> had been compiling to a filter on a field the type didn’t declare: always zero, and no test noticed.<\/p>\n
  <\/a> A lexer that cannot decide alone <\/h2>\n
GUML has an ambiguity no lexer can resolve on its own. The comment at the top of crates\/guml-syntax\/src\/lib.rs<\/code> puts it in two lines: <\/p>\n
\n
btn Decrement ghost >count-- \/\/ Decrement is a label, ghost is a modifier p Press the buttons to change. \/\/ the whole remainder is prose content <\/code><\/pre>\n
\n<\/p><\/div>\n<\/p><\/div>\n
Same shape, opposite meanings. Whether the rest of a line is structure<\/strong> or prose<\/strong> depends on the tag, and the tag’s kind lives in the registry. So the lexer produces both readings<\/em> of every line: a token list and the raw text. Then the parser, which knows the registry, picks one.<\/p>\n
The rule is subtle: a text tag stays prose unless<\/em> the line contains an =<\/code> whose name the registry accepts for that tag. So p Set x=1 to enable<\/code> is prose, and text {title} strike={done}<\/code> is structure. Step through it:<\/p>\n
<\/a><\/p>\n
A frame from the interactive sketch in the original<\/a> \u2014 watch it run<\/a>.<\/em><\/p>\n
Two more lexer decisions I like:<\/p>\n