BestHub
Sign in
Tagged articles

LLVM

52 articles · Page 1 of 1
Full-Stack Cultivation Path
Full-Stack Cultivation Path
Jul 28, 2026 · Fundamentals

Can TypeScript Produce Standalone Native Binaries? A Deep Dive into scriptc and Perry

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.

CompilerLLVMPerry
0 likes · 9 min read
Can TypeScript Produce Standalone Native Binaries? A Deep Dive into scriptc and Perry
Node.js Tech Stack
Node.js Tech Stack
Jul 28, 2026 · Backend Development

Does Vercel’s scriptc Deliver Native TypeScript Binaries? The Perry Claim

The article examines Vercel Labs’ scriptc tool that compiles TypeScript into a ~178 KB native executable with ~2 ms startup, compares its compilation pipeline, runtime implementation, and feature set to the earlier Perry project, and evaluates the plagiarism accusations by analyzing code differences, release timelines, and architectural choices.

LLVMOpen SourcePerry
0 likes · 11 min read
Does Vercel’s scriptc Deliver Native TypeScript Binaries? The Perry Claim
dbaplus Community
dbaplus Community
Dec 27, 2025 · Fundamentals

How Compilers Evolved from Assembly to LLVM: A 60‑Year Journey

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.

FortranGCCLLVM
0 likes · 6 min read
How Compilers Evolved from Assembly to LLVM: A 60‑Year Journey
Code Ape Tech Column
Code Ape Tech Column
Nov 5, 2025 · Backend Development

How Jeandle Leverages LLVM to Supercharge JVM Performance

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.

CompilerJVMLLVM
0 likes · 6 min read
How Jeandle Leverages LLVM to Supercharge JVM Performance
Selected Java Interview Questions
Selected Java Interview Questions
Nov 4, 2025 · Backend Development

Jeandle: How Ant Group’s LLVM‑Based JVM JIT Aims to Supercharge Java Performance

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.

CompilerJVMLLVM
0 likes · 7 min read
Jeandle: How Ant Group’s LLVM‑Based JVM JIT Aims to Supercharge Java Performance
Java Captain
Java Captain
Oct 31, 2025 · Backend Development

How Jeandle Uses LLVM to Supercharge JVM Performance

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.

CompilerJVMLLVM
0 likes · 5 min read
How Jeandle Uses LLVM to Supercharge JVM Performance
Architect's Guide
Architect's Guide
Oct 30, 2025 · Backend Development

How Jeandle Uses LLVM to Supercharge JVM Performance

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.

CompilerJVMJeandle
0 likes · 6 min read
How Jeandle Uses LLVM to Supercharge JVM Performance
21CTO
21CTO
Aug 28, 2025 · Fundamentals

What’s New in LLVM 21.1.0? A Deep Dive into the Latest Compiler Features

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.

AMD GFX1250LLDBLLVM
0 likes · 2 min read
What’s New in LLVM 21.1.0? A Deep Dive into the Latest Compiler Features
macrozheng
macrozheng
Aug 22, 2025 · Fundamentals

How Jeandle’s LLVM‑Powered JIT Could Supercharge Java Performance

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.

CompilerJVMLLVM
0 likes · 6 min read
How Jeandle’s LLVM‑Powered JIT Could Supercharge Java Performance
Java Backend Technology
Java Backend Technology
Aug 22, 2025 · Backend Development

How Jeandle’s LLVM‑Powered JIT Could Revolutionize Java Performance

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.

CompilerJVMLLVM
0 likes · 6 min read
How Jeandle’s LLVM‑Powered JIT Could Revolutionize Java Performance
ByteDance SYS Tech
ByteDance SYS Tech
Dec 27, 2024 · Backend Development

How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat

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%.

C++CompilationLLVM
0 likes · 26 min read
How ByteDance Tackled C++ Compilation Bottlenecks and Massive Binary Bloat
21CTO
21CTO
Dec 12, 2024 · Information Security

How Google Added Low‑Cost Memory‑Safety Checks to C++ Production Code

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.

C++CompilerLLVM
0 likes · 9 min read
How Google Added Low‑Cost Memory‑Safety Checks to C++ Production Code
Linux Kernel Journey
Linux Kernel Journey
Nov 12, 2024 · Operations

eBPF Talk: Fixing a 7‑Year‑Old Bug in bpftool

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.

LLVMbpftooldisassembly
0 likes · 9 min read
eBPF Talk: Fixing a 7‑Year‑Old Bug in bpftool
DataFunSummit
DataFunSummit
Nov 7, 2024 · Backend Development

Understanding LLVM Instruction Scheduling Algorithms and Topological Sorting

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.

Instruction SchedulingLLVMStatic Scheduling
0 likes · 10 min read
Understanding LLVM Instruction Scheduling Algorithms and Topological Sorting
Java Tech Enthusiast
Java Tech Enthusiast
Sep 15, 2024 · Fundamentals

How Source Code Is Transformed into Machine Instructions

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.

ASTCompilerLLVM
0 likes · 4 min read
How Source Code Is Transformed into Machine Instructions
Sohu Tech Products
Sohu Tech Products
Jan 24, 2024 · Databases

Optimizing Database Expression Evaluation with JIT Technology Using Gandiva

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.

Apache ArrowApache GandivaExpression Evaluation
0 likes · 17 min read
Optimizing Database Expression Evaluation with JIT Technology Using Gandiva
DataFunTalk
DataFunTalk
Jan 15, 2024 · Databases

Optimizing Database Expression Evaluation with JIT Compilation Using Gandiva

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.

Apache ArrowDatabaseExpression Evaluation
0 likes · 17 min read
Optimizing Database Expression Evaluation with JIT Compilation Using Gandiva
21CTO
21CTO
Jan 12, 2024 · Fundamentals

How CPython’s New JIT Will Boost Python 3.13 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.

CPythonLLVMPython
0 likes · 6 min read
How CPython’s New JIT Will Boost Python 3.13 Performance
Baidu Geek Talk
Baidu Geek Talk
Sep 20, 2023 · Backend Development

How Baidu Cut iOS App Size by Removing Unused Methods with LLVM Libtooling

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.

ASTBuild ToolsLLVM
0 likes · 17 min read
How Baidu Cut iOS App Size by Removing Unused Methods with LLVM Libtooling
21CTO
21CTO
Aug 23, 2023 · Backend Development

Why LLVM Is the Secret Engine Powering Modern Languages

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.

CompilerIRLLVM
0 likes · 13 min read
Why LLVM Is the Secret Engine Powering Modern Languages
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 18, 2023 · Information Security

Shadow Call Stack (SCS) in Android: Mechanism, Requirements, and Implementation

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.

Android SecurityAssemblyLLVM
0 likes · 7 min read
Shadow Call Stack (SCS) in Android: Mechanism, Requirements, and Implementation
OPPO Amber Lab
OPPO Amber Lab
Aug 11, 2023 · Information Security

How Android’s Shadow Call Stack Strengthens Kernel Security

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.

Android SecurityKernel HardeningLLVM
0 likes · 6 min read
How Android’s Shadow Call Stack Strengthens Kernel Security
ByteDance SYS Tech
ByteDance SYS Tech
Jun 9, 2023 · Backend Development

Why Strict Aliasing Matters: Deep Dive into LLVM TBAA and TypeSanitizer

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.

LLVMcompiler optimizationsanitizer
0 likes · 33 min read
Why Strict Aliasing Matters: Deep Dive into LLVM TBAA and TypeSanitizer
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Jun 5, 2023 · Fundamentals

Understanding Swift SIL and Method Dispatch Mechanisms

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.

CompilerLLVMMethod Dispatch
0 likes · 20 min read
Understanding Swift SIL and Method Dispatch Mechanisms
DaTaobao Tech
DaTaobao Tech
Feb 6, 2023 · Frontend Development

WebAssembly Overview and Rust Development Guide

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.

LLVMRustWasm
0 likes · 30 min read
WebAssembly Overview and Rust Development Guide
21CTO
21CTO
Sep 17, 2022 · Fundamentals

Can Rust Really Power Linux Kernel Drivers? Exploring the Challenges

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.

GCCLLVMLinux
0 likes · 4 min read
Can Rust Really Power Linux Kernel Drivers? Exploring the Challenges
Tencent Cloud Developer
Tencent Cloud Developer
Sep 5, 2022 · Fundamentals

Static Function Hooking in Objective-C Using LLVM Pass

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.

IR ModificationLLVMObjective‑C
0 likes · 11 min read
Static Function Hooking in Objective-C Using LLVM Pass
ITPUB
ITPUB
Jun 2, 2022 · Artificial Intelligence

Why AI Needs Modular Infrastructure: Lessons from LLVM and the Future of ML Systems

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.

AI infrastructureLLVMML compilers
0 likes · 11 min read
Why AI Needs Modular Infrastructure: Lessons from LLVM and the Future of ML Systems
Tencent Cloud Developer
Tencent Cloud Developer
May 24, 2022 · Backend Development

Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap

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.

AssemblyBootstrapCompiler
0 likes · 21 min read
Three Advanced Go Techniques: Minimal Runtime, JIT Compilation, and Bootstrap
Tencent Cloud Developer
Tencent Cloud Developer
Sep 29, 2021 · Fundamentals

Building a Simple LLVM-Based Compiler: Lexer, Parser, SSA, Optimizer, JIT and Mutable Variables

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.

KaleidoscopeLLVMOptimizer
0 likes · 47 min read
Building a Simple LLVM-Based Compiler: Lexer, Parser, SSA, Optimizer, JIT and Mutable Variables
ByteDance Terminal Technology
ByteDance Terminal Technology
Jul 28, 2021 · Backend Development

Investigating a Clang -Oz Optimization Bug that Triggers Memory Bloat in a Video Component

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.

LLVMOptimizationclang
0 likes · 11 min read
Investigating a Clang -Oz Optimization Bug that Triggers Memory Bloat in a Video Component
MaGe Linux Operations
MaGe Linux Operations
Dec 15, 2020 · Fundamentals

Boost Python Speed: 5 Proven Techniques to Outrun C and Java

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.

CythonLLVMPython
0 likes · 5 min read
Boost Python Speed: 5 Proven Techniques to Outrun C and Java
Amap Tech
Amap Tech
Aug 28, 2020 · Fundamentals

Code Coverage Instrumentation Using LLVM and GCOV

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.

CompilerIRInstrumentation
0 likes · 17 min read
Code Coverage Instrumentation Using LLVM and GCOV
Sohu Tech Products
Sohu Tech Products
Jan 8, 2020 · Backend Development

Understanding Swift SIL: Exploring LLVM Backend and Protocol Extension Implementation

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.

CompilerLLVMProtocol Extension
0 likes · 12 min read
Understanding Swift SIL: Exploring LLVM Backend and Protocol Extension Implementation
21CTO
21CTO
Sep 7, 2017 · Fundamentals

Inside the Mind of Chris Lattner: From LLVM to Swift and Beyond

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.

Chris LattnerCompiler designLLVM
0 likes · 30 min read
Inside the Mind of Chris Lattner: From LLVM to Swift and Beyond
Qunar Tech Salon
Qunar Tech Salon
Aug 3, 2017 · Information Security

Why Use LLVM for Obfuscation and How to Apply It in Android Development

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.

AndroidLLVMNDK
0 likes · 2 min read
Why Use LLVM for Obfuscation and How to Apply It in Android Development
Baidu Tech Salon
Baidu Tech Salon
Jun 5, 2014 · Fundamentals

Chris Lattner: LLVM, Clang, and the Creation of Swift

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.

CompilerLLVMProgramming Languages
0 likes · 6 min read
Chris Lattner: LLVM, Clang, and the Creation of Swift