Useful Abstractions is a C++23 header-only library providing seven compile-time utility components, installable as a single header, CMake dependency, or vendored checkout. The library enables constexpr string handling and type introspection, with the fixed_string component allowing string literals as non-type template parameters.
Linux From Scratch is a project providing step-by-step instructions for building custom Linux systems from source code. It includes multiple subprojects like BLFS for extending installations, ALFS for automation, MLFS for 32-bit support, and GLFS for gaming, along with documentation, patches, and historical archives.
Ouroboros HTML is a humorous project that compiles HTML through 20 incompatible programming languages and runtimes (Python, PHP, Go, C, WebAssembly, Brainfuck, JavaScript, Svelte, PostgreSQL, Pandoc, and others) to produce functionally identical HTML5 output, demonstrating the software engineering principle of solving problems through layers of indirection while ironically proving the inverse theorem about too many abstraction layers.
Unison is a statically-typed functional programming language featuring content-addressed code stored as ASTs in a database, enabling perfect incremental compilation, instant renaming, and semantically-aware version control. It supports type inference, an effect system, and can be used standalone or with Unison Cloud for distributed systems development.
C++26 introduces three targeted improvements to the C++20 module system: prohibiting macros in module declarations to enable faster dependency scanning, allowing main to be explicitly attached to modules for easier testing, and permitting #line directives before module declarations for better code generator support. These changes address adoption friction without adding new features.
Kache v0.21.0 expands caching for C/C++ compilation, adding support for whole-program links, preprocessor output, Windows clang-cl flags used by Firefox, and single-source CUDA nvcc compilation. New features include machine-level configuration defaults, trust domain isolation for persistent stores, and improved telemetry.
Closure Compiler is a JavaScript optimizer and checker that compiles JavaScript to faster, smaller JavaScript by analyzing code, removing dead code, and minimizing output. It requires code written specifically for the compiler and uses aggressive whole-world optimization that can break code if global variables or properties are hidden from analysis. The tool primarily supports Google's goog.module syntax and has limited, unmaintained support for ECMAScript and CommonJS modules.
A Spanish-language article about setting up local AI (LLMs) with Emacs for programming projects. The author describes installing llama.cpp from source, selecting the Qwen 3.5 9B model, and troubleshooting compilation and library linking issues on OpenSuse Tumbleweed.
AgentJIT is a compiler that traces dynamic LLM agent workflows and converts them into optimized Python code, reducing execution time from seconds to milliseconds and eliminating API token costs for recurring patterns. It works by capturing tool calls on the first run, analyzing data dependencies, and generating type-safe Python pipelines with automatic fallback to the LLM agent if inputs diverge.
A developer created buildprof, an open-source Linux tracing tool that visualizes compile times by showing process timelines during builds. The tool was inspired by investigating why Bun's Rust build was reportedly 5× faster than its previous Zig build, revealing how factors like compiler choice and link-time optimization strategies affect build performance.
GSH is a lightweight interactive REPL for the Gleam programming language, built in Gleam and Erlang. It provides fast in-memory code compilation (~18ms evaluation), hot-reloading, tab-completion, and BEAM VM integration for debugging, prototyping, and interactive development without JavaScript support.
U is a new programming language that transpiles PHP, JavaScript, and TypeScript to compiled C binaries, achieving 14K–70K requests per second compared to PHP's 800 req/s and Node's 2.4K req/s. The compiler catches null dereferences and capability violations that LLMs introduce 23–31% of the time, producing tiny, dependency-free binaries suitable for edge computing and resource-constrained environments.
A C++ pointer cannot distinguish host from device memory, creating a type system vulnerability where GPU data accessed from the host compiles but crashes at runtime. Vx fixes this by encoding memory space directly in the type signature, making unsafe memory accesses a compile-time error instead.
JEP 544 introduces ahead-of-time (AOT) code compilation for Java's HotSpot JVM to improve startup and warmup times by pre-compiling application code to native code during a training run and caching it for production use. The system dynamically regenerates native code if workloads change, combining AOT and JIT compilation benefits without requiring application code changes or new workflows.
DeepJIT is a header-only C++20 JIT runtime that provides a unified interface for compiling and caching GPU kernels on NVIDIA CUDA and Huawei Ascend devices. It enables kernel libraries to share runtime infrastructure including caching, lazy initialization, and distributed filesystem support across both backends.
ARM engineer Lorenzo Stoakes submitted 23 patches to significantly speed up Linux kernel compilation by addressing single-threaded bottlenecks, achieving up to 90% faster noop builds. An LLM assisted in identifying bottlenecks and generating code, which Stoakes then extensively audited and rewrote, with improvements verified across multiple hardware configurations and kernel settings.