But Google loses $11 billion per year, and they gain $50 billion... in stock?
As far as I know they really will be paying $11 billion annually in liquid cash to SpaceX (not a small ask) starting this year, and all they get in return is more money on paper?
What incentive do they have to help SpaceX out like this at great cost, if they're not actually buying something valuable? Why are they incentivized to do this if it's just an empty deal and financial engineering? Genuine, good faith question: what are they getting out of this?
The contract has an exit clause, either side can terminate the agreement with 90 days notice. I do not expect this contract to last the full 3-year term.
And this deal protects Google's investment. Google owns close to $100 billion of SpaceX stock. This deal increases SpaceX's revenue by 30%, and pushes SpaceX into profitability. With this deal, SpaceX is eligible for S&P inclusion. Assuming $6-7 trillion in S&P 500 tracked funds, and a 1% SpaceX weight after a year, this is $600-700 billion in demand for SpaceX stock. It means Google now has someone to unload its position off to. This play directly protects Google's investments.
SpaceX announced $26B/year in compute deals with Anthropic and Google in the past week. The margins on both deals are incredibly high, Google is paying around $11.75/hour per GPU. Infrastructure costs are far below that, SpaceX likely has 70-90% margins. These two deals are around $20B/year profit. In the preliminary S-1, SpaceX reported a $5B loss in 2025. Combining these numbers, that's a $15B profit, assuming losses are constant. Likely expenditures will increase, but even if losses double, that's a very healthy $10B profit.
Where did you get your costs and margins from? I have direct experience in this business and I can tell you they’re usually not that high. These machines are also not cheap to power, cool, and house.
As a comparison point, CoreWeave’s most recently reported operating margin was 16%.
That's what I'm saying though. They must be getting something out of this deal, otherwise why would they be going through with it?
The explanation that this is just financial engineering (which to me, means neither Google nor SpaceX is getting anything out of this other than looking better on paper) doesn't make sense to me. How does this financial engineering benefit Google?
Even if they have an exit option, why is Google (a private, separate, self-interested firm) giving a single dollar to SpaceX if the deal isn't mutually beneficial?
They’re getting compute. There was a free for all period when xAI did one smart thing and that’s build like there’s no tomorrow. Because tomorrow is today, and today jurisdictions are racing to pause datacenter construction.
This deal can't just be financial engineering, since that wouldn't make sense. They must be getting something out of this, i.e. compute.
Google is buying compute because they need it. That explanation works a lot better to me than one where Google is doing this purely for unrealized future gains on a minority stake in SpaceX.
the ironic thing is if the parties involved were bullish on xAI winning or near term ODCs undercutting compute costs this deal wouldn't have been attractive. But as it is, Google probably only slightly overpays for boring ground-based datacenter space they actually need to hit internal goals, and it looks even better if IPO investors in a stock they hold pick up some of the the tab.
That $5 return doesn't actually materialize the way you're framing it.
Even if your 94x multiple held perfectly (a big if), Google's "return" here is unrealized appreciation on an illiquid, minority stake. They can't spend it. And if they try to sell post-IPO, the act of selling a large block would push the price down, shrinking the very gains you're describing.
Meanwhile, the $11B/year in cash going out the door is very real and liquid and hits Google's income statement immediately. So the actual trade is: guaranteed cash expense now, in exchange for speculative paper gains later on a stake they can't easily exit. Even if you assume bad faith on Google's part here, no CFO in their right mind would see this situation as an easy 5:1 return.
The simpler explanation is the one Google gave: they need bridge compute capacity because Gemini Enterprise demand is outrunning their own datacenter buildout, and SpaceX has 110K GPUs available now.
So you think Google is going to spend $11B in hopes it will boost the value of the SpaceX stock, while pretending to public investors it's a multi-year thing, and then after 1yr sell off their SpaceX stock after the value rises while also ending the contract early?
they're spending $11B on compute because they need the compute and that's the market rate for it. it's the same price Anthropic is paying to spacex for compute.
but if they boost the spacex stock for the right amount of time, they can get that compute for free instead of for $11B. Google's own announcement of the deal frames it as a short-term agreement while they scale up their own datacenter capacity.
They also get compute, which has real value. If you are going to spend 11B on new data centers or rental, better to spend with a a company you are about to ipo.
Either way, 500% return on the spend would be amazing
Unrelated, but this post has a level of rigor you rarely see nowadays. I think it deserves to be commended for that.
HN relatively, is a very intellectual part of the internet, yet even still, it's really common to see very uneducated opinions here. Not that everyone needs to be very educated, but posts with plainly wrong assumptions and biases shouldn't go completely unchecked so rampantly.
More than React, I'm interested in the question of how to best write UI through code, in general.
Even though I'm a fan of React, and use it for practically every web application I build, my biggest and most obvious issue has been that writing UIs through React doesn't feel as natural as, say, writing command line tools in Go, or live/realtime apps in Elixir.
Some languages just feel incredibly natural and frictionless for certain things, and nobody has really nailed UIs yet. Swift, JSX/HTML, Svelte, or whatever framework of the week: they all feel like they're working around the problem to some extent. Like at some point in the process, the designers of the language/framework had to compromise and implement some hacky/weird/painful syntax to satisfy project requirements.
UI's natural interface is visual, so tools like Figma can serve as an essential part of the solution, but nonetheless, I feel there's something missing. There must be a more intuitive way to represent the visual through code. The current solutions, although I find it hard to describe precisely, are always tantalizingly lacking in one way or another.
I don’t think UI’s natural interface is visual. I think the natural interface is a state machine.
The most reliable and performant UI code I’ve written usually tackles this head on by thinking through all the possibilities of different states the application can be in and how the transition of each state should look. This can very quickly get mind boggling complex.
Systems programming languages seem like they model their problems better because it’s less common to ask a systems programmer for a like button that shows bubbles when you press it. If you model your UI explicitly like a state machine, you can say “no” to the bubbles like every systems programmer says “no” to most features, because you realize the explosion of state will be unmanageable. Or you can use a JavaScript framework and download a bubbles package and wonder why your app is buggy, but have job security.
I feel similarly. I really liked React when it came out because compared to the alternatives at the time, it just felt perfect.
I still prefer it over almost everything, including Svelte, Vue and Solid. But I have started using Crank (https://crank.js.org/) which seems a step closer to where I want to end up. However, I have so far only used it for toy projects so I can't speak to how well it will scale, both in terms of performance and DX.
As an engineer, it's easy to look at every problem and think to yourself: "There is a perfect solution for this, we just haven't found it yet."
Yet, as the years go by, I find myself accepting a less idealistic answer: Maybe there isn't. Maybe the problem space is just so complex that no one (humanly feasible) general solution exists for all forms of it. If there's one thing that this is true for, UI is probably it.
Years are a pretty short time frame as it relates to technology, though. Even for software.
The solution might be well out of grasp now, but think 10, 20, 100 years from now. Somebody smart with a new perspective will eventually come around and tear out the roots, and we'll all be better for it. Perhaps what's holding us back isn't the problem itself, but the way we approach it and the assumptions we bring.
Trying is at least worth the effort, especially since "better" is very achievable, rather than total perfection.
> Some languages just feel incredibly natural and frictionless for certain things, and nobody has really nailed UIs yet.
Emphatically yes. If you look at books written about the problem in the early 90s[1], they are still applicable today.
> The current solutions, although I find it hard to describe precisely, are always tantalizingly lacking in one way or another.
The best analysis of this I have seen so far is in Chatty's Programs = Data + Algorithms + Architecture: consequences for interactive software engineering [2]. It's a bit hard to get through, but absolutely worth it.
As a short summary, the problem is architectural, or more specifically linguistic/architectural mismatch: the architecture our "general purpose" programming languages induces, which is the call/return architectural style, does not match the architecture required for user interfaces, but rather conflicts with that style.
I also wrote about it in Can Programmers Escape the Gentle Tyranny of call/return?.
My current approach is to first build a programming language that can easily express alternative architectural styles: Objective-Smalltalk [4].
With that I am now working an a UI framework I call interscript, including HTMXNative and other goodies.
> This whole thread is an overreaction. 302 comments about code that does not work. We haven’t committed to rewriting. There’s a very high chance all this code gets thrown out completely.
I would say it is reasonably clear they had already committed to rewriting at that point.
The possibility that that particular code might be thrown out was potentially true, but also totally unrelated to the previous statement.
At the end of the day, whatever, but this feels a heck of a lot like “ah, we didn't mean for this to be public yet” rather than “this is just a random experiment”.
Software is only as good as the end result; it doesn't matter how we get there.
There is reason to be suspicious of LLMs, but people should stop getting so wrought up over _how_ the Bun team writes their software, until they have complaints over the software itself.
Just let the team do their thing. You're free to reject the end result.
I agree, if the code gets tested endlessly, and audited, and nobody, not even the LLM can find major jarring issues with it, it compiles, builds, and works as expected, isn't degraded in any way, I don't think I care how you built the "new" rendition of the software.
Can you setup wildcards? Like for example *.[name].san-fransisco.ca.us? That way I can do this once for my own name and have it setup for all future needs as well.
People are trying to “make the best software”, though.
I think the Quixotic accelerationists of AI are more or less a vocal minority of the people who make software, and the choice of online APIs over local systems is largely a choice made for users, rather than developer’s laziness.
You can do more and better with private AI today than with local models. There is no getting around that. Even if local AIs get better, being on the cutting edge of LLM performance is often a very worthy investment.
Most people won’t settle for a product if it’s not the very best and incredibly convenient. That’s a high bar, and local AI often doesn’t meet those standards.
HN’s insistence on treating all users like they are open-source, privacy-first, self-hosted Linux fanatics is painfully corny.
The prerequisite to starting is having a working instrument (roughly) in tune. Then you can start. If you don't know absolutely anything at all, then it wouldn't be so bad to learn some things in parallel to learning by ear, such as basic chord shapes. But you can get started with trying to transcribe happy birthday by ear. Try to play it and find the notes. After a few nusrsery rhymes, you can move on to something simple that is perhaps more inspiring. But to answer your question, you start by taking the first step.
I guess I'll say that minicomputer and mainframe implementations of languages like Pascal and FORTRAN and COBOL and even BASIC back in the 1970s were frequently built with interoperability in mind, like you bought all the compilers in one big bundle. (Maybe like gcc or the the llvm-based compiler suite today?) It might have been easier because most of these languages had minimal runtime systems and the science of activation records and language implementation was mostly figured out by 1975 when Scheme came out with closures.
More modern languages have data structures that are similar but different that are a challenge. For instance the list types in Java and Python as they are used in common software are similar in a lot of ways but different. C has arrays in the stdlib but not that kind of expandable list, C developers might write their own or get one out of a library, I guess C++ has std::list but that doesn't have a fast way to get the n-th element of a list. Common Lisp has its own idea of a "list" and Clojure lives in the JVM and can access a Java List just fine but has its own immutable list which has a totally different API than thoses other language (e.g. no nconc!)
In general it is not so hard to access those objects through the 'foreign function API' or whatever you have but you either write stuff in the host language which is built especially to work with the guest language, or you make a wrapper, or you copy the data structures wholesale. It is never going to be trivial.
Similarly a language like Java has garbage collection and Python and Rust have their own forms of reference counting, either way you will either do your own memory management in the guest language or use some APIs to participate in the memory management of the host but it is a hassle.
For a long time the standard architecture for complex systems has been a scripting language + a systems language. Like Lua and C or Python and C or maybe Clojure and Java.
As far as I know they really will be paying $11 billion annually in liquid cash to SpaceX (not a small ask) starting this year, and all they get in return is more money on paper?
What incentive do they have to help SpaceX out like this at great cost, if they're not actually buying something valuable? Why are they incentivized to do this if it's just an empty deal and financial engineering? Genuine, good faith question: what are they getting out of this?