RECALL: What COBOL Would Have Built for the Web

It Started as a Joke

The original impulse behind RECALL was almost aesthetic. What if someone opened View Source on a web page and saw COBOL? Not a comment referencing COBOL. Not a joke in the markup. Actual COBOL divisions, sections, display statements — the source that produced the page, embedded in the page itself.

The reaction I was imagining was surprise. Maybe delight. The cognitive dissonance of encountering 1959 syntax in a browser in 2026.

What I didn't anticipate was what happened next: the syntax started pulling in ideas that had nothing to do with the joke. The vocabulary wasn't just surprising — it was semantically precise in a way that no modern web syntax is. IDENTIFICATION DIVISION. WORKING-STORAGE. PROCEDURE DIVISION. These aren't implementation details. They're the shape of how an organisation thinks about a document. The joke turned out to have structural load-bearing properties.

That was three days ago. RECALL is now a working compiler, a self-hosted documentation site, a production publishing pipeline, and the beginning of something that doesn't have a clean name yet. This is the account of what happened — and why I think COBOL syntax was the right seed for it.

What COBOL Actually Got Right

COBOL is stigmatised. Everyone who works in software knows the story: legacy systems, ageing workforce, technical debt measured in decades. Every major bank would replace it tomorrow if they could.

What that story misses is why COBOL survived. Not because organisations are lazy or cowardly. Because COBOL was semantically precise in a way that nothing has replaced. It encoded business intent at the language level. The vocabulary — not the runtime, not the ecosystem, the vocabulary — described what a business program was doing in terms the business understood.

COMPUTE TOTAL-INTEREST = PRINCIPAL * RATE * YEARS is not a formula. It is a business rule, stated in the language of the domain, visible to anyone who reads it. No abstraction layer between the intent and the code.

That is what RECALL inherits. Not the runtime. Not the compilation model. Not the historical baggage. The design position: the language should express intent directly, in vocabulary the domain recognises, without translation.

Applied to web publishing, that position produces something like this:

IDENTIFICATION DIVISION.
   PROGRAM-ID. MY-SITE.
   PAGE-TITLE. "Hello, World.".

PROCEDURE DIVISION.

   RENDER-HERO.
      DISPLAY SECTION ID "hero".
         DISPLAY HEADING-1 "Still Here.".
         DISPLAY PARAGRAPH "Built to last.".
      STOP SECTION.

   STOP RUN.

You don't need to know RECALL to read that. The intent is on the surface. That's the point.

The Source Is the Artifact

RECALL compiles .rcl source files into self-contained HTML. No runtime dependencies. No external CSS. No JavaScript framework. One file, works everywhere, works indefinitely.

But the more important property is this: every compiled HTML file embeds its source in an HTML comment at the top of the output. View source on any RECALL page and the .rcl that produced it is right there. Not a link to a repository. Not a reference to a build log. The actual source.

This is the principle: the source is the artifact. The provenance travels with the output. You cannot lose the intent because it is inside the thing the intent produced.

Most build systems treat this as waste. Compile the source, discard the source, ship the output. The reasoning is efficient from a file-size perspective and wrong from a semantic one. When you discard the source, you discard the meaning. The output is correct today. In five years, without the source, it is just markup.

With the source embedded, an artifact from 2026 is as readable in 2040 as it is today. Open the file. Read the comment. The intent is there.

Why AI Writes It Naturally

Here is the observation that surprised me most.

Every AI model trained on code has seen enormous quantities of COBOL. Banking systems, insurance systems, payroll systems — decades of COBOL in the training data. When Claude reads a RECALL file it doesn't encounter an unknown syntax. It pattern-matches immediately to something deeply familiar. The vocabulary, the division structure, the verbosity — all of it maps to existing knowledge.

The result is zero-shot comprehension of a new language, for free. I don't need to explain RECALL syntax to an AI that is helping me author content. It reads the structure, understands the intent, and produces valid RECALL output because it already knows what COBOL looks like and can infer the rest from context.

That is a significant bootstrap advantage that I did not plan for. It emerged from the choice of syntax. COBOL-inspired means AI-familiar. And AI-familiar means the language is immediately usable in the workflows where AI is doing the authoring.

This is the workflow that crystallised in three days: Claude Desktop authors the intent — the signal extraction, the CAL calculation, the brief JSON. Claude Code compiles and deploys. The RECALL source is the handoff format. Both sides of the pipeline read it natively.

The Self-Hosting Moment

The documentation site for RECALL — recall.cormorantforaging.dev — is written in RECALL.

View source on the landing page and you see COBOL divisions. Not as a joke this time. As the actual source that produced the page you are reading.

In computer science this is called self-hosting — when a compiler can compile itself. It is considered a milestone, a proof that the language has reached a certain maturity. Most languages take years to get there.

RECALL got there on day one because the site had to be built in something and the obvious choice was itself. But self-hosting compilers are a technical milestone. This is something different: a publishing language whose own publication is written in that language. The documentation is not about RECALL. It is RECALL.

When someone reads the docs and then hits View Source and sees the same COBOL vocabulary they just learned about — that is not a coincidence. That is the medium being the message in the most literal possible way.

The Plugin System and What It Enables

The core compiler handles structure. Plugins handle domain-specific output. The architecture is intentional: a stable semantic layer (the language) and an extensible rendering layer (the plugin registry).

In practice, a domain plugin registers named elements with render functions:

registerElement('TIMELINE', (stmt, data) => {
  // reads TIMELINE group from data
  // returns HTML string
})

A case study page then expresses intent without knowing or caring about the rendering:

DISPLAY TIMELINE USING TIMELINE.

That one line, in a five-line .rcl file referencing a brief JSON, produces a full chronological cascade timeline with date columns, dot variants, citation linking, and tag badges. The intent is declared. The rendering is handled. They are explicitly separated.

The same principle scales. A DevOps plugin registers infrastructure elements. A dashboard plugin registers metric displays. A report plugin registers summary formats. The language stays the same. The domain vocabulary expands.

The Larger Thread

There is a broader idea underneath all of this that I am still working out.

Current orchestration — multi-agent pipelines, DevOps infrastructure-as-code, automated workflows — shares a common failure mode: intent is lost at every boundary. One agent hands off to the next via output, not meaning. A Terraform file tells you what infrastructure exists. It does not tell you why this particular configuration, what decision it encoded, what should change if the requirement changes.

If the source is always the artifact, and the artifact always carries its intent, then no context is ever truly lost. Every agent picks up from meaning, not from reconstructing meaning from outputs. Every audit starts from what was intended, not from inferring intent from what was built.

RECALL demonstrates this works for publishing. The same principle applied to infrastructure, to agent orchestration, to logging — produces a system where the semantic layer is always present, always attached, always in sync with the output because it produced the output.

That is not a feature. That is an architectural position. And it started because someone thought it would be funny to put COBOL in the View Source.

A Note on COBOL

RECALL is an independent language inspired by COBOL's syntax and design philosophy. It shares no code with any COBOL implementation and makes no claim to COBOL compatibility.

The COBOL vocabulary is borrowed because it encodes business intent at the language level in a way that no modern web syntax does. That design position — not nostalgia, not irony — is what RECALL inherits.

RECALL is MIT licensed and open source. The compiler is @semanticintent/recall-compiler on npm. The documentation is at recall.cormorantforaging.dev — written in RECALL.