> 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.
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.
So there is 'no sharing of state' baked into the computational model by design, enforced by this very simple and elegant design choice.
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.
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.
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?"
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
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.
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.
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.
[1] https://en.wikipedia.org/wiki/Dataflow_architecture
Every step there is local, every dependence is explicit and every value has only one owner.
> 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.
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.
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.
Llms are pretty good at porting software.
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 :)
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.
> 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.
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
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.
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?
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.
In short, how can we be sure it will work and be stable, and that we're not just watching another AI hallucination?
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.