The HDMI Forum, re­spon­si­ble for the HDMI spec­i­fi­ca­tion, con­tin­ues to stonewall open source. Valve’s Steam Machine the­o­ret­i­cally sup­ports HDMI 2.1, but the mini-PC is soft­ware-lim­ited to HDMI 2.0. As a re­sult, more than 60 frames per sec­ond at 4K res­o­lu­tion are only pos­si­ble with lim­i­ta­tions.

In a state­ment to Ars Technica, a Valve spokesper­son con­firmed that HDMI 2.1 sup­port is “still a work-in-progress on the soft­ware side.” “We’ve been work­ing on try­ing to un­block things there.”

The Steam Machine uses an AMD Ryzen APU with a Radeon graph­ics unit. Valve strictly ad­heres to open-source dri­vers, but the HDMI Forum is un­will­ing to dis­close the 2.1 spec­i­fi­ca­tion. According to Valve, they have val­i­dated the HDMI 2.1 hard­ware un­der Windows to en­sure ba­sic func­tion­al­ity.

The re­stric­tion im­posed by the HDMI Forum was al­ready crit­i­cized in early 2024 by an AMD em­ployee re­spon­si­ble for Linux. Even then, ac­cord­ing to AMD, they had sub­mit­ted a func­tional, HDMI 2.1-compatible dri­ver, which the HDMI Forum re­jected.

“Unfortunately, the HDMI Forum re­jected our pro­posal,” it was stated at the time. “At this time an open source HDMI 2.1 im­ple­men­ta­tion is not pos­si­ble with­out run­ning afoul of the HDMI Forum re­quire­ments.”

Only HDMI 2.1 of­fers suf­fi­cient band­width for 120 or 144 Hertz at 3840 × 2160 pix­els with­out com­pres­sion. Furthermore, this ver­sion in­tro­duced man­u­fac­turer-in­de­pen­dent vari­able re­fresh rates (HDMI VRR). Valve en­ables 4K and 120 Hertz us­ing chroma sub­sam­pling, a com­pres­sion tech­nique that is par­tic­u­larly no­tice­able with text. VRR func­tions in the form of AMD’s Freesync, which re­quires com­pat­i­ble dis­plays.

Alternatively, in­ter­ested par­ties can use an ac­tive adapter from DisplayPort 1.4 to HDMI 2.1 to in­crease the frame rate with­out com­pres­sion. However, they do not of­fi­cially sup­port VRR. Popular vari­ants from Club3D are no longer avail­able; of­fers from less well-known providers (starting from 35,67 €) are still avail­able in price com­par­isons.

Last week, I started work­ing on a new side-pro­ject. It’s a stan­dard React app partly made up of run-of-the-mill CRUD views—a per­fect fit for LLM-assisted pro­gram­ming. I rea­soned that if I could get an LLM to quickly write the bor­ing code for me, I’d have more time to fo­cus on the in­ter­est­ing prob­lems I wanted to solve.

I’ve pretty much set­tled on Claude Code as my cod­ing as­sis­tant of choice, but I’d been hear­ing great things about Google’s Gemini 3 Pro. Despite my aver­sion to Google prod­ucts, I de­cided to try it out on my new code­base.

I al­ready had Gemini CLI in­stalled, but that only gave me ac­cess to Gemini 2.5 with rate lim­its. I wanted to try out Gemini 3 Pro, and I wanted to avoid be­ing rate lim­ited. I had some spare cash to burn on this ex­per­i­ment, so I went look­ing for ways to pay for a Gemini Pro plan, if such a thing ex­isted.

Thus be­gan my grand ad­ven­ture in try­ing to give Google my money.

The name “Gemini” is so over­loaded that it barely means any­thing. Based on the con­text, Gemini could re­fer to:

To make things even more con­fus­ing, Google has at least three dif­fer­ent prod­ucts just for agen­tic cod­ing: Gemini Code Assist (Gemini CLI is a part of this suite of prod­ucts), Jules, and Antigravity.

And then there’s a bunch of other GenAI stuff that is pow­ered by Gemini but does­n’t have the word Gemini in the name: Vertex AI Platform, Google AI Studio, NotebookLM, and who knows what else.

I just wanted to plug my credit card in­for­ma­tion into a form and get ac­cess to a cod­ing as­sis­tant. Instead, I was dunked into an al­pha­bet soup of prod­ucts that all seemed to do sim­i­lar things and, cru­cially, did­n’t have any gi­ant “Buy Now!” but­tons for me to click.

In con­trast, both Anthropic and OpenAI have two pri­mary ways you can ac­cess their prod­ucts: via their con­sumer of­fer­ings at claude.ai and chat­gpt.com re­spec­tively, or via API cred­its that you can buy through their re­spec­tive de­vel­oper con­soles. In each case, there is a form field where you can plug in your credit card de­tails, and a big, friendly “Buy Now!” but­ton to click.

After half an hour of search­ing the web, I did the ob­vi­ous thing and asked the free ver­sion of Gemini (the chat­bot, not one of those other Geminis) what to do:

How do I pay for the pro ver­sion of Gemini so i can use it in the ter­mi­nal for writ­ing code? I specif­i­cally want to use the Gemini 3 Pro model.

It thought for a sus­pi­ciously long time and told me that Gemini 3 Pro re­quired a de­vel­oper API key to use. Since the new model is still in pre­view, it’s not yet avail­able on any of the con­sumer plans. When I asked fol­low up ques­tions about pric­ing, it told me that “Something went wrong”. Which trans­lates to: we broke some­thing, but we won’t tell you how to fix it.

So I asked Claude for help. Between the two LLMs, I was able to fig­ure out how to cre­ate an API key for the Gemini I wanted.

Google AI Studio is sup­posed to be the all-in-one dash­board for Google’s gen­er­a­tive AI mod­els. This is where you can ex­per­i­ment with model pa­ra­me­ters, man­age API keys, view logs, and man­age billing for your pro­jects.

I logged into Google AI Studio and cre­ated a new API key. This part was pretty straight­for­ward: I fol­lowed the on-screen in­struc­tions and had a fresh new key housed un­der a pro­ject in a few sec­onds. I then ver­i­fied that my key was work­ing with Gemini CLI.

It worked! Now all that was left to do was to pur­chase some API cred­its. Back in Google AI Studio, I saw a link ti­tled “Set up billing” next to my key. It looked promis­ing, so I clicked it.

That’s where the fun re­ally be­gan.

The “Set up billing” link kicked me out of Google AI Studio and into Google Cloud Console, and my heart sank. Every time I’ve logged into Google Cloud Console or AWS, I’ve wasted hours upon hours read­ing out­dated doc­u­men­ta­tion, gaz­ing in de­spair at graphs that make no sense, go­ing around in cir­cles from dash­board to dash­board, and feel­ing a strong de­sire to at­tain free­dom from this mor­tal coil.

Turns out I can’t just put $100 into my Gemini ac­count. Instead, I must first cre­ate a Billing Account. After I’ve done that, I must as­so­ci­ate it with a pro­ject. Then I’m al­lowed to add a pay­ment method to the Billing Account. And then, if I’m lucky, my API key will turn into a paid API key with Gemini Pro priv­i­leges.

So I did the thing. The whole song and dance. Including the manda­tory two-fac­tor OTP ver­i­fi­ca­tion that every Indian credit card re­quires. At the end of the process, I was greeted with a popup telling me I had to ver­ify my pay­ment method be­fore I’d be al­lowed to use it.

Wait. Didn’t I just ver­ify my pay­ment method? When I en­tered the OTP from my bank?

Nope, turns out Google hungers for more data. Who’d have thunk it?

To ver­ify my pay­ment method for re­als, I had to send Google a pic­ture of my gov­ern­ment-is­sued ID and the credit card I’d just as­so­ci­ated with my Billing Account. I had to en­sure all the num­bers on my credit card were redacted by man­u­ally plac­ing black bars on top of them in an im­age ed­i­tor, leav­ing only my name and the last four dig­its of the credit card num­ber vis­i­ble.

This felt un­nec­es­sar­ily in­tru­sive. But by this point, I was too deep in the process to quit. I was in­vested. I needed my Gemini 3 Pro, and I was will­ing to pay any price.

The up­load form for the gov­ern­ment ID re­jected my up­load twice be­fore it fi­nally ac­cepted it. It was the same ex­act ID every sin­gle time, just in dif­fer­ent file for­mats. It wanted a PNG file. Not a JPG file, nor a PDF file, but a PNG file. Did the up­load form men­tion that in the in­struc­tions? Of course not.

After jump­ing through all these hoops, I re­ceived an email from Google telling me that my ver­i­fi­ca­tion will be com­pleted in a few days.

A few days? Nothing to do but wait, I sup­pose.

At this point, I closed all my open Cloud Console tabs and went back to work. But when I was fif­teen min­utes into writ­ing some code by hand like a Neanderthal, I re­ceived a sec­ond email from Google telling me that my ver­i­fi­ca­tion was com­plete.

So for the tenth time that day, I nav­i­gated to AI Studio. For the tenth time I clicked “Set up billing” on the page list­ing my API keys. For the tenth time I was told that my pro­ject was­n’t as­so­ci­ated with a billing ac­count. For the tenth time I as­so­ci­ated the pro­ject with my new billing ac­count. And fi­nally, af­ter do­ing all of this, the “Quota tier” col­umn on the page list­ing my API keys said “Tier 1” in­stead of “Set up billing”.

Wait, Tier 1? Did that mean there were other tiers? What were tiers, any­way? Was I al­ready on the best tier? Or maybe I was on the worst one? Not im­por­tant. The im­por­tant part was that I had my API key and I’d man­aged to con­vince Google to charge me for it.

I went back to the Gemini CLI, ran the /settings com­mand, and turned on the “Enable ex­per­i­men­tal fea­tures” op­tion. I ran the /models com­mand, which told me that Gemini 3 Pro was now avail­able.

When I tried send­ing a mes­sage to the LLM, it failed with this 403 er­ror:

“error”: {

“message”: “{\n "error": {\n \“code\”: 403,\n \“message\”: \“The caller does not have per­mis­sion\”,\n \“status\”:\“PERMISSION_DENIED\“\n }\n}\n”,

“code”: 403,

“status”: “Forbidden”

Is that JSON in­side a string in­side JSON? Yes. Yes it is.

To fig­ure out if my key was even work­ing, I tried call­ing the Gemini API from JavaScript, re­pro­duc­ing the ba­sic ex­am­ple from Google’s own doc­u­men­ta­tion.

No dice. I ran into the ex­act same er­ror.

I then tried talk­ing to Gemini 3 Pro us­ing the Playground in­side Google AI Studio. It showed me a toast mes­sage say­ing Failed to gen­er­ate con­tent. Please try again. The chat tran­script said An in­ter­nal er­ror has oc­curred.

At this point I gave up and walked away from my com­puter. It was al­ready 8pm. I’d been try­ing to get things to work since 5pm. I needed to eat din­ner, play Clair Obscur, and go to bed. I had no more time to waste and no more fucks to give.

Just as I was get­ting into bed, I re­ceived an email from Google with this sub­ject line:

Your Google Cloud and APIs billing ac­count XXXXXX-XXXXXX-XXXXXX is in good stand­ing at this time.

With the mes­sage in­side say­ing:

Based on the in­for­ma­tion you pro­vided and fur­ther analy­sis by Google, we have re­in­stated your billing ac­count XXXXXX-XXXXXX-XXXXXX. Your ac­count is in good stand­ing, and you should now have full ac­cess to your ac­count and re­lated Project(s) and Service(s).

I have no idea what any of this means, but Gemini 3 Pro started work­ing cor­rectly af­ter I re­ceived this email. It worked in the Playground, di­rectly by call­ing the API from JavaScript, and with Gemini CLI.

Problem solved, I guess. Until Google mys­te­ri­ously de­cides that my ac­count is no longer in good stand­ing.

This was such a frus­trat­ing ex­pe­ri­ence that I still haven’t tried us­ing Gemini with my new code­base, nearly a week af­ter I made all those sac­ri­fices to the Gods of Billing Account.

I un­der­stand why the process for get­ting a Gemini API key is so con­vo­luted. It’s de­signed for large or­ga­ni­za­tions, not an in­di­vid­ual de­vel­op­ers try­ing to get work done; it serves the bu­reau­cracy, not the peo­ple do­ing the work; it’s de­signed for max­i­mum com­pli­ance with gov­ern­ment reg­u­la­tions, not for ef­fi­ciency or pro­duc­tiv­ity.

Google does­n’t want my money un­less I’m an or­ga­ni­za­tion that em­ploys ten thou­sand peo­ple.

In con­trast to Google, Anthropic and OpenAI are much smaller and much more nim­ble. They’re able to make the process of set­ting up a de­vel­oper ac­count quick and easy for those of us who just want to get things done. Unlike Google, they haven’t yet be­come com­pla­cent. They need to com­pete for de­vel­oper mind­share if they are to sur­vive a decade into the fu­ture. Maybe they’ll add the same level of bu­reau­cracy to their processes as they be­come larger, but for now they’re fairly easy to deal with.

I’m still go­ing to try us­ing Gemini 3 Pro with Gemini CLI as my cod­ing as­sis­tant, but I’ll prob­a­bly cap the ex­per­i­ment to a month. Unless Gemini 3 Pro is a mas­sive im­prove­ment over its com­peti­tors, I’ll stick to us­ing tools built by or­ga­ni­za­tions that want me as a cus­tomer.

In September of 2024, Israel blew up boo­bie trapped pagers be­long­ing to Hezbollah fig­ures in pub­lic places in Lebanon, killing 12 peo­ple, in­clud­ing two chil­dren and two health­care work­ers, and in­jur­ing 2,800.

The at­tack was fol­lowed by an­other at­tack us­ing ex­plo­sives in walkie-talkies that killed 25 peo­ple and in­jured an­other 600.

The Associated Press re­ported that the at­tacks “wounded many civil­ians” and that sur­vivors are left “with miss­ing eyes, faces laced with scars, hands with miss­ing fin­gers”.

The United Nations at the time noted that the at­tacks “constitute war crimes of mur­der, at­tack­ing civil­ians, and launch­ing in­dis­crim­i­nate at­tacks, in ad­di­tion to vi­o­lat­ing the right to life” adding that, “Around 500 peo­ple suf­fered se­vere eye in­juries, in­clud­ing a diplo­mat. Others suf­fered grave in­juries to their faces, hands and bod­ies” and that “It is also a war crime to com­mit vi­o­lence in­tended to spread ter­ror among civil­ians, in­clud­ing to in­tim­i­date or de­ter them from sup­port­ing an ad­ver­sary, A cli­mate of fear now per­vades every­day life in Lebanon”.

At the time, when asked about the at­tacks, for­mer CIA di­rec­tor Leon Panetta said, “I don’t think there’s any ques­tion that it’s a form of ter­ror­ism”.

Now, a new book qui­etly re­veals that Israel car­ried out the ter­ror­ist at­tack with the help of the AI sur­veil­lance firm Palantir, led by Alex Karp and Peter Thiel.

In the new bi­og­ra­phy of Palantir co-founder Alex Karp, “The Philosopher in the Valley: Alex Karp, Palantir, and the Rise of the Surveillance State,” by New York Times jour­nal­ist Michael Steinberger, he writes that prior to the geno­cide in Gaza, “the Mossad had been us­ing Palantir tech­nol­ogy,” adding that the Shin Bet and IDF, “ sought to ob­tain Palantir’s soft­ware in the wake of Ocotber 7th”.

He goes on to write that, “The de­mand for Palantir’s as­sis­tance was so great that the com­pany dis­patched a a team of en­gi­neers from London to help get Israeli users on­line,” adding, “Palantir ended up hav­ing to rent a sec­ond-floor build­ing that housed its Tel Aviv of­fice, to ac­com­mo­date the in­tel­li­gence an­a­lysts who needed tu­to­ri­als”.

Revealing what Israel used the AI-powered soft­ware for, Michael Steinberger notes, “Its soft­ware was used by the Israeli mil­i­tary in sev­eral raids in Gaza” and goes on to write that, “The com­pa­ny’s tech­nol­ogy was de­ployed by the Israelis dur­ing mil­i­tary op­er­a­tions in Lebanon in 2024 that dec­i­mated Hezbollah’s top lead­er­ship” adding that, “It was also used in Operation Grim Beeper, in which hun­dreds of Hezbollah fight­ers were in­jured and maimed when their pagers and walkie-talkies ex­ploded (the Israelis had booby trapped the de­vices)”.

Francesca Albanese, the United Nations’ Special Rapporteur on the sit­u­a­tion of hu­man rights in the Palestinian Territory, oc­cu­pied since 1967, doc­u­mented Palantir’s role in the geno­cide in Gaza, not­ing, “In January 2024, Palantir an­nounced a new strate­gic part­ner­ship with Israel and held a board meet­ing in Tel Aviv “in sol­i­dar­ity”; in April 2025, Palantir’s Chief Executive Officer re­sponded to ac­cu­sa­tions that Palantir had killed Palestinians in Gaza by say­ing, ‘mostly ter­ror­ists, that’s true’. Both in­ci­dents are in­dica­tive of ex­ec­u­tive-level knowl­edge and pur­pose vis-à-vis the un­law­ful use of force by Israel, and fail­ure to pre­vent such acts or with­draw in­volve­ment.”

Now it is re­vealed that the AI soft­ware was used in Israel’s ter­ror­ist at­tack in Lebanon as well.

In a re­cent in­ter­view, the for­mer head of the Israeli Mossad, Yossi Cohen, re­vealed that Israel has sim­i­lar “booby-trapped and spy-ma­nip­u­lated equip­ment” in “all the coun­tries you can imag­ine”.

The fact that a com­pany as in­flu­en­tial as Palantir was in­volved in the ter­ror­ist at­tacks makes these com­ments even more con­cern­ing.

Note to read­ers: The Dissident is a reader-sup­ported out­let. If you liked this ar­ti­cle, con­sider be­com­ing a paid sub­scriber.

Yesterday I stum­bled on this HN thread Show HN: Gemini Pro 3 hal­lu­ci­nates the HN front page 10 years from now, where Gemini 3 was hal­lu­ci­nat­ing the front­page of 10 years from now. One of the com­ments struck me a bit more though - Bjartr linked to the HN front­page from ex­actly 10 years ago, i.e. December 2015. I was read­ing through the dis­cus­sions of 10 years ago and men­tally grad­ing them for pre­science when I re­al­ized that an LLM might ac­tu­ally be a lot bet­ter at this task. I copy pasted one of the ar­ti­cle+com­ment threads man­u­ally into ChatGPT 5.1 Thinking and it gave me a beau­ti­ful analy­sis of what peo­ple thought + what ac­tu­ally hap­pened in ret­ro­spect, even bet­ter and sig­nif­i­cantly more de­tailed than what I was do­ing man­u­ally. I re­al­ized that this task is ac­tu­ally a re­ally good fit for LLMs and I was look­ing for ex­cuses to vibe code some­thing with the newly re­leased Opus 4.5, so I got to work. I’m go­ing to get all the front pages of December (31 days, 30 ar­ti­cles per day), get ChatGPT 5.1 Thinking to do the analy­sis, and pre­sent every­thing in a nice way for his­tor­i­cal read­ing.

There are two macro rea­sons for why I think the ex­er­cise is in­ter­est­ing more gen­er­ally:

I be­lieve it is quite pos­si­ble and de­sir­able to train your for­ward fu­ture pre­dic­tor given train­ing and ef­fort.

I was re­minded again of my tweets that said “Be good, fu­ture LLMs are watch­ing”. You can take that in many di­rec­tions, but here I want to fo­cus on the idea that fu­ture LLMs are watch­ing. Everything we do to­day might be scru­ti­nized in great de­tail in the fu­ture be­cause do­ing so will be “free”. A lot of the ways peo­ple be­have cur­rently I think make an im­plicit “security by ob­scu­rity” as­sump­tion. But if in­tel­li­gence re­ally does be­come too cheap to me­ter, it will be­come pos­si­ble to do a per­fect re­con­struc­tion and syn­the­sis of every­thing. LLMs are watch­ing (or hu­mans us­ing them might be). Best to be good.

Vibe cod­ing the ac­tual pro­ject was rel­a­tively pain­less and took about 3 hours with Opus 4.5, with a few hick­ups but over­all very im­pres­sive. The repos­i­tory is on GitHub here: karpa­thy/​hn-time-cap­sule. Here is the pro­gres­sion of what the code does:

* Given a date, down­load the front­page of 30 ar­ti­cles

* For each ar­ti­cle, down­load/​parse the ar­ti­cle it­self and the full com­ment thread us­ing Algolia API.

* Package up every­thing into a mark­down prompt ask­ing for the analy­sis. Here is the prompt pre­fix I used:

The fol­low­ing is an ar­ti­cle that ap­peared on Hacker News 10 years ago, and the dis­cus­sion thread.

Let’s use our ben­e­fit of hind­sight now in 6 sec­tions:

1. Give a brief sum­mary of the ar­ti­cle and the dis­cus­sion thread.

2. What ended up hap­pen­ing to this topic? (research the topic briefly and write a sum­mary)

3. Give out awards for “Most pre­scient” and “Most wrong” com­ments, con­sid­er­ing what hap­pened.

4. Mention any other fun or no­table as­pects of the ar­ti­cle or dis­cus­sion.

5. Give out grades to spe­cific peo­ple for their com­ments, con­sid­er­ing what hap­pened.

6. At the end, give a fi­nal score (from 0-10) for how in­ter­est­ing this ar­ti­cle and its ret­ro­spect analy­sis was.

As for the for­mat of Section 5, use the header “Final grades” and fol­low it with sim­ply an un­ordered list of peo­ple and their grades in the for­mat of “name: grade (optional com­ment)”. Here is an ex­am­ple:

Final grades

- speckx: A+ (excellent pre­dic­tions on …)

- tosh: A (correctly pre­dicted this or that …)

- keep­amovin: A

- bg­wal­ter: D

- fs­flover: F (completely wrong on …)

Your list may con­tain more peo­ple of course than just this toy ex­am­ple. Please fol­low the for­mat ex­actly be­cause I will be pars­ing it pro­gram­mat­i­cally. The idea is that I will ac­cu­mu­late the grades for each ac­count to iden­tify the ac­counts that were over long pe­ri­ods of time the most pre­scient or the most wrong.

As for the for­mat of Section 6, use the pre­fix “Article hind­sight analy­sis in­ter­est­ing­ness score:” and then the score (0-10) as a num­ber. Give high scores to ar­ti­cles/​dis­cus­sions that are promi­nent, no­table, or in­ter­est­ing in ret­ro­spect. Give low scores in cases where few pre­dic­tions are made, or the topic is very niche or ob­scure, or the dis­cus­sion is not very in­ter­est­ing in ret­ro­spect.

Here is an ex­am­ple:

Article hind­sight analy­sis in­ter­est­ing­ness score: 8

* Submit prompt to GPT 5.1 Thinking via the OpenAI API

* Render the re­sults into sta­tic HTML web pages for easy view­ing

* Host the html re­sult pages on my web­site: https://​karpa­thy.ai/​hn­cap­sule/

* Host all the in­ter­me­di­ate re­sults of the data di­rec­tory if some­one else would like to play. It’s the file data.zip un­der the ex­act same url pre­fix (intentionally avoid­ing a di­rect link).

I spent a few hours brows­ing around and found it to be very in­ter­est­ing. A few ex­am­ple threads just for fun:

And then when you nav­i­gate over to the Hall of Fame, you can find the top com­menters of Hacker News in December 2015, sorted by imdb-style score of their grade point av­er­age. In par­tic­u­lar, con­grat­u­la­tions to pcwal­ton, tp­tacek, paulmd, cstross, greglin­dahl, moxie, han­nob, 0xcde4c3db, Manishearth, john­colan­duoni - GPT 5.1 Thinking found your com­ments very in­sight­ful and pre­scient. You can also scroll all the way down to find the noise of HN, which I think we’re all fa­mil­iar with too :)

My code (wait, Opus’ code?) on GitHub can be used to re­pro­duce or tweak the re­sults. Running 31 days of 30 ar­ti­cles through GPT 5.1 Thinking meant 31 * 30 = 930 LLM queries and cost about $58 and some­where around ~1 hour. The LLM mega­minds of the fu­ture might find this kind of a thing a lot eas­ier, a lot faster and a lot cheaper.

A new toll ap­plied to cars dri­ving in parts of New York City has led to a mea­sur­able drop in traf­fic, and with it, a 22 per­cent de­cline in par­tic­u­late pol­lu­tion, ac­cord­ing to a new study.

Congestion pric­ing came into ef­fect in January, with cars pay­ing $9 to drive through busy parts of Manhattan dur­ing peak hours. In the first six months of the pro­gram, traf­fic in the con­ges­tion zone dropped by 11 per­cent, ac­ci­dents by 14 per­cent, and com­plaints of ex­ces­sive honk­ing or other noise by 45 per­cent, of­fi­cials said.

A new study from Cornell has now tal­lied the im­pact on par­tic­u­late pol­lu­tion. Particulates is­sued from tailpipes can ag­gra­vate asthma and heart dis­ease and in­crease the risk of lung can­cer and heart at­tack. Globally, they are a lead­ing risk fac­tor for pre­ma­ture death.

Analyzing data on air qual­ity, traf­fic, and weather con­di­tions, re­searchers de­ter­mined that in the first half of this year, par­tic­u­late pol­lu­tion was down 22 per­cent in parts of Manhattan af­fected by con­ges­tion pric­ing.

The de­cline seen in New York was greater than in other cities with con­ges­tion pric­ing, such as Stockholm and London, re­searchers note. And the ef­fect ex­tended be­yond Lower Manhattan. Pricing led to a drop in pol­lu­tion across the greater met­ro­pol­i­tan area, ac­cord­ing to the study, pub­lished in the jour­nal npj Clean Air.

“It’s re­ally ex­cit­ing to me that air qual­ity im­proved through­out the en­tire metro area,” said lead au­thor Timothy Fraser, of Cornell University. “This tells us that con­ges­tion pric­ing did­n’t sim­ply re­lo­cate air pol­lu­tion to the sub­urbs by rerout­ing traf­fic. Instead, folks are likely choos­ing cleaner trans­porta­tion op­tions al­to­gether, like rid­ing pub­lic trans­porta­tion or sched­ul­ing de­liv­er­ies at night. This thins traf­fic and lim­its how smog com­pounds when many cars are on the road.”

Interested in our next book? Learn more about Building Large-scale JavaScript Web Apps with React

Patterns.dev is a free on­line re­source on de­sign, ren­der­ing, and per­for­mance pat­terns for build­ing pow­er­ful web apps with vanilla JavaScript or mod­ern frame­works.

Share prop­er­ties among many ob­jects of the same type

Use ob­serv­ables to no­tify sub­scribers when an event oc­curs

Split up your code into smaller, reusable pieces

Add func­tion­al­ity to ob­jects or classes with­out in­her­i­tance

Use a cen­tral me­di­a­tor ob­ject to han­dle com­mu­ni­ca­tion be­tween com­po­nents

Use a fac­tory func­tion in or­der to cre­ate ob­jects

An in­tro­duc­tion to an­i­mat­ing page tran­si­tions us­ing the View Transitions API and li­braries

Learn how to op­ti­mize your load­ing se­quence to im­prove how quickly your app is us­able

Import code that has been ex­ported by an­other mod­ule

Import parts of your code on de­mand

Load non-crit­i­cal com­po­nents when they are vis­i­ble in the view­port

Load non-crit­i­cal re­sources when a user in­ter­acts with UI re­quir­ing it

Inform the browser of crit­i­cal re­sources be­fore they are dis­cov­ered

Fetch and cache re­sources that may be re­quested some time soon

Reduce the per­for­mance im­pact third-party scripts have on your site.

Reduce the time needed to trans­fer scripts over the net­work.

Enforce sep­a­ra­tion of con­cerns by sep­a­rat­ing the view from the ap­pli­ca­tion logic

Pass reusable logic down as props to com­po­nents through­out your ap­pli­ca­tion

Use func­tions to reuse state­ful logic among mul­ti­ple com­po­nents through­out the app

Create mul­ti­ple com­po­nents that work to­gether to per­form a sin­gle task

Render your ap­pli­ca­tion’s UI on the client

Generate HTML to be ren­dered on the server in re­sponse to a user re­quest

Deliver pre-ren­dered HTML con­tent that was gen­er­ated when the site was built

Update sta­tic con­tent af­ter you have built your site

Delay load­ing JavaScript for less im­por­tant parts of the page

Generate HTML to be ren­dered on the server in re­sponse to a user re­quest

Server Components com­pli­ment SSR, ren­der­ing to an in­ter­me­di­ate ab­strac­tion with­out need­ing to add to the JavaScript bun­dle

With Next.js, there are sev­eral com­po­nents that can help im­prove Core Web Vitals met­rics

A com­pre­hen­sive guide to build­ing React apps in 2025/2026, cov­er­ing frame­works, build tools, rout­ing, state man­age­ment, and AI in­te­gra­tion

Self-contained mod­ules that cou­ple markup (HTML), logic (JS), and styles (CSS) within them

Functions to en­cap­su­late and reuse state­ful logic among mul­ti­ple com­po­nents

Enforce sep­a­ra­tion of con­cerns by sep­a­rat­ing the view from the ap­pli­ca­tion logic

Dynamically switch be­tween com­po­nents with the spe­cial

Have nested com­po­nents ac­cess data with­out us­ing props

Components that don’t ren­der their own markup

Compile-time syn­tac­tic sugar for us­ing the Composition API

We pub­lish pat­terns, tips and tricks for im­prov­ing how you ar­chi­tect apps for free. Keep in mind, de­sign pat­terns are de­scrip­tive, not pre­scrip­tive

. They can guide you when fac­ing a prob­lem other de­vel­op­ers have en­coun­tered many times be­fore, but are not a blunt tool for jam­ming into every sce­nario. Patterns.dev aims to be a cat­a­log of pat­terns (for in­creas­ing aware­ness) rather than a check­list (what you must do).

Design pat­terns are a fun­da­men­tal part of soft­ware de­vel­op­ment, as they pro­vide typ­i­cal so­lu­tions to com­monly re­cur­ring prob­lems in soft­ware de­sign. The im­ple­men­ta­tion, ben­e­fits and pit­falls of com­mon de­sign pat­terns us­ing ES2017+.React-specific de­sign pat­terns and their pos­si­ble mod­i­fi­ca­tion and im­ple­men­ta­tion us­ing React Hooks….and many more Web Performance pat­terns and op­ti­miza­tions that can help im­prove your mod­ern web app!

A com­mon cri­tique of de­sign pat­terns is that they need­lessly add com­plex­ity.

Our per­spec­tive is that pat­terns are valu­able for solv­ing spe­cific prob­lems, of­ten help­ing to com­mu­ni­cate com­mi­nal­i­ties in code prob­lems for hu­mans. If a pro­ject does­n’t have those prob­lems, there is­n’t a need to ap­ply them. Patterns can also be very lan­guage or frame­work-spe­cific (e.g. React), which can of­ten mean think­ing be­yond the scope of just the orig­i­nal GoF de­sign pat­terns.

We help you scale your we­bapps for per­for­mance

Learn about web per­for­mance pat­terns for load­ing your code more ef­fi­ciently. Unsure how to think about mod­ern ap­proaches to load­ing or ren­der­ing user-ex­pe­ri­ences? We’ve got you cov­ered.

I needed a restau­rant rec­om­men­da­tion, so I did what every nor­mal per­son would do: I scraped every sin­gle restau­rant in Greater London and built a ma­chine-learn­ing model.

It started as a very rea­son­able prob­lem. I was tired of doom-scrolling Google Maps, try­ing to dis­en­tan­gle gen­uinely good food from what­ever the al­go­rithm had de­cided to push at me that day. Somewhere along the way, the pro­ject stopped be­ing about din­ner and be­came about some­thing slightly more un­hinged: how dig­i­tal plat­forms qui­etly re­dis­trib­ute eco­nomic sur­vival across cities.

Because once you start look­ing at London’s restau­rant scene through data, you stop see­ing all those cute in­de­pen­dents and hot new open­ings. You start see­ing an al­go­rith­mic mar­ket - one where vis­i­bil­ity com­pounds, de­mand snow­balls, and who gets to sur­vive is in­creas­ingly de­cided by code.

The pub­lic story of Google Maps is that it pas­sively re­flects “what peo­ple like.” More stars, more re­views, bet­ter food. But that fram­ing ob­scures how the plat­form ac­tu­ally op­er­ates. Google Maps is not just in­dex­ing de­mand - it is ac­tively or­gan­is­ing it through a rank­ing sys­tem built on a small num­ber of core sig­nals that Google it­self has pub­licly ac­knowl­edged: rel­e­vance, dis­tance, and promi­nence.

“Relevance” is in­ferred from text match­ing be­tween your search query and busi­ness meta­data. “Distance” is purely spa­tial. But “prominence” is where the po­lit­i­cal econ­omy be­gins. Google de­fines promi­nence us­ing sig­nals such as re­view vol­ume, re­view ve­loc­ity, av­er­age rat­ing, brand recog­ni­tion, and broader web vis­i­bil­ity. In other words, it is not just what peo­ple think of a place - it is how of­ten peo­ple in­ter­act with it, talk about it, and al­ready recog­nise it.

Visibility on these ranked lists de­ter­mines foot traf­fic. Foot traf­fic de­ter­mines how quickly re­views ac­cu­mu­late. Review ac­cu­mu­la­tion then feeds di­rectly back into the promi­nence sig­nal. The sys­tem com­pounds. Early dis­cov­ery gen­er­ates de­mand. Demand gen­er­ates data. Data gen­er­ates fu­ture dis­cov­ery. This cre­ates a cu­mu­la­tive-ad­van­tage dy­namic that looks re­mark­ably sim­i­lar to the way cap­i­tal com­pounds in fi­nan­cial mar­kets. This is es­sen­tially Robert Merton’s Matthew Effect ap­plied to ke­bab shops - ‘unto every one that hath shall be given.’

This dis­pro­por­tion­ately re­wards chains and al­ready-cen­tral venues. Chains ben­e­fit from cross-lo­ca­tion brand recog­ni­tion. High-footfall ar­eas gen­er­ate re­views faster, mean­ing venues in those zones climb the promi­nence rank­ing more quickly even at iden­ti­cal un­der­ly­ing qual­ity. By con­trast, new in­de­pen­dents face a clas­sic cold-start prob­lem: with­out re­views they are hard to find, and with­out be­ing found they strug­gle to ac­cu­mu­late re­views at all. What looks like neu­tral con­sumer choice is there­fore bet­ter un­der­stood as al­go­rith­mi­cally me­di­ated mar­ket de­sign.

In eco­nom­ics, this dy­namic closely re­sem­bles the logic of a mar­ket maker: an in­ter­me­di­ary that does not merely re­flect un­der­ly­ing sup­ply and de­mand, but ac­tively shapes liq­uid­ity, match­ing, and price dis­cov­ery. Platforms like Google Maps per­form an anal­o­gous func­tion for lo­cal ser­vices by con­trol­ling vis­i­bil­ity rather than prices di­rectly. In the lan­guage of dig­i­tal eco­nom­ics, rank­ing al­go­rithms act as at­ten­tion al­lo­ca­tors, steer­ing de­mand to­ward some firms and away from oth­ers.

If Google Maps now acts as a kind of mar­ket maker for ur­ban de­mand, the ob­vi­ous next ques­tion is: what would the city look like with­out that am­pli­fi­ca­tion layer? In other words, how do you sep­a­rate a restau­ran­t’s in­trin­sic per­for­mance from the vis­i­bil­ity ef­fects of the plat­form it­self?

To get at that, I built a ma­chine-learn­ing model - a gra­di­ent-boosted de­ci­sion tree (for the ML crowd: HistGradientBoostingRegressor from scikit-learn) - to pre­dict what a restau­ran­t’s Google rat­ing should be, given only its struc­tural char­ac­ter­is­tics. This class of model is de­signed for large, messy, mixed-type tab­u­lar data and is par­tic­u­larly good at cap­tur­ing in­ter­ac­tion ef­fects, with­out me hav­ing to spec­ify those by hand. Features in­clude how many re­views it has (log-transformed to re­flect di­min­ish­ing re­turns to at­ten­tion), what cui­sine it serves, whether it is part of a chain or an in­de­pen­dent, its price level, broad venue types (restaurant, café, take­away, bar), and where it sits in the city via a spa­tial grid.

Quick aside: for a sub­set of places I also scraped re­view text, lan­guages, and pho­tos. But for this first full-city run I stayed within the Google Maps API free tier - partly for re­pro­ducibil­ity, partly be­cause pre­vi­ous grid-scrap­ing ad­ven­tures taught me that cloud bills com­pound faster than re­view counts. So, for fu­ture ver­sions, more fea­tures will only im­prove things. In par­tic­u­lar, who is do­ing the re­view­ing mat­ters. A five-star re­view of an Indian restau­rant writ­ten in Hindi prob­a­bly car­ries a dif­fer­ent sig­nal than one writ­ten by some­one or­der­ing chips with every­thing. (No judg­ment of white British peo­ple ofc…)

One prac­ti­cal prob­lem I ran into early on is that Google Maps is sur­pris­ingly bad at cat­e­goris­ing cuisines. A huge share of restau­rants are la­belled vaguely (“restaurant”, “cafe”, “meal take­away”), in­con­sis­tently, or just in­cor­rectly. So I ended up build­ing a sep­a­rate cui­sine-clas­si­fi­ca­tion model that pre­dicts cui­sine from restau­rant names, menu lan­guage, and re­view text where avail­able. In other words, the cui­sine fil­ters in the dash­board are not just Google’s tags - they’re ma­chine-learned. This mat­ters more than it might sound: if you mis­clas­sify cuisines, you mis­read di­ver­sity, clus­ter­ing, and who ac­tu­ally com­petes with whom on the high street. Btw, I briefly con­sid­ered clas­si­fy­ing Pret A Manger as French, just to see if it would make any French peo­ple an­grier at me than they al­ready are. I did­n’t. But I thought about it.

Before any mod­el­ling hap­pens, all fea­tures go through a stan­dard pre­pro­cess­ing pipeline - im­pu­ta­tion, en­cod­ing, the usual. Crucially, the model is trained only to learn the map­ping be­tween ob­serv­able plat­form-vis­i­ble fea­tures and rat­ings. This al­lows me to gen­er­ate a coun­ter­fac­tual ex­pected rat­ing for each restau­rant - what the plat­form would typ­i­cally as­sign un­der those struc­tural con­di­tions. The dif­fer­ence be­tween a restau­ran­t’s real rat­ing and this pre­dicted rat­ing is what I call the rat­ing resid­ual. A pos­i­tive resid­ual means the restau­rant per­forms ma­te­ri­ally bet­ter than its plat­form base­line would sug­gest. A neg­a­tive resid­ual means it un­der­per­forms rel­a­tive to what the al­go­rithm nor­mally re­wards. This is not a per­fect mea­sure of food qual­ity - but it is a pow­er­ful mea­sure of al­go­rith­mic mis­pric­ing: where so­cial or culi­nary value di­verges from what the plat­form struc­turally am­pli­fies.

One caveat: some restau­rants pay for pro­moted pins or lo­cal-search ads. Because paid vis­i­bil­ity is­n’t pub­licly dis­closed, I can’t es­ti­mate how many - which is it­self a sign of how opaque plat­form in­flu­ence has be­come. My resid­u­als may partly re­flect ad spend I can’t ob­serve.

To sum­marise this, I built the London food dash­board. The dash­board cur­rently al­lows users to search by name and fil­ter by un­der­rated gems (identified by my ma­chine learn­ing al­go­rithm), cui­sine, bor­ough, price level, min rat­ing, and re­view vol­ume. It is still very much a ver­sion-one pro­to­type - but it is al­ready a work­ing mi­cro­scope into London’s al­go­rith­mic food econ­omy.

If you want to ex­plore it your­self, you can find it on my per­sonal web­site at: lau­ren­leek.eu/​food-map .

Naturally, I im­me­di­ately stress-tested it on my favourite part of London: Islington (maybe all this promo - also in my pre­vi­ous Substack on UK seg­re­ga­tion - makes me qual­ify for a coun­cil tax re­bate? - I’m look­ing at you Jeremy Corbyn…). I switched on my “underrated gems” fil­ter - that’s the ML resid­ual at work - set a min­i­mum rat­ing and re­view count, ex­clude the eye-wa­ter­ingly ex­pen­sive op­tions, and let the bub­bles guide me. Bigger, darker bub­bles mean places my model thinks the al­go­rithm is un­der­valu­ing.

And just like that, I had din­ner plans. Do try it your­self.

Btw, this is very much still a beta ver­sion - which means bugs, blind spots, and lots of room to grow. If some­thing looks odd, miss­ing, or wrong, please leave fea­ture ideas and sug­ges­tions in the com­ments or via the com­ments on my web­site. Unlike the VS Code GitHub tracker and its 13.8k open is­sues, I re­ally do read them.

But restau­rants don’t fail alone - they fail in ecosys­tems. I also wanted to un­der­stand what hap­pens when plat­form dy­nam­ics scale up from restau­rants to en­tire neigh­bour­hood food ecosys­tems. So I added a sec­ond mod­el­ling layer.

First, I ag­gre­gate restau­rants into small spa­tial cells (the hexa­gons you see on the maps - be­cause squares are for peo­ple who haven’t thought hard enough about edge ef­fects) and com­pute sum­mary fea­tures for each area: restau­rant den­sity, mean rat­ing, mean resid­ual, to­tal re­views, chain share, cui­sine en­tropy, and price level. I then stan­dard­ise these and run prin­ci­pal com­po­nent analy­sis (PCA) to com­press them into a sin­gle con­tin­u­ous hub score that cap­tures over­all “restaurant ecosys­tem strength” in one di­men­sion. Finally, I ap­ply K-means clus­ter­ing to the same fea­ture space to clas­sify ar­eas into four struc­tural types: elite, strong, every­day, and weak hubs.

At first glance, the pat­terns look com­fort­ingly fa­mil­iar. Central London dom­i­nates. Of course it does. But what mat­ters is not just where the hubs are - it’s what kind of hubs they are. Using the full hub score rather than raw rat­ings alone, I iden­tify the five most struc­turally pow­er­ful restau­rant hubs in London. They are the places where den­sity, al­go­rith­mic at­ten­tion, in­de­pen­dent sur­vival, and con­sumer spend­ing power all line up at once. They are la­beled on the maps. I am de­lib­er­ately re­fus­ing to rank them loudly in prose in or­der to avoid start­ing neigh­bour­hood wars at scale (and to not dis­ap­point Islington) - but the vi­sual story is al­ready ex­tremely clear.

Overlaying this with the cui­sine den­sity pan­els re­veals some­thing even sharper. London’s culi­nary di­ver­sity is not evenly dis­trib­uted across its plat­form econ­omy. Migrant cuisines clus­ter strongly in parts of the city where al­go­rith­mic vis­i­bil­ity is struc­turally weaker. Italian, Indian, Turkish, Chinese, Thai, British, Japanese, French, American, and fish-and-chips all trace dis­tinct set­tle­ment his­to­ries, labour net­works, re­tail for­mats, and re­la­tion­ships to cap­i­tal and rent. Some cuisines form long, con­tigu­ous cor­ri­dors. Others ap­pear as punc­tu­ated clus­ters tied to spe­cific high streets or in­come brack­ets.

Cuisine di­ver­sity, in other words, is not just about taste. It is about where fam­i­lies set­tled, which high streets re­mained af­ford­able long enough for a sec­ond gen­er­a­tion to open busi­nesses, and which parts of the city ex­pe­ri­enced dis­place­ment be­fore culi­nary ecosys­tems could ma­ture. (If this part es­pe­cially speaks to you, I go much deeper into it in Food for thought: lo­cal restau­rant di­ver­sity meets mi­gra­tion).

The Take-Away and Some Unwanted Policy Advice

This pro­ject started as a search prob­lem and ended as some­thing more. The most im­por­tant re­sult is­n’t which neigh­bour­hood tops the rank­ings - it’s the re­al­i­sa­tion that plat­forms now qui­etly struc­ture sur­vival in every­day ur­ban mar­kets. London’s restau­rant scene is no longer or­gan­ised by taste alone. It is or­gan­ised by vis­i­bil­ity that com­pounds, rent that rises when dis­cov­ery ar­rives, and al­go­rithms that al­lo­cate at­ten­tion long be­fore con­sumers ever show up. What looks like “choice” is in­creas­ingly the down­stream ef­fect of rank­ing sys­tems.

For pol­icy, that shifts the frame. If dis­cov­ery now shapes small-busi­ness sur­vival, then com­pe­ti­tion, fair­ness, and ur­ban re­gen­er­a­tion can no longer ig­nore plat­form rank­ing sys­tems. Councils can re­build streets and lib­er­alise li­cens­ing all they like - but al­go­rith­mic in­vis­i­bil­ity can still leave places eco­nom­i­cally stranded. Platform trans­parency and au­ditabil­ity are no longer niche tech de­bates; they are qui­etly be­com­ing tools of lo­cal eco­nomic pol­icy. At min­i­mum, rank­ing al­go­rithms with this much eco­nomic con­se­quence should be au­ditable. We au­dit fi­nan­cial mar­kets. We should au­dit at­ten­tion mar­kets too.

For a nav­i­ga­tion app, Google maps has a re­mark­able amount of power.

Just say­ing.

I’m also work­ing on other maps (including a map of the best cy­cling and run­ning routes with ex­cel­lent cafés along the way, be­cause I have needs). More broadly, I’m in­vest­ing more and more time into build­ing higher-qual­ity pub­lic data pro­jects. If you have an idea you’d like to see built - pitch it to me. And if you en­joy this kind of work, you can al­ways Buy Me A Coffee or sub­scribe to help fund the next round of over-en­gi­neered maps.

Running large lan­guage mod­els lo­cally has al­ways been a game of com­pro­mise. You ei­ther spend \$10,000+ on con­sumer GPUs that can barely han­dle 70 B pa­ra­me­ter mod­els, or you dream about en­ter­prise hard­ware you’ll never af­ford. The Grace-Hopper plat­form—Nvidi­a’s uni­fied CPU-GPU su­per­chip ar­chi­tec­ture—rep­re­sents the kind of dream-rig AI in­fra­struc­ture LocalLlama drools over, with sys­tems typ­i­cally cost­ing well over \$100,000 and ex­clu­sively avail­able to data cen­ters and re­search in­sti­tu­tions.

So when I stum­bled across a Grace-Hopper sys­tem be­ing sold for 10K euro on Reddit, my first thought was “obviously fake.” My sec­ond thought was “I won­der if he’ll take 7.5K euro?”.

This is the story of how I bought en­ter­prise-grade AI hard­ware de­signed for liq­uid-cooled server racks, con­verted it to air cool­ing, sur­vived mul­ti­ple near-dis­as­ters (including GPUs re­port­ing tem­per­a­tures of 16 mil­lion de­grees), and ended up with a desk­top that can run 235B pa­ra­me­ter mod­els at home. It’s a tale of ques­tion­able de­ci­sions, cre­ative prob­lem-solv­ing, and what hap­pens when you try to turn dat­a­cen­ter equip­ment into a daily dri­ver.

If you’ve ever won­dered what it takes to run truly large mod­els lo­cally, or if you’re just here to watch some­one dis­as­sem­ble $80,000 worth of hard­ware with noth­ing but hope and iso­propanol, you’re in the right place.

Early this year, while brows­ing r/​Lo­cal­L­LaMA/​new, I came across a ridicu­lously good deal. How good? These were the specs for the server of­fered for 10K euro, and a se­ri­ous up­grade to my 4x RTX 4090 rig:

UPDATE:Since I bought this, DDR5 RAM prices have be­come in­sane. 960GB of fast DDR5 now costs more than what I paid for the whole Grace-Hopper sys­tem 🤯

H100s cost about 30-40,000 euro each, and this sys­tem has two of them­Grace-Hop­per NVL2 sys­tems are ba­si­cally not for sale for con­sumers any­way!

The Reddit thread ex­plained the rea­son the sys­tem was be­ing sold cheap:

The main rea­son why is that it is a Frankensystem con­verted from liq­uid-cooled to air­cooled. Also it is not very pretty and not rack­able, be­cause it has a 48V power sup­ply at­tached. It is orig­i­nally di­rectly from Nvidia.

I im­me­di­ately of­fered to buy it, be­cause why not? If it was a scam, I could al­ways back out, but I wanted to be first in line!

It turns out I live near the seller, and he runs an on­line shop that sells mod­i­fied Nvidia server equip­ment as desk­tops. It still seemed pretty risky, so I did some re­search and found a video re­view of one of his Desktops on Youtube. With the deal now seem­ing at least plau­si­ble, and the seller only a two-hour drive away and agree­ing to take cash, it was time to take a Bavarian road trip.

I ar­rived at a farm­house in a small for­est, and met Bernhard the pro­pri­etor of GPTshop.ai. He showed me a nice work­shop (plasma cut­ters, an elec­tron­ics lab, etc.) from which he fab­ri­cates cus­tom cases for the high-end H100 desk­tops he builds. These desk­tops seem pretty damn nice, so it’s un­for­tu­nate that his web­shop gives off shady vibes; the busi­ness reg­is­tra­tion in the Cayman Islands def­i­nitely does­n’t help. What I can say though is that this item was heav­ily dis­counted, and not what he usu­ally sells.

Disclaimer: I have zero af­fil­i­a­tion with GPTshop.ai be­yond hand­ing them a stack of cash and re­ceiv­ing a dust-cov­ered server in re­turn. If this were a spon­sored post, they prob­a­bly would­n’t let me men­tion the 16 mil­lion de­gree GPU tem­per­a­tures or the part where I had to free-sol­der com­po­nents while pray­ing to the elec­tron­ics gods.

The server it­self was not in great con­di­tion. These things run ex­tremely loud and high-through­put fans, and these had sucked in a lot of dust, coat­ing the main­board so heav­ily I could­n’t tell the color of the PCB. However, it booted up and ran OK, so I handed over a wad of cash, strapped it into the back­seat of my car with the seat­belt (it weighed ~20 kg), and drove it home.

Did I men­tion it’s loud? Firing up the sys­tem is phys­i­cally painful. There are 8x Sunon dual-fan mod­ules, and each is as loud as a pow­er­ful vac­uum cleaner, but with a much higher and more an­noy­ing pitch. With all 8 run­ning at full power, hear­ing pro­tec­tion is nec­es­sary - I could hear the sys­tem run­ning in my base­ment with the win­dows closed from 50 me­ters away! My wife im­me­di­ately (and quite fairly), banned its use at home. We both work home-of­fice and it was sim­ply too loud for on­line meet­ings. But I had other plans any­way…

First things first, I of course quickly de­cided and then pro­ceeded to strip down the server, af­ter first photo-doc­u­ment­ing the var­i­ous con­nec­tors be­tween the var­i­ous PCBs, mod­ules and main­board.

The ma­jor­ity of the dust was vac­u­umed off dur­ing dis­as­sem­bly, but there was clearly a lot more un­der the Grace-Hopper mod­ules. After re­mov­ing those as well, I de­cided to go with a full wash­down of the main­board.

I pur­chased a few litres of Isopropanol, and with a soft brush I went over the whole board a few times to get the re­main­ing fine dust from in­side con­nec­tors and be­tween SMD-component pins.

I sus­pected there might also be dust in­side the Grace-Hopper mod­ules, but ac­tu­ally, I re­ally just wanted to pop them open to poke around.

The main­board went on my heated floor to dry for a week, while I moved on to re­plac­ing the cool­ing sys­tem.

I had looked into build­ing a cus­tom wa­ter-cool­ing block, but I was wor­ried about leaks, when I found cheap all-in-one wa­ter cool­ing sys­tems for ~40 euro each on sale. Two per GH200 mod­ule would be suf­fi­cient, so I care­fully mea­sured the di­men­sions of the GPU die and CPU, as well as screw lo­ca­tions, and threw those into Fusion 360 to model up an adapter block.

I have a Bambu X1, which came in very handy for pro­to­typ­ing the adapter blocks. The tol­er­ances have to be very tight, so I printed sev­eral cut-away ver­sions to make sure there was solid con­tact to the bare GPU die, and a safe mar­gin from con­tact to frag­ile parts.

The parts were then sent for CNC milling, and were de­liv­ered as the main­board was fin­ished dry­ing. After us­ing yet more iso­propanol to clean off the ma­chin­ing oil, they were mounted with­out much fuss.

My go-to ma­te­r­ial for this kind of pro­ject is ProfilAlu from eBay. It’s cheap, stiff, and de­liv­ered pre-cut for as­sem­bly. I put to­gether a de­sign in Fusion 360, and had the parts in a few days. The var­i­ous mounts how­ever were much more work. I needed to de­sign a few dozen cus­tom mounts for the var­i­ous PCBs and air-fil­ter fix­ings; this used up a few ki­los of fil­a­ment to get things just right.

The sys­tem did­n’t start to boot any­more. Checking the logs, I saw 16 crit­i­cal er­rors, one for each fan in the 8 pairs:

With the fans re­moved, the BMC (Baseboard Management Controller) im­me­di­ately pan­icked, and shut down the main­board to pre­vent ther­mal dam­age, even with the wa­ter cool­ers in place. So, I dis­abled the fan-check sub­sys­tem.

Great! I could start the boot process, and even reach lo­gin! But only about 1 time in 4… Not op­ti­mal. And even logged in, the server would crash within 2 min­utes.

Looking into the BMC logs, I saw:

* System pow­ers off within ~30 sec­onds of suc­cess­ful boot

But why?!!? I had shut down the hard­ware mon­i­tor­ing.

Warning: Your GPU should not reach 16,777,214 Celsius dur­ing boot. Imagine what would hap­pen un­der load!

This took some time to de­bug, as I was quite sure the sen­sors could not phys­i­cally han­dle read­ing tem­per­a­tures over 16 mil­lion Celsius… But then I no­ticed some­thing in­ter­est­ing about that spe­cific num­ber:

This is 2²⁴ - 2, which is sus­pi­ciously close to the max­i­mum value of a 24-bit un­signed in­te­ger. In the hard­ware world, this is the equiv­a­lent of a sen­sor throw­ing up its hands and scream­ing “I have no idea what’s hap­pen­ing!” When hard­ware can’t read a value prop­erly—whether due to a loose con­nec­tion, dam­aged cir­cuit, or ini­tial­iza­tion fail­ure—it of­ten re­turns the max­i­mum (or near-max­i­mum) rep­re­sentable value. It’s like the dig­i­tal ver­sion of a shrug.

The logs con­firmed this the­ory: see­ing 1.67772e+07 (16,777,214) was­n’t ev­i­dence that my GPU had achieved nu­clear fu­sion tem­per­a­tures 🔥—it was ev­i­dence that the tem­per­a­ture sen­sor had sim­ply stopped work­ing. And if a sen­sor er­ror is in­ter­mit­tent, the most likely cul­prit is a loose con­nec­tion or phys­i­cal dam­age.

After spend­ing way too long pur­su­ing soft­ware so­lu­tions (because who wants to dis­as­sem­ble every­thing again?), I fi­nally ac­cepted the in­evitable and broke out the screw­drivers.

I hap­pened to have bought a new mi­cro­scope ear­lier this year, and it turned out to be the per­fect tool for di­ag­nos­ing and fix­ing the is­sue. Near one of the mod­ules, I found some dam­aged sur­face mount com­po­nents. The dam­age must have hap­pened af­ter clean­ing, prob­a­bly dur­ing the re­assem­bly of the mod­ules with the cop­per adapters. They weigh over 2 kg, so a slight bump would have eas­ily caused this dam­age. Amazingly, the tiny com­po­nents were still at­tached to the traces, and so I could mea­sure them eas­ily: a 100 nF ca­pac­i­tor, and 4.7k re­sis­tor (both of which I had on-hand, as they are stan­dard val­ues for de­cou­pling cir­cuits). The bad news? I had huge “0805” sized parts (2mm long), these were tiny “0402” (1mm long). And one of the traces was just gone.

With some very fid­dly sol­der­ing, and scratch­ing off the sol­der mask on the PCB to ex­pose more trace, I was able to ‘free sol­der’ the parts into a won­der­ful 3D sculp­ture which was then lib­er­ally coated in UV-curing mask resin, set, and then held in place with sticky tape. Very pro­fes­sional. After re­assem­bly, the sys­tem booted smoothly.

* Cool-looking mesh to pro­tect the wa­ter-cool­ing ra­di­a­tors and dust fil­ters

Getting the ac­tual GPU work­ing was also painful, so I’ll leave the de­tails here for fu­ture ad­ven­tur­ers:

That’s what you’re here for, maybe? I have only just started, but af­ter com­pil­ing the lat­est Llama.cpp ver­sion us­ing 144 cores in 90 sec­onds, here’s some bench­marks on larger LLMs:

This is pretty un­op­ti­mized, but it’s look­ing promis­ing so far! During the LLM tests I hit around 300W per GPU, far from the 900W max.

Here’s what the en­tire build ac­tu­ally cost me, from the ini­tial pur­chase to the fi­nal touches:

Not in­cluded: hear­ing pro­tec­tion (absolutely nec­es­sary), the mi­cro­scope I al­ready owned (but proved es­sen­tial), sev­eral failed 3D prints, and the emo­tional cost of see­ing “16,777,214°C” in sys­tem logs.

So, was it worth it? I now have a desk­top that can run 235B pa­ra­me­ter mod­els at home for less than the cost of a sin­gle H100. It re­quired dis­as­sem­bling $80,000 worth of en­ter­prise hard­ware, de­bug­ging sen­sors that re­ported tem­per­a­tures ap­proach­ing the sur­face of the sun, and free-sol­der­ing com­po­nents un­der a mi­cro­scope. Your mileage may vary. Literally: I had to drive two hours to pick this thing up.

Chinese ar­ti­fi­cial in­tel­li­gence startup DeepSeek has re­lied on Nvidia Corp. chips that are banned in the coun­try to de­velop an up­com­ing AI model, ac­cord­ing to a new re­port in The Information.

Nvidia’s Blackwell chips were smug­gled into China through coun­tries that per­mit­ted their sale, The Information re­ported, cit­ing un­named sources. More specif­i­cally, DeepSeek tapped chips that were in­stalled in data cen­ters in un­spec­i­fied coun­tries, then dis­man­tled and shipped to China af­ter clear­ing in­spec­tion by com­pa­nies de­vel­op­ing server equip­ment, The Information said.

The US bans the sale of these ad­vanced semi­con­duc­tors to China, which has led AI de­vel­op­ers there to ac­cess the hard­ware through data cen­ters lo­cated out­side of the main­land or sub­terfuge. In November, US pros­e­cu­tors charged two Chinese na­tion­als and two US cit­i­zens with a scheme to ship chips to China by way of Malaysia us­ing a fake real es­tate busi­ness.

A rep­re­sen­ta­tive for DeepSeek did­n’t im­me­di­ately re­spond to a re­quest for com­ment.

DeepSeek drew global at­ten­tion in January when it de­buted an AI model that was com­pet­i­tive with Silicon Valley’s best and said it had built it at a frac­tion of the cost. The startup was funded by the Chinese hedge fund High-Flyer, which had amassed 10,000 Nvidia GPUs in 2021, prior to US bans on ex­ports of so­phis­ti­cated Nvidia chips and other graph­ics pro­cess­ing units.

Earlier this week, President Donald Trump granted Nvidia per­mis­sion to ship to China an older ver­sion of its AI ac­cel­er­a­tors, the H200. An ex­port ban on its more pow­er­ful Blackwell ver­sion re­mains in place.

Beijing has mean­while pushed Chinese tech­nol­ogy com­pa­nies to rely on do­mes­tic equip­ment to de­velop AI. DeepSeek re­leased a new model in September and in­di­cated that it was work­ing with Chinese chip­mak­ers on the model.

Nvidia told The Information that it has­n’t seen “any sub­stan­ti­a­tion or re­ceived tips” about smug­gling through data cen­ters out­side of China.