compiler

Solod v0.2 releases with networking support (TCP, UDP, Unix sockets), new compilation targets (32-bit, WebAssembly, bare metal), and improved C interoperability.

Loko Scheme 0.13.0 is released with bug fixes, performance improvements, and new features. It is an optimizing Scheme compiler that supports R6RS and R7RS standards.

This blog post details three recent optimizations to LLVM's BumpPtrAllocator, reducing fast-path overhead by removing redundant alignment, null pointer checks, and per-allocation accounting, resulting in improved performance for Clang, lld, and other LLVM components.

A developer shares months of work building a compiler that outperforms cuBLAS for matrix multiplication on an A100 GPU, with visualizations.

Introduces a paper accepted at PACT 2025, proposing the ComPilot framework, which uses off-the-shelf LLMs as optimization agents to automatically optimize complex loop nests without fine-tuning, achieving a geometric mean speedup of 3.54x, surpassing the SOTA Pluto.

OxCaml, Jane Street's superset of OCaml, introduces a `[@zero_alloc]` annotation that forces the compiler to refuse to build if any function in the call tree allocates on the heap, shifting allocation detection from runtime profiling to compile-time enforcement.

Mojo, a programming language designed for AI and high-performance computing, will soon become open-source, enabling broader community adoption and contribution.

Prism is a new functional language that integrates algebraic effects with a type system, allowing mutable state and other effects to be used without monads while preserving purity externally. It aims to make effects a first-class part of the type system, enabling optimization and safe usage.

Gossamer is a new programming language inspired by Rust that features real goroutines, pause-free deterministic memory management with reference counting and arenas, and a bytecode VM with LLVM compilation. It aims to provide expressive syntax without a borrow checker or garbage collector pauses.

Slisp is a simple compiler that reads Lisp programs and generates standalone assembly representations for Linux/AMD64, with support for basic primitives, closures, and a standard library.

Zig's SPIR-V backend has been overhauled with new built-in types, improved execution mode handling, capabilities/extensions from CPU features, multi-threaded codegen, and object file linking, making it more useful for shader and GPU programming.

Kuma is a compiler/runtime that compiles exported PyTorch models into self-contained WebGPU executables, enabling direct browser inference without Python or server dependencies.

A blog post describing a tiny compiler that demonstrates how to lower data-parallel kernels by converting for loops into vectorized loops with lanes and masks, implemented in ~180 lines of Python.

Zig language introduces new @bitCast semantics and improves its LLVM backend by changing integer lowering to avoid miscompilations and better align with compiler optimizations.

Reverse engineering the Qualcomm NPU compiler reveals undocumented VTCM memory management, MILP-based placement, automatic precision alteration, and a hidden analytical simulator (Hextimate) for edge deployment optimization.

Fil-C introduces memory-safe inline assembly, ensuring that programmer errors result in panics or traps rather than miscompilation.

A developer shares their weekend project of building a low-level infix language that compiles to WebAssembly, and offers a personal ranking of AI coding tools from contextual autocomplete to frontier models.

The GHC team outlines progress on making GHC upgrades easier, focusing on the Big Stability Goal and Base Package Goal to decouple the base package from compiler releases.

This article explores how intermediate floating-point precision in C++ code depends on compiler settings, CPU flags, and architecture, particularly on x87 FPU, and how this affects performance and calculation results.

A technical report introducing the APLR(1) algorithm for generating compact LR(1) parsers, which is simpler and more capable than the existing IELR(1) algorithm, and supports nondeterministic/ambiguous grammars for GLR parsing.