Top
Best
New

Posted by shioyama 11 hours ago

Frostbite: A new CPU architecture discovered, designed and verified by AI(architectlabs.com)
570 points | 302 commentspage 7
FrustratedMonky 10 hours ago|
So far this thread is a little breathless about AI.

This looks cool and all.

But, can someone with CPU experience give an opinion? Does this blow your mind? Or is it trash?

Like how the new math solutions when read by a mathematician seem 'ugly', even if technically correct. Does this look like something actually alien and groundbreaking?

fwip 7 hours ago||
I'm not in the industry, just a casual observer (went to school for it though). But it looks similar to the kind of thing that would come out of academia (few profs + grad students), plus a lot of LLM-written hype.

It's not especially hard to get chips that win in some metrics on some inputs, especially when you get to design the ISA.

I don't see any indication that they got their chips fabricated, which is the "last 90%" of the work.

jcarmackdaddy 9 hours ago||
[dead]
SecretDreams 8 hours ago||
Now they AI can sulk and dwell, wondering why adoption for their new architecture is low, like other, prior, new architectures after arm!
shevy-java 8 hours ago||
Ok but ...

... WHY ARE THE PRICES SO DAMN HIGH COMPARED TO THREE YEARS AGO?

rvz 10 hours ago||
Once again, you are "not allowed" to invest in the frontier.
imtringued 10 hours ago||
Looks like AI doesn't have to fall for C hubris. Honestly, if you want to make it in this new AI age I recommend you to question every single thing that is considered set in stone, anything that is considered "the natural order of things" in software development. Think hard outside the box.

I don't know why nobody is seeing the problems with C. From my perspective it's not useful to think of C as a portable assembler or a thin layer on "top of the machine", because it makes C machines look eternal and timeless, even though we are deep into the post C machine era of multi core processors with cache coherence.

>Mainstream programming languages, when compiled for general-purpose CPUs, hide the dependencies between the parts of a program. Any piece of code may read or write any variable through a shared, mutable state, and so modern CPU hardware assumes the worst case and rediscovers, at runtime, which instructions actually depend on each other.

To this day I still wonder why people aren't seeing the immediate glaring red flag that the conventional sequential programming model presents. To this day people keep building inherently sequential languages and then wonder why parallelism is so hard. It's hard because you made a fatal assumption: There is only one global memory. How exactly is anyone supposed to reason about such an omnipotent and all powerful concept, where everything can potentially affect anything? If you have two cores, the entire idea of a singular memory screams like a bottleneck. Like, it's crazy to me that anyone would think in 2026 "yup, lets build another sequential language that makes our lives a living hell".

>Moreover, single-core CPU performance has largely stalled since the early 2000s, pushing people towards large multicore CPUs such as Intel Xeon, AMD Zen, and NVIDIA Vera. This forces CPUs to maintain the illusion that every core sees the same memory, and keeping that illusion consistent and performant requires deep cache hierarchies and coherence protocols that cost area and power, and scale poorly.

Correct. Because everything potentially depends on everything, you need to figure out at runtime when things don't depend on each other, which is kind of insane when you think about it.

The assumption of a single global memory is what doomed C. It's the 21th century. Computers don't have global memories anymore, they pretend they do. You can't fix it. No amount of nostalgia towards C is going to fix this mistake.

Also before someone accuses me of e.g. being a C hater, I'll tell you that Zig's IO Backend parameters are the same type of flaw in Rust that probably will never be fixed. Implicit IO is a different kind of global state that Rust inherited and from the 2026 agentic coding perspective it's a pretty egregious flaw because agents don't care about passing in a parameter, meanwhile from the perspective of PL design, using a parameter instead of a full on effects system has this certain charm / beauty to it, how you don't need to special case everything to get the same results. You just use what is already there.

w4der 7 hours ago||
> keeping that illusion consistent and performant requires deep cache hierarchies and coherence protocols that cost area and power, and scale poorly.

Cache hierarchies also exist because memory latency and capacity tend to be inversely proportional to each other, and directly proportional to cost. The underlying process and physics of chip design works against you on this front.

I'd love to have 1 GB of L1 cache, but that is simply not viable because your cache would be as big as your core, way more expensive, and by the sheer size, it would become a NUMA cache, which defeats the point of a cache and the "illusion" of UMA.

jkhdigital 6 hours ago|||
Yes, there’s a notable IEEE article from like 15 years ago that riffs on these same points—the gap between the abstraction presented by the typical ISA and the actual microarchitecture is too great to ignore and we have blindingly complex and opaque layers of compiler optimizations and OOO pipelines that exist solely to maintain the fiction for programmers.

I think the greatest benefit of rethinking CPU architecture at the level of the ISA will be to make performance more transparent to developers without the layers of black magic.

joshheitzman 2 hours ago|||
> Computers don't have global memories anymore, they pretend they do.

Citation needed. After 10 minutes of searching I can't find anything to support this statement.

skydhash 9 hours ago|||
> It's hard because you made a fatal assumption: There is only one global memory. How exactly is anyone supposed to reason about such an omnipotent and all powerful concept, where everything can potentially affect anything?

Because parallelism is not that needed, there’s always contention starting from physical constraint. A user can only have one body, a printer can only output one piece of paper at a time,… There are natural areas for parallelism and it’s been already implemented. Memory as a bottleneck has not been a things for decades.

Breaking down things in terms of tasks is not hard. The hard part is discovering that those parts need to communicate. And sometimes they want access to same limited resources. We already have things like array programming that have a parallel view of computation. But no one is rushing to get things done with them.

actionfromafar 10 hours ago|||
I'm with you, but I don't see a clear path from "here" (illusion of the same memory) to "there" (each processor has its own memory, I guess). It's really hard to reason about latency, synchronization and communication costs in the abstract.

In a way I see the various cloud computing services as the organically grown (i.e. haphazard and clunky) answer to this problem.

jkhdigital 6 hours ago||
One of the reasons it is so hard is because the discipline of thinking about those things isn’t baked into the language like it should be. You can’t look at a piece of code in a typical high-level language and reason about synchronization overhead because those semantics aren’t expressible in the code. We need languages that support expression of effects and coeffects, which would enable that kind of high-level reasoning about tradeoffs.
actionfromafar 5 hours ago||
Do you have any ideas on what that would look like? The best I can come up with is something like https://seastar.io/ built in to the language.

But even that feels lacking, even though I'm really impressed with Seastar. I love the "bring operations to data" thinking.

ModernMech 5 hours ago||
I agree, I've always viewed C as a sort of domain specific language for Von Neumann architectures. We only call it a "general purpose language" because the domain was so big, but using C to write multi-core distributed, networked programs to me feels like using CSS to write an operating system.
Vivek-KY 11 hours ago||
[dead]
chahmed312 10 hours ago||
[flagged]
stpedgwdgfhgdd 9 hours ago||
[flagged]
encyclopediai 7 hours ago||
[dead]
ElUncivio 10 hours ago|
[dead]
More comments...