← GUMP

Turbo

The K→Native compiler. 630–930× over Python.
$499/mo

Write in 6 operators. Compile to native binary. The compiler builds a dependency graph and schedules independent operations into execution waves automatically. No annotations. No runtime overhead. Output: optimized C (-O3) → native binary.

Same input → same binary → same result. No JIT variance. Amortized cost per operation: ~0.2 ns (vectorized execution across waves).

BENCHMARKS

502 operations (arithmetic + trig):
  Native: 90.9 ns/iter  |  Python: 68,580 ns  |  NumPy: 9,590 ns
  Speedup: 754× vs Python  |  106× vs NumPy

102 operations:
  Native: 21.6 ns/iter  |  Python: 13,730 ns  |  NumPy: 3,130 ns
  Speedup: 634× vs Python  |  145× vs NumPy

12 operations (minimal):
  Native: 2.3 ns/iter  |  Python: 2,100 ns  |  NumPy: 1,800 ns
  Speedup: 930× vs Python  |  797× vs NumPy

Per-operation cost: 0.2 ns  |  Compilation: ~40ms  |  Correctness: verified against Python output

THE K LANGUAGE

! K has 6 operators. That's it.
: x 5          ! create oscillator
: y 10         ! create oscillator
+ x y sum      ! resonate (add)
* x y prod     ! entangle (multiply)
* sum prod r   ! entangle
@ r            ! observe → 750

! The compiler finds: x and y are independent (Wave 0)
! sum and prod are independent (Wave 1)
! r depends on both (Wave 2)
! 6 operations → 3 waves → 2× parallelism

WHAT YOU GET

K language interpreter (free)
K→C source-to-source compiler
Automatic wave scheduling
cc -O3 native binary output
Python→K translator
Parallelism analysis + report
sin/cos/sqrt/pow built-in
Deterministic: same input, same binary, same result
Smart dispatch: GPU for matrices >= 512, CPU for small ops
Hardware-signed compilation outputs via Secure Enclave

WHAT THIS IS / WHAT THIS ISN'T

WHAT THIS IS

A compiler for the K language that produces native binaries from K source code. The K language has 6 operators and auto-parallelizes. The compiler finds execution waves (groups of independent operations), generates C code, and compiles with -O3. Benchmarked at 630–930× over Python, 106–797× over NumPy (see benchmarks above).

WHAT THIS ISN'T

A general-purpose Python accelerator. You write in K (or use the Python→K translator for simple code). K handles arithmetic, trig, and scalar computation. It doesn't do string processing, file I/O, network calls, or object-oriented programming. It's a computation language, not a general-purpose language.

YEAH BUT

"How is 930× possible?"
Python interprets every line, checks types, manages memory, calls through abstraction layers. Native C does none of that. The speedup is the cost of removing the interpreter. Benchmarks above are verified and reproducible. pip install begump and run them yourself.
"Why not just write C directly?"
You can. But K auto-parallelizes. The compiler finds execution waves that a human writing C would miss. And K is 6 operators — you can learn it in 10 minutes. C takes years.
"MATLAB and Mathematica already do scientific computing."
MATLAB costs $2,150/yr and runs interpreted. Mathematica costs $3,225/yr and runs interpreted. Neither compiles to native binary. Neither auto-parallelizes. Turbo does.

SELF-VERIFYING

The K compiler can compile itself. We wrote the compiler's wave scheduling algorithm in K, then compiled it. Then compiled that. Four levels deep — the compiler compiling a compiler compiling a compiler compiling a compiler. Wave depth stays at 4 no matter how deep you go (tested on 10 random programs, 3 levels each). Parallelism grows ~3.5x per level (6.5x → 23x → 79x). Self-reference doesn't create bottlenecks — it creates surface area for parallel execution. All levels produce correct output.

VS THE COMPETITION

MATLAB
$2,150/yr — interpreted, JIT for some operations. No native binary output.
Turbo: $499/mo. Compiles to native -O3 binary. 630–930× over Python.
Mathematica
$3,225/yr — symbolic + numeric. Powerful but interpreted. No native compilation.
Turbo: numeric computation compiled to hardware speed. Different tool, complementary.
Cython / Numba
Free — Python-to-C compilation. Requires type annotations. Per-function, not whole-program.
Turbo: whole-program wave scheduling. Auto-parallelization. K is simpler than annotated Python.

TESTING

Unit tests, adversarial input testing (None, wrong types, NaN, empty data, unicode), real user workflow testing, and cross-product integration testing. Every public function handles every input permutation without crashing. 673 quality tests across all products, zero failures. Self-verifying: the product can audit its own output.

By purchasing you agree to our Terms of Service

Get Turbo — $499/mo

After purchase: setup guide

GUMP — ask Harmonia · [email protected] · terms