On November 18, 2026, the chip-design startup Architect Labs published a post introducing Frostbite. They describe it as a general-purpose CPU with a new instruction set. They say their AI systems designed it, from the compiler down to the final chip layout. The Hacker News thread reached 657 points and 342 comments.
Most coverage is about the AI and the headline number: 4.59x better performance per watt than a conventional core. This article looks at the part software developers can try today. Frostbite runs programs as interaction nets, a model of computation that is more than 35 years old. The language that compiles to it, Vine, is open source, and you can install it with Cargo today.
A note on sources: I have not run Vine or seen Frostbite hardware. Every number below comes from the linked sources: the Frostbite post, the Vine documentation, an explainer from the company behind Vine, and the HN discussion.
What Frostbite claims, in short
All of these come from the Architect Labs post:
- The workloads. 25 programs in five groups: parallel, staged, sequential, branching, and recursive. The agents tuned the design on 10 of them. The other 15 were held out until the final evaluation.
- The headline result. One Frostbite "quad" (a two-by-two group of tiles) reached a geometric mean of 4.59x the performance per watt of the comparison core across all 25 workloads. That splits into 6.02x on the 10 tuning workloads and 3.83x on the 15 held-out ones.
- Area. An average 8.77x performance per area, on a 7 nm process.
- The baseline. The comparison core is "a modern, silicon-proven superscalar (dual-issue, in-order) CPU core". A footnote says: "For legal reasons, we cannot disclose the exact CPU."
- The status. The design reached 500 MHz in the final GDS (the layout file sent to a chip factory). The post itself calls the power numbers "pre-silicon". It does not report results from a manufactured chip.
- The process. The specification ended as formal contracts that compiled to more than 800,000 lines of Lean (a proof assistant). The agents tried 58 design ideas and kept 37.
Why can this design drop so much of a normal CPU's hardware? The answer is in the programming model.
Why your CPU spends energy guessing
A normal compiler sees which operations in your program depend on each other. It uses that information for optimization. Then it throws most of it away and produces one long list of instructions.
The CPU then tries to rebuild that information at runtime. Out-of-order cores keep large buffers to find instructions that can run early. Multicore chips add cache coherence protocols so every core sees the same memory, because any instruction might touch any address.
The explainer from Tendrils, the company that develops Vine, puts it this way: "Normal compilers already track these dependencies internally and use them to make optimizations. However, this information is then thrown away and the entire program is linearized into a sequence of instructions."
Frostbite's post shows the cost. Leaving out clock distribution, the comparison core spends 57% of its energy on memory and 27% on fetching, decoding, and issuing instructions. Only 13% goes to computing. Interaction nets keep the dependency information instead.
Interaction nets in four ideas
Interaction nets were introduced by Yves Lafont in a 1990 paper at POPL, a major programming-languages conference. The model fits in four ideas.
1. A program is a graph of nodes. Each node has exactly one principal port (its main connection point) and zero or more auxiliary ports (extra connection points). Wires connect ports. In the simple examples, a number and an addition are both nodes.
2. Computation is rewriting pairs. When a wire connects the principal ports of two nodes, they form an active pair. A rule says how that pair is replaced by a small new piece of graph. Then the next active pair is rewritten, and so on, until none are left. Each step only touches the two nodes involved. Tendrils calls this property locality.
3. Active pairs never overlap. A node has only one principal port, so it can be part of only one active pair at a time. That means all active pairs are independent. You can rewrite them in any order, or all at once, and the final result is the same. This property is called confluence. In practice it means no race conditions: there is no shared variable for two threads to fight over.
4. Every value is used exactly once. This is linearity. If a value needs to be used twice, the net contains an explicit duplicate node. If it is not used, an explicit erase node destroys it. Nothing is copied or dropped by accident. Rust developers will recognize the idea: it is close to ownership.
The Tendrils explainer shows this with unary arithmetic. In its multiplication example, the first rewrite leaves two independent active pairs, which can run in parallel with no coordination. Nobody added that parallelism. It is a side effect of keeping the dependencies.
What linearity looks like in Vine
Nobody wants to wire graph nodes by hand. Vine is a language with syntax close to Rust that compiles to interaction nets. Its Apache-2.0 GitHub repository calls it "an experimental new programming language based on interaction nets". Vine compiles to Ivy, a low-level net language, which runs on a runtime called the IVM. The Frostbite post says programs for the chip are written in Vine and compiled to Ivy.
Linearity shows up in Vine's type system as "flexibility". The Fork and Drop documentation says every type has two yes-or-no properties: can its values be forked (copied), and can they be dropped (destroyed)? The annotations work like regex quantifiers:
- No annotation: values must be used exactly once.
-
?: values may be used zero or one times (droppable). -
+: values may be used one or more times (forkable). -
*: values may be used zero or more times (both).
When you use a variable twice, the compiler inserts a fork for you. The docs show (used_multiple_times, used_multiple_times) becoming (used_multiple_times.fork(), used_multiple_times) behind the scenes.
The IO type cannot be forked or dropped. The docs explain the result: "at any point in the execution of a Vine program, there is exactly one IO handle, so all IO operations are ordered." So the language gets ordered side effects from the type system, while pure computation stays free to run in parallel.
Measure your program's parallelism with one flag
Vine can tell you how parallel a program is, without any parallel hardware.
The installation page needs Rust and one command:
cargo install --git https://github.com/VineLang/vine --locked Every Vine program needs a main function that takes the IO handle. The hello world is:
pub fn main(&io: &IO) { io.println("Hello, world!"); } Run it with vine run hello_world.vi. After the output, Vine prints statistics. The docs show 341 total interactions for this program. The statistics page says the total interaction count is deterministic: "the same program will always have the exact same interaction count, no matter what machine it is run on." That makes it a stable measure of work, unlike wall-clock time.
The useful flag is --breadth-first. The CLI docs say it runs the program so that "at each step, every possible interaction is performed in parallel." This pretends you have a machine with unlimited cores. It reports three numbers:
- Total: all interactions, the amount of work.
- Depth: the number of parallel steps needed. This is the critical path, the longest chain of steps that must happen one after another.
- Breadth: total divided by depth, the average number of interactions ready at each step.
This is the work-span model from algorithms courses: total is the work, depth is the span, and breadth is the average parallelism.
A worked example: longest common subsequence
The Tendrils explainer uses the longest common subsequence problem. Given two lists, find the length of the longest sequence of items that appears in both, in order, but not always next to each other. For "Tendrils" and "edits", the answer is "edis", length 4.
Here is their Vine code, a plain dynamic-programming version with two nested loops and no parallel hints:
pub fn lcs[T*; Eq[T]](a: List[T], b: List[T]) -> N32 { let row = []; for a_elem in a { let prev_row_entry = 0; let prev_new_entry = 0; let new_row = []; for b_elem in b { let row_entry = row.pop_front().or_use(0); let new_entry = if a_elem == b_elem { prev_row_entry + 1 } else { row_entry.max(prev_new_entry) }; prev_row_entry = row_entry; prev_new_entry = new_entry; new_row.push_back(new_entry); } row = new_row; } row.get(b.len() - 1).or_use(0) } Note the T* in the signature. With the flexibility rules above, that says list items may be copied or dropped freely.
They ran it on two random lists of 200 items with vine run lcs.vi --breadth-first:
Interactions Total 2_993_893 Depth 10_920 Breadth 274 On average, 274 interactions could run at each step. Then they increased both lists to 2,000 items:
Interactions Total 296_223_905 Depth 108_142 Breadth 2_739 The total work grew about 100x, because the algorithm is quadratic. The depth grew only about 10x. The explainer gives the reason: every cell on a diagonal of the DP table is independent of the others, so the critical path is just the main diagonal, which grows linearly. The parallel work grows with the input.
The explainer says the Vine compiler does this "not by magically extracting parallelism out of the program; it simply preserves dependency information all the way down to the hardware (or runtime, in this case)."
Frostbite's post shows the same pattern on a smaller problem. For five queens on a five-by-five board, the net runs 3,183 interactions with a critical path of 262 steps. On average, about twelve interactions are ready at every step.
How to read your own numbers
If you try this on your own algorithms, keep two limits in mind:
- Breadth-first mode is optimistic. The CLI docs say it "gives an upper bound on the speedup that could be seen from a parallel machine." Real hardware has a fixed number of cores and pays to move work between them.
- Depth is the floor. No hardware can finish faster than the critical path. A program with a breadth near 1 is sequential, whatever the chip is. This is close to Amdahl's law, and one HN commenter made that point about general-purpose code: "the longest serial task is what ends up slowing everything down."
From a net to a chip: how Frostbite schedules work
Frostbite is a grid of tiles. Each tile has a small local memory, an engine, and a runtime block. Because every value has one owner and every step is local, data can sit in small memories next to where it is used, instead of in a deep shared cache.
There is no central scheduler. The Frostbite post says each tile follows three rules:
- Run your own work first (the work in your input ports).
- If you have none, take work from a neighboring tile that has some to spare.
- If no neighbor has any, go inactive and save power.
Per the post, when a loop or branch splits into parallel pieces, the running code parks what comes next in a small record (the "frame manager"), puts the new tasks on a hardware "work queue", and takes the newest one itself. Idle neighbors pull the rest over the on-chip network. When the last piece returns, the parked code wakes up.
The post calls this "stealing work". Java developers know the same idea from ForkJoinPool, which its docs describe as "employing work-stealing". Here it is built into the tile hardware. The post says no human specified it and that it can be traced to "necessity on specific regressions and hill-climbing performance metrics."
The energy breakdown shows the trade. A Frostbite quad cuts memory energy to 38% and fetch, decode, and issue to 6%. In exchange, it spends 26% on the on-chip network and scheduler. Frostbite moves energy from guessing about dependencies to moving messages between tiles.
What the numbers do not show yet
The baseline is a small core, and it is not named. A dual-issue, in-order core is far simpler than the out-of-order cores in laptops and servers. One HN commenter pointed this out: "Actual modern high-performance CPUs use way larger than dual-issue front-ends." The post says comparisons against larger out-of-order CPUs, multicore setups, and the SPEC and PARSEC benchmark suites are planned "in the coming months".
The power numbers are pre-silicon. They come from models and RTL (hardware description code), not a measured chip. The post says they can be matched to real chips "over multiple tapeout loops", which has not happened yet.
The held-out score is the one to quote. The post reports both 6.02x on tuning workloads and 3.83x on held-out ones. When someone repeats "4.59x", remember that 3.83x is the number for programs the design never saw.
The workloads are small. Three kernels follow the SPLASH-2 suite but are "64 times smaller", per the post. Another HN commenter noted that the tests are compute-heavy kernels on small working sets, and asked how the design handles programs that "build large data structures and slowly mutate them."
Debugging changes. A commenter pointed out that there is no call stack or program counter, and that nets can leak values or get stuck waiting on each other. Vine's own statistics page touches on this: the Allocated and Freed memory numbers should always match, and "if they differ, that indicates that there was a vicious circle in the interaction net." Vine has a debug mode, but the same commenter called a source-level debugger "a requirement" and said that building one, if it does not exist yet, "would represent a substantial engineering project."
Some framing is disputed. The Frostbite post and the Tendrils explainer both say single-core CPU performance has largely stalled since the early 2000s; one commenter disagreed, citing yearly gains in Apple's chips. Another argued that the ideas came from decades of human research, and the AI turned them into an engineered product.
Who builds what
Two companies appear in this story. Architect Labs built Frostbite; its launch post mentions "$24M in seed funding led by Kindred Ventures". Tendrils develops Vine; its November 10 announcement says it raised $30M in a round led by Benchmark to build its own processor "to have thousands of cores operating in parallel."
The Frostbite post cites Vine and the Tendrils explainer. An HN commenter asked whether the two companies are related. Neither post says, so treat them as separate projects that share a language.
The Frostbite post lists its next steps: an FPGA-hosted playground where anyone can run programs, a basic operating system, benchmarks against a broader set of CPUs, and a release of the RTL and ISA.
What you can do with this today
- Run your algorithms with
--breadth-first. Depth and breadth show how much of your code is a serial chain and how much is independent work. If a rewrite lowers depth, it has more room for parallel speedup on any machine. - Notice where you share mutable state. Interaction nets make every copy and drop explicit. Asking "who owns this value?" in Java, Go, or Rust is the same habit that makes concurrent code safer.
- Watch for the FPGA playground and the SPEC results. They will show whether the 3.83x held-out number survives real hardware and stronger baselines.
Frostbite may or may not become a product. The model under it is well defined and available now in a language you can install with one command.
Would you write code for a chip with no program counter and no shared memory, if the tooling caught leaks and stuck nets for you?
Sources
- [1] Introducing Frostbite, Architect Labs
- [2] Hacker News discussion of Frostbite
- [3] On Interaction Nets, Tendrils
- [4] Interaction nets, Wikipedia (cites Lafont, POPL 1990)
- [5] Vine documentation
- [6] Vine on GitHub
- [7] Vine docs: Fork and Drop
- [8] Vine docs: Using the CLI
- [9] Vine docs: Statistics
- [10] Introducing Architect Labs
- [11] Tendrils: $30M Raised to Redo the CPU
