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.
From the painful days of hand‑written assembly to the birth of Fortran, the rise of GCC, and the modular revolution of LLVM, this article traces six decades of compiler history, highlighting key breakthroughs, influential figures, and the lasting impact on modern software development.
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.
LLVM 21.1.0, released on August 26, introduces the AMD GFX1250 target, enhancements to the AMDGPU backend, support for NVIDIA GB10 CPUs, RISC‑V improvements, and LLDB debugger upgrades, and is freely available for download from the official GitHub releases page.
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.
ByteDance's STE team dissected the severe compile‑time delays and oversized binary artifacts in their data‑center C++ applications, presenting root‑cause analyses, LLVM bug fixes, and a suite of optimization techniques that together cut build times by up to 50% and reduced binary size by over 80%.
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 article details how a long‑standing bug that displayed incorrect call‑address information in bpftool’s JIT disassembly was reproduced, analyzed, and fixed by correcting the PC parameter to use the function’s kernel symbol address, with patches applied to both LLVM and libbfd back‑ends.
This article explains the importance of instruction scheduling for modern CPU pipelines, describes dependency types, distinguishes dynamic and static scheduling, outlines LLVM's multiple scheduling phases and algorithms, and introduces the underlying topological‑sort technique used to improve compiler performance.
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 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.
The article explains how Python 3.13 introduces a copy‑and‑patch Just‑In‑Time (JIT) compiler that compiles bytecode to machine code on first execution, reuses it to boost performance, and leverages LLVM tools for efficient runtime code generation.
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 explains how database expression evaluation—especially in WHERE and SELECT clauses—can be dramatically accelerated by replacing interpreted AST traversal with Just‑In‑Time compilation using Apache Gandiva, which leverages LLVM to generate SIMD‑optimized machine code for Arrow columnar data, and discusses extensions such as timestamp, array, higher‑order functions, and UDF support.
This article explains how Just‑In‑Time (JIT) compilation, particularly via the Gandiva expression compiler built on LLVM and Apache Arrow, can dramatically accelerate database expression evaluation by transforming abstract syntax trees into native vectorized code, addressing traditional interpretation bottlenecks and improving CPU‑bound query performance.
The upcoming CPython 3.13 release will optionally include a JIT compiler built on LLVM, offering modest speed gains of 2%‑9% today and promising larger improvements in future versions through advanced optimization techniques.
Baidu reduced the iOS app package by over 350 MB by discarding dead code, replacing unreliable Mach‑O analysis with a source‑level AST approach built on LLVM libtooling and the Swift compiler, and implementing a multi‑layer static‑analysis pipeline that extracts, transforms, stores, and filters method usage data.
This article explains what LLVM is, how it differs from GCC, its design for portability, its role in language development, JIT compilation, automatic optimizations, domain‑specific language support, and what it does not handle, providing a comprehensive overview for developers.
Android’s Shadow Call Stack (SCS), silently enabled since Android R on AArch64 devices, stores return addresses in a protected register‑based stack separate from the regular stack, complementing stack canaries and requiring hardware support, while developers can activate it via -fsanitize=shadow-call-stack and avoid using X18 elsewhere.
This article explains Android's Shadow Call Stack (SCS) security mechanism, its hardware dependencies, enabling methods, and how it protects return addresses on AArch64 kernels, illustrated with code examples and real‑world deployment results.
This article explains the Strict Aliasing Rule, how compilers use Type‑Based Alias Analysis (TBAA) for optimization, demonstrates LLVM’s metadata‑based implementation, introduces the TypeSanitizer tool for detecting aliasing violations, and offers practical guidance to avoid common pitfalls in C/C++ code.
Swift inserts the high‑level SIL intermediate representation between source code and LLVM, exposing type declarations, method blocks, and virtual tables, while supporting three dispatch strategies—direct for value types and final methods, VTable for regular class methods, and Objective‑C message dispatch for @objc dynamic methods—crucial for debugging mixed Swift/Objective‑C and protocol‑extension behavior.
This article introduces WebAssembly’s efficient, safe, open standards and LLVM‑based compilation pipeline, then guides Rust developers through installing tools, writing and binding simple functions, optimizing performance and bundle size, and explores tooling, runtimes, real‑world use cases, current limitations, and future extensions such as WASI, SIMD, and threads.
The upcoming Linux 6.0 kernel hints at future Rust driver support, but significant hurdles remain such as compiler compatibility, LLVM vs GCC toolchains, and limited architecture support, making widespread Rust integration unlikely until later releases.
The article presents a technique for static function hooking in Objective‑C by writing a custom LLVM Pass that modifies the intermediate representation during compilation to inject stub calls at chosen points inside a function, and details the required LLVM setup, Pass implementation, Clang integration, and Xcode configuration.
The article examines how monolithic AI toolchains hinder innovation, recounts the historical fragmentation of software in the 1990s, highlights LLVM's modular architecture as a turning point, and argues for a new, composable AI infrastructure to make machine learning more accessible and scalable.
This article explores how to reduce Go's heavy runtime by replacing its entry point, demonstrates building a minimal Go runtime, implements a simple Python JIT compiler in Go, and shows how to create a self‑hosted Go compiler using LLVM IR, complete with code examples and optimizations.
The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.
The tutorial walks through building a complete LLVM‑based Kaleidoscope compiler—from a tokenizing lexer and recursive‑descent parser, through AST construction, LLVM IR generation with SSA and phi nodes, optimization passes, JIT execution, and mutable variable handling via stack allocation—providing full C++ source examples.
The article describes how enabling the aggressive size‑optimisation flag -Oz in Clang caused a video component to create numerous GLFramebuffer and CVPixelBuffer objects, leading to OOM crashes, and explains the underlying ARC and Machine Outliner interactions that exposed a compiler bug which was later fixed in LLVM.
Although Python is slower than C, Java, or JavaScript for CPU‑intensive tasks, several projects—including PyPy, Pyston, Nuitka, Cython, and Numba—offer distinct approaches such as JIT compilation, LLVM back‑ends, or C conversion to significantly improve Python’s runtime performance.
This article explains how to use LLVM and SanitizerCoverage to insert BasicBlock‑level instrumentation into iOS binaries such as the WeChat SDK, covering the theory of code‑coverage metrics, compilation steps, bitcode extraction, and a practical demo that visualizes runtime execution paths.
This article explains how large-scale recommendation systems rely on efficient feature engineering, describes the three-layer architecture (offline, stream, online), and details how Spark SQL and the LLVM‑optimized FESQL engine improve performance and ensure offline‑online feature consistency.
The article explains how to instrument code for coverage using LLVM’s modular compiler infrastructure—adding compile‑time probes that generate .gcno files, runtime counters that produce .gcda files, and then parsing these with GCOV, while detailing LLVM IR, basic blocks, flow graphs, and extensions for custom plugins.
This article explains how Swift leverages LLVM's three‑stage compiler architecture and the Swift Intermediate Language (SIL) to implement protocol extensions, detailing the generation and analysis of SIL code, VTables, Witness Tables, and function calls to reveal the language's underlying compilation process.
This article details a comprehensive set of practical techniques—ranging from Xcode project configuration tweaks and CocoaPods packaging to CCache, distcc, hardware tricks, PCH usage, and deep Clang/LLVM analysis—that together reduced a massive iOS build from over 27 minutes to under 10 minutes.
This article explains why modern iOS apps need modular dependency analysis, compares common approaches such as CocoaPods, header scanning, and symbol tools, and then details a source‑level LLVM‑based solution that uses Clang plugins to generate precise method‑level dependency metadata for each bundle.
This article explores the challenges of iOS code coverage, explains the generation of .gcno and .gcda files using LLVM, and presents a transparent, Git‑aware incremental coverage solution that integrates into the development workflow with minimal overhead.
This article presents an in‑depth interview with Chris Lattner, covering his education, the creation of LLVM, the birth of Swift, his management philosophy, ABI stability, and the future of Swift across platforms, offering valuable insights into modern compiler and language design.
This article explains the reasons for using LLVM to obfuscate Android applications, describes various LLVM-based obfuscation techniques such as instruction substitution, control‑flow flattening, bogus control flow, and custom passes, and illustrates their effects with diagrams.
Chris Lattner, the original creator of LLVM and Clang, now leads Apple’s Developer Tools division and has driven the development of Swift since 2010, integrating his compiler expertise, fostering interactive tools like Xcode Playgrounds, and shaping modern programming education.
