Lean is great. But these days with Aristotle you can check memory safety for other languages like C so it's not totally obvious it's worth rewriting everything in Rust.
> Or check SIGPLAN papers on machine learning based compilers.
Mind providing some examples? My (admittedly probably dated) understanding of how ML is used in compilers is for picking heuristics/thresholds/other things for which there's no known optimal "right" answer (e.g., pass order, inlining thresholds). Everything else was done in the "traditional" manner, which meant that the machine learning bits were, strictly speaking, completely optional. I haven't heard of compilers where ML techniques are integral to the process to the point where removing any ML bits would result in a nonfunctional compiler.
Rust is a terrible language for many of the tasks people try to shoehorn it into. As processors and memory get faster, garbage collection only becomes more attractive, while the borrow checker remains a PITA that gets in the way of plenty of sensible architectures. In a sane world, Rust will never take over frontend development, for example - it’s a terrible fit.
(I qualify with “in a sane world” because obviously it could happen. In a truly sane world, JavaScript would never have happened, either!)
> As processors and memory get faster, garbage collection only becomes more attractive, while the borrow checker remains a PITA that gets in the way of plenty of sensible architectures.
I’d counter with: as LLM driven coding becomes more and more common the PITA borrow checker is something individual developers interact with less than less. Garbage collection looks more and more like a waste when an LLM can examine memory allocations before the app is even built.
Maybe, but whatever workarounds or compromises the LLM has to settle on to satisfy the borrow checker will live in the code forever, while garbage collection can continue to get faster in the same executable.
Eh. In my experience any long-running Rust project will go through a lot of refactors, often driven by borrow checker issues. The only bright spot is that the compiler makes them relatively easy and safe. But it would be better not to have to do them in the first place if your architecture is already solid, just not in a way that the borrow checker understands.
> As processors and memory get faster, garbage collection only becomes more attractive
Just because they did in the past doesn't mean they will continue to do so in the future. If we are honest then Moore's Law ended a decade ago (the latest) and we've been picking the low hanging fruit we left alone during Moore's era since. This too will come to an end for sure, just not a pretty and well defined one.
So, my conclusion is the opposite. Garbage collected and DX optimized languages made sense while processors and memory got faster, the future will be elsewhere.
Did Moore’s Law really end? My ARM Mac from five years ago is a literal order of magnitude faster than a gigantic, beefy desktop tower from five years before that, and my newest ARM Mac from this year is another 5x or so faster than my first. Computers continue to get much, much faster, at least in terms of time to completion of normal workloads.
As processors and memory get faster, people will expect more from them. And the fact that languages like Rust give you fine-grained control over memory allocation is part of what allows it to be so performant on modern hardware where memory latency is still relatively high and bandwidth still relatively low. My intuition is that any data-intensive operation (such as blurring an image) will almost always be far faster in rust than javascript.
I think most of those tradeoffs flip as more of the engineering is done by AI systems. I think that's true on its own, but it's especially true if those systems are increasingly capable of autonomously verifying their own correctness.
I'm not advocating for Rust (or against it), I'm just stating that currently it's hard to open the news without seeing Rust expanding somewhere, and it feels like "taking over the world". Whether that is bad or good is another question.
And yeah, it feels a bit like JavaScript a while ago, that's a good comparison.
No language that perfectly fills that niche exists, because none was ever needed. JavaScript eventually became Good Enough. Python is OK, but it’s an old language at this point and it suffers a lot of technical debt.
JavaScript’s biggest weakness IMO is its absolutely abysmal standard library, particularly in terms of data structures. (At least we have Map and Set now, but still no way to define a hash/equality function for a type…) The situation is so bad that essentially any other modern programming language would be an improvement.
That's true and there are some truly high throughput systems that absolutely benefit from garbage collection (I've written one of them, and can't sing enough praises of not one but several java garbage collection types), but there are two problems here:
1) most garbage collectors are pretty lame and can't even come close to the throughput/efficiency of manually managed memory, and
2) the vast majority of software does not even come close to the frontier of what is possible with software, and therefore the thing that matters most is correctness.
Rust does a better job at correctness than most languages because the type system is so robust, and it does a better job at memory management than most languages because most languages do garbage collection so poorly.
I don’t think you can do a “you’re holding it wrong” with UI code when it seems like every UI framework eventually evolves to let people hold it that way. People find it difficult to build fully-featured UI frameworks in Rust, and people writing UIs don’t tend to pick Rust frameworks. They aren’t wrong for that!
2. I think they still are _somewhat_ informative. Like, the same model may produce very different pelicans at different reasoning efforts, even though the training data is the same. So looking at pelicans may give you _some_ information (like "what reasoning effort I want to use that model with?".
NVIDIA has not delivered useful AI applications either, yet it clearly is one of the main AI companies, and while many are struggling to turn their AI applications into reliable revenue streams, NVIDIA has a viable business model.
So does Apple even need to create applications (that nowadays will get copied and opensourced in a day), or the hardware is the winning strategy in the end?
Right. So far hardware has been the real winner. The rest is still a promise.
I think the more interesting question for Apple is the split between cloud and local. Economies of scale and aggregation vs privacy and ownership. I’d say so far it’s 2-1.
NVIDIA GR00T, Omniverse, Cosmos. Their local AI stuff for streaming is good and free, and while not a revenue stream, it's all just more reasons to go with NVIDIA cards over others when building a gaming PC.
"The state of the world economy and the future of open models would be in turmoil due to the affairs of a person who's not even a politician" was not on my 2026 bingo card.
So, the highest score so far but also the highest "cost per task" so far, and pretty slow... which, I guess, makes it the Cybertruck of language models. Impressive in its own way, but impractical for most people (me included). Sticking to Opus for now.
That's technically impressive, sure, and if the kid loved it I feel happy for him, but...
I personally got bored after a minute of playing that, because that felt like a classic game with a slick skin over it. And games that really capture attention usually feel novel, not "Super Mario but make it about Dario".
Currently "oh wow I'm in the game" has the novelty value, but I feel that in two years that would feel like telling Nano Banana "make me look like a princess". Everyone can do that and no one quite cares anymore.
But the bright side is, with that capabilities level, people who have novel and unusual game ideas can probably implement them much quicker and easier, too.
I'm interested in African culture, but I've never been to Ghana.
This project is useful for me, playing local games is much more immersive than reading about games. But some polish would help, too. Currently it's a project that's interesting to click through once, but I feel that it has a potential to be repeatedly playable.
If you were actually involved in that work pre-LLM, you know it didn't go in a circle. Most projects died at training data and problem definition. That isn't the case with LLM applications which can ship with zero data collection and labelling effort.
Now you can iterate on your 20 ticket categories in days against real workloads and not commit to training an efficient model until you've proven the prototype in production.
That also makes me wonder: what other things are achieved by now and are up for grabs, and that will seem obvious in retrospect, but we don't notice it yet?
Roughly speaking, has AGI actually been achieved two years ago and we go around don't noticing that?
reply