Blog posts exploring the concept "Cross-Platform"
← Back to all tagsBlog posts exploring the concept "Cross-Platform"
← Back to all tagsThe Fidelity framework’s Farscape CLI addresses a pressing challenge in modern software development: how to enhance the safety of battle-tested C/C++ tools without disrupting the countless systems that depend on them. Every day, organizations rely on command-line tools like OpenSSL, libzip, and many others that represent decades of engineering expertise but carry the inherent memory safety risks of their C/C++ heritage. Farscape’s “shadow-api” design aims to provide a breakthrough solution: the ability to generate drop-in replacements for these critical tools that maintain perfect compatibility while adding comprehensive type and memory safety guarantees.
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 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 represents an ambitious project to bring F# to native compilation without runtime dependencies. One of the most challenging aspects of this endeavor is the treatment of asynchronous programming. This design document outlines our approach to compiling F#’s async computation expressions to efficient native code through delimited continuations, and introduces Frosty, an enhancement that brings advanced async patterns to this runtime-free environment. 🔄 Updated July 25, 2025 True RAII principles for automatic async resource management Bidirectional PSG “zipper” computation expressions for async transformations Integration with Olivier actor model for structured concurrency …with special thanks to Paul Snively for his polyglot perspective that led to many of the connections drawn through the latest updates.
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 MoreThe journey from managed code to native compilation in F# represents a significant architectural shift. As the Fidelity Framework charts a course toward bringing F# to new levels of hardware/software co-design, we face a fundamental question: how do we distribute and manage packages in a world where the comfortable-yet-constraining assumptions afforded in the .NET ecosystem no longer hold? This article explores Fargo, a forward-looking package management system that reimagines F# code distribution for the age of multi-platform native compilation.
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 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 MoreThe .NET platform introduced the concept of assemblies over two decades ago, a fundamental building block that has served as the cornerstone of .NET development since its inception in 2002. Assemblies, typically manifested as DLL or EXE files, represented a significant advancement in software componentization at the time. They combined compiled Intermediate Language (IL) code with rich metadata about types, references, and versions into a cohesive deployment unit that could be shared across applications.
Read MoreThe software industry has perfected a peculiar form of value extraction that emerges not through direct coercion or byzantine contract provisions, but through the accumulated weight of community contributions that inadvertently reinforce ecosystem boundaries. We call it… “Lazy Lock-in” Unlike traditional vendor lock-in, which relies on proprietary formats or contractural switching costs, this phenomenon arises from the very generosity and creativity of open source contributors. The irony of this is that those purveyors that capitalize on this now once ridiculed and structurally resisted open development for many years.
Read More