upvote
Tendrils just raised $30m from Benchmark to build an interaction net based CPU

https://tendrils.co/blog/2026-11-10/30m-raised

reply
Thanks for sharing, TIL about interaction nets. I found the article linked at the bottom easier to understand[0].

> Another issue with multi-core CPUs is the difficulty of programming them. Debuggability is a major issue, and entirely new classes of issues arise, such as race conditions. However, in interaction nets, all active pairs are independent, and so can actually be executed in any order. This property is known as confluence, and means that no matter the order in which things are executed, the result will be the same. This makes debugging straightforward and eliminates issues like race conditions. This allows Vine to be parallel out of the box; the programmer does not have to do anything special with threads, processes, CUDA kernels, etc. to get parallel execution.

[0]: https://tendrils.co/blog/2026-04-26/on-inets

reply
I'd be interested to see how this would pan out.

Seems to describe something analogous instruction level parallelism, which traditional CPUs made this millennium have as well via instruction pipelines, branch prediction, and speculative execution. Some of which turned out to not work too well so now we generally run hobbled CPUs with Spectre/Meltdown mitigation enabled.

The reason why we tend to reach for difficult abstractions for core level parallelism is that most automatic/safe approaches tend to stumble pretty hard on Amdahl's law, where most parallel code is consequently almost entirely designed around minimizing critical sections.

I don't fully see how inets would resolve Amdahl's law.

reply
I think you're thinking about this the wrong way. This isnt about surpassing theoretical parallelism limits. Its about gaining parallelism without having to be explicit about it. If you look at the solve function from the page, its doing a brute force search of the 5 queens problem. In the naieve implementation, this is done serially. But with the different approach to compiling the implementation, we can essentially "automatically parallelize" it. Thats the difference between the animation on the left and right. The thing is that in order to handle fine grained parallelism like this you need better/different hardware primitives so that you can split computation at a more fine grain, which is why they needed a new hardware model/isa. This is how they achieved the 4-5x speed up: by automatically parallizing a serially implemented function. If you were to compare a parallelized function to their parallelized function, I would expect to see a smaller speedup. Or at least as I understand it. Correct me if I'm wrong.
reply
I read through the first half, but the graph operations are really confusing me. What's the difference between a principal port and auxiliary ports? A lot of the rewrites are swapping them around so I'm confused what their significance is.
reply
This is the key feature of the architecture. Computation is shown to be localizable and independent in terms of 'active pairs' which are defined as elements connected via their 'principle port'. Since the design permits only one 'principle port' per element, all possible graphs that we can arrive at with this formalism can only have components that 'exclusively' participate in a single 'active pair'.

So there is 'no sharing of state' baked into the computational model by design, enforced by this very simple and elegant design choice.

reply
deleted
reply
I was a bit surprised by Vine's syntax. I expected something a lot more like Lisp.
reply
For me, the edges are still too blurry for me to make out what this actually is. I need someone with more in-depth knowledge to let me know what is actually being proposed here.

On the optimistic side, this looks like a kind of "bigger step" in the direction that GPU/shader programming took, where you change the way you think about and break down a problem to get insanely fast results. Feels like if you target this interaction net structure and give it to this CPU that uses them natively, we could amplify the speed of computations to possibly allow for things that are currently way to slow to do. Realtime physics sims with magnitudes faster steps. That's pretty cool. And all of the downstream effects that would allow for, in product design, scientific modelling, etc. And that's just one train of thought.

On the pessimistic side, though, I have no clue how to "program for an interaction net". Seems like the authors took a "you don't need to, an LLM will do it for you" position, and I can get behind that, but that's a pretty huge step in the direction of "Natural Language Programming" in that I literally can't program it without using an LLM and natural language, because I don't understand the underlying details and probably won't have any structural support to understand it for a while, as the tooling slowly rolls out and gets iterated on, until it can do something we can recognize as "Debugging". I imagine there's some kind of "program it in C, and translate it" thing, too, but it feels like the point here is not to have me be able to debug it, and a detour through C just wastes LLM tokens.

So those are the initial impressions, but then I'm making a TON of assumptions in both sides of that. So I don't even know if my initial impressions are conceptualizing the right paradigms, much less if they are worth discussing with people who are seriously considering this topic. Only speaking for myself here, but at least my own silence is due to not having enough information myself, and not seeing enough in this paper to interest me in research in the topic just yet. Maybe if they've got something I can play with, I could get my head around it more. But, for now, it's just neat.

reply
> Feels like if you target this interaction net structure and give it to this CPU that uses them natively, we could amplify the speed of computations to possibly allow for things that are currently way to slow to do.

I mean, it's basically what out-of-order CPUs already do: read lots of instructions in at the same time, dispatch instructions as their inputs become ready to execute.

Sort of the reality of modern processors is that we have the units available to do the work, we just don't have dispatch logic to keep them fed with work, given how slow memory is. When you have very regular parallelism--dense linear algebra is the canonical example here--SIMD works very efficiently to minimize the dispatch logic needed to keep units fed. When you've got irregular parallelism, dataflow architectures seem to work well at first, until you start trying to make actual chips and you find you've been consistently underestimating how much overhead your dispatch logic is actually chewing up.

reply
Right. Sounds like that to me, too. But, again, I'm completely new to the topic, so what do I know?

If it is true that what is offering is some kind of "super-simd" processor that is built in a way that everything run through it must be similar to simd style code, but because it's hardware, it will run it much faster, then my questions are definitely targeted toward what the speed up is vs a highly-performant SIMD application. I would hope that their "coming next" stuff includes comparisons against the types of SIMD-boosted dense linear algebra you referenced. What is the speed up compared to that. And if it's less than (arbitrarily, say) 10x, how much can be gained by just having an LLM target breaking more stuff down in to multiplex-able instructions? But then, if it's more than that, my questions start turning towards "how much would it take to prototype" and "how much has to be changed from current tooling to produce the chips at scale" and "what is a good showcase target for an initial run? what would be something that could be made actually (in real dollars/hours) cheaper/faster/better by using this chip?"

reply
From what I got, the magic is possible because the software is expressed as interaction networks and the CPU doesn’t need to resolve inter-instruction dependencies because the program makes them explicit.
reply
Isn't this just VLIW / EPIC that failed spectacularly in the early 2000s?
reply
> If it is true that what is offering is some kind of "super-simd" processor

if it is, that has been tried before and failed (with itanium/etc), because the optimization burden on compilers means that they never end up getting the projected speeds over conventional execution

reply
Interaction nets are a _model of computation_, not a programming paradigm.

I.e. they are on the same level as Turing machines and Lambda Calculus. Arguably they are more elegant than LC as beta-reduction doesn't look like a primitive operation.

E.g. if try to 'run' Turing machine using pencil and paper, a primitive step is to update one step. With IN one step can also be 'local'.

OTOH LC beta-reduction might be impossible to do in-place - you might need a lot of new pages to do just one beta-reduction.

reply
I tried reading that when it was mentioned earlier here on HN, and the fact that the pointy end of the triangle isn't an output, nor can I tell where the outputs are, breaks it all for me, the cognitive impedance mismatch is too damned high.

People had a lot of novel ideas for nomenclature back then in the 1940s, that just don't work 80 years later, it's a shame they still clung on to it in 2026.

reply
> Do people here know what interaction nets are?

Even if people know they are it doesn't help that a good chunk of the article is dedicated to their AI methods, and there are very little technical explanations of how this actually works.

reply
I've been thinking of a calculator builder tool for OSRS for a while now, and it seems like I was just trying to use interaction nets! Thanks for the terminology :)
reply
There was also a smaller scale approach called edge/trips that could express code as a dag: https://www.microsoft.com/en-us/research/publication/evaluat...
reply
I think that data flow computing paradigm subsumes interaction nets.

[1] https://en.wikipedia.org/wiki/Dataflow_architecture

Every step there is local, every dependence is explicit and every value has only one owner.

reply
In the context of this story, I wonder whether interaction nets are more amenable to hardware implementation? I plead ignorance about how the dataflow paradigm maps to hardware.
reply
same as interaction nets, no? except they are strongly confluent and have incremental sharing
reply

  > same as interaction nets, no?
Exactly my point. But well researched and has compilers from high level languages (Id and some others).

  > except they are strongly confluent and have incremental sharing
Data flow is an inverted representation of data demand (lazy evaluation, which is strongly confluent) [1] and I do not see why it cannot (be constrained to) have strong confluence.

[1] https://dl.acm.org/doi/pdf/10.1145/93548.93578

Have authors compared interaction nets to the data flow machines? No.

They did not even compared their results to the Transport Triggered Architecture [2] automatic core construction workflow.

[2] https://web.archive.org/web/20051125195128/http://ce.et.tude...

In some cases (FFT), TTA's automatic synthesis was able to provide power-per-operation reduction of three orders of magnitude, when compared to specialized ASIC hardware.

reply
I mean, it's not like interaction nets don't come up every now and again. I remember the Bend language making the rounds here several times, v1 of that language was built on their own HVM, which uses interaction nets, it's a niche idea but not a completely forgotten one (Bend 2 appears to have dropped them due to perf reasons). We also get the occasional articles on revolutionary new (old) CPU architectures that will displace everything, last one I saw was pushing VLIW as the silver bullet that would displace the current CPU giants and make x86 obsolete. I don't see much reason to believe that this approach would overcome the main barrier to adoption that those approaches failed on, which is the cost of porting existing software across, unless the creators are willing to front the token costs for that.

Also, the article title is one that heavily emphasizes the AI autoresearch aspects, and doesn't mention interaction nets at all, so it makes sense that people would go into the article primed to think about the autoresearch aspects.

reply
You don't have to make x86 obsolete to be successful. You can just add extra accelerator chips. GPUs did this, NPUs are trying to do this, and there are plenty of exotic accelerators inside modern computers doing specialized DSP tasks.

If this stuff works, it'll surface first as some PCIe extension device that work can be dispatched to when it makes sense. Then maybe it'll get integrated into SoCs and be exposed via new CPU instructions or devices. Perhaps compilers can then start to identify blocks of code that can be reduced to interaction nets, compile the net and then run them on Frostbite style chips opportunistically.

reply
People keep rediscovering the same ideas and renaming it. Interaction nets are another kind of graphical dataflow model. There are lots, but they are all basically the same idea.
reply
//I don't see much reason to believe that this approach would overcome the main barrier to adoption that those approaches failed on, which is the cost of porting existing software across,

Llms are pretty good at porting software.

reply
> Wow, I posted this and come back a few hours later, and the comments are... a bit depressing honestly.

I think AI sentiment is charged and skews negative amongst culture, but very negatively charged amongst engineers because of the "impending doom" and how our jobs are obviously changing. The craft is arguably gone. Interesting news just becomes another rung in the ladder of job insecurity.

Nice to see you on the interwebs Chris-san :)

reply
5 years ago this would have been super cool to me, but now it feels like the gun aimed at us will one day soon use bigger/faster bullets
reply
All things being equal, I could see this leading to 1-2 order of magnitude in compute efficiency over von Neumann / Harvard architectures, and may be ideally suited to in-memory compute, in particular.

If you can program it in rustish language with the intermediate representation, that makes everything portable to it without having to figure out the parallelism, potentially.

Very impressive and potentially revolutionary. Micron or Samsung needs to see this, they are having to reinvent compute anyway.

reply

  > without having to figure out the parallelism...
Parallelism can be regular (matrix or tensor operations are examples of that) and irregular (Barnes-Hut as a very simplified example). To extract something like Barnes-Hut from the code with quadratic complexity, one have to make some interesting assumptions. E.g., one has to figure out something.

One may think that regular parallelism is a solved problem, but even nested loops are not always parallelizable without figuring out how to make them to work in parallel.

Then there comes Microsoft Word. Can we make a CPU where Microsoft Word gets executed with maximum IPC achievable? If you do not like MS Word, take a look at Linux Kernel and userland programs as a whole.

reply
This is historic. This kind of thing is what ai self improvement looks like (like it or not...). It might not be this architecture specifically, but this is what the acceleration is going to look like -- show hn posts about ai advancing its tech stack

My question: if these new developments roll out steadily for enough years, what does that mean for nvidia or amd or intel? Do they benefit? Probably? They already have the manufacturing pipelines

reply
Is it real, or is it clickbait nonsense? AIs are really good at producing clickbait nonsense.

Several new kinds of architectures have been tried: the iAPX 432, the Mill, the Reduceron, but things just keep coming back to the out-of-order modified Harvard (a.k.a. fake von Neumann) machine being the most efficient general-purpose computer in our laws of physics.

reply
Any article with a description of a large agentic search process and ... 4 citations ... is begging to be ripped apart.

Really? They let a swarm of AI agents loose and you're sure they didn't draw upon more than 4 references?

Did they just ignore Taelin and HVM?

reply
They aren't. They're just dataflow graphs, and AFAICT they are less powerful than program expression grammars, e-graphs, or the sea of nodes.
reply
> and the comments are... a bit depressing

This is a very interesting project, but unfortunately at this point in time anything with “AI” in the title invites too many hot takes and personal opinions about AI that are unrelated to the story.

On Hacker News (and Reddit and every other social news site) the title drives the comments more than the article content because, frankly, most people don’t even try to read the article. If you had submitted this with a headline that didn’t mention AI and instead said something about interaction nets the tone would probably be very different in the comments.

Please don’t be discouraged, though. This content is very interesting to many of us, but it takes time to read and appreciate it, whereas firing off some “AI bad” hot takes in the comments without reading the article is an easy way to get some upvotes and ignite large comment chains without reading the article. That asymmetry always biases the comments in one direction, but don’t take the comment section bias as a sign that it wasn’t appreciated as a submission. It’s currently the #1 story which is a much better signal of interest than the comments.

reply
Best I can do is upvote your post and reply to it to see if it gets it closer to the top.
reply
dude, CEO of this "startup" done 2 internships. this is obviously investor slop bait
reply
Well I mean all of the visuals on the web site are nice and shiny, but all of the existing real and physical architectures are built on years and decades of experience, and years and decades of failure and optimization.

In short, how can we be sure it will work and be stable, and that we're not just watching another AI hallucination?

reply
Did you not read the article? IIUC the entire chip is formally verified (because, why not)
reply
Does the proof correspond with the chip? Does it prove useful properties? Are the properties it proves desirable? Desirable for what? How did you check?
reply
Good questions, also is the machine code derived from the proof (rocq) or is there just a proof along the code, which allows drift between theory and implementation.
reply
Formally - but by LLM. In theory practice is the same as in theory.

Will be cool to see if Linux can run on a QEMU or FPGA based implementation of this and how the efficiency numbers look then because it's not quite as interesting if it's not general purpose computing ready.

reply