Tag: #compiler

한국어English日本語中文

← All posts

• The HEIR Homomorphic Encryption Compiler and the Condition Called Cost — When the Comments Supply the Number the Announcement Omits

  Google published HEIR, an open source compiler toolchain for homomorphic encryption. The real news here is the compiler, not the cryptography — what has kept homomorphic encryption out of deployment was never the mathema

  2026-08-14 · 7 min read #cryptography#privacy#compiler#machine-learning#security

• When Two Services That Passed the Type Checker Halt Waiting for Each Other — Choreography as a Different Approach

  Using a language that guarantees memory safety does not stop two services from halting while each waits for a message from the other, because the field of view of a type checker ends at one process. Choreographic program

  2026-08-09 · 8 min read #programming-languages#compiler#distributed-systems#type-systems#concurrency

• GPU Compiler and Framework Landscape — One Problem, Turning a Graph into a Kernel, a Different Answer at Every Layer

  This post puts NVCC and PTX, LLVM, MLIR, Triton, torch.compile, XLA, IREE, and TVM on one map. Different names, different owners, but they all solve the same problem: turning a computation graph into an executable kernel

  2026-08-02 · 21 min read #gpu#compiler#mlir#triton#pytorch

• Three Layers of Writing a Kernel — Comparing CUDA C++, Triton, and CUTLASS on the Same Problem

  Compares what changes when you approach the same GPU kernel by hand in CUDA C++, tile-by-tile in Python with Triton, or assembled from templates in CUTLASS and CuTe. We actually write a row-wise softmax in both CUDA C++

  2026-08-02 · 18 min read #triton#cuda#cutlass#gpu-kernel#compiler

• ZJIT's Lightweight Frames — How Ruby 4.1 Erases Method-Frame Pushes, and What It Costs

  Ruby 4.0 shipped ZJIT on December 25, 2025 — but shipped it turned off: it's compiled into the binary, yet the default JIT is still YJIT. The official release notes put it this way: "ZJIT is faster than the interpreter,

  2026-07-16 · 20 min read #ruby#zjit#yjit#jit#compiler

• Triton Gluon: The Language That Hand-Writes the Layouts the Compiler Used to Hide

  Gluon is a low-level GPU language built on the same compiler stack as Triton — it hands kernel authors the layouts, shared memory, and warp specialization that Triton normally keeps hidden. Its reason for existing is cle

  2026-07-16 · 19 min read #gpu#triton#kernel#compiler#performance

• Zig 0.16.0 — The Release That Turned I/O into an Interface, and the Bill It Came With

  Zig 0.16.0, released on April 14, 2026, changed the standard library so that every I/O operation takes an Io instance as an argument. It takes the old Zig habit of passing an Allocator as an argument and applies the same

  2026-07-16 · 23 min read #zig#systems-programming#async-io#compiler

• TypeScript 7 Is GA — the 8-12x Is Real, but Some People Cannot Move Today

  On July 8, 2026, TypeScript 7.0 went GA. The Go-rewritten native port is no longer a separate binary — it is now simply tsc, and npm install -D typescript pulls it in. Microsoft's reported full-build speedup is 8 to 12x,

  2026-07-16 · 18 min read #typescript#compiler#tooling#build-systems#compile-times

• React Compiler Got Ported to Rust — What Merged, What Did Not, and That "10x" Number

  On June 9, 2026, PR 36173 — a Rust port of React Compiler — merged into facebook/react main. It added more than 120,000 lines across 461 files, and the number "3x faster as a Babel plugin, about 10x faster in the transfo

  2026-07-16 · 19 min read #react#rust#compiler#performance#frontend

• Rust 1.97 Cut Off Pre-Volta GPUs — Inside the nvptx64 Baseline Bump

  Rust 1.97 (July 9, 2026) raised the minimum requirements for the nvptx64-nvidia-cuda target to PTX ISA 7.0 (CUDA 11 driver or newer) and SM 7.0 (Volta or newer). Maxwell- and Pascal-generation GPUs, and CUDA 10 and older

  2026-07-16 · 13 min read #rust#cuda#gpu#compiler#nvidia

• Kotlin Swift Export Reaches Alpha — It Is Tearing Down the Objective-C Bridge, but Do Not Cross Yet

  The biggest tax Kotlin Multiplatform has paid on iOS has been the Objective-C bridge. Kotlin code could not reach Swift without passing through an Objective-C header, and in that crossing, Int? got boxed into KotlinInt,

  2026-07-16 · 17 min read #kotlin#kotlin-multiplatform#swift#ios#compiler

• Clang 22's MSVC ABI Change — the Vector Deleting Destructor and the delete[] Heap Corruption Still Alive in 22.1.x

  Clang 22.1.0 (2026-02-24) changed destructor codegen in two places when targeting the MSVC ABI. One aligns ::delete handling with MSVC; the other is vector deleting destructor support, closing an issue opened in 2014 aft

  2026-07-16 · 17 min read #llvm#clang#cpp#compiler

• Elixir 1.20's Gradual Type System — The Reality of Finding 'Verified Bugs' Without Annotations

  Elixir v1.20, released on June 3, 2026, closed out the first milestone of the set-theoretic type system work that began in 2022. Every Elixir program is now gradually type-checked without a single type annotation, and th

  2026-07-16 · 17 min read #elixir#type-system#beam#compiler#static-analysis

• Opinionated Tools — gofmt, gofumpt, and the Politics of Code Style

  Why was code formatting ever a subject of debate, and how did gofmt end it? We compare gofmt with the stricter gofumpt, and contrast them with tools from other languages like prettier and black, taking a deep look at how

  2026-06-25 · 21 min read #compiler#go#gofmt#gofumpt#formatter

• GPU vs TPU vs ASIC — The 2026 Inference War

  A comparison of the GPU, TPU, and ASIC competition over 2026 inference workloads. We cover Google TPU v6 Trillium and Ironwood, the fast-growing cloud in-house inference ASICs, the throughput/latency/cost/power trade-off

  2026-06-16 · 23 min read #gpu#tpu#asic#inference#ai-hardware

• The Charm of Small Languages — Janet, Lua, and the World of Embeddable Scripting

  The essay Why Janet is back on the HN front page, and interest in small embeddable languages is reviving. From the success story of Lua to the design philosophy of Janet, hands-on C embedding examples, an introduction to

  2026-06-12 · 16 min read #janet#lua#embedded-scripting#dsl#programming-languages

• Compiler and Linker Internals — From #include to an Executable: ELF, Symbols, Static/Dynamic Linking, Relocation, LTO (2025)

  Tracing the journey of "hello.c" becoming an executable, atom by atom. The four phases of preprocess / compile / assemble / link, ELF file layout, symbol tables and relocation, the archive structure of static libraries,

  2026-04-15 · 20 min read #compiler#linker#elf#symbol#static-linking

• Compilers and Modern Language Runtimes — LLVM, JIT, GC, V8 TurboFan/Maglev, Inline Caching, Escape Analysis, Rust Monomorphization Complete Guide (2025)

  Everything that happens from a line of code to CPU execution. LLVM's dominance, V8's 4-tier JIT, Hidden Classes and Inline Caching, Escape Analysis, GC lineage from Mark & Sweep to ZGC, Go's work-stealing scheduler, Rust

  2026-04-15 · 11 min read #compiler#runtime#llvm#jit#garbage-collection

• Compiler & Interpreter Design Complete Guide 2025: Lexer, Parser, AST, Code Generation

  Everything about compiler/interpreter design! Lexer (tokenization), Parser (syntax analysis/recursive descent/Pratt), AST (abstract syntax tree), semantic analysis (type checking), IR (intermediate representation), code

  2026-04-14 · 31 min read #compiler#interpreter#lexer#parser#ast

• Compilers and Interpreters: How Code Actually Runs — Everything Developers Need to Know

  A complete deep-dive into how code executes! Lexing → Parsing → AST → IR → Code Generation, Compiler vs Interpreter vs JIT, V8 (JS), CPython (Python), JVM (Java), GCC/LLVM, GraalVM — build the performance intuition every

  2026-03-23 · 17 min read #compiler#interpreter#lexer#parser#ast