Braidpoint

eBPF (Extended Berkeley Packet Filter) lets you run custom, sandboxed code directly inside an OS kernel (Linux *or* Windows) without altering the kernel itself. It can provide real-time, deep system visibility, performance and security enforcement at near-native speeds. Most developers still don't know it exists, but they should. Shifting eBPF verification left is the key to treating the OS kernel as a core accelerator in heterogeneous AI workloads. Traditionally, developers fight the rigid kernel verifier at load time, causing silent deployment failures. By using a proof-aware compiler framework, we can mathematically guarantee a program will pass the verifier before it ever builds. This brings the OS kernel into the exact same accelerator "weave" as GPUs, NPUs, and other processor types. https://lnkd.in/eZXf9gWM

My company is growing, and so the name change is reflective of that. There's lots of work to do, not the least of which is pivoting the company page here. But I thought I'd drop this early note to let my early supporters know what's coming - great things ahead! https://lnkd.in/e-HNj3Se

"Weaving the Braid" is a #cleflang blog entry on "braided parallelism" in our concurrent programming model. "Braid" as a term goes further, into quantum compute, which we'll save for later as the work demands it. The current blog entry is a summation that points to a range of contributions in our body of work. https://lnkd.in/eA-t-PDD

https://lnkd.in/eVNYXh7h

https://lnkd.in/eYDUxUQW

https://lnkd.in/euAY6bqQ

Everyone is concerned with memory use and computational efficiency. So it begs the deeper technology question: what does concurrency actually cost? The #rustlang community has put that question in front of the entire industry, and we're encouraged by the conversation it's started. A recent talk by Jon Gjengset, "The Cost of Concurrency Coordination," is a clear, careful walk from "are mutexes slow?" all the way down to the CPU cache line. His conclusion is with examining in context: it was never really about locks. Coordinating concurrent work is expensive because of cache coherence, the cross-core traffic that fires whenever threads share mutable state. Even lock-free code pays a dear cost, through a failure mode called "false sharing". His presentation, which we cite through the blog entry, shows his take on how an expert might deal with that cost: pick the right algorithm for your workload, give each reader its own cache line, align the counters by hand, and verify with a profiler. It works, and it is real engineering. It also puts the burden on the person at the keyboard, applied by hand, per data structure, per workload - a personal guard posted at every juncture for the entire application lifetime. Our continuing work at SpeakEZ Technologies asks a different question: what if the structure of the program carried that cost internally? Instead of a "guard at every corner" curated by hand, transparent automation in the compiler always makes the correct choice. In our design, each actor owns its own region of memory, and actors that don't share memory cannot share a cache line. So the isolation an expert would otherwise build by hand becomes the default arrangement of a well-organized program. The coordination cost never appears because the design deals with it elegantly, with principles that persist. This is the performance focused companion piece to another blog entry we published regarding the correctness side of concurrency. Both come from the same conviction: a language whose first concern is concurrency should let its compiler carry "the hard parts", so engineers can focus on building solutions and allow intelligent tooling to match their design to the hardware's capabilities. We believe it shows the way to a safer, more efficient and maintainable future for systems design. Read our take here: https://lnkd.in/eN9i2-XN #Concurrency #SystemsProgramming #CompilerDesign #Performance

Live recomputation for a chaotic N-body simulation may seem like an academic flex, but it has massive implications for AI, quantum infrastructure, and high-assurance computing. The key is a principled mechanism to let a system calculate its own path backward. Doing that without a tape required a type system where values can structurally travel in reverse. By keeping these complex obligations entirely hidden inside automated solver tiers, we preserve everyday software engineering ergonomics while gaining absolute architectural certainty. What looks like a beautiful physics experiment is actually a blueprint for a highly efficient, ergonomic and utilitarian language design.

This is the companion to our Fixed-Point Scaffolding paper. It goes further into negative and fractional types, both in theory and application. https://lnkd.in/eh2kQNFF