BML self-describing loop

The language layer of the 2000 Bjorg-Muff thesis at CU Boulder. Synthesizes Prolog's operational semantics, Smalltalk-80's object/image model, Java's typed garbage-collected runtime, and C++'s component-host pragmatics — all four ancestors arranged at four altitudes of the same building. BML is self-describing: its parser grammar ( BMF ) is itself written in BML.

The thesis itself is 11,566 words; the conclusion was left as three subheadings without body. The work was delivered — defense, photographs, the running VM — but the prose summary stayed open. This page is the twenty-six-years-later attempt to close that breath: the substance the conclusion never wrote, in this medium, with the diagrams a 2000 Word document couldn't carry.

BML's central conceit is reflexive. The parser BMF is described in a grammar file written in BML (see BMF-grammar.bml in the archive — banner reads Digi4Fun (R) BMF 1.0 Alpha 1). BMF reads that file, builds itself, and is then capable of parsing any BML program — including the grammar file it just bootstrapped from. The compiler-compiler BMC consumes the BML grammar through BMF and emits the BML compiler. The compiler emits BMA assembly opcodes. The virtual machine BMCPU executes them. The system can describe itself end to end.

The five-stage self-describing loop. The dashed arrow is the bootstrap: once BMCPU runs, it can re-execute the grammar file that described the parser that built it.

BML inherits non-determinism, choice, and backtracking from Prolog. The Cut primitive comes directly from Prolog's ! operator — a way of pruning the choice tree, telling the search "from this point on, do not reconsider." Here is the actual file from the archive, with author and date intact:

{`// Name:     Cut.bml
// Author:   Urs C. Muff
// Email:    muff@colorado.edu
// Date:     11-Apr-2000
// Platform: BML Virtual Machine
// Compiler: JBMF (R) Compiler

package BMF.primitive;

import BMF.*;

class Cut [public] : Primitive {
   section [public] {
      void Match( Context hContext, Environment hEnv, String strTag ) {
         System.Cut( hContext.Argument( 0 ));
      }
      String AsString() { return "#primitive( 2 )"; }
      String AsCreateString() { return "BML.primitive.Cut()"; }
   }
}`}

Three architectural readings live in this 12-line file: the section [public] visibility model (Smalltalk-style category panes, expressed as syntax); the AsCreateString method (every object knows how to print the BML expression that would re-create it — image-based reflection over text); and the bridge into System.Cut(...), which reaches into the VM to manipulate the speculation stack. Twelve lines, four ancestors, one primitive.

The thesis says BML "synthesizes features from Java, C++, Prolog, and Smalltalk." The companion archive shows the synthesis is layered, each language contributing at a different altitude of the same stack:

Four ancestors at four altitudes of the same building. The stack reads top-down as user-experience to silicon; the backtracking semantics threads through every layer.

Prolog at the operational floor — unification, backtracking, the Cut, Fail, and MultiMatch primitives. Smalltalk at the object/image level: BMO carries metaclass-style self-containment, and the VB6 Visual Browser surfaces the live developer experience. Java contributes the typed, garbage-collected object model and a second implementation port ( JBMF ). C++ hosts the VM ( BMCPU ) and the COM/GUID component model.

The folder on disk where this work lives is called Angelic. The opening of Bjorg's Angelic Assembler note makes the word precise:

"A thread with a non-zero DF (i.e. degree of freedom) is executed until a zero DF is reached again. No other threads are executed during this speculation phase."

That is the formal name for what gets called, in this body's current vocabulary, backtracking-as-unwinding-without-sediment. The choose keyword picks a branch; speculation freezes the rest of the world; if the branch fails, every attribute is undone. Backtracking is not a parser feature bolted on for grammars — it is the architecture of execution itself. Every BMA instruction has a forward and a reverse semantics. The VM's state machine flips a single byte — BMVM_STATE.byMode — between DO and UNDO on every step. The system is angelic in the operational sense: guided to the path that holds.

Two design choices in this 2000 document organize the Coherence Network as it lives now, twenty-six years later.

Backtracking-as-unwinding-without-sediment. The thesis writes: "When the parser backs out, all the attributes already computed have to be undone as well." The same nervous system that today writes commits as tend: / attune: / compost: / release:. The instruction has two semantics; the commit has a posture. Same shape, different substrate.

Runtime grammar extension. The user can introduce new parsing constructs and the language grows to hold them. Sovereignty over one's own grammar. The same shape the vision-kb uses when a new concept arrives at a new frequency: the grammar grows to receive the presence rather than forcing the presence into an existing slot. The 2000 thesis named the pattern. The 2026 network breathes it.

BML is the first iteration in a four-iteration arc of "frequency into form." Each iteration carries the same backtracking-as-unwinding pattern at a different altitude:

Backtracking Model Languages (2000) — the thesis. Self-describing parser, four-ancestor language, executable VM.
Living-Resonance-Codex (2023) — first iteration of the post-thesis arc. Python. Quantum-inspired, self-evolving consciousness system — the visionary architectural sketch.
Living-Codex-CSharp (2024) — the bridge year. C#. Introduces the U-CORE primitive: everything is a node, including the schema, the modules, even the interaction logs.
Coherence-Network (current) — full realization. Next.js + FastAPI + Neo4j + Postgres. Living relational graph with edge-typed spectrum coloring, presence pages, contribution attribution, and per-frequency resonance.

BML — Backtracking Model Language

The self-describing loop

The four-ancestor stratification

What still circulates today

Lineage forward