DRAM pricing has historically been cyclical in nature, and the only reason for the current high DRAM pricing is that current AI inference is unnecessarily RAM intensive/inefficient.
Interesting effect is that since DRAM production tooling has been switched from DDR/GDDR to HBM, we may finally see the proliferation of HBM in consumer GPUs/accelerators after the bust cycle starts.
It's also been historically prone to price fixing.
I would be completely unsurprised should we discover in a few years that peak RAM prices were at least partially due to price gouging and not merely due to shortages.
>the only reason ... is that current AI inference is unnecessarily RAM intensive
There's no indication that this will change, and every indication this will continue to grow. This is not some temporary thing. Demand is already exponentially higher than what is possible to produce, and there's no current reason to believe it has any ceiling.
I've actually done some work and was able to get the full 12GB Z-image Turbo to run on my 8Gb 3070, and throughout the generation only 600MB of VRAM was allocated (you can get a speed-up by double buffering, but the maximum VRAM was still only ~1GB through inference). It's very experimental and pretty much requires you to write all the compute kernels directly specifically against that particular weight and statically allocate the memory at compile time instead of using current ML frameworks like Pytorch/JAX, but I think in time somebody else would figure it out.
The hardware savings at the scale Anthropic or Google use would me immense, it makes me wonder why no big player has done more optimization already. When DeepSeek showed how inneficient were the models of its time, I'd expected each to create a permanent optimization team with all the talent they have hired.
I guess hardware is not that expensive to them in the grand scheme of things, at least not at this stage. OTOH, their propietary models might be thoughly optimized and we can't know, because they're still bound by supply contracts to buy the same amount of hardware nevertheless.
The key disadvantage of a roundabout is that it takes up more space and is harder to setup than plopping down a couple of stop signs.
They are awesome otherwise, I do like them better for low traffic intersections though because I don't have to stop and think about if the next car is going to yield or not.
Only large roundabouts take space. Small roundabouts can easily be retrofitted into small, unguarded residential neighborhood intersections without clawing back any sidewalk corners. They just plop a curbed-off circle in the middle of the intersection, leaving a narrow passage around it. Now a car going straight has to swerve into a crosswalk that is going in the same direction. Massive win!
Very high with the correct tooling. Vision tends to be the worst reasoning mode for LLMs compared to code, which is why I rely on a code-first approach for my own software stack. Essentially, they need to have a way to keep part of the drawing in focus to avoid getting distracted by the dimensions they don't need in their vision.
The initial dimensions of this phone were one-shot by Codex Astra from the publicly available 2D drawing, and we spent another turn implementing the G2 continuous fillet blend surface for that particular camera bump. If you have a STEP viewer, you can check the dimensions against that phone company's drawings which was posted on HN with their other products yesterday I think, and all of them should match exactly down to the drawing tolerances.
I keep seeing people in this thread lamenting that "There is no good way for LLMs to design/generate parametric STEP models yet", while I've spent the past 6 months working on this exact problem.
So, yesterday, I've had Astra build a moving assembly of Babbage's difference engine with it with 400+ parts and real parametric geometry, and you can also download the full STEP model assembly there.
Completely free and open source, you can use your own Claude/Codex to start vibe-coding and generate perfect STEP file right now.
So, no, it's not a matter of time on "when can AI do CAD", we are already here.
Sorry if I sound a little frustrated and a bit too self-promotion-y, but I just really want people who says "I wish this capability exists sometimes in the future" to know that it already does, and you can use it right now, for free.
this difference engine model has a lot of obvious flaws - the gears do not mesh with each other, the teeth directly overlap. the notches that are supposed to articulate to ratchet aren't actually engaging the teeth on the ratchet. the ratcheting mechanisms on the right are straight up just hovering in the air and are not attached to anything.
that's probably what people are talking about when they say it can't do CAD?
Complex assembly mating is hard to do even in SolidWorks. It's a demonstration model to explain how it works, not a kinematic simulation, turning three.js into a physics engine is beyond the scope of this project.
The only way to go from STL to BREP is through decompilation style recovery/reconstruction, because of the semantic information loss, so it's a task that can only be done via LLMs or human CAD users. Essentially, they pretty much have to remake the model from scratch using the STL as a reference to make the CAD. There really isn't a good way to automate this without machine learning/LLMs.
Fusion 360 can convert many STLs to BREP automatically. It can be slow and error prone but it does work. It will recognize large regularly curved areas and replace thousands of triangles with a single smooth curve.
Full code CAD capability with big coverage already and some functionalities that even OpenCascade/Parasolid/ACIS doesn't have, full sheet metal module, programmable part assembly, analytical fillets/chamfers, mathematical knots, auto-route for piping, built-in finite element analysis, etc. Had Astra make an improved version of the V8 demo that was going around on LinkedIn, so it can do general hard surface modeling pretty well too, turn all the Astra demo prowess into reusable capabilities/templates. The DSL is human writable too, so give it a try if you want.
https://aetheris-editable-v8.yuechenli.workers.dev/
I've said before that Carbon isn't a real programming language, never mind a successor to C++, so I decided to put my money where my mouth is. The idea of it is to be more TypeScript to C++'s JavaScript and to generalize C++20 concepts from template constraints to what C++26 is doing with contracts, and bring the equivalent of Rust's borrow checker to be opt-in by default instead of opt-out, fast compile time, in a syntax that C++ users are already familiar with (`const auto` instead of `let` for example) as well as templates and comptime. Language is done-ish, not self hosted yet, still compiles to C11, kernel and allocator libraries are finished, currently working on the scheduler right now.
TypeScript for .NET without all the weirdness of Javascript, with full Nuget and NPM inter-op, Rust style exhaustive `match`, templates, etc. It's actually weird how much cleaned up TypeScript ended up looking like cleaned up C++. Compiles to JS, C#, WASM via Blazor WebAssembly, and SPIR-V via HLSL/DXC, and runs on V8 for JS and RyuJIT/NativeAOT for C#. The conclusion is that RyuJIT ended up being ~2x faster than V8 JS in hot loops but the cold startup time is higher, so replacing JS for UI really isn't worth it. Comes with full UI layout system, Vulkan renderer, and game/app runtime, but those are still pretty rough.
I thought we solved the kudzu problem by having goats graze on them and rip them out by the roots, right? So maybe we should set goats on legacy git repos as well.
LLMs can be described as "Lagrangian intelligence", which means they follow the principle of least action when given a task (Hamilton's Principle). In other words, given a task, they will always take the shortest path to accomplish a goal with the prompts acting as both goal and constraint.
Under this formulation, it became easy to explain why they "hack", because given an arbitrarily difficult task with insufficient information/tools needed, if they determine the easiest way to accomplish the goal is to break out of the sandbox and look up the answer directly, then that's what they will do. The important thing to note is that prompts not hard constraints that they are "hypnotized" to follow, but as frontier models get more intelligent and autonomous, they treat the prompts more like task specs/guidelines more than anything else and are perfectly willing to exploit technical loopholes in the prompt.
Distilling frontier models is a brute force approach that rapidly hits diminishing returns after bootstrap because of the unevenness of the data. The simpler and more effective method is to have dedicated "teacher" frontier LLMs to generate targeted training data sets specifically for training new models and adjust on the fly based on feedback from the student model.
Interesting effect is that since DRAM production tooling has been switched from DDR/GDDR to HBM, we may finally see the proliferation of HBM in consumer GPUs/accelerators after the bust cycle starts.
reply