JIT Compilation

What is JIT?

Just-In-Time (JIT) compilation converts your Nevaarize code directly to native machine code at runtime, achieving performance comparable to C and C++.

Unlike other languages that rely on LLVM or external compilers, Nevaarize's JIT is built entirely from scratch with zero dependencies.

How It Works

Nevaarize Source
      ↓
   Lexer → Tokens
      ↓
   Parser → AST
      ↓
   JIT Compiler → x86-64 Machine Code
      ↓
   CPU Execution

The JIT compiler directly emits x86-64 machine instructions, which are then executed natively by your CPU. No intermediate bytecode, no virtual machine overhead.

Using JIT Functions

Nevaarize provides built-in JIT-accelerated functions:

// Native JIT sum loop benchmark
iterations = 100000000

result = nativeSumLoop(iterations)
sum = result[0]
opsPerSec = result[1]

print("Sum:", sum)
print("Performance:", int(opsPerSec / 1000000), "M ops/sec")

Available JIT Functions

TRUE JIT: Compiling Your Code

The jitSumLoop function demonstrates TRUE JIT compilation — it compiles actual Nevaarize loop constructs to native code:

// This Nevaarize code:
// for (i in Range(1, n)) { sum = sum + i }
// Gets compiled to x86-64 machine code!

result = jitSumLoop(1, 100000000)
sum = result[0]
opsPerSec = result[1]

print("Sum:", sum)
print("Compiled performance:", int(opsPerSec / 1000000), "M ops/sec")
print("")
print("This is REAL JIT!")
print("Your for-loop was compiled to native x86-64 machine code.")

Performance Comparison

Under the Hood

Here's what the JIT generates for a simple sum loop:

; x86-64 assembly generated by Nevaarize JIT
; for (i in Range(1, n)) { sum += i }

    xor rax, rax        ; sum = 0
    mov rcx, n          ; i = n
loop_start:
    add rax, rcx        ; sum += i
    dec rcx             ; i--
    jnz loop_start      ; if i != 0, continue
    ret                 ; return sum in rax

This is direct machine code — no interpretation, no bytecode, just raw CPU instructions.

Running Benchmarks

# Run the JIT benchmark suite
./bin/nevaarize examples/benchmarks/nativeJIT.nva
./bin/nevaarize examples/benchmarks/trueJIT.nva

Expected output:

=== NATIVE JIT BENCHMARK ===
True x86-64 machine code execution

Testing Native Sum Loop with 500000000 iterations...

Sum: 125000000250000000
Operations per second: 505000000
Performance: 505 M ops/sec

=== Native Fibonacci Loop ===
Fib result: 4660046610375530309
Performance: 410 M ops/sec

=== Native Function Call Loop ===
Call result: 125000000750000000
Performance: 350 M ops/sec