Such rule changes would have ac­com­mo­dated SpaceX’s plan to only of­fer ap­prox­i­mately 3 per­cent of its IPO shares to pub­lic in­vestors, and the fact that SpaceX is cur­rently un­prof­itable with a grow­ing debt load that has reached $29 bil­lion be­cause of its spend­ing spree on AI in­fra­struc­ture.

But in its fi­nal de­ci­sion, the S&P Dow Jones Indices stated that “no changes will be made to the el­i­gi­bil­ity cri­te­ria in­clud­ing fi­nan­cial vi­a­bil­ity screens, sea­son­ing pe­riod, or min­i­mum IWF.” Even af­ter the stan­dard year­long wait, SpaceX, Anthropic, and OpenAI may strug­gle to de­liver the con­sis­tent prof­itabil­ity nec­es­sary to qual­ify for the S&P 500.

Money rules and ex­cep­tions

Swift en­try into the S&P 500 would have trig­gered $14 bil­lion of pas­sive fund buy­ing for SpaceX, ac­cord­ing to Bloomberg Intelligence. The in­vest­ment re­search arm of Bloomberg also es­ti­mated that OpenAI could have gained more than $8 bil­lion, and Anthropic could have net­ted $4.6 bil­lion from sim­i­lar pas­sive buy­ing sprees trig­gered by their S&P 500 en­tries.

This is be­cause $7.5 tril­lion in pas­sively man­aged funds—pop­u­lar among both in­di­vid­ual in­vestors and in­sti­tu­tional in­vestors—fol­low the S&P 500 by pur­chas­ing shares of com­pa­nies ac­cord­ing to their pro­por­tional rep­re­sen­ta­tion in the S&P 500 in­dex. For ex­am­ple, the Vanguard and Fidelity bro­ker­age gi­ants both of­fer pas­sive in­vest­ment funds that track the S&P 500 com­po­si­tion.

However, the S&P Dow Jones Indices did “carve out one con­ces­sion” by chang­ing the in­vestable weight fac­tor rules for “lower-profile bench­marks” such as the S&P Total Market Index and Dow Jones US Total Stock Market Index, ac­cord­ing to Quartz. That could al­low an IPO faster en­try into those in­dexes.

By con­trast, the Nasdaq stock ex­change changed its rules to al­low SpaceX to en­ter the Nasdaq-100 Index within 15 trad­ing days as op­posed to the usual three months. Similarly, the FTSE Russell in­dex provider de­cided to give SpaceX and other fol­low-on com­pa­nies ac­cel­er­ated en­try to the Russell Top 500 Index af­ter the close of the fifth trad­ing day fol­low­ing an IPO.

The de­nial of ac­cel­er­ated S&P 500 en­try for SpaceX comes just days af­ter Morningstar an­a­lysts de­scribed SpaceX as hav­ing been “significantly over­val­ued” in the lead-up to its IPO. The in­vest­ment re­search firm val­ued SpaceX at $780 bil­lion—less than half of SpaceX’s $1.75 tril­lion IPO goal—pri­mar­ily based on the strengths of SpaceX’s Starlink satel­lite ser­vice and rocket launch busi­ness.

This story was up­dated on June 6, 2026 to more clearly de­scribe the pro­posed rule changes that would have ap­plied to all MegaCap com­pa­nies.

Home

Blog

Research

About

Portfolio

Monday. June 01, 2026 -

26 mins

This post is a walk­through of how LLMs work. Modern LLMs are mostly built by stack­ing trans­former blocks over and over, so un­der­stand­ing the trans­former ma­chin­ery gets you most of the way there.

I’ll cover the core mech­a­nisms in­side mod­ern trans­former-based LLMs, with­out all that sticky math stuff. Don’t get me wrong, you should learn the math, but this can serve as an in­tro­duc­tion.

Most mod­ern LLMs share the same trans­former-fam­ily skele­ton. The dif­fer­ences come from what each one was trained on, the scale and con­fig­u­ra­tion choices, and the post-train­ing done on top. By the end, you should be able to read many mod­ern LLM pa­pers or model cards and know which piece of the ar­chi­tec­ture each sec­tion is talk­ing about.

Here’s the path:

Tokens, how a string of text be­comes a se­quence of in­te­gers

Embeddings, how those in­te­gers get mean­ing

Positional en­cod­ing, how the model knows what or­der the to­kens came in

Attention, how to­kens share in­for­ma­tion with each other

Multi-head at­ten­tion, how the model tracks many kinds of re­la­tion­ships at once

The feed-for­ward net­work, where a large share of the mod­el’s stored struc­ture lives

The resid­ual stream and layer nor­mal­iza­tion, what makes deep stacks train­able

Predicting the next to­ken, what the model ac­tu­ally out­puts and how the gen­er­a­tion loop works

Architecture vs trained weights, what’s broadly shared across mod­ern LLMs, and what’s dif­fer­ent

Tiny ex­plain­ers ap­pear through­out so any­one can fol­low along, re­gard­less of back­ground.

Tokenization

Models don’t read text di­rectly. They read in­te­ger IDs. The step that con­verts your prompt into a se­quence of those in­te­gers.

That con­ver­sion step is called to­k­eniza­tion. A to­k­enizer takes a string and pro­duces a se­quence of in­te­gers, where each in­te­ger points to an en­try in a fixed vo­cab­u­lary. Modern LLM vo­cab­u­lar­ies usu­ally con­tain tens of thou­sands to a few hun­dred thou­sand en­tries.

Tiny ex­plainer: to­ken ID A to­ken ID is the in­te­ger the model uses for one vo­cab­u­lary en­try. The model works with the num­ber, not the writ­ten word it­self.

Tiny ex­plainer: to­ken ID A to­ken ID is the in­te­ger the model uses for one vo­cab­u­lary en­try. The model works with the num­ber, not the writ­ten word it­self.

Tokens aren’t usu­ally whole words. They’re usu­ally sub­word pieces. The word “tokenization” might split into [“token”, “ization”]. The word “running” might split into [“run”, “ning”]. The rea­son is ef­fi­ciency. Whole-word vo­cab­u­lar­ies are too big and don’t gen­er­al­ize to new words. Character-level vo­cab­u­lar­ies are too small and force the model to learn even the sim­plest pat­terns from scratch. Subword to­k­eniza­tion sits in the mid­dle. The most com­mon pieces be­come sin­gle to­kens, and rare or novel words get com­posed from smaller pieces.

Tiny ex­plainer: vo­cab­u­lary The vo­cab­u­lary is the to­k­eniz­er’s fixed list of pieces. Each piece has an ID, and the model can only di­rectly re­ceive IDs from that list.

Tiny ex­plainer: vo­cab­u­lary The vo­cab­u­lary is the to­k­eniz­er’s fixed list of pieces. Each piece has an ID, and the model can only di­rectly re­ceive IDs from that list.

The trade-off shows up in places peo­ple don’t ex­pect. The clas­sic ex­am­ple: ask an LLM how many R’s are in “strawberry.” LLMs used to get it wrong. That’s not the model fail­ing at count­ing. It’s the model not op­er­at­ing on let­ters di­rectly, only to­ken IDs that hap­pen to spell out a word a hu­man would split let­ter by let­ter.

Different model fam­i­lies use dif­fer­ent to­k­eniz­ers. GPT mod­els use Byte Pair Encoding vari­ants. SentencePiece is com­mon in LLaMA-style mod­els. The choice mat­ters for com­pute (fewer to­kens means less work) and for things like mul­ti­lin­gual cov­er­age, but the ba­sic shape is the same. Text in, in­te­gers out.

Now that the prompt is a se­quence of in­te­gers, the next step is to give those in­te­gers mean­ing.

Embeddings

A to­ken ID like 1024 is just a row in­dex. It does­n’t mean any­thing by it­self. The thing that gives it mean­ing is a gi­ant table called the em­bed­ding ma­trix.

Every model has one. It has one row per en­try in the vo­cab­u­lary, and each row is a long vec­tor of num­bers. The length of each row is the mod­el’s hid­den size. In many 7B-class mod­els, that means 4,096 num­bers per to­ken. Larger mod­els usu­ally use wider vec­tors.

Tiny ex­plainer: vec­tor A vec­tor is a list of num­bers. In a trans­former, each to­ken be­comes a vec­tor so the model can do math with it.

Tiny ex­plainer: vec­tor A vec­tor is a list of num­bers. In a trans­former, each to­ken be­comes a vec­tor so the model can do math with it.

When the to­k­enizer hands the model an in­te­ger, the model looks up that row and uses the vec­tor in­stead. That vec­tor is the to­ken’s em­bed­ding. It’s the mod­el’s rep­re­sen­ta­tion of what that to­ken “means,” learned dur­ing train­ing.

Tiny ex­plainer: em­bed­ding ma­trix The em­bed­ding ma­trix is a lookup table. Token ID in, learned vec­tor out.

Tiny ex­plainer: em­bed­ding ma­trix The em­bed­ding ma­trix is a lookup table. Token ID in, learned vec­tor out.

The in­ter­est­ing prop­erty of these em­bed­dings is that se­man­ti­cally sim­i­lar to­kens end up with sim­i­lar vec­tors. The vec­tor for “king” is close in space to the vec­tor for “queen,” and the vec­tor for “Paris” is close to “France.” None of this is hard-coded. It emerges from train­ing on enough text, and the model learns these po­si­tions be­cause they let it pre­dict text well.

You can do arith­metic on em­bed­dings and it some­times works. The fa­mous ex­am­ple is king − man + woman ≈ queen. The geom­e­try of em­bed­ding space car­ries real se­man­tic struc­ture, even though no­body told the model to build it that way.

Worth be­ing clear on: at this stage every to­ken has been re­placed by its em­bed­ding, but the em­bed­ding alone says noth­ing about where the to­ken sits in the se­quence. The vec­tor for “dog” is the same vec­tor whether “dog” is the first word in your prompt or the fifth. That’s a prob­lem.

That’s the gap po­si­tional en­cod­ing fills.

Positional en­cod­ing

Plain self-at­ten­tion does­n’t have a built-in rep­re­sen­ta­tion of word or­der. Without some po­si­tional sig­nal, it has no di­rect way to know that “dog” came be­fore “bites” in­stead of af­ter it.

Word or­der changes mean­ing. So the model needs an­other piece. It needs a way to in­ject the po­si­tion of each to­ken into the math.

Tiny ex­plainer: po­si­tional en­cod­ing Positional en­cod­ing is how the model gets or­der in­for­ma­tion. It tells the model where each to­ken sits in the se­quence.

Tiny ex­plainer: po­si­tional en­cod­ing Positional en­cod­ing is how the model gets or­der in­for­ma­tion. It tells the model where each to­ken sits in the se­quence.

The orig­i­nal trans­former pa­per (Vaswani et al. 2017) did this by giv­ing each po­si­tion its own pat­tern of num­bers and adding it di­rectly to each to­ken’s em­bed­ding be­fore any other pro­cess­ing. Position 1 had one pat­tern, po­si­tion 5 had a dif­fer­ent pat­tern, po­si­tion 100 had an­other. The pat­terns came from sine and co­sine waves at dif­fer­ent fre­quen­cies. Now the em­bed­ding for “dog” at po­si­tion 1 was dif­fer­ent from the em­bed­ding for “dog” at po­si­tion 5, just be­cause the po­si­tion pat­tern added to it was dif­fer­ent.

That worked, and si­nu­soidal en­cod­ings were cho­sen partly be­cause they can ex­trap­o­late be­yond the ex­act se­quence lengths seen dur­ing train­ing. But ad­di­tive po­si­tion schemes still had two prob­lems that be­came im­por­tant as mod­els scaled up.

First, the em­bed­ding had to carry both mean­ing and po­si­tion in the same set of num­bers. There’s only so much you can pack in.

Second, learned ab­solute po­si­tion em­bed­dings in par­tic­u­lar don’t gen­er­al­ize cleanly. If you trained on prompts up to 2,048 to­kens long, the model never saw po­si­tion 5,000 dur­ing train­ing, and the em­bed­ding for that po­si­tion was not learned in the same way.

Modern mod­els mostly use a dif­fer­ent scheme called Rotary Position Embeddings (RoPE), in­tro­duced by Su et al. in 2021 and now used in LLaMA, Mistral, Gemma, Qwen, and most other open-weight fam­i­lies. The in­tu­ition: in­stead of adding po­si­tion info to each to­ken’s vec­tor, RoPE ro­tates the vec­tor by an an­gle that de­pends on its po­si­tion. A to­ken at po­si­tion 1 gets a small turn, a to­ken at po­si­tion 100 gets a big­ger turn. When two to­kens are later com­pared dur­ing at­ten­tion, what mat­ters is the dif­fer­ence be­tween their ro­ta­tions, which en­codes how far apart they are.

Tiny ex­plainer: RoPE RoPE stands for Rotary Position Embeddings. Instead of adding a po­si­tion vec­tor, it ro­tates to­ken vec­tors so rel­a­tive dis­tance shows up dur­ing at­ten­tion.

Tiny ex­plainer: RoPE RoPE stands for Rotary Position Embeddings. Instead of adding a po­si­tion vec­tor, it ro­tates to­ken vec­tors so rel­a­tive dis­tance shows up dur­ing at­ten­tion.

The prac­ti­cal ad­van­tages are real. RoPE en­codes rel­a­tive po­si­tion nat­u­rally (which is closer to what at­ten­tion ac­tu­ally wants). It gen­er­al­izes bet­ter to longer con­texts. And it does­n’t add new pa­ra­me­ters to the model.

Even with good po­si­tional en­cod­ing, mod­ern LLMs have a doc­u­mented “lost in the mid­dle” prob­lem (Liu et al. 2023). They use in­for­ma­tion at the start and end of long prompts more re­li­ably than in­for­ma­tion buried in the mid­dle. That’s why prompt en­gi­neer­ing tips like “put im­por­tant con­text first” or “repeat key info at the end” ac­tu­ally help. The model is­n’t us­ing every part of your prompt equally well.

With to­ken mean­ing and po­si­tion both en­coded, the next ques­tion is how do to­kens ac­tu­ally ex­change in­for­ma­tion?

Attention

This is the mech­a­nism that gave the ar­chi­tec­ture its name. Attention.

Inside every trans­former layer, at­ten­tion does one thing. It lets each to­ken look at the other to­kens it is al­lowed to see and de­cide which ones mat­ter for what comes next.

It does this by giv­ing each to­ken three roles at once. Each to­ken gets trans­formed into three new vec­tors, called Query, Key, and Value (Q, K, V).

Tiny ex­plainer: Q, K, V Query means “what am I look­ing for,” Key means “what do I match with,” and Value is the in­for­ma­tion that gets copied when the match is strong.

Tiny ex­plainer: Q, K, V Query means “what am I look­ing for,” Key means “what do I match with,” and Value is the in­for­ma­tion that gets copied when the match is strong.

The Query asks, “what am I look­ing for from other to­kens?”

The Key says, “this is what I of­fer to to­kens look­ing at me.”

The Value car­ries, “this is what gets passed along when a match hap­pens.”

The same to­ken plays all three roles at the same time. The Q, K, V trans­for­ma­tions are learned ma­tri­ces, so the model fig­ures out dur­ing train­ing what each to­ken should look for and what it should of­fer.

Matching hap­pens through a sim­i­lar­ity score. Each to­ken’s Query is com­pared against the Key of each to­ken it is al­lowed to see, us­ing a scaled dot prod­uct. Intuitively, this mea­sures how much the two vec­tors line up. The scal­ing keeps the num­bers sta­ble be­fore soft­max.

Tiny ex­plainer: dot prod­uct A dot prod­uct is a sim­ple way to score how aligned two vec­tors are. Higher align­ment means a stronger match.

Tiny ex­plainer: dot prod­uct A dot prod­uct is a sim­ple way to score how aligned two vec­tors are. Higher align­ment means a stronger match.

The match scores then get turned into weights us­ing soft­max. Softmax takes any set of num­bers and turns them into a prob­a­bil­ity-like dis­tri­b­u­tion that sums to 1. Tokens with higher match scores get higher weights, and the weights are then used to take a weighted av­er­age of the value vec­tors.

Tiny ex­plainer: soft­max Softmax turns raw scores into weights that add up to 1. Big scores get big weights, small scores get small weights.

Tiny ex­plainer: soft­max Softmax turns raw scores into weights that add up to 1. Big scores get big weights, small scores get small weights.

An ex­am­ple. Consider the sen­tence “The cat that I saw yes­ter­day was sleep­ing.” When the model processes “was,” it needs to fig­ure out what’s do­ing the sleep­ing. The Query vec­tor for “was” gets com­pared against the Key vec­tors of the to­kens it is al­lowed to see. The dot prod­uct with “cat” is high, be­cause the model has learned that verbs like “was” need a sub­ject and that sub­jects like “cat” pro­duce Key vec­tors that line up well. The dot prod­uct with “yesterday” is low. Softmax turns those scores into weights, “cat” gets a high weight, “yesterday” gets a low one. The model then takes a weighted sum of the cor­re­spond­ing value vec­tors, so the value for “cat” dom­i­nates the re­sult. The new rep­re­sen­ta­tion of “was” is now mostly shaped by the value of “cat.” That’s how a to­ken sev­eral po­si­tions back be­comes the ref­er­ent.

There’s a con­straint spe­cific to GPT-style lan­guage mod­els, which is that they gen­er­ate text left to right. A to­ken at po­si­tion 5 is only al­lowed to at­tend to po­si­tions 1 through 5. It can­not at­tend to to­kens at po­si­tions 6, 7, 8, be­cause those haven’t been gen­er­ated yet. This is called causal mask­ing. The im­ple­men­ta­tion is sim­ple: fu­ture to­kens get match scores so low they end up with ef­fec­tively zero weight af­ter soft­max.

Tiny ex­plainer: causal mask­ing Causal mask­ing hides fu­ture to­kens. It keeps a de­coder-only lan­guage model from look­ing ahead while pre­dict­ing the next to­ken.

Tiny ex­plainer: causal mask­ing Causal mask­ing hides fu­ture to­kens. It keeps a de­coder-only lan­guage model from look­ing ahead while pre­dict­ing the next to­ken.

One of the most in­ter­est­ing find­ings in in­ter­pretabil­ity re­search is about spe­cial­ized at­ten­tion heads called in­duc­tion heads, found by Anthropic in 2022. These heads learn to spot pat­terns of the form “A B … A” in the prompt and pre­dict that B comes next. When the model sees “A” the sec­ond time, the in­duc­tion head looks back to where “A” ap­peared be­fore, sees what came af­ter, and copies that. They’re one of the clear­est known mech­a­nisms be­hind in-con­text learn­ing, the abil­ity of an LLM to pick up a pat­tern from your prompt and con­tinue it.

Tiny ex­plainer: in­duc­tion head An in­duc­tion head is an at­ten­tion head that no­tices re­peated pat­terns in the prompt and helps con­tinue them.

Tiny ex­plainer: in­duc­tion head An in­duc­tion head is an at­ten­tion head that no­tices re­peated pat­terns in the prompt and helps con­tinue them.

Attention has one big cost. In full at­ten­tion, each to­ken com­pares against all the to­kens it is al­lowed to see, so dou­bling the prompt length roughly quadru­ples the work. This is why long prompts are ex­pen­sive to run, and why a lot of re­cent re­search is about mak­ing at­ten­tion more ef­fi­cient (FlashAttention, sparse at­ten­tion, lin­ear at­ten­tion).

But one at­ten­tion head only gives the model one learned view of those re­la­tion­ships.

Multi-head at­ten­tion

A sin­gle at­ten­tion pass gives the model one way of de­cid­ing which to­kens mat­ter to which other to­kens. That’s not enough. Language has many re­la­tion­ships hap­pen­ing at the same time. Subject and verb agree­ment. Pronouns and the names they re­fer to. Long-range ref­er­ences be­tween sen­tences. Word or­der and lo­cal phrases.

Multi-head at­ten­tion solves this by run­ning at­ten­tion many times in par­al­lel, with each par­al­lel pass op­er­at­ing in its own smaller space. Each par­al­lel pass is called a head.

Tiny ex­plainer: at­ten­tion head An at­ten­tion head is one in­de­pen­dent at­ten­tion pass with its own learned pro­jec­tions.

Tiny ex­plainer: at­ten­tion head An at­ten­tion head is one in­de­pen­dent at­ten­tion pass with its own learned pro­jec­tions.

The part that’s of­ten de­scribed wrong, in­clud­ing in plenty of tu­to­ri­als. Each head does­n’t get a lit­eral slice of the orig­i­nal to­ken vec­tor. Each head has its own learned pro­jec­tion ma­tri­ces that map the full to­ken vec­tor down to its own smaller Q, K, and V vec­tors. So if a model has 4,096 num­bers per to­ken and 32 heads, each head usu­ally works in a 128-dimensional space, but those 128 num­bers are a learned pro­jec­tion of the full 4,096, not a fixed slice. Different “views” of the same to­ken, not dif­fer­ent chunks of it.

Each head runs its at­ten­tion pass in­de­pen­dently. Then the out­puts of all the heads get con­cate­nated and passed through a fi­nal lin­ear layer that mixes them back into one full-size vec­tor. The model learns that fi­nal mix­ing too.

What makes this in­ter­est­ing is that dif­fer­ent heads of­ten end up par­tially spe­cial­ized. The model is never told what each head should do. Specialization emerges nat­u­rally dur­ing train­ing. Researchers have found heads that track gram­mar (linking verbs to their ob­jects, ar­ti­cles to their nouns), heads that fig­ure out which pro­noun refers to which name, heads that track po­si­tional pat­terns, in­duc­tion heads, and many more. A sin­gle trans­former layer might have 32 heads. A mod­ern fron­tier model has dozens of lay­ers. So a typ­i­cal LLM has thou­sands of at­ten­tion heads in to­tal, each adding its own learned view.

There’s a prac­ti­cal cost con­cern that drove a re­cent ar­chi­tec­tural change. Each head needs to keep its Key and Value vec­tors in mem­ory for all the to­kens al­ready gen­er­ated, so that when a new to­ken gets gen­er­ated the model does­n’t have to re­com­pute every­thing from scratch. This is called the KV cache, and it’s the main mem­ory cost of run­ning an LLM at long con­text lengths.

Tiny ex­plainer: KV cache The KV cache stores old Key and Value vec­tors dur­ing gen­er­a­tion. It saves the model from re­com­put­ing the whole prompt every time it adds a to­ken.

Tiny ex­plainer: KV cache The KV cache stores old Key and Value vec­tors dur­ing gen­er­a­tion. It saves the model from re­com­put­ing the whole prompt every time it adds a to­ken.

Modern de­coder-only LLMs mostly use a vari­ant called Grouped-Query Attention (GQA). Instead of every head hav­ing its own keys and val­ues, groups of heads share the same key and value heads. LLaMA-2 70B has 64 query heads but only 8 key/​value heads. Mistral 7B has 32 query heads and 8 key/​value heads. The re­sult is nearly the same ac­cu­racy as full multi-head at­ten­tion but with much less mem­ory pres­sure and in­fer­ence cost.

Tiny ex­plainer: GQA Grouped-Query Attention lets mul­ti­ple query heads share fewer key/​value heads. That cuts KV-cache mem­ory while keep­ing many query views.

Tiny ex­plainer: GQA Grouped-Query Attention lets mul­ti­ple query heads share fewer key/​value heads. That cuts KV-cache mem­ory while keep­ing many query views.

Feed-forward net­work

After at­ten­tion fin­ishes mix­ing in­for­ma­tion be­tween to­kens, every layer has a sec­ond step that no­body talks about as much. The feed-for­ward net­work.

pub­lic sec­tor

Means res­i­dents can skip the credit card and use ‘pay by bank’ for lo­cal au­thor­i­ties and ser­vices

The UK’s Government Digital Service (GDS) has re­placed Stripe with Dutch provider Adyen as its proces­sor for many pay­ments made through its GOV.UK Pay ser­vice.

Adyen will take over GOV.UK Pay card pay­ments for lo­cal au­thor­i­ties, po­lice forces and armed forces units from Stripe, as well as pay by bank ser­vices, un­der a three-year con­tract worth up to £25.3 mil­lion.

According to the ten­der no­tice pub­lished in February 2025, the con­tract cov­ers around 17 per­cent of pay­ments made through GOV.UK Pay but more than 70 percent of its or­ga­ni­za­tions and in­cludes the only op­tion al­low­ing users to start tak­ing pay­ments within one work­ing day. At that point the con­tract had an es­ti­mated max­i­mum value of £49 mil­lion, al­though with no guar­an­tees over vol­ume.

REG AD

In a blog­post about the con­tract award on 2 June, GDS said it will mi­grate around 1,000 ser­vices to the new sup­plier. “We will make mi­gra­tion as straight­for­ward as pos­si­ble while com­ply­ing with Know Your Customer leg­is­la­tion that pro­tects every­one from fraud,” wrote Alan Maddrell, se­nior con­tent de­signer for the ser­vice. “Most im­por­tantly, there will be no dis­cernible dif­fer­ence for pay­ing users and no loss in func­tion­al­ity.”

REG AD

He added that the change of sup­plier will help in­tro­duce new op­tions in­clud­ing pay by bank, which trans­fers money di­rectly be­tween bank ac­counts us­ing open bank­ing ser­vices and avoids the need to type in card de­tails. GDS will con­tinue to use WorldPay to process pay­ments for cen­tral gov­ern­ment, linked or­ga­ni­za­tions and NHS bod­ies.

GDS es­tab­lished GOV.UK Pay to save pub­lic ser­vices the ef­fort and cost of set­ting up on­line pay­ments them­selves. It does­n’t charge or­ga­ni­za­tions for the ser­vice be­yond pass­ing on trans­ac­tion fees.

According to its per­for­mance data page, GOV.UK Pay has processed 137.5 mil­lion trans­ac­tions since it was set up in 2016, worth around £9.2 bil­lion. It cur­rently pro­vides 1,718 ser­vices, in­clud­ing 662 for lo­cal gov­ern­ment and 256 for po­lice forces, to 608 or­gan­i­sa­tions rang­ing from 1079 (Tiverton) Squadron RAF Air Cadets to Yeovil Town Council. ®

The en­ergy-ef­fi­cient de­sali­na­tion sys­tem pro­duces fresh wa­ter with­out chem­i­cal ad­di­tives and trans­forms left­over salts into use­ful ma­te­ri­als.

The United Nations es­ti­mates that 2.2 bil­lion peo­ple lack safely man­aged drink­ing wa­ter, and com­mu­ni­ties from California to the Middle East rely on de­sali­na­tion plants to con­vert ocean wa­ter to fresh wa­ter. Common de­sali­na­tion tech­niques, such as re­verse os­mo­sis and ther­mal dis­til­la­tion, are en­ergy-in­ten­sive, re­quire pre- and post-wa­ter treat­ment, and leave be­hind a con­cen­trated salt­wa­ter byprod­uct called brine. The brine byprod­uct wreaks havoc on sea life when it’s de­posited back into the ocean by rais­ing the salt level and low­er­ing oxy­gen in the wa­ter.

But a novel ap­proach de­vel­oped at the University of Rochester of­fers a way to over­come these draw­backs. Researchers at URochester’s Institute of Optics de­vel­oped a new so­lar-ther­mal de­sali­na­tion process to pro­duce fresh wa­ter in an en­ergy-ef­fi­cient way that does not leave be­hind brine and re­quires no chem­i­cal ad­di­tives to pre-treat the wa­ter. A team led by Chunlei Guo, a pro­fes­sor of op­tics and of physics and a se­nior sci­en­tist at URochester’s Laboratory for Laser Energetics, de­scribes their method in a pa­per pub­lished in Light: Science & Applications.

The tech­nol­ogy uses so­lar pan­els made of black metal etched with fem­tosec­ond lasers to make the sur­face su­per light-ab­sorb­ing and su­per­wick­ing—or ex­tremely at­trac­tive to wa­ter. The pan­els have a laser-treated ac­tive re­gion that pulls a thin layer of wa­ter across the sur­face, ab­sorbs nearly all so­lar ra­di­a­tion, dis­tills the wa­ter, and de­posits the left­over salts and min­er­als into the pan­el’s un­treated sides or “passive” re­gion so that the salt does not clog the ac­tive re­gion and dis­rupt con­tin­u­ous de­sali­na­tion.

Leveraging the ‘coffee ring’ ef­fect

Guo says other re­searchers have de­vel­oped so­lar-ther­mal de­sali­na­tion tech­niques that work well in lab ex­per­i­ments us­ing sim­u­lated sea­wa­ter made of only wa­ter and sodium chlo­ride. As the wa­ter evap­o­rates, the sodium chlo­ride crys­tal­lizes in a grainy and porous fash­ion al­low­ing wa­ter to pass through to dis­solve the salt. The so­lar pan­els, mean­while, can be eas­ily cleaned.

But real ocean has a much more com­plex com­po­si­tion, and these sys­tems tend to en­counter is­sues when tested in the field. Unlike sodium chlo­ride, many other com­po­nents in sea­wa­ter, such as mag­ne­sium- and cal­cium-based ma­te­ri­als, crys­tal­lize in a crusty and non-porous fash­ion on the so­lar pan­el’s sur­face, clog­ging it. Eventually, wa­ter can no longer seep through. This is the same phe­nom­e­non as your shower head clog­ging over time or your teapot lined with scales, ex­cept that sea­wa­ter con­tains hun­dreds of times more salts than your tap wa­ter.

“Mining lithium from the earth has proven to be very tax­ing from an en­ergy and en­vi­ron­men­tal stand­point, so pulling lithium di­rectly from salt­wa­ter could be a very im­por­tant fu­ture route.”

“Mining lithium from the earth has proven to be very tax­ing from an en­ergy and en­vi­ron­men­tal stand­point, so pulling lithium di­rectly from salt­wa­ter could be a very im­por­tant fu­ture route.”

To keep their so­lar panel sur­face from gum­ming up sim­i­larly, Guo’s team pre­cisely etched the black met­al’s grooves so the var­i­ous salts and min­er­als in ocean wa­ter would sim­ply slough off. They also lever­aged a phys­i­cal phe­nom­e­non that has plagued clumsy javaphiles for cen­turies: the cof­fee ring ef­fect.

“If you drop cof­fee on a sur­face, even­tu­ally the wa­ter evap­o­rates, and there’s a ring left at the outer edge that is the con­cen­trated cof­fee par­ti­cles,” says Guo. “We use that same prin­ci­ple to ad­vance the salts to the pas­sive re­gion.”

Testing their so­lar-ther­mal de­sali­na­tion tech­nique us­ing sam­ples of wa­ter from the Pacific, Atlantic, and Indian Oceans, Guo and his team were able to make the sur­face self-clean­ing. In other words, it ex­tracted fresh­wa­ter and di­rected the re­main­ing salts to the pas­sive re­gion where they could be later col­lected with­out re­duc­ing the pan­el’s ef­fi­ciency.

Turning waste into re­sources

One of the new de­sali­na­tion method’s dis­tinct ad­van­tages is that in­stead of leav­ing be­hind brine that must be dis­posed of or processed, it ex­tracts nearly 100 per­cent of the salts in solid form. This could not only pro­duce an abun­dant sup­ply of table salt, but it could also be used to ex­tract more pre­cious min­er­als, in­clud­ing lithium, which is used in the lithium-ion bat­ter­ies that power elec­tric ve­hi­cles and other elec­tron­ics.

In a re­lated pa­per in the Journal of Materials Chemistry A, Guo and his col­leagues show how they can use the same su­per­wick­ing so­lar pan­els to sep­a­rate lithium from the rest of other salts in de­sali­na­tion. Embedding nanopar­ti­cles made of hy­dro­gen ti­tanate in the tiny grooves of the black metal sur­face iso­lates the lithium from other salts and min­er­als.

“Mining lithium from the earth has proven to be very tax­ing from an en­ergy and en­vi­ron­men­tal stand­point, so pulling lithium di­rectly from salt­wa­ter could be a very im­por­tant fu­ture route,” says Guo.

Using wa­ter sam­ples from Great Salt Lake, the re­searchers ex­tracted about 50 per­cent of the lithium from the salts left be­hind by the de­sali­na­tion process.

Guo says now that the su­per­wick­ing de­sali­na­tion tech­nol­ogy has been demon­strated in proofs of con­cept on small-scale de­vices, he sees the tech­nol­ogy in­her­ently scal­able, ca­pa­ble of im­prov­ing global ac­cess to drink­ing wa­ter and build­ing more sus­tain­able sup­ply chains for pre­cious min­er­als.

The National Science Foundation, the Bill & Melinda Gates Foundation, and Worldwide Universities Network sup­ported this re­search. Guo’s col­leagues from the Institute of Optics who con­tributed to the re­search in­clude Senior Scientist Subash Singh, alum­nus Ran Wei ’24 (PhD), PhD stu­dents Luheng Tang and Tainshu Xu, and Mingjiang Ma.

GrapheneOS Discussion Forum

Your browser does not sup­port the au­dio el­e­ment.

Listen to ar­ti­cle

This con­tent is gen­er­ated by Google AI. Generative AI is ex­per­i­men­tal

[[duration]] min­utes

Since re­leas­ing Gemma 4 two months ago, we’ve been con­tin­u­ously work­ing to ex­pand its ca­pa­bil­i­ties. First, we in­tro­duced Multi-Token Prediction (MTP) to ac­cel­er­ate in­fer­ence, and just a cou­ple of days ago, we re­leased a 12B model to bridge the gap be­tween our E4B and 26B MOE mod­els.

Today, we are re­leas­ing new check­points op­ti­mized with Quantization-Aware Training (QAT) to make Gemma 4 even more ef­fi­cient, so you can run mod­els lo­cally on every­day edge de­vices and con­sumer GPUs.

By sim­u­lat­ing quan­ti­za­tion dur­ing train­ing, QAT min­i­mizes qual­ity loss when the model is com­pressed. This re­lease in­cludes QAT check­points for the pop­u­lar Q4_0 quan­ti­za­tion for­mat as well as a novel quan­ti­za­tion for­mat spe­cial­ized for mo­bile use cases. Using this mo­bile for­mat, we’ve re­duced the mem­ory foot­print of Gemma 4 E2B to 1GB. Together, these dra­mat­i­cally re­duce mem­ory re­quire­ments while pre­serv­ing the ca­pa­bil­i­ties and qual­ity you ex­pect from Gemma 4.

Keeping model qual­ity while mak­ing them smaller

Quantization is a key tech­nol­ogy to run mod­els on con­sumer hard­ware by re­duc­ing their mem­ory foot­print while also ac­cel­er­at­ing de­code speed. However, stan­dard Post-Training Quantization (PTQ) of­ten leads to per­for­mance degra­da­tion. Instead of sim­ply quan­tiz­ing the model af­ter train­ing, QAT in­te­grates the quan­ti­za­tion process di­rectly into train­ing. While PTQ is al­ready ef­fec­tive at pre­serv­ing qual­ity, our QAT re­sults yield even higher over­all qual­ity com­pared to stan­dard PTQ base­lines.

We ap­plied this QAT recipe to the pop­u­lar Q4_0 for­mat to max­i­mize per­for­mance for all the mod­els. For the edge mod­els (E2B and E4B), we rethought how we ap­proach quan­ti­za­tion with a spe­cial mo­bile-spe­cial­ized quan­ti­za­tion schema.

Saving on VRAM and Storage

Below are the ap­prox­i­mate mem­ory re­quire­ments in­di­cat­ing how much VRAM is re­quired to load the mod­els:

Optimizing for mo­bile de­vices un­der the hood

Standard com­pres­sion for­mats are of­ten hard for mo­bile proces­sors to run ef­fi­ciently. To en­sure Gemma 4 per­forms smoothly on mo­bile, we en­gi­neered a cus­tom mo­bile-quan­ti­za­tion schema de­signed for edge hard­ware:

Static ac­ti­va­tions: Normally, mod­els waste pro­cess­ing power cal­cu­lat­ing how to scale data on the fly. We pre-cal­cu­late these set­tings dur­ing train­ing, which re­duces work­load on mo­bile chips and makes re­sponses faster.

Channel-wise quan­ti­za­tion: We struc­tured the com­pressed data to fit the de­sign of mo­bile ac­cel­er­a­tors. This al­lows the phone to run cal­cu­la­tions na­tively with­out need­ing slow workarounds.

Targeted 2-bit quan­ti­za­tion: We heav­ily com­pressed (to 2-bit) the spe­cific parts of the model that gen­er­ate to­kens, while keep­ing the core rea­son­ing lay­ers at higher pre­ci­sion. This saves stor­age with­out mak­ing the model less smart.

Embedding and KV cache op­ti­miza­tion: We fo­cused com­pres­sion on the mod­el’s vo­cab­u­lary list and its short-term mem­ory. This dras­ti­cally re­duces the ac­tive mem­ory foot­print, let­ting you have long chats with­out run­ning out of space.

Because our au­dio and vi­sion en­coders are not needed in many use cases, you can op­ti­mize your mem­ory foot­print even fur­ther by de­ploy­ing only the modal­i­ties you need. For ex­am­ple, the Gemma 4 E2B text-only model (without Per-Layer Embeddings) re­quires less than 1 GB of mem­ory.

Get started to­day

To make those mod­els eas­ily us­able with your pre­ferred work­flow, we’ve part­nered with pop­u­lar de­vel­oper tools across the ecosys­tem to seam­lessly sup­port the Gemma 4 QAT check­points start­ing to­day:

Download the weights: Access the Q4_0 and mo­bile model weights right now on Hugging Face. We’ve tai­lored the for­mats to fit your work­flow: GGUF for­mats are ready for use with llama.cpp, and com­pressed ten­sors are pro­vided for vLLM. For every­thing else, we share un­quan­tized check­points that can be con­verted and quan­tized into for­mats sup­port­ing Q4_0.

Integrate & learn: Explore our doc­u­men­ta­tion to learn how to best de­ploy the QAT check­points.

Try on your desk­top: Easily down­load, man­age, and run Gemma 4 QAT mod­els lo­cally on your desk­top us­ing user-friendly in­ter­faces like llama.cpp, Ollama and LM Studio.

Deploy on-de­vice: Use Google’s light­weight LiteRT-LM run­time for op­ti­mized edge de­ploy­ment or run the mod­els di­rectly on the web with Transformers.js

Use your fa­vorite de­vel­op­ment tools: Serve larger mod­els ef­fi­ciently with SGLang and vLLM, op­ti­mize for Apple Silicon with MLX. Use the MTP QAT check­points to pre­serve the speedup of MTP while quan­tiz­ing the mod­els. Fine-tune weights di­rectly us­ing Hugging Face Transformers and Unsloth.

We can’t wait to see what you build with Gemma 4 run­ning lo­cally!

Sigma 45mm f/​2.8 Lens Repair & Analysis

[05.12.24]

I have a cam­era gear col­lec­tion prob­lem and as part of my per­sonal 12 step plan, I re­strict my­self from pur­chas­ing func­tion­ing lenses. This sounds il­log­i­cal, and it frankly is, but it’s very hard for me to re­sist heav­ily dis­counted lenses. To keep my hat, I tend to only bid on lenses that are less than 1/4 of the go­ing used sale prices and have lit­tle to no me­chan­i­cal dam­age. In this case I’ve been eye­ing the re­cently pro­duced sigma I-series lenses that fea­ture mostly alu­minum con­struc­tion. A bro­ken 45mm f/​2.8 lens popped up on ebay in January for a song and a dance, and I sim­ply could not re­sist.

The auc­tion was listed by an ebay seller that tends to have reg­u­lar in­ven­tory of bro­ken mod­ern cam­era gear which is great from a re­pair per­spec­tive. Occasionally the seller will tear­down equip­ment and sell parts, leav­ing me a bit un­easy about the in­ter­nal state of the listed items for sale, but I took a chance and went with it.

Arrival

The lens came well pack­aged and on ini­tial in­spec­tion, fea­tured zero me­chan­i­cal flaws. No scratches on the bar­rel or lens el­e­ments what­so­ever. To prop­erly in­spect the outer lens el­e­ments, I use my oil free air com­pres­sor and thor­oughly blow off any de­bris from the lens and prop­erly clean both front and rear el­e­ment with a kimwipe and lens clean­ing so­lu­tion. Eye glasses cleaner from the drug store is ad­e­quate for most ex­ter­nal lenses. Isopropyl al­co­hol is an­other good al­ter­na­tive, but don’t use on plas­tic lenses.

This is bro­ken???

I mounted the lens to my Lumix S5 and with seem­ingly too much force, it clicked into place. The cam­era booted up fine and even dis­played a live im­age, but no elec­tronic con­trols worked what­so­ever. None of the di­als or switches on the lens re­sponded to user in­put. The con­trol di­als on the cam­era did not reg­is­ter move­ment. Clearly, there was some­thing elec­tri­cally wrong with the lens. The con­trol PCB is usu­ally found on the rear of the lens near­est to the rear lens con­tact block. It would also pro­vide a good time to in­ves­ti­gate the very stiff lens mount.

Tools

The bar­ri­ers to en­try on this re­pair are low. Most of these tools are pretty stan­dard and generic at this point. The biggest ex­pense be­sides the lens is fil­tered air, but even a com­pressed air duster can suf­fice. Note: Since most of the cam­era in­dus­try de­sign folks are cen­tered in Japan, the JIS screw is stan­dard. Using a Phillips will work but it tends to wear down the heads on the JIS screws faster. Here are some of my go-to tools:

Kimwipes / lint-free lens clean­ing wipes

Spray Isopropyl Alcohol (ipa)

Eye glass cleaner

Microfiber cloth

Nitrile gloves

Highly fil­tered shop air / oil free com­pres­sor

Tape

Sharpie

Scalpel

Plastic Spudger

Magnifier / op­tic

JIS x 2.5mm / Philips #00 screw­driver

JIS x 3.0mm / Philips #0 screw­driver

Disassembly

For dis­as­sem­bly, I ori­ent the lens with the aper­ture mark fac­ing me and the table front edge. The rear plas­tic beauty spacer around the rear el­e­ment is re­moved first along with (3) black ma­chine screws. Following, the two nickel plated screws that fix­ture the side of the plas­tic lens block ter­mi­nal in­ter­face to the metal lens mount are re­moved. The screws are placed on dou­ble sided tape in an ori­en­ta­tion that matches the lens ori­en­ta­tion. This makes fu­ture re­assem­ble sub­stan­tially eas­ier.

Next or­der of busi­ness, the lens mount bay­o­net and shims. The ori­en­ta­tion and or­der of these shims mat­ter so they de­serve their own bit of tape. This lens had trou­ble mount­ing to a cam­era body so I thor­oughly in­spected the shims, bay­o­net mount back and the lens body for im­per­fec­tions and sur­face con­t­a­m­i­na­tion. I cleaned all sur­faces with ipa and moved on. Note: be ex­tra care­ful when han­dling the lens con­tact block flex ca­ble.

At this point in the dis­as­sem­bly, the lens con­tact block can be freely re­moved from the con­trol PCB. The con­tact block for L-mount fea­tures 10 ter­mi­nals that con­nect to the con­trol PCB via a flex­i­ble poly­imide ca­ble. This flex ca­ble has a ten­dency to tear eas­ily, es­pe­cially if not han­dled care­fully. Before con­tin­u­ing fur­ther with the tear­down, take a mul­ti­me­ter and check the con­ti­nu­ity of each trace. If there are vis­i­ble tears in the flex ca­ble, re­pair that first be­fore con­tin­u­ing to di­ag­nose any prob­lems. I have an­other guide on how to make your own flex ca­bles here. The flex ca­ble me­tered out to be flaw­less, so I pro­ceeded the tear­down.

The rear CNC ma­chined alu­minum shell of the lens is up next. Two ground­ing straps are fix­tured to the rear shell us­ing nickel plated ma­chine screws. The straps are ori­ented around the 2pm and 7pm clock po­si­tion. A push-in switch flex con­nec­tor is po­si­tioned around the 11pm po­si­tion that can be wig­gled out us­ing a pair of tweez­ers. There are (4) black ox­ide self tap­ping screws that mate the shell to the cen­ter plas­tic lens mod­ule. The rear shell can now be safely lifted up and set aside, with the aper­ture mark po­si­tioned to­ward the table edge.

The con­trol PCB and re­main­der of the flex ca­bles are now eas­ily ac­ces­si­ble. Three black self tap­ping screws mate the PCB to the plas­tic lens mod­ule at the 2pm, 7pm, and 10pm clock po­si­tion, re­spec­tively. Once the flex ca­bles are wig­gled loose, the con­trol PCB can be freed from the lens body and more closely scru­ti­nized.

PCB Analysis

The C-shaped PCB looks right at home with the dozens of other lens con­trol PCBs I’ve an­a­lyzed. There’s a main mi­cro­con­troller, DC-DC con­troller, mo­tor con­troller, crys­tal os­cil­la­tor, and a slew of pas­sives.

The re­verse side is adorned with FPC (Flexible Printed Circuit) con­nec­tors, test points and an 8-pin SPI flash pack­age di­rectly be­low the main mi­cro­con­troller.

Inspecting any un­known PCB for faults can be quite in­tim­i­dat­ing, but I find it eas­i­est to start with trac­ing the in­put power lines first. Where is this board sup­posed to re­ceive power from? Where do the V+ and Gnd traces first be­gin on the PCB? What is the first com­po­nent that re­ceives power on the board? PCBs can be a very com­pli­cated mess of lay­ers and jumped traces, so feel free to write down sim­pli­fied schematic notes on scrap pa­per to keep a sim­ple PCB power or­der-of-op­er­a­tions.

To start, trace the in­put power from the lens ter­mi­nal block. The thicker flex PCB traces are most def­i­nitely V+ and Gnd. Follow those traces on the PCB and use the con­ti­nu­ity mode of your mul­ti­me­ter to find out where the power traces on the PCB lead to. In this case, trac­ing the in­put power is tricky be­cause the large traces as­so­ci­ated with the flex ca­ble are hid­den be­neath the FPC con­nec­tor and passed through the PCB to the op­po­site side through vias. The power traces were then fed to a small square black chip, a sta­ple in small scale elec­tron­ics: the DC-DC con­verter.

A tell­tale sign of a DC-DC con­troller is the pres­ence of an ad­ja­cently placed prop­erly-chunky tan, beige or black col­ored block that dwarfs the size of the power con­troller. The photo be­low in­di­cates a cir­cled “2R2” or a 2.2 uH (micro Henry) in­duc­tor. This close prox­im­ity in­duc­tor arrange­ment is uni­ver­sally rec­om­mended by semi­con­duc­tor man­u­fac­tur­ers in ef­fort to re­duce ra­di­ated emis­sions / noise.

In this case, the 16-VQFN pack­age TI TPS62140RGTR Buck con­verter, la­beled as “PA71 TI 18i” is used in this sigma lens PCB. The lay­out en­gi­neer heeded the ad­vice of the TI datasheet and im­ple­mented a very sim­i­lar lay­out but added a few com­po­nents to keep things spicy. Looking over the lay­out rec­om­men­da­tion, “C1″ con­nects Vin to Gnd, and serves as the main in­put fil­ter ca­pac­i­tor for the dc-dc con­verter. Inquisitive minds can eas­ily de­ter­mine that the un­known “N” la­beled pack­age ad­ja­cent to C1 on the in­put volt­age rail is in­deed a fuse to pro­tect the dc-dc from dam­age. A quick check with the mul­ti­me­ter con­firms that the fuse was open, so it took one for the team and saved the DC-DC from de­struc­tion.

Searching on­line for an “N” la­beled fuse does not lead to many promis­ing search re­sults but it did bring up a sug­gested 2a rated smt fuse on aliex­press. The TI TPS62140RGTR datasheet quotes a 2a out­put cur­rent, and while there’s op­er­a­tional qui­es­cent cur­rent, 2a is likely an ap­pro­pri­ate value. Being fa­mil­iar with the Panasonic Semi smt fuses used all through­out the Lumix cam­era line, I picked up a 2amp 32v fast blow fuse part# ERB-RE2R00V. The lu­mix gh3, gh4 and gh5 cam­eras use a mix­ture of 32v 2.5a and 1.5a fuses, so I knew I was in the right ball­park. I have found that in cam­era elec­tron­ics, 2 ter­mi­nal re­sis­tor-look­ing pack­ages with ar­bi­trary sin­gle let­ter no­ta­tion tend to be smt fuses. They some­times have scal­loped ter­mi­nals.

The fuse im­ple­mented was sized as 0603, mak­ing re­pair pos­si­ble with less ex­pen­sive and pre­cise equip­ment. 0402 and even 0201 fuses very much ex­ist. The lay­out en­gi­neer also left space be­side the fuse for ease of ac­cess with re­pair tools. There have been many times when a fuse was put in a pocket or crowded sec­tion of a PCB re­quir­ing a nearby com­po­nent des­ol­der­ing to gain ac­cess to the failed com­po­nent. An ex­am­ple is the Lumix GH3 / GH4 main­board that fea­tures the bat­tery in­put fuse sand­wiched be­tween an SD card slot and a pro­trud­ing bat­tery con­nec­tor. SMT tweez­ers make this re­pair a breeze, but wield­ing two sol­der­ing irons also works in a pinch. Desolder the failed fuse, clean the pads, po­si­tion the new fuse, hold down the fuse and sol­der one ter­mi­nal at a time.

Fuse Investigation

As to why the fuse failed, I have not dis­cov­ered a spe­cific fail­ure point. Certain con­clu­sions can be ar­rived at, such as spe­cific edge cases where some­one leaves the lens in AFC mode (auto fo­cus con­tin­u­ous) and sets the cam­era to hunt for fo­cus for hours / days on end. It’s pos­si­ble the lens was never de­signed to be used 24/7 for rack­ing fo­cus and caused the buck con­verter to pull more cur­rent than than 2a fuse could sus­tain, caus­ing it to open.

An in­ter­est­ing op­er­a­tional con­di­tion in the TI datasheet may pro­vide clues to the fail­ure point. On page 11 it states: “The out­put cur­rent of the de­vice is lim­ited by the cur­rent limit (see Section 7.5). Due to in­ter­nal prop­a­ga­tion de­lay, the ac­tual cur­rent can ex­ceed the sta­tic cur­rent limit dur­ing that time.” “ILIMF is the sta­tic cur­rent limit. ILIMF = High-side MOSFET for­ward cur­rent limit. Test con­di­tions: VIN = 12 V, TA = 25°C. Min:2.45A Typ:3A Max:3.5A.” Thus in over cur­rent sit­u­a­tions, due to in­ter­nal prop­a­ga­tion de­lay, the ac­tual cur­rent con­sumed can ex­ceed the sta­tic cur­rent limit for a very short amount of time. If the lens con­trol PCB de­sign­ers im­ple­mented a 2a fast-act­ing smt fuse as es­ti­mated, the dc-dc con­troller would have been op­er­at­ing out­side the 2a fuse spec­i­fi­ca­tion. This is spec­u­la­tion at this point, but fail­ure point analy­sis is cer­tainly in­ter­est­ing.

Did the re­pair work?

What’s the TLDR? Does she chooch? Most cer­tainly! This is the lens in ac­tion. AFC per­for­mance is not light­ning fast, but I don’t ex­pect it to be! The man­ual fo­cus dial works won­ders and has just the right amount of damp­en­ing to make it en­joy­able to use. The aper­ture ring feels like a close cousin to the Lumix LX100, which is noth­ing short of ex­cel­lent.

Further Troubleshooting

If the fuse was con­tin­u­ous, the next tar­get for in­spec­tion would be the out­put volt­age on the dc-dc. Is the out­put within op­er­a­tional spec­i­fi­ca­tions? Is it be­low or ex­ceed­ing the power re­quire­ments of the main mi­cro­con­troller? The main mi­cro on this PCB is la­beled as a “341Fy 551486” but it is re­ally a Toshiba TMPM341FYXBG. This is a 32bit Arm M3 mi­cro with plenty of fea­tures, I/O pe­riph­eral sup­port and mo­tor con­trol com­mu­ni­ca­tion pro­to­cols. A mi­cro­con­troller chip serves as the main com­mu­ni­ca­tion hub on the con­trol PCB. Dedicated mi­cro­con­trollers re­quire ac­cu­rate clock sig­nals to speak with other mi­cros and pe­riph­er­als in cir­cuit, thus if you find a ded­i­cated crys­tal os­cil­la­tor on a PCB, there’s a good chance there’s a mi­cro­con­troller nearby!

Traditional quartz crys­tal os­cil­la­tors vary in op­er­a­tional fre­quency and are sealed in metal pack­ages sil­ver in lus­ter. They are com­monly found in sur­face mount or through hole pack­ages in many shapes and sizes. MEMS crys­tal os­cil­la­tors are a pos­si­bil­ity but they are slightly more ex­pen­sive and thus not as com­mon. MEMS os­cil­la­tors are usu­ally a very tiny square re­flec­tive chip-scale / flip-chip pack­age. Some mi­cro­con­trollers fea­ture on-chip os­cil­la­tors but they are not as con­sis­tent as ex­ter­nal crys­tals, thus ex­ter­nal crys­tals are still pre­ferred.

Building on pre­vi­ous trou­bleshoot­ing, the TMPM341FYXBG needs to be checked for in­put power. Failure of any com­po­nents be­tween the out­put rail of the dc-dc con­troller and the power in­put of the TMPM341FYXBG can cause the main mi­cro to mal­func­tion. The TMPM341FYXBG is a 0.5mm pitch 6x6mm 113 ball P-TFBGA113 BGA pack­age, mean­ing there is no easy prob­ing of Vin and gnd. The nearby cir­cuit will have to be in­ves­ti­gated. Working with what we know, the main mi­cro is a Arm M3, mean­ing it’s a 3.3v com­po­nent. The Toshiba datasheet quotes an op­er­a­tional volt­age range of 2.7 to 3.6V. If in­put power to the mi­cro is not within that range, or if there’s a short be­tween Vin and ground near the mi­cro, that’s def­i­nitely a red flag.

The eas­i­est way to probe for volt­ages live is to in­stall the lens con­tact flex back into the con­trol PCB and 3D print a fake lens as a jig in or­der to get the lens PCB in con­tact with a cam­era body on hand. Surprisingly, this is an eas­ier feat than ex­pected since sigma up­loaded nearly all of their cam­era bod­ies and ac­ces­sories on grab­cad for free. Step files for all y’all. Hats off to sigma for up­load­ing these, most cam­era com­pa­nies do not do this. Once the lens con­trol PCB is in po­si­tion and mounted to the cam­era, prob­ing can be­gin. Power traces are con­ven­tion­ally wider than sig­nal traces, so one can go about prob­ing wide traces near the TMPM341FYXBG for 3.3v.

If the mi­cro­con­troller is re­ceiv­ing power within spec­i­fi­ca­tion, an ad­di­tional range of trou­bleshoot­ing would be nec­es­sary to di­ag­nose the lens PCB fail­ure. Luckily, there are cir­cu­lar test pads near the main mi­cro, in­di­cat­ing these con­trol PCBs were pro­grammed and tested on a bed-of-nails jig be­fore as­sem­bly. Unfortunately, these test pads are not la­beled so find­ing the cor­rect ones be­comes a game of trial and er­ror. A logic an­a­lyzer would be needed to probe the test points near the mi­cro­con­troller. If UART can be dis­cov­ered on any of the test pins, the logic an­a­lyzer can help pro­vide in­put on whether the mi­cro­con­troller is boot­ing cor­rectly by de­ci­pher­ing the boot-up bit se­quence.

Depending on how far down the rab­bit hole you want to go, there is an 8 pin SPI flash pack­age la­beled “GD V4CE 2030” which is likely a 8 – 32mbit nor pack­age that is com­monly used with ARM mi­cro­con­trollers to ex­tend pro­gram mem­ory space. While I do not have the ex­act datasheet for this pack­age, I was able to de­ter­mine it was in­deed flash be­cause “GD” is the des­ig­nated com­pany pre­fix for “GigaDevice” a known mem­ory pack­age man­u­fac­turer and 8 pin pack­ages are a sta­ple in small sized ex­ter­nal flash pack­ages. In this case, the pack­age mea­sures a very small 3*2mm XY foot­print and closely matches the USON8 LGA8 pack­ages of­fered in the GigaDevice datasheet (page 29). The flash chip can be des­ol­dered and the con­tents can be read / cloned onto an­other flash pack­age if there was an inkling that the flash pack­age might have failed. The analy­sis of the flash pack­age ex­ceeds the con­text of this re­pair, but it is in­ter­est­ing to in­ves­ti­gate the ex­tent of fail­ure analy­sis.

If the main mi­cro­con­troller seems to be work­ing cor­rectly, there would likely be some in­put val­ues dis­played on the cam­era LCD when the lens con­trol PCB is in­stalled, such as aper­ture or fo­cus dis­tance in­for­ma­tion. The val­ues may be in­cor­rect but some val­ues should be dis­played on the cam­era dis­play from the lens con­troller mi­cro. Continuing down the line, the next tar­get would be the mo­tor con­troller IC. In this case, the “U24020 202184” pack­age is a Rohm BU24020GU mo­tor con­troller con­fig­ured as an SPI pe­riph­eral. SPI is a syn­chro­nous form of com­mu­ni­ca­tion and re­quires a clock sig­nal be­tween the mas­ter con­troller and slave de­vice.

Looking at the PCB macro shot, the BU24020GU has plenty of sur­round­ing pas­sive com­po­nents but has an un­pop­u­lated 4 pin pack­age that was likely in­tended for a 4 ter­mi­nal slot-style Photointerrupter but was aban­doned later in the de­vel­op­ment cy­cle. This is the kind of sim­plis­tic sen­sor that is po­si­tioned around a coded ro­tat­ing disc to log po­si­tion­ing in­for­ma­tion. Looking over the Rohm datasheet, this is an­other 3.3v part. Just as be­fore, thou shall check volt­ages! If the part is not re­ceiv­ing the 2.7 –> 3.6v in­put range, the chip’s not go­ing to work prop­erly. This is un­for­tu­nately an­other BGA com­po­nent, so prob­ing is go­ing to be chal­leng­ing. However, physics never left your side, and there’s mo­bile elec­trons on this here high­way. Thicker traces = more elec­trons!

Looking around the U24020 chip, you can see a pat­tern in se­ries of three - three arrange­ments of two ca­pac­i­tors tied to ground. These two ca­pac­i­tors are de­cou­pling ca­pac­i­tors, sized “big” and “small.” The big de­cou­pling ca­pac­i­tor is usu­ally be­tween 0.1uf and 1uf while the small ca­pac­i­tor is in the nano­farad range. This arrange­ment of ca­pac­i­tors is very com­mon and is de­signed to re­duce noise at dif­fer­ent fre­quen­cies. The datasheet tells us this is a four chan­nel mo­tor con­troller, and the ca­pac­i­tor arrange­ment tells us that power to all chan­nels has been laid out on the PCB. Thus, a mea­sure­ment be­tween any of high­lighted power pairs will pro­vide all you need to know. The datasheet lists Vin = DVDD, MVCC12, MVCC34 while Gnd = DVSS, MGND12 MGND34. Vin and gnd are high­lighted in the tra­di­tional color scheme, red for Vin, black for gnd.

If the mo­tor con­troller is re­ceiv­ing 3.3v but the lens fo­cus mo­tor is not mov­ing when a fo­cus pull is trig­gered, make sure to op­ti­cally in­spect the lens fo­cus flex ca­ble. Flex ca­bles tend to fa­tigue and break if the flex ra­dius is com­pressed too small. Fatiguing ca­bles can be prob­lem­atic be­cause de­pend­ing on the move­ment of the ca­ble, the fo­cus mech­a­nism can be­gin to tem­porar­ily work again, but it’s a false pos­i­tive as the next flex may kill lens com­mu­ni­ca­tion.

Other Lens PCB Tidbits

Looking over the lens PCB macro shots, there are a slew of tiny holes scat­tered through­out the board. These tiny holes are through hole vias and a large num­ber of them are drilled into the green top layer ground pour. These vias serve as re­turn paths for noisy com­po­nents on the PCB and con­nect the outer layer ground pour to in­ner ground lay­ers. You may have won­dered why there are such large clus­ters of vias in cer­tain parts of the board but not in oth­ers. Clusters of vias, or via stitch­ing, is used to pro­vide a low-im­ped­ance path for the re­turn cur­rent in­duced by a par­tic­u­larly noisy com­po­nent. By sur­round­ing a noisy com­po­nent or re­gion of the PCB, stitch­ing vias can block prop­a­ga­tion of elec­tro­mag­netic waves up to some max­i­mum fre­quency. The stitch­ing vias im­ple­mented here do not fully en­close any trace or spe­cific com­po­nent, so they do not work as a Faraday cage or as a guard ring, but they do pro­vide noise re­turn paths to help lower ra­di­ated EMI dur­ing the fi­nal de­sign process.

Conclusion

I com­pleted this re­pair about 2 months ago, just in time for spring’s first blooms in the north east­ern United States. The 45mm lens has been work­ing a treat in and around the gar­den and for doc­u­ment­ing other elec­tron­ics pro­jects. I added some sam­ple pho­tos in the be­hind-the-scenes pho­to­set to show this lens in ac­tion. It’s amaz­ing that a tiny 0603 com­po­nent can keep a good lens down and I’m glad I was able to thor­oughly doc­u­ment the re­pair process for oth­ers to learn from. All in all, the com­plete lens tear­down and fuse swap took less than an hour! In com­par­i­son, this writeup eas­ily ex­ceeded an or­der of mag­ni­tude more time to com­plete than the re­pair. Would I do it all again? Most cer­tainly!

Thanks for Reading!

Want more? Here’s a be­hind the scenes look at my work­space and some of the im­ages that did not make the cut to be in­cluded in the write-up:

AI agents tend to be, at least as of this writ­ing (May 2026), lousy at writ­ing tests. The tests they write are of­ten vague, cryp­tic, over­com­pli­cated, hacky, dis­or­ga­nized, tau­to­log­i­cal, per­for­ma­tive, per­func­tory and down­right point­less.

Unfortunately, I don’t ex­pect un­coached agents to get much bet­ter at writ­ing tests any­time soon, be­cause the agents learned by hu­man-writ­ten ex­am­ple, and the hu­man-writ­ten ex­am­ples out there are of­ten, I’m sorry to say, just as bad. Not only are the tests writ­ten by “amateurs” of­ten poor qual­ity, but, sadly, the test­ing prac­tices preached by teach­ers are of­ten pretty bad as well. It’s truly rough out there.

The good news is that I’ve found that, with a bit of guid­ance, agents are ca­pa­ble of fol­low­ing a ra­tio­nal TDD process and of writ­ing clear, mean­ing­ful tests. What ex­actly is that guid­ance? The short an­swer, which can serve as a close enough ap­prox­i­ma­tion to the truth, is Kent Beck’s Canon TDD. If you give your agent a skill that says noth­ing more than “Follow Kent Beck’s Canon TDD” then I sus­pect you’ll be a good 60% of the way there. The longer an­swer is what I’ve baked into my own per­sonal TDD skill.

My TDD skill

Since it’s a liv­ing doc­u­ment, I don’t want to bake my TDD skill into this blog post and freeze it in time. Instead, you can see my TDD skill here on GitHub. Having said that, I can cer­tainly share the essence of the skill here since I’m sure that that is­n’t go­ing to change.

First I clue the agent in to what I call the spec­ify-en­code-ful­fill loop, which is my per­sonal al­ter­na­tive to red-green-refac­tor. Specify-encode-fulfill (SEF) goes like this:

Specify: Come up with the spec­i­fi­ca­tions for what you want to build

Encode: Encode those spec­i­fi­ca­tions as au­to­mated tests (executable spec­i­fi­ca­tions)

Fulfill: Write the code to ful­fill the spec­i­fi­ca­tions

SEF is the high-level view of what, to me, TDD is all about. At a slightly lower level is Kent Beck’s Canon TDD, which I’ve de­scribed be­low in my own words.

Write a list of the spec­i­fi­ca­tions within scope of the cur­rent TDD ses­sion

Encode each item in the list as an au­to­mated test

Change the code just barely enough to make the cur­rent test fail­ure go away. Avoid “speculative cod­ing” - if we write more code than nec­es­sary to make the cur­rent test fail­ure go away, we risk hav­ing code never ex­er­cised by any test

Optionally refac­tor, but not be­fore com­mit­ting the be­hav­ior change. Never mix be­hav­ior changes with refac­tor­ing

Until the list is empty, go back to #2

My TDD skill con­tains a bit more de­tail but this is the essence of the process. This process does­n’t have much in­flu­ence over the de­sign of the tests them­selves, though, so I have a dif­fer­ent skill for that, Test Design Review. Test Design Review spawns a sep­a­rate agent (in an ef­fort to avoid bias), looks for vi­o­la­tions of de­sign prin­ci­ples (such as case is where a test fo­cus­ing on means rather than ends) and makes sug­ges­tions for fixes. Sometimes the “fixes” are du­bi­ous but usu­ally they’re on the mark. When I’m not sat­is­fied with the way my agent has writ­ten a cer­tain test, I run Test Design Review to try to let the agent catch its own mis­takes.

General de­sign re­view

Many test de­sign vi­o­la­tions are just vi­o­la­tions of gen­eral soft­ware de­sign prin­ci­ples, such as the prin­ci­ple of “call things what they are”. In ad­di­tion to feed­ing my tests through my Test Design Review skill, I like to feed them through my Software Design Review skill as well.

My agent sur­prises me some­times. In my TDD skill I in­cluded an in­struc­tion, with­out much ex­pec­ta­tion that it would par­tic­u­larly be fol­lowed, that if it turns out to be hard to write the test we want to write, that might be a sign we need to “clean the kitchen be­fore we make din­ner”. For what­ever rea­son, Claude has re­ally taken this to heart, and it pauses quite of­ten to ask if per­haps we should clean the kitchen, and quite of­ten it’s the case that we should.

I haven’t yet got­ten my agents to write ac­cept­able tests 100% of the time, not by a long shot, but my TDD skill has worked well enough for me that it has be­come my de­fault way of mak­ing any change. It’s not sur­pris­ing to me that ap­ply­ing these TDD and test de­sign prin­ci­ples yields such good re­sults. In my judg­ment, the biggest AI pro­duc­tiv­ity gains come from when AI is com­bined with time­less, im­mutable prin­ci­ples which were dis­cov­ered decades ago, hold just as true to­day, and which, no mat­ter what new tech­nolo­gies may arise, will never cease to be use­ful.

SpaceX has lined up an­other com­pute deal ahead of its his­toric IPO, this time with Google. The com­pany an­nounced the deal in a reg­u­la­tory fil­ing on Friday.

Under the terms of the deal, Google will pay SpaceX $920 mil­lion per month from October 2026 through June 2029 for ac­cess to “approximately 110,000 NVIDIA GPUs, CPUs, mem­ory, and other re­lated com­po­nents.”

The deal is sim­i­lar in length and scope to the one SpaceX an­nounced with Anthropic in late May. As part of that deal, Anthropic agreed to pay SpaceX $1.25 bil­lion per month through 2029 to rent all the avail­able com­pute from its Colossus 1 data cen­ter near Memphis, Tennessee, that xAI — now part of SpaceX — orig­i­nally built for its own ar­ti­fi­cial in­tel­li­gence ef­forts.

Google’s deal ap­pears to be pay­ing for roughly half the amount of com­pute that Anthropic has ac­cess to at Colossus 1. SpaceX did­n’t say which spe­cific data cen­ter Google would be us­ing. CEO Elon Musk has pre­vi­ously sug­gested his com­pany would re­serve the Colossus 2 data cen­ter for xAI.

Anthropic was sig­nif­i­cantly lim­ited in its com­pute ca­pac­ity prior to its deal with SpaceX, rais­ing us­age lim­its on the same day the deal was an­nounced. Google is in a very dif­fer­ent po­si­tion, with some es­ti­mates nam­ing it as the world’s largest sin­gle owner of AI com­pute.

In a state­ment, a Google rep­re­sen­ta­tive de­scribed the deal as a re­sult of un­ex­pected de­mand for its re­cently launched AI prod­ucts. “Google Cloud and SpaceX are long-time part­ners,” Google said in a state­ment. “This is a short-term, timely agree­ment to en­sure we have bridge ca­pac­ity to meet surg­ing cus­tomer de­mand for our agent plat­form, Gemini Enterprise, which has been even higher than we ex­pected.”

But its par­ent com­pany Alphabet is on a spend­ing spree. Alphabet has al­ready com­mit­ted to more than $180 bil­lion in cap­i­tal ex­pen­di­tures this year and has said it ex­pects that to “significantly in­crease” in 2027. To help with that, Alphabet re­cently an­nounced an $80 bil­lion eq­uity sale.

Also like the Anthropic deal, the agree­ment with Google in­cludes a can­cel­la­tion clause. Both SpaceX and Google have the op­tion to ter­mi­nate the agree­ment with 90 days’ no­tice af­ter December 31, 2026. Google’s ac­cess to the data cen­ter will ramp up “through September at a re­duced fee,” ac­cord­ing to the fil­ing.

“If we fail to de­liver ac­cess to the com­mit­ted amount of GPUs by September 30, 2026, then fol­low­ing a one-month grace pe­riod, Google may im­me­di­ately ter­mi­nate the agree­ment or ac­cept the num­ber of GPUs pro­vided” with a re­duc­tion in the monthly fees, it reads.

SpaceX an­nounced the deal just one week be­fore the com­pa­ny’s stock is ex­pected to start trad­ing on the Nasdaq ex­change. Paperwork filed with the Securities and Exchange Commission shows the com­pany is aim­ing to raise around $75 bil­lion at a val­u­a­tion of around $1.75 tril­lion — mak­ing it the largest in his­tory.

Google is a long­time in­vestor in SpaceX. Its stake in Musk’s com­pany is ex­pected to be worth more than $100 bil­lion af­ter the IPO. The com­pa­nies are also re­port­edly in talks to try to build or­bital data cen­ters — a ma­jor com­po­nent of SpaceX’s fu­ture plans post-IPO.

When you pur­chase through links in our ar­ti­cles, we may earn a small com­mis­sion. This does­n’t af­fect our ed­i­to­r­ial in­de­pen­dence.

Sean O’Kane is a re­porter who has spent a decade cov­er­ing the rapidly-evolv­ing busi­ness and tech­nol­ogy of the trans­porta­tion in­dus­try, in­clud­ing Tesla and the many star­tups chas­ing Elon Musk. Most re­cently, he was a re­porter at Bloomberg News where he helped break sto­ries about some of the most no­to­ri­ous EV SPAC flops. He pre­vi­ously worked at The Verge, where he also cov­ered con­sumer tech­nol­ogy, hosted many short- and long-form videos, per­formed prod­uct and ed­i­to­r­ial pho­tog­ra­phy, and once nearly passed out in a Red Bull Air Race plane.

You can con­tact or ver­ify out­reach from Sean by email­ing sean.okane@techcrunch.com or via en­crypted mes­sage at okane.01 on Signal.

View Bio