Story
JIT Compiling Code in 5μs
1 report
1 website
1 discussion
Latest report
Overview
Pgrust’s JIT compiler reportedly compiles code in about 5 microseconds, allowing the PostgreSQL-compatible database project to JIT-compile every SQL query rather than only selected queries. The implementation directly generates ARM64 machine code instead of relying on LLVM or generated C/C++, options the developer says impose higher compilation overhead. A demonstration regular-expression engine supports literal strings, concatenation, and repetition, then uses copy-and-patch compilation to turn its parsed expression tree into executable code at runtime. Reusable ARM64 instruction templates, or stencils, perform character comparisons, branching, backtracking-stack operations, success checks, and failure handling. The runtime allocates executable memory with mmap, copies generated instructions into it, invalidates the instruction cache, and calls the memory as a Rust-compatible function on macOS ARM64. For the regex b(an)*, benchmark results put the JIT implementation near handwritten code and substantially ahead of an interpreter. Across inputs from 9 to 2,049 bytes, the JIT took 3.8 to 470 nanoseconds and delivered 11.7x to 19.7x speedups over the interpreter; handwritten code took 3.8 to 393 nanoseconds. The developer says AI assistance reduced the difficulty of producing and modifying assembly-level code, which historically limited adoption of custom JIT compilers.
Summary from malisper.me.
Reports
One report so far. Additional coverage will appear here when it is linked to this story.
malisper.me
JIT Compiling Code in 5μs
Read report →
Community reactions
Each reaction summarizes sampled comments from the linked discussion.
Hacker News · malisper.me
Historical count: 10 · 10 saved in sample · Historical sample
Analysis ready
Read this discussion’s reaction
Based on 10 sampled comments from this thread. Analyzed 2026-08-23.
Despite the article’s focus on ultra-fast JIT compilation, the only sustained AI-relevant exchange asked whether coding models can meaningfully help with compiler work. One commenter treated JIT implementation as exactly the kind of problem where producing code is not a clerical exercise but the central difficulty: it demands command of machine-level execution, optimization tradeoffs, and security constraints. That framing implicitly challenges the popular claim that programming is rarely the bottleneck. The reply was much harsher about current public models. It argued that AI can be useful for familiar, bounded work such as interface components, but falls apart when the obstacle is deep domain complexity rather than routine software construction. From that perspective, generating plausible-looking compiler code is not the same as understanding correctness, architecture-specific behavior, or the performance and security consequences of code generation. No participant offered a concrete success story in which an available model had built or substantially advanced a real JIT compiler. The discussion therefore landed on a narrow but pointed conclusion: advanced systems work remains a poor test case for today’s public coding assistants, even if AI may still accelerate less demanding implementation tasks.
The dispute is whether AI meaningfully lowers the barrier to difficult compiler engineering. One side sees JITs as proof that code itself can be the hard part and thus a valuable target for AI assistance; the opposing view is that public models handle routine coding but lack the domain understanding needed for genuinely complex compiler work.
- Praise: JIT compilers highlight a class of work where generating implementation details could matter enormously, rather than merely polishing already-understood product code.
- Concern: Current public coding models are seen as unreliable once compiler work hinges on deep domain knowledge, where plausible code can conceal severe correctness, performance, or security failures.
- Concern: AI appears most useful for bounded, familiar tasks, not the machine-level reasoning required to design and validate a production-quality JIT.