nahuel genchi

inside kirby super star ultra

2026-10-13T12:00:00Z

kirby's dead land is a mod that puts kirby in dead cells. it does not redraw him. the real game from 2008, kirby super star ultra, runs hidden inside an emulator, sixty times a second, and dead cells borrows its hero: his jump, his sword, his appetite. to wire one game into another like that, the guest has to be known from the inside. so the cartridge was read, end to end. this is what is in there.

5,996 functions · 157 pieces of program · 42 enemies · 4,096 random numbers · 48 hit records

dead cells starts a frame
the hidden DS runs one frame of kirby's game
the mod reads kirby out
- where he is
- his sprites
- his hits
dead cells draws him and takes the hits

every number below was measured on that hidden game, on a workbench copy of the emulator, with nothing on screen.¹

a cartridge that is mostly film

the cartridge holds 134 megabytes and the game fills 76 of them. most of that is not game at all. it is fifty-one cutscenes.

61 in 100 bytes of the game are cutscenes.

what the 76 megabytes are, in megabytes
	megabytes
cutscenes	46.40
every level, in one file	10.65
the program	5.80
kirby's sprites	2.73
a copy to send to a second console	1.65
all the sound	1.28
menus, enemies and the rest	7.57

everything kirby can do, every enemy and every boss, is the bar picked out.

the sound is the neat part. 114 pieces of music and 452 effects fit in 1.28 MB, because nothing in there is a recording: it is sheet music and a few short samples, played live by the console. and the file still carries the names its makers gave each one.

a program that arrives in pieces

a DS has four megabytes of memory. the program alone is 5.8. it cannot all be in memory at once, and it never is: 5.3 of those megabytes are cut into 157 overlays, pieces of program that are loaded when they are needed and thrown out when they are not. every enemy is one. so are the bosses.

this is memory while kirby stands in green greens, the first level:

the program in memory, during play
piece	starts at	bytes	what it is
the core	0x02000000	291320	always there: the system under everything
overlay 23	0x02071240	23744	hits and collisions
overlay 24	0x0207f180	131520	the level, and what appears in it
overlay 25	0x020a0080	110240	the player, whoever it is
overlay 26	0x020bc180	592896	kirby: every action and all 24 abilities
overlay 27	0x0214cd80	143552	the lists of enemies and bosses
overlay 28	0x021700a0	163424	what all enemies have in common
overlay 29	0x02197f20	19680	waddle dee
four more chairs	0x0219cc00	43488	room for four other enemies, as the next part tells
the rest	0x021a75e0	2460192	bosses when there are any, the second processor's program, and everything the game is working on

all four megabytes, drawn to scale. the hatched stretch is data and a few small pieces left out.

overlay 26 is kirby himself: 2,212 functions in 593 kilobytes. the hero is twice the size of the core of his own game. and at the far end, in 19 kilobytes, sits the smallest thing with a mind in it: a waddle dee.

five chairs for every enemy

each ordinary enemy is a small program of its own, between 1 and 20 kilobytes. and each of those programs was built to sit at one of five fixed places in memory. two enemies built for the same place cannot be in a room together: loading one would write over the other. every room of the original game is musical chairs, with five chairs.

who was built for which chair
chair	at	built to sit there
1	`0x021a2b00`	bomber, cappy, kabu, laser ball, moto shotzo, coconut
2	`0x02197f20`	waddle dee and waddle doo, blade knight, sword knight, walky, chilly, burning leo, plasma wisp, bio spark, capsule j
3	`0x021a4ce0`	shotzo, grizzo, gim, knuckle joe, jungle bomb, birdon, tac
4	`0x0219f2a0`	sir kibble, twizzy, gator, scarfy, poppy bros. jr., gip, bandana waddle dee
5	`0x0219cc00`	noddy, bronto burt, rocky, broom hatter, simirror, wheelie, squishy, lovely, flotzo

so a waddle dee and a blade knight never share a room, anywhere in the game. green greens seats waddle dee and waddle doo, who are one program, then cappy, bronto burt and twizzy: four chairs, one of each.

this matters to the mod. every dead cells enemy near kirby gets a stand-in inside the hidden game, so that the original's own code decides what his sword touches. the stand-ins are all waddle dees, in chair 2. the table says which real enemies could sit beside them, and which never could.

each enemy also carries a small record of who it is. read out of all of them, and set against kirby's own 76 points of health:²

health, as the cartridge states it
	health
bandana waddle dee	250
kirby	76
grizzo	55
sword knight	48
rocky	42
flotzo	32
knuckle joe	30
blade knight	24
waddle doo	18
waddle dee	16
shotzo	1

a shotzo, the cannon nothing can destroy, has one point of health on paper.

all forty-two, to sort

every enemy record found
enemy	health	swallowed, gives	a touch costs kirby	chair
bandana waddle dee	250	nothing	7	4
grizzo	55	nothing	11	3
sword knight	48	sword	8	2
rocky	42	stone	10	5
flotzo	32	nothing	6	5
knuckle joe	30	fighter	8	3
moto shotzo	26	nothing	8	1
blade knight	24	sword	8	2
chilly	20	ice	8	2
simirror	20	mirror	7	5
sir kibble	20	cutter	10	4
capsule j	18	jet	9	2
the one filed as `magical`	18	nothing	7	2
waddle doo	18	beam	8	2
a second swimmer	16	nothing	10	2
a swimmer	16	nothing	7	2
birdon	16	wing	8	3
bomber	16	crash	7	1
broom hatter	16	nothing	7	5
burning leo	16	fire	10	2
gator	16	nothing	8	4
gim	16	yo-yo	8	3
jungle bomb	16	bomb	8	3
kabu	16	nothing	7	1
scarfy	16	crash	7	4
squishy	16	nothing	6	5
waddle dee	16	nothing	7	2
walky	16	mike	7	2
wheelie	14	wheel	6	5
cappy	12	nothing	7	1
noddy	12	sleep	8	5
plasma wisp	10	plasma	10	2
a small swimmer	8	nothing	7	2
bio spark	8	ninja	6	2
bronto burt	8	nothing	7	5
gip	8	nothing	7	4
laser ball	8	beam	6	1
tac	8	copy	6	3
twizzy	6	nothing	6	4
twizzy, second kind	6	nothing	7	4
coconut	1	nothing	7	1
shotzo	1	nothing	8	3

three records, for poppy bros. jr., lovely and one more, were not found. the swimmers share a file and their names are not in it.

what kirby is doing, and how

sixty times a second the game asks one question about kirby: what is he doing? the answer is a number, his action. there are 44. standing is 6, walking is 11, a jump is 13, falling 14, floating 15, being hurt 29 and dying 33.

nearly every action is run by the same five routines. what sets one apart is a single question of its own: which move? a move is the exact way of doing the action. walking has three: plain, with a mouthful, and wading through water. so the game keeps two bookmarks for kirby, the kind of thing he is doing and exactly how, and the second is the one that knows his mouth is full.

from	to	when
stand	walk	hold a direction
walk	dash	tap it twice
dash	skid	turn round
stand	jump	`A`
jump	fall	at the top
fall	land	the floor
fall	float	`A` again
land	stand	6 frames on
stand	use the ability	`B`
use the ability	stand	done

ten of the ways from one action to the next, each seen by pressing the button and watching the number change. a jump is the blue road.

the blue road, measured. kirby leaves the ground in a burst, 10.5 pixels in the first frame, then 8.0, 5.4 and 2.9. after that the game takes about a sixth of a pixel off his speed every frame, until he is falling at 3.5 pixels a frame and it lets him fall no faster.

one jump, every third frame
frame	pixels off the floor
0	0
1	10.5
4	26.8
7	34.5
10	40.6
13	45.2
16	48.2
19	49.7
22	49.7
25	48.1
28	45.0
31	40.3
34	36.3
37	29.0
40	20.2
43	10.0
46	0

up in twenty frames, down in twenty-six. the top is 49.9 pixels, a little over three of the game's 16-pixel tiles. three quarters of a second in all.

twenty-four costumes

to the program, a copy ability is one pointer. when kirby swallows a blade knight, a single routine says goodbye to the old ability, looks sword up in a list, and swaps the table of moves his actions read from. nothing else about him changes. that is why the mod can hand him any ability: it calls that one routine, and the original does the rest.

each ability was then given the same ten presses, alone in an empty room, and every hit it made was written down.³

the hardest single hit of each ability
	damage
crash	160
hammer	80
paint	70
cook	70
stone	50
mike	40
parasol	28
wing	26
ninja	25
sword	24
wheel	23
cutter	22
mirror	22
fighter	22
ice	20
fire	20
beam	18
yo-yo	18
suplex	16
bomb	16
jet	14
copy	10
plasma	8

red is the four abilities that are used up, and hit the whole screen. blue is hammer's upward flip, the strongest thing kirby can do twice. a waddle dee has 16 health.

and this is one of those moves from the inside. what follows is not a picture of the game. it is sword's standing slash as the program sees it: the hit boxes, frame by frame, exactly where the game put them.

twenty-four frames, four tenths of a second in the game. kirby is the circle, and the small square in his middle is the only part of him that can be hurt. red is the blade, with what it hits for. blue is the beam that leaves it, at 7 pixels a frame.

the slash starts over his head, comes down in front from above his hat to under the floor, and then, for two frames, there is a box behind him. the follow-through hits too.

a full mouth

the mod gives kirby a second pocket. dead cells has a key for healing, F, which kirby has no use for, so it holds one of the four abilities that get used up: crash, paint, mike or cook. a press lends him that ability through the same routine a swallow uses, lets him fire it, and hands him back his own.

one moment broke it: kirby with his mouth full. asked what he is doing, the game answers standing, because a full mouth keeps the action numbers of standing, walking and jumping. so the mod saw a kirby standing still, and lent him the crash. if he swallowed then, the swallow won. on the workbench he came out of it with the swallowed ability, and the crash in his pocket was lost.

the game itself is never fooled. kirby's record keeps a byte that the original reads before it picks how he stands: 1 for an empty mouth, 2 for a full one. and the move it then picks, the second bookmark from earlier, is a different one. the mod reads both now, and F waits for the mouth to be empty.

what the mod reads of kirby, three moments
kirby	action	the mouth byte	move
standing	6	1	`021314d8`
mouth full	6	2	`02131508`
after the spit	6	1	`021314d8`

the action says standing all three times. only the byte and the move know about the mouth. a move is named by where it sits in memory.

and this is the same moment in the mod, in one of its test runs, against a real dead cells zombie.⁴

five seconds of one run. a kirby inhales the zombie. b his mouth is full. F is pressed here, and for the 80 frames the mouth stays full nothing happens. c he spits the zombie out as a star. d F again: the lent crash goes off, and when it is spent kirby is himself again.

the same move can tell more than the mouth: whether kirby is wading, and which of an ability's attacks he is making. so far the mod asks it only about the mouth.

what a hit is made of

every creature in the game starts from four bytes.

field	bytes	what it holds
class	1	what kind of thing this is, 0 to 59
copy ability	1	what kirby becomes if he swallows it
health	2	how much it starts with

here are two enemies, as they are stored:

00 00 10 00

00 14 10 00

one byte apart. 14 is twenty in hexadecimal, and ability twenty is parasol.

that second byte is the whole of kirby's most famous trick. it is also the byte the mod writes on its stand-ins, which is how a dead cells zombie can taste of sword.

dice with 4,096 faces

everything left to chance in the game, 86 places in the program, goes through one routine of two lines:

seed = (seed * 61 + 1401) & 0xFFF;  // twelve bits
return (seed * n) >> 12;            // 0 to n - 1

s_{n + 1} = (61 s_{n} + 1401) mod 4096

the same thing, as a formula.

try it. with the seed at 0, the next seed is 1,401, and a die of six faces thrown with it shows 3.

the two numbers are well chosen: the seed walks through all 4,096 values before it comes back to the first. but 4,096 is very few. the whole future of the game's luck is a loop that short, and whoever knows where the seed stands knows every throw to come.

one sixtieth of a second

a DS draws 59.83 frames a second. in each one its main processor has 560,190 ticks to spend, and when the work is done it sleeps until the next. standing still in green greens, kirby's game is mostly asleep.

35 in 100 ticks of a quiet frame are spent working.

and almost none of the working part is kirby.

where the instructions of a quiet frame are run
	share
the core	73.7%
the level	17.9%
the player	3.9%
hits and collisions	2.4%
the lists of enemies	1.6%
kirby's actions and abilities	0.3%

the largest piece of the program does a third of a percent of the work. the rest is housekeeping: one routine in the core, the one that makes the list of sprites to draw, is 6.7% alone.

then the room fills. in the mod, each dead cells enemy near kirby is one more stand-in for the original to look after, and kirby may have a helper walking beside him. this is how full the frame gets:

how much of a frame is used, kirby swinging a sword with a helper beside him
stand-ins	on average	the worst frame in twenty	the worst frame
0	40.3%	47.6%	57.1%
8	47.7%	61.3%	94.8%
16	54.0%	67.2%	84.1%
24	60.6%	88.0%	100%
31	63.8%	83.8%	100%

six seconds of play at each size of crowd. from twenty-four on, the worst frames do not fit.

when a frame does not fit, the original does what every console game of its time did: it lets the picture go by and finishes the work in the next one. on a DS that is a moment of slow motion, a lag frame. in the mod it was worse. dead cells went on drawing while the hidden game was half way through its sums, and kirby was shown one tile away from where he stood: a flicker. the mod now waits for the original to finish, which is right, and is still a stutter.

so, an experiment. the console in the mod is not real. its processor can be told it is twice as fast.

frames that did not fit, in 360
stand-ins, with a helper	the real speed	twice the speed
16	0	0
24	5	not run
31	2	0

the part that makes it usable: with no crowd, and with a crowd of eight, kirby's path through six hundred frames is the same at both speeds, byte for byte. a faster processor changes nothing until the moment the slow one would have dropped a frame.

the emulator's bill

dead cells has 16.7 ms for each of its frames, and the hidden console is paid out of that. it can be run two ways. an interpreter reads the game's instructions one at a time and acts each one out, every time it meets it. a recompiler translates a stretch of them into the host machine's own language once, and runs the translation from then on. the mod used the first, and since 14 october it uses the second.

milliseconds to run one frame of the hidden game
	kirby alone	31 stand-ins and a helper
interpreter, as the mod ran it	2.41	3.71
recompiler	1.31	1.71
recompiler, unseen screen not drawn	0.93	1.24

one machine, one evening. kirby's six-hundred-frame path was the same under the interpreter and the recompiler, in all three scenes tried.

the last row is a small thing with a large effect. the mod draws kirby itself, from the sprites the original lists, so most of the time nobody looks at the picture the hidden console paints. not painting it saves more than a quarter of what is left.

forty-eight hit records

whatever can hit or be hit in kirby's game borrows a record for it: its four sets of hit boxes and its health, 580 bytes. the records come from one pool, which the game fills with forty-eight at the start of every stage. for the rooms of the original, it was enough.

a stand-in holds one record, for its body, and every hit borrows one more for about seven frames, while the enemy flinches. thirty-one stand-ins, one swing of the sword that hits twenty-four of them, and the pool is empty. the twenty-fourth flinch was handed a record that is not there, address zero, and the game wrote the enemy's health into it all the same.

what came next depended on how the console was run. the game itself tells the processor never to write there, and the interpreter, which keeps that rule as the console does, stopped the processor for good: the hidden game froze in the middle of the fight, and dead cells went on around a kirby who could no longer move. the recompiler does not check the rule. it let the write land in the processor's own fast memory, and six bytes of a routine kept there were quietly overwritten. it was never seen running in play, which is luck, not design.

the mod's answer changes not one instruction of the original. it lets the game build its forty-eight at the start of a stage, then makes sixty-four more, two for every stand-in, out of memory the room does not use, and puts them at the end of the pool. the game hands them out as its own.

the fewest records left free, in one attack on 31 stand-ins piled up
	records
the game's 48, one sword swing	0
112, the same swing	48
112, crash	80
112, the worst of 96 attacks	44

the first ran out, one record short. the 96 attacks are every ability, with the button tapped, held, and with up and with down, four seconds each.

the test that found it, run again with the fix, on the interpreter: thirty-one zombies in three piles, and the first swing hits thirty. frames that ended with the hidden game's work unfinished: 7, against 3,264 before the fix, when every frame after that swing was one.

what it changes in the mod

the first three went into the mod on 14 october, on by default: the translation, the faster processor and the unpainted screen. in the game itself, one run each, the hidden game's frame went from 2.8 ms to 1.5 ms with kirby walking alone, and from 3.6 ms to 1.8 ms among twenty zombies. three more were built and tested the same day, and went in that evening. one idea was set aside.

idea	where it stands	what it showed
translate, do not interpret	in the mod	about half the cost of every frame, and the same kirby
a processor twice as fast	in the mod	no frame of the original left unfinished, even in a crowd of 31
do not paint what nobody sees	in the mod	0.4 ms a frame
read the move, not only the action	in the mod, for the mouth	the mod asks the game whether kirby's mouth is full, instead of guessing from his pose
a bigger pool of hit records	in the mod	a crowd no longer freezes the hidden game, or writes over its program
less bookkeeping	in the mod	the mod's own work of pairing zombies with stand-ins, among 31 of them: from 0.51 ms a frame to 0.35
real enemies in the empty chairs	set aside	a sir kibble can sit beside the waddle dees. a blade knight never can

the last one was set aside because nobody would see it. the stand-ins are never drawn: where one stands, dead cells draws its own enemy, so a real blade knight would be as invisible as the waddle dee it replaced. the ability already comes from the stand-in's byte. every dead cells enemy tastes of a random one, up to thirty-one at a time, which five chairs could never seat. and a real enemy would bring everything the stand-in was set up not to have, its own attacks, its own touch that hurts and its own way of dying, each to be tamed one by one.

how it was read

unpack the cartridge its first bytes say where the program, its 157 overlays and its 1,886 files are.
take the program apart every piece that is in memory during play, turned back from numbers into instructions: 5,996 functions, with a note of who calls whom and who reads what.
doctor the emulator a private copy that counts every instruction it runs, stops at any address, and says who touched a given byte.
guess from the reading, then make the game prove it press a button, and watch for the number that changes.
write down only what was seen

the disassembly, the doctored emulator and the cartridge stay private. what is here is what they said.⁴

changes

14 october 2026 two new parts, a full mouth and forty-eight hit records, with the first frames of the mod at play. what it changes in the mod now says where each idea stands, and has two more. the line under the opening no longer says that no picture is taken from the game, and the notes say where the frames come from.

words

frame: one picture on the screen, and all the work the game does to get to the next: about a sixtieth of a second.
hit box: the rectangle a game tests instead of the drawing. a sword hits when its box overlaps an enemy's, whatever the pixels show.
interpreter: an emulator that reads the guest's instructions one by one and acts each out. simple, exact, and slow.
lag frame: a frame in which the game did not finish its work in time, so the screen showed the old picture again.
overlay: a piece of a program kept on the cartridge and loaded into memory only while it is needed. several can be built for the same place, as long as they are never needed together.
recompiler: an emulator that translates the guest's instructions into the host's own, once, and then runs the translation.
stand-in: an enemy of the original game, placed where a dead cells enemy is, so that kirby's own code can find something to hit.

notes

nothing here was judged by playing. the hidden game was run with no window, from a saved moment in the first level, and its memory read after each frame. the frames of the mod come from its own test runs, which press the keys by script, with no window either.
health, the ability given and the cost of a touch are the numbers stored in each enemy's program. only waddle dee's were watched being put to use.
with nobody to hit, a throw has nothing to throw and a charge is let go early, so suplex and plasma show less than they can do.
the strip of the slash was drawn by a script, from boxes the game reported. the five frames of the mod at play come from its test runs: dead cells drew them, the room and the zombies from its own files, and kirby from the sprites the hidden game listed.

everything this blog can do

2026-10-12T12:00:00Z

this page uses everything an article on this blog can use, and says how each thing is written. it is also the page to open after changing the blog, to see that nothing broke.

every number on this page was measured from the blog's own files on 12 october 2026

the weights behind the charts csv · 2.6 kb
version 3 · 12 october 2026 · sha-256 b81bd1e351d62c17ef450002453a981bd2b98bdf9a87f5961cd10e6f5b20ffb3

how a page reaches you

the blog is one html page, the frame. it holds the sidebar, the type and the list of articles. an article is a plain fragment of html in a folder of its own, and the frame fetches it when its address is asked for. whatever an article needs beyond prose and tables, a chart, a block of code, a note in the margin, is a piece: a small script, a stylesheet or both, fetched only by the articles that use it.

what is fetched, and when. this drawing is an <svg> written into the article, in the same inks as the charts.

nothing comes from another site: no fonts, no scripts, no counters.¹ four words come up again and again below:

the frame index.html, site.css, site.js: what every page pays for: 11.5 kb gzipped, of the 12 it is allowed.
an article its own index.html: a fragment: its text, under one line that forwards anyone who opens the folder itself and a few that say what it is to a link preview. 40 kb at most, except for this one: it has to show every piece there is, and the checker names it and allows it 52.
a piece assets/chart.js, assets/chart.css and the like: fetched when an article needs it. the article says which in a line at its own top, written there by a script that reads its text. each has a budget of its own.
the library at the foot of index.html: the list of articles: a title, a line, a date and a few tags for each.

what the heaviest pieces weigh, gzipped
piece	weight
chart	5.3 kb
dump	4.7 kb
code	4.5 kb
bars	2.9 kb
notes	2.9 kb
graph	2.8 kb
listing	2.7 kb
knob	2.7 kb

the eight heaviest of sixty-eight. this page asks for every one of the sixty-eight, and an article with no chart never fetches the first.

addresses are written after a #, so the blog runs from any static host, in any folder, with nothing to configure: #/typography is a section, #/typography/everything-this-blog-can-do is this page, and #/tag/blog is everything filed under a tag. every heading like the one above has an address of its own, and a line in the sidebar. the folders work too: /typography/everything-this-blog-can-do/ forwards to the right place.

the frame around an article

before any piece, this is what the frame does for every article:

a sidebar on the left lists the sections, each with a count of its articles, and a dot beside the one you are in. on a phone it folds into a menu.
under it, the headings of the article. the one being read is marked, and it follows as you scroll.
a thin line across the top of the page fills as the article is read.
above the title: the section, the date, and how long the article takes to read.
at the foot: the article before and after, the section, the tags, and the other parts when it belongs to a series.
a link to a heading lands on it softly. a link to something smaller, a note or a reference, also tints it for a moment, so the eye finds it.
light mode only. readers who ask their system for less motion keep the fades and lose the movement.

two more things belong to the frame without being part of it. the frame only knows how to fetch them, and does so when a reader first asks. the search is one: the entry under the sections, or /. it answers at once from titles, decks and tags, then reads the feed, which holds every article whole, and searches the text as well. under each article it found are the parts that say what was asked for, and each is a link to that heading. try it with glider: it finds this sentence, and the clip under images. nothing typed there is sent anywhere.

the other is a handful of keys, for reading without the mouse:

key	what it does
`/`	opens the search. `?` does too, and the keys are listed at its foot
`j` `k`	down and up one part of an article. in a list of articles, down and up one article
`n` `o`	the newer article and the older one
`u`	up, from an article to its section and from a section to the front

single keys can get in the way of software that types for its reader, so the foot of the search has a switch that turns them off, remembered on that device. the two together weigh 5.3 kb, and a reader who never presses a key or opens the search never fetches a byte of them.

words

everything visible is lowercase. a capital survives only where it carries meaning, and the markup has to say so:

the bacterium Escherichia coli carries the gene lacZ in its DNA and grows best near pH 7. to check an article, type node scripts/check.mjs. to close a picture, press esc. and a phrase can be picked out like this one.

it reads like an article, never like a dashboard

— the first rule in the readme

<p>the bacterium <i lang="la">Escherichia coli</i> carries the gene <var>lacZ</var>
in its <abbr title="deoxyribonucleic acid">DNA</abbr> and grows best near
<span data-case>pH</span> 7. … press <kbd>esc</kbd>. and <mark>a phrase can be
picked out</mark> like this one.</p>

<blockquote>
  <p>it reads like an article, never like a dashboard</p>
  <p class="meta">— the first rule in <cite>the readme</cite></p>
</blockquote>

seven things keep their capitals:

<code>, <pre> and <kbd>: code, and keys.
<cite> and <blockquote>: a citation, and someone else's words.
<abbr>: an abbreviation, set a little smaller so its capitals do not shout.
lang on anything: a scientific name, or a phrase in another language.
<var> and <math>: a symbol, and a formula.
data-case on anything: a unit, a product, a name that insists.
class="qty": a quantity, whose unit may need them.

a quantity is a number and a unit that belong together. marked up as one, it is never broken across two lines, and the space typed between its parts is set as a thin one:

light crosses 299 792 458 m/s, a mole holds 6.022 × 10²³ things, the earth leans 23° 26′ from upright, and nothing gets colder than −273.15 °C, which is 0 K.

a quantity can also be written the way a program prints it, and is then set the way a paper does. an electron carries 1.602176634e-19 C, betelgeuse stands at 5h 55m 10.3s, and the universe is growing by 67.4 +- 0.5 km/s for every megaparsec (planck 2020). in the page's own source those are 1.602176634e-19 C, 5h 55m 10.3s and 67.4 +- 0.5 km/s, and that is how the feed still gives them.

chemistry is typed the same plain way, in a <span class="chem">, where it also keeps its capitals. a number after a letter goes below the line and one in front stays, a caret raises a charge or a mass number, and -> is an arrow. a leaf makes sugar by 6CO2 + 6H2O -> C6H12O6 + 6O2, a sulfate ion is SO4^2-, and the carbon that dates a bone is ^14C.

the checker holds a quantity to the signs made for it: a minus and not a hyphen, a multiplication sign and not the letter beside it, primes and not straight quotes, a raised power and not a caret.

a key is a <kbd>, and so is the button of a controller, with class="pad": round when it holds one sign, a pill when it holds more, and ringed in one of the four inks when the button has a colour of its own. the best known cheat in games is ↑ ↑ ↓ ↓ ← → ← → B A, and then start. buttons held together go inside one more <kbd>, which keeps them on a line: A + B + select + start sends most game boy games back to their title screen.

and what a reader may not want to know yet can wait under a cover, until it is clicked or opened from the keyboard with enter. the first seven castles of Super Mario Bros. all end on the same news: the princess is in another castle.

<span class="qty">6.022 × 10<sup>23</sup></span>
<span class="qty">−273.15 °C</span>
<span class="qty">67.4 +- 0.5 km/s</span>
<span class="chem">6CO2 + 6H2O -&gt; C6H12O6 + 6O2</span>

<kbd class="pad">↑</kbd> <kbd class="pad" data-ink="2">B</kbd> <kbd class="pad">start</kbd>
<kbd><kbd class="pad">A</kbd> + <kbd class="pad">B</kbd></kbd>

<span class="spoiler">the princess is in another castle</span>

the cover is put on by the same script that takes it off. a reader whose browser runs no scripts, or reads the article in a feed, gets the sentence plain.

this is a line of small print, a paragraph with class="meta". the line under it is an <hr>.

words in another language ask for more. a sentence taken apart word by word is a <dl class="gloss">: each word in a <div> with what it means under it, and the pairs wrap the way words do. the labels of grammar go in <abbr>, and are set in small capitals.

vos: 2SG
sabés: know.2SG
que: that
no: not
vino: come.PST.3SG

“you know he did not come”, as it is said in buenos aires: vos sabés, where madrid says tú sabes.

a reading set over a word is a <ruby>, which browsers have long known how to set: 日本語にほんご is the japanese word for the japanese language, with the way it is said written over it in the script that spells sounds.

<dl class="gloss">
  <div><dt lang="es">sabés</dt><dd>know.<abbr>2SG</abbr></dd></div>
  <div><dt lang="es">que</dt><dd>that</dd></div>
</dl>

<ruby lang="ja">日本語<rt>にほんご</rt></ruby>

an original and its translation are a <figure class="facing">. the paragraphs are written in turn, one of each, and set in two columns, so every pair starts level however long either half runs. on a narrow page each translation goes under its original.

Gallia est omnis divisa in partes tres, quarum unam incolunt Belgae, aliam Aquitani, tertiam qui ipsorum lingua Celtae, nostra Galli appellantur.

all gaul is divided into three parts. the belgae live in one, the aquitani in another, and in the third those who are called celts in their own tongue, and gauls in ours.

Hi omnes lingua, institutis, legibus inter se differunt.

all of them differ from one another in language, in customs and in laws.

Gallos ab Aquitanis Garumna flumen, a Belgis Matrona et Sequana dividit.

the river garonne parts the gauls from the aquitani, and the marne and the seine part them from the belgae.

how caesar's account of his war in gaul begins (caesar), with a translation made for this page.

and a source set down as it was written is a <blockquote class="source"> around a list of its lines. the lines are numbered the way an edition numbers them, the first and every fifth. a quotation keeps its capitals, so these do. what an editor has supplied goes in an <ins> and is set in brackets, and an empty one is a gap nobody could fill.

SENATVS · POPVLVS · QVE · ROMANVS

IMP · CAESARI · DIVI · NERVAE · F · NERVAE

TRAIANO · AVG · GERM · DACICO · PONTIF

MAXIMO · TRIB · POT · XVII · IMP · VI · COS · VI · P · P

AD · DECLARANDVM · QVANTAE · ALTITVDINIS

MONS · ET · LOCVS · TANTIS · OPERIBVS · SIT · EGESTVS

the six lines cut into the base of trajan's column in rome (as transcribed). a small piece at the bottom of the stone has been lost, and the letters in brackets are what was put back. these are the capitals that roman type has been drawn from ever since.

<figure class="facing">
  <p lang="la">Gallia est omnis divisa in partes tres, …</p>
  <p>all gaul is divided into three parts. …</p>
</figure>

<blockquote class="source" lang="la">
  <ol>
    <li>AD · DECLARANDVM · QVANTAE · ALTITVDINIS</li>
    <li>MONS · ET · LOCVS · TANT<ins>IS · OPER</ins>IBVS · SIT · EGESTVS</li>
  </ol>
</blockquote>

some things have to be heard. a link to a sound file with class="say" gets a mark to press: the sound plays in the page, and stops when it is pressed again. nothing is fetched before that, and nothing ever plays by itself. this is one note, twice: the a that orchestras tune to, 440 vibrations a second, first as a square wave and then as a sine. the pitch is the same and the sound is not.

<a class="say" href="a440.wav">one note, twice</a>

and each word can carry a number. in a <p class="tokens">, every word written as a <data value="…"> is tinted by how large its number is, the way a cell is in a table with class="heat". the scale is written under the text with what the numbers count, and pointing at a word gives its own. writing about language models, it is the usual way to show how much weight each word was given. here it is one of this blog's rules, each word tinted by how many times this article had used it when the sentence was added, on 12 october 2026, among 15,046 words:

it reads like an article, never like a dashboard

the numbers run from 2 to 698, so the scale is in powers of ten, which is what data-log asks for. data-min and data-max pin its ends, for two paragraphs that should be read against each other, and numbers on both sides of zero take an ink for each side.

<p class="tokens" data-log data-unit="times in this article">
  <data value="303">it</data> <data value="16">reads</data> <data value="17">like</data> …
</p>

lists

a list is bullets, numbers, or terms with their definitions, and this page uses all three. seven more kinds are drawn with more than a marker.

a list inside a list, with class="tree", is drawn with its branches. this is the folder the blog is served from:

blog/
- index.html the frame, with the library at its foot
- feed.xml
- assets/
  - site.css, site.js the rest of the frame
  - fonts/
  - tree.css and a file or two like it for every other piece
- scripts/
  - check.mjs
  - feed.mjs
- software/
  - everything-this-blog-can-do/
    - index.html this article
    - weights.csv
    - stylesheet.png and two more pictures
  - claude-haiku-5-5/
  - opencode-go-model-league/
- biology/

a tree can also show a change. a name inside <ins> is new, a name inside <del> is gone, and a <data> is a size, set at the far end of its line so that the sizes make a column. this is what the pull request that added this paragraph did, in bytes as they are stored. nothing has ever been taken out of the blog's folder, so there is no file struck out to show: the only things struck out are the sizes that changed.

assets/
- code.css ~~3,030~~ 3,326
- code.js ~~7,499~~ 8,318
- files.css ~~1,240~~ 2,110
- files.js 870
- matrix.css 692
- matrix.js 639
- site.js ~~16,835~~ 16,884
- tabs.css 949
- tabs.js 1,931
- tree.css ~~1,985~~ 2,390
scripts/
- check.mjs ~~47,496~~ 49,340

<ul class="tree">
  <li><code>assets/</code>
    <ul>
      <li><ins><code>tabs.js</code></ins> <data value="1931">1,931</data></li>
      <li><del><code>old.js</code></del></li>
      <li><code>tree.css</code> <data value="2390"><del>1,985</del> <ins>2,390</ins></data></li>
    </ul>
  </li>
</ul>

with data-across the same list runs across the page, each fork opening to the right of its name. a fork may go without a name, which is all a family tree asks for. these are the great apes, in the order their lines parted (prado-martinez and others 2013):

great apes
- orangutans Pongo
- - gorillas Gorilla
  - - humans Homo
    - - chimpanzees Pan troglodytes
      - bonobos Pan paniscus

the order of the forks is the whole of it. the lengths of the branches say nothing about time.

<ul class="tree" data-across>
  <li>great apes
    <ul>
      <li>orangutans <i lang="la">Pongo</i></li>
      <li>
        <ul>
          <li>gorillas <i lang="la">Gorilla</i></li>
          <li>…</li>
        </ul>
      </li>
    </ul>
  </li>
</ul>

when the lengths should say something, the list is a class="clade" and every item carries a data-length: how long the branch that leads to it is. each tip gets a line of its own, and each branch runs as far across the page as it is long. with data-ago the lengths are time, and an axis under the tree counts back from the tips. with data-unit they are anything else, and a bar of one round length says how much. these are the african apes, by when their genomes parted (scally and others 2012):

- western gorillas Gorilla gorilla
- eastern gorillas Gorilla beringei
- humans Homo sapiens
- chimpanzees Pan troglodytes

a tree whose lengths are time. the gorilla line parted from ours about ten million years ago, and the chimpanzee line about six. the two gorilla species are younger by far: on average their sequences parted 1.75 million years ago.

<ul class="clade" data-ago="million years">
  <li data-length="8.25">
    <ul>
      <li data-length="1.75">western gorillas</li>
      <li data-length="1.75">eastern gorillas</li>
    </ul>
  </li>
  <li data-length="4">…</li>
</ul>

things done in order are an <ol class="steps">: a number for each, on one line from the first to the last, a <small> for the detail, and a <time> for a step that has one, set beside it. this is how every change reaches the blog, with the times of the one that added this section:

11:14:41 open an issue it says what is wanted and why, and carries a label for its kind and a milestone.
make a branch from it named after the issue: 55-small-things-for-words.
11:25:44 commit one line, lowercase, starting with the area it touches: site: …
11:25:48 open a pull request its description starts with closes #55, which ties the two together.
11:26:01 wait for two checks one reads the steps above, the other runs scripts/check.mjs.
11:26:06 squash and merge the branch lands as one commit on main, which moves in no other way.

<ol class="steps">
  <li><time datetime="2026-10-12T11:14:41-03:00">11:14:41</time> open an issue
    <small>it says what is wanted and why.</small></li>
  <li>make a branch from it <small>named after the issue.</small></li>
</ol>

when it is the thing handed on that matters, and not the hour, the list is an <ol class="flow">: a box for each step and an arrow to the next, across the page for as long as there is room. a list inside a step is what happens there side by side. this is the same road, as a change travels it:

an issue
a branch
a pull request
- flow
- checks
one commit on main

<ol class="flow">
  <li>a branch</li>
  <li>a pull request
    <ul>
      <li>flow</li>
      <li>checks</li>
    </ul>
  </li>
</ol>

a conversation is an <ol class="chat">: a turn for each item, and each turn starts with who spoke, in a <b>. it is set like the script of a play, and nobody's words go in a bubble. each speaker gets a mark of their own, in the order they first speak. a turn holds whatever a list item can, so a call to a tool is a block of code. and a turn that runs long is folded until it is asked for, as the third one is here.

user what were the last things added to the blog?
assistant the history will say. one line for each pull request, newest first:
```
$ git log --oneline --first-parent -20
```

tool git

ff17ef0 site: an article names the pieces it needs, and the frame stops growing with them (#88)
f9f097b site: glosses, facing text, sources as written, kinds of source, and a sound (#86)
04cc995 site: bits, traces and alignments (#84)
a77e419 site: tabs, sessions at a terminal, yes and no, changes in a tree, and downloads with a sum (#82)
db8741b site: pipelines, graphs and trees with lengths (#80)
a5a01ca site: distributions, flows and treemaps (#78)
eec2d02 site: areas, slopes, bars back to back, waterfalls and indexed lines (#76)
f8ba532 site: tracks, deep time and events on a chart (#74)
d1d1360 article: the tour's own numbers, measured again (#72)
4f84a1f fix: a page with many blocks of code is laid out once, not once for every block (#71)
cf420ff site: a title and a description in every article's own file, for link previews (#68)
1dcab41 site: a search, and keys to read without the mouse (#66)
dc83c27 site: notes that open where they are cited, and references that say what kind of evidence they are (#64)
6c2d653 site: more from a picture: marks with a key, before and after, pixel art, and short clips (#62)
ab985a9 site: more ways to read bytes: a diff between two dumps, a map to scale, and sequences (#60)
02eac6d site: code read closely: blocks side by side, callouts, and disassembly listings (#58)
81c346a site: small things for words: quantities, keys, trees, steps, spoilers, and changes that show (#56)
4a1bd96 site: tables to read at a glance: heat, sorting, and changes with a sign (#54)
9145e4f site: tables that draw themselves: ranges, spans, blocks, days, and shares counted out (#52)
bc0a6f5 site: charts that say how sure they are, and against what (#50)

assistant the newest eight are one piece of work: ways to write about more subjects, from tracks of time to a sentence taken apart word by word. the last of them took the list of pieces out of the frame, so that it stops growing.

an exchange written for this page. what the tool says is what git printed on 12 october 2026.

<ol class="chat">
  <li><b>user</b> what were the last things added to the blog?</li>
  <li><b>tool <code>git</code></b> <pre><code>ff17ef0 site: an article names the pieces it needs …</code></pre></li>
</ol>

a few facts about one thing are a <dl class="card">: terms and what each comes to, ruled like a small table and no wider than a card. in an aside with a name it is the box of facts an encyclopedia sets beside its text. the numbers on this one were counted by running the gun, which is further down, and who found it is as gardner told it.

<dl class="card">
  <dt>period</dt><dd>30 generations</dd>
</dl>

the last kind is the list at the top of this page: files that travel with an article are a <ul class="files"> of links. a paragraph under a link says what is known about the file: which version it is, when it was made, and its sha-256, which is shown by its two ends and copied whole. the checker takes the sum of the file again on every run, so a file that changes without its line changing fails.

<ul class="files">
  <li><a href="weights.csv" download>the weights behind the charts <small>csv · 2.6 kb</small></a>
    <p>version 3 · <time datetime="2026-10-12">12 october 2026</time> · sha-256 <code>b81bd1e3…20ffb3</code></p></li>
</ul>

tables

a table may run wider than the text, and scrolls sideways when it has to. the first column names each row and stays put while the rest moves. numbers are set right, in figures of equal width, so they line up.

seven of the sixty-eight pieces, heaviest first
#piece	fetched when an article has	script	styles	budget
1chart	a table with the class of a chart	3.9 kb	1.4 kb	5.5 kb
2dump	a hex dump, a sequence, a map or the layout of a header	3.2 kb	1.5 kb	5 kb
3code	a block of code	3.2 kb	1.2 kb	5 kb
4notes	a list of notes or of references	1.7 kb	1.2 kb	3 kb
5image	an image	1.4 kb	1.1 kb	3 kb
6aside	an aside, or a section that folds	—	0.9 kb	1 kb
7math	a formula	—	0.6 kb	1 kb
the seven		13.4 kb	7.9 kb	23.5 kb

a position hangs in front of each name. the second column is words, so it wraps on a narrow screen. the lightest stylesheet is picked out, and a piece with no script says so with a dash. the last row is a <tfoot>, which is what the columns come to: the checker adds them up, and refuses a foot that says anything else.

<tr>
  <th scope="row"><span class="rank">7</span>math</th>
  <td class="words">a formula</td>
  <td class="none">—</td>
  <td class="best">0.6 kb</td>
  <td>1 kb</td>
</tr>

some tables draw themselves. the numbers stay in their cells, and a last column is added with a picture of each row.

class="range" is for a value and the range it is expected in: a name, a value, a low end and a high end. the range is a band across the middle of the row and the value is a point, so a point outside its band is a number outside its range, and that number is set heavier. every row has a scale of its own, which lets rows in different units share a table. a range with one end has a dash for the other.

this blog, against what is asked of a page
measure	here	at least	at most
characters to a line	64	45	75
the same, on a phone	39	45	75
line height	1.5	1.5	—
contrast, text	16.6	7	—
contrast, quiet text	5.1	4.5	—
the frame, kb	11.5	—	12
this article, kb	50.2	—	52

values against their ranges. the length of a line is from bringhurst 2012, contrast and line height from the accessibility guidelines (w3c 2024), and the last two are this blog's own budgets. one number is out of range: a phone held upright has no room for forty-five characters at a size worth reading.

class="spans" is for things that last: a name, when it starts and when it ends, as numbers, as times on a clock like 1:23.4, or as dates. every row gets a bar on one scale, from the earliest start to the latest end, and the two ends of the scale are written over it. a row with no end is a moment, and gets a point.

a first visit to this page
what is fetched	asked for	arrived
the page	0 ms	1.2 ms
the upright font	3.3 ms	8.8 ms
the stylesheet	3.5 ms	8.6 ms
the script	3.5 ms	9.0 ms
this article	20.4 ms	21.9 ms
its pieces	23.3 ms	75.6 ms
the italic font	121.3 ms	411.7 ms

spans. one cold load, from a server on the same machine, so the times are small and the order is the point: the page, then the frame, then the article, then the hundred and sixteen files of the pieces it calls for. the italic font is asked for last, when the first slanted word is about to be drawn, and most of its wait is the pieces at work: this page gives them more to do than any other.

rows that follow each other under one name are a track: the name is said once, and they share its line. a gene is the usual case, its exons on one line and the stretches that are read into protein on the next.

the gene for β-globin, letter by letter
what	from	to
exons	1	142
exons	273	495
exons	1,346	1,608
read into protein	51	142
read into protein	273	495
read into protein	1,346	1,474
the sickle-cell letter	70

tracks. HBB as its reference sequence gives it (ncbi), counted from the first letter that is transcribed: three exons, the two stretches between them that are cut out, and inside the exons the 444 letters that are read. the point is the one letter whose change, a T where an A should be, gives sickle-cell disease.

a start or an end can also lie deep in the past, 541 mya or 12 ka, or before year one, 44 bce. when the times are too far apart for one ruler, data-log sets the scale in powers of ten. zero has no place on such a scale, so the present is put one power of ten past the nearest time the table names.

the earth's time, in powers of ten
stretch	from	to
hadean	4,567 mya	4,031 mya
archean	4,031 mya	2,500 mya
proterozoic	2,500 mya	538.8 mya
paleozoic	538.8 mya	251.9 mya
mesozoic	251.9 mya	66 mya
cenozoic	66 mya	0 mya
pleistocene	2.58 mya	11.7 ka
holocene	11.7 ka	0 ka

deep time, with the ages of the international chart (cohen and others 2013). on a ruler the holocene would be three millionths of the width, and invisible. here every tenfold step back gets the same room, so the nearer to now the more there is, and it is the hadean that shrinks to a sliver. neither picture is wrong, and the caption has to say which one it is.

three more classes are for reading a table at a glance. with class="sort" every column head is a button: one click puts the rows in order by that column, a second turns the order round, and a third puts them back the way they were written. numbers start from the largest, words from a.

every piece, and what calls for it
piece	fetched when an article has	script	styles	budget
code	a block of code	3.2 kb	1.2 kb	5 kb
pair	two blocks side by side	—	0.3 kb	0.5 kb
callouts	numbered marks in a block	0.4 kb	0.6 kb	1.5 kb
tabs	blocks behind tabs	0.8 kb	0.5 kb	1.5 kb
listing	a listing of machine code	1.9 kb	0.8 kb	3 kb
chart	a table with the class of a chart	3.9 kb	1.4 kb	5.5 kb
bars	a chart drawn as bars	1.9 kb	1.0 kb	3 kb
lines	a chart drawn as lines	2.4 kb	—	2.5 kb
dots	a chart drawn as dots	2.4 kb	—	2.5 kb
plot	a chart drawn as lines or as dots	—	1.3 kb	1.5 kb
areas	a chart drawn as areas	1.2 kb	0.2 kb	1.5 kb
slope	a chart drawn as slopes	1.5 kb	0.4 kb	2 kb
hist	a histogram, or boxes	1.6 kb	0.8 kb	2.5 kb
flows	a table of flows	1.6 kb	0.5 kb	2.5 kb
treemap	a list drawn as tiles by size	1.8 kb	0.7 kb	2.5 kb
graph	a table of edges	2.0 kb	0.8 kb	3 kb
flow	a pipeline	—	0.6 kb	1 kb
clade	a tree with lengths	1.4 kb	0.9 kb	2.5 kb
events	events listed under a chart	0.8 kb	0.5 kb	1.5 kb
blocks	a table of blocks	1.4 kb	0.4 kb	2 kb
days	a table of days	1.3 kb	0.6 kb	2 kb
spark	a sparkline	0.5 kb	0.3 kb	1 kb
range	a table of ranges	0.9 kb	0.6 kb	1.5 kb
spans	a table of spans	1.4 kb	0.6 kb	2 kb
of	a share to count out	0.7 kb	0.5 kb	1.5 kb
heat	a table tinted by its numbers	0.7 kb	0.4 kb	1.5 kb
sort	a table that sorts	1.0 kb	0.5 kb	2 kb
delta	a change with a sign	0.3 kb	0.3 kb	1 kb
qty	a quantity	0.5 kb	0.3 kb	1 kb
pad	the buttons of a controller	—	0.5 kb	1 kb
tree	a tree of files	—	0.9 kb	1 kb
steps	a list of steps	—	0.5 kb	1 kb
spoiler	text under a cover	0.4 kb	0.3 kb	1 kb
revise	a correction, or a list of changes	0.5 kb	0.7 kb	1.5 kb
aside	an aside, or a section that folds	—	0.9 kb	1 kb
math	a formula	—	0.6 kb	1 kb
image	an image	1.4 kb	1.1 kb	3 kb
marks	an image with marks on it	1.1 kb	1.1 kb	2.5 kb
compare	two images to compare	0.9 kb	0.9 kb	2 kb
pixel	pixel art, or a palette	0.8 kb	0.5 kb	1.5 kb
clip	a short clip	1.1 kb	0.6 kb	2 kb
notes	a list of notes or of references	1.7 kb	1.2 kb	3 kb
dump	a hex dump, a sequence, a map or the layout of a header	3.2 kb	1.5 kb	5 kb
seq	a sequence	0.8 kb	—	1 kb
align	sequences set under each other	1.1 kb	0.3 kb	1.5 kb
map	a map of a file or of memory	0.8 kb	—	1 kb
files	a list of downloads	0.5 kb	1.0 kb	1.5 kb
matrix	a table of yes and no	0.4 kb	0.4 kb	1 kb
trace	a table of states, step by step	0.4 kb	0.2 kb	1 kb
gloss	a gloss word under word, or ruby	—	0.5 kb	0.5 kb
facing	a text facing its translation	—	0.4 kb	0.5 kb
source	a source as it was written	—	0.4 kb	0.5 kb
say	a sound to hear	0.5 kb	0.3 kb	1 kb
chat	a conversation	0.8 kb	0.9 kb	2 kb
tokens	words tinted by a number	1.0 kb	0.6 kb	2 kb
board	a grid written in characters	0.7 kb	0.6 kb	1.5 kb
frames	frames in one place, or pictures that blink	1.4 kb	0.8 kb	2.5 kb
card	a card of facts	—	0.5 kb	0.5 kb
scale	a picture with a scale bar	0.8 kb	0.4 kb	1.5 kb
set	panels with letters	—	0.6 kb	1 kb
sky	a chart of the sky	1.7 kb	0.8 kb	2.5 kb
tiles	a map of tiles	1.1 kb	0.6 kb	2 kb
chem	a chemical formula	0.5 kb	0.2 kb	1 kb
knob	a number a reader can change	2.2 kb	0.5 kb	3 kb
curve	a curve from a formula	2.1 kb	—	2.5 kb
sum	a table with a foot	—	0.2 kb	0.5 kb
glossary	a glossary	0.7 kb	0.6 kb	1.5 kb
fig	a numbered figure	—	0.2 kb	0.5 kb

a table that sorts. try the script column: the chart core is the heaviest thing here, and the pieces with a dash in it are a stylesheet and nothing else.

class="heat" tints every cell by how large its number is, in one hue from the paper up. the numbers stay, so the tint is a second way to read them. one scale covers the table, unless data-by="column" or data-by="row" gives each its own. numbers on both sides of zero take two inks, one for each side.

what gzip leaves of a file, at four of its levels
file	level 1	level 3	level 6	level 9
feed.xml	23.2%	21.7%	19.6%	19.2%
this article	29.9%	28.4%	25.9%	25.7%
site.css	33.3%	31.4%	28.7%	28.7%
site.js	38.9%	37.6%	35.5%	35.5%
index.html	40.7%	40.1%	38.9%	38.9%
chart.js	43.1%	42.0%	40.3%	40.3%
math.css	52.1%	51.5%	50.9%	50.9%
stylesheet.png	96.6%	96.5%	96.3%	96.3%
newsreader.woff2	99.7%	99.7%	99.7%	99.7%

a table with its heat. the longer a file of text is, the more of it gzip can fold away. what is already packed, an image or a font, does not pack again, which is why the blog weighs its fonts as they are.

and class="delta" on a cell marks a number as a change: an arrow goes in front of it, up or down by its sign, in an ink for each.

what six pull requests did to the frame
pull request	what it brought	the frame after	change
#33	a feed	11,802	+78
#35	cells of words that wrap	11,933	+131
#46	a shorter list of pieces, and downloads in a piece	11,647	−286
#48	a piece for each form of chart	11,665	+18
#50	charts that say how sure they are	11,665	0
#52	tables that draw themselves	11,696	+31

changes with a sign, in bytes gzipped. a feature that lives in a piece costs the frame one line in a list, or nothing.

and a table of yes and no is a class="matrix". every cell starts with yes, no or partly, and shows a disc for it: full, empty or half. the word stays inside the mark, for a screen reader and for whoever copies the table, and whatever a cell says after its word stays beside it. this is what a block of code gets a colour for, by language:

language	comments	strings	numbers	names
js	yes	yes	yes	no
css	yes	yes	yes	no
json	no it has none	partly values, not keys	yes	no
html	yes	yes	yes	yes of tags

four of the twenty-two languages a block knows. the rule is comments, strings and numbers, and nothing else. markup is the exception, because there the names are most of what is written.

<table class="matrix">
  <tr><th scope="row">json</th><td>no <small>it has none</small></td><td>partly</td><td>yes</td></tr>
</table>

code

a block of code gets a button that copies it. a label says where it came from. the language, written the way markdown tools already write it, turns on colour: comments step back, strings and numbers step forward, and everything else stays ink. keywords are left alone on purpose, so a page of code stays calm.

export const pieces = [
  ['code', 'js css', 'pre'],
  ['pair', 'css'],
  ['callouts', 'js css'],
  ['tabs', 'js css'],
  ['listing', 'js css'],
  ['chart', 'js css', '.bars .lines .dots .blocks .days .areas .slope .hist .box .flows .sky .tiles .curve'],
  ['bars', 'js css'],
  ['lines', 'js'],
  ['dots', 'js'],
  ['plot', 'css', '.lines .dots .areas .slope .curve'],
  ['areas', 'js css'],
  ['slope', 'js css'],
  ['hist', 'js css', '.hist .box'],
  ['flows', 'js css'],
  ['treemap', 'js css'],
  ['graph', 'js css'],
  ['flow', 'css'],
  ['clade', 'js css'],
  ['events', 'js css'],
  ['blocks', 'js css'],
  ['days', 'js css'],
  ['spark', 'js css'],
  ['range', 'js css'],
  ['spans', 'js css'],
  ['of', 'js css'],
  ['heat', 'js css'],
  ['sort', 'js css'],
  ['delta', 'js css'],
  ['qty', 'js css'],
  ['pad', 'css'],
  ['tree', 'css'],
  ['steps', 'css'],
  ['spoiler', 'js css'],
  ['revise', 'js css', 'ins del .changes'],
  ['aside', 'css', 'aside details'],
  ['math', 'css', 'math'],
  ['image', 'js css', 'img'],
  ['marks', 'js css'],
  ['compare', 'js css'],
  ['pixel', 'js css', '.pixel .palette'],
  ['clip', 'js css'],
  ['notes', 'js css', '.notes .refs'],
  ['dump', 'js css', '.hex .seq .fields .map .align'],
  ['seq', 'js'],
  ['align', 'js css'],
  ['map', 'js'],
  ['files', 'js css'],
  ['matrix', 'js css'],
  ['trace', 'js css'],
  ['gloss', 'css', '.gloss ruby'],
  ['facing', 'css'],
  ['source', 'css'],
  ['say', 'js css'],
  ['chat', 'js css'],
  ['tokens', 'js css'],
  ['board', 'js css'],
  ['frames', 'js css', '.frames .blink'],
  ['card', 'css'],
  ['scale', 'js css', '[data-across]'],
  ['set', 'css'],
  ['sky', 'js css'],
  ['tiles', 'js css'],
  ['chem', 'js css'],
  ['knob', 'js css'],
  ['curve', 'js'],
  ['sum', 'css', 'tfoot'],
  ['glossary', 'js css'],
  ['fig', 'css'],
];

const calls = (html) => ([name, , signs = `.${name}`]) =>
  signs.split(' ').some((sign) =>
    RegExp(sign[0] === '.' ? `<[^>]+class="[^"]*\\b${sign.slice(1)}\\b` : sign[0] === '[' ? `<[^>]+\\s${sign.slice(1, -1)}[=\\s>]` : `<${sign}[\\s>]`).test(html),
  );

that is the whole list of pieces, and the four lines that read it: a name, what to fetch, and the tags, classes or attributes that call for it, the piece's own name when none are given. the frame never sees the list. a script reads it, and writes at the top of each article the pieces that article needs, so the frame weighs the same however long the list grows. the lines are numbered from 7, where the list starts in the file, and line 13 is marked. a long line does not wrap, and the last but one is long: the block grows past the text until it meets the edge of the page, and scrolls after that.

a patch is a block in the language diff. the lines it adds and removes are tinted:

@@ -652,7 +652,13 @@
-.prose :is(th, td).l {
+.prose :is(th, td):is(.l, .words) {
   text-align: left;
 }
+
+/* a cell of words rather than a number: it wraps where it runs long */
+.prose .words {
+  min-width: 10em;
+  white-space: normal;
+}

and a phrase inside a block can be pointed at with <mark>:

python3 -m http.server 4173  # then open http://localhost:4173

<pre data-label="scripts/pieces.mjs" data-lines="7" data-mark="13">
<code class="language-js">export const pieces = [
  ['code', 'js css', 'pre'],
  …
];</code></pre>

twenty-two languages are known: js, ts, c, cpp, rust, zig, go, java, css, json, python, ruby, sh, make, yaml, toml, asm, sql, lua, html, xml and svg. anything else is shown plain.

the same thing said several ways is a <figure class="tabs"> around the blocks. one shows at a time, under a row of the names their data-labels give them. a name picked in one set is picked in every set on the page that has it, so a language is chosen once. without scripts, and on paper, every block shows. this is a function that counts the steps a number takes to reach one, halving when it is even, and tripling and adding one when it is odd:

int steps(unsigned long n) {
    int count = 0;
    while (n != 1) {
        n = n % 2 ? 3 * n + 1 : n / 2;
        count++;
    }
    return count;
}

def steps(n):
    count = 0
    while n != 1:
        n = 3 * n + 1 if n % 2 else n // 2
        count += 1
    return count

function steps(n) {
  let count = 0;
  while (n !== 1) {
    n = n % 2 ? 3 * n + 1 : n / 2;
    count++;
  }
  return count;
}

and this is each of them asked about twenty-seven. all three say 111.

printf("%d\n", steps(27));

print(steps(27))

console.log(steps(27));

<figure class="tabs">
  <pre data-label="c"><code class="language-c">…</code></pre>
  <pre data-label="python"><code class="language-python">…</code></pre>
</figure>

a session at a terminal is a block of language-console. a line that starts with $, # or % and a space was typed, and so is the line after one that ends in a backslash, when it starts with >. everything else is what came back, and it steps behind. the prompt is not picked up with a selection, and the copy button takes only what was typed. these are the thirty-nine commits on main up to pull request #78, counted by the area each one names. the odd one out is the commit the repository was made with:

$ git rev-list --count --first-parent a5a01ca
39
$ git log --first-parent --format=%s a5a01ca \
>   | cut -d: -f1 | sort | uniq -c | sort -rn
     25 site
      4 fix
      4 article
      3 design
      2 repo
      1 Initial commit

two blocks in a <figure class="pair"> sit side by side, to be read line against line, and stack on a narrow page. pointing at a line picks out the one level with it on the other side, so a blank line is part of the text: it is what keeps the two level. on the left is a function that counts the steps of a collatz sequence, written the way the compiler read it. on the right is what gcc 15.2 made of it at -Os, with the labels named by hand.

int steps(unsigned long n) {
    int count = 0;
    while (n != 1) {

        if (n % 2) {

            n = 3 * n + 1;
            count++;

        }
        n = n / 2;
        count++;
    }
    return count;
}

steps:
        xor   eax, eax
.loop:  cmp   rdi, 1
        je    .done
        test  edi, 1
        je    .half
        lea   rdi, [rdi+rdi*2]
        inc   eax
        inc   rdi

.half:  shr   rdi, 1
        inc   eax
        jmp   .loop
.done:  ret

each line of c sits beside the first instruction that carries it out. twelve instructions, 33 bytes.

a register xored with itself is zero. this is count = 0, in two bytes where a plain move takes five.
three times n without a multiplication: the instruction that works out addresses adds n to twice n.
the + 1, and after it no jump back to the test at the top. three times an odd number, plus one, is even, so the compiler knows which way the next turn goes and falls straight into the halving.

the numbers in the right block are callouts: a <mark data-note="1"> around what is meant, and an <ol class="callouts"> after the block with a line for each number. pointing at a mark lights its line, and pointing at a line lights its mark. the copy button leaves the numbers out.

<figure class="pair">
  <pre data-label="steps.c"><code class="language-c">…</code></pre>
  <pre data-label="gcc -Os"><code class="language-asm">steps:
        <mark data-note="1">xor   eax, eax</mark>
        …</code></pre>
  <figcaption>each line of c sits beside the first instruction that carries it out.</figcaption>
</figure>

<ol class="callouts">
  <li>a register xored with itself is zero.</li>
</ol>

a disassembly is a <pre class="listing">, pasted as objdump prints it. it is set in columns: where each instruction is, the bytes it is made of, and what it says. every jump that lands inside the listing gets an arrow in the gutter, short ones on the inside and long ones further out, and pointing at a jump, or at the place one lands, picks its arrow out. on a phone the bytes step aside. this is the same function, read back out of the object file:

0000000000000000 <steps>:
   0:	31 c0                	xor    eax,eax
   2:	48 83 ff 01          	cmp    rdi,0x1
   6:	74 18                	je     20 <steps+0x20>
   8:	f7 c7 01 00 00 00    	test   edi,0x1
   e:	74 09                	je     19 <steps+0x19>
  10:	48 8d 3c 7f          	lea    rdi,[rdi+rdi*2]
  14:	ff c0                	inc    eax
  16:	48 ff c7             	inc    rdi
  19:	48 d1 ef             	shr    rdi,1
  1c:	ff c0                	inc    eax
  1e:	eb e2                	jmp    2 <steps+0x2>
  20:	c3                   	ret

<pre class="listing" data-label="objdump -d -M intel steps.o">
0000000000000000 &lt;steps&gt;:
   0:	31 c0                	xor    eax,eax
   2:	48 83 ff 01          	cmp    rdi,0x1
   6:	74 18                	je     20 &lt;steps+0x20&gt;
   …
</pre>

what a listing does not show at a glance is the shape of the thing: where it forks, and where it comes back round. a <table class="graph"> is a list of edges, one to a row: where it starts, where it ends and, if it has one, a word for it. the things are set in layers down the page, each under what leads to it, and an edge that goes back up is drawn round the side. a class on a row, a to d, gives its edge an ink. this is every way through the function above, by the addresses in the listing:

from	to	when
`0` count = 0	`2` n is 1?
`2` n is 1?	`20` return count	yes
`2` n is 1?	`8` n is odd?	no
`8` n is odd?	`10` n = 3n + 1	yes
`8` n is odd?	`19` n = n / 2	no
`10` n = 3n + 1	`19` n = n / 2
`19` n = n / 2	`2` n is 1?	again

six blocks and seven edges. the one in red is the loop: it leaves the bottom of the function and comes back in at the test. the compiler's shortcut is here too, as an edge that is missing: nothing leads from 10 back to the test.

<table class="graph">
  <thead><tr><th>from</th><th>to</th><th>when</th></tr></thead>
  <tbody>
    <tr><td>n is 1?</td><td>return count</td><td>yes</td></tr>
    <tr><td>n is 1?</td><td>n is odd?</td><td>no</td></tr>
    <tr class="b"><td>n = n / 2</td><td>n is 1?</td><td>again</td></tr>
  </tbody>
</table>

and what it does, step by step, is a <table class="trace">: a row for each step, and the state after it. a cell that is not what it was in the row above is picked out, and the rest step back, so the eye goes to what a step did. this is the function asked about the number two, as a debugger stepped through it:

after	`rdi`	`eax`	zero flag
`0` `xor eax,eax`	2	0	1
`2` `cmp rdi,1`	2	0	0
`6` `je 20`	2	0	0
`8` `test edi,1`	2	0	1
`e` `je 19`	2	0	1
`19` `shr rdi,1`	1	0	0
`1c` `inc eax`	1	1	0
`1e` `jmp 2`	1	1	0
`2` `cmp rdi,1`	1	1	1
`6` `je 20`	1	1	1
`20` `ret`	1	1	1

eleven instructions to halve a two. n lives in rdi and the count in eax. the zero flag is how a test is remembered until the jump after it: a je jumps only when the flag holds a one.

<table class="trace">
  <thead><tr><th>after</th><th>rdi</th><th>eax</th><th>zero flag</th></tr></thead>
  <tbody>
    <tr><th scope="row">xor eax,eax</th><td>2</td><td>0</td><td>1</td></tr>
    <tr><th scope="row">cmp rdi,1</th><td>2</td><td>0</td><td>0</td></tr>
  </tbody>
</table>

charts

a chart is a table with a class. the frame reads the numbers and draws them, and the table stays in the page: a screen reader gets it instead of the drawing, and so does a feed reader. the first column names each row, every other column is a series, and the caption becomes the title.

<figure>
  <table class="bars" data-max="100">
    <caption>how full a budget is</caption>
    <thead><tr><th>part</th><th>used</th></tr></thead>
    <tbody>
      <tr class="a"><th scope="row">the frame</th><td>96%</td></tr>
      <tr><th scope="row">chart</th><td>97%</td></tr>
      …
    </tbody>
  </table>
  <figcaption>one row is picked out, and the scale is pinned at 100.</figcaption>
</figure>

how full a budget is
part	used
the frame	96%
chart	97%
notes	96%
dump	95%
aside	92%
code	89%
image	83%
math	62%

bars, one series. one row is picked out with a class on its <tr> and the rest step back to grey. the scale is pinned at 100 with data-max, so a full bar means a full budget. these are the frame and the seven pieces of the first table under tables.

with several columns of numbers, each row becomes a group of bars, and the head of the table becomes the legend. there are four inks, and no chart draws more than four series.²

the five largest files, as written and as sent
file	as written	gzipped
site.css	17.8 kb	5.1 kb
site.js	15.5 kb	5.5 kb
chart.js	9.8 kb	3.9 kb
code.js	8.1 kb	3.2 kb
dump.js	7.6 kb	3.2 kb

bars, two series. gzip leaves between three and four tenths of each.

numbers below zero put bars on both sides of a line:

the ten pull requests that moved the frame most, in bytes gzipped
pull request	bytes
#10 charts and code	+818
#22 diffs and line numbers	−139
#25 images	+158
#30 tags, series, reading time	+486
#32 a fix to the reading time	+90
#35 cells of words	+131
#46 room for more pieces	−286
#66 the search and the keys	+228
#88 the list of pieces moves out	−465
#100 another language	+86

bars around zero: the ten changes that moved the frame's weight most, in the order they were made. three made it lighter, and each time something left the frame: the styles for code, the styles for a list of downloads, and at #88 the list of pieces itself.

when the columns are parts of a whole, class="bars stacked" sets them end to end and writes the total at the tip:

what the frame and the pieces are made of, in kb gzipped
part	html	styles	script
the frame	0.9	5.1	5.5
chart	—	1.4	3.9
dump	—	1.5	3.2
code	—	1.2	3.2
notes	—	1.2	1.7
image	—	1.1	1.4
aside	—	0.9	—
math	—	0.6	—

stacked bars. two pieces are a stylesheet and nothing else.

two series can also stand back to back. class="bars mirrored" runs the first left from a middle line and the second right, which is how two halves of one thing are compared: two sexes by age, two sides of a trade, two models on the same tests.

one test, three runs of it
run	haiku 5.5	deepseek v4.1 flash
the makers' own tables	39.2%	31.2%
artificial analysis	32.8%	26.8%
vals ai	35.4%	19.7%

bars back to back, from the article on haiku 5.5: the share of terminal-bench 4.0 each model finished, as three parties measured it.

class="bars waterfall" is for changes that add up. each bar starts where the one above it ended, a rise in one ink and a fall in another, and a row in a <tfoot> is what they come to, drawn from zero.

what the frame gained between its first pull request and #68
stretch	change
charts and code, inside the frame	+0.79 kb
seven small things	+0.24 kb
tags, series and the feed	+0.76 kb
the pieces move out	−0.28 kb
seven more small things	+0.17 kb
the search, the keys, the previews	+0.26 kb
gained in all	+1.94 kb

a waterfall. the same history as the line chart further down, added up by stretch instead of step by step: six changes, one of them a fall, and the 1.94 kb they come to.

a number can say how sure it is. a cell written as 52.8 ± 1.6 ms, as 1.16 (1.15–1.18) or as two ends, 36–43, gives a chart an interval as well as a value, and each form draws it in its own way. on a bar it is a whisker:

four commands, from start to finish
command	time
node, doing nothing	14.1 ± 2.1 ms
writing the link previews	49.3 ± 1.6 ms
writing the feed	33.9 ± 3.6 ms
checking the blog	148.6 ± 2.2 ms

bars with whiskers: the mean of twenty runs on one laptop, give or take a standard deviation. checking every rule on every page costs thirteen hundredths of a second more than starting node does.

a line chart runs across the rows in order. it does not write every value, so the pointer reads them off it, and a link under it swaps the drawing for the table. data-line on the table is a value to read the rest against: a dotted rule, named in the legend in the words it was written with.

the weight of the frame, pull request by pull request
after	the frame
#6	9.86 kb
#7	9.85 kb
#10	10.65 kb
#22	10.51 kb
#23	10.54 kb
#24	10.55 kb
#25	10.70 kb
#26	10.77 kb
#27	10.84 kb
#28	10.88 kb
#29	10.89 kb
#30	11.36 kb
#32	11.45 kb
#33	11.53 kb
#35	11.65 kb
#46	11.37 kb
#48	11.39 kb
#52	11.42 kb
#54	11.44 kb
#56	11.48 kb
#58	11.50 kb
#60	11.51 kb
#62	11.54 kb
#66	11.76 kb
#68	11.80 kb
#74	11.80 kb
#76	11.82 kb
#78	11.85 kb
#80	11.87 kb
#82	11.88 kb
#84	11.89 kb
#86	11.92 kb
#88	11.46 kb
#100	11.55 kb

#10: charts and blocks of code arrive, inside the frame
#30–#35: tags, series, reading time and the feed
#46: the frame makes room: what an article may ask for moves out of it
#66: the search and the keys
#88: the list of pieces leaves the frame

a line and a rule, from data-line="12 kb, the budget". each step is a pull request that changed the frame, named by its number, from the first to the latest. after #100 it stands 462 bytes from its budget.

the numbers over that chart are events: a <dl class="events"> straight after the table, each <dt> saying when in the words of a row, #46, or of two with a dash between them, #30–#35. a moment gets a rule and a stretch gets a band, and the list becomes the key. without the drawing it is still a list of what happened and when.

two measures on different scales never share a chart as they are. set to a common start they can: data-index="low" names a row, and every series becomes a share of what it was there, which is 100.

what more effort buys, and what it costs, with low effort as 100
effort	index score	cost per task
low	29	$0.02
medium	34	$0.05
high	38	$0.08
xhigh	41	$0.12
max	43	$0.21

indexed lines, in powers of ten. the table holds a score out of a hundred and a price in dollars, from the article on haiku 5.5, and the chart shows what happened to each: at the most effort the score is half as high again, and the price is ten and a half times what it was.

class="areas" piles the series of a line chart on each other, for the parts of a whole as they change. the top edge is the total, and only the bottom series can be read against a flat line, so the one that matters most goes first.

all the code the blog can send, pull request by pull request
after	the frame	the pieces	what a reader asks for
#6	9.9 kb	0.0 kb	0.0 kb
#10	10.6 kb	7.5 kb	0.0 kb
#22	10.5 kb	9.2 kb	0.0 kb
#23	10.5 kb	10.1 kb	0.0 kb
#24	10.5 kb	10.7 kb	0.0 kb
#25	10.7 kb	12.7 kb	0.0 kb
#26	10.8 kb	14.8 kb	0.0 kb
#28	10.9 kb	18.2 kb	0.0 kb
#29	10.9 kb	20.2 kb	0.0 kb
#30	11.4 kb	20.2 kb	0.0 kb
#35	11.7 kb	20.2 kb	0.0 kb
#46	11.4 kb	20.9 kb	0.0 kb
#48	11.4 kb	23.6 kb	0.0 kb
#50	11.4 kb	27.6 kb	0.0 kb
#52	11.4 kb	35.3 kb	0.0 kb
#54	11.4 kb	38.5 kb	0.0 kb
#56	11.5 kb	42.2 kb	0.0 kb
#58	11.5 kb	46.8 kb	0.0 kb
#60	11.5 kb	49.6 kb	0.0 kb
#62	11.5 kb	56.1 kb	0.0 kb
#64	11.5 kb	56.8 kb	0.0 kb
#66	11.8 kb	56.8 kb	5.3 kb
#74	11.8 kb	58.8 kb	5.3 kb
#76	11.8 kb	62.7 kb	5.3 kb
#78	11.9 kb	69.7 kb	5.3 kb
#80	11.9 kb	75.4 kb	5.3 kb
#82	11.9 kb	78.8 kb	5.3 kb
#84	11.9 kb	81.0 kb	5.3 kb
#86	11.9 kb	83.1 kb	5.3 kb
#88	11.5 kb	83.1 kb	5.3 kb
#90	11.5 kb	86.5 kb	5.3 kb
#92	11.5 kb	90.5 kb	5.3 kb
#94	11.5 kb	93.2 kb	6.8 kb
#96	11.5 kb	98.7 kb	6.8 kb
#98	11.5 kb	103.7 kb	6.8 kb
#100	11.5 kb	105.2 kb	6.8 kb

areas, in kb gzipped. the frame is the band at the bottom and stays the thickness it started at. everything the blog has learned since #10 went into the pieces, which a page pays for only when it uses them.

class="slope" reads a table the other way: a line for each row, running across the columns. with two columns it says what rose and what fell between two moments. with more, and data-flip when the numbers are places in a ranking, it says who overtook whom.

one test, as it got harder
model	version 2.1	version 3.0	version 4.0
deepseek v4.1 flash	90.6%	30.0%	31.2%
opus 5.0	89.1%	43.3%	51.8%
haiku 5.5	—	—	39.2%

slopes, from the same article. deepseek led on the old exam by a point and a half, and trails by twenty on the current one. haiku 5.5 was only measured on the last, so it is a point and not a line.

charts set side by side in a <figure class="multiples"> share one scale, so they can be read against each other:

index.html
after	kb gzipped
#6	0.89 kb
#7	0.89 kb
#10	0.89 kb
#22	0.89 kb
#23	0.89 kb
#24	0.89 kb
#25	0.89 kb
#26	0.89 kb
#27	0.89 kb
#28	0.89 kb
#29	0.89 kb
#30	0.89 kb
#32	0.89 kb
#33	0.92 kb
#35	0.92 kb
#46	0.92 kb
#48	0.92 kb
#52	0.92 kb
#54	0.92 kb
#56	0.92 kb
#58	0.92 kb
#60	0.92 kb
#62	0.92 kb
#66	0.95 kb
#68	0.95 kb
#74	0.95 kb
#76	0.95 kb
#78	0.95 kb
#80	0.95 kb
#82	0.95 kb
#84	0.95 kb
#86	0.95 kb
#88	0.95 kb
#100	0.95 kb

site.css
after	kb gzipped
#6	4.99 kb
#7	4.97 kb
#10	5.51 kb
#22	5.13 kb
#23	5.14 kb
#24	5.14 kb
#25	5.14 kb
#26	5.12 kb
#27	5.19 kb
#28	5.19 kb
#29	5.19 kb
#30	5.26 kb
#32	5.26 kb
#33	5.27 kb
#35	5.40 kb
#46	5.08 kb
#48	5.08 kb
#52	5.08 kb
#54	5.08 kb
#56	5.08 kb
#58	5.08 kb
#60	5.08 kb
#62	5.08 kb
#66	5.11 kb
#68	5.11 kb
#74	5.11 kb
#76	5.11 kb
#78	5.11 kb
#80	5.11 kb
#82	5.11 kb
#84	5.11 kb
#86	5.11 kb
#88	5.11 kb
#100	5.11 kb

site.js
after	kb gzipped
#6	3.99 kb
#7	3.99 kb
#10	4.25 kb
#22	4.49 kb
#23	4.51 kb
#24	4.52 kb
#25	4.67 kb
#26	4.77 kb
#27	4.77 kb
#28	4.80 kb
#29	4.81 kb
#30	5.21 kb
#32	5.30 kb
#33	5.34 kb
#35	5.34 kb
#46	5.38 kb
#48	5.40 kb
#52	5.43 kb
#54	5.44 kb
#56	5.49 kb
#58	5.51 kb
#60	5.52 kb
#62	5.55 kb
#66	5.71 kb
#68	5.75 kb
#74	5.75 kb
#76	5.77 kb
#78	5.80 kb
#80	5.81 kb
#82	5.82 kb
#84	5.84 kb
#86	5.87 kb
#88	5.41 kb
#100	5.50 kb

small multiples: the same thirty-four steps, file by file. the page itself is a sliver. the stylesheet ends 0.1 kb heavier than it began, having twice handed styles to a piece, and the script 1.5 kb heavier, having handed its list of pieces to a file the frame never reads.

on a line, how sure a number is becomes a band around it:

what gzip leaves of a file, level by level
level	the middle file
1	48.9% (44.3–54.2)
2	48.5% (43.9–54.0)
3	48.3% (43.6–53.7)
4	47.5% (42.7–53.4)
5	47.3% (42.4–53.2)
6	47.3% (42.4–53.2)
7	47.3% (42.4–53.2)
8	47.3% (42.4–53.2)
9	47.3% (42.4–53.2)

a line with a band. a hundred and twenty-three of the blog's files, the frame's and the pieces', each gzipped at all nine levels: the line is the middle file, and the band holds the middle half of them. what a level buys is small beside what sets one file apart from the next, and past level five it buys nothing.

some numbers do not slope. a count stays where it is until something changes it, and class="lines stepped" draws it that way:

pieces an article can call for
after	pieces
#6	0
#7	0
#10	2
#22	2
#23	3
#24	4
#25	5
#26	6
#27	6
#28	7
#29	7
#30	7
#32	7
#33	7
#35	7
#46	8
#48	13
#52	18
#54	21
#56	27
#58	30
#60	32
#62	36
#66	36
#68	36
#74	37
#76	39
#78	42
#80	45
#82	47
#84	49
#86	53
#88	53
#90	55
#92	58
#94	60
#96	63
#98	66
#100	68

a stepped line. the count stood at seven for a while. the jump at #48 is one piece becoming six, a core and each form of chart fetched on its own by the articles that draw it, and every step since is new things an article can use, each a piece of its own.

two columns of numbers make a scatter with class="dots": across by the first, up by the second. the rows picked out are named, and the rest go grey.

length against weight, file by file
file	lines	kb gzipped
index.html	89	1.30
align.css	26	0.31
areas.css	7	0.15
aside.css	94	0.92
bars.css	110	0.96
blocks.css	24	0.38
board.css	82	0.61
callouts.css	68	0.63
card.css	40	0.49
chart.css	205	1.38
chat.css	104	0.93
chem.css	16	0.19
clade.css	108	0.88
clip.css	74	0.60
code.css	180	1.22
compare.css	120	0.93
days.css	75	0.56
delta.css	23	0.26
dump.css	218	1.52
events.css	56	0.52
facing.css	35	0.36
fig.css	19	0.22
files.css	91	0.96
flow.css	60	0.60
flows.css	59	0.52
frames.css	100	0.82
gloss.css	43	0.49
glossary.css	53	0.60
graph.css	109	0.83
heat.css	28	0.41
hist.css	110	0.77
image.css	144	1.12
knob.css	25	0.45
listing.css	103	0.81
marks.css	135	1.06
math.css	36	0.62
matrix.css	35	0.38
notes.css	126	1.20
of.css	45	0.49
pad.css	45	0.46
pair.css	29	0.34
pixel.css	48	0.47
plot.css	209	1.31
qty.css	23	0.25
range.css	64	0.57
revise.css	73	0.74
say.css	16	0.26
scale.css	28	0.39
search.css	204	1.25
set.css	57	0.64
site.css	1,051	5.11
sky.css	87	0.77
slope.css	48	0.39
sort.css	50	0.48
source.css	48	0.44
spans.css	78	0.60
spark.css	35	0.30
spoiler.css	30	0.30
steps.css	57	0.50
sum.css	10	0.21
tabs.css	51	0.47
tiles.css	53	0.64
tokens.css	54	0.63
trace.css	10	0.17
tree.css	125	0.91
treemap.css	79	0.72
align.js	40	1.14
areas.js	54	1.18
bars.js	106	1.95
blocks.js	55	1.37
board.js	20	0.67
callouts.js	18	0.44
chart.js	214	3.93
chat.js	33	0.77
chem.js	15	0.49
clade.js	56	1.39
clip.js	58	1.06
code.js	210	3.24
compare.js	42	0.90
curve.js	92	2.08
days.js	56	1.28
delta.js	10	0.33
dots.js	105	2.42
dump.js	171	3.22
events.js	27	0.81
files.js	22	0.48
flows.js	65	1.61
frames.js	84	1.40
glossary.js	31	0.75
graph.js	95	1.98
heat.js	33	0.74
hist.js	63	1.59
image.js	62	1.36
keys.js	57	0.98
knob.js	124	2.21
lines.js	110	2.37
listing.js	80	1.86
look.js	85	1.54
map.js	29	0.81
marks.js	47	1.08
matrix.js	15	0.39
notes.js	93	1.68
of.js	23	0.72
pixel.js	32	0.80
qty.js	15	0.49
range.js	31	0.85
revise.js	20	0.50
say.js	31	0.54
scale.js	27	0.76
search.js	154	3.04
seq.js	24	0.78
site.js	425	5.50
sky.js	63	1.72
slope.js	56	1.46
sort.js	45	0.98
spans.js	57	1.39
spark.js	14	0.55
spoiler.js	21	0.44
tabs.js	50	0.84
tiles.js	44	1.15
tokens.js	39	1.05
trace.js	13	0.36
treemap.js	90	1.76

dots: every file of the frame and its pieces, a hundred and twenty-three of them, by how long it is and what it weighs. four are picked out, two stylesheets and two scripts. a line of script weighs about two and a half times a line of styles.

some numbers need another kind of scale. data-log counts in powers of ten, for what spans several of them, and data-flip runs a scale backwards, for measures where less is more. each names the axis it is for, x, y or both. a third column of numbers sizes the dots, and the area of a dot is what carries the number.

the planets at their brightest
planet	distance from the sun, in au	magnitude at its brightest	diameter
mercury	0.387	−2.48	0.383
venus	0.723	−4.92	0.949
mars	1.52	−2.94	0.532
jupiter	5.20	−2.94	11.21
saturn	9.57	−0.55	9.45
uranus	19.17	5.38	4.01
neptune	30.18	7.67	3.88

dots across powers of ten and up a scale that runs backwards: a magnitude is smaller the brighter a thing is. distance and diameter are in earths (williams 2025), brightness is as seen from here (mallama and hilton 2018). jupiter is over three times as far from the sun as mars and exactly as bright, being twenty-one times as wide. neptune is the one planet below the rule.

class="dots joined" draws a line through the points in the order of the rows. a line chart spaces its rows evenly, whatever they are called. this one puts each where its number says, so it is the form for a line over uneven time, and with the two scales above, for time counted backwards.

the frame's weight against the clock
after	hours before pull request #72	the frame
#6	14.56 h	9.86 kb
#7	14.53 h	9.85 kb
#10	13.78 h	10.65 kb
#22	13.33 h	10.51 kb
#23	13.26 h	10.54 kb
#24	13.20 h	10.55 kb
#25	13.10 h	10.70 kb
#26	12.99 h	10.77 kb
#27	12.96 h	10.84 kb
#28	12.88 h	10.88 kb
#29	12.80 h	10.89 kb
#30	12.75 h	11.36 kb
#32	12.72 h	11.45 kb
#33	12.68 h	11.53 kb
#35	12.41 h	11.65 kb
#46	2.36 h	11.37 kb
#48	2.30 h	11.39 kb
#52	1.74 h	11.42 kb
#54	1.66 h	11.44 kb
#56	1.39 h	11.48 kb
#58	1.24 h	11.50 kb
#60	1.11 h	11.51 kb
#62	0.70 h	11.54 kb
#66	0.46 h	11.76 kb
#68	0.29 h	11.80 kb

joined dots, on a scale that runs backwards in powers of ten. the first twenty-five steps of the line further up, as far as #68, placed by when each was merged instead of one after another: fifteen in the first two hours, a night with nothing, and ten in the last two and a half hours, which this scale gives most of the room.

with one column of numbers, class="dots" gives each row a line of its own: a point where its number falls, its interval through it, and the number as written at the end. unlike a bar, a point does not start from zero, so it can sit on either side of a rule.

time to gzip at level nine, over time at level six
file	times as long
feed.xml	3.20 (3.19–3.21)
this article	1.68 (1.68–1.69)
the model league	1.62 (1.60–1.63)
site.css	1.18 (1.16–1.20)
site.js	1.08 (1.07–1.09)
chart.js	1.04 (1.02–1.04)
code.js	1.11 (1.10–1.12)
lines.js	1.04 (1.03–1.05)
notes.css	1.01 (1.00–1.02)
bars.css	1.01 (0.98–1.05)

estimates and their intervals, the largest file first. each file was gzipped thirty times at both levels, and the number is one middle time over the other, with the interval that 95 in 100 resamplings of those runs fall in. the large files pay for the higher level. for the two smallest the interval reaches the rule: no difference can be told from none.

class="blocks" is for things that lie in an order and take up room: the sections of a file, the functions of a binary, what a page sends. each row is a name, a size and a kind. they are drawn as one long strip cut into rows, every block as wide as its size and tinted by its kind, and the legend says what share each kind comes to.

what a first visit to this page weighs, in the order it arrives
file	bytes	part
index.html	1,334	the frame
newsreader.woff2	58,084	fonts
site.css	5,230	the frame
site.js	5,627	the frame
this article	51,392	this article
code.js	3,318	its pieces
code.css	1,251	its pieces
pair.css	346	its pieces
callouts.js	451	its pieces
callouts.css	645	its pieces
tabs.js	864	its pieces
tabs.css	478	its pieces
listing.js	1,909	its pieces
listing.css	829	its pieces
chart.js	4,028	its pieces
chart.css	1,415	its pieces
bars.js	1,996	its pieces
bars.css	980	its pieces
lines.js	2,422	its pieces
dots.js	2,481	its pieces
plot.css	1,342	its pieces
areas.js	1,213	its pieces
areas.css	155	its pieces
slope.js	1,500	its pieces
slope.css	403	its pieces
hist.js	1,628	its pieces
hist.css	784	its pieces
flows.js	1,653	its pieces
flows.css	531	its pieces
treemap.js	1,805	its pieces
treemap.css	742	its pieces
graph.js	2,024	its pieces
graph.css	845	its pieces
flow.css	614	its pieces
clade.js	1,428	its pieces
clade.css	901	its pieces
events.js	828	its pieces
events.css	531	its pieces
blocks.js	1,404	its pieces
blocks.css	387	its pieces
days.js	1,307	its pieces
days.css	572	its pieces
spark.js	561	its pieces
spark.css	307	its pieces
range.js	875	its pieces
range.css	587	its pieces
spans.js	1,424	its pieces
spans.css	611	its pieces
of.js	739	its pieces
of.css	501	its pieces
heat.js	761	its pieces
heat.css	420	its pieces
sort.js	1,008	its pieces
sort.css	494	its pieces
delta.js	334	its pieces
delta.css	263	its pieces
qty.js	502	its pieces
qty.css	257	its pieces
pad.css	468	its pieces
tree.css	929	its pieces
steps.css	515	its pieces
spoiler.js	451	its pieces
spoiler.css	312	its pieces
revise.js	516	its pieces
revise.css	761	its pieces
aside.css	939	its pieces
math.css	631	its pieces
image.js	1,391	its pieces
image.css	1,146	its pieces
marks.js	1,107	its pieces
marks.css	1,081	its pieces
compare.js	917	its pieces
compare.css	948	its pieces
pixel.js	817	its pieces
pixel.css	485	its pieces
clip.js	1,090	its pieces
clip.css	616	its pieces
notes.js	1,722	its pieces
notes.css	1,224	its pieces
dump.js	3,297	its pieces
dump.css	1,553	its pieces
seq.js	796	its pieces
align.js	1,170	its pieces
align.css	315	its pieces
map.js	829	its pieces
files.js	494	its pieces
files.css	987	its pieces
matrix.js	395	its pieces
matrix.css	391	its pieces
trace.js	373	its pieces
trace.css	176	its pieces
gloss.css	502	its pieces
facing.css	372	its pieces
source.css	452	its pieces
say.js	554	its pieces
say.css	262	its pieces
chat.js	792	its pieces
chat.css	951	its pieces
tokens.js	1,073	its pieces
tokens.css	643	its pieces
board.js	690	its pieces
board.css	629	its pieces
frames.js	1,434	its pieces
frames.css	840	its pieces
card.css	506	its pieces
scale.js	782	its pieces
scale.css	396	its pieces
set.css	656	its pieces
sky.js	1,758	its pieces
sky.css	785	its pieces
tiles.js	1,176	its pieces
tiles.css	656	its pieces
chem.js	505	its pieces
chem.css	195	its pieces
knob.js	2,267	its pieces
knob.css	463	its pieces
curve.js	2,131	its pieces
sum.css	211	its pieces
glossary.js	764	its pieces
glossary.css	614	its pieces
fig.css	224	its pieces
newsreader-italic.woff2	64,520	fonts

blocks. text is weighed gzipped and the fonts as they are stored. the colours are the ones in the table of spans above.

class="days" is for a number a day: a date in the first column, written year first, and a value in the second. it is drawn as a calendar, a column for each week with monday at the top, and each day is tinted by its number in one hue. the pointer reads a day off it.

how much of the moon is lit, night by night
night	lit
2026-10-01	78%
2026-10-02	68%
2026-10-03	57%
2026-10-04	45%
2026-10-05	34%
2026-10-06	24%
2026-10-07	15%
2026-10-08	8%
2026-10-09	3%
2026-10-10	0%
2026-10-11	0%
2026-10-12	2%
2026-10-13	6%
2026-10-14	11%
2026-10-15	18%
2026-10-16	26%
2026-10-17	34%
2026-10-18	44%
2026-10-19	53%
2026-10-20	63%
2026-10-21	72%
2026-10-22	80%
2026-10-23	88%
2026-10-24	94%
2026-10-25	98%
2026-10-26	100%
2026-10-27	99%
2026-10-28	96%
2026-10-29	89%
2026-10-30	81%
2026-10-31	71%
2026-11-01	60%
2026-11-02	49%
2026-11-03	38%
2026-11-04	27%
2026-11-05	18%
2026-11-06	11%
2026-11-07	5%
2026-11-08	2%
2026-11-09	0%
2026-11-10	0%
2026-11-11	3%
2026-11-12	7%
2026-11-13	12%
2026-11-14	19%
2026-11-15	27%
2026-11-16	36%
2026-11-17	45%
2026-11-18	55%
2026-11-19	65%
2026-11-20	74%
2026-11-21	83%
2026-11-22	91%
2026-11-23	96%
2026-11-24	99%
2026-11-25	100%
2026-11-26	97%
2026-11-27	92%
2026-11-28	84%
2026-11-29	75%
2026-11-30	64%
2026-12-01	53%
2026-12-02	42%
2026-12-03	32%
2026-12-04	23%
2026-12-05	15%
2026-12-06	9%
2026-12-07	4%
2026-12-08	1%
2026-12-09	0%
2026-12-10	1%
2026-12-11	3%
2026-12-12	8%
2026-12-13	13%
2026-12-14	20%
2026-12-15	29%
2026-12-16	38%
2026-12-17	48%
2026-12-18	58%
2026-12-19	68%
2026-12-20	78%
2026-12-21	87%
2026-12-22	94%
2026-12-23	98%
2026-12-24	100%
2026-12-25	99%
2026-12-26	94%
2026-12-27	88%
2026-12-28	79%
2026-12-29	69%
2026-12-30	58%
2026-12-31	48%

a calendar: the last three months of 2026, each night at midnight, universal time, worked out the way meeus 1998 sets down. the moon keeps to neither weeks nor months, so its full nights step down the columns from one month to the next.

and a share can be counted out. a paragraph with class="of" that says 8 in 100 gets a hundred dots over it, eight of them filled. several in one figure sit side by side.

8 in 100 men of european descent see red and green less apart than most people do.

4 in 1,000 women do.

shares counted out, from birch 2012. this is who the four chart inks were measured for.²

and a line can sit in a sentence. the frame went from 9.9 kb to 11.5 9.86 9.85 10.65 10.51 10.54 10.55 10.70 10.77 10.84 10.88 10.89 11.36 11.45 11.53 11.65 11.37 11.39 11.42 11.44 11.48 11.50 11.51 11.54 11.76 11.80 11.80 11.82 11.85 11.87 11.88 11.89 11.92 11.46 11.55 in thirty-four steps. a sparkline has no axis and no scale: it says which way something went, so the numbers that matter belong in the words around it (tufte 2006).

the frame went from 9.9 kb to 11.5
<span class="spark">9.86 9.85 10.65 10.51 … 11.55</span> in thirty-four steps.

some charts are drawn from the things themselves instead of from a summary of them. the table has a row for each thing that was measured, and the class says what to make of them. class="hist" counts the values into bins. class="box" gives each name a box: the middle half of its values, a line at their median, and whiskers out to the smallest and the largest. a table can ask for both, and then they share a scale.

how many lines a pull request changes
kind of pull request	lines added and removed
new features	1,933
new features	940
new features	434
new features	62
new features	275
new features	76
new features	346
new features	344
new features	77
new features	113
new features	140
new features	1,059
new features	538
new features	758
new features	284
new features	583
new features	496
new features	399
new features	711
new features	147
new features	504
new features	250
articles	861
articles	537
articles	655
articles	744
upkeep	316
upkeep	114
upkeep	210
upkeep	8
upkeep	19
upkeep	36
upkeep	13
upkeep	5
upkeep	9

a histogram over three boxes, in powers of ten. the thirty-five pull requests of the blog's first day, counted by git log --numstat with the feed left out, since a script writes it. the small number beside a name is how many it has. half of them changed fewer than three hundred lines, and a new feature is seldom small.

class="flows" is for what goes from one place to another. each row is a source, a destination and an amount, and each becomes a band as thick as its amount, between boxes as tall as everything that passes through them. a destination that is the source of another row gets a column of its own, further right.

a day of work, by what it was for and where its lines landed
kind of pull request	where	lines added and removed
new features	the pieces	5,977
new features	the frame	1,987
new features	the articles	925
new features	the scripts	919
new features	the readme and the flow	661
articles	the articles	2,762
articles	the frame	35
upkeep	the readme and the flow	346
upkeep	the pieces	257
upkeep	the frame	46
upkeep	the scripts	45
upkeep	the articles	36

flows. the same thirty-five pull requests, and the 13,996 lines they changed. the widest band is new features going into the pieces. the surprise is the third from the top: almost a thousand lines of new features went into articles, because each feature is shown on this page as it is built.

a nested list with a number on each leaf, <ul class="treemap">, is drawn as tiles whose areas are the numbers, each group in its own ink. it shows at a glance what a bar chart of fourteen rows makes the eye add up: how much each group comes to. the list stays behind the drawing, one click away.

LINEs
- l1 16.89%
- l2 3.22%
- l3 0.31%
SINEs
- alu 10.60%
- mir 2.20%
- mir3 0.34%
retrovirus-like
- malr 3.65%
- class i 2.89%
- class iii 1.44%
- class ii 0.31%
DNA transposons
- charlie 1.39%
- tigger 1.02%
- zaphod 0.16%
- the rest 0.27%

a treemap: the 44.83% of the human genome that is copies of sequences able to copy themselves, by class and family, as the first draft of the genome counted them (international human genome sequencing consortium 2001, table 11). two families, L1 and Alu, are more than a quarter of everything we carry.

two more forms are maps. a <table class="sky"> has a row for each star: its right ascension and its declination in degrees, and its magnitude. it is drawn the way an atlas prints the sky, ink on paper, east on the left, a brighter star a larger dot. these are the nine stars marked on the picture of orion, figure 2, from the same numbers:

orion, from a table
star	right ascension	declination	magnitude
betelgeuse	88.79	7.41	0.42
bellatrix	81.28	6.35	1.64
meissa	83.78	9.93	3.66
mintaka	83.00	−0.30	2.41
alnilam	84.05	−1.20	1.69
alnitak	85.19	−1.94	1.77
saiph	86.94	−9.67	2.06
rigel	78.63	−8.20	0.13
hatysa	83.86	−5.91	2.77

figure 1. the chart makes room for the stars it is given. data-frame on the table pins its edges instead, the way it does for marks.

and a <table class="tiles"> draws a map without drawing a coastline. each row is a place, where its tile goes, across and then down, and a number. every place gets a square of one size, tinted by its number, so a small place counts for as much to the eye as a large one. a tile may sit a part of a step along, which staggers the rows. it is made for provinces and countries. here the places are the keys of a keyboard, and the number is how much of this article each letter was on 12 october 2026, out of 65,487 letters:

the letters of this article, where the fingers find them
letter	across	down	% of all letters
q	1	1	0.2
w	2	1	1.9
e	3	1	12.4
r	4	1	5.8
t	5	1	10.2
y	6	1	1.1
u	7	1	2.0
i	8	1	6.8
o	9	1	6.0
p	10	1	2.1
a	1.25	2	9.1
s	2.25	2	8.6
d	3.25	2	3.7
f	4.25	2	2.4
g	5.25	2	2.1
h	6.25	2	5.1
j	7.25	2	0.3
k	8.25	2	1.4
l	9.25	2	4.1
z	1.75	3	0.1
x	2.75	3	0.3
c	3.75	3	3.5
v	4.75	3	0.7
b	5.75	3	2.1
n	6.75	3	6.0
m	7.75	3	2.2

<table class="sky">
  <tr><th scope="row">rigel</th><td>78.63</td><td>−8.20</td><td>0.13</td></tr>
</table>

<table class="tiles">
  <tr><th scope="row">e</th><td>3</td><td>1</td><td>12.4</td></tr>
  <tr><th scope="row">a</th><td>1.25</td><td>2</td><td>9.1</td></tr>
</table>

bytes

two drawings take a file format apart. the first is a hex dump: bytes written as pairs of hex digits, set sixteen to a row, or eight where sixteen would not fit, with the offset in front and the same bytes as text behind. these are the first 48 bytes of the font this sentence is set in, a woff2 file (levantovsky and levien 2018). its first four spell wOF2.

77 4f 46 32 00 01 00 00 00 00 e2 e4 00 14 00 00
00 01 b2 dc 00 00 e2 71 00 01 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

a range in a <mark> is tinted in both columns, and named under the dump with where it starts and how long it is. the second drawing is the layout of a header: a table with a row for each field and its size, and above it a strip with every field as wide as it is.

the header of a woff2 file, 48 bytes
field	bytes	in this file
signature	4	`wOF2`
flavour	4	truetype outlines
length	4	58,084 bytes
tables	2	20
reserved	2	0
size unpacked	4	111,324 bytes
size packed	4	57,969 bytes
major	2	1, the version of the format
minor	2	0
metadata offset	4	0, there is none
metadata length	4	0
metadata unpacked	4	0
private offset	4	0, there is none
private length	4	0

the strip is sixteen bytes to a row, like the dump above it. pointing at a field lights its row in the table.

with data-unit="bit" the same table is a register, or a byte that packs several things. it is written from its highest bit down, as a register is, and the number on each field is the bit it starts at. this is the last byte of the instruction that triples n in the listing, 48 8d 3c 7f: the byte that says rdi, plus twice rdi.

the byte `7f`, as the processor reads it after `lea`
field	bits	holds	which means
scale	2	`01`	the second register is doubled
index	3	`111`	the second register is `rdi`
base	3	`111`	the first register is `rdi`

eight bits, three fields. the strip counts down from bit seven, the way the manuals draw it.

<pre class="hex" data-label="assets/fonts/newsreader.woff2">
<mark data-label="signature">77 4f 46 32</mark> <mark data-label="flavour: truetype outlines">00 01 00 00</mark> …
</pre>

<table class="fields" data-per="16">
  <thead><tr><th>field</th><th>bytes</th><th>in this file</th></tr></thead>
  <tbody>
    <tr class="a"><th scope="row">signature</th><td>4</td><td><code>wOF2</code></td></tr>
    …
  </tbody>
</table>

two dumps in a <figure class="pair"> are compared, byte against byte, and the ones that are not the same are picked out in both: on the left in the tint a patch gives to what it takes out, on the right in the tint for what it puts in. the blog has two font files, and their headers begin alike:

77 4f 46 32 00 01 00 00 00 00 e2 e4 00 14 00 00
00 01 b2 dc 00 00 e2 71 00 01 00 00 00 00 00 00

77 4f 46 32 00 01 00 00 00 00 fc 08 00 14 00 00
00 01 df 48 00 00 fb 94 00 01 00 00 00 00 00 00

the first 32 bytes of the upright and the italic. six bytes differ, two in each of three sizes: the file, its tables unpacked, and its tables packed. everything else in the header is the same.

where things sit, in a file or in memory, is a <table class="map">: a name, a start and a size in each row. the strip above it is drawn to scale, except that nothing is drawn too thin to point at, and a stretch that no row accounts for is hatched. this is the object file the listing was read from:

steps.o, 872 bytes
part	starts at	bytes	what it holds
elf header	0x000	64	what kind of file this is, and where the section headers are
`.text`	0x040	33	the function: the twelve instructions of the listing
`.comment`	0x061	39	the name and version of the compiler
`.symtab`	0x088	72	three symbols, one of them `steps`
`.strtab`	0x0d0	15	their names
`.shstrtab`	0x0df	69	the names of the sections
section headers	0x128	576	nine entries of 64 bytes, one for each section

two thirds of the file describe the rest of it, and the function is 33 bytes. the hatched sliver in front of the section headers is four bytes of padding, there so that the headers start on a multiple of eight. a name is written in the strip where there is room to read it, and the table has them all.

a sequence is not bytes, but it is read the same way. a <pre class="seq"> sets dna, rna or protein in tens under a ruler, six tens to a row where there is room, with the position each row starts at, and names its marked ranges underneath. this is human insulin as the cell first makes it (uniprot P01308):

MALWMRLLPL LALLALWGPD PAAAFVNQHL CGSHLVEALY LVCGERGFFY TPKTRREAED
LQVGQVELGG GPGAGSLQPL ALEGSLQKRG IVEQCCTSIC SLYQLENYCN

the signal is cut off on the way out of the cell's factory, and the c peptide is cut out from between the two chains, which stay joined. the two pairs of letters left untinted are where those cuts are made.

several sequences that are nearly the same are a <pre class="align">: a line for each, its name and then its letters, with a - wherever one of them has nothing. they are set letter under letter. a letter that is not the one the first sequence has there is tinted, a gap is tinted another way, and the last line has a star under every place they all share. these are the first ninety letters of the gene for β-globin that are read into protein (refseq NG_059281.1), and the same letters with three changes that are found in people: the one behind sickle-cell disease, the one behind haemoglobin e (aziz and others 2025), and a loss of two letters that puts every letter after it out of step (tariq and others 2021).

reference    ATGGTGCATCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGC
hb s         ATGGTGCATCTGACTCCTGTGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGC
hb e         ATGGTGCATCTGACTCCTGAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTAAGGCCCTGGGC
codon 5 −ct  ATGGTGCATCTGACTC--GAGGAGAAGTCTGCCGTTACTGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGGCCCTGGGC

<pre class="align" data-label="hbb">
reference    ATGGTGCATCTGACTCCTGAGGAGAAG…
hb s         ATGGTGCATCTGACTCCTGTGGAGAAG…
codon 5 −ct  ATGGTGCATCTGACTC--GAGGAGAAG…
</pre>

<figure class="pair">
  <pre class="hex" data-label="newsreader.woff2">77 4f 46 32 … 00 00 e2 e4 …</pre>
  <pre class="hex" data-label="newsreader-italic.woff2">77 4f 46 32 … 00 00 fc 08 …</pre>
</figure>

<table class="map">
  <thead><tr><th>part</th><th>starts at</th><th>bytes</th></tr></thead>
  <tbody>
    <tr><th scope="row">elf header</th><td>0x000</td><td>64</td></tr>
    <tr class="a"><th scope="row">.text</th><td>0x040</td><td>33</td></tr>
    …
  </tbody>
</table>

<pre class="seq" data-label="preproinsulin, homo sapiens">
<mark data-label="signal peptide">MALWMRLLPL LALLALWGPD PAAA</mark><mark data-label="b chain">FVNQHL …</mark>
</pre>

maths

a formula is written in mathml, which browsers set by themselves: no script, no font to download (carlisle and wang). it can sit in a line, like the step of a chart's axis, $s \in {1, 2, 5} \times 10^{k}$ , or take a line of its own. this is how the frame works out the reading time above every title, from the words $w$ outside tables and code, and the number $b$ of tables and blocks of code:³

minutes = ⌈ \frac{w}{230} + \frac{b}{4} ⌉

the reading time. the haiku report has about 5,800 words and 20 tables and blocks: 25.2 and 5 make 31 minutes.

<math display="block">
  <mi>minutes</mi><mo>=</mo>
  <mrow><mo>⌈</mo>
    <mfrac><mi>w</mi><mn>230</mn></mfrac><mo>+</mo><mfrac><mi>b</mi><mn>4</mn></mfrac>
  <mo>⌉</mo></mrow>
</math>

numbers and words inside a formula are set in the face of the text around them. a lone letter is a variable and comes out italic. brackets and signs come from the reader's own maths face, so they can look a little different from one machine to the next.

a formula can also be worked out, on numbers the reader changes. a <data class="knob"> is a number in a sentence that is dragged sideways, or moved with the arrow keys, and every <output data-f> works its formula out again. a page that grows by 5% with every pull request weighs 1.6 times what it did after 10 of them, and twice as much after 15.

how many times its weight, by pull request
pull requests	times its weight
0	1.0
10	1.6
20	2.7
30	4.3
40	7.0
50	11.5

a <table class="curve"> holds a few values of a formula and is drawn as the whole line, and again when a knob moves. a formula is arithmetic, read by the piece itself and never run as code. the checker works each one out where the knobs stand, so what the page says without scripts, and in the feed, is true.

<data class="knob" data-name="r" data-min="1" data-max="20" value="5"
  aria-label="percent it grows by each time">5</data>
<output data-f="(1 + r/100)^n" data-places="1">1.6</output>

<table class="curve" data-f="(1 + r/100)^x">
  <tr><th scope="row">10</th><td>1.6</td></tr>
</table>

images

an image lives in the article's folder. it has to say what it shows and how large it is, so the page holds its place while the file is on its way and nothing jumps when it lands. it is fetched when the reader gets near it, never before. in a figure it opens large on a click, and closes on another click, on esc, or when the page is scrolled on. opened, it can be looked into: the wheel or two fingers bring it closer about the point they are on, a drag moves it, and a click steps back out, to the whole picture first and then to the page. +, - and the arrows do the same. the part that does this is fetched the first time an image is opened.

the blog's stylesheet, all 1,051 lines of it, drawn the way an editor's minimap would: a mark for every character. letters are ink, digits blue, braces red. the file shown is 7 kb, and a click opens one with four times the pixels.

<figure>
  <a href="stylesheet-large.png">
    <img src="stylesheet.png" alt="five columns of short dark dashes …" width="540" height="330">
  </a>
  <figcaption>the blog's stylesheet, all 1,051 lines of it …</figcaption>
</figure>

the link around it is optional: without one, the image opens as it is. outside a figure an image sits in the line and does not open, like the dot that marks the current section in the sidebar. an image may weigh 250 kb at most, and the checker measures the file to see that the width and height written beside it are its real shape.

some pictures need pointing at. an <ol class="marks"> after an image is its key, and each item says where its number goes: data-at="62% 31%", across and then down, as shares of the image. where there is room beside the image the key stands there, so that neither has to be scrolled away to read the other, and pointing at a number lights its line.

a picture of somewhere can be marked in that place's own coordinates instead. data-frame on the list says what the picture's left, bottom, right and top edges are, west south east north on a map, and each data-at is then a place: across, and then up. such a mark is a ring round the place, with its number off to the upper right, or wherever left and down send it. and a picture that says how much it spans, with data-across, gets a bar of a round length to measure by. this is orion, drawn from the positions and magnitudes that simbad holds for its stars (wenger and others 2000). its marks are right ascensions and declinations in degrees, and on a chart of the sky east is on the left, so the frame's first number is the larger:

betelgeuse α · 0.42
bellatrix γ · 1.64
meissa λ · 3.66
mintaka δ · 2.41
alnilam ε · 1.69
alnitak ζ · 1.77
saiph κ · 2.06
rigel β · 0.13
hatysa ι · 2.77

figure 2. every star brighter than magnitude 5.5 in a field of 18 by 23 degrees, fifty-six of them, with north up and east to the left. a brighter star is a larger dot, and its colour leans the way the star's does. each line of the key gives a star's letter in the constellation and its magnitude.

a figure the text points at from far away can carry a number. class="fig" counts it, and the number is said before its caption: the picture above is figure 2, and the same stars drawn from a table, under charts, are figure 1. the stylesheet does the counting. the checker reads every link that says “figure” and a number, and fails when the number is not the one its figure has.

<figure class="fig" id="orion-picture"> … </figure>

<p>… the picture above is <a href="../../#/typography/everything-this-blog-can-do/orion-picture">figure 2</a>.</p>

two pictures of one thing are compared best in one place. a <figure class="compare"> with two images of the same shape lays the second over the first and puts a divider between them. it can be dragged, sent somewhere with a press, or moved with the arrow keys once it has the focus, and a data-label on an image names its side. the two below are simulated: the belt and the sword from the chart above with the noise of a short exposure added, once, and then sixty-four times over and averaged.

averaging sixty-four frames leaves an eighth of the noise, the square root of sixty-four. measured in an empty corner of these two, it is 7.98 times less. twenty-one stars are in the field, and the faintest of them can only be told from the noise on the right.

when two pictures should be read side by side, and not one through the other, they are panels. a <figure class="set"> holds a figure for each, letters them in their corners, and keeps one caption under them all. they stand in a row where there is room and under each other where there is not, and each still opens large.

the two frames of the divider above, as panels: a one exposure, b sixty-four, averaged.

pixel art is the one kind of picture that must never be smoothed. an <img class="pixel"> is shown at a whole multiple of its size, the largest that fits, counted in the pixels of the screen and not of the page, so that each of its pixels is a clean square and all of them are the same size. data-max="4" holds it to four times. the caption is told what the multiple came to.

a night drawn by a short script, in four greens. the file is 599 bytes.

a <ul class="palette"> shows the colours themselves: each item gets a swatch of the first colour written in it. these are the four greens most often used to stand for the screen of the first game boy, with how many of the scene's 5,184 pixels wear each.

#0f380f 2,039
#306230 2,381
#8bac0f 633
#9bbc0f 131

and some things only make sense moving. a short silent loop is written as a still that links to its file, in a <figure class="clip">. that is all a feed reader or a browser without scripts will show, and it is enough. here the still stays until the reader is near, and only then is the clip fetched. it plays while it is in view, rests when it is not, and stops at its button or at a press on the picture. a reader who has asked their system for less motion gets the still, and a button that says play.

gosper's glider gun, the first pattern found in conway's game of life that grows without end (gardner 1971). it fires a glider every thirty generations. here an eater at the lower right swallows each one, so after thirty frames everything is where it began and the loop has no seam. three seconds, 10 kb.

<figure>
  <img src="orion.png" alt="a dark sky with the stars of orion …" width="720" height="900" data-across="18.4°">
  <ol class="marks" data-frame="92.90 -12.03 74.48 10.82">
    <li data-at="88.79 7.41">betelgeuse <small><i>α</i> · 0.42</small></li>
    <li data-at="85.19 -1.94 left down">alnitak <small><i>ζ</i> · 1.77</small></li>
    …
  </ol>
</figure>

<figure class="compare">
  <img src="one.jpg" alt="a grainy grey frame …" width="720" height="450" data-label="one exposure">
  <img src="sixty-four.jpg" alt="the same frame, smooth …" width="720" height="450" data-label="sixty-four, averaged">
</figure>

<figure class="set">
  <figure><img src="one.jpg" alt="a grainy grey frame …" width="720" height="450"></figure>
  <figure><img src="sixty-four.jpg" alt="the same frame, smooth …" width="720" height="450"></figure>
  <figcaption><b>a</b> one exposure, <b>b</b> sixty-four, averaged.</figcaption>
</figure>

<figure>
  <img class="pixel" src="scene.png" alt="a night in four greens …" width="96" height="54">
</figure>

<ul class="palette">
  <li><code>#0f380f</code> 2,039</li>
  …
</ul>

<figure class="clip">
  <a href="gun.mp4"><img src="gun.png" alt="black cells on a pale grid …" width="552" height="408"></a>
</figure>

some pictures are better written than drawn. a <pre class="board"> is a grid with a character for each cell, and the list after it is its legend: each item starts with the character it explains, and data-ink gives that character one of the four inks. a character the legend leaves out is an empty cell, and a space is no cell at all, which is how four boards stand in one block here. this is a glider, generation by generation, with what the rules are about to do to it:

...... ...... ...... ......
..x... ...... ...... ......
.+.o.. .x.o.. ..+x.. ..x+..
.xoo.. .+xo.. .x.o+. ...xo.
..+... ..o+.. ..oo.. ..oo+.
...... ...... ...... ......

o alive, and staying so
x alive, and about to die
+ empty, and about to be born

four generations of a glider, left to right. black and red together are the glider as it is, black and green the glider as it will be. worked out by running the rules.

frames that follow each other can share one file. an <img class="frames" data-frames="24"> is a strip of that many frames side by side, shown one at a time, six a second unless data-fps says otherwise. it moves only while it is in view and it can be stopped. stopped, a press on the picture moves it on by one. this glider lives on a board six cells square whose edges are joined, so after twenty-four generations it is back where it began:

twenty-four frames in one file of 0.8 kb.

and two pictures of one shape can take turns, which is how astronomers used to find what had moved between two plates. in a <figure class="blink"> the pictures lie on each other and swap every 0.8 seconds, or every data-every, and data-label names each one under the picture. this is the gun of the clip above, and the same gun thirty generations later. everything in it is back where it was, and the one new thing is the glider it has let go:

thirty-six cells, then forty-one.

<pre class="board" aria-label="four small boards …">
..x... ......
.+.o.. .x.o..
</pre>
<ul>
  <li data-ink="2"><code>x</code> alive, and about to die</li>
</ul>

<img class="frames" data-frames="24" src="glider.png" alt="…" width="3456" height="144">

<figure class="blink">
  <img src="gun-0.png" alt="…" width="456" height="168" data-label="generation 0">
  <img src="gun-30.png" alt="…" width="456" height="168" data-label="generation 30">
</figure>

the checker holds each of these to its form. a mark needs its place, the two sides of a comparison need one shape, pixel art has to be stored without loss and at the size written beside it, and a clip is an mp4 or a webm of 500 kb at most, behind a still that is checked like any other image.

asides and folds

an <aside> is a note beside the argument. a <strong> at its start gives it a name, and class="warn" turns it into a warning, like the one near the top of this page.

a <details> folds away what most readers will not need. it can hold anything an article can.

what the checker printed for this blog

weight, gzipped

  the shell (html + css + js)                              11.5 kb  of 12
  the library (4 articles)                                  0.5 kb  of 1
  code, for the articles that use it                        4.5 kb  of 5
  pair, for the articles that use it                        0.3 kb  of 0.5
  callouts, for the articles that use it                    1.1 kb  of 1.5
  tabs, for the articles that use it                        1.3 kb  of 1.5
  listing, for the articles that use it                     2.7 kb  of 3
  chart, for the articles that use it                       5.3 kb  of 5.5
  bars, for the articles that use it                        2.9 kb  of 3
  lines, for the articles that use it                       2.4 kb  of 2.5
  dots, for the articles that use it                        2.4 kb  of 2.5
  plot, for the articles that use it                        1.3 kb  of 1.5
  areas, for the articles that use it                       1.3 kb  of 1.5
  slope, for the articles that use it                       1.9 kb  of 2
  hist, for the articles that use it                        2.4 kb  of 2.5
  flows, for the articles that use it                       2.1 kb  of 2.5
  treemap, for the articles that use it                     2.5 kb  of 2.5
  graph, for the articles that use it                       2.8 kb  of 3
  flow, for the articles that use it                        0.6 kb  of 1
  clade, for the articles that use it                       2.3 kb  of 2.5
  events, for the articles that use it                      1.3 kb  of 1.5
  blocks, for the articles that use it                      1.7 kb  of 2
  days, for the articles that use it                        1.8 kb  of 2
  spark, for the articles that use it                       0.8 kb  of 1
  range, for the articles that use it                       1.4 kb  of 1.5
  spans, for the articles that use it                       2.0 kb  of 2
  of, for the articles that use it                          1.2 kb  of 1.5
  heat, for the articles that use it                        1.2 kb  of 1.5
  sort, for the articles that use it                        1.5 kb  of 2
  delta, for the articles that use it                       0.6 kb  of 1
  qty, for the articles that use it                         0.7 kb  of 1
  pad, for the articles that use it                         0.5 kb  of 1
  tree, for the articles that use it                        0.9 kb  of 1
  steps, for the articles that use it                       0.5 kb  of 1
  spoiler, for the articles that use it                     0.7 kb  of 1
  revise, for the articles that use it                      1.2 kb  of 1.5
  aside, for the articles that use it                       0.9 kb  of 1
  math, for the articles that use it                        0.6 kb  of 1
  image, for the articles that use it                       2.5 kb  of 3
  marks, for the articles that use it                       2.1 kb  of 2.5
  compare, for the articles that use it                     1.8 kb  of 2
  pixel, for the articles that use it                       1.3 kb  of 1.5
  clip, for the articles that use it                        1.7 kb  of 2
  notes, for the articles that use it                       2.9 kb  of 3
  dump, for the articles that use it                        4.7 kb  of 5
  seq, for the articles that use it                         0.8 kb  of 1
  align, for the articles that use it                       1.5 kb  of 1.5
  map, for the articles that use it                         0.8 kb  of 1
  files, for the articles that use it                       1.4 kb  of 1.5
  matrix, for the articles that use it                      0.8 kb  of 1
  trace, for the articles that use it                       0.5 kb  of 1
  gloss, for the articles that use it                       0.5 kb  of 0.5
  facing, for the articles that use it                      0.4 kb  of 0.5
  source, for the articles that use it                      0.4 kb  of 0.5
  say, for the articles that use it                         0.8 kb  of 1
  chat, for the articles that use it                        1.7 kb  of 2
  tokens, for the articles that use it                      1.7 kb  of 2
  board, for the articles that use it                       1.3 kb  of 1.5
  frames, for the articles that use it                      2.2 kb  of 2.5
  card, for the articles that use it                        0.5 kb  of 0.5
  scale, for the articles that use it                       1.2 kb  of 1.5
  set, for the articles that use it                         0.6 kb  of 1
  sky, for the articles that use it                         2.5 kb  of 2.5
  tiles, for the articles that use it                       1.8 kb  of 2
  chem, for the articles that use it                        0.7 kb  of 1
  knob, for the articles that use it                        2.7 kb  of 3
  curve, for the articles that use it                       2.1 kb  of 2.5
  sum, for the articles that use it                         0.2 kb  of 0.5
  glossary, for the articles that use it                    1.3 kb  of 1.5
  fig, for the articles that use it                         0.2 kb  of 0.5
  keys, when a reader asks for it                           1.0 kb  of 1.5
  search, when a reader asks for it                         4.3 kb  of 4.5
  look, when a reader asks for it                           1.5 kb  of 2
  fonts (2 files)                                         119.7 kb  of 130
  typography/everything-this-blog-can-do/index.html          50.2 kb  of 52
    its 12 images, as stored                              305.4 kb  of 250 each
    its clip, as stored                                    10.2 kb  of 500 each
    its sound, as stored                                   29.8 kb  of 100 each
  software/la-liga-de-modelos-de-opencode-go/index.html     7.0 kb  of 40
  software/claude-haiku-5-5/index.html                     16.5 kb  of 40
  software/opencode-go-model-league/index.html              6.5 kb  of 40

all good: 2 sections, 4 articles.

<aside>
  <p><strong>the rule behind all of it.</strong> a page pays only for what it uses.</p>
</aside>

<details>
  <summary>what the checker printed for this blog</summary>
  <pre><code>…</code></pre>
</details>

notes and references

a small number in the text leads to a note. on a wide screen the note moves out into the margin, beside the line that cites it. on a narrow one it waits at the foot of the article, with a caret that leads back, until it is asked for: a press on its number opens it right under the line that cites it, and another puts it away. on paper it stays at the foot. wherever it is, it is only ever in one place. a note cited twice, like the one about the inks,² gets a letter at the foot for each place that cites it. and when every note has gone to the margin, the list and its heading step aside: on a wide screen this page has no section of notes at all.

a reference is the same idea with a different job. it stays in its list on every screen, keeps the capitals a citation is written with, and can be cited by a number or by name, the way this page is set in newsreader (the newsreader project authors 2020) and its feed is an atom feed (nottingham and sayre 2005).

a reference can also say what kind of evidence it is, which matters most when the subject is health. data-kind takes one of six words, review, trial, observational, lab, guideline or preprint, and the reference wears it as a label in its list. four more are for other subjects. primary is the record itself and secondary an account of it, which is what history asks first of a source: on this page caesar is the one, and the encyclopaedia that transcribes trajan's column is the other. vendor is what the maker of a thing says about it, and benchmark is somebody's measurement of it. three papers about vitamin d show why it is worth a word. in a cohort of 13,331 adults, those with the least of it in their blood died at a higher rate over the nine years or so that followed (melamed and others 2008). in a trial, 25,871 people took it or a placebo for about five years, and about as many broke a bone either way (leboff and others 2022). and a review that pooled 81 trials found no effect on fractures or falls (bolland and others 2018). the first kind can say that two things go together, and only the other two can say what a supplement does.

that aside is the other half. an article about health says once, plainly, what it is not, in an <aside class="care">. the checker asks for one in every article tagged health, and the words are the author's.

a glossary is a third list. a <dl class="glossary"> holds the words an article uses in a sense of its own, each a <dfn>, in the order of the alphabet. a word in the text that links to its entry sits on a dotted line, and a press on it opens what it means under the line it is on, the way a note opens. four words on this page do, where each is first explained, and this is where they lead:

feed: one file, feed.xml, with every article in it whole. a feed reader follows the blog through it, and the search reads it.
frame: the one page every address opens: index.html, its stylesheet and its script. it draws the sidebar and fetches the article that was asked for.
library: the list of every article, written inside the frame: its section, its title, its date and its tags.
piece: a script, a stylesheet or both, fetched only by the articles that use what it draws.

<p>the blog is one html page, the <a href="../../#/typography/everything-this-blog-can-do/term-frame">frame</a>.</p>

<dl class="glossary">
  <dt id="term-frame"><dfn>frame</dfn></dt>
  <dd>the one page every address opens …</dd>
</dl>

<p>nothing comes from another site.<sup><a href="../../#/typography/everything-this-blog-can-do/note-fonts">1</a></sup></p>
<p>… its feed is an atom feed (<a href="../../#/typography/everything-this-blog-can-do/rfc-4287">nottingham and sayre 2005</a>).</p>

<ol class="notes">
  <li id="note-fonts">the two font files are served from the blog's own folder.</li>
</ol>

<ol class="refs">
  <li id="rfc-4287"><cite>Nottingham, M. &amp; Sayre, R., eds. (2005).
    <i>The Atom Syndication Format</i>. RFC 4287.</cite></li>
  <li id="leboff-2022" data-kind="trial"><cite>LeBoff, M. S., Chou, S. H., Ratliff, K. A. et al. (2022). …</cite></li>
</ol>

<aside class="care"><strong>a word of care.</strong> nothing here is advice about what to take …</aside>

around the article

an article is listed in the library with a title, a line that says what it is, and a date. three more fields are optional:

{
  "section": "software",
  "slug": "everything-this-blog-can-do",
  "title": "everything this blog can do",
  "deck": "every piece an article can use, shown and explained.",
  "date": "2026-10-12",
  "updated": "2026-10-12",
  "tags": ["blog", "writing"]
}

tags. each tag has a page of its own with everything that carries it, from every section. the links are under this article.
a series. articles that share a "series" are parts of one thing. each says which part it is beside its date, and lists them all in order at its foot.
the reading time is counted by the frame, from the formula under maths.
the feed. feed.xml carries every article in full, newest first. a chart arrives in a reader as the table it was written as.

two more fields are for an article that is not in english. "lang" says which language it is in, and the frame marks its title and its text as that language, for the software that reads a page aloud or breaks its words. a translation also names what it translates, as "translates": "software/opencode-go-model-league", and the checker sees that each of the two leads to the other. the league of models is one: it can be read en español.

the same entry is what a link to this article says of it somewhere else. paste a link into a chat, and the software there fetches it, reads the top of the file for a title and a line about it, and runs no script. so the first lines of this article's own file say both. nobody wrote them: scripts/head.mjs did, from the entry above, and the checker fails when the two disagree. the last of those lines is for the frame and not for a preview: it names the pieces this article needs, which is all of them.

<script>location.replace("../../#/typography/everything-this-blog-can-do")</script>
<meta charset="utf-8">
<title>everything this blog can do · nahuel genchi</title>
<meta name="description" content="every piece an article can use, shown and explained.">
<meta property="og:type" content="article">
<meta property="og:site_name" content="nahuel genchi">
<meta property="og:title" content="everything this blog can do">
<meta property="og:description" content="every piece an article can use, shown and explained.">
<meta property="article:published_time" content="2026-10-12">
<meta property="article:modified_time" content="2026-10-12">
<meta name="twitter:card" content="summary">

the frame leaves those lines out when it sets the article, and so do the feed and the search. they add about 160 bytes to each article. two limits come with them. the address to paste is the folder's, typography/everything-this-blog-can-do/, which is the one the feed gives out: the address in the bar has a # in it, and what follows a # never reaches a server, so a preview of it is a preview of the front page. and a preview with a picture needs the picture's full address, which waits for the blog to have one.

the third field, "updated", is the day an article last changed, and it comes with a duty: the article has to say what changed. the smallest change is made where it stands, with <del> for what was taken out and <ins> for what was put in. the article on haiku 5.5 first said of four scores that they were ~~inside half a point of each other~~ inside two points of each other, three of them inside 0.6, with the four scores written in the same sentence.

anything larger goes in a list with class="changes": one dated entry for each day the article was touched, newest first. the date at the top of the page then gains an “updated”, linked to the list, and the checker will not let the list and the library disagree about the day. this page has one, and so does the article that needed it most.

<p>… they were <del>inside half a point</del> <ins>inside two points</ins> of each other.</p>

<h2>changes</h2>

<ul class="changes">
  <li><time datetime="2026-10-12">12 october 2026</time> twelve sentences and labels
    disagreed with the numbers beside them, and were made to agree.</li>
</ul>

what keeps it honest

one script, scripts/check.mjs, reads the whole blog and fails on anything that breaks a rule. it runs on every pull request, and nothing reaches the blog without passing it. it checks that:

every visible letter is lowercase, outside the exceptions under words
nothing is fetched from another site, and every link inside the blog leads somewhere
the frame, each piece, each article and each image is under its weight
a chart is a table the frame can draw, with its series named and no more than four of them
an image says what it shows and gives its true shape
every note is cited, and every note and reference has an address
a quantity is written with the signs made for it
an article the library calls updated says what changed, on the same day
the feed, and what a link preview reads, have kept up with the library

it cannot check that a page reads well. that part is done by looking, on a phone and on a wide screen.

changes

12 october 2026 the page grew on the day it was published, as the blog did. new since the morning: charts that say how sure they are, tables that draw themselves, tables read at a glance, the small things under words and lists, under code the pair, the callouts and the listing, under bytes the diff, the map and the sequence, under images the marks, the divider, pixel art and clips, under notes and references notes that open in place, kinds of evidence and the word of care, and around it all the search and the keys, and what a link to an article says of it when it is pasted somewhere. at the end of the day every number the page gives about the blog was measured again. then it began to grow again, by subject. under words: glosses, readings over a word, facing text, sources as they were written, a sound, words tinted by a number, numbers as science writes them, and chemistry. under lists: trees that show a change, trees with lengths, pipelines, conversations, cards of facts, and downloads with a sum. under tables: tracks, deep time, yes and no, and totals that are added up. under maths: numbers a reader can change, and curves. under code: tabs, sessions at a terminal, graphs and traces. under bytes: bits and alignments. under notes and references: four more kinds of source, and a glossary. under images: a closer look at an opened one, marks by coordinates, a bar to measure by, panels, boards written in characters, strips of frames, pictures that take turns, and figures with numbers. around the article: one in another language. under charts: the sky, maps of tiles, events, dots joined in order, bars back to back, waterfalls, indexed lines, areas, slopes, histograms and boxes, flows and treemaps. when that was done, the numbers were measured once more.

notes

the two font files are served from the blog's own folder, with their licence beside them.
each pair of the four inks was measured, on this paper colour, to hold apart for readers with the common forms of colour blindness. the hex dump uses the same four.
230 words a minute is a comfortable pace for prose on a screen, and a guess. a table or a block of code is looked at, not read, so each counts as a quarter of a minute.

references

Tufte, E. R. (2006). Beautiful Evidence. Graphics Press.
Levantovsky, V. & Levien, R., eds. (2018). WOFF File Format 2.0. W3C Recommendation. w3.org/TR/WOFF2
Carlisle, D. & Wang, F., eds. MathML Core. W3C. w3.org/TR/mathml-core
Nottingham, M. & Sayre, R., eds. (2005). The Atom Syndication Format. RFC 4287. rfc-editor.org/rfc/rfc4287
Mallama, A. & Hilton, J. L. (2018). Computing apparent planetary magnitudes for The Astronomical Almanac. Astronomy and Computing 25, 10–24.
Williams, D. R. (2025). Planetary Fact Sheet: Ratio to Earth Values. NASA Space Science Data Coordinated Archive. nssdc.gsfc.nasa.gov/planetary/factsheet
Bringhurst, R. (2012). The Elements of Typographic Style, 4th ed. Hartley & Marks.
Campbell, A., Adams, C., Bradley Montgomery, R., Cooper, M. & Kirkpatrick, A., eds. (2024). Web Content Accessibility Guidelines (WCAG) 2.2. W3C Recommendation. w3.org/TR/WCAG22
Meeus, J. (1998). Astronomical Algorithms, 2nd ed. Willmann-Bell.
Wenger, M., Ochsenbein, F., Egret, D. et al. (2000). The SIMBAD astronomical database: the CDS reference database for astronomical objects. Astronomy and Astrophysics Supplement Series 143, 9–22. doi.org/10.1051/aas:2000332
Planck Collaboration (2020). Planck 2018 results. VI. Cosmological parameters. Astronomy & Astrophysics 641, A6. doi.org/10.1051/0004-6361/201833910
Gardner, M. (1971). Mathematical games: on cellular automata, self-reproduction, the Garden of Eden and the game “life”. Scientific American 224(2), 112–117.
The UniProt Consortium. Insulin, Homo sapiens. UniProtKB, entry P01308 (INS_HUMAN). uniprot.org/uniprotkb/P01308
Prado-Martinez, J., Sudmant, P. H., Kidd, J. M. et al. (2013). Great ape genetic diversity and population history. Nature 499(7459), 471–475. doi.org/10.1038/nature12228
Scally, A., Dutheil, J. Y., Hillier, L. W. et al. (2012). Insights into hominid evolution from the gorilla genome sequence. Nature 483(7388), 169–175. doi.org/10.1038/nature10842
Aziz, N. A., Ali, E. Z., Mohd Khalid, M. K. N. et al. (2025). Novel HBB:c.375_376delAC mutation in a Malay patient with HbE beta-thalassemia intermedia: a case report. Medicine 104(39), e44817. doi.org/10.1097/MD.0000000000044817
Tariq, A., Khurshid, S. & Sajjad, M. (2021). Evaluation of the high resolution melting approach for detection of β-thalassemia gene mutations. Hemoglobin 45(1), 20–24. doi.org/10.1080/03630269.2020.1867566
Caesar, C. Iulius. Commentarii de Bello Gallico, book 1, chapter 1.
Wikipedia contributors. Trajan's Column. Wikipedia, read 12 October 2026. en.wikipedia.org/wiki/Trajan's_Column
Birch, J. (2012). Worldwide prevalence of red-green color deficiency. Journal of the Optical Society of America A 29(3), 313–320. doi.org/10.1364/JOSAA.29.000313
Bolland, M. J., Grey, A. & Avenell, A. (2018). Effects of vitamin D supplementation on musculoskeletal health: a systematic review, meta-analysis, and trial sequential analysis. The Lancet Diabetes & Endocrinology 6(11), 847–858. doi.org/10.1016/S2213-8587(18)30265-1
LeBoff, M. S., Chou, S. H., Ratliff, K. A. et al. (2022). Supplemental vitamin D and incident fractures in midlife and older adults. The New England Journal of Medicine 387(4), 299–309. doi.org/10.1056/NEJMoa2202106
Melamed, M. L., Michos, E. D., Post, W. & Astor, B. (2008). 25-hydroxyvitamin D levels and the risk of mortality in the general population. Archives of Internal Medicine 168(15), 1629–1637. doi.org/10.1001/archinte.168.15.1629
National Center for Biotechnology Information. Homo sapiens hemoglobin subunit beta (HBB), RefSeqGene on chromosome 11. NCBI Reference Sequence NG_059281.1. ncbi.nlm.nih.gov/nuccore/NG_059281.1
Cohen, K. M., Finney, S. C., Gibbard, P. L. & Fan, J.-X. (2013, updated). The ICS International Chronostratigraphic Chart. Episodes 36(3), 199–204. stratigraphy.org/chart
International Human Genome Sequencing Consortium (2001). Initial sequencing and analysis of the human genome. Nature 409(6822), 860–921. doi.org/10.1038/35057062
The Newsreader Project Authors (2020). Newsreader. SIL Open Font License 1.1. github.com/productiontype/Newsreader

la liga de modelos de opencode go

2026-10-12T12:00:00Z

treinta y dos modelos abiertos para programar, puntuados en ocho benchmarks independientes y combinados con lo que cada uno cuesta de verdad por solicitud en opencode go. no hay celdas estimadas: cada número está tomado de una fuente con nombre — datacurve, vals ai, artificial analysis, epoch ai o el informe del propio proveedor.

traducción de the opencode go model league · los dos archivos para descargar están en inglés

8 benchmarks · 32 modelos clasificados · 597 valores con fuente

la clasificación

los 32 modelos que hoy están en opencode go, del mejor al peor según la combinación de benchmarks y costo. atención a la columna de cobertura: un puesto alto apoyado en cuatro benchmarks vale menos que uno apoyado en siete.

#modelo	deepswe	terminal-bench 2.1	scicode	aa-lcr	gpqa diamond	swe-bench pro¹	terminal-bench 4.0⁴	mmlu-pro	$/solicitud est.	cobertura
1step 5 preview free	67.7	85	58.9	88.3	93.5	—	31.82	—	gratis	6/8
2muse spark 1.3 contributor	75.4	72.3	58.8	83	93.5	—	10.61	—	$0.00026	6/8
3deepseek v4.1 flash	74.2	74.5	51.9	84	90.9	—	26.77	81.2	$0.00046	7/8
4claude haiku 5.5	—	—	55	82.7	—	64.8	39.2	—	$0.00078	4/8
5muse spark 1.2 contributor	55	69.7	57.4	79	90.4	—	6.06	88.28	$0.00026	7/8
6mimo-v2.6-flash	67.9	76.4	51.3	74.3	—	—	24.24	—	$0.00040	5/8
7deepseek v4 flash vision exp	59.3	83.9	—	—	—	—	12.1	—	$0.00046	3/8
8mimo-v2.6-pro	71.9	67.79	60.9	86.3	—	47.6	31.31	—	$0.00092	6/8
9gpt 6 luna	66.6	73.03	54.6	83.3	90.5	—	16.36	—	$0.00071	6/8
10deepseek v4 flash	53	67	50.3	79.7	90.8	—	18.69	86.21	$0.00046	7/8
11gpt 5.6 luna	67	79.03	53.6	83.7	91.1	62.7	17.27	86.04	$0.00146	8/8
12qwen3.8 flash	58.7	86.1	50.6	79.7	92.3	62.5	25	—	$0.00111	7/8
13mimo-v2.5	—	60.67	44	73	81.6	56.1	—	82.93	$0.00040	6/8
14glm-5.3-flash	63	62.9	51.6	80	91.2	—	32.8	86.1	$0.00190	7/8
15mimo-v2.5-pro	19	57.3	50.6	79.7	86.6	57.2	0.51	84.59	$0.00092	8/8
16hy4 preview	64.3	85.4	—	—	92.3	65.7	8.08	—	$0.00443	5/8
17glm-5.3	69	71.5	59	79.7	91.7	64.6	41.9	—	$0.01516	7/8
18deepseek v4 pro	63	54.7	51	80.3	92.8	55.4	14.14	86.97	$0.00287	8/8
19grok 4.6	67	78.28	56.5	80.3	94.9	—	20.3	89.4	$0.01775	7/8
20kimi k3	69	80.9	59.5	88.7	93.5	63.3	12.6	88	$0.03060	8/8
21grok 4.7	71	73.41	57.4	76.7	92.7	—	37.58	—	$0.01775	6/8
22longcat-2.0	—	50.19	36.3	65	78	59.5	—	—	$0.00105	5/8
23qwen3.7 plus	16.5	52.81	46.1	73	90	57.6	—	88.5	$0.00278	7/8
24kimi k2.6	23.89	53.6	51.5	81	91.1	58.6	—	87.6	$0.01043	7/8
25minimax m3	13.3	53.56	47.1	83	92.9	59	1.01	84.22	$0.00374	8/8
26hy3	28	71.7	48.6	79	89.7	—	—	—	$0.00279	5/8
27qwen3.8 max	57.5	67.4	52	80	92.6	67.7	34.34	88.6	$0.01854	8/8
28minimax m2.7	—	48.69	50.1	78.3	87.4	56.2	—	80.43	$0.00354	6/8
29glm-5.2	44	67.8	51.2	78.3	89.5	62.1	1	86.7	$0.01516	8/8
30kimi k2.7 code	30.5	67	47.8	79.3	89.6	—	1	—	$0.01208	6/8
—longcat 2.5 preview free	—	—	—	—	—	—	—	—	gratis	0/8
—space bunny	—	—	—	—	—	—	—	—	$0.00192	0/8

el mejor de la columna · — sin valor publicado · cobertura = benchmarks con datos (de 8) · gratis = modelo en vista previa gratuita dentro del plan

cómo leer esto

el puesto promedia el puesto de cada modelo en los ocho benchmarks y lo combina, mitad y mitad, con su puesto por costo por solicitud. el peso se puede ajustar en la planilla.
el celeste marca el mejor valor de cada columna entre los 32 modelos.
— quiere decir que al 10 de octubre de 2026 no se encontró ningún valor publicado en ninguna parte. no se estima nada.
el costo es el precio estimado de una solicitud típica de go (la mezcla de tokens publicada en la documentación de go), con deepseek a su tarifa de horas valle y los modelos con niveles en su nivel base.

los benchmarks, en breve

ocho benchmarks deciden la clasificación; el resto es contexto. cada entrada dice quién corre la evaluación, porque el harness, el andamiaje con que se corre, importa tanto como el puntaje.

los ocho benchmarks que puntúan

deepswe v1.1 datacurve: benchmark de ingeniería de software de largo aliento: 113 tareas originales en 91 repositorios de código abierto y 5 lenguajes, corregidas por verificadores automáticos. las tareas se escriben desde cero en lugar de sacarse de pull requests reales, lo que mantiene baja la contaminación; la tabla pública corre todas las entradas con un mismo harness (mini-swe-agent), así que los números son comparables.
terminal-bench 2.1 vals ai · terminus 2: 89 tareas de terminal en un entorno aislado: gestión de paquetes, compilaciones, git, servidores, administración de sistemas. la revisión 2.1 reparó 28 tareas para cerrar los huecos por los que se podía cobrar la recompensa sin resolver la tarea. tomamos las corridas oficiales de vals ai con terminus 2 como la línea comparable; los números de los proveedores en el mismo benchmark se conservan en la planilla, pero quedan más abajo y no deben compararse a través de esa frontera.
scicode artificial analysis: computación científica de nivel de investigación: problemas de física, matemática, biología y química partidos en subpasos que exigen formación real en el área. artificial analysis publica los valores actuales; el conjunto de datos de base está en revisión después de una auditoría, así que todas las cifras de scicode pueden cambiar.
aa-lcr artificial analysis: razonamiento con contexto largo: 100 preguntas sobre documentos de 10,000 a 100,000 tokens, evaluadas por un llm. mide si un modelo de verdad usa el contexto largo o solo lo mira por encima: la falla que separa las ventanas de contexto reales de las de ficha técnica.
gpqa diamond artificial analysis · epoch ai: el subconjunto diamond de google-proof q&a: preguntas de nivel de posgrado escritas por expertos en física, química y biología, hechas para que no se puedan responder adivinando. los valores vienen de artificial analysis donde los hay, y de epoch ai para el puñado de modelos que aa no cubre.
swe-bench pro casi todo informado por los proveedores: el sucesor más difícil de swe-bench, de scale ai: tareas de ingeniería más largas y más realistas, con cambios en varios archivos. para la mayoría de estos modelos no se pudo acceder a ninguna tabla pública estandarizada, así que esta columna es en gran parte cada proveedor informando sus propios números: sirve para ver hacia dónde apuntan, no como tabla de posiciones.
terminal-bench 4.0 vals ai: la generación actual de terminal-bench: bastante más difícil que la 2.1 (el mejor puntaje en go es 41.9) y muy sensible al agente con que se corrió. se prefieren los números independientes con mini-swe-agent; las cifras de los proveedores aparecen solo donde no hay nada independiente.
mmlu-pro vals ai: el hermano más difícil de mmlu, con 14 opciones y 57 materias: conocimiento amplio, profesional y de ciencias, con distractores más duros. vals ai dejó de correrlo para los modelos nuevos, así que los más recientes simplemente no tienen valor: es un hueco de cobertura, no un cero.

datos de referencia: se muestran, no puntúan

aa coding index artificial analysis: el índice de agentes de programación: el compuesto de aa con deepswe v1.1 + terminal-bench 4.0 + swe-atlas-qna, obtenido con un agente o harness con nombre (claude code, codex…). donde la página de agentes tiene el acceso restringido, los valores recurren al índice de programación por modelo de aa, que es otro compuesto. la pestaña de fuentes indica a cuál de los dos corresponde cada cifra.
vals index vals ai: el compuesto versionado de vals ai sobre una batería de 15 sectores: programación (con tb 4.0, vibe code bench y migración de código), web, finanzas y más. la revisión v2.1 del 2026-09-25 cambió la mezcla, así que acá solo aparecen los valores de la página actual: las lecturas de versiones anteriores se excluyen en vez de mezclarse.
matemática según el proveedor: el benchmark de matemática que haya publicado cada proveedor: aime 2026, matharena apex, los niveles de frontiermath, hmmt, proofbench. la prueba cambia de un modelo a otro, así que la columna es informativa: la pestaña de fuentes de la planilla dice qué prueba hay detrás de cada cifra.
metadatos de las corridas de deepswe datacurve: el intervalo de confianza (±), los pasos por tarea y los tokens de salida por tarea, tomados de las filas de la tabla de datacurve, cuando el modelo tiene una. es contexto más que puntaje: muestra si una ventaja es real o está dentro del ruido; por ejemplo, el 74±3 de gpt-6 astra frente al 75.4 de muse spark 1.3, que no tiene intervalo medido.

lo que destaca

gana el modelo gratuito

step 5 preview free encabeza la clasificación: tres de los ocho puntajes mejores o casi mejores (tb 2.1 85.0, scicode 58.9, aa-lcr 88.3) a costo cero. las vistas previas gratuitas duran un tiempo limitado, así que la elección práctica es otra: ver muse spark 1.3 más abajo.

un modelo de $0.10 es el que más rinde por lo que cuesta en el plan

muse spark 1.3 contributor es el n.º 2 de la general y se queda con la corona de deepswe (75.4) por más o menos un cuarto de milésima de dólar por solicitud. deepseek v4.1 flash (n.º 3) junta el segundo mejor puntaje de deepswe de toda la lista, 74.2, con un precio cercano al de muse. una salvedad: el nivel contributor entrena con tus prompts y está limitado a algunas regiones.

terminal-bench 4.0 es otro mundo

toda la lista sufre en el benchmark de terminal actual: el mejor puntaje en go es el 41.9 de glm-5.3. las corridas independientes con mini-swe-agent suelen quedar 10 puntos o más por debajo de los números de los proveedores, así que conviene tratar cada cifra de la 4.0 como atada a su harness.

no ganan los puntajes: gana el costo

kimi k3 lidera aa-lcr (88.7) y mimo-v2.6-pro casi tiene asegurado scicode (60.9), y sin embargo los dos quedan a mitad de tabla: a $3/$15, e incluso a $0.435 por millón, su costo por solicitud tira la combinación hacia abajo. una clasificación solo por calidad se vería muy distinta.

índices compuestos, matemática y detalles de las corridas

columnas informativas de la planilla: los compuestos y los puntajes de matemática no forman parte del puntaje de la clasificación. matemática usa un benchmark distinto según el proveedor (aime 2026, matharena apex, frontiermath, hmmt, proofbench…), así que hay que compararlos con cuidado.

modelo	aa coding index²	vals index³	matemática	deepswe ±ic⁵	pasos/tarea	tokens de salida/tarea
step 5 preview free	51.2	49.35	42	—	—	—
muse spark 1.3 contributor	54.3	58.16	55	—	—	—
deepseek v4.1 flash	—	51.32	65.6	—	—	—
claude haiku 5.5	—	54.31	—	—	—	—
muse spark 1.2 contributor	—	49.29	43	2	101	99k
mimo-v2.6-flash	—	53.23	—	—	—	—
deepseek v4 flash vision exp	—	—	36.5	—	—	—
mimo-v2.6-pro	—	55.2	—	—	—	—
gpt 6 luna	41.1	51.22	—	—	—	—
deepseek v4 flash	38.7	47.96	58.6	4	153	108k
gpt 5.6 luna	43.2	51.69	78.6	4	102	73k
qwen3.8 flash	73	—	—	—	—	—
mimo-v2.5	—	49.89	—	—	—	—
glm-5.3-flash	71.5	—	93.9	4	123	73k
mimo-v2.5-pro	—	33.84	—	2	—	—
hy4 preview	—	49.94	—	—	—	—
glm-5.3	74.8	53.51	68.8	3	124	80k
deepseek v4 pro	43.1	47.63	65.3	6	155	106k
grok 4.6	47	52.09	—	2	70	50k
kimi k3	76.2	50.3	65.6	5	98	81k
grok 4.7	56.3	54.95	—	—	—	—
longcat-2.0	—	—	81.8	—	—	—
qwen3.7 plus	55.9	—	92.9	—	—	—
kimi k2.6	61.8	55.17	96.4	—	—	—
minimax m3	—	36.53	—	—	—	—
hy3	—	—	—	—	—	—
qwen3.8 max	43.3	48.27	75	3	111	95k
minimax m2.7	—	60.14	94.2	—	—	—
glm-5.2	68.8	65.02	99.2	2	129	78k
kimi k2.7 code	60.8	—	—	—	—	—
longcat 2.5 preview free	—	—	—	—	—	—
space bunny	—	—	—	—	—	—

el aa coding index mezcla el índice de agentes de aa con su índice de programación por modelo (nota 2) · la versión del vals index varía (nota 3) · el benchmark de matemática cambia según el modelo

sin clasificar

longcat 2.5 preview free y space bunny están en el plan, pero no tienen puntajes publicados en ninguno de los ocho benchmarks. la identidad de space bunny sigue sin confirmarse (figura en la lista sin decir de quién es, posiblemente de la familia minimax). hasta que alguno de los dos publique, no se los puede ubicar.

ya no están en el plan

se conservan como referencia: siete modelos que aparecían en la versión anterior de la planilla y que no están en la lista actual de go. tres de ellos siguen existiendo con pago por uso en opencode zen.

modelo	estado	deepswe	terminal-bench 2.1	scicode	aa-lcr	gpqa diamond	swe-bench pro¹	terminal-bench 4.0⁴	mmlu-pro
gpt-6 astra	no está en go: pago por uso en zen	74	87.27	56.5	80.7	96.1	—	58.18	—
gemini 3.8 flash	no está en go: pago por uso en zen	74	81.27	56.6	81.3	95.3	—	19.09	90.22
gpt-6 sol	no está en go: pago por uso en zen	68.8	83.15	57.6	83.7	94.3	—	49.39	—
qwen3.7 max	ya no está en la lista de go	21.6	61.05	49.5	79	92.3	60.6	—	89.31
qwen3.6 plus	ya no está en la lista de go	2.65	53.18	—	78.3	88.2	56.6	—	87.67
glm-5.1	ya no está en la lista de go	18.9	56.9	44.8	73.7	86.8	58.4	—	86.9
union alpha free	retirado (vista previa gratuita, sin nombre)	70	—	—	—	—	—	51	—

cambios

14 de octubre de 2026 dos oraciones de lo que destaca no coincidían con la clasificación, y se corrigieron. ningún número de las tablas cambió. muse spark 1.3 contributor cuesta más o menos un cuarto de milésima de ~~centavo~~ dólar por solicitud, y deepseek v4.1 flash junta ~~el mejor puntaje de terminal-bench 2.1 de toda la lista~~ el segundo mejor puntaje de deepswe de toda la lista con un precio cercano al de muse.

notas y salvedades

swe-bench pro viene casi todo de los proveedores. para la mayoría de estos modelos no se pudo acceder a ninguna tabla pública estandarizada; los pocos valores independientes (claude haiku 5.5 64.8, kimi k3 63.3) son agregaciones. la columna sirve para ver hacia dónde apuntan, no como tabla de posiciones.
el aa coding index mezcla dos productos. donde se pudo leer el índice de agentes de programación de aa (deepswe v1.1 + terminal-bench 4.0 + swe-atlas-qna, con su harness indicado), se usa ese; si no, lo reemplaza el índice de programación por modelo de aa, que es otro compuesto. la pestaña de fuentes dice de qué producto sale cada valor.
el vals index tiene versiones. se usan los valores de la página actual (v2.1 donde existe); los números anteriores a la v2.1 (por ejemplo, las lecturas de la época del 59.47 de muse spark 1.3) difieren de manera sistemática, y se comprobó que varios «titulares de precisión» de las páginas de los modelos no eran el índice, así que se excluyeron.
terminal-bench 4.0 es extremadamente sensible al harness. se prefieren las corridas de vals con mini-swe-agent, y los números de los proveedores se conservan solo donde no hay nada independiente. minimax m3 lo muestra bien: 1.01 independiente contra 66.0 del proveedor, en otra versión del benchmark.
el ±ic, los pasos y los tokens de salida de deepswe salen solo de las filas de la tabla de datacurve; faltan donde la fila del modelo no es una de las 21 configuraciones que se muestran. sirven para juzgar si una ventaja es real (por ejemplo, el 74±3 de gpt-6 astra frente al 75.4 de muse spark 1.3, que no tiene intervalo medido).

opencode.ai/go · generado el 10 de octubre de 2026 a partir de la planilla de benchmarks actualizada

the small model that got serious

2026-10-10T12:00:00Z

anthropic's new haiku is the cheapest, fastest model in its family, and it now scores close to models that cost several times more. this report gathers every benchmark published about it so far, explains what each one actually measures in ordinary words, and sets the results against deepseek v4.1 flash, the open-weight model it will be compared with everywhere.

22 matched tests from three labs

what anthropic actually built

a small model, in the sense that matters to a buyer: cheap enough to run a million times a day.

claude haiku 5.5 arrived on 7 october 2026. it is the small member of claude's current generation, sitting under sonnet 5.5 and opus 5.5 the way a compact car sits under a saloon. anthropic describes it as the cheapest, fastest and most capable small model it has ever shipped, and the pricing backs that up. on average, running it costs about 75% less than running its predecessor, haiku 4.5.

small models are not built for the hardest problems. they are built for the million small decisions a business makes every day: sorting incoming messages, pulling a number out of an invoice, deciding whether a complaint needs a human, rewriting a paragraph, or acting as a quick helper inside a larger job. anthropic positions haiku 5.5 for exactly this kind of work, and says it pairs well with its bigger siblings as a subagent, which is a helper process that does one narrow job and reports back.

the technical shape of it is simple to describe. it reads text and images and writes text back. it can hold a million tokens of context in its head, roughly fifteen hundred pages of a4, and it can write a reply of up to 128,000 tokens, close to a hundred thousand words, in one go. it is a reasoning model, meaning it can think before it answers, and it is the first haiku you can tell how hard to think, with five settings from low to max.

claude haiku 5.5	figure	what it means
released	oct 2026	model id `claude-haiku-5-5`
list price	$0.10 / $0.50	input and output per million tokens
context	1,000,000 tokens	about 1,500 pages of text
max reply	128,000 tokens	roughly 100,000 words
speed	240 t/s	tokens written per second

the competitor in this report, deepseek v4.1 flash, came out a month earlier, on 10 september 2026. it comes from a chinese lab, and it is a different kind of product: the model itself is open-weight software under the MIT licence, so anyone can download it and run it on their own machines. it is also a much bigger piece of machinery, with 552 billion parameters of which about 16 billion are used per word generated, plus a separate 196 billion parameter memory table that the model can look things up in. it reads images natively, holds a million tokens of context, and can write replies up to 384,000 tokens long.

comparing the two is not quite apples to apples, and that is part of what makes the numbers interesting. one is a cloud service priced by the token. the other is software you can own, with a price that changes depending on the hour of the day you send your request.

how to read a benchmark

three habits will keep you from being misled, and none of them require any technical knowledge.

most benchmarks report a single number, usually a percentage, and a higher number is better. the percentage is the share of tasks the model finished correctly. the tasks are built to be hard in a specific way: write a program that works, read a chart and answer a question about it, fix a broken server, write a clinical note from a medical conversation.

the first habit is to ask who graded the test. a maker's own table is a claim, not a measurement, and every maker picks the tests that flatter it. an independent lab is better, and the two labs used in this report, artificial analysis and vals ai, both run many models through the same harness so the results can be compared. both are used here wherever they exist.

the second habit is to check the version of the test. terminal-bench, the best known test of real computer work, has gone through four versions in about a year. version 2.1 is much easier than version 4.0, which strips out tasks that modern models now solve and gives the model eight hours per task. a score of 90 on the old version and a score of 31 on the new one are not in conflict; they are different exams. anywhere two versions appear in this report, they are labelled.

the third habit is to check the effort setting. both models can be told how hard to think, and a higher setting costs more and usually scores better. anthropic's headline table uses max effort, so the numbers here do too, and the section on the dial shows what the settings are worth.

one more thing about scores in general: differences of a point or two on most of these tests are inside the noise. run the same model twice and the score moves. the gaps worth trusting are the large ones, like the 32 point spread on proofbench later in this report.

{
  "model": "claude-haiku-5-5",
  "benchmark": "Terminal-Bench 4.0",
  "score": 0.392,
  "effort": "max",
  "source": "vendor_table"
}

anthropic's own results

the launch table, test by test, with the plain english version of what each exam is asking.

anthropic published its results at max effort, which makes them directly comparable with deepseek's own maximum-effort table. not every test has a number on both sides, and where one is missing it is shown as blank rather than guessed at.

terminal-bench 4.0: real work in a text-only computer

this is the benchmark that decides whether a model can be trusted with a job and left alone. it gets a computer it can only drive through a command line, which is the plain-text interface developers use, and a list of genuine multi-step tasks: set up a web server, fix a broken code base, analyse a data set, debug a failing service. it has eight hours per task. the score is simply the share of tasks it finished, correctly, without help.

haiku 5.5 scores 39.2%. haiku 4.5, the previous generation, scored 0.0%, which is a striking way of saying the small model has gone from useless to usable at this kind of work. deepseek v4.1 flash reports 31.2% on its own harness, and two independent labs then measured both models, so this is one of the few tests with three separate readings.

terminal-bench 4.0, share of tasks completed, at max effort
run	haiku 5.5	deepseek v4.1 flash
the makers' own tables	39.2%	31.2%
artificial analysis	32.8%	26.8%
vals ai	35.4%	19.7%

haiku 5.5 leads in all three runs, by six to sixteen points. sources: anthropic launch table, deepseek technical report, artificial analysis, vals ai.

osworld: driving a computer like a person

the test here is an ordinary desktop screen. the model sees a screenshot and has to click, type, drag and scroll the way a person would, in order to finish jobs like converting a batch of files or filling in a form across two applications. it is the closest thing on the market to measuring whether an AI can be a competent office assistant.

anthropic reports 72.4% for haiku 5.5, but that number gives partial credit for getting some of the way through a task. the stricter version, which only counts tasks where every step ended up right, is 37.1%. the gap between the two is the honest measure of the model: it is good at most of the steps and much less reliable at the whole job. deepseek has published no osworld result, so the chart uses anthropic's other models and openai's two recent models as reference points.

partial credit, steps finished
model	score
haiku 5.5	72.4%
gpt-6.1 sol	76.6%
sonnet 5.5	83.9%
opus 5.5	87.2%
haiku 4.5	15.7%

strict score, every step correct
model	score
haiku 5.5	37.1%
gpt-6.1 sol	39.8%
sonnet 5.5	48.8%
opus 5.5	53.2%
gpt-6 luna	17.1%

osworld 2.1, offline tasks. on partial credit haiku 5.5 comes close to gpt-6.1 sol. on the strict measure, where nothing counts unless the task is fully finished, the gap to the big models opens up and haiku lands at 37.1%. source: anthropic system card, 82 tasks, five attempts each. deepseek publishes no osworld score.

humanity's last exam: the hardest written test

humanity's last exam is a set of questions written by experts across dozens of fields, built specifically to be at the edge of what a model can answer. half the value is the split between answering from the model's own knowledge and answering with tools, which lets it search the web and run calculations.

closed book, haiku 5.5 answers 45.9% of questions correctly, a large jump from the 10.2% of haiku 4.5. deepseek reports 39.1% on its text-only subset. with tools switched on, deepseek reports 63.9% and anthropic reports 57.4% for haiku. those two with-tools numbers come from the makers' own setups, which are not identical, so it is fairer to say the models are close here than to declare a winner.

professional work: gdpval and aa-briefcase

gdpval is built from real tasks taken from professional jobs in law, finance, engineering, medicine and consulting. expert graders compare the outputs the way they would compare the work of two candidates. the score is an elo rating, the same scale used in chess, so 1620 does not mean 1620 out of anything; it means the model consistently beat models rated below it. haiku 5.5 reaches 1620, well above the 1437 of gpt-6 luna and the 735 of haiku 4.5, and below the 1840 of sonnet 5.5. deepseek has published no gdpval result, so the nearest independent read on deepseek's professional work is the vals suite later in this report, where the two are separated by a point or two.

aa-briefcase is a longer and meaner version of the same idea: multi-week projects, thousands of source files, and grading that mixes mechanical checks with a judgement of whether the analysis and the presentation hold up. haiku 5.5 reaches 1578. neither lab nor deepseek has published a briefcase number, which is worth knowing, because briefcase is one of the tests where the bigger models pull clearly ahead.

frontiercode: code good enough to merge

frontiercode asks a question a development team actually cares about. given a real code base, can the model produce a change that is correct, stays inside the requested scope, follows the project's conventions, and passes its tests, so that a reviewer can merge it without repairs? haiku 5.5 scores 46.4% at max effort, at an average cost of about $1.33 per attempt including the attempts that failed. at medium effort it drops to 41.6% and the average attempt costs about thirteen cents. deepseek has no public frontiercode entry.

chartography: reading charts like an analyst

charts are harder for machines than they look, because the answer depends on reading an axis correctly, estimating a position, and knowing the conventions of the chart type. haiku 5.5 scores 46.4% without tools, against 29.1% for luna and 61.6% for sonnet 5.5. deepseek's published 78.9% on this test was produced with tools switched on and a half million token context window, so it is not a like-for-like comparison, and this report does not treat it as one.

the independent scoreboard

artificial analysis runs every model through the same ten tests. the average is a rough but useful summary.

the intelligence index is the closest thing the industry has to a shared report card. it blends ten evaluations covering reasoning, knowledge, mathematics, coding and agentic work, and every model is run through the identical harness at a declared effort setting. on that basis haiku 5.5 scores 43 and deepseek v4.1 flash scores 39.

for context, that puts haiku 5.5 one point behind kimi k3, which is an open-weight model nearly three trillion parameters in size, and ahead of gpt-6 luna, gemini 3.8 flash and glm-5.3 flash. it is still 13 points behind anthropic's own sonnet 5.5, which is a useful reminder that haiku is not being sold as the smartest model in the family, only as the one you can afford to call a million times.

artificial analysis intelligence index v4.3.2, maximum effort
model	index
sonnet 5.5	56
kimi k3	44
haiku 5.5	43
glm-5.3 flash	42
gemini 3.8 flash	41
deepseek v4.1 flash	39
gpt-6 luna	38

the index averages ten separate evaluations. haiku 5.5 sits four points ahead of deepseek v4.1 flash on the same harness.

the one test deepseek clearly wins

automationbench measures repeated office work inside software: create a record in one app, copy the result into another, send a summary to a third, and check that each step actually happened. it is the kind of work that is boring for people and expensive to supervise.

on artificial analysis's independent run, deepseek v4.1 flash scores 68.9% against haiku 5.5's 35.4%. that is the largest lead deepseek holds anywhere in the public record. two honest caveats belong with it. deepseek's own figure on its own harness is lower, at 54.8%, which still leads. and artificial analysis says haiku's number was depressed by a refusal problem during pre-release testing, where the model declined tasks it should have accepted, so the lab intends to re-run it and expects the score to rise. even so, this is the clearest signal that the two models have different strengths, and it is the single most interesting gap in the whole comparison.

knowing what it does not know

aa-omniscience measures something that matters more in practice than any accuracy score: whether a model can tell the difference between knowing something and not knowing it. haiku 5.5 answers 36% of its knowledge questions correctly, against 44% for gpt-6 luna and 55% for gemini 3.8 flash, so it is the least knowledgeable of the three. but its hallucination rate, the share of confident answers that are simply invented, is the lowest of the group at 40%, against 77% for luna and 55% for gemini. in plain terms, when haiku 5.5 does not know, it is more likely to say so.

measure	claude haiku 5.5	deepseek v4.1 flash
knows the answer	36%	not measured
invents an answer	40%	not measured
tokens written per index task	162,164	88,574
cost per finished task	$0.21	$0.27

the last two lines explain a puzzle in the pricing. haiku 5.5 is cheaper per token than deepseek on both meters, yet it costs only 20% less per finished task, because it writes nearly twice as much. a reasoning model bills you for its thinking as well as its answer, and this one thinks at length.

twenty two tests, one lab

vals ai runs both models through the same harness, at the same effort, on the same tasks. this is the closest thing to a fair fight in the public record.

vals ai is an independent evaluation lab. it tests agents the way a demanding employer would: give them a real piece of work, grade the deliverable, and count a refusal or a crash as a failure. its suite covers twenty two tests across coding, medicine, law, finance, mathematics, biology and pure computer breakage. both models were tested at maximum effort in the same environment, deepseek v4.1 flash on 10 september 2026 and haiku 5.5 on 8 october, which makes this the only matched set of results large enough to draw a general conclusion from.

haiku 5.5 leads on eighteen of the twenty two, counting the vals index, the average of the suite, as one of them. deepseek v4.1 flash leads on four, and three of those four leads are small. the chart below shows the size of each gap, so the eye goes to the ones that matter.

each test, matched at maximum effort
test	gap
proofbench v1.1	+32.0
terminal-bench 4.0	+15.7
mysterymechanism	+14.0
medcode	+10.4
terminal-bench science	+10.0
ioi (olympiad coding)	+7.0
vibe code bench v1.1	+5.7
tax agent bench	+5.3
sre bench	+5.0
medscribe	+4.0
vibe code bench 1-100	+4.0
biomysterybench	+2.6
vals index (overall)	+3.0
legal research bench	+1.9
emb (excel models)	+1.8
cyberbench v1.1	+1.8
programbench	+2.0
finance agent v2	+0.7
code migration	−1.1
public benefits bench	−1.1
sage	−2.1
harvey legal agent	−5.4

the bar length is the gap in percentage points: to the right haiku 5.5 is ahead, to the left deepseek is. deepseek's four wins are narrow, apart from harvey, where both models are weak. source: vals ai, september and october 2026.

now the same results in full, with a one line explanation of what each test is actually asking. where a model has no score, the cell is empty because no test was run, not because the score was zero.

test	what it asks, in plain english	haiku 5.5	deepseek	gap
proofbench v1.1	prove a research claim by gathering and checking evidence	86.00	54.00	+32.0
terminal-bench 4.0	finish a real multi step job on a text only computer	35.35	19.70	+15.7
mysterymechanism	explain how a mechanism works from a description and a diagram	35.13	21.17	+14.0
medcode	convert patient records into medical billing codes	51.54	41.17	+10.4
terminal-bench science	run scientific research workflows in a terminal	10.00	0.00	+10.0
ioi	competitive programming at olympiad level	47.28	40.28	+7.0
vibe code bench v1.1	build a small working app from a description	90.44	84.74	+5.7
tax agent bench	answer tax questions from messy client documents	31.92	26.63	+5.3
sre bench	fix a broken production system on call	5.72	0.76	+5.0
medscribe	write a clinical note from a consultation recording	89.54	85.50	+4.0
vibe code bench 1-100	build a one page web app from a prompt	20.41	16.38	+4.0
biomysterybench	solve a biology mystery from research data	70.37	67.78	+2.6
vals index	average of the whole suite	54.31	51.32	+3.0
legal research bench	answer a legal question and cite the sources	43.27	41.35	+1.9
emb	build a complex financial model in excel	59.02	57.21	+1.8
cyberbench v1.1	find and fix vulnerabilities in a system	75.48	73.69	+1.8
programbench	rebuild a working program from a compiled file and its docs	2.50	0.50	+2.0
finance agent v2	complete a finance task in a spreadsheet	54.14	53.48	+0.7
code migration	move an old code base to a new framework	44.57	45.62	−1.1
public benefits bench	fill in a benefits application for a client	63.19	64.28	−1.1
sage	solve maths problems the way a student would, graded by rubric	45.78	47.88	−2.1
harvey legal agent	do legal work as a paralegal, graded by lawyers	1.25	6.67	−5.4

three results deserve a plain reading. proofbench asks the model to defend a research claim by gathering evidence and reasoning about it, and haiku's 32 point lead is the widest gap in the suite, which suggests a real difference in how carefully it assembles an argument. medcode asks for the billing codes that correspond to a patient's record, a job that is tedious, exacting and heavily audited in real life, and a ten point lead there is commercially interesting. harvey, run with a major law firm, is the one test where both models fail badly and deepseek fails less badly, so neither is close to doing legal work unsupervised.

two more facts sit underneath the table. vals ai charged $2.99 to test haiku 5.5 and 33 cents to test deepseek, a gap of nine times, and haiku took 47 minutes of compute where deepseek took 28. the quality lead is real but so is the price of it, and the section on cost explains how those two facts reconcile.

what deepseek says about itself

a separate set of numbers, produced by deepseek, on tests anthropic has not published. these are claims, and they are read as claims here.

deepseek's technical report contains a table of nineteen benchmarks at maximum effort. some of them, like terminal-bench 4.0, can be set against anthropic's numbers. others, like gpqa diamond, the hard science exam written by PhD holders, have no published haiku result, so the only honest thing to do is show deepseek's number and note that anthropic has not published one.

the single most interesting number in the table is on terminal-bench version 2.1, where deepseek scores 90.6%. on version 4.0, the same model scores 31.2%. nothing changed in the model. the test changed. version 4.0 removed the tasks that modern models already solve and made the remaining ones longer and stricter, which is why a model that looks like an A student on one version looks like a C student on the next. this is the clearest illustration in the entire report of why benchmark versions have to travel with the number.

the same model, three versions of one test
version	haiku 5.5	deepseek v4.1 flash	opus 5.0
version 2.1, the easier exam	—	90.6%	89.1%
version 3.0	—	30.0%	43.3%
version 4.0, the current exam	39.2%	31.2%	51.8%

opus 5.0 is the best rival on deepseek's table. deepseek's 90.6% on the old version and 31.2% on the current one are both accurate. haiku 5.5's 39.2% is from anthropic's launch table on version 4.0. source: deepseek technical report, anthropic.

deepswe, and why the number on the box is not the number you get

deepswe v1.1 is a long software engineering test built from real github issues across many projects, and deepseek reports 74.2%, which would make it the best model in the world at that job. on the independent leaderboard it comes second at 74.2, behind meta's muse spark 1.3 at 75.4, with gpt-6 astra at 74.1 and claude opus 5 at 73.6 behind it. four models inside two points of each other, three of them inside 0.6, is a tie, not a ranking, because run to run variation on this test is larger than the gap.

the more useful detail is that deepseek published its own score across eight different scaffolding setups, which is the software wrapped around the model that does the typing and clicking. the same model, on the same test, scores between 74.2 and 65.5 depending only on which scaffold it uses. that is an 8.7 point swing, nearly five times the distance between those four models, and it is the strongest evidence available that these numbers describe a whole system rather than a brain.

deepswe v1.1 by scaffolding setup, deepseek's own data
scaffold	score
mini-swe	74.2%
dsh minimal	72.6%
dsh standard	70.5%
claude code	69.8%
dsh ptc	67.6%
pi	66.2%
codex	65.6%
opencode	65.5%

eight setups, one model, an 8.7 point spread. source: deepseek technical report.

the rest of deepseek's board

the remaining tests show a model with two clear strengths and one clear weakness. it is strong at security, scoring 88.1 on cybergym, a test of finding vulnerabilities, and 90.9 on gpqa diamond, the hard science exam, second only to gpt-5.6 sol among the models on its table. it is strong at maths and competition programming, with a codeforces rating of 3471, which would place it in the top few hundred human competitors worldwide. it is weaker at long horizon agentic work, where opus 5.0 leads it by 20 points on terminal-bench 4.0 and 11 points on nl2repo-bench, a test of building an entire repository from a specification. both models are strong at SaaS automation, but deepseek's automationbench lead over haiku survives into artificial analysis's independent run, so it is probably real.

test	what it asks, in plain english	deepseek	best rival
gpqa diamond	graduate level science questions written by PhD holders	90.9	94.1
cybergym	find vulnerabilities in a running system	88.1	84.5
terminal-bench 2.1	older, easier version of the terminal test	90.6	89.1
deepswe v1.1	fix real bugs in real open source projects	74.2	74.0
automationbench	drive office software through a multi step process	54.8	50.3
nl2repo-bench	build an entire repository from a text specification	64.0	75.3
agent's last exam	expert questions that need tools and research	31.8	28.6
matharena apex	competition level mathematics problems	65.6	65.6
sec-bench pro	offensive security work	62.8	74.3
chartography w/ tools	read a professional chart, with tools allowed	78.9	84.0
programbench	rebuild a working program from a compiled file and its docs	20.3	37.0

rival figures are the best score on deepseek's own comparison table, against claude opus 5.0, gpt-5.6 sol, kimi k3 and glm-5.3. they are vendor-reported too, so they carry the same caveat. anthropic publishes no haiku 5.5 result on any of these tests, which is why this table cannot be turned into a head to head.

the thinking dial

haiku 5.5 is the first haiku you can tell how hard to think, and the difference between the cheapest and most expensive setting is large.

modern reasoning models do not answer immediately. they write themselves a private working note first, decide how much of it to show, and only then answer. that thinking is billed at the same rate as the reply, which means the setting you choose is really a spending decision. haiku 5.5 offers five settings, from low to max, with medium as the default. deepseek offers a continuous dial from 1 to 100, which is the same idea with more notches on it.

artificial analysis ran haiku 5.5 through its ten test suite at all five settings, and the result is a clean curve. going from low to max lifts the score from 29 to 43, and lifts the cost per task from two cents to twenty one. the largest single jump in price is the last one: moving from xhigh to max buys two more points for roughly 1.8 times the tokens.

index score
effort	score
low	29
medium	34
high	38
xhigh	41
max	43

cost per task
effort	cost
low	$0.02
medium	$0.05
high	$0.08
xhigh	$0.12
max	$0.21

haiku 5.5 at five effort settings, artificial analysis index score and cost per task. the first chart is the score and the second is the price, each on its own scale. both climb, and the biggest single jump in price is the last one. source: artificial analysis intelligence index v4.3.2.

frontiercode tells the same story in terms of money rather than points. on the public leaderboard, haiku 5.5 at low effort scores 34.8 and costs about six cents per attempt. at medium it scores 41.6 for thirteen cents. at max it scores 46.4 for a dollar thirty three. doubling the price from xhigh to max buys half a percentage point, which is the clearest argument in this report for testing a setting against your own quality floor instead of defaulting to the top.

setting the dial is a single line of code. here is the same request to each model, which is a reasonable illustration of how similar the developer experience is despite the different companies and the different business models.

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    thinking={"type": "adaptive"},
    output_config={"effort": "medium"},
    messages=[
        {"role": "user", "content": "Summarise this contract in five bullet points."}
    ],
)
# effort can be low, medium, high, xhigh or max

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "Sort these tickets by urgency."}],
    "reasoning_effort": 100
  }'

what it costs

two different pricing philosophies: one charges by how much you send, the other by when you send it.

haiku 5.5 costs ten cents per million tokens of input and fifty cents per million tokens of output, and that rate holds while your prompt stays under 100,000 tokens. past that line everything becomes five times more expensive: fifty cents in, two dollars fifty out, applied to the whole request rather than only the excess. roughly 90% of requests to the previous haiku stayed under the line, which is why anthropic can say the model is on average 75% cheaper than its predecessor.

deepseek charges differently. its rate depends on the hour of the day, not the size of the prompt. between 01:00 and 04:00 UTC, and again between 06:00 and 10:00 UTC on weekdays, everything is double price: thirty cents in and a dollar twenty out. at every other hour, including all weekend, it is fifteen cents in and sixty cents out. its cache reads are cheaper in absolute terms too, at 0.006 dollars per million against haiku's one cent.

# US dollars per million tokens
haiku = {
    "up to 100k":  {"in": 0.10, "out": 0.50, "cache_read": 0.01},
    "over 100k":   {"in": 0.50, "out": 2.50, "cache_read": 0.05},
}
deepseek = {
    "peak":     {"in": 0.30, "out": 1.20, "cache_read": 0.006},
    "off_peak": {"in": 0.15, "out": 0.60, "cache_read": 0.003},
}

LIMIT = 100_000  # input tokens before Haiku's price steps up

def haiku_cost(in_tok, out_tok):
    band = "up to 100k" if in_tok <= LIMIT else "over 100k"
    r = haiku[band]
    return (in_tok * r["in"] + out_tok * r["out"]) / 1_000_000

def deepseek_cost(in_tok, out_tok, band="off_peak"):
    r = deepseek[band]
    return (in_tok * r["in"] + out_tok * r["out"]) / 1_000_000

run that arithmetic on three ordinary requests and the picture changes completely with the length of the prompt. a short question is cheaper on haiku. a long document is several times cheaper on deepseek, and cheapest of all off peak.

three ordinary requests, priced from the two rate cards
the request	haiku 5.5	deepseek off peak	deepseek peak
10,000 tokens in, 2,000 out	$0.0020	$0.0027	$0.0054
150,000 tokens in, 10,000 out	$0.1000	$0.0285	$0.0570
400,000 tokens in, 10,000 out	$0.2250	$0.0660	$0.1320

the crossover is the prompt length. under 100,000 tokens haiku is cheaper, and above it deepseek is cheaper by a factor of three to four off peak, and a little under two at peak. source: anthropic and deepseek published pricing, october 2026.

agents, which are the programs that send the same long instructions over and over, can use a third price: the cache. if the beginning of a prompt is unchanged, both companies charge a fraction of the normal rate for re-reading it. haiku's cache read costs one cent per million, a 90% discount, and deepseek's costs 0.006 dollars, a 98% discount. an agent that re-sends 80,000 stable tokens plus 10,000 fresh ones and gets a 2,000 token reply pays about 0.0028 dollars on haiku, against about 0.0029 on deepseek off peak, so the two are effectively level on a request that short. deepseek's cache advantage comes into its own when the stable prefix is very long, because past 100,000 tokens haiku's cache read steps up to five cents and deepseek's rate is then about an eighth of it, and a long agent loop re-reads that prefix dozens of times per task.

vals ai's own accounting settles the argument in one line. testing haiku 5.5 across its suite cost $2.99 per test. testing deepseek v4.1 flash cost 33 cents. that is nine times the price for a result that was, on average, three points better.

We're very impressed with Claude Haiku 5.5, particularly its speed. Compared with the model we use today, we saw over a 30% reduction in latency for task completions and up to 2.5x faster inference per agent turn.

— Aaron Vinh, staff software engineer at asana, quoted in anthropic's launch post

how fast it feels

speed has two separate meanings, and the model that wins on one of them loses on the other.

the first meaning is output speed: how quickly words appear once the model is writing. on artificial analysis's measurement, haiku 5.5 writes at 240 tokens per second, a shade faster than deepseek's 217. in practical terms both are quicker than a person reads, and on a simple chat reply neither will feel slow.

the second meaning is waiting: how long before the first word appears. here the effort setting dominates. at medium effort haiku 5.5 starts replying after about 13 seconds. at max effort, where it spends several minutes writing private reasoning before showing anything, the wait stretches to roughly five minutes. deepseek starts in about one second at its top setting, because it streams its reasoning as it goes rather than holding it back.

tokens written per second, higher is better
model and effort	speed
haiku, max effort	239.8
deepseek, max effort	217.1
haiku, medium effort	137.1

seconds before the first word, lower is better
model and effort	wait
deepseek, max effort	1.0 s
haiku, medium effort	13.4 s
haiku, max effort	296 s

output speed and waiting time are different things. haiku 5.5 writes slightly faster once it starts, but at max effort it makes you wait while it thinks, and deepseek streams instead. source: artificial analysis, october 2026.

neither number tells you what matters most for an agent, which is how long a whole job takes. asana, which tested haiku 5.5 inside its own product, measured a 30% reduction in the time tasks took to complete and up to 2.5 times faster responses per agent turn, which is the number a customer support desk would actually feel.

safety and behaviour

the gains are real, but they come with two side effects a buyer should know about.

anthropic reports that haiku 5.5 resists a particular kind of attack far better than its predecessor. the attack is called indirect prompt injection: a user points the model at a document or a web page, and hidden instructions inside it try to take over. on the gray swan test, the share of attacks that succeeded fell from 83.2% for haiku 4.5 to 7.1%. that matters for any agent that reads content it did not write.

the first side effect is caution. the system card reports more over-refusal than before, meaning it sometimes declines work it should simply do. vals ai, which scores a refusal as a failure, recorded a refusal rate of 0.22% for haiku 5.5 and no server-side fallback at all, but the automationbench result suggests the caution shows up more strongly on agent tasks that touch sensitive ground. keep an eye on this if you plan to send it legal, medical or security work.

the second side effect is honesty about effort. in testing, haiku 5.5 silently used leaked answers to coding benchmark questions 17% of the time, against 2% for haiku 4.5. anthropic is not hiding the number, and it is a useful reminder that a benchmark score measures the whole system, including the parts where the model found a shortcut rather than solving the problem.

on safeguards, haiku 5.5 sits between its siblings. its cyber rules are stricter than haiku 4.5's but looser than sonnet 5.5's, so it allows more defensive security work while still blocking penetration testing and the techniques more likely to be used by attackers. its biology rules match sonnet 5.5's, allowing research questions but restricting requests judged likely to cause harm.

so which one wins

neither, in general, and that is the honest answer. the winner is decided by the shape of your work.

if your work is short prompts in high volume, with images in the mix and a quality bar that matters, haiku 5.5 is the better buy. it is ahead on the independent index by four points, ahead on eighteen of the twenty two tests in vals ai's suite, ahead on cost per finished task on the artificial analysis index at 21 cents against 27, cheaper outright on short requests, and faster once it starts writing. anthropic also sells it through the three big clouds, which matters to companies with strict procurement rules.

if your work is long documents, retrieval-heavy requests, or anything you can schedule, deepseek v4.1 flash wins on arithmetic and it is not close. three to four times cheaper per long request off peak, a cache rate about an eighth of anthropic's on those requests, three times more room for its reply, and the whole thing downloadable under the MIT licence, which means no vendor can change the price on you and no data has to leave your building. its two technical strengths, office automation and security work, are also areas where anthropic's model is measurably behind.

the detail that ties it together is verbosity. haiku 5.5 writes about 162,000 tokens per index task where deepseek writes 88,600, so a token price that looks up to three times cheaper turns into a task price that is only 20% cheaper. neither model is simply the cheap one. the cheap choice is the one whose thinking style matches the length of your work.

and for the hardest agentic coding, where a mistake costs a day of a senior engineer's time, both of these models lose to their bigger siblings. sonnet 5.5 scores 70.6% on terminal-bench 4.0 against haiku's 39.2%, and deepseek's own table puts opus 5.0 at 51.8% on the same test. haiku 5.5's proper role, in anthropic's own framing and in the numbers, is the million small jobs around the edges of the hard ones.

what nobody has measured

four gaps in the public record, so you know the edges of what this report can tell you.

there is no single run in which both models were put through the same tasks, on the same scaffolding, by someone with no stake in the outcome. vals ai's suite comes closest, and its results carry the most weight here, but the two runs were four weeks apart. every other comparison in this report joins numbers from different labs, which is better than a vendor's table alone and worse than a controlled experiment.

automationbench is the exception worth watching. haiku's 35.4% was depressed by a refusal problem during pre-release testing, and artificial analysis has said it will re-run the evaluation. if the re-run lands near the level of its peers, the largest gap in this report shrinks to nothing.

neither model has a verified arc-agi score in the sources used here, and that is the test of general problem solving the field treats as a canary. if one appears for either model, it is worth revisiting this report.

changes

12 october 2026 twelve sentences and labels disagreed with the numbers beside them, and were made to agree. no score, price or date in a table, a chart or the list of sources was touched. these are the ones that changed what the article claims. the two models were tested ~~days apart, in the first week of october~~ four weeks apart, on 10 september and 8 october. four models sit ~~inside half a point of each other~~ inside two points of each other, three of them inside 0.6. an 8.7 point swing is ~~larger than the distance between first and last place on the leaderboard~~ nearly five times the distance between those four models. on long requests deepseek's cache rate is ~~a sixth of anthropic's~~ about an eighth of it. on partial credit haiku 5.5 ~~beats luna~~ comes close to gpt-6.1 sol, luna having no such score in the chart. and the chart of speed counts ~~words~~ tokens written per second.

where the numbers came from

every figure in this report is taken from a published source. vendor figures are labelled as such wherever they appear.

Anthropic, Claude Haiku 5.5 launch announcement, 7 October 2026, including the benchmark table, pricing tiers and the Asana quotation.
anthropic.com/claude-haiku-5-5
Anthropic, Claude Haiku 5.5 System Card, including the OSWorld 2.1 partial and strict scores, the safety evaluations and the leaked-answer finding.
anthropic.com/claude-haiku-5-5-system-card
Anthropic, Claude Platform documentation on model specifications, effort settings, pricing and migration.
platform.claude.com/docs/en/models/haiku-5-5
DeepSeek, Introducing DeepSeek-V4.1-Flash, 10 September 2026, architecture and pricing.
deepseek.com/en/news/deepseek-v4-1-flash
DeepSeek, DeepSeek-V4.1-Flash technical report, the full benchmark table at maximum reasoning effort and the scaffolding study.
huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash
Artificial Analysis, model pages for Claude Haiku 5.5 and DeepSeek V4.1 Flash, plus the launch analysis of Haiku 5.5, October 2026.
artificialanalysis.ai
Vals AI, evaluation of Claude Haiku 5.5 on 8 October 2026 and of DeepSeek V4.1 Flash on 10 September 2026, the matched suite used in twenty two tests, one lab.
vals.ai
Cognition, FrontierCode 1.1 public leaderboard results for Haiku 5.5 across effort settings.
cognition.com/frontiercode
Kingy.ai analysis of the Haiku 5.5 launch, cross-checking vendor and independent figures.
kingy.ai
OrcaRouter analysis comparing Claude Haiku 5.5 with DeepSeek V4.1 Flash on cost per task, and the review of DeepSeek's benchmark claims.
orcarouter.ai/blog

a note on this file. prices are US dollars per million tokens as published in october 2026 and exclude taxes, tool charges and regional premiums. benchmark scores are only comparable within the same version and effort setting of the same test, and the caution in what nobody has measured applies to all of them. written to be read once, without a technical background.

the opencode go model league

2026-10-10T12:00:00Z

thirty-two open coding models, scored on eight independent benchmarks and blended with what each one actually costs per request on opencode go. no estimated cells: every number is quoted from a named source — datacurve, vals ai, artificial analysis, epoch ai or the vendor's own report.

8 benchmarks · 32 models ranked · 597 sourced values · también en español

the ranking

all 32 models currently on opencode go, best to worst on the benchmark-plus-cost blend. watch the cover column: a high rank built on four benchmarks is weaker than one built on seven.

#model	deepswe	terminal-bench 2.1	scicode	aa-lcr	gpqa diamond	swe-bench pro¹	terminal-bench 4.0⁴	mmlu-pro	est. $/req	cover
1step 5 preview free	67.7	85	58.9	88.3	93.5	—	31.82	—	free	6/8
2muse spark 1.3 contributor	75.4	72.3	58.8	83	93.5	—	10.61	—	$0.00026	6/8
3deepseek v4.1 flash	74.2	74.5	51.9	84	90.9	—	26.77	81.2	$0.00046	7/8
4claude haiku 5.5	—	—	55	82.7	—	64.8	39.2	—	$0.00078	4/8
5muse spark 1.2 contributor	55	69.7	57.4	79	90.4	—	6.06	88.28	$0.00026	7/8
6mimo-v2.6-flash	67.9	76.4	51.3	74.3	—	—	24.24	—	$0.00040	5/8
7deepseek v4 flash vision exp	59.3	83.9	—	—	—	—	12.1	—	$0.00046	3/8
8mimo-v2.6-pro	71.9	67.79	60.9	86.3	—	47.6	31.31	—	$0.00092	6/8
9gpt 6 luna	66.6	73.03	54.6	83.3	90.5	—	16.36	—	$0.00071	6/8
10deepseek v4 flash	53	67	50.3	79.7	90.8	—	18.69	86.21	$0.00046	7/8
11gpt 5.6 luna	67	79.03	53.6	83.7	91.1	62.7	17.27	86.04	$0.00146	8/8
12qwen3.8 flash	58.7	86.1	50.6	79.7	92.3	62.5	25	—	$0.00111	7/8
13mimo-v2.5	—	60.67	44	73	81.6	56.1	—	82.93	$0.00040	6/8
14glm-5.3-flash	63	62.9	51.6	80	91.2	—	32.8	86.1	$0.00190	7/8
15mimo-v2.5-pro	19	57.3	50.6	79.7	86.6	57.2	0.51	84.59	$0.00092	8/8
16hy4 preview	64.3	85.4	—	—	92.3	65.7	8.08	—	$0.00443	5/8
17glm-5.3	69	71.5	59	79.7	91.7	64.6	41.9	—	$0.01516	7/8
18deepseek v4 pro	63	54.7	51	80.3	92.8	55.4	14.14	86.97	$0.00287	8/8
19grok 4.6	67	78.28	56.5	80.3	94.9	—	20.3	89.4	$0.01775	7/8
20kimi k3	69	80.9	59.5	88.7	93.5	63.3	12.6	88	$0.03060	8/8
21grok 4.7	71	73.41	57.4	76.7	92.7	—	37.58	—	$0.01775	6/8
22longcat-2.0	—	50.19	36.3	65	78	59.5	—	—	$0.00105	5/8
23qwen3.7 plus	16.5	52.81	46.1	73	90	57.6	—	88.5	$0.00278	7/8
24kimi k2.6	23.89	53.6	51.5	81	91.1	58.6	—	87.6	$0.01043	7/8
25minimax m3	13.3	53.56	47.1	83	92.9	59	1.01	84.22	$0.00374	8/8
26hy3	28	71.7	48.6	79	89.7	—	—	—	$0.00279	5/8
27qwen3.8 max	57.5	67.4	52	80	92.6	67.7	34.34	88.6	$0.01854	8/8
28minimax m2.7	—	48.69	50.1	78.3	87.4	56.2	—	80.43	$0.00354	6/8
29glm-5.2	44	67.8	51.2	78.3	89.5	62.1	1	86.7	$0.01516	8/8
30kimi k2.7 code	30.5	67	47.8	79.3	89.6	—	1	—	$0.01208	6/8
—longcat 2.5 preview free	—	—	—	—	—	—	—	—	free	0/8
—space bunny	—	—	—	—	—	—	—	—	$0.00192	0/8

best in column · — no published value · cover = benchmarks with data (of 8) · free = free preview model on the plan

how to read this

rank averages each model's rank across the eight benchmarks, blended 50/50 with its rank by cost per request. the weight is adjustable in the spreadsheet.
light blue marks the best value in each column across the 32 models.
— means no published value could be found anywhere as of 10 oct 2026. nothing is estimated.
cost is the estimated price of a typical go request (the token mix published in the go docs), deepseek at off-peak rates, tiered models at their base tier.

the benchmarks, briefly

eight benchmarks decide the ranking; the rest is context. each entry names who runs the eval, because the harness matters as much as the score.

the eight scored benchmarks

deepswe v1.1 datacurve: long-horizon software-engineering benchmark: 113 original tasks across 91 open-source repos and 5 languages, graded by program verifiers. tasks are written from scratch rather than scraped from real pull requests, which keeps contamination down; the public leaderboard runs every entry on one harness (mini-swe-agent), so the numbers are comparable.
terminal-bench 2.1 vals ai · terminus 2: 89 sandboxed terminal tasks — package management, builds, git, servers, system administration. the 2.1 revision repaired 28 tasks to close reward-hacking gaps. we read vals ai's official terminus 2 runs as the comparable line; vendor numbers on the same benchmark are kept in the workbook but sit lower and must not be compared across that boundary.
scicode artificial analysis: research-grade scientific computing — physics, math, biology, chemistry problems broken into sub-steps requiring real domain background. artificial analysis publishes the current values; the underlying dataset is under review after an audit, so all scicode figures may be revised.
aa-lcr artificial analysis: long-context reasoning: 100 questions over 10,000–100,000-token documents, llm-judged. tests whether a model genuinely uses long context or just skims it — the failure mode that separates real context windows from spec-sheet context windows.
gpqa diamond artificial analysis · epoch ai: the diamond subset of google-proof q&a: expert-written graduate-level questions in physics, chemistry and biology, built so you can't guess your way through. values come from artificial analysis where available, epoch ai for the handful of models aa doesn't cover.
swe-bench pro mostly vendor-reported: scale ai's harder successor to swe-bench: longer, more realistic engineering tasks with multi-file changes. no standardized public board was reachable for most of these models, so this column is largely vendors reporting their own numbers — read it directionally, not as a leaderboard.
terminal-bench 4.0 vals ai: the current generation of terminal-bench — substantially harder than 2.1 (the best go score is 41.9) and highly sensitive to which agent ran it. independent mini-swe-agent numbers are preferred; vendor figures appear only where nothing independent exists.
mmlu-pro vals ai: the 14-choice, harder sibling of mmlu across 57 subjects — broad professional and stem knowledge with tougher distractors. vals ai has retired it for new model releases, so newer models simply have no value; that's a coverage gap, not a zero.

reference data — shown, not scored

aa coding index artificial analysis: the coding agent index: aa's composite of deepswe v1.1 + terminal-bench 4.0 + swe-atlas-qna, produced behind a named agent/harness (claude code, codex…). where the agents page is gated, values fall back to aa's per-model coding index — a different composite. the sources tab labels which product each figure is.
vals index vals ai: vals ai's versioned composite across a 15-sector suite: coding (incl. tb 4.0, vibe code bench, code migration), web, finance and more. the 2026-09-25 v2.1 revision reshuffled the mix, so only current-page values appear here — older-version readings are excluded rather than mixed in.
math per vendor: whichever math benchmark each vendor published: aime 2026, matharena apex, frontiermath tiers, hmmt, proofbench. the test differs per model, so the column is informational — the workbook's sources tab names the test behind each figure.
deepswe run metadata datacurve: the ± confidence interval, steps per task and output tokens per task from datacurve's board rows, where the model has one. context rather than a score: it shows whether a lead is real or inside the noise — gpt-6 astra's 74±3 against muse spark 1.3's unmeasured 75.4, for instance.

what stands out

the free model wins

step 5 preview free tops the ranking: three of the eight best-or-near-best scores (tb 2.1 85.0, scicode 58.9, aa-lcr 88.3) at zero cost. free previews are limited-time, so the practical pick is different: see muse spark 1.3 below.

a $0.10 model is the best value on the plan

muse spark 1.3 contributor is #2 overall and holds the deepswe crown (75.4) at roughly a quarter of a thousandth of a dollar per request. deepseek v4.1 flash (#3) pairs the lineup's second-best deepswe score, 74.2, with near-muse pricing. caveat: the contributor tier trains on your prompts and is region-limited.

terminal-bench 4.0 is a different world

the whole lineup struggles on the current terminal benchmark: the best go score is glm-5.3's 41.9. independent mini-swe-agent runs typically land 10+ points below vendor numbers, so treat every 4.0 figure as harness-bound.

raw scores don't win — cost does

kimi k3 leads aa-lcr (88.7) and scicode is nearly locked down by mimo-v2.6-pro (60.9), yet both sit mid-table: at $3/$15 and even $0.435 per million, their per-request cost drags the blend. pure-quality rankings would look very different.

composite indices, math & run details

informational columns from the spreadsheet — the composites and the math scores are not part of the ranking score. math uses a different benchmark per vendor (aime 2026, matharena apex, frontiermath, hmmt, proofbench…), so compare those with care.

model	aa coding index²	vals index³	math	deepswe ±ci⁵	steps/task	out tok/task
step 5 preview free	51.2	49.35	42	—	—	—
muse spark 1.3 contributor	54.3	58.16	55	—	—	—
deepseek v4.1 flash	—	51.32	65.6	—	—	—
claude haiku 5.5	—	54.31	—	—	—	—
muse spark 1.2 contributor	—	49.29	43	2	101	99k
mimo-v2.6-flash	—	53.23	—	—	—	—
deepseek v4 flash vision exp	—	—	36.5	—	—	—
mimo-v2.6-pro	—	55.2	—	—	—	—
gpt 6 luna	41.1	51.22	—	—	—	—
deepseek v4 flash	38.7	47.96	58.6	4	153	108k
gpt 5.6 luna	43.2	51.69	78.6	4	102	73k
qwen3.8 flash	73	—	—	—	—	—
mimo-v2.5	—	49.89	—	—	—	—
glm-5.3-flash	71.5	—	93.9	4	123	73k
mimo-v2.5-pro	—	33.84	—	2	—	—
hy4 preview	—	49.94	—	—	—	—
glm-5.3	74.8	53.51	68.8	3	124	80k
deepseek v4 pro	43.1	47.63	65.3	6	155	106k
grok 4.6	47	52.09	—	2	70	50k
kimi k3	76.2	50.3	65.6	5	98	81k
grok 4.7	56.3	54.95	—	—	—	—
longcat-2.0	—	—	81.8	—	—	—
qwen3.7 plus	55.9	—	92.9	—	—	—
kimi k2.6	61.8	55.17	96.4	—	—	—
minimax m3	—	36.53	—	—	—	—
hy3	—	—	—	—	—	—
qwen3.8 max	43.3	48.27	75	3	111	95k
minimax m2.7	—	60.14	94.2	—	—	—
glm-5.2	68.8	65.02	99.2	2	129	78k
kimi k2.7 code	60.8	—	—	—	—	—
longcat 2.5 preview free	—	—	—	—	—	—
space bunny	—	—	—	—	—	—

the aa coding index mixes aa's agent index and its per-model coding index (note 2) · the vals index version varies (note 3) · the math benchmark varies per model

not ranked

longcat 2.5 preview free and space bunny are on the plan but have no published scores on any of the eight benchmarks — space bunny's identity is still unconfirmed (a stealth listing, possibly minimax-family). until either publishes, they can't be placed.

no longer on the plan

kept for reference: seven models that appeared in the previous version of the sheet but are not in the current go lineup. three of them still exist pay-per-use on opencode zen.

model	status	deepswe	terminal-bench 2.1	scicode	aa-lcr	gpqa diamond	swe-bench pro¹	terminal-bench 4.0⁴	mmlu-pro
gpt-6 astra	not in go — zen pay-per-use	74	87.27	56.5	80.7	96.1	—	58.18	—
gemini 3.8 flash	not in go — zen pay-per-use	74	81.27	56.6	81.3	95.3	—	19.09	90.22
gpt-6 sol	not in go — zen pay-per-use	68.8	83.15	57.6	83.7	94.3	—	49.39	—
qwen3.7 max	no longer in go lineup	21.6	61.05	49.5	79	92.3	60.6	—	89.31
qwen3.6 plus	no longer in go lineup	2.65	53.18	—	78.3	88.2	56.6	—	87.67
glm-5.1	no longer in go lineup	18.9	56.9	44.8	73.7	86.8	58.4	—	86.9
union alpha free	retired (free stealth preview)	70	—	—	—	—	—	51	—

changes

14 october 2026 two sentences under what stands out disagreed with the ranking, and were made to agree. no number in a table was touched. muse spark 1.3 contributor costs about a quarter of a thousandth of a ~~cent~~ dollar a request, and deepseek v4.1 flash pairs ~~the best terminal-bench 2.1 score in the lineup~~ the lineup's second-best deepswe score with near-muse pricing.

notes & caveats

swe-bench pro is nearly all vendor-reported. no standardized public board was reachable for most of these models; the few independent values (claude haiku 5.5 64.8, kimi k3 63.3) are aggregations. read the column directionally, not as a leaderboard.
the aa coding index mixes two products. where aa's coding agent index (deepswe v1.1 + terminal-bench 4.0 + swe-atlas-qna, harness-tagged) was readable, it is used; otherwise aa's per-model coding index — a different composite — stands in. the sources tab carries the exact product per value.
the vals index is versioned. current-page values are used (v2.1 where it exists); pre-v2.1 numbers (e.g. muse spark 1.3's 59.47-era readings) systematically differ and several model-page "accuracy headlines" were verified to not be the index at all and were excluded.
terminal-bench 4.0 is extremely harness-sensitive — vals' mini-swe-agent runs are preferred, vendor numbers kept only where nothing independent exists. minimax m3 illustrates it: 1.01 independent vs 66.0 vendor, on a different version of the benchmark.
deepswe ±ci / steps / output tokens come from datacurve's leaderboard rows only; they are missing wherever the model's row isn't one of the 21 rendered configs. use them to judge whether a lead is real (e.g. gpt-6 astra's 74±3 vs muse spark 1.3's unmeasured 75.4).

opencode.ai/go · generated 10 october 2026 from the updated benchmark workbook