Blog posts discussing the technical implementation detail "LLVM"
← Back to all tagsBlog posts discussing the technical implementation detail "LLVM"
← Back to all tagsThe challenge of binding F# to C++ libraries has historically forced developers into compromising positions: accept the limitations of C-style APIs, manually write error-prone binding code, or rely on runtime marshaling that imposes performance penalties. Farscape’s design targets Plugify’s C++ ABI intelligence. This represents a paradigm shift in this space, enabling automatic generation of type-safe F# bindings that compile away to zero-cost abstractions through LLVM’s Link-Time Optimization. This architectural roadmap outlines how Farscape will evolve from its current C-focused binding generation to comprehensive C++ support by leveraging Plugify’s battle-tested understanding of C++ ABIs.
Read MoreThe “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 MoreThe industry is witnessing an unprecedented $4 billion investment to finally set aside the 80-year-old Harvard/Von Neumann computer design pattern. Companies like NextSilicon, Groq, and Tenstorrent are building novel, alternative architectures that eliminate the traditional bottlenecks between memory and program execution. Yet compiler architectures remain trapped in antiquated patterns - forcing stilted relationships into artificial constructions, obscuring the natural alignment with the emerging dominance of dataflow patterns. What if the key to targeting both traditional and revolutionary architectures lies not in choosing sides, but in recognizing that programs are “hypergraphs” by nature?
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 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 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 Firefly compiler represents a fundamental shift in how F# code gets compiled to native executables. Unlike traditional F# compilation that relies on pre-compiled assemblies and the .NET runtime, Firefly compiles F# directly to native code through MLIR and LLVM, creating truly dependency-free executables. This architectural choice creates an interesting challenge: how do we handle library dependencies when we can’t rely on traditional assembly resolution? Beyond Assembly-Based Dependencies Traditional F# development uses a well-established pattern where open statements resolve to compiled assemblies in NuGet packages.
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 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 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 MoreIn our work to bring F# to systems programming, we’re pursuing a vision of deterministic memory management outside the familiar boundaries of managed runtimes. For developers who have only known automatic memory management as an omnipresent runtime service, the concept we’re pursuing - applying RAII (Resource Acquisition Is Initialization) principles to actor-based systems - represents a significant departure from established patterns. Our current research focuses on how three complementary systems work together: RAII-based arena allocation, the Olivier actor model we’re developing, and our proposed Prospero orchestration layer.
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