Welcome to The Software Frontier!
About
Where abstraction ends.
The Software Frontier is a publication for engineers who want to understand systems at the level the machine actually executes them.
Not the API boundary. Not the framework surface. The scheduler, the memory hierarchy, the execution model, the synchronization primitive underneath.
The focus is on the layers where modern systems become physical constraints: GPU execution pipelines, warp scheduling, PTX and SASS semantics, kernel internals, cache coherency, NUMA effects, distributed systems under failure, network transport behavior, concurrency control, and the infrastructure abstractions built on top of them.
Most essays are researched directly against primary sources: NVIDIA architecture documentation, PTX ISA specifications, SASS disassembly, Linux kernel source, ACM and IEEE papers, database engine internals, vendor postmortems, and production systems literature.
The objective is not to repackage existing summaries, but to reconstruct the mechanism itself from the lowest layer upward.
The promise to the reader is simple:
every claim should be traceable, every diagram should correspond to a real execution path, and every abstraction should eventually resolve into the hardware and software primitives that make it possible.
This is not a tutorial publication.
It is a systems publication for engineers who want to reason about how modern computing infrastructure actually behaves under the hood, at scale, and under real constraints.
The three threads
GPU execution. The Mastering CUDA and High-Performance Computing series, ten parts so far, goes from LLVM internals down to SASS, the warp scheduler, the memory hierarchy, cp.async, software pipelining, and the roofline model. It is the center of mass of the publication and the foundation that CUDA Mastery 2026 is built on.
Kernel internals. How Meta turned the Linux Kernel into a planet-scale Load Balancer: a three-part series on Katran, XDP, eBPF, stateless routing, and why hyperscale traffic outgrew userspace proxies. The kernel as a runtime.
Distributed systems at scale. How Systems Really Fail: a series opening with the November 2025 Cloudflare ClickHouse incident, threading through FLP impossibility, CAP, Lamport on clocks, and the structural reason production failures at scale stop being technical and start being epistemic.
Occasionally, an essay sits where the technical work meets the deeper questions, The Age of Synthetic Thought, The Future of Computer Science, Can Time Be Computed, Thinking in Systems.
Not the main thread. What happens when the main thread is followed far enough.
Who writes it
Lorenzo Bradanini. Co-founder and lead author at The Software Frontier. Systems engineer based near Como, Italy. Works at the GPU microarchitecture and kernel-internals level — the LLVM backend pipeline (FunctionPassManager, GVN, SROA, LoopVectorization, instruction scheduling), SASS, NVIDIA architecture from Volta through Hopper and Blackwell, and the full CUDA toolchain.
Co-founder of CortexFlow, an open-source container networking and observability project.
Author of the Software Architecture Patterns series under the CortexFlow technical publication: four parts, roughly 500 total reactions and thunderds of thousands of views, and of adjacent essays on AI compute (the DeepSeek analysis) and vector database internals.
Writes a second Substack, The Cognitive Layer : “the architecture of thought through AI, philosophy, mathematics, neuroscience, and software engineering”, for the cross-cutting and slower work that sits outside The Software Frontier’s technical scope.
Author of Il Silenzio Tra le Stelle, a book on physics, mathematics, and the limits of computation, organized around an original framework called the Principio Relazionale Fondamentale. Cross-posts technical notes on dev.to and Medium.
Lorenzo Tettamanti. Co-owner of The Software Frontier, co-author, and editor.
Co-founder of CortexFlow: the open-source container networking and observability platform written in Rust and eBPF, designed for distributed cloud and hybrid cloud–edge workloads running on Kubernetes.
The platform implements a sidecarless architecture with kernel-level traffic enforcement through TC and XDP hooks, eBPF-map-driven event propagation, adaptive telemetry pipelines, and an OpenTelemetry-integrated metrics and tracing stack optimized for high-throughput distributed environments.
Physicist by training, with working knowledge spanning distributed systems, Linux kernel internals, operating systems, CUDA programming, LLM inference systems, computational physics, networking, system design, backend infrastructure, frontend architecture, and data engineering.
Has practical experience building and operating cloud-native systems with Kubernetes and Docker, including container orchestration, networking, observability, distributed deployment pipelines, and infrastructure automation.
Works extensively across modern systems and application stacks including:
Rust, C, C++, Python, Java, TypeScript, eBPF, CUDA, SQL, and distributed runtime environments.
Experienced with frameworks and ecosystems including:
TensorFlow, PyTorch, React, Next.js, Node.js, Apache Spark, Apache Kafka, Docker, and PostgreSQL.
Co-authors the Mastering CUDA series, the Katran series, and How Systems Really Fail; leads the technical and editorial review of every long-form publication before release, with particular focus on correctness, systems-level reasoning, and architectural fidelity to underlying implementation details.
Cadence
The Software Frontier publishes long-form technical essays roughly every one to two weeks.
The publication is intentionally low-frequency and research-heavy. There are no filler issues, recycled news summaries, trend recaps, or “five links of the week” posts designed to satisfy an algorithmic schedule. Every essay is written only when there is something substantial enough to justify the reader’s attention.
Some pieces take multiple weeks of research, reconstruction, benchmarking, source tracing, and editorial review before publication. When there is nothing worth publishing, nothing goes out.
The objective is not output volume.
It is signal density.
Free and paid
Many essays published by The Software Frontier remain free and publicly accessible.
A smaller subset of essays, typically the pieces requiring the deepest original research, architecture reconstruction, kernel-level investigation, or multi-week technical analysis, are reserved for paid subscribers.
Paid subscriptions fund the research time that makes this level of depth possible:
time spent reading architecture documentation, tracing execution behavior, reproducing systems behavior experimentally, reviewing source code, validating claims against primary references, and editing large technical manuscripts to publication quality.
Paid does not exist to lock away the publication itself.
A large chunk of the work remains public by design.
The goal is to build a sustainable, long-term systems publication supported by readers who value serious technical writing and deep engineering analysis.
Paid subscribers receive:
access to subscriber-only essays and research series
the full publication archive
discussion threads and technical community access
early access to selected long-form essays and releases
Products
CUDA Mastery 2026
The Definitive Engineer’s Reference for Hopper, Blackwell, and Beyond.
CUDA Mastery 2026 is a production-focused deep technical reference covering modern NVIDIA GPU architecture, CUDA programming, kernel optimization, and large-scale accelerated computing systems.
The guide includes:
27 technical chapters
5 appendices
end-to-end fact-checking against NVIDIA primary documentation
PTX ISA 8.7 coverage
architecture-level analysis of modern NVIDIA execution models
Coverage includes:
CUDA Toolkit 13.0–13.2
compute capabilities 7.5–12.1
WMMA, WGMMA, and UMMA (tcgen05)
Tensor Memory Accelerator (TMA)
thread block clusters
CUDA Tile and Tensor Memory
CUTLASS 4 and CuTe
NCCL 2.30
Nsight 2025.4 tooling and profiling workflows
The material is designed for engineers writing and optimizing production CUDA kernels, inference systems, HPC workloads, and distributed GPU infrastructure.
Available on Gumroad · €89
Sponsorships
The Software Frontier reaches a concentrated audience of engineers and technical operators working across:
ML infrastructure
GPU programming
high-performance computing
distributed systems
cloud infrastructure
low-level systems engineering
The readership includes engineers working with CUDA, inference systems, Kubernetes infrastructure, networking, observability, and large-scale backend systems.
If your company, infrastructure product, developer tool, or platform serves that audience, sponsorship information is available through the sponsor page.
Elsewhere
The Cognitive Layer
Companion publication focused on broader and slower essays exploring philosophy, technology, systems, intelligence, and long-form conceptual analysis.
dev.to/cortexflow
Shorter technical notes, implementation details, experiments, and working drafts.
Medium
Additional essays, engineering posts, and technical writing.
CortexFlow GitHub
Open-source infrastructure projects, systems tooling, and kernel/networking work related to CortexFlow.
CortexFlow Website
Platform documentation, architecture information, and project updates.
VivereComo
Tourism and regional discovery platform focused on the Lake Como region, including editorial content, travel infrastructure, and local experience discovery.
Gumroad
Technical guides, references, and long-form engineering material.
Contact
Reply directly to any essay or publication email.
Every polite reply is genuinely read.
