- The claim. Your outline says "against C++ and Rust". C++ has not been measured at all, so the page says Rust, Go and C#, the languages in the run, and a [pending] row marks where C++ would go. Whether to add a C++ column or narrow the sentence is yours.
- "Within a margin." Two rows lose by about 2 times or much more (an Arc kept at its last use, and the worst frame
of the per-actor collector at 2 million live objects), and
parallel eachscaling, pending, may too. I let the page say so in the table and not hide them; the sentence of the claim promises only "a margin where it doesn't win yet", for you to tighten or loosen. - Numbers. Every figure is from the claims ledger (PLAN.md, "Claims ledger, 30 Oct evening"),
region-gaps-profile-2026-10-30.mdorregion-performance-findings-2026-10-30.md. Three are not ledger rows and are mine to flag: the SIMD dot product (7.7 times, from cone-plan andWI\arrays.md; it is Cone against Cone's own plain loop, not another language); the Rc and Go/C# binary-tree figures (taken from the same findings notes as the ledger's uni row, and from the earlier run, so the 31 Oct run may move them); and the I/O percentages (Cone against its own earlier build). - "Pending" rows. [pending 31 Oct run] on the table's rows for: arena and pool on binary trees, frames
by value, borrow cost with numbers, actor ping-pong, I/O against the other languages,
parallel eachscaling, entity churn, the shared-mutable document, the bakery, the Cone-vs-Rust compute set (n-body, spectral-norm, mandelbrot, fannkuch, fasta), and a C++ column. Also pending: the "roughly 5 times" arena figure in the second story. - Unresolved links: the harness (placeholder), the manual pages under
../coneref/(copied from the memory page's convention, unverified), and the playground. - Not claimed anywhere: that Cone beats any language, except where a row says it measured so; Arc parity with Rust (a fix is running); a Linux or macOS number (every run is Windows x86-64 on your laptop).
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.
| Workload | What it models | Cone | The others | Why |
|---|---|---|---|---|
| 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 pool | Building 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 value | The 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 workers | Two 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 stream | A 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 workers | The 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 million | Spawn 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 views | An editor | [pending 31 Oct run] | Rust Rc<RefCell>, Go, C# | Whether shared and mutable costs a check at run time. |
| The bakery, actor against lock | Many 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, fasta | Plain 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:
- Cone's clock ran through the teardown of the tree and the live set; Rust's stopped before. Both now read the clock before anything is dropped.
- Cone's actor workers start on demand, so the first message paid for waking them; the others started their runtimes first. Now the Cone programs warm the workers before the clock starts.
- Cone's arena rows grew in 4 KiB steps while Rust's vector was allocated whole. Giving the arena its size moved that row from 1.8 times Rust to about 1.1.
- The message-passing row stopped its clock after the final wait for the actors, where the others stopped at the last receive.
- Rust's single-file programs were built at -O (level 2) and now are at opt-level=3, as its Cargo builds were. That one made the other side faster.
- Two of the "gaps" against Rust, the one-owner and counted binary trees, were never gaps. I profiled both and Cone and Rust do the same work against the same heap.
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
- Vectors: many numbers at once, in the manual.
- The harness, the programs and the raw results.
Why I built Cone · Next: Safety