The Story of Fifth Language

A tale of semantic ambition, late-night commits, and the emergence of human-AI pair programming

Prologue: The Vision

In September 2024, a single developer named Andrew Matthews committed the first lines of what would become Fifth—a programming language born from an audacious question: What if knowledge graphs were as natural to work with as integers and strings?

The vision was clear from the start: create a systems programming language where RDF triples, SPARQL queries, and graph operations are first-class citizens. A language where you could seamlessly move between imperative code and semantic web technologies without context-switching or awkward interop layers.

// The dream: knowledge graphs as naturally as arithmetic
g: graph = @<
    @prefix x: <http://example.org/> .
    x:people { x:Alice x:age 42 . }
>;
myStore += g;

The Chronicles: A Year in Numbers

From the first commit on September 21, 2024 to today, the repository has accumulated 811 commits across 14 months of development.

The Great Acceleration

Activity tells a story of growing momentum:

Month	Commits	Notable Events
Sep 2024	5	Project inception
Oct 2024	21	Initial parser and AST work
Nov 2024	4	—
Dec 2024	9	Year-end foundation work
Jan 2025	3	Quiet planning period
Mar 2025	9	Guard clause completion
Aug 2025	99	The acceleration begins
Sep 2025	131	KG types, TriG literals
Oct 2025	234	Roslyn backend, SPARQL
Nov 2025	271	Peak activity: Generics, Constructors, Release pipeline

The quiet first half of 2025 was followed by an extraordinary burst of productivity. From August onward, the commit rate increased 10x, transforming Fifth from a parser experiment into a functional compiler.

By the Numbers

• 756 commits in the past year
• 39 pull requests merged
• 28 feature specifications initiated
• 14 features completed and shipped
• 160 bug fixes (commits containing “fix” or “Fix”)
• 323 implementation commits (containing “Implement”, “Add”, or “Phase”)

Cast of Characters

Andrew Matthews — The Architect

411 commits (54%)

The creator and driving force behind Fifth. Andrew’s commits reveal a pattern of someone who works in intense bursts, often on weekends and early mornings (Australian time). His work spans every layer—grammar design, AST architecture, transformation passes, and the intricate knowledge graph integration that makes Fifth unique.

copilot-swe-agent — The Implementer

327 commits (43%)

The AI coding agent that emerged as a major contributor starting in August 2025. Given detailed specifications, the agent implements features phase-by-phase with remarkable consistency.

The Rhythm of Development

Fifth is clearly a passion project. The commit distribution by day of week tells the story:

Day	Commits
Sunday	218
Saturday	166
Wednesday	99
Friday	82
Thursday	74
Monday	66
Tuesday	51

Sunday alone accounts for nearly 30% of all commits. This is the unmistakable signature of a side project built with dedication and love.

The Great Themes

Theme 1: The Knowledge Graph Dream

The heart of Fifth is its knowledge graph integration. The repository tells the story of progressive capability building:

1. Graph Assertion Blocks (GAB) — The original syntax for declaring graph facts inline (later removed for cleaner design)
2. System KG Types — graph, triple, store, query as runtime primitives
3. TriG Literal Expressions — Multi-line graph blocks with full TriG syntax
4. SPARQL Literal Expressions — Embedded queries: ?<SELECT ?x WHERE {...}>
5. Query Application — results = query <- store operator semantics

Theme 2: The Compiler Maturation

The transformation from parser experiment to real compiler follows the git history:

Early 2024-2025: Parser foundations — ANTLR grammar design, AST model creation, basic visitor infrastructure.

Mid 2025: The Roslyn Revolution — Complete backend rewrite from custom IL emitter to Roslyn. A brave simplification that paid dividends.

Late 2025: Language Features Pour In — Exception handling (try/catch/finally), full generics support, constructor functions, guard clauses and destructuring.

Theme 3: The Human-AI Collaboration Experiment

Perhaps the most fascinating story is the emergence of human-AI pair programming at scale.

Starting around August 2025, a pattern emerges:

1. Andrew writes detailed specifications with clear contracts, tests, and phased implementation plans
2. copilot-swe-agent implements following those specifications methodically
3. Andrew reviews, fixes edge cases, and handles the tricky integration work
4. Repeat

This isn’t AI replacing the developer—it’s AI as a highly capable junior engineer, executing well-specified tasks while the human maintains architectural vision.

Plot Twists and Turning Points

The GAB Removal

Graph Assertion Blocks were an early syntax for inline graph facts. The decision to remove them shows mature language design: features that don’t carry their weight get cut.

The Roslyn Pivot

The move from a custom IL emitter to Roslyn was a turning point. This simplification unleashed a flood of feature development that followed.

The CI Battles

Throughout October-November 2025, a recurring subplot: CI/CD fixes. The unglamorous but essential work of keeping the build green.

The Release Pipeline Epic

November 2025 saw an extended saga of release engineering — the long road from “code compiles” to “artifacts ship”. Release engineering is where ambition meets reality.

The Current Chapter

As of December 2025, Fifth stands at a fascinating inflection point.

What’s Working

• Full compilation pipeline: Source to .NET assembly via Roslyn
• Knowledge graph primitives: Graphs, triples, stores, queries as native types
• Rich type system: Generics, constructors, classes, methods
• Multi-platform releases: Linux, macOS, Windows packages with checksums
• 14 completed specifications: A disciplined feature delivery process

What’s Next

The roadmap points toward:

• Language Server Protocol (LSP) for IDE integration
• Parser error recovery for better developer experience
• Incremental compilation for faster builds
• NuGet SDK publishing for easier adoption

Epilogue: The Larger Story

Fifth is more than a compiler—it’s an experiment in three simultaneous hypotheses:

1. Language Design: Can knowledge graphs become as natural as loops and conditionals?
2. Development Process: Can detailed specifications enable effective human-AI collaboration?
3. Solo Development: Can one determined developer (plus AI assistance) build a real language?

The commit history suggests cautious optimism on all three fronts.

The weekend coding sessions, the methodical specification process, the AI implementation experiments, the stubborn CI battles—they add up to something real. A language that compiles, runs tests, ships binaries, and does something genuinely novel with knowledge graphs.

Whether Fifth becomes widely adopted is unknowable. But the story of its creation—told through 811 commits, 39 merged PRs, and countless early morning coding sessions—is a testament to what’s possible when vision meets persistence meets modern tooling.

The chronicle continues. git log awaits the next chapter.

Generated December 5, 2025 from git history analysis