1
-- Naive Fibonacci in different languages
2
function fib(n)
3
    if n < 2 then return n end
4
    return fib(n-1) + fib(n-2)
5
end
6
 
7
-- Benchmark results for fib(40):
8
-- CPython 3.9:      ~32 seconds
9
-- Ruby 3.0:         ~19 seconds
10
-- PHP 8.0:          ~11 seconds
11
-- JavaScript V8:    ~1.2 seconds
12
-- Lua 5.4:          ~15 seconds
13
-- LuaJIT 2.1:       ~0.8 seconds
14
-- C (gcc -O2):      ~0.5 seconds

1
-- Numeric computation benchmark
2
local function mandelbrot(N)
3
    local width, height, limit2 = N, N, 4.0
4
    local iter = 50
5
    local bits, bit = 0, 128
6
    
7
    for y = 0, height - 1 do
8
        for x = 0, width - 1 do
9
            local Zr, Zi, Cr, Ci = 0.0, 0.0, 0.0, 0.0
10
            Cr = 2.0 * x / width - 1.5
11
            Ci = 2.0 * y / height - 1.0
12
            
13
            local i = iter
14
            repeat
15
                local Tr = Zr * Zr - Zi * Zi + Cr
16
                local Ti = 2.0 * Zr * Zi + Ci
17
                Zr, Zi = Tr, Ti
18
                i = i - 1
19
            until (Zr * Zr + Zi * Zi > limit2) or (i == 0)
20
            
21
            if i == 0 then bits = bits + bit end
22
            if bit == 1 then
23
                io.write(string.char(bits))
24
                bits, bit = 0, 128
25
            else
26
                bit = bit / 2
27
            end
28
        end
29
    end
30
end
31
 
32
-- Performance (smaller is better):
33
-- C (gcc -O3):        0.146s
34
-- LuaJIT:             0.172s (only 18% slower!)
35
-- Java:               0.291s
36
-- JavaScript V8:      0.385s
37
-- Lua 5.4:            8.937s (52x slower than LuaJIT!)

1
-- Consider this code:
2
function process_data(items)
3
    local sum = 0
4
    for i = 1, #items do
5
        if items[i] > 0 then  -- Branch
6
            if items[i] < 100 then  -- Another branch
7
                sum = sum + items[i]
8
            else
9
                sum = sum + 100
10
            end
11
        end
12
    end
13
    return sum
14
end
15
 
16
-- Method JIT must compile all possible paths
17
-- Trace JIT only compiles the path actually taken!

1
-- This is ALL you need to call C functions:
2
local ffi = require("ffi")
3
ffi.cdef[[
4
    typedef struct { double x, y; } point_t;
5
    double sqrt(double x);
6
    double atan2(double y, double x);
7
]]
8
 
9
-- Now just use it!
10
local function distance(p1, p2)
11
    local dx = p2.x - p1.x
12
    local dy = p2.y - p1.y
13
    return math.sqrt(dx*dx + dy*dy)  -- Calls C's sqrt directly!
14
end
15
 
16
-- Creating C structs is trivial
17
local p1 = ffi.new("point_t", {x = 10, y = 20})
18
local p2 = ffi.new("point_t", {x = 30, y = 40})
19
print(distance(p1, p2))  -- 28.284271247462

1
-- This Lua code:
2
local function add_arrays(a, b, c, n)
3
    for i = 0, n-1 do
4
        c[i] = a[i] + b[i]
5
    end
6
end
7
 
8
-- Compiles to THIS machine code:
9
-- movsd xmm0, [rsi+rax*8]   ; Load a[i]
10
-- addsd xmm0, [rdx+rax*8]   ; Add b[i]
11
-- movsd [rcx+rax*8], xmm0   ; Store to c[i]
12
-- inc rax                   ; i++
13
-- cmp rax, rdi              ; i < n?
14
-- jl loop                   ; Loop if true
15
 
16
-- That's literally what a C compiler would generate!

1
-- This handles 1M+ requests/second:
2
local redis = require "resty.redis"
3
local cjson = require "cjson"
4
 
5
local red = redis:new()
6
red:connect("127.0.0.1", 6379)
7
 
8
local user_id = ngx.var.arg_id
9
local user_data = red:get("user:" .. user_id)
10
 
11
if user_data then
12
    ngx.header.content_type = "application/json"
13
    ngx.say(user_data)
14
else
15
    ngx.status = 404
16
    ngx.say(cjson.encode({error = "User not found"}))
17
end

1
-- LÖVE2D game engine with LuaJIT
2
function love.update(dt)
3
    -- This particle system can handle 100K+ particles at 60 FPS
4
    for i = 1, #particles do
5
        local p = particles[i]
6
        p.vy = p.vy + gravity * dt
7
        p.x = p.x + p.vx * dt
8
        p.y = p.y + p.vy * dt
9
        p.life = p.life - dt
10
        
11
        if p.life <= 0 then
12
            table.remove(particles, i)
13
        end
14
    end
15
end

1
-- SciLua: Scientific computing in LuaJIT
2
local ffi = require("ffi")
3
local C = ffi.C
4
 
5
ffi.cdef[[
6
    void dgemm_(char* transa, char* transb, int* m, int* n, int* k,
7
                double* alpha, double* a, int* lda, double* b, int* ldb,
8
                double* beta, double* c, int* ldc);
9
]]
10
 
11
-- Direct BLAS calls with zero overhead!
12
local function matrix_multiply(A, B, C, m, n, k)
13
    local alpha, beta = 1.0, 0.0
14
    local transa, transb = 'N', 'N'
15
    C.dgemm_(transa, transb, m, n, k, 
16
             ffi.new("double[1]", alpha), A, m, B, k,
17
             ffi.new("double[1]", beta), C, m)
18
end

1
// Simplified trace recording logic
2
void record_trace() {
3
    while (recording) {
4
        BCIns ins = *pc++;  // Get next bytecode
5
        
6
        switch (bc_op(ins)) {
7
        case BC_ADD:
8
            emit_ir(IR_ADD, bc_a(ins), bc_b(ins), bc_c(ins));
9
            break;
10
        case BC_LOOP:
11
            if (++loop_count > HOTLOOP_THRESHOLD) {
12
                end_trace();
13
                compile_trace();
14
            }
15
            break;
16
        // ... guards for type checks, bounds checks, etc
17
        }
18
    }
19
}

1
-- Normal Lua creates a temporary table here
2
function vector_add(x1, y1, x2, y2)
3
    local v1 = {x = x1, y = y1}  -- Allocation?
4
    local v2 = {x = x2, y = y2}  -- Another allocation?
5
    return v1.x + v2.x, v1.y + v2.y
6
end
7
 
8
-- LuaJIT's trace compiler sees through this!
9
-- After optimization, it compiles to:
10
-- return x1 + x2, y1 + y2
11
-- The tables NEVER GET ALLOCATED

1
function compute_distance(points, i, j)
2
    local dx = points[i].x - points[j].x
3
    local dy = points[i].y - points[j].y
4
    
5
    -- These array lookups are identical to above
6
    local norm_x = (points[i].x - points[j].x) / distance
7
    local norm_y = (points[i].y - points[j].y) / distance
8
    
9
    return norm_x, norm_y
10
end
11
 
12
-- LuaJIT recognizes the repeated subexpressions:
13
-- points[i].x - points[j].x  (computed once)
14
-- points[i].y - points[j].y  (computed once)

1
function process_data(data, multiplier, offset)
2
    local result = 0
3
    local factor = multiplier * 2.5 + offset  -- Loop invariant
4
    
5
    for i = 1, #data do
6
        local adjusted = data[i] * (multiplier * 2.5 + offset)  -- Same calculation!
7
        result = result + adjusted
8
    end
9
    return result
10
end
11
 
12
-- LuaJIT hoists the invariant calculation:
13
-- multiplier * 2.5 + offset computed ONCE before loop

1
function update_positions(objects, dt)
2
    for i = 1, #objects do
3
        objects[i].x = objects[i].x + objects[i].vx * dt
4
        objects[i].y = objects[i].y + objects[i].vy * dt
5
        -- Can we be sure objects[i] didn't change between accesses?
6
    end
7
end

1
function sum_positive(arr)
2
    local sum = 0
3
    for i = 1, #arr do
4
        if type(arr[i]) == "number" then  -- Type guard
5
            if arr[i] > 0 then              -- Value guard
6
                sum = sum + arr[i]
7
            end
8
        end
9
    end
10
    return sum
11
end

1
// LuaJIT's value representation (simplified)
2
typedef union {
3
    double n;        // Numbers stored directly
4
    uint64_t u64;    // For type tagging
5
} TValue;
6
 
7
// Special NaN patterns encode types:
8
// 0xfff8000000000000 | type | payload
9
// This allows:
10
// - Numbers: stored as-is (fast path)
11
// - Pointers: encoded in NaN space
12
// - Booleans, nil: special NaN values

1
-- Generic addition must handle all types:
2
function add(a, b)
3
    return a + b  -- Could be numbers, strings, tables with __add
4
end
5
 
6
-- But in a trace where a and b are always numbers:
7
-- LuaJIT generates:
8
//   movsd xmm0, [rax]      -- Load double directly
9
//   addsd xmm0, [rbx]      -- Floating-point add
10
//   movsd [rcx], xmm0      -- Store double
11
// No type checking needed!

1
-- Naive matrix multiplication
2
function matmul(A, B, C, n)
3
    for i = 1, n do
4
        for j = 1, n do
5
            local sum = 0
6
            for k = 1, n do
7
                sum = sum + A[i][k] * B[k][j]
8
            end
9
            C[i][j] = sum
10
        end
11
    end
12
end
13
 
14
-- After LuaJIT optimization:
15
-- 1. Type guards eliminated (arrays proven homogeneous)
16
-- 2. Bounds checks eliminated (loop bounds proven safe)
17
-- 3. A[i] hoisted out of k-loop (LICM)
18
-- 4. No temporary tables allocated
19
-- 5. Innermost loop unrolled and vectorized
20
 
21
-- Result: 20x faster than interpreted Lua
22
-- Only 2x slower than optimized C (gcc -O3)

1
; Inner loop after all optimizations:
2
.loop:
3
    movsd  xmm0, [rsi+rax*8]     ; A[i][k]
4
    movsd  xmm1, [rdx+rcx*8]     ; B[k][j]
5
    mulsd  xmm0, xmm1             ; multiply
6
    addsd  xmm2, xmm0             ; accumulate
7
    add    rax, 1                 ; k++
8
    cmp    rax, r8                ; k < n?
9
    jl     .loop

1
/* This is typical LuaJIT code - brilliant but impenetrable */
2
static void asm_fuseahuref(ASMState *as, IRRef ref, int32_t *ofsp, RegSet allow)
3
{
4
  IRIns *ir = IR(ref);
5
  if (ra_noreg(ir->r)) {
6
    if (ir->o == IR_AREF) {
7
      if (mayfuse(as, ref)) {
8
        if (irref_isk(ir->op2)) {
9
          IRRef tab = IR(ir->op1)->op1;
10
          int32_t ofs = 8*IR(ir->op2)->i;
11
          if (checki16(ofs)) {
12
            *ofsp = ofs;
13
            return (int32_t)ra_alloc1(as, tab, allow);
14
          }
15
        }
16
      }
17
    } else if (ir->o == IR_HREFK) {
18
      if (mayfuse(as, ref)) {
19
        int32_t ofs = (int32_t)(IR(ir->op2)->op2 * sizeof(Node));
20
        if (checki16(ofs)) {
21
          *ofsp = ofs;
22
          return (int32_t)ra_alloc1(as, ir->op1, allow);
23
        }
24
      }
25
    }
26
  }
27
  *ofsp = 0;
28
  return ra_alloc1(as, ref, allow);
29
}

1
-- This ray tracer runs at 60 FPS in LuaJIT
2
-- Try this in Python and watch your CPU melt
3
 
4
local ffi = require("ffi")
5
local C = ffi.C
6
 
7
ffi.cdef[[
8
    typedef struct { double x, y, z; } vec3;
9
    double sqrt(double);
10
    double pow(double, double);
11
]]
12
 
13
local vec3 = ffi.typeof("vec3")
14
 
15
local function dot(a, b)
16
    return a.x*b.x + a.y*b.y + a.z*b.z
17
end
18
 
19
local function normalize(v)
20
    local len = C.sqrt(dot(v, v))
21
    return vec3(v.x/len, v.y/len, v.z/len)
22
end
23
 
24
local function trace(orig, dir, spheres, depth)
25
    -- Ray tracing with full reflections
26
    -- This inner loop runs millions of times per second
27
    local nearest_t = 1e20
28
    local nearest_sphere = nil
29
    
30
    for i = 1, #spheres do
31
        local sphere = spheres[i]
32
        local oc = vec3(orig.x - sphere.x, orig.y - sphere.y, orig.z - sphere.z)
33
        local b = dot(oc, dir)
34
        local c = dot(oc, oc) - sphere.radius * sphere.radius
35
        local disc = b*b - c
36
        
37
        if disc > 0 then
38
            local t = -b - C.sqrt(disc)
39
            if t > 0.001 and t < nearest_t then
40
                nearest_t = t
41
                nearest_sphere = sphere
42
            end
43
        end
44
    end
45
    
46
    -- ... reflection calculation ...
47
    return color
48
end
49
 
50
-- This outperforms C++ ray tracers that use virtual functions
51
-- Because LuaJIT inlines EVERYTHING