llvm

TinyGo 0.42 introduces recoverable panics, Go 1.27 support, UEFI targets, and expanded hardware support for ESP32 and STM32, enhancing its capabilities for embedded systems development.

The article describes how switching a BPF program to use BTF-generated vmlinux.h caused incorrect IP checksums due to Clang's Type-Based Alias Analysis optimization, and details the debugging process through assembly inspection.

The author details converting the scheme-rs Scheme implementation to a CPS-based JIT compiler and applying three optimizations, including beta-reduction, to achieve a 25x performance improvement.

This article discusses how MLIR compiler passes can introduce NaN values through constant folding even with valid operands, and proposes a verification workflow to catch and fix such issues at the IR boundary.

LLVM 23 delivers a 6.75% reduction in compile-time for -O3 builds, driven by key improvements in ADT hash maps, sets, and other components.

This paper presents a zero-overhead, multi-vendor GPU compilation framework built into the Rust compiler, leveraging Rust's ownership model to ensure memory safety and achieve competitive performance with native CUDA and HIP baselines.

A YouTube playlist featuring talks and slides from the 2026 EuroLLVM conference, a meeting for LLVM developers and enthusiasts.

A technical blog post explaining how to compute graph dominators, comparing the Lengauer-Tarjan algorithm with the 'A Simple, Fast Dominance Algorithm' and providing intuition behind the data-flow approach.

The article describes methods to find missed alarm bugs in the Alive2 formal verification tool by adapting the YARPGen random program generator for differential testing.

A developer discovers a decades-old bug in Knuth's Algorithm D for long division, leading to a new theorem added to the TAOCP errata, and also uncovers a related bug in LLVM's implementation.

RPCS3's ARM port now runs 60% faster and draws 25% less power after fixing a busy-wait timer bug, replacing x86 pause with ARM ISB, and reworking LLVM code generation. The gains come from low-level ARM optimizations driven by a cheap Android handheld test device.

BorrowSanitizer is an open-source LLVM sanitizer for detecting Rust-specific aliasing violations in multi-language applications, aiming to be fast enough for fuzzing and to support Rust, C, and C++ interop.

This post explains MLIR as a compiler infrastructure framework that provides a flexible dialect stack, describing how it is used across modern ML compilers like XLA, Triton, and Mojo to progressively lower tensor operations to machine code.

Fil-C is a fully memory-safe implementation of C/C++. It bundles pointer values with boundary information using invisicaps at the LLVM IR stage, achieving high compatibility with a performance penalty of about 4x.

A detailed analysis of Rust's std::simd::swizzle_dyn implementation, exposing performance shortcomings and proposing optimizations to better leverage hardware shuffle instructions.

The author built a joke programming language called bet that compiles via LLVM, uses arena-based memory management, and successfully runs the full DOOM game (56,000 lines) without code review, relying only on tests.

This blog post explores a technique to make legacy Fortran simulation code differentiable using LFortran, Enzyme, and Tesseract, allowing automatic differentiation and integration with JAX for use in machine learning pipelines.

This article explains how implementing a Dense Arena Interner can drastically improve compiler performance by converting strings and structures into dense integers, enabling O(1) comparisons after an upfront hashing cost during lexing.

LLVM is a collection of modular and reusable compiler and toolchain technologies used for developing compiler front ends and back ends.

This blog post explores an optimization for LLVM's SmallVector::push_back by tail-calling the grow-and-push path, which eliminates callee-saved register spills and improves the fast path performance.