The hottest Compilers Substack posts right now

And their main takeaways
Category
Top Technology Topics

Size Does Matter: Why -Os Beat -O2 on My ESP32-S3

atomic14 • 346 implied HN points • 07 Mar 26
🕹 Technology Compilers
  1. On the ESP32-S3, compiling with -Os (optimize for size) gave better results than using -O2 (optimize for speed).
  2. Binary size can matter more than you might expect on constrained microcontrollers, so smaller builds can be preferable.
  3. This challenges the common assumption that higher optimization levels focused on speed are always the best choice for embedded targets.

Emulating future RISC-V Vector extensions

Fprox’s Substack • 145 implied HN points • 08 Mar 26
🕹 Technology Compilers
  1. You can emulate proposed RISC‑V Vector extensions by translating them into RVV 1.0 intrinsics, so programs using new instructions can run on existing RVV1.0 hardware without compiler or hardware support for the new ops.
  2. The generated emulation is functional and easy to run but not optimal: the code is verbose and much slower than a dedicated hardware implementation, though it still lets you measure real performance and iterate on designs.
  3. The tool is Python‑driven and open source, already supports several draft extensions, and is useful for extension designers and early application developers to prototype and test features before toolchain or hardware support exists.

Copy-on-write teaches you EVERYTHING about Swift Internals 🐮

Jacob’s Tech Tavern • 2405 implied HN points • 15 Dec 25
🕹 Technology Compilers
  1. isKnownUniquelyReferenced is the tiny runtime check Swift uses to tell if a heap-backed value has only one owner. It’s the key mechanism that makes copy-on-write work under the hood.
  2. Copy-on-write lets structs behave like independent value types while sharing heap storage until you mutate them, at which point a uniqueness check triggers a deep copy. This gives easy-to-reason-about value semantics with low memory overhead.
  3. Many core Swift types (Array, Set, Dictionary, String, Data) use copy-on-write, and you can implement it yourself by wrapping your value in a reference box and using isKnownUniquelyReferenced to decide when to copy.

Beyond the Instruction Stream

More Than Moore • 467 implied HN points • 03 Feb 26
🕹 Technology Compilers
  1. They use a dataflow architecture that runs the compiler's intermediate graph directly instead of a traditional instruction stream, so pipelines stay full and ALUs can execute whole loops every cycle for much higher effective throughput.
  2. Memory is handled by many small, localized MMU-like units plus runtime telemetry that adapts allocations to reduce false sharing, enabling an order-of-magnitude more outstanding memory requests and very high HBM utilization even on irregular workloads like GUPS.
  3. Their go-to-market and tooling are HPC-first while supporting common parallel models (OpenMP, CUDA, Kokkos) with a "bring your own code" approach, hardware-accelerated low-overhead kernel reconfiguration, and chiplet/RDMA-style scaling, with AI-specialized designs planned later.

Software Machine Tools

Bzogramming • 61 implied HN points • 03 Mar 26
🕹 Technology Compilers
  1. There is no universal machine tool: every manufacturing process has hard trade-offs in cost, speed, materials, and geometry, and even hypothetical atom-by-atom assemblers would face stability, energy, and material limits.
  2. In software, theoretical universality (Turing-completeness) doesn’t imply practical usefulness—different paradigms like programming languages, neural networks, and superoptimizers are distinct "software machine tools" with very different real-world strengths.
  3. Big opportunities lie in alternative software tools and analyses—verification-driven code synthesis, superoptimizers, compact magic-constant solutions, better static analysis, and more visual/geometric tooling can solve hard problems more efficiently than brute-force code or giant models.
Get a weekly roundup of the best Substack posts, by hacker news affinity:

Compiling History: A brief tour of C compilers

Deus In Machina • 217 implied HN points • 04 Jan 24
🕹 Technology Compilers
  1. The history of C compilers dates back to the early 1970s with the creation of the first C compiler for Unix.
  2. Early C compilers like the PDP C Compiler and the Portable C Compiler laid the foundation for modern C programming.
  3. The development of standards like C89 brought uniformity and clarity to the C language, leading to the evolution of modern compilers like GCC and LLVM.

Borrow Checking from Scratch

Burning the Midnight Coffee • 64 implied HN points • 17 Nov 24
🕹 Technology Compilers
  1. The concept of 'borrow checking' helps programmers ensure their code is memory safe. This means the code won't allow unsafe practices like using memory that has already been freed.
  2. Implementing a simple, C-like language called Cnile can introduce memory safety by adding rules that check for issues during compilation rather than at runtime. This involves stopping problems like double-free and use-after-free situations.
  3. Using single-use types ensures resources can only be used once, which helps prevent memory leaks and makes it safer to manage dynamic data structures in programming.

Understanding the Compilation Process in C: A Step by Step Guide

Deus In Machina • 72 implied HN points • 11 Jan 24
🕹 Technology Compilers
  1. The compilation process in C involves preprocessing, compilation to assembly, assembly into an object file, and linking for the final executable.
  2. Each step in the compilation process serves a critical role in converting high-level C code to machine-executable instructions.
  3. Understanding the compilation process helps programmers appreciate the intricate steps involved in turning source code into functioning programs.

How security cookie works

bumbread • 19 implied HN points • 28 Aug 22
🕹 Technology Compilers
  1. Buffer overruns can lead to memory corruption by writing data outside allocated buffers.
  2. Security cookies are implemented to detect buffer overruns by placing a special value on the stack near the return address, which is checked for changes.
  3. Control over security checks can be managed by compilers, and understanding how security cookies work can be valuable in analyzing assembly code and optimizing performance.

Unblocking myself by writing compilers

derw • 0 implied HN points • 09 May 23
🕹 Technology Compilers
  1. When faced with a coding blocker, take a break and try various activities to get past it.
  2. Developing compilers by writing parsers can help to creatively solve coding challenges.
  3. Creating 'lunchtime languages' with parsers that can be written quickly can be an efficient way to experiment with new coding concepts.

Is Mixing OpenMP® Runtimes Safe?

CPU fun • 0 implied HN points • 31 Oct 23
🕹 Technology Compilers
  1. Mixing OpenMP runtimes in the same program can cause fatal issues.
  2. For non-offload codes, the LLVM runtime can provide the interfaces needed by GCC compiled OpenMP code.
  3. It's safer to link with the LLVM runtime only when dealing with OpenMP.

ABEND dump #5

Bit Maybe Wise • 0 implied HN points • 10 Jul 23
🕹 Technology Compilers
  1. ABEND dump is back after a break, sharing interesting content
  2. Tests should run fast, be easy to write, and give good feedback
  3. Compilers are fascinating software that can be optimized for faster performance