Recent content on Clef Programming Language
To our surprise, it is now two engineers named “Moog” that inform this framework’s narrative in some way or other. Robert Moog built the synthesizers that brought the family name into the music industry lexicon. Houston Haynes, designer of this framework, its language, and its type system, began his career as Bob’s student and later helped him restart the company that once…
Ask three developers where “the scheduler” lives in their stack and you’ll likely receive multiple earnest, precise answers that are correct while barely overlapping. A systems programmer might offer details on an epoll or io_uring loop, a thread-per-core layout, and capacities provisioned at boot from numbers somebody chose by hand. A .NET developer building on Akka.NET may have…
Ask a .NET developer to consider a language that compiles to native code with no runtime, and one question arrives before almost any other: what about reflection? The question deserves a better answer than a feature checklist. Reflection is one of the places where a legacy strategy calcified into a mental model and then got mistaken for an intrinsic necessity. As most developers know it,…
Here is a claim that might sound a bit reckless on the surface: a kernel-level program can be loaded into the running OS kernel, on a production server, under live traffic, and the kernel carries a guarantee that program cannot crash the machine. Not that it probably will not crash. That it cannot . Netflix uses code like this to watch every disk request on live systems. Cloudflare uses it to drop…
A ‘Hidden’ Hierarchy In Plain Sight graph LR ROOT['Sealed artifact<br/>one image, self-contained'] ROOT --> SEQ['Braided Parallelism<br/>instruction stream'] ROOT --> SIMT['SIMT<br/>lockstep thread groups'] ROOT --> DF['Dataflow<br/>compiled graph'] ROOT --> FIX['Fixed fabric<br/>synthesized logic'] SEQ --> MCU['SoC/MCU<br/>reset vector,<br/>register direct'] SEQ --> UVM['CPU…
The field has a shelf of terms for the portion of computation that ‘comes apart’ cleanly. map SIMD/SIMT confluent data-parallel referentially transparent Embarrassingly parallel Each names a mechanic whose elements do not depend on others, so an application can run them separately with no coordination. Now consider terms that cover the adjacent case… …a program that…
Some bugs survive in production for years because the code reads exactly like careful engineering. FreeBSD recently resolved a deep issue that fits in that category: a bounds check in the kernel, correct on its face, that fails against a single negative number. The video below breaks it down step by step and is worth watching before reading on. The function copies a bounded region of kernel memory…
Every developer, whether by accident of history or through a specific educational arc, lands somewhere on the spectrum between concrete and abstract code conventions. The concrete end commits early and commits by hand: name the type, fix the width, pin the layout, and carry those decisions forward as the program grows. The abstract end leaves what it is made of to be settled later, by inference,…
A pipeline of independent transforms over a collection, mapping a calibration across a frame of samples, scoring each one, normalizing the result, is a description of data flow. Nothing in that code says “do these in order.” Each element is its own small computation, written as independent because that is how the problem actually looks. The parallelism is there in the source, leaving…
Every developer wants their code to be memory safe, the threads and processes to never deadlock, and for no buffer to overflow. Our design aims to resolve all of these considerations and more in concurrent Clef, with no annotation and no handwritten proof term to crowd the code. The language, the Program Semantic Graph (PSG), and the elaboration and saturation pipeline that builds it are in place;…
Concurrency has been the through-line of our work from the start. We describe Clef as a concurrent programming language that happens to use ML-family semantics inside our Native Type Universe, and the ordering in that sentence is deliberate. The functional core, the immutability, the parametric types, the computation expressions, is the material we build with. What we are building is a language…
A recent Pragmatic Engineer episode with Alice Ryhl talks through how the Rust team at Google and the Tokio side of their work. She’s about as deep in production Rust as anyone. And the practical advice she keeps circling back to, when someone is stuck fighting the borrow checker, is to change the data structure. She says it more than once. When that doesn’t get you out, the escape…
Most developers approaching mobile deployment take the cross-platform framework ‘shortcut’. React Native, Flutter, Kotlin Multiplatform, .NET MAUI, Capacitor, and Cordova abstract the platform-native binding surfaces behind a uniform runtime, and the developer’s main language stays at the door in exchange for targeting handheld and wearable devices. Native compilation modes…
On April 29, 2026, the cryptographer JP Aumasson posted the following observation on social media: dont worry, BLAKE3 is post-quantum; unlike the provably secure hash VSH The remark is compressed enough to read as a quip and substantive enough to deserve unpacking. Aumasson co-designed the BLAKE family of hash functions, and his statement carries a specific technical claim: a hash function with no…
The Bermuda Triangle was the great mystery of the 1970s, the kind of story that sold twenty million copies of Charles Berlitz’s paperback and gave Leonard Nimoy a full season of In Search Of… episodes to walk through in that baritone voice. That phenomenon was a product of marketing and pre-Internet pop-culture amplification. The mystery here is the opposite kind: it seems forbidding…
The Fidelity framework is primarily designed to target hardware in the most direct manner possible. You know the acronyms: CPUs, GPUs, FPGAs, MCUs, NPUs, and other accelerators too. Every compilation target goes through Alex (the “Library of Alexandria”), our MLIR middle-end, where dimensional verification, escape analysis, and BAREWire schema derivation all happen in one place. It is…
Beyond Dimensional Consistency A companion line of work expands on the formal lineage connecting Reynolds’ abstraction theorem and Wadler’s parametricity result to the Dimensional Type System’s design-time verification. That lineage is one of several converging influences on the DTS design. Kennedy’s Units of Measure [5] demonstrated that dimensional inference is practical…
In 1989, Philip Wadler published “Theorems for free!” , a paper that demonstrated a counterintuitive property of polymorphic type systems: the type of a function, by itself, determines non-trivial theorems about that function’s behavior. No implementation needs to be examined. No test cases need to be run. The type is the theorem. This result, grounding John Reynolds’…
There’s a question that comes up early in any FPGA design course: is this a Moore machine or a Mealy machine? Students learn the distinction, draw the state diagrams, and internalize the rule. Moore machines have outputs that depend only on state. Mealy machines have outputs that depend on both state and inputs. It’s clean, it’s testable, and it’s one of those…
Two capabilities define the architectural foundation of the Fidelity framework: Deterministic Memory Management (DMM) Dimensional Type System (DTS) While each addresses distinct engineering challenges, they rest on a single insight: memory semantics and physical semantics are both dimensions. They survive compilation the same way, constrain code generation the same way, and enable verification the…
There’s a particular kind of frustration that comes from watching a progress bar crawl across your screen while an Electron app loads its bundled Chromium instance. Somewhere in those three-plus seconds of initialization, a complete web browser is waking up, allocating its 200 megabytes of baseline memory, spawning its constellation of processes, all so you can run what amounts to a…
In a universally contested future, every cryptographic operation rests on a single foundation: entropy. The keys that protect communications, the nonces that prevent replay attacks, the seeds that initialize secure protocols; all derive their strength from randomness that adversaries cannot predict or influence. When that foundation weakens, everything built upon it becomes vulnerable to…
The actor model presents a useful abstraction for concurrent and distributed systems. When building two frameworks that target different runtimes, a natural question arises: can we maintain a consistent developer experience across native compilation (Fidelity) and edge deployment (Conclave)? Our answer is a division the framework has since made formal in the scheduler contract : actors are defined…
Reactive programming has become essential infrastructure for modern applications. From browser interfaces responding to user input to distributed systems coordinating state across nodes, the ability to propagate changes through a dependency graph underpins countless software architectures. Yet the dominant patterns for implementing reactivity carry significant cognitive and runtime overhead. The…
AI’s Berlin Wall In our exploration of neuromorphic computing , we examined how specialized hardware might finally deliver on AI’s efficiency promises. Hardware alone does not address a structural limitation in current AI systems: the wall between how systems learn and how they operate. 🔄 Updated October 22, 2025 This article now includes cross-references to related blog entries,…
The story of distributed systems in F# begins with two distinct programming traditions that converge in F# in unique ways. From OCaml came the functional programming foundation and type system rigor. From Erlang came the mailboxprocessor and with it an approach to fault-tolerant distributed systems. Don Syme’s work fused concurrency into the primitives of a high-level programming language.…
When a vendor site boasts that it can “blur the lines between P and NP,” they’re either lying outright, putting massively subsidized compute “on blast” in a server farm behind the scenes, or putting fancy framing around something more mundane: running a workload on hardware that fits the problem. The mathematical complexity is never made to disappear . Our read is…
The blog post “Abstract Machine Models - Also: what Rust got particularly right” makes a compelling case for Abstract Machine Models (AMMs) as a missing conceptual layer between computer science and hardware. The author, reflecting on a failed microprocessor project, discovers that programmers don’t reason about either programming theory or raw hardware, but rather about…
Transformers have delivered broad capabilities, and their energy consumption scales with that reach. The human brain operates on roughly 20 watts, processing large volumes of information through sparse, event-driven spikes, at least as we currently understand it. Current AI systems consume thousands of watts to support narrow inference capabilities, forcing dense matrix operations through every…
A Confession and a Vision A personal note from the founder of SpeakEZ Technologies, Houston Haynes I must admit something upfront: when I began design of the Fidelity framework in 2020, I was driven by practical engineering frustrations, particularly with AI development. The limitations of a managed runtime, the endless battle with numeric precision, machine learning framework quirks, constant bug…
Every software engineering team knows the testing treadmill. Write code, write tests, run tests, fix failures, write more tests to catch what you missed, maintain those tests forever. We’ve accepted this as the calendar and staffing cost multiplication demanded by standard approaches to quality software. But what if this entire cycle represents an inefficiency, a workaround in the absence of…
The quantum computing landscape in 2025 presents both advances and sobering realities. The technology has moved beyond pure research into early commercial deployments, and it remains years away from the applications often promised in popular media. For our Fidelity framework, this raises a design question. How can we architect the system to leverage quantum acceleration when it becomes practical,…
Reactive programming sits at the intersection of practical engineering and algorithmic integrity in our Fidelity framework. While exploring reactive models, we drew on Ken Okabe’s Timeline library , a minimalist F# implementation that built a reactive system with little code. That economy was a key inspiration for Fidelity.Rx, though we evolved the concepts to fit the framework’s…
The computing industry sits at a notable juncture in 2025. After decades of general-purpose processor dominance that led to the accidental emergence of general purpose GPU, we’re witnessing what appears to be a reverse inflection point. Specialized architectures are re-emerging as an economic imperative, with important differences from the LISP machines of the past. We examine here how…
A startup’s gene analysis samples nearly melted because someone confused Fahrenheit and Celsius in their monitoring system. A Mars orbiter was lost because of mixed metric and imperial units. Medication dosing errors have killed patients due to milligrams versus micrograms confusion. These are not edge cases. They are symptoms of a recurring problem in how we build mission-critical systems:…
While this idea might be met with controversy in the current swarm of AI hype, we believe that the advent of sub-quadratic AI models, heterogeneous computing, and unified memory architectures will show themselves as pivotal components to next generation AI system design. The elements are certainly taking shape. As we stand at this technological crossroads, AMD’s hardware trajectory tells the…
The AI industry stands at an inflection point. As detailed in our “Beyond Transformers” analysis, the convergence of matmul-free architectures and sub-quadratic models will shift how we build and deploy AI systems. While the research community has demonstrated these approaches can match or exceed transformer performance with dramatically lower computational requirements, our…
The cybersecurity landscape has shifted dramatically in recent years, with memory safety vulnerabilities accounting for approximately 70% of critical security issues in systems software. This reality has prompted governments and industries to mandate transitions to memory-safe languages for critical infrastructure. Yet the economics of wholesale rewrites are daunting: decades of refined C and C++…
The debate over higher-kinded types (HKTs) in F# surfaces a tension between theoretical expressiveness and practical accessibility. This analysis examines that tension through two lenses: first, Don Syme’s stance that has shaped standard F#, and second, how our Fidelity framework’s position as a native Clef compiler changes the calculus. I want to understand both perspectives while…
As we’ve established in previous entries, from the FidelityUI model to leveraging Fabulous for native UI , our FidelityUI deterministic memory approach serves embedded systems and many desktop applications. The question we take up here is what happens when an application grows beyond simple UI interactions: when it needs to coordinate business logic, handle concurrent operations, and manage…
Creating a native UI framework for our Clef language raises a specific question: how would we preserve the functional programming experience Clef developers work in while compiling to native code with deterministic memory management? As we envision FidelityUI, our UI framework for the Fidelity ecosystem, we sit at the intersection of functional programming and systems programming. We would not…
From our design perspective, the path for AI inference lies less in ever-larger transformer models demanding massive GPU clusters and more in a diverse ecosystem of specialized architectures optimized for specific deployment scenarios. We are developing the infrastructure that could make this approach practical. Our “Beyond Transformers” analysis explored the theoretical foundations of…
Our Fidelity framework takes an approach to building desktop applications with the Clef language that aims to let developers create native user interfaces across multiple platforms. We draw on the patterns established by Elmish and the MVU pattern, particularly within Avalonia, and we take many lessons from Fabulous . Our FidelityUI design adapts these approaches for native compilation, with the…
Clef’s concurrency reads like the async, task, and actor models a .NET developer already knows, and compiles to something quite different underneath. The surface conventions carry over; what happens beneath them does not. The Iceberg Model: Familiar on the Surface, Different Underneath Think of our Fidelity concurrency model as an iceberg. Above the waterline, it looks similar to what you…
The computing landscape has undergone seismic shifts over the past three decades, yet many of our foundational software platforms remain anchored to paradigms established during a vastly different technological era. Virtual machines and managed runtime environments like Java’s JVM and .NET’s CLR emerged during the late 1990s and early 2000s as solutions to very specific problems of…
AI accelerators are changing the performance characteristics developers can target, and post-quantum cryptography is moving from research into practice. Security vulnerabilities in memory-unsafe code continue to cost billions annually. The ecosystem of foundational libraries, from TensorFlow’s core implementations to OpenSSL, remains anchored in C and C++. We have been asking how to bring…
Our Fidelity framework builds desktop applications with our Clef language , targeting native user interfaces across multiple platforms while keeping the functional programming model. The layout system is one hard part of that: it has to stay functional and still give developers the panel, grid, and stacking primitives that established UI frameworks offer. This article describes how Fidelity can…
The computing world has fragmented into specialized ecosystems. Embedded systems demand byte-level control, mobile platforms enforce strict resource constraints, and server applications require elasticity and parallelism. Traditionally, these environments have forced developers to choose between conflicting approaches: use a high-level language with garbage collection and accept the performance…
Erlang emerged in the late 1980s at Ericsson, when distributed systems were in their infancy and reliability was becoming a critical concern in telecommunications. It was built to meet a practical need: telephone exchanges that could achieve the “nine nines” (99.9999999%) of uptime. To get there, Erlang took an unusual position on concurrency and fault tolerance. A Pioneer in Reliable…
We are working on transfer learning that combines convolutional neural networks (CNNs) with Topological Object Classification (TopOC) methods. This memo outlines our design approach to dimensionally-constrained models that maintain representational integrity through the transfer learning process, while targeting deployment to resource-constrained hardware through our Fidelity Framework compilation…