What I learned sell­ing 2500 MIDI recorders, part 1: Hardware is not so hard

A year and a half ago, I launched Jamcorder.

It marked the com­ple­tion of two life goals of mine.

First, I fi­nally had the pi­ano record­ing de­vice I’d al­ways wanted: a fully au­to­mated de­vice that cap­tures every­thing I play, no hu­man-in­volve­ment re­quired.

And sec­ond, af­ter a ca­reer in soft­ware, I got to build hard­ware. It was su­per fun.

2500 units have al­ready been sold, and count­ing! People gen­uinely love it! And it’s able to stand on its own feet as a busi­ness. In my eyes, that’s a suc­cess.

For my first blog post, I want to re­flect on the biggest sur­prise I en­coun­tered cre­at­ing Jamcorder.

Coming from a ca­reer in soft­ware, I ex­pected build­ing hard­ware to be the hard­est part.

After all, hard­ware is hard. That’s the say­ing, right?

Electronics de­sign, plas­tics, man­u­fac­tur­ing, ful­fil­ment, com­po­nent short­ages, etc, etc, etc.

I ex­pected these & more to make hard­ware hard.

But, it was­n’t.

I kept wait­ing for some­thing to get me by sur­prise. A scrapped pro­duc­tion run (my worst night­mare). Or com­po­nent sourc­ing is­sues, per­haps?

It never hap­pened. (Though Trump’s tar­iffs were a close call).

The hard­est part of build­ing Jamcorder was still, by far, the soft­ware — roughly 200K lines of code spread across the firmware, app, and man­u­fac­tur­ing tool­ing. It took over 3 years and many long nights in a pre-LLM world.

When com­pared to that, the hard­ware was un­de­ni­ably smooth sail­ing.

For the record, I don’t think I’m spe­cial. It’s just that hard­ware’s rep­u­ta­tion for be­ing dif­fi­cult is, IMO, over­stated.

Now, granted, Jamcorder is — very much in­ten­tion­ally — a sim­ple de­vice. I get that.

Assembly is just a sin­gle screw, for a sin­gle PCB. The in­jec­tion mold has gen­er­ous draft, no slides.

I cut low bat­tery de­tec­tion, am­bi­ent light de­tec­tion, the power-but­ton, even USB-C.

All these things kept Jamcorder sim­ple.

I’m also un­der no il­lu­sion that 2500 units is a lot by most stan­dards.

But you know what? The hard­ware side would have been easy re­gard­less.

Don’t get me wrong. If Jamcorder was 10x more com­plex, or 100x more scale, that would be a dif­fer­ent story (and a very pop­u­lar prod­uct!).

Or if I was try­ing to com­pete in the smart­watch mar­ket, or the car mar­ket, or any num­ber of very es­tab­lished in­dus­tries with low mar­gins, good luck.

But for me the take away still is: “hardware is as hard as you make it”.

If you’re think­ing about build­ing a hard­ware prod­uct & have a way to pro­tect your mar­gins, don’t let build­ing hard­ware scare you.

It’s not as hard as the say­ing goes.

POSTSCRIPT

I don’t want to end this ar­ti­cle with­out some prac­ti­cal take-aways. So here are my top rec­om­men­da­tions for suc­cess­fully ship­ping hard­ware that worked for me at medium scale:

Keep your BOM sim­ple. Avoid sin­gle-man­u­fac­turer com­po­nents wher­ever pos­si­ble.

Avoid com­plex as­sem­bly and cal­i­bra­tion.

Partner with a Chinese as­sem­bly house and sup­pli­ers. Alibaba is your friend.

Aim for at least 70% gross mar­gin or more.

Keep your com­pany lean. Scaling hard­ware is slower.

Have a strong anti-coun­ter­feit strat­egy. Don’t over­look this.

Do fi­nal Q/A in-house & hold fin­ished in­ven­tory lo­cally.

Request sam­ples be­fore every pro­duc­tion run.

Write a step-by-step man­u­fac­tur­ing & as­sem­bly guide with pic­tures.

Keep your pack­ag­ing small. A value dense prod­uct makes every­thing eas­ier.

19th July 2026

In Rewriting Bun in Rust Jarred Sumner made the fol­low­ing claim:

Claude Code v2.1.181 (released June 17th) and later use the Rust port of Bun. Startup got 10% faster on Linux but oth­er­wise, barely any­one no­ticed. Boring is good.

Claude Code v2.1.181 (released June 17th) and later use the Rust port of Bun. Startup got 10% faster on Linux but oth­er­wise, barely any­one no­ticed. Boring is good.

I de­cided to have a poke at my own Claude Code in­stal­la­tion to see if I could find ev­i­dence that it was us­ing Bun writ­ten in Rust.

I found these two com­mands con­vinc­ing:

strings ~/.local/bin/claude | grep -m1 ‘Bun v1’

For me this out­puts Bun v1.4.0 (macOS ar­m64). The most re­cent re­lease of Bun on GitHub is cur­rently v1.3.14 from May 12th, so that v1.4.0 ver­sion num­ber in Claude sup­ports them ship­ping a pre­view of a not-yet-re­leased Bun ver­sion.

(Update: The Rust ver­sion has been re­leased as Bun ca­nary - run­ning bun up­grade –canary will in­stall this re­lease.)

strings ~/.local/bin/claude | grep -Eo ‘src/[[:alnum:]_./-]+\.rs’

This out­puts a list of 563 file­names, start­ing with these:

src/​run­time/​bake/​de­v_server/​mod.rs src/​run­time/​bake/​pro­duc­tion.rs src/​bundler/​bun­dle_v2.rs

It looks like Bun in Rust is in­deed be­ing run in pro­duc­tion across mil­lions of dif­fer­ent de­vices. Like Jarred said, “Boring is good”.

Update: Here’s a neat trick from Ajan Raj:

cat > /tmp/bun-version.ts <<‘EOF’ con­sole.log(“em­bed­ded bun:”, Bun.version); process.exit(0); EOF BUN_OPTIONS=“–preload=/tmp/bun-version.ts” claude –version

This out­puts 1.4.0 for me.

Here’s the com­mit from May 17th that up­dated the ver­sion in pack­age.json to 1.4.0. That ver­sion has­n’t been changed since then, but also has­n’t yet made it into a tagged re­lease out­side of ca­nary.

Showcase Reel

Watch the Recap Video

Released July 14th, 2026

GEOMETRY NODES

Music to your Nodes

Imagine dri­ving your nodes with im­ported au­dio files, how does that sound?

The Sample Sound Frequencies node, cou­pled with the new Sound socket, brings au­dio-re­ac­tive an­i­ma­tions and sim­u­la­tions to Geometry Nodes.

Sound files can be loaded di­rectly into the node tree. To hear them dur­ing play­back, add them to the Video Sequencer as well, and set Playback Sync to “Sync to Audio”.

GEOMETRY NODES

Bevel and be well

A new node en­ters the chat: Mesh Bevel.

The long awaited power of de­tailed pro­ce­dural con­trol over the edges or ver­tices.

Cloth Dynamics

Quickly add a cloth-like be­hav­iour to any mesh with a new node-based mod­i­fier (and a node group as well). Comes with a list of built-in con­trols for pin­ning, tear­ing, con­trol­ling stretch and bendi­ness.

Hair Dynamics

Hair physics work sim­i­larly to cloth: the only ex­tra re­quire­ment is hav­ing a sur­face ob­ject to at­tach hair to. The set up it­self can be au­to­mated with the up­dated Empty hair op­er­a­tor.

Effectors

New node-based dy­nam­ics come with a bunch of built-in ef­fec­tors for ef­fort­less grav­ity and/​or sur­face col­li­sion ap­pli­ca­tion. In 5.2. LTS, three types of cus­tomis­able ef­fec­tors are avail­able:

Colliders

Apply a Collider mod­i­fier to trans­form any closed mesh into a col­li­sion ob­ject. Or go fur­ther in a fully pro­ce­dural set up and use the col­lider ef­fec­tor bun­dle and pass into the dy­nam­ics node.

Forces

Built-in grav­ity setup is avail­able, as well as end­less pos­si­bil­i­ties to build your own cus­tom forces.

Custom ef­fec­tors

Inject fully cus­tom be­hav­iour into sim­u­la­tions us­ing Closure and Custom Effector nodes.

Tag&Filter

Tag-based fil­ter­ing sys­tem for ef­fec­tors is also here to eas­ily de­ter­mine which geome­tries they af­fect. Each sim­u­lated geom­e­try can have mul­ti­ple tags for the ef­fec­tor to spec­ify which tags it should af­fect.

Physics: Solved

Reimagined, node based: Blender 5.2. LTS in­tro­duces a brand new pro­ce­dural ap­proach to physics for hair and cloth sim­u­la­tions.

The power be­hind ex­per­i­men­tal node-based physics lies within the new built-in XPBD Solver node.

While built-in as­sets con­tain use-case spe­cific de­clar­a­tive sys­tems around it, ad­vanced users can cus­tomize the sim­u­la­tions fur­ther. Adapt ex­ist­ing node groups by edit­ing con­straints as needed or cre­ate a new sim­u­la­tion sys­tem from scratch.

What the com­mu­nity is cre­at­ing with node-based physics

Bundle Up

Blender 5.0 in­tro­duced the con­cept of bun­dles, which can now be at­tached to geom­e­try to carry ar­bi­trary data across mod­i­fier and ob­ject bound­aries.

Use new Get Geometry Bundle and Set Geometry bun­dle nodes to un­lock new work­flows and pos­si­bil­i­ties.

More Geometry Nodes

Lists

New core data type that al­lows stor­ing a se­quence of ar­bi­trary length (e.g. num­bers or strings). Lots of new nodes were added to pro­vide con­trol.

Create lists through Field to List and Closure to List nodes.

Access lists with List Length and Get List Item nodes.

Modify lists with clas­sic Math nodes as well as new Filter List and Sort List nodes.

Attributes

The Capture Attribute node now sup­ports se­lec­tion.

The new Rename Attribute node re­names at­trib­utes with a spe­cific pre­fix.

The Get Attribute Names node out­puts a list of the names of at­trib­utes in a geom­e­try, op­tion­ally fil­tered by do­main and data type.

The new Transfer Attributes node can trans­fer an ar­bi­trary num­ber of at­trib­utes from one geom­e­try to an­other.

Attributes can now be stored as 4D float vec­tors (note that Geometry Nodes cur­rently only op­er­ate on 3D vec­tors).

Strings

Geometry Nodes now sup­port String fields.

The Find in String node can now find the first oc­cur­rence from the end.

Remove spe­cific char­ac­ters at the start or end of a string with the new Trim String node.

Reverse the char­ac­ter or­der in a string with the new Reverse String.

Switch be­tween up­per and lower case through the new Set String Case.

String and String to ValueBaseinput.

Split text into a list based on a de­lim­iter with new Split String node.

Empty Objects

Geometry nodes mod­i­fiers can be now ap­plied to emp­ties. Recommended use: cus­tom ef­fec­tors for sim­u­la­tions, pro­ce­dural ef­fects that don’t re­quire orig­i­nal geom­e­try.

Curves

You can now ac­cess built-in at­trib­utes to con­trol the com­pu­ta­tion of the fi­nal curve with the new Set NURBS Order and Set NURBS Weight nodes.

Node Tools

Node tools in­puts are re­mem­bered be­tween op­er­a­tor in­vo­ca­tions.

Node tool in­puts can now be as­signed in Python.

Performance

Internal fields pre-eval­u­a­tion dedu­pli­ca­tion.

Face cor­ner eval­u­a­tion is now avoided in some sam­pling nodes.

Preferences: con­fig­ure a new call stack depth limit for Geometry Nodes.

Other

New in: Collection Children node for ac­cess­ing all the Child Objects and Collections of a Collection as a list.

New in: Principal Component Analysis nodes.

3 new build­ing block nodes as­so­ci­ated with Merge by Distance for ex­panded con­trol over merg­ing.

Node group in­puts: new Scene Frame de­fault in­put type.

Object sock­ets can now have Self Object as a de­fault in­put mode.

Access the in­ter­nal at­tribute which tells in­stances what geom­e­try to in­stance with the new Instance Reference node.

Extract a sin­gle com­po­nent of a geom­e­try or edit it in a new sim­pler way with the Get Geometry Component node.

Closures can now be called re­cur­sively.

Display data-block name in Viewer Node.

Data-blocks sock­ets can now be com­pared to each other and to None.

Bone Info: New “Exists” out­put.

CYCLES

Cached In

On scenes with many im­age tex­tures, the new Texture Cache sig­nif­i­cantly re­duces mem­ory us­age and startup time by au­to­mat­i­cally gen­er­at­ing smaller, op­ti­mized tex­ture files that load only the tiles and res­o­lu­tions needed for ren­der­ing.

Texture Cache Off

Texture Cache On

Attic

Attic

Bistro

Bistro

Junkshop

Junkshop

0

1000

2000

3000

4000

5000

6000

Memory us­age

Unit: MB

CYCLES

Easy Savings

One tog­gle, loads of mem­ory sav­ings.

“Wait wait wait wait wait wait.”

Whatever you were look­ing for is no longer here (404)

Have a ques­tion about this pro­ject? Sign up for a free GitHub ac­count to open an is­sue and con­tact its main­tain­ers and the com­mu­nity.

Sign up for GitHub

By click­ing “Sign up for GitHub”, you agree to our terms of ser­vice and pri­vacy state­ment. We’ll oc­ca­sion­ally send you ac­count re­lated emails.

Already on GitHub? Sign in to your ac­count

TL;DR

Researchers found AI ad­vice sup­pressed judg­ment sus­pen­sion from 44% to 3%, ac­cu­racy from 27% to 9%, while con­fi­dence rose from 30% to 76%. People trusted wrong AI an­swers.

Researchers from three French and Italian uni­ver­si­ties found that ac­cess to AI ad­vice col­lapsed peo­ple’s will­ing­ness to say “I don’t know” from 44% to 3%. Accuracy dropped from 27% to 9%. Confidence, mean­while, rose from 30% to 76%. “People be­came much worse, the ac­cu­racy was only one third, but they were twice as con­fi­dent,” said Valerio Capraro, as­so­ci­ate pro­fes­sor at the University of Milano-Bicocca.

The study, au­thored by Capraro with Chiara Marcoccia of École Normale Supérieure and Walter Quattrociocchi of Sapienza University of Rome, de­lib­er­ately used ques­tions where AI mod­els typ­i­cally fail: vi­sual de­tails from films, such as the colour of a team’s uni­form in Bend It Like Beckham. The re­searchers used Step 3.5 Flash, a model that was usu­ally wrong on these ques­tions, pre­cisely so any re­duc­tion in judg­ment could not be ex­plained as sen­si­ble del­e­ga­tion to a re­li­able tool. Some par­tic­i­pants who would have an­swered cor­rectly on their own asked the AI and be­came wrong.

Monetary in­cen­tives helped, but not much. Willingness to ad­mit ig­no­rance rose from 3% to 8% and ac­cu­racy from 9% to 16%, both still well be­low the no-AI base­lines of 44% and 27%. Wharton re­searchers coined the term “cognitive sur­ren­der” ear­lier this year to de­scribe the same phe­nom­e­non: peo­ple ac­cept­ing in­cor­rect AI an­swers 80% of the time while re­port­ing higher con­fi­dence than those work­ing with­out AI. The new study adds a sharper data point. It is not just that peo­ple trust wrong AI an­swers. It is that the mere avail­abil­ity of AI sup­presses the cog­ni­tive habit of recog­nis­ing what you do not know.

The 💜 of EU tech

The lat­est rum­blings from the EU tech scene, a story from our wise ol’ founder Boris, and some ques­tion­able AI art. It’s free, every week, in your in­box. Sign up now!

“For hu­mans, the ca­pac­ity to say ‘I don’t know’ is very im­por­tant be­cause it rep­re­sents the recog­ni­tion of the lim­its of our own knowl­edge,” Capraro said. He is par­tic­u­larly con­cerned about chil­dren, who are grow­ing up with these sys­tems be­fore they have de­vel­oped crit­i­cal think­ing skills. Google’s AI search over­haul re­placed links with con­fi­dent AI-generated sum­maries, and Common Sense Media this week called that de­sign an “unacceptable risk” for stu­dents. The pat­tern is con­sis­tent: AI prod­ucts are de­signed to an­swer, never to say “I don’t know.” The hu­mans us­ing them are learn­ing to do the same.

Get the TNW newslet­ter

Get the most im­por­tant tech news in your in­box each week.

Happy Snapshot Tues… Thursday? Yes, you read that right! As we’ve en­tered peak va­ca­tion sea­son here in Sweden, snap­shots might not come out on their usual sched­ule.

In to­day’s snap­shot we have switched the li­brary used for win­dow man­age­ment, in­put and plat­form in­te­gra­tion from GLFW to SDL3.

We have also added new item com­po­nents for cus­tom fur­nace fu­els, as well as sev­eral tech­ni­cal changes for signs, world gen­er­a­tion and loot ta­bles.

Happy min­ing!

Known Issues

Exclusive fullscreen mode on Windows may cause the game to crash in cer­tain sit­u­a­tions, es­pe­cially when us­ing mul­ti­ple mon­i­tors

Entering Exclusive fullscreen mode crashes the game on Wayland

New Features

Players in spec­ta­tor mode can now in­ter­act with por­tals to tele­port

Changes

Minor Tweaks to Blocks, Items and Entities

Armadillos no longer try to roll up when sub­merged in liq­uids

UI

Removed the Raw Input mouse set­ting­Mouse in­put now al­ways uses rel­a­tive mouse mode while play­ing in-game

Mouse in­put now al­ways uses rel­a­tive mouse mode while play­ing in-game

Key bind­ings now use phys­i­cal keys in­stead of key­board-lay­out-spe­cific key codes

Borderless Fullscreen is now the de­fault fullscreen mode

Switching be­tween Borderless and Exclusive Fullscreen no longer re­quires restart­ing the game

Exclusive fullscreen mode on ma­cOS is no longer sup­ported

The min­i­mum win­dow size is now 320 by 240 pix­els

On ma­cOS, hold­ing a key while en­ter­ing text now dis­plays the na­tive ac­cent and can­di­date popup

On Linux sys­tems, the game will now use and pre­fer Wayland na­tively if avail­able

Debug Overlay

The de­bug over­lay now sup­ports a sep­a­rate GUI scale than the rest of the ga­me­This is cus­tomiz­able through the Debug Options screen, F3 + F6The de­fault scale is “Auto”, which tries to stay at a higher res­o­lu­tion than nor­malAn­other op­tion is “Unchanged”, which matches your reg­u­lar GUI scaleThe rest of the op­tions work the same as in the nor­mal “GUI Scale”, con­trol­ling the scale di­rectly

This is cus­tomiz­able through the Debug Options screen, F3 + F6

The de­fault scale is “Auto”, which tries to stay at a higher res­o­lu­tion than nor­mal

Another op­tion is “Unchanged”, which matches your reg­u­lar GUI scale

The rest of the op­tions work the same as in the nor­mal “GUI Scale”, con­trol­ling the scale di­rectly

Added a “player_speed” de­bug en­try that dis­plays the speed of the player in blocks per tick.

The de­bug over­lay now shows the dis­play re­fresh rate

Creative Inventory

Reordered min­eral item and block or­der­ing to have non-tiered in­gre­di­ents up first, then tiered in­gre­di­ents that craft into equip­ment last­In­gre­di­entsNon-tiered min­er­al­sUn­re­fined tiered min­er­al­sRe­fined tiered min­er­al­sNuggetsIn­gots

Building BlocksNon-tiered min­eral blocks and vari­antsRe­fined tiered min­eral blocks and vari­antsCop­per block fam­ily Copper Blocks con­tinue to be pushed to the end of the or­der in Building Blocks since they have a large list of con­tent

IngredientsNon-tiered min­er­al­sUn­re­fined tiered min­er­al­sRe­fined tiered min­er­al­sNuggetsIn­gots

Non-tiered min­er­als

Unrefined tiered min­er­als

Refined tiered min­er­al­sNuggetsIn­gots

Nuggets

Ingots

Building BlocksNon-tiered min­eral blocks and vari­antsRe­fined tiered min­eral blocks and vari­antsCop­per block fam­ily

Non-tiered min­eral blocks and vari­ants

Refined tiered min­eral blocks and vari­ants

Copper block fam­ily

Copper Blocks con­tinue to be pushed to the end of the or­der in Building Blocks since they have a large list of con­tent

Improved or­der­ing of Natural Blocks tab so that all in­ner or­der­ing of group con­tent se­quen­tially pro­gresses from Overworld -> Nether -> End to stay con­sis­tent with other tabs

Technical Changes

The Data Pack ver­sion is now 111.0

The Resource Pack ver­sion is now 92.0

Loot table types that have a ded­i­cated reg­istry now sup­port reg­istry el­e­ment and tag ref­er­ences­This means that the ma­jor­ity of fields of such types that pre­vi­ously ac­cepted sin­gle el­e­ments will now ac­cept ei­ther a name­spaced ID or an in­line value, while fields that pre­vi­ously ac­cepted lists can now ac­cept an in­line value, a sin­gle name­spaced ID, a list of name­spaced IDs, a list of in­line val­ues, or a hash-pre­fixed tag IDAffected types:minecraft:ad­vance­ment­minecraft:item_­mod­i­fier­minecraft:loot_tablem­inecraft:num­ber_provi­der­minecraft:pred­i­catem­inecraft:recipem­inecraft:slot_­source Existing ref­er­ence types for pred­i­cates, item mod­i­fiers and slot sources are now ob­so­lete and have been re­moved

This means that the ma­jor­ity of fields of such types that pre­vi­ously ac­cepted sin­gle el­e­ments will now ac­cept ei­ther a name­spaced ID or an in­line value, while fields that pre­vi­ously ac­cepted lists can now ac­cept an in­line value, a sin­gle name­spaced ID, a list of name­spaced IDs, a list of in­line val­ues, or a hash-pre­fixed tag ID

Affected types:minecraft:ad­vance­ment­minecraft:item_­mod­i­fier­minecraft:loot_tablem­inecraft:num­ber_provi­der­minecraft:pred­i­catem­inecraft:recipem­inecraft:slot_­source

minecraft:ad­vance­ment

minecraft:item_­mod­i­fier

minecraft:loot_table

minecraft:num­ber_provider

minecraft:pred­i­cate

minecraft:recipe

minecraft:slot_­source

Existing ref­er­ence types for pred­i­cates, item mod­i­fiers and slot sources are now ob­so­lete and have been re­moved

Windowing and Input Backend

Minecraft now uses SDL3 in­stead of GLFW for win­dow man­age­ment, in­put and plat­form in­te­gra­tion

Keyboard in­put now uses SDL scan­codes for phys­i­cal key po­si­tions and SDL key­codes for lay­out-de­pen­dent text edit­ing short­cuts

Data Pack Version 111.0

Signs no longer au­to­mat­i­cally ex­e­cute click events in cus­tom text

Commands

Changes to spread­play­ers

Whether a block is safe to spread a player to is now con­trolled by the #entities_can_teleport_to block tag

Environment Attributes

Added minecraft:game­play/​nat­ur­al_­mob_s­pawns

Defines mob spawns in an Environment Attribute Source

During world­gen place­ment, only Dimensions and Biomes will ap­ply this Environment Attribute

Format: ob­ject with fields:spawn­s_­by_­cat­e­gory - map of spawn cat­e­gory to weighted list of spawn dataS­pawn data for­mat: ob­ject with fields:type - en­tity type, the en­tity to spawn­count - int provider, amount to spawn

spawn_­costs - map of en­tity type to ob­ject with fields:en­er­gy_bud­get - float, en­ergy change al­lowed per spawn­charge - float, how much ex­ist­ing mobs will at­tract or re­pulse other charged mobs

spawn­s_­by_­cat­e­gory - map of spawn cat­e­gory to weighted list of spawn dataS­pawn data for­mat: ob­ject with fields:type - en­tity type, the en­tity to spawn­count - int provider, amount to spawn

Spawn data for­mat: ob­ject with fields:type - en­tity type, the en­tity to spawn­count - int provider, amount to spawn

type - en­tity type, the en­tity to spawn

count - int provider, amount to spawn

spawn_­costs - map of en­tity type to ob­ject with fields:en­er­gy_bud­get - float, en­ergy change al­lowed per spawn­charge - float, how much ex­ist­ing mobs will at­tract or re­pulse other charged mobs

en­er­gy_bud­get - float, en­ergy change al­lowed per spawn

charge - float, how much ex­ist­ing mobs will at­tract or re­pulse other charged mobs

Available at­tribute mod­i­fiers:over­lay­For each mob cat­e­gory, over­rides the lower lay­er’s spawn set­tings with the higher lay­er’s, un­less the cat­e­gory is not in­clud­ed­Merges each lay­er’s spawn costs to­gether, over­rid­ing the lower lay­er’s spawn costs with the higher lay­er’s if both de­fine the same en­tity type

over­lay­For each mob cat­e­gory, over­rides the lower lay­er’s spawn set­tings with the higher lay­er’s, un­less the cat­e­gory is not in­clud­ed­Merges each lay­er’s spawn costs to­gether, over­rid­ing the lower lay­er’s spawn costs with the higher lay­er’s if both de­fine the same en­tity type

For each mob cat­e­gory, over­rides the lower lay­er’s spawn set­tings with the higher lay­er’s, un­less the cat­e­gory is not in­cluded

Merges each lay­er’s spawn costs to­gether, over­rid­ing the lower lay­er’s spawn costs with the higher lay­er’s if both de­fine the same en­tity type

Default: Empty

Added minecraft:game­play/​crea­ture_­world_­gen_s­pawn_prob­a­bil­ity

Sets the prob­a­bil­ity to run an it­er­a­tion in which mobs de­fined to spawn in the crea­ture mob cat­e­gory will spawn dur­ing world gen­er­a­tion

Only Dimensions and Biomes will ap­ply this Environment Attribute

Format: float with range [0,1)

Default: 0.1

Changed minecraft:vi­sual/​am­bi­en­t_­par­ti­cles

Now sup­ports in­ter­po­la­tion be­tween Timeline keyframes (probabilities will be cross­faded)

Introduced sup­port for new mod­i­fier: ap­pen­dUn­like over­ride which to­tally re­places the par­ti­cle list, this mod­i­fier con­cate­nates all el­e­ments with the lay­ers be­low

Unlike over­ride which to­tally re­places the par­ti­cle list, this mod­i­fier con­cate­nates all el­e­ments with the lay­ers be­low

Data Components

Added minecraft:cook­ing_­fuel

Describes an item that can be used as fuel for a Furnace, Smoker or Blast Furnace

Format: ob­ject with fields­burn_­time - name­spaced ID point­ing to an el­e­ment of minecraft:num­ber_provider reg­istry rep­re­sent­ing the time, in ticks, for which this fuel will burn­speed_­mul­ti­plier - name­spaced ID point­ing to an el­e­ment of minecraft:num­ber_provider reg­istry rep­re­sent­ing the speed of the cook­ing/​smelt­ing

burn_­time - name­spaced ID point­ing to an el­e­ment of minecraft:num­ber_provider reg­istry rep­re­sent­ing the time, in ticks, for which this fuel will burn

speed_­mul­ti­plier - name­spaced ID point­ing to an el­e­ment of minecraft:num­ber_provider reg­istry rep­re­sent­ing the speed of the cook­ing/​smelt­ing

Elementary school stu­dents might mem­o­rize their times ta­bles for sin­gle-digit num­bers, but mem­o­riza­tion won’t cut it when the teacher asks for three-digit mul­ti­pli­ca­tion. This re­quires an al­go­rithm: stu­dents are taught to stack one num­ber atop an­other and mul­ti­ply each digit of the bot­tom num­ber by each digit of the top one. For mil­len­nia, math­e­mati­cians be­lieved this to be the fastest mul­ti­pli­ca­tion method, un­til a 23-year-old made a shock­ing dis­cov­ery in 1960, which led to a mys­tery that re­mains un­solved to this day.

This mys­tery is crit­i­cal to any­one who par­takes in the dig­i­tal world be­cause mul­ti­pli­ca­tion is a foun­da­tional op­er­a­tion for com­put­ers. Encryption, ro­bot­ics, ar­ti­fi­cial in­tel­li­gence, au­dio pro­cess­ing and pretty much every­thing else we task sil­i­con chips with in­volves mul­ti­pli­ca­tion, some­times of huge num­bers many times over. At this scale, even a sim­ple op­er­a­tion be­comes a bot­tle­neck, and any ex­tra ef­fi­ciency has global eco­nomic con­se­quences.

To un­der­stand the na­ture of that bot­tle­neck, ob­serve how the grade-school al­go­rithm han­dles growth. When you mul­ti­ply two two-digit num­bers, you per­form four sin­gle-digit mul­ti­pli­ca­tions. If you bump that up to a three-digit pair of num­bers, you do nine sin­gle-digit mul­ti­pli­ca­tions. The work­load scales with the square of the num­ber of dig­its (n2, where n is the num­ber of dig­its in the num­bers be­ing mul­ti­plied). When an­a­lyz­ing an al­go­rithm like this, com­puter sci­en­tists don’t mea­sure speed in sec­onds, be­cause that de­pends on the hard­ware. Instead they count the com­pu­ta­tional steps. They also ig­nore mi­nor book­keep­ing de­tails, such as the time it takes to carry a one when mul­ti­ply­ing. When num­bers get large enough, those lower-level op­er­a­tions cease to mat­ter, en­tirely eclipsed by the more in­ten­sive op­er­a­tions in­volved. Computer sci­en­tists de­note the num­ber of steps us­ing what’s called Big O no­ta­tion: the grade-school al­go­rithm, for ex­am­ple, takes O(n2) steps, which is read as “order n squared.” Broadly speak­ing, if the num­bers are twice as long, the al­go­rithm takes four times as much com­pu­ta­tional work to ex­e­cute. If the num­bers are a thou­sand times as long, it takes a mil­lion (1,000 squared) times as much work.

On sup­port­ing sci­ence jour­nal­ism

If you’re en­joy­ing this ar­ti­cle, con­sider sup­port­ing our award-win­ning jour­nal­ism by sub­scrib­ing. By pur­chas­ing a sub­scrip­tion you are help­ing to en­sure the fu­ture of im­pact­ful sto­ries about the dis­cov­er­ies and ideas shap­ing our world to­day.

Since an­tiq­uity, math­e­mati­cians have sus­pected that O(n2) was an in­her­ent speed limit for mul­ti­pli­ca­tion. The cel­e­brated Soviet math pro­fes­sor Andrey Kolmogorov posed the O(n^2) speed limit as a for­mal con­jec­ture and men­tioned it dur­ing a 1960 sem­i­nar at Moscow State University. Whenever math­e­mati­cians pro­pose a con­jec­ture, they are plant­ing a flag of sorts and wait­ing for oth­ers to ei­ther prove or dis­prove them. It took just a week for Anatoly Karatsuba, then a 23-year-old stu­dent in the au­di­ence, to re­turn and prove Kolmogorov wrong. Kolmogorov was stunned. The re­sult was pub­lished in the pres­ti­gious Proceedings of the USSR Academy of Sciences, but amus­ingly, Karatsuba did­n’t write it. Kolmogorov wrote the for­mal proof him­self and sub­mit­ted it for pub­li­ca­tion with Karatsuba listed as the lead au­thor. Karatsuba only found out about the pa­per when he re­ceived the reprints in the mail.

Karatsuba’s ge­nius was re­al­iz­ing that you can trade ex­pen­sive, time-con­sum­ing mul­ti­pli­ca­tions for cheap, fast ad­di­tions. Adding two n-digit num­bers takes only O(n) time be­cause it en­tails a sin­gle sweep through the dig­its rather than a com­plete sweep through the top num­ber for every digit of the bot­tom num­ber, as in mul­ti­pli­ca­tion. To see how Karatsuba traded mul­ti­pli­ca­tion for ad­di­tion, let’s look at a small ex­am­ple. The method would be overly com­pli­cated for such a sim­ple prob­lem, but it saves a mean­ing­ful amount of time when num­bers get larger.

In this sim­ple ex­am­ple, let’s cal­cu­late 12 × 34.

First, we split both num­bers into their tens and ones dig­its. Assign a = 1 and b = 2 (for 12), and c = 3 and d = 4 (for 34). Algebraically, we can rewrite 12 × 34 as (10a + b) × (10c + d).

Expanding this gives 100(ac) + 10(ad + bc) + (bd).

To solve the equa­tion in the tra­di­tional way, one must per­form four dis­tinct mul­ti­pli­ca­tions: ac = 3, ad = 4, bc = 6 and bd = 8, which is ex­actly what the grade-school stack­ing method en­tails. (Note that we don’t count the mul­ti­pli­ca­tions by 100 or by 10 be­cause those only in­volve plop­ping ze­roes at the ends of num­bers.) Karatsuba no­ticed a bril­liant al­ge­braic trick. Once you com­pute the first and last terms, ac and bd, you can fig­ure out that pesky mid­dle term (ad + bc) with one more mul­ti­pli­ca­tion step rather than two. You don’t need to cal­cu­late ad and bc in­di­vid­u­ally:

(ad + bc) = ((a + b) × (c + d)) — ac — bd,

Or with our con­crete num­bers:

((1 × 4) + (2 × 3)) = ((1 + 2) × (3 + 4)) — 3 – 8 = 10.

Pause to no­tice the weird­ness in the equa­tion above. It sug­gests that to mul­ti­ply 12 × 34 quickly, you should add the 1 and the 2 in 12 and the 3 and the 4 in 34. This is hardly a nat­ural thing to do. No won­der it took so long for some­one to fig­ure it out. It ends up re­duc­ing the work­load, how­ever: be­cause we’ve al­ready com­puted ac and bd, the right-hand side only con­tains one more mul­ti­pli­ca­tion, plus some ad­di­tions and sub­trac­tions.

Returning to 100(ac) + 10(ad + bc) + (bd), we only need three mul­ti­pli­ca­tions rather than four. We com­pute ac and bd in the straight­for­ward way and then use Karatsuba’s trick to com­pute (ad + bc) with a sin­gle mul­ti­pli­ca­tion. Plugging in ac = 3, bd = 8 and (ad + bc) = 10 gives our an­swer of 408.

We shaved one mul­ti­pli­ca­tion off the pro­ce­dure. If that seems measly, Karatsuba has an­other in­sight in store. Say we’re mul­ti­ply­ing big­ger num­bers: 1,234 × 5,678. We split them in half like we did be­fore: a = 12, b = 34, c = 56 and d = 78, and we write the prob­lem as (100a + b) × (100c + d) = 10,000(ac) + 100(ad + bc) + (bd).

We can solve this with three mul­ti­pli­ca­tions. Those mul­ti­pli­ca­tions, how­ever, now in­volve two-digit num­bers. Luckily, we know a way to mul­ti­ply two-digit num­bers with only three sin­gle-digit mul­ti­pli­ca­tions each! In to­tal, a prob­lem that would take 16 sin­gle-digit mul­ti­pli­ca­tions the tra­di­tional way now needs only nine. By re­cur­sively ap­ply­ing Karatsuba’s trick on large num­bers, the sav­ings com­pound. It splits the in­put num­bers in half, then splits those halves in half, and so on, ap­ply­ing this four-for-three trade all the way down. The al­go­rithm works out to have a run­ning time of roughly O(n1.585), which is dras­ti­cally faster than O(n2). For ref­er­ence, mul­ti­ply­ing a pair of thou­sand-digit num­bers in­volves a mil­lion sin­gle-digit mul­ti­pli­ca­tions us­ing the grade-school method but fewer than 57,000 us­ing Karatsuba’s al­go­rithm.

The 23-year-old’s ef­fi­ciency is baked into soft­ware that runs every day. Because of its ex­tra over­head (the ad­di­tions, man­ag­ing the re­peated split­ting and re­com­bin­ing of num­bers, and so on) its ad­van­tages over the grade-school al­go­rithm don’t kick in un­til num­bers grow rel­a­tively big. Python, for ex­am­ple, is a pop­u­lar pro­gram­ming lan­guage that is fa­mously smooth at han­dling in­te­gers of any size. If you peek into Python’s un­der­ly­ing source code (search “Karatsuba” here), you will see it re­lies on a hy­brid ap­proach. For mod­estly sized in­puts, it uses the grade-school math, but once num­bers reach around 630 dec­i­mal dig­its, it flips a switch and em­ploys Karatsuba’s al­go­rithm. That many dig­its might seem gar­gan­tuan by ter­res­trial stan­dards, but com­put­ers deal with much big­ger. (Technical aside: On most mod­ern ma­chines Python stores large num­bers in base 230, so the linked Karatsuba cut­off of 70 dig­its in base 230 trans­lates to roughly 630 dec­i­mal dig­its).

Karatsuba’s al­go­rithm ig­nited a decades-long race to find the ul­ti­mate speed limit of mul­ti­pli­ca­tion. That pur­suit cul­mi­nated in 2019, when math­e­mati­cians David Harvey and Joris van der Hoeven de­scribed an ex­tremely so­phis­ti­cated al­go­rithm that beat Karatsuba’s by more than any of the pre­vi­ous break­throughs. The new al­go­rithm runs in O(n × log n) time. Here log de­notes the log­a­rithm of n, which is a func­tion that grows very slowly. It’s a stag­ger­ing re­sult. The func­tion n × log n is just a lit­tle bit big­ger than n it­self. This means that cal­cu­lat­ing the prod­uct of two mas­sive num­bers re­quires only a lit­tle more time than adding them, or even read­ing them, would in the first place (it takes n com­pu­ta­tional steps to read all n dig­its of a num­ber).

The tri­umph comes with a cru­cial caveat, though. Just as Karatsuba’s al­go­rithm only out­per­forms the grade-school ap­proach when num­bers get rea­son­ably large, the Harvey-van der Hoeven al­go­rithm does­n’t pull ahead un­til the num­bers be­come truly galac­tic. In com­puter sci­ence, a “galactic al­go­rithm” is a for­mal term for a method that is im­pres­sively ef­fi­cient on suf­fi­ciently large num­bers but will never be use­ful in prac­tice be­cause the num­bers are so large.

Even with that as­ter­isk, it was a wa­ter­shed achieve­ment. It se­cured the record for the fastest known mul­ti­pli­ca­tion method in prin­ci­ple and could pave the way for al­go­rithms that run in O(n × log n) steps, not just in prin­ci­ple, but in prac­tice. Today, the­o­ret­i­cal com­puter sci­en­tists widely sus­pect that O(n × log n) is the fastest pos­si­ble speed for mul­ti­pli­ca­tion, and for­mally prov­ing it has be­come the holy grail for this niche field of math­e­mat­ics. But as his­tory re­minds us, wide­spread con­sen­sus is not a math­e­mat­i­cal proof. Conjectures about the speed limit of mul­ti­pli­ca­tion have been over­turned be­fore.

Token Plan Upgraded

Individual is now avail­able, and Team is more af­ford­able. Get ad­vanced mod­els like Qwen3.8-Max-Preview for less—and start build­ing with AI to­day.To­ken Plan

Multiple Models, One Plan

One plan of­fers uni­fied ac­cess to lead­ing text, vi­sion, speech, and im­age gen­er­a­tion mod­els.

Seamless AI Toolchain Integration

Higher Quota, Better Price

Multiple Models, One Plan

One plan of­fers uni­fied ac­cess to lead­ing text, vi­sion, speech, and im­age gen­er­a­tion mod­els.

Seamless AI Toolchain Integration

Higher Quota, Better Price

Token Plan Special Offer

Token Plan of­fers Individual and Team Plans — choose the one that fits your needs.Learn more

Lite Plan

/month

Access mul­ti­ple mod­elsModel List

Accessharness tools

Run 1 – 2 agents con­cur­rently

Standard Plan

Hot

/month

4x the cred­its of Lite Plan

Everything in Lite Plan

Run 3 – 4 agents con­cur­rently

Pro Plan

/month

16x the cred­its of Lite Plan

Everything in Standard Plan

Run 6 – 8 agents con­cur­rently

Supported AI Tools

Token Plan works with main­stream tools that sup­port OpenAI and Anthropic pro­to­col­sLearn More

Frequently Asked Questions

How do I use the Token Plan Individual?

After sub­scrib­ing to Token Plan Individual, fol­low these steps:

• Subscribe: Buy Token Plan on this page. • Get your cre­den­tials: Go to the 「API Keys」page to get your base URL and API key. • Configure and use: Enter the base URL and API key in any sup­ported AI tool to com­plete setup. (Note: For tool-spe­cific setup in­struc­tions, see the in­te­gra­tion guide.)

Can I sub­scribe to mul­ti­ple Token Plan Individual plans at once?

Does Token Plan Individual sup­port re­funds?

How do I check my Token Plan us­age?

If you are look­ing for a rea­son to cel­e­brate to­day, the last of the MPEG-4 Part 2 patents ex­pired to­day.

While the US and EU patents around MPEG-4 Part 2 ex­pired in re­cent years, un­til to­day there re­mained one patent still ac­tive in Brazil. This fi­nal patent was BRPI0109962B1 - “process for stor­ing and pro­cess­ing im­age in­for­ma­tion from suc­ces­sive im­ages over time”.

The VIA Licensing Alliance con­firmed that this was the fi­nal MPEG-4 Visual patent and in­deed ex­pir­ing to­day, 19 July 2026.

Great to see this day fi­nally re­al­ized given the preva­lence of MPEG-4.