Blog posts discussing the technical implementation detail "MLIR"
← Back to all tagsBlog posts discussing the technical implementation detail "MLIR"
← Back to all tagsThe “AI industrial complex” in its current form is not sustainable. While transformers have delivered remarkable capabilities, their energy consumption and computational demands reveal a fundamental inefficiency: we’re fighting against nature’s design principles. The human brain operates on roughly 20 watts, processing massive volumes of information through sparse, event-driven spikes. (at least, as we currently understand it today) Current AI systems consume thousands of watts to support narrow inference capabilities, forcing dense matrix operations through every computation.
Read MoreSoftware verification has always forced a cruel choice: accept runtime overhead for safety checks, or trust that your optimizing compiler won’t break critical invariants. Traditional compilers treat proofs as obstacles to optimization, while proof assistants have a reputation (earned or not) that they generate code too conservative for production use. But what if verification and optimization weren’t opposing forces but complementary dimensions of the same compilation process? The Fidelity Framework’s hypergraph architecture makes this vision real by treating proof obligations as first-class hyperedges that guide, not hinder, aggressive optimization.
Read MoreModern processors are marvels of parallel execution. A typical server CPU offers dozens of cores, each capable of executing multiple instructions per cycle through SIMD operations. GPUs push this further with thousands of cores organized in warps and thread blocks. Emerging accelerators like NextSilicon’s Maverick or Graphcore’s IPU reimagine computation entirely. Yet most code fails to harness even a fraction of this power. Why? Because choosing the right parallel execution strategy requires understanding not just what your code does, but what it needs from its environment.
Read MoreWhen we set out to build Firefly, we faced a fundamental question that cuts to the heart of functional systems programming: how far down the compilation stack can we preserve the elegant abstractions that make F# powerful? Specifically, can delimited continuations - the theoretical foundation for async/await, generators, and algebraic effects - survive the journey from high-level F# through MLIR’s SSA form to executable code? And perhaps more importantly, should they?
Read MoreIn 1998, Andrew Appel published a paper that heralded a change to how we should think about compiler design. “SSA is Functional Programming” demonstrated that Static Single-Assignment form, the intermediate representation at the heart of modern optimizing compilers, is exactly equivalent to functional programming with nested lexical scope. This insight has profound implications as we enter a new era of hardware-software co-design. At SpeakEZ, this revelation validates our approach with the Fidelity framework more than 25 years after its first publication: lowering F# to native code through MLIR isn’t just possible, it’s aligned to the fundamental structure of well-principled compilation.
Read MoreWhen we set out to design the Firefly compiler for the Fidelity Framework, one of our core goals was to produce truly minimal native executables. In the world of traditional .NET development, your “Hello World” application carries the weight of the entire runtime and referenced assemblies, resulting in deployments measured in megabytes. For embedded systems, high-frequency trading platforms, or any scenario where every byte matters, this overhead is unacceptable. Our solution involves a revolutionary approach: type-aware tree shaking that operates directly on the F# Compiler Services AST, preserving rich type information to guide precise dead code elimination.
Read MoreThe 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++ code represent trillions of dollars in intellectual property and domain expertise. What if, instead of rewriting everything, we could wrap existing code in provably safe interfaces?
Read MoreThe Fidelity Framework and its ecosystem of technologies represent more than technical achievements, they embody our core values in executable form. Where our Compact establishes how people and groups interact within the SpeakEZ ecosystem, our technical innovations demonstrate these same principles applied to systems design. This alignment between human values and technical architecture is neither accidental nor superficial; it reflects our belief that sustainable innovation emerges when technological choices reinforce rather than contradict constituent needs.
Read MoreThe Fidelity framework introduces a revolutionary approach to building desktop applications with F#, enabling developers to create native user interfaces across multiple platforms while preserving the functional elegance that makes F# special. Drawing inspiration from the successful patterns established by Elmish and the MVU pattern - particularly within Avalonia - we take many lessons from Fabulous. FidelityUI adapts these proven approaches for native compilation, creating a framework that feels familiar to F# developers while delivering unprecedented performance through direct hardware access.
Read MoreAt the intersection of two powerful but largely separate computing paradigms stands the Fidelity framework, a revolutionary approach to systems programming that re-imagines what’s possible when functional programming meets direct native compilation. For decades, developers have been forced into an artificial choice: embrace the productivity and safety of managed runtimes like .NET and the JVM while accepting their performance limitations, or pursue the raw efficiency of direct compilation while shouldering the burden of manual memory management and more complex development workflows.
Read MoreCreating software with strong correctness guarantees has traditionally forced developers to choose between practical languages and formal verification. The Fidelity Framework addresses this challenge through a groundbreaking integration of F# code, F* proofs, and MLIR’s semantic dialects. This essay explores how the Fidelity Framework builds upon the semantic verification foundations introduced in “First-Class Verification Dialects for MLIR” (Fehr et al., 2025) to create a unique pipeline that preserves formal verification from source code to optimized binary.
Read MoreHere at SpeakEZ we’re rethinking how developers interact with memory management in systems programming. The conventional wisdom suggests we face a stark choice: embrace the ubiquitous memory burdens of Rust or abdicate all memory concerns and accept the performance penalties of garbage collection. We believe there’s a better way. Mandatory vs. Optional Memory Management Rust’s borrow checker has revolutionized systems programming by statically preventing memory safety issues, but it comes at a significant cost: every line of code must consider ownership and borrowing.
Read MoreWe at SpeakEZ have been working on the Fidelity framework for a while, and it’s been a journey to find the right balance of familiar conventions with new capabilities. Nowhere is that more apparent than in the async/task/actor models for concurrent programming. The Iceberg Model: Familiar on the Surface, Revolutionary Underneath Think of Fidelity’s concurrency model as an iceberg. Above the waterline, it looks remarkably similar to what you already know:
Read MoreFor .NET developers, the term “frontend” already carries rich meaning. It might evoke XAML-based technologies like WPF or UWP, the hybrid approach of Blazor, or perhaps JavaScript visualization frameworks such as Angular, Vue or React. Within the .NET ecosystem, “frontend” generally refers to user interface technologies - the presentation layer of applications. When that same .NET developer encounters terminology like “MLIR C/C++ Frontend Working Group,” something doesn’t quite compute. This clearly isn’t referring to user interfaces or presentation technologies.
Read MoreThe 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 that time: platform independence, memory safety, and simplified development in an era of relatively homogeneous computing resources.
Read MoreThe Fidelity framework aims to create a novel approach to building desktop applications with F#, enabling developers to create native user interfaces across multiple platforms while preserving functional elegance. One of the key challenges in building such a framework is developing a robust layout system that maintains the functional programming paradigm while providing the flexibility and power of established UI frameworks. This article explores how Fidelity can incorporate ideas from modern functional UI frameworks to create a pure F# implementation of a window layout system without external dependencies, relying solely on F# native code and integrated low level LVGL and Skia libraries.
Read MoreThe computing world has fragmented into specialized ecosystems - embedded systems demand byte-level control, mobile platforms enforce strict resource constraints, while 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 overhead, or drop down to systems programming with manual memory management and lose expressiveness. Beyond Runtime Boundaries The Fidelity Framework represents a fundamental rethinking of this dichotomy.
Read MoreAt SpeakEZ, we are working on transformative approaches to transfer learning that combine convolutional neural networks (CNNs) with Topological Object Classification (TopOC) methods. This memo outlines our design approach to creating dimensionally-constrained models that maintain representational integrity throughout the transfer learning process while enabling deployment to resource-constrained hardware through our Fidelity Framework compilation pipeline. By leveraging F#’s Units of Measure (UMX) system to enforce dimensional constraints across the entire model architecture, we achieve not only safer and more reliable models but also significantly more efficient computational patterns that can be directly compiled to FPGAs and custom ASICs.
Read MoreIn the world of artificial intelligence, a quiet revolution is taking place. For more than a decade, the presumed fundamental building block of neural networks has been matrix multiplication (or “matmul” in industry parlance) – the mathematical operation that powers everything from language models like ChatGPT to computer vision systems analyzing medical images. But what if we told you that matrix multiplication, the cornerstone of current AI, is actually a significant bottleneck for efficiency?
Read MoreThe embedded systems industry has operated under a fundamental assumption for decades: achieving hardware control requires sacrificing high-level abstractions and type safety. This assumption has created a divide between embedded development and modern software engineering practices, forcing developers to choose between expressiveness and efficiency. The Fidelity Framework challenges this paradigm through a revolutionary approach that delivers hardware type safety with truly zero runtime cost, a breakthrough in hardware/software co-design methodology.
Read MoreIn the evolving landscape of programming languages, Mojo has emerged as a fascinating experiment in bridging disparate worlds. Created by Chris Lattner, whose pioneering work on LLVM and MLIR has fundamentally transformed how we think about compiler infrastructure, Mojo represents an ambitious vision: bringing Python’s accessibility to systems programming while leveraging the revolutionary capabilities of MLIR. At SpeakEZ, we’ve been exploring similar territory with our Fidelity framework built on F#. Both projects share a common foundation in MLIR, yet approach the challenge of modern language design from remarkably different philosophical starting points.
Read MoreThe AI industry is experiencing a profound shift in how computational resources are allocated and optimized. While the last decade saw rapid advances through massive pre-training efforts on repurposed GPUs, we’re now entering an era where test-time compute (TTC) and custom accelerators are emerging as the next frontier of AI advancement. As highlighted in recent industry developments, DeepSeek AI lab disrupted the market with a model that delivers high performance at a fraction of competitors’ costs, signaling two significant shifts: smaller labs producing state-of-the-art models and test-time compute becoming the next driver of AI progress.
Read MoreIn the coming waves of “AI” innovation, the computing landscape will continue to fragment into an increasingly divergent array of hardware choices. From embedded microcontrollers to mobile devices, workstations, and accelerated compute clusters, developers will face a challenging decision: build with distinctly different “stacks” for each target or accept the deep compromises of existing cross-platform frameworks. Meanwhile, Python continues its paradoxical ascent, simultaneously becoming the lingua franca of modern computing while quietly imposing an unsustainable tax on engineering resources.
Read More