neo vs Spark.

01 · The race

One kernel at a time

Each piece of work below has its own race, what it measures, what neo is held to, how Spark does it and every number taken for it. In a race both ships run for the same stretch: Spark completes the work once, and neo completes it as many times as the measured ratio says, turning around at each end.

1. 01.1 · load the CSV, parse and type130×
2. 01.2 · filter amount > 500, count2,049×
3. 01.3 · filter into a new table57.8×
4. 01.4 · sort, as a permutationnot measured
5. 01.5 · sort into a new table45.0×
6. 01.6 · sum by region1,948×

def load():
    global df
    if df is not None:
        df.unpersist(blocking=True)
    df = spark.read.csv(args.csv, header=True, inferSchema=True).cache()
    df.count()  # force the read into memory; inferSchema has already read the file once more for types
res["load_first_ms"], res["load_ms"] = load_twice(load)

timed("filter", lambda: df.filter(pred).count())

timed("filter_mat", lambda: sink(df.filter(pred)))

res["sort_perm_ms"] = None

timed("sort_mat", lambda: sink(df.orderBy("amount")))

timed("agg", lambda: df.groupBy("region").agg(F.sum("amount")).collect())

02 · Every number

03 · Both sides

Spark's side, in full

Apache Spark is a distributed engine built for clusters, run here on one machine on Java 17. Its JVM and session start-up are listed separately and not counted against the kernels. Its kernels are written the way its users write them. Each kernel's lines are beside its race above; this is the whole block they come from, with the checks it prints.

elif args.lib == "spark":
    t0 = now()
    from pyspark.sql import SparkSession, functions as F
    import pyspark
    res["version"] = pyspark.__version__
    mem = os.environ.get("NEON_SPARK_MEMORY", "48g")
    spark = (SparkSession.builder.master(f"local[{args.threads}]")
             .config("spark.driver.memory", mem)
             .config("spark.sql.shuffle.partitions", str(args.threads))
             .config("spark.default.parallelism", str(args.threads))
             .config("spark.ui.enabled", "false")
             .config("spark.sql.adaptive.enabled", "true")
             .getOrCreate())
    spark.sparkContext.setLogLevel("ERROR")
    res["startup_ms"] = (now() - t0) * 1000
    PIDS = descendants()  # the JVM is where Spark's work is done
    res["java"] = spark.sparkContext._jvm.java.lang.System.getProperty("java.version")

    df = None

    def load():
        global df
        if df is not None:
            df.unpersist(blocking=True)
        df = spark.read.csv(args.csv, header=True, inferSchema=True).cache()
        df.count()  # force the read into memory; inferSchema has already read the file once more for types
    res["load_first_ms"], res["load_ms"] = load_twice(load)
    res["rows"] = df.count()
    pred = F.col("amount") > 500
    sink = lambda d: d.write.format("noop").mode("overwrite").save()  # Spark's benchmarking sink: every row is produced, none is collected
    timed("filter", lambda: df.filter(pred).count())
    timed("filter_mat", lambda: sink(df.filter(pred)))
    res["sort_perm_ms"] = None
    timed("sort_mat", lambda: sink(df.orderBy("amount")))
    timed("agg", lambda: df.groupBy("region").agg(F.sum("amount")).collect())
    checks["filter_count"] = df.filter(pred).count()
    checks["first_sorted"] = [float(r[0]) for r in df.orderBy("amount").select("amount").limit(3).collect()]
    checks["sums"] = {r[0]: float(r[1]) for r in df.groupBy("region").agg(F.sum("amount")).collect()}
    energy_summary()  # while the JVM is still there to be read
    spark.stop()  # so the JVM's peak RSS is in RUSAGE_CHILDREN

neo's side: confidential

neo's kernels, the ports written in-house to beat them, and the techniques behind both stay with the engine. Nothing about how the numbers were made is withheld: the method, the checks every engine had to pass, every number and every place neo is behind are on this page. The engine itself we keep confidential, because we don't want it getting into the wrong hands. The binaries run on request and reproduce every number here.

04 · Diligence

What both sides were held to

• Same input, same answer. Every engine reads the same file and prints the same checks line: the filter count, the first sorted values, the group sums. A number enters the ledger only when the checks agree with the C++.
• Timed the same way. A kernel is the best of three in one process; a load is the engine's typed read, best of two, with the first read of a fresh process kept separately. Engines that need a warm-up get it before the clock.
• Energy is what the machine billed. Millijoules a run, read from the hardware counters for each engine's whole process tree, with the draw at rest subtracted for the seconds of the window.
• The machine is named, and so is its load. Apple M5 Max, 18 cores, 26.4.1. The load average before each run is in the ledger, and a study taken on a shared machine says so beside its numbers.
• Where Spark wins, it is shown winning. None of the 14 measurements on this page, and that is also a measurement.
• The caveat on this comparison. Spark is a cluster engine run on one laptop, which is not what it is for. Its JVM and session start are excluded from every kernel, its materialisations go to the noop sink so every row is produced and none collected, and it was given 48 GB. These are the numbers a Spark user gets on one machine, not what a cluster does.
• What is kept back. neo's kernels, the in-house ports and the techniques behind them: we don't want them getting into the wrong hands. The binaries run on request.

Scripts: scripts/bench_libraries.sh · measured 2026-10-11 · the numbers on this page come from the same ledger as the app's own Evals page, written by neon-cpp/scripts/results_md.py.