Draft 1 for Jon, 30 Oct 2026, written by design chat's writer from your outline and the page shapes. Not live. Mine, not yours, and worth checking:

A language for 3D engines that is slow will not get an engine built in it. So this page asks one question: how does Cone do, on the kinds of work an engine does, beside the best languages I could run against it? It gives the answer in one sentence, then the table of workloads, then what is behind the biggest numbers, and last how I measured, including the mistakes in my own measuring that I had to fix.

The claim

On a broad range of workloads, Cone keeps up with the best of the languages I measured it against, within a margin. It wins some, loses some, and where it doesn't yet keep up, the table says so.

Why it can

Three things, and none of them is clever on its own.

The back end. Cone compiles through LLVM, the optimizer behind Clang and Rust. I did not write a code generator and then spend years finding out what it forgot.

Features that make the obvious code the fast code. A value can sit in place, inside the struct that holds it, without a heap object behind it. A borrowed reference passes a value to a function without copying it and without touching a count. Each data structure picks how its memory is managed (the memory page is about that), so a scratch buffer can be an arena and a swarm of particles a pool. And Vector[T, N] gives you the processor's wide registers directly. Here is the same dot product written twice, as an ordinary loop and with eight lanes at a time:

fn dotLoop(a: &Array[f32], b: &Array[f32]) f32 {
  var s = 0.0f;
  var i = 0usize;
  while i < a.len() {
    s += a[i] * b[i];
    i += 1usize;
  }
  s
}

fn dotVector(a: &Array[f32], b: &Array[f32]) f32 {
  var acc = Vector[f32, 8]() <- fill 0.0;
  var i = 0usize;
  while i < a.len() {
    acc += Vector[f32, 8].load(a, i) * Vector[f32, 8].load(b, i);
    i += 8usize;
  }
  acc.sum()
}

perf_dot.cone (its module, import and main left out)

loop:   12285
vector: 12285

The plain loop is slow for a reason that is not the compiler's fault. Adding floats in a different order can change the last digits, so the compiler may not rearrange the additions into lanes for you. The second version says in the code that eight running sums are what I want. On my laptop, built with the default settings, the loop costs 0.453 nanoseconds per element and the vector version 0.0586, which is 7.7 times faster, and both print the same sum on this input. It is not a free win everywhere: for a loop like y = a*x + y LLVM's own vectorizer already does as well, and writing it with Vector was slightly slower. A vector is for the cases the compiler cannot guess.

Packages built for heavy work. The actors package runs one worker pool across the cores, the arena and pool packages are written for large counts of small things, and the memory strategies are libraries in Cone, not special cases in the compiler. What they cost is in the table.

The workloads

Each row is a kind of work an engine does, Cone's number, the other languages' numbers, and a few words on why. Smaller is better for times, larger for rates. Cone's wins and losses are in the same table. A grey row is a workload I have built and checked but not yet measured on a quiet machine: it is here so you can see the whole shape, and it will be filled by the next run.

WorkloadWhat it modelsConeThe othersWhy
Binary trees, one owner (Uni), depth 18, 35 million nodes Building and dropping a scene graph 1,026 ms Rust Box 1,148 ms. The collectors looked ahead (C# 443 ms, Go 788 ms) in a run that timed Cone's teardown but not theirs [pending 31 Oct run] Cone and Rust spend about 80% of the time in the same Windows heap, so this is a tie with Rust, not a win. A single owner needs no header and no count. The collectors are ahead, I think because they allocate more cheaply than malloc; I have not isolated that. Cone uses the system allocator today; its own is a candidate, not built.
Binary trees, counted (Rc), depth 18 The same tree, shared 1,080 ms Rust Rc 1,124 ms Cone's count header is 8 bytes and Rust's is 16, so a node is smaller; the heap is the same.
Binary trees, the per-actor collector (ActorGc), depth 18 A tree built inside an actor 656 ms Ahead of Cone's own one-owner and counted trees (1,026 and 1,080 ms), Go's collector 788 ms. Behind C#'s, 443 ms The collector runs between an actor's messages and copies what is live. The Go and C# figures are from the earlier run [pending 31 Oct run, side by side]
Binary trees, arena and poolBuilding a tree that is thrown away whole [pending 31 Oct run]Rust and Go preallocated arrays The earlier run was timed with Cone's teardown inside the clock. It is not quoted until it is rerun with the fix.
Allocating 64-byte objects into an arena sized for them A frame's scratch 12.4 ns an object Rust Vec::with_capacity 11.3 ns Within about 10%. The arena's default grows 4 KiB at a time and, unsized, costs 20.5 ns; knowing the size is worth the 8 ns.
Frames with a big live heap, 2 million live objects, 20,000 sparks a frame, on the per-actor collector A game frame that makes scratch objects Frames a second level with Go. Worst frame 61.7 ms Go worst frame 2.3 ms; Cone one-owner 0.9 ms Loses on the pause. One collection copies the whole live set, and four happened in the 500 frames. A young generation would cut that; it is not built. One noisy run [pending 31 Oct run]
Frames by valueThe same frame, with no allocation at all [pending 31 Oct run]Rust, Go, C# value types Expected to be the largest ratio on the page: not allocating beats every allocator.
A function over a borrowed reference, the value held in a one-owner, counted or shared-counted owner Drawing a mesh however it is owned The same cost from every owner; nothing counted [pending 31 Oct run, the ns] Rust the same, by the same reasoning True by construction: a borrow touches no count, takes no lock.
An Arc stored by the function it is passed to Handing a shared mesh to a function that stores it 16.9 ns Rust 8.7 ns Loses by about 2 times, and I know why. The compiler counts the copy and then counts the scope's release again: four atomic operations where Rust does two. A fix is running; until it is measured I make no claim of parity.
A value moved into a message, a ring of 8 actors, 500,000 hops Handing an object to another actor 8.5 to 9.1 million hops a second, for 8 words and for 1 MiB alike Rust 4.7 to 5.0 million; Go 5.0 million The payload moves, not a copy: the rate does not fall with size. Cone is about 1.8 times ahead at steady state. A short run of a few thousand hops pays a start-up of about 1 ms for waking the workers, which is a good part of such a run.
Dot product, Vector[f32, 8] Lighting and skinning arithmetic 0.0586 ns an element Cone's own plain loop 0.453 ns, 7.7 times slower Float additions may not be reordered by the compiler, so the loop stays scalar. This row compares Cone with itself, not with another language.
Actor ping-pong, 1, 4 and 24 workersTwo actors trading messages [pending 31 Oct run]Rust (Tokio), Go, C# The 27 Oct run had Cone first at every worker count, but the runtime has changed since and that run's program no longer builds. Not quoted until rerun.
Loopback network I/O, ping and streamA server's connections [pending 31 Oct run]Rust, Go, C# Cone trailed all three in the 27 Oct run, the ping by 1.5 to 3 times. Since then #801 moved I/O work onto the worker threads, which raised Cone's own ping by 18% to 27% and its stream by 36% to 93%. How far that closes the gap is not yet measured.
parallel each, 1 to 24 workersThe same work over many items [pending 31 Oct run]Rust threads, Go, C# Parallel.For The page cannot say "within a margin" until the scaling curve is in. I expect the memory-bound loop to plateau in every language, and the uneven one to be where Cone is tested.
Entity churn, 100,000 and 1 millionSpawn and despawn a swarm each frame [pending 31 Oct run]Rust, Go, C# slabs and maps Cone's pool beside each language's hash map and hand-built slab.
A shared document, many viewsAn editor [pending 31 Oct run]Rust Rc<RefCell>, Go, C# Whether shared and mutable costs a check at run time.
The bakery, actor against lockMany callers, one stock room [pending 31 Oct run]Rust, Go, C#, each as actor, lock and atomic "No lock in sight" is a safety claim. An actor is likely to be slower than a lock on a one-line critical section, in every language.
Compute kernels: n-body, spectral-norm, mandelbrot, fannkuch, fastaPlain single-thread arithmetic [pending 31 Oct run]Rust The classic set. There is no measurement of Cone on these yet.
All of the above against C++ [pending: no C++ column exists]C++

Read the table as a person who would use these things in an engine. The memory rows say Cone is level with the best of its peers where they use the same machinery, and that the large multiples come from the structure you choose, not from the language. The losses are real: an engine that has to finish a frame cannot take a 62 ms pause, and I would not ask you to.

Three stories behind the big numbers

Messages that move. An actor's mailbox takes a value without copying it, so the cost of sending an object does not depend on its size. The hop rate in the table is the same for eight words and a megabyte. The ping-pong run, once rerun, is the other half of this story: two actors trading a ball, where Cone was ahead of Rust, Go and C# at every worker count in October [pending 31 Oct run]. The concurrency page is where it belongs.

Choosing how a structure is allocated. The same binary tree costs very different amounts depending on where its nodes live. One heap object per node, whether a single owner or counted, is dominated by the allocator. A tree built into an arena, which frees everything at once, was far ahead of it in the earlier run, roughly five times [pending 31 Oct run, with the harness fixed]. That ratio is between families, not between languages: contiguous storage that is freed together, against one object per value. The memory page shows how to choose.

SIMD. The dot product above. The vector type exists so the ones the compiler cannot guess are written down, and it is passed in the processor's registers. It is a tool for a few hot loops, not a way to write a program.

How it was measured

The harness is twelve workloads and 48 programs, in Cone, Rust, Go and C#, in one folder with a runner that does the timing. Every program writes the same checksum for the same input, and the runner refuses to start if any two disagree. I wrote each in the way a fluent user of that language would, with Rust restricted to its standard library, because I could not fetch crates: no bumpalo, no rayon. Where a Rust program would use those, it has the hand-written equivalent, and the table's Rust rows say what that gives away.

The runner takes a lock on the machine, waits until the processors are idle, and refuses to run if they don't settle. It runs seven rounds, drops the first, rotates the order of languages in every round so none gets the warm cache every time, and reports the median. Each group also runs one program twice, byte for byte, so I can see how much two identical runs differ. Everything is on one machine, my laptop (an i7-13700HX with 24 threads, Windows 11), and every number is Windows x86-64. I have not measured Linux or macOS.

Compiler settings: Cone with --release (LLVM at its default optimization, for a generic CPU); Rust at opt-level=3; Go at its default baseline; C# with the default just-in-time settings of .NET 9, nothing tuned. The comparison Rust map in the entity-churn row will use Rust's default hasher, because that is what ordinary Rust has, which makes it slower than a tuned one.

The first results were wrong, and I would rather say how. On 30 October I audited the harness and found places where one side was timed differently from the others:

The numbers on this page come from after those fixes where the table says so. The full overnight run, tagged whycone-fixed-1031, replaces every earlier figure, and it will also fill the grey rows.

Further reading

Why I built Cone · Next: Safety