Cloudflare's VoidZero team develops tsrs, a Rust port of the TypeScript compiler that reduces memory usage by 70% and achieves up to 8x faster type checking than the Go-based version, while adding WebAssembly support for browser-based type checking.
JD engineers detail their migration from monolithic KMP delivery to per-component builds for iOS and HarmonyOS, sharing a stdlib/runtime carrier, fixing bridge numbering mismatches and type ID issues in the KN compiler, implementing custom Gradle plugins and CI/CD for independent XCFramework/HAR publishing, enabling on-demand integration and faster builds.
TypeScript 7.0 rewrites its compiler in Go, enabling multi-threaded type checking and shared memory, cutting VS Code codebase type-check time from 125.7s to 10.6s (12x faster) and reducing memory usage by half, eliminating editor lag in large projects.
Praneos Labs benchmarked 26 Go versions (1.2 to 1.27) on identical hardware, revealing three performance phases: compiler overhaul (1.5–1.7), a seven-year throughput plateau (1.8–1.23) focused on GC latency, and recent runtime optimizations (1.24–1.27) delivering an 11.5% speedup over 1.23, with map-heavy and allocation-heavy code benefiting most while numeric loops stagnated since 1.7.
Quartex Pascal releases a new compiler with Delphi-compatible generics, full RTTI, binary records for low-level memory access, near-doubled compilation speed, and self-hosting capability, demonstrated by porting the Reticulum network protocol from C to Object Pascal.
Polonius Alpha, the flow‑sensitive next‑generation borrow checker for Rust, has arrived in the Nightly channel, promising to accept code previously rejected by the flow‑insensitive NLL checker, with performance impact largely negligible across thousands of popular crates, while still offering a way to disable it.
The August 2026 preview of MSVC Build Tools for Visual Studio v14.52 introduces extensive front‑end, module, optimizer, debugger, static analysis, and linker enhancements, along with dozens of bug fixes, and can be obtained via the Stable or Insiders channel.
Mojo 1.0, the production‑ready language created by Chris Lattner, promises a unified, open‑source AI stack that combines Python simplicity, Rust safety, and C‑level performance via MLIR, breaking CUDA lock‑in and supporting any GPU, CPU or ASIC.
The article evaluates Go, Rust, and Zig under the new AI‑assisted development paradigm, comparing raw execution performance, memory overhead, latency, compile speed, and AI‑coding productivity, and concludes that Go currently offers the most efficient AI feedback loop while Rust excels in safety and Zig lags behind.
scriptc, an open‑source tool from Vercel Labs, can compile a TypeScript file into a ~178 KB native binary that starts in about 2 ms, prompting a debate over originality with the earlier Perry project; the article examines their compilation pipelines, runtime strategies, feature boundaries, and the broader implications for the TypeScript ecosystem.
Ant Group has open‑sourced Jeandle, a new LLVM‑powered JIT compiler for the OpenJDK HotSpot JVM that promises to boost Java performance, explains JIT and LLVM fundamentals, and outlines a detailed roadmap toward full bytecode support and advanced optimizations.
The article contrasts Bun's 11‑day AI‑driven rewrite of 500 k lines of Zig to Rust with Roc's 487‑day manual rewrite of a 300 k‑line Rust compiler to Zig, analyzing the engineering motivations, performance benchmarks, memory‑safety bug counts, and ecosystem trade‑offs that led each team to choose its language.
The TypeScript team rewrote the compiler in Go, achieving roughly a ten‑fold build‑time reduction, and the article analyzes how Go’s fast compilation, deterministic dependency handling, and lack of hidden runtime magic make it a superior default language for AI‑driven agent pipelines compared with Python, Rust, and the Node ecosystem.
The article dissects the Go 1.28 planning notes, detailing upcoming compiler memory‑free mechanisms, pre‑compiled Cgo support, revived generic containers, SIMD extensions, Wasm stack‑switching, structured struct tags, sharded counters, and GC scalability work, while explaining the motivations, trade‑offs, and open questions behind each proposal.
TypeScript 7.0, rewritten in Go, boosts compiler speed by 8‑12× across large codebases, cuts memory use, slashes editor error‑display latency, and introduces new parallel flags, while the article explains why Go was chosen over Rust and how to upgrade safely.
The article examines how Go’s compiler handles constant folding, using the vtprotobuf SizeVT function to illustrate compile‑time size calculations, and explains that inlining feasibility and compile‑time known arguments are key factors that determine whether expressions are folded into constants.
Microsoft’s TypeScript 7.0 RC rewrites the compiler in Go, delivering roughly ten times faster type checking through native execution and parallelism, introduces new CLI flags for concurrency, replaces the file‑watcher with a Go implementation, adds many breaking changes, and ships a multithreaded language server with richer editor features.
The article traces how low‑level programming harnesses—from ENIAC wiring and punch‑card code to assembly, compilers, operating systems, database optimizers, and memory‑management techniques—have been progressively abstracted away by tools, type systems, and language semantics, highlighting what has been "eaten" and what still requires manual expertise.
Microsoft’s TypeScript 7 RC replaces the compiler core with Go, delivering roughly a ten‑fold speed increase across CLI builds and editor services while remaining fully compatible with TypeScript 6 semantics, and provides detailed upgrade guidance and parallel‑compilation options.
The React team fully migrated the React Compiler from TypeScript to Rust, combining human‑designed architecture with AI‑generated code, achieving up to 10× faster core conversion, a 3× overall compile speed increase, seamless integration with Babel, SWC and OXC, and a rigorous three‑layer testing regime.
The React team merged a massive PR that ports the React Compiler from TypeScript to Rust, adding over 123,000 lines, delivering roughly 3× overall speed and 10× pure transform speed, preserving the original architecture, passing 1,725 tests, supporting Babel, OXC and SWC integrations, and largely written with Claude AI, though it remains an early‑sharing experimental build.
Meta merged a massive PR that rewrites the official React Compiler in Rust, adding 123,289 lines, delivering roughly 3× overall speed‑up (10× on pure transforms), preserving the original architecture, passing 1,725 tests, and largely authored by Claude AI.
The article explains that system calls are triggered by CPU‑provided privileged instructions (e.g., int 0x80, syscall, svc), with compilers translating high‑level calls into these instructions, and why user‑mode programs cannot access hardware directly for security reasons.
The article examines Go’s long‑standing boilerplate adapter pattern, explains the newly accepted Issue #47487 that enables explicit conversion of functions to single‑method interfaces, compares it with the rejected implicit assignability approach, and shows how the compiler generates hidden types to preserve safety and reduce code.
Swoole Compiler v4 introduces a Native AOT compiler that turns PHP code into native binaries with performance comparable to Rust and Go, offers about 95% PHP compatibility, outlines a C++‑based compilation pipeline, reports up to 150× speed gains, and signals a major shift for the PHP ecosystem by 2027.
A Go compiler issue shows that an exponentially growing string constant can exhaust memory during compilation, causing an out‑of‑memory crash, and the article explains how the constant is built, why it differs from variables, historical related bugs, the core team's mitigation plans, and practical safeguards for code generators and online compilers.
The article explains how Java generics, introduced in Java 5 to improve type safety and reduce code duplication, rely on type erasure for backward compatibility, detailing its implementation, advantages such as compatibility and performance, drawbacks like lack of primitive support and overload restrictions, and practical techniques to mitigate these issues.
The Swoole‑Compiler v4 adds a native Ahead‑of‑Time (AOT) compiler that transforms PHP scripts into standalone binaries, eliminating the ZendVM interpreter, achieving up to 150× speed gains in intensive calculations such as Fibonacci and π, while detailing supported syntax, limitations, C/C++ interop, real‑world Workerman testing, and future roadmap.
This article details Kuaishou's systematic compiler and build‑system optimizations—including AutoFDO, ThinLTO, BOLT, and a newly improved Propeller—showing how they reduced compilation time from hours to seconds, cut CPU usage by 10%, and achieved up to 15% performance gains while solving profile‑staleness and integration challenges.
An open‑source PHP‑written Rust compiler can generate native x86‑64 Linux ELF binaries without LLVM, assemblers, or linkers, offering ownership, borrowing, type checking, generics, traits, closures, and more; the guide covers installation via PHP and WSL, usage commands, supported features, and current limitations.
An analysis of Go 1.26’s milestone data reveals a spike to 39 open issues—far higher than previous releases—highlighting major compiler, runtime, and go‑fix regressions and offering a risk‑based guide on whether to upgrade now.
Microsoft announced the TypeScript 6.0 beta, the last version written in JavaScript, and revealed that the compiler will be re‑implemented in Go to improve editor startup, reduce build times, and cut memory usage, with new default compiler options and tsconfig behavior changes.
This article explains why Java’s finally block normally runs, dives into the compiler’s code‑copying, the bytecode exception table, JVM dispatch, JIT optimizations, and the design trade‑offs that ensure reliable cleanup while highlighting cases where finally may be skipped.
This article analyzes seven years of Go language support for the LoongArch architecture, presenting commit statistics, developer ecosystem growth, module change distribution, key compiler and runtime components, and future development trends based on detailed Git repository data.
The Microsoft TypeScript team rebuilt the compiler in Go, setting hard performance goals, choosing Go for its GC and concurrency, prototyping the scanner and parser, redesigning AST structures, and leveraging parallel parsing and independent type‑checkers to cut VS Code compile time from 80 seconds to 7 seconds, a ten‑fold improvement.
Jeandle is an open‑source LLVM‑backed JIT compiler for the JVM released by Ant Group, designed to bring LLVM’s high‑performance optimizations to Java, with a detailed roadmap, technical overview, and public GitHub repositories for developers to explore.
Jeandle is a new open‑source JIT compiler for the JVM, built by Ant Group on LLVM, which brings LLVM’s performance and ecosystem advantages to Java, explains JIT and LLVM basics, outlines its architecture, future roadmap, and provides GitHub links for the project.
Jeandle, an open‑source JIT compiler built on LLVM, introduces LLVM’s performance and modularity to the OpenJDK HotSpot JVM, explains core concepts of JIT and LLVM, outlines technical challenges, and presents a roadmap toward full bytecode support and advanced optimizations.
This article walks through the design and implementation of a static analysis framework for C programs using MoonBit, covering lexical and syntactic parsing, AST generation, conversion to a control‑flow‑graph IR, and data‑flow analyses such as uninitialized‑variable detection and liveness.
Microsoft’s Project Corsa rewrites the TypeScript compiler in Go, achieving a ten‑fold performance increase, halving memory usage, adding native multithreaded builds, and providing a stable Native Preview that developers can adopt today, while outlining the roadmap toward instant‑build compilation.
Microsoft announced that the upcoming TypeScript 7 (codenamed Corsa) reaches its final stage, offering near‑full compatibility, up to ten‑fold faster compilation on large codebases, a shift to a Go‑based compiler, and a new VS Code language service with shared‑memory architecture.
GCC has officially made C++20 the default language standard, a shift that reshapes codebases, tooling, and developer habits, requiring both newcomers and seasoned programmers to adapt to new features like modules, concepts, and coroutines while managing potential build issues.
This article explains the natural alignment requirements of C/C++ data types, how structs are padded and aligned based on member alignments, the hardware, cache and compiler reasons for alignment, and the concept of over‑aligned types with practical examples and usage guidelines.
This article details the year‑long exploration of Profile‑Guided Optimization (PGO) for WeChat’s backend, covering its theory, compiler implementations, practical experiments with Propeller and BOLT, transparent eBPF sampling, engineering challenges, and the measurable CPU and memory savings achieved across production services.
Jeandle, an open‑source JIT compiler built on LLVM, brings advanced optimization and code generation to the OpenJDK HotSpot JVM, promising dramatic performance gains, modular extensibility, and a roadmap that includes full bytecode support, custom Java optimizations, and modern garbage‑collection integration.
Jeandle, the newly open‑sourced LLVM‑based JIT compiler from Ant Group, combines JVM and LLVM strengths to dramatically boost Java execution speed, explains JIT and LLVM fundamentals, outlines its architectural advantages, and details an ambitious roadmap toward full bytecode support and advanced optimizations.
Jeandle, the new open‑source LLVM‑based JIT compiler for the OpenJDK HotSpot JVM, brings LLVM's powerful optimizations to Java, explaining JIT fundamentals, LLVM architecture, and the project's ambitious roadmap toward full bytecode support and advanced Java‑specific performance enhancements.
Jeandle, an open‑source JVM JIT compiler from Ant Group, leverages LLVM's modular optimization and code‑generation capabilities to bring unprecedented performance to Java applications, outlining its architecture, core concepts, and ambitious roadmap for future enhancements.
This article examines real‑world anecdotes of hidden backdoors in software, explores how Chinese law treats such vulnerabilities, and outlines the hierarchy of backdoor techniques from simple code tricks to compiler‑level implants, highlighting the security risks they pose.
The article examines how two leading Rust compiler engineers, Nicholas Nethercote and Michael Goulet, are seeking new positions, highlights their massive contributions, discusses the funding challenges of the Rust foundation, and explores how AI and corporate priorities are reshaping the future of the language.
Two leading Rust compiler engineers announced they are looking for new positions, exposing funding gaps in the Rust Foundation, highlighting their massive contributions to the language, and sparking a broader debate about how open‑source projects can sustainably support core developers amid AI‑driven budget shifts.
This article examines whether the C/C++ entry‑point function main can call itself recursively, outlines the relevant language standards, shows compiler support and example code, discusses practical limitations such as stack size and portability, and recommends safer programming patterns.
Jeandle, the new open‑source JVM JIT compiler from Ant Group, uses LLVM to bring advanced optimization and code generation to Java, promising dramatic performance gains and a roadmap that includes full bytecode support and cutting‑edge Java‑specific optimizations.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to integrate LLVM’s high‑performance optimizations into the JVM, offering faster execution, future roadmap details, and insights into JIT and LLVM fundamentals for Java developers.
Jeandle, the new open‑source LLVM‑based JIT compiler released by Ant Group, aims to boost Java performance by integrating LLVM’s optimization capabilities into the JVM, explaining JIT and LLVM fundamentals, its architecture, and an ambitious roadmap toward full bytecode support and advanced optimizations.
Microsoft’s TypeScript team migrated the compiler from JavaScript to Go, achieving up to ten‑fold performance gains, halving memory usage, and enabling shared‑memory concurrency, while preserving compatibility and exploring future AI‑driven code analysis and language‑service APIs.
An experienced programmer shares a weekend project that builds a simplified BASIC variant, toybasic, and a three‑stage compiler written in Go—using Nex for lexical analysis, goyacc for parsing, and custom code generation—to translate BASIC programs into Go code, complete with examples and source links.
React MCP Server, an experimental addition to the React repository, bridges large language models with the React compilation toolchain via the MCP protocol, offering AI‑driven compile optimization and documentation lookup, enabling automated performance tuning of components through a closed‑loop of compilation, measurement, and improvement.
This article explains why code can run slowly on resource‑constrained devices and presents eight practical techniques—ranging from loop unrolling and memory access reduction to SIMD intrinsics and table look‑ups—to help C programmers write faster, more efficient code.
Microsoft unveiled a native preview of TypeScript rewritten in Go, delivering up to ten‑fold speed improvements in compilation, detailing the motivations for the rewrite, performance benchmarks, installation commands, VS Code extension support, current limitations, and future development plans.
This article provides an in‑depth overview of CPU performance metrics, practical optimization techniques—including algorithm selection, compiler flags, cache‑aware programming, and vectorization—along with real‑world case studies and a detailed survey of Linux profiling and analysis tools for developers.
Microsoft announced that it will rewrite the TypeScript compiler in Go, citing native code compilation, automatic memory management, simplicity, portability, and strong concurrency support, promising up to ten‑fold performance gains, faster editor feedback, new features, and a roadmap extending to a Go‑based TypeScript 7 release.
Microsoft rewrote the TypeScript compiler in Go, achieving a nine‑to‑tenfold speed boost, and explains that Go’s low‑level design, built‑in garbage collection, cross‑platform compilation, and functional‑style compatibility made it a better fit than C#, reflecting both technical advantages and Microsoft’s internal “Eat Dog Food” culture.
GCC 15 is slated for release in late April or early May, bringing a native COBOL frontend, default C23 support, early C++23/26 features, expanded RISC‑V capabilities, and a roadmap that still leaves Algol‑68 for future versions.
Microsoft announced a port of the TypeScript compiler to Go, promising over tenfold speed gains, and explained that portability and automatic garbage collection made Go a more practical choice than Rust despite community disappointment.
Microsoft announced a native Go implementation of the TypeScript compiler that dramatically cuts build times and memory usage, promising a ten‑fold speed boost for large projects and laying the groundwork for next‑generation AI‑assisted development tools.
Microsoft’s TypeScript team announced a Go‑based rewrite of the compiler that delivers up to a 13.5× speed increase in type checking, halves memory usage, and cuts project load times by eightfold, with a roadmap spanning TypeScript 5.x through the native Go 7.0 “Corsa” release.
Anders Hejlsberg announces a native implementation of the TypeScript compiler that dramatically reduces build and editor startup times, offers up to ten‑fold speed gains across large codebases, and outlines the roadmap toward TypeScript 7 with enhanced AI‑driven tooling.
This article dissects the C expression ++i + i++, shows how compiler‑generated assembly executes both increments exactly once, and demonstrates why the result is 3 while highlighting the pitfalls of undefined evaluation order in C.
This guide explains Swift 5.9 macros—both attached and freestanding—detailing how the compiler expands them using SwiftSyntax’s AST manipulation, walks through creating and declaring macros, and demonstrates a PeerMacro that automatically generates async counterparts for completion‑handler functions, reducing boilerplate and improving code clarity.
This course introduces the background and features of PHP, explains the inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students through implementing these components in C to create a simple interpreter while enhancing their programming and problem‑solving skills.
This article walks through the fundamentals of compiler front‑end development, covering lexical analysis, parsing, and semantic analysis, and provides hands‑on Antlr examples for Java code to illustrate each stage.
This article introduces the fundamentals of compiler front‑end development, covering lexical analysis with finite automata, syntax analysis using context‑free grammars and parsing strategies, and semantic analysis concepts, while providing practical Antlr examples for Java code tokenization, parsing, and semantic checks.
Google's research shows that adding boundary checks to its C++ codebase can automatically fix thousands of CVE‑related memory bugs, cut production crash rates by 30%, and improve performance with only a 0.3% overhead, sparking a broad community discussion on safe legacy code.
The author, a seasoned TypeScript developer, explains why they chose Rust over C/C++, outlines effective learning resources, and compares Rust’s compiler, type system, and memory management to JavaScript/TypeScript, highlighting the language’s performance, safety, and practical benefits for low‑level development.
This course introduces the background and characteristics of PHP, explains the role and operation of the PHP interpreter, and guides students through building a simple interpreter in C by covering lexical analysis, parsing, virtual machine design, and hands‑on debugging with GDB.
A compiler transforms source code into executable machine instructions by first tokenizing the text into keywords, identifiers and literals, then parsing these tokens into an abstract syntax tree, generating and optimizing intermediate code, and finally assembling and linking the output for the target architecture or LLVM IR.
This article introduces five widely used, free C/C++ compilers—GCC, Clang/LLVM, Tiny C Compiler, Microsoft Visual C++, and Digital Mars—detailing their main features, platform support, typical usage commands, and ideal application scenarios for developers seeking lightweight or powerful compilation tools.
This article dissects the massive 5‑万‑line checker.ts file in the TypeScript compiler, explaining why the team packed the entire type‑system logic into a single file, how low‑level decisions like named‑parameter comments, heavy use of const enum, ESM/CJS export patterns, var usage, and lack of try‑catch affect V8 performance, and what these choices reveal about TypeScript’s evolution.
PXP is a collection of tools and libraries that combine Rust and PHP to create a fast, reliable superset of PHP with modern language features, a language server, static analyzer, formatter and linter, aiming to improve the overall PHP developer experience.
The RECom compiler introduces a subgraph‑parallel fusion technique and symbolic shape handling to dramatically speed up GPU inference of deep recommendation models with massive embedding columns, achieving up to 6.61× lower latency and 1.91× higher throughput than TensorFlow baselines, while eliminating redundant computations.
This article walks through how a compiler turns human‑readable source code into binary machine instructions, covering tokenization, parsing, abstract syntax tree construction, code generation, optimization, and linking, while highlighting the role of LLVM as a portable backend.
This article explains how a programmer's source code is transformed into CPU‑executable machine instructions through lexical analysis, parsing into an abstract syntax tree, optimization, target‑specific code generation, and linking, highlighting the role of compilers and tools like LLVM.
Microsoft released TypeScript 5.6 Beta on July 26 2024, introducing stricter null‑and‑truthiness checks, iterator helper methods, built‑in iterator types, arbitrary module identifiers, new compiler flags like --noUncheckedSideEffectImports and --noCheck, region‑priority diagnostics, improved project ownership detection, and several notable behavior changes across the language and tooling.
From raw binary on punched tape to mnemonic assembly and then to high‑level constructs like if, while, and functions, programmers created recursive grammars that compile source code into abstract syntax trees, which a compiler translates back into machine instructions, illustrating how recursion underpins both programming language design and computation.
This article provides a comprehensive overview of LLVM, covering its history, three‑part architecture, detailed IR features, powerful optimizations, and diverse application scenarios such as static analysis, JIT compilation, and hardware simulation.
The article introduces the newly open‑sourced React Compiler, explains its underlying concepts and automatic memo optimization, provides step‑by‑step usage instructions with health‑check, ESLint and Babel plugins, and shares performance results from Meta’s production apps.
This guide walks you through creating a domain‑specific language using Langium, covering lexical analysis, parsing, linking, semantic validation, developer experience enhancements, and deployment options, all illustrated with concrete ZModel examples and code snippets.
This article provides a comprehensive walkthrough of Webpack’s internal architecture, detailing the core JavaScript bundling workflow, the roles of Compiler and Compilation objects, the lifecycle of plugins and loaders, the parsing of modules into an AST, chunk creation, and the final emission of assets to the output directory.
Modular Inc. announced the open‑source release of Mojo’s core standard library, highlighting its Python‑like syntax, MLIR‑based compiler, SIMD‑first design, eager destruction, and performance claims of being tens of thousands of times faster than Python, positioning it as a potential future‑dominant AI language.
This article explains the theoretical and practical limits of Java String length, covering compiler restrictions, UTF‑8 encoding effects, constant‑pool constraints, runtime constructor limits, memory consumption, and the JDK9 optimization that changes internal storage.
This article walks through the design and implementation of a compiler that automatically transforms Rax components into Taro components, covering the background, Babel‑based AST processing, import rewriting, component attribute mapping, project structure, automated end‑to‑end testing, and future enhancements.
This course introduces the background and features of PHP, explains the role and operation of the PHP interpreter, and guides learners through building core components such as lexical analysis, parsing, and a virtual machine in C, enabling hands‑on creation of a simple interpreter.
This course introduces the background and features of PHP, explains the role and inner workings of the PHP interpreter—including lexical analysis, parsing, and the virtual machine—and guides students to implement a simple interpreter using C, enhancing their programming and problem‑solving skills.
The article analyzes the shift from x86 to ARM in server hardware, compares CISC and RISC instruction sets, reviews domestic Chinese CPU projects, examines GPU/NPU/FPGA accelerators, and proposes concrete ARM instruction‑set, compiler, and operating‑system standards for the telecom industry.
The article explains how Go’s function values introduce an extra indirection and trigger escape analysis, making indirect calls slower than C pointers, and offers optimization tactics such as avoiding function‑pointer calls, using switch‑based dispatch, or applying the unsafe noescape trick when safe.
MoonBit is a new open‑source programming language from China that delivers tiny WebAssembly binaries, high runtime speed, advanced compile‑time performance, and a modern toolchain, while sparking community debate over adding Chinese keywords to its syntax.
This article explains the principles of Profile‑Guided Optimization, outlines the three‑step workflow, demonstrates practical PGO implementations for Go and C++ with code examples and devirtualization techniques, and presents benchmark results showing significant latency reduction and throughput improvement.
In a candid interview, Chris Lattner and Tim Davis explain how Modular aims to solve AI infrastructure fragmentation by building a unified, hardware‑agnostic engine, the challenges of compiler design, and the creation of Mojo—a Python superset designed for high‑performance, scalable AI development.