Today we released the first public version of DivookaBenchmark_Mandelbrot — a standardized benchmark suite built specifically to measure the real-world performance of Divooka against a wide range of languages and runtimes.
The benchmark computes the Mandelbrot set at 2000 × 2000 resolution with a maximum of 1000 iterations per pixel, then verifies correctness using a 32-bit checksum (target: 689833081). We run each implementation five times and record average time, min/max, peak memory, and distribution size.
Why This Benchmark Matters
One of our core beliefs is that a modern scripting language needs a "decent (high) performance". This benchmark was designed to prove that point in a reproducible way.
It exercises heavy integer and floating-point math, tight loops, branches, and memory writes — exactly the kind of workload where interpretation overhead shows up quickly. This particular benchmark doesn't test function calls directly.
The goal is not to produce the an optimized Mandelbrot renderer, but to compare a simple, fixed algorithm across different languages and runtimes, then use the result to understand where Divooka currently stands.
We included implementations (or equivalent ports) for:
- C++
- C# (.NET 10, including AoT/trimmed)
- JavaScript (multiple browsers + Node.js)
- Go, Java, Julia, Python 3.13, Ruby, Prolog, GNU Octave
- And of course, multiple execution modes of Divooka 0.75.2 (compiled, Aviator, Neo Editor, Stewer)
We even tested AI-generated versions from ChatGPT, Gemini, Grok, and Kimi to see how reliable and performant LLM-produced result is in practice.
Key Results (on Windows 11, i7-13700KF)
- Fastest overall: JavaScript in Edge/Chrome/Brave (~1,296 ms, very low memory)
- Fastest native: C++ (~1,308 ms)
- Strong managed contender: C# AoT (~1,355 ms)
- Divooka compiled: 3,639 ms — comfortably beating pure interpreters like Python (~47 s) and Ruby (~49 s) ⚡
- Divooka Aviator: 6,711 ms
- Divooka Neo Editor: significantly higher overhead (estimated multi-hour range for full runs)
The gap between Divooka's compiled mode and the top-tier JITs (especially V8) is still noticeable, but the improvement over classic interpreted scripting languages is clear. This reinforces why we’ve been investing heavily in our compilation pipeline and runtime optimizations.
AI-generated implementations varied wildly — some produced correct checksums but took 26 seconds to several minutes, while others failed entirely or fell back to calling Python under the hood. Deterministic engineering still wins.
What We Learned
- JIT is not optional for competitive scripting performance.
- Tooling and editor overhead can dominate if not carefully managed (something we're actively addressing).
- Even simple, well-defined tasks like Mandelbrot reveal meaningful differences in language/runtime design.
The full repository is now public:
https://github.com/MethodoxTech/DivookaBenchmark_Mandelbrot
It includes all source implementations, PowerShell automation scripts, result tables, and artifacts. Feel free to clone, run it yourself, or contribute additional language ports.
This benchmark will become part of our regular performance regression suite as Divooka evolves. Future runs should show steady gains as we refine the compiler and reduce runtime overhead.
Current Results
Results from best runs of respective platform:
| Rank | Language / Runtime | Size | Best Time |
|---|
| 1 | JavaScript Web, Edge / Chrome / Brave | 3 KB | 1295.80–1302.80 ms |
| 2 | C++ | 15 KB | 1308.00 ms |
| 3 | C# AoT | 911 KB | 1355.35 ms |
| 4 | C# .NET 10 | 16.5 MB | 1357.47 ms |
| 5 | JavaScript Node.js | 2 KB + 98.2 MB | 1406.20 ms |
| 6 | Go | 2 KB + 224 MB | 1425.01 ms |
| 7 | Julia | 2 KB + 1 GB | 1511.20 ms |
| 8 | JavaScript Web, Firefox | 3 KB | 1513.00 ms |
| 9 | Java OpenJDK 17.0.11 | 301 MB + small files | 1587.79 ms |
| 10 | Divooka 0.75.2, Compiled | 71.914 MB | 3639.24 ms |
| 11 | Divooka 0.75.2, Aviator Run | 8 KB + 2.16 GB + 776 MB | 6710.84 ms |
| 12 | Python 3.13.5 | 2 KB + 139 MB | 47127.70 ms |
| 13 | Ruby 3.2.2 | 1 KB + 907 MB | 49489.82 ms |
| 14 | Prolog SWI, optimized | 2 KB + 42.8 MB | 314687.84 ms |
| 15 | GNU Octave 7.3.0 | 2 KB + 2.07 GB | 2464913.29 ms |
| 16 | Divooka 0.75.2, Neo Editor estimate | 8 KB + 2.67 GB | ~95.8 hr |
Limitations
This benchmark only tests a narrow case.
It does not test UI programming, data manipulation, graph execution, external libraries, async workloads, recursion-heavy workloads, or large real-world applications.
It also does not fully normalize warm-up behavior. Browser JavaScript likely benefits from highly optimized JIT behavior, and other runtimes may have different startup / warm-up costs.
GNU Octave is probably optimized for matrix-oriented workloads, not naive scalar loops.
Python is rarely used this way in performance-sensitive numerical code; normally people use NumPy, Numba, Cython, PyPy, or native extensions.