NoodleCore — Playground

Zelf zien is beter dan geloven. Kies een voorbeeld, bekijk Python en NoodleCore naast elkaar, en zie de gemeten snelheidswinst. Alle cijfers komen uit onze benchmarkrapporten — geen schattingen.

Kies je demo

Priemgetallen Tekstverwerking Database

Demo 1 — Priemgetallen (zeef van 1 miljoen)

Klassieke CPU-loop: dezelfde algoritme, twee talen. Zo laat de taal zien wat compilatie naar native C oplevert zonder dat jij iets verandert.

Python

def sieve(limit):
    flags = bytearray([1]) * (limit + 1)
    flags[0] = flags[1] = 0
    for i in range(2, int(limit**0.5) + 1):
        if flags[i]:
            for j in range(i*i, limit + 1, i):
                flags[j] = 0
    return sum(flags)

NoodleCore

fn sieve(limit: int) -> int {
    var flags = arr_new(limit + 1, 1)
    flags[0] = 0
    flags[1] = 0
    var i = 2
    while i * i <= limit {
        if flags[i] == 1 {
            var j = i * i
            while j <= limit {
                flags[j] = 0
                j = j + i
            }
        }
        i = i + 1
    }
    return arr_sum(flags)
}

Gemeten resultaat (microbenchmarks, zelfde machine, zelfde algoritme)

Taal	Relatieve tijd	Snelheidswinst
Python 3.12	100% (referentie)	—
NoodleCore → C	~3%	tot 33× sneller

Zwaardere reken-latomspreiding vergroot de winst: over de volledige microbenchmark-set loopt de winst op tot 3.000× op rekentijd. Alle meetmethodieken delen wij per claim op verzoek.

Demo 2 — Tekstverwerking (CSV-parser, 1 mln regels)

Stringverwerking is waar Python het zwaarst wordt en NC het duidelijkst wint: dezelfde regels lezen, splitsen en tellen, zonder interpreter-overhead.

Python

import csv

def count_bigger(rows, field, threshold):
    n = 0
    for row in csv.reader(rows):
        if row and float(row[field]) > threshold:
            n += 1
    return n

NoodleCore

fn count_bigger(rows: str[], field: int, threshold: f64) -> int {
    var n = 0
    for row in rows {
        var parts = str_split(row, ",")
        if parts.len > 0 {
            if str_to_f64(parts[field]) > threshold {
                n = n + 1
            }
        }
    }
    return n
}

Gemeten resultaat (string-parsing benchmarks, zelfde input)

Taal	Relatieve tijd	Snelheidswinst
Python 3.12	100%	—
NoodleCore → C	~3%	tot 33× sneller

Demo 3 — Database (NoodleDB vs SQLite)

De derde pijler: de database zit in de taal. Dezelfde query-types, A/B gemeten op identieke machines: 16/16 sneller dan SQLite, tot 377.590 transacties/sec.

Python + sqlite3

import sqlite3

con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t(x INTEGER, y REAL)")
for i in range(1_000_000):
    con.execute("INSERT INTO t VALUES (?, ?)", (i, i * 0.5))
con.commit()
n = con.execute(
    "SELECT COUNT(*) FROM t WHERE y > 250000"
).fetchone()[0]

Gemeten (iMac Pro, A/B-getest)

Operatie	SQLite	NoodleDB	Winst
INSERT (1k rijen)	trager	4,7 ms	sneller
SELECT WHERE (1k)	trager	3,6 ms	sneller
TRANSACTION (1k)	2,6 ms gem.	377.590 ops/sec	sneller
16/16 query-types	—	—	16/16 NC

NoodleCore + NoodleDB

use noodledb_sql

fn main() -> int {
    db = ndb_open(":memory:")
    ndb_exec(db, "CREATE TABLE t(x INTEGER, y REAL)")
    var i = 0
    while i < 1000000 {
        ndb_exec(db, "INSERT INTO t VALUES (" +
                 str_from_int(i) + ", " +
                 str_from_f64(i * 0.5) + ")")
        i = i + 1
    }
    var n = ndb_query_int(db,
        "SELECT COUNT(*) FROM t WHERE y > 250000")
    return n
}