Seeing the Brain Grow: The Montage, the Mind in the Corners, and Every Screen of Orrery and Treadcore

Abstract

Treadcore is an MIT-licensed tank game whose computer players are trained by a fleet of ten ordinary computers and three graphics cards. A console named orrery runs that fleet, and a CUDA program named crucible evolves small neural networks on the graphics cards. Until today the learning could be read only as tables of numbers. This report documents the system's visual state on 4 November 2026 and the work of that day. We rebuilt the training montage, a film that follows the best champion of each generation through its duels. Every other duel of the same start now appears as a faded crowd moving with the camera, and the champion's network is drawn thinking in the film's corners: its 55 inputs, its two hidden layers of 48 with the strongest currents lit, an eight-second spectrogram of its decisions, and the generation. A title sequence borrows treadcore.org's brushed metal and phosphor. Every film is copied, with a chapter list ready for upload, to an output folder. The same animation now plays inside orrery, from a 0.55 MB file written beside the film, and a new page lists every finished film with its data, ready to post. We photographed every screen of orrery (30 pictures) and of the game (8 pictures), and we describe the redesigned flow by which a change to the brains becomes a promotion: a paired census, a trade guard, and since today a gauntlet guard of 22 single-decision tests. The recordings that once filled 114.5 GB on one machine are now debug material, kept only on request. The film of twelve generations is 99 s long, 4.2 MB, and took 233 s to make.

Index Terms: neuroevolution, neural network visualization, behaviour cloning, simulation-based testing, game AI, visual analytics, software architecture, immediate-mode graphical user interface.

To the reader: what to expect

This report is written for an application software architect who has not seen these programs before and wants to judge a working prototype: what it is for, how its parts fit, what it can show, and where its claims stop.

Expect three things. First, a map: three programs (the game, the console, the GPU trainer) and the flow of a decision through them, from an idea about how a tank should play to a commit that changes how it plays. Second, pictures: every screen as it was on the evening of 4 November, each with a caption that says what it is for. Third, evidence: every claim of improvement in this project is tied to a measurement with an error bar, and a change that did not meet its rule is reported as a failure, as two of today's did.

The side notes, numbered in red, explain an idea when it first appears: what a neural network is, why a census is paired, what a spectrogram shows. A reader who knows the idea can skip the note; a reader who does not should find enough there to follow the argument. Nothing in this report requires knowing Rust, CUDA, or machine learning in advance.

The impression we hope to leave is of a system that is small enough to understand, honest about what it has not shown, and built so that every picture is drawn from recorded data rather than from a guess.

I. Introduction: a game that teaches itself

Treadcore is an overhead tank game for up to sixteen players. Each tank carries a gun with two modes (a flat direct shot to ten tiles, and a lobbed mortar from twelve to sixty), a bay of drones (recon, interceptor, strike, longshot), and a squad of builders that capture pillboxes, mine ore and lay roads. Empty seats are filled by computer players, which the project calls bots or brains. The game is MIT licensed¹ and runs on Linux, macOS and Windows.

A brain decides, several times a second, where its tank drives, what it shoots at, and which drone it launches. There are two kinds. The rules are hand-written: a commander, a tactician and a doctrine, about fourteen thousand lines of Rust with some three hundred numbers, called dials, that tune them. The nets are small neural networks² that read the game as a list of numbers and answer with a choice.

The project's question is how to make these brains better without guessing. Its answer is a fleet: ten computers that play thousands of matches a day, each comparing a changed brain against today's on the same random seeds. A change is accepted only if it wins by more than two standard errors³. Three of the computers also hold graphics cards, where a second program evolves populations of neural networks by the million.

A system like this produces numbers faster than anyone can read them. The question this report answers is a visual one: can a person watch the brains learn? Since 4 November the answer is yes, in three places: a film, a page in the console, and this report.

II. The system at a glance

Three programs, each in its own repository, share the work. Figure 1 shows how a decision moves among them.

• treadcore, the game, in Rust. Its simulation is deterministic⁴: given the same seed and the same brains, a match plays the same way every time, which is what makes fair comparisons possible. It also holds the brains, the tests called gauntlets, and the census that measures a brain against another.
• orrery, the console, in Rust with no third-party libraries. It draws its own window, keeps a queue of jobs for the fleet, plans what to run next, and shows the results. Its planner, tools/plans/treadcore.py, decides each minute which machine plays what.
• crucible, the GPU trainer, in CUDA⁵. Each graphics card runs an island: a population of networks that duel each other in a small arena under the game's rules, the winners breeding the next generation. A champion judged better than every one before it becomes a milestone.

The design keeps one rule throughout: nothing changes how a brain plays until a measurement says it is not worse. The pictures in this report sit on top of that rule; none of them decides anything.

III. The brains, and their program flow redesigned

A. Two kinds of brain, and the styles between them

The rules are three layers. The commander picks a goal (hunt pillboxes, defend the base, escort a leader, fortify) and an errand within it. The tactician picks a target and decides whether to close, wait, or kite, by weighing distance, threat and the odds of the fight⁶. The doctrine fires the gun and launches the drones. Every number they use is a dial with a written range (RANGES), so the fleet can search them, and only Paul may fix one as a constant.

The nets read 160 numbers a decision: a compass of eight sectors with eleven channels each (enemy tanks, friends, pillboxes, depots, shells), the tank's body (armour, shells, reload), its instruments, a periscope of the nearest enemy and the nearest thing to take, the rules' hints, an incoming shell and a drone. They answer with a choice in each of seven heads: drive, gun, lead, mortar, drone, squad, signal. The game's own trainer finds their weights by evolution strategies with the Adam step rule [1], [21], or by imitation (Section III-D).

Between the two sit the styles: a roster of seventeen ways to play, each a set of dial values or a shipped net. Style 6, the Scholar, is a net that learned by imitating the rules. Style 7, the Duelist, and style 17, the Gladiator, read a champion from crucible's islands and drive with it, behind a gate⁷ that lets the champion steer only when it is confident.

B. How a change is judged

A census plays the same seeds twice: once with the trial brain in a seat and once with today's, every other seat unchanged. Each match is 900 game seconds on one of twelve maps, with sixteen seats in teams and three respawns. Each seat is scored by a ledger of what it did: kills, deaths, damage, pillboxes taken, ore delivered and, since today's section 139, what it built and kept standing. The census reports the trial's score minus the base's, a seat at a time, averaged over the seeds, with its standard error. Because both halves of a pair share their seed, the luck of the map cancels⁸.

The project writes down the rule that would confirm a change before running its census, and a result inside two standard errors is reported as inside the noise. A default that changes must also hold the families, nine scenario sets of up to a thousand runs each (a tank under a shell, a raid on a guarded base), each with a floor of its own.

C. The guards on a promotion, redesigned today

In auto mode orrery commits a winning candidate to the game by itself. Two guards now stand in front of that commit.

• The trade guard holds a candidate that wins by doing less of what the game needs: one whose team gives up more building, or more road, than a tenth of what the other teams build or lay is held even if it scores more. The tenth is a share of the other teams' own numbers, so it means the same on every map.
• The gauntlet guard (section 143, today) reads each candidate on all 22 gauntlets⁹ with its own dials, and holds it if any file falls under its floor. The promotion job reads the batch again just before it commits.

The floors themselves were reset today to today's success: each is the rules' share on 200 seeds less two standard errors of a hundred, rounded down to the twentieth, and never lowered. A generation that falls under one has stepped back; every generation above all of them is a step forward. Paul's words: "adjust the floors to be what we have now as success, so we can create generations from here forwards."

D. The GPU growth step

On each graphics card, crucible keeps a population of networks of 55 inputs, two hidden layers of 48 and 4 outputs¹⁰. Each generation, every network duels sparring partners and milestones in an arena with pillars and four neutral pillboxes, under the game's own numbers (reload, range, damage, speed); the best quarter breed the next generation, each child its parent plus a little gaussian noise. This is neuroevolution: no gradients, only selection [1], [2], [3].

A champion the ladder judges better than every one before it becomes a milestone; fifteen exist. Three things now follow a milestone automatically. The bridge reads it in the real game as the Gladiator, in a census against the one shipped, and ships it if it reads better. The montage films the milestones every five. And the clone stage records the rules, trains an imitation of them on the graphics card¹¹, and judges it by census and gauntlet before it can replace the Scholar. Its first round (clone −42.71 a seat against the Scholar's −39.93) did not ship.

E. Today's changes to the brains

Two of the nine did not do what was hoped, and the table says so. Section 145 also tried two designs before the one it kept: a duck from an evenly loaded gun (no effect, because a tank sees exactly as far as a gun reaches, ten tiles, so a gun is first seen inside its own reach) and holding the mortar while kiting (worse, because the mortar's splash hits counted for a third of what the rules gave). Section 146 found that the nets' failure on G18 was one of experience, not of eyes: a net that has imitated the rules where G18's choice comes up passes it every time without the new sense.

IV. Recordings: from storage hog to debug and cleanup

To train a net by imitation, the fleet records the rules playing: at each decision, the 160 senses and the seven choices, a few hundred bytes a sample, millions of samples a run¹². By the morning of 4 November one machine, calber, held 114.5 GB of them and another 18.9 GB. Nothing read most of them twice.

The redesign rests on determinism. A shard is a function of two things: the program that made it and the seeds it played. So orrery now keeps a recipe for each run (the program's build, its seeds, and the SHA-256 hash of every shard), proves the recipe by making one shard of each program again and comparing it byte for byte, and only then deletes the shards. Any shard can be made again, exactly, from its recipe. Recording itself happens only when a clone round needs it.

• Recordings are dropped by default once their recipe is proved; a run marked keep (or the global setting keep_recordings) stays for debugging.
• A sweep every six hours drops what is complete and unmarked.
• A reader opens one seed of one run, remaking its shard from the recipe if it was dropped, and follows each tank through it.
• Builds of the game are pruned when main moves, except those a recipe still needs.

The result: calber's fleet folder went from 114.5 GB to 6.5 GB, two recording runs worth 87.5 GB were dropped with proved recipes, and the first build prune freed another 45.3 GB. Section VI shows the Recordings page (Fig. 24).

V. The montage: a film of the generations

The montage answers a plain question: what does a better generation look like? It films each milestone's champion in the moments that decide a duel, and since today it shows what the champion's network was doing in those moments.

A. What a chapter is

Each chapter is one milestone. Its champion plays 64 duels in one arena from one start: the same pillars, the same four pillboxes, the same places for both tanks, drawn once from a seed. Only the opponent changes with the duel's number: half are sparring partners of five styles (a script, a Raider, a Castle, an Expander, a Timid tank), half are milestones spread along the ladder. Duel 17 is the same contest in every chapter, so the film compares like with like¹³.

The camera follows the duel the champion won best. It cuts each kill shot and each pillbox fight from one second before to half a second after, at three frames a step (a step is 0.1 s of game time, so the film runs at real speed). When the generation changes, a title holds the upper right for a quarter of a second. Between chapters, orrery's own pages tell the story: the flowchart of Fig. 15, the Growth page with the chapter's generation marked, and its facts in large type.

B. The crowd: every other duel, faded

Paul asked for "a crowd of tanks on the same map because the pill boxes don't move ... enemy ghost tanks ... a faded overlay with same camera movement to make it align." Because every duel shares the arena, all 64 can be drawn on one map at the same step. The followed duel is drawn solid; every other duel's champion (blue) and opponent (red) are drawn as faded tanks with a short track behind them¹⁴. They use the followed tank's camera, so the crowd moves with the shot. A duel that has already ended keeps its tanks where they stopped, fading out over three seconds. In the first film the crowd had mostly vanished by the time of a kill shot, because by then most duels were over; it no longer empties.

Two smaller changes came from looking at the film. The camera now frames the fight, aiming a third of the way from the champion toward a living foe within 16 tiles, and may look six tiles past a wall. Before that, a kill shot by the north wall put the champion under the caption and its foe under the generation.

C. The mind in the corners

The champion's network is drawn in three corners of every clip frame, and the generation in the fourth. Fig. 3 is a real frame; point at a corner, or tab to it, to read what it shows.

Point at a corner of the frame, or tab to it, to read what it shows.

How the corners are made. Crucible's trace (the file the film is cut from) gained a version 2 today: at every step of every duel it records the 55 numbers the champion's network read and the 4 it drove with. The two hidden layers are not stored. The film computes them again from the champion's own 5,236 weights, using crucible's own forward pass, layer by layer, with the same tanh¹⁵. Because that computation is exact, the corners show the network as it was, not an approximation.

The lines in the transform are the strongest currents of the step: for every connection, its weight times the activity of the unit it starts from, the part that unit contributed to the next one's sum. The 28 strongest from the first layer to the second and the 14 strongest from the second layer to the outputs are drawn, brighter for stronger. This is a simple form of attribution¹⁶: it shows which paths carried the decision, not why the weights are what they are.

Older champions are drawn too. The first milestones are of the old arena's smaller network; the film widens them into the new shape exactly as crucible does, every new weight zero, so their answers are unchanged and the units they never had stay black.

D. The decision spectrogram

Paul asked for "a history of decisions like a spectrogram of fire, from a bright square display." A spectrogram¹⁷ draws time across and channels down, with brightness for strength. Here the channels are the tank's turn, its speed, its fire, the network's own say (its gate output), and a row of shots. Eight seconds are shown, a column a step, the newest at the right. A glance shows when the champion committed to an attack (speed and fire lit together), when it handed the wheel back to the rules (the gate turns amber), and where its shells landed.

E. Play it here

Fig. 4 is the same animation, running in this page from the film's own data (three of its twelve chapters, 133 KB). Press Play, pick a chapter, or drag the step. Point at any square to name it: an input gets its meaning and value, a hidden unit lights its own currents in white.

F. The title sequence

The film opens on treadcore.org's own look (Fig. 5): the battlefield behind a dark veil and scanlines, a brushed-metal plate with four screws, the name etched into it, an eyebrow label above, a phosphor screen that types what the film holds, and the game's newswire along the foot. It is drawn with ImageMagick [19] from the site's own colours (site.css), 36 frames typed at ten a second and faded in, 3.6 s. A card follows that names the four corners on a real frame (Fig. 6).

G. Scripted, and placed in the output folder

The whole film is one command, or one press of Make montage on orrery's Montage page:

python3 tools/montage.py ~/code/treadcore/build/queue/grove make            # the generations since the last film
python3 tools/montage.py ~/code/treadcore/build/queue/grove make --since start  # the whole ladder again

It traces the chapters on whichever GPU island answers, renders every frame in plain Python, joins the pieces with FFmpeg [18], and writes three places: the archive (archive/montages/NNNN/: the film, its summary, its mind), orrery's Montage page, and the output folder, orrery/output/ (or ORRERY_OUTPUT), where treadcore-montage-NNNN.mp4 sits beside a .txt with a title, a description and a timestamp for every chapter, ready to paste into a video site. The trace and the frames are deleted when the film is made; git ignores the output folder.

Treadcore: crucible montage 3, generations 200 to 247,700

Champions of crucible's GPU islands, trained by neuroevolution under treadcore's rules, each playing 64 duels from one start. The camera follows the duel each won best; the faded tanks are the other duels at the same moment. In the corners, the champion's net thinking: its inputs, its two hidden layers with the strongest currents lit, its decisions over the last eight seconds, and the generation.

0:00 Title
0:03 How to read the film
0:09 The flowchart
0:19 Generation 200 (M0001)
0:25 Generation 235,800 (M0002)
0:30 Generation 236,600 (M0004)
0:36 Generation 162,500 (M0005)
0:42 Generation 237,000 (M0006)
0:49 Generation 85,900 (M0008)
0:55 Generation 238,100 (M0009)
1:03 Generation 238,700 (M0011)
1:09 Generation 239,000 (M0012)
1:15 Generation 239,200 (M0013)
1:21 Generation 241,300 (M0015)
1:27 Generation 247,700 (the newest)
1:33 Every chapter's duels

MIT licensed: https://treadcore.org  Made by orrery (tools/montage.py) on 2026-11-04.

Since the evening of 4 November the finished films have their own page in orrery, Results, Videos (Fig. 9): a list with data, not a player, as Paul asked ("its just a list with data, not a player"). Each film in the output folder is a row with when it was made, its length, its size, its chapters and the generations it covers; the one chosen shows its title, its description and its chapter marks, the lines to paste when it is posted to a video site, and where the file and its text are. Open plays it in the machine's own player and Show finds it in the file browser. The page never plays or moves a file itself, and offers only a plain file name to the command behind the buttons, since that command passes through a shell.

H. Inside orrery: the Mind player

The animation does not need the film. Each film now has a mind.json beside it, every step of every clip with its inputs, layers, outputs, shots and currents (0.55 MB). The Montage page draws the corners from it natively, in orrery's own renderer at its six frames a second, paced by the wall clock so a step still lasts 0.1 s (Fig. 10). It has Play mind, Pause and chapter buttons, and when paused it rests on the first step whose shell hit.

A recording of the game itself (Section IV) does not yet carry these overlays: the game's nets are a different network from crucible's, and the game's own window does not yet draw them. Section IX lists this as not built.

VI. A tour of orrery, every screen

Orrery is one window with seven tabs along the top (Machines, Projects, Queue, Results, Watch, Fleet, Settings), a list of pages down the left, and a line under the tabs, About this screen, that says what each page is for. It is written in Rust with no third-party libraries: it draws every pixel itself, letters included, and redraws the whole window six times a second¹⁸. Every picture here was drawn by orrery's own --frame renderer from the live queue at about 15:40 on 4 November, the same code that draws the window, so the pictures are the window. The steel frame is treadcore's brushed metal; the screens inside are its phosphor.

A. Machines, Projects and Queue: the fleet at work

B. Results: what the search found

Results is where the search reports. Its first line is the same on every page: the candidates found, how many are on today's defaults, the improvements so far, and whether auto mode is on. Its Videos and Montage pages are in Section V (Figs. 9 and 10).

C. Algorhythm: the brain as a patch, and six ways to look inside it

Algorhythm is a set of tabs for reading the brain as a whole: its dials and switches, and the shape of the search around it¹⁹.

D. Watch, Fleet, Storage and Settings

VII. A tour of treadcore, the game

The game's pictures were taken on a virtual machine running the game in a real window, software-rendered, from main at commit 0e10d4a (today's LR 145). The match is the window's default: the naval map, three teams, fifteen bots, three respawns. The player's tank is on autopilot, so the rules drive it; what the pictures show is the brain at work²³.

The game's window does not yet draw the mind of a net-driven tank. The rules, which drove every tank above, explain themselves in words on the coordination screen instead (Fig. 41), the counterpart of the film's corners for a hand-written brain.

VIII. Measurements

Two readings of Table III, both cautious. The generations are counted on each island separately, so they do not rise in ladder order. And the early hybrid champions win as often as the latest ones (M0001, of the old arena's net, wins 38 of 64) because a hybrid with its gate mostly shut plays the rules' script, which beats sparring partners; the film shows how a champion fights, while the ladder, which judges champions against each other, decides which is better.

IX. Limitations, and what is not built

• The game does not draw the mind. The corners exist in the film and in orrery for crucible's champions. The game's own nets (160 senses, seven heads) are a different network, and the game's window has no overlay for them yet. The Gladiator, which drives crucible's champion inside the game, is the natural first candidate.
• The game's recordings carry no overlays. Section IV's recordings are training data, not film. A recording that also carried a net's layers would be larger again; the film's own trace carries them and is deleted after use.
• The fade is pre-blended. Ghosts are mixed with the grass's colour, so where two overlap the nearer one wins instead of both darkening.
• The currents are first-order. Weight times activation shows where a decision flowed, not why; it ignores the tanh after each sum.
• Video-site chapters. The output's chapter list is correct, but most chapters are about six seconds long, and a video site that requires ten seconds a chapter will show the list as text rather than as chapters.
• The Gauntlet page lags the files. It shows the fleet's last gauntlet job (3 November, 17 files); today's five appear when the fleet runs the next one.
• The ring sense is parked. It is proved harmless and was not shown to help imitation; G19's result swings from 0 to 172 of 200 with the training run's random start alone, which is the next problem to solve.
• Committed. Everything in Section V is on the main lines: orrery d9892ba and 2b5ad05 (the Videos page), crucible e09089a (which has no remote), treadcore 5b2f7c7 (section 146). The ring sense itself is kept off main, in a stash.

X. Conclusion

A system that learns by measurement produces a great deal of evidence and very little to look at. Today it gained three ways to look. The film now shows what a generation does and what its network did while doing it: the crowd of its other duels, its inputs, its two hidden layers with their strongest currents, and its decisions in an eight-second spectrogram. Orrery plays the same animation without the film, and this page lets a reader point at any square and be told what it is. Following Tufte's advice to show the data and nothing that is not the data [7], every mark in the corners is a number from the trace or an exact recomputation from the champion's weights.

The pictures do not replace the measurements. The day's brain work shows why: of nine changes, two did not do what was hoped, and both were caught by a rule written before the run, not by a picture. What the pictures add is a way to see where to look next, and to show someone new, in a minute and a half, what the fleet has been doing.

Acknowledgment

The fleet's machines, the islands' graphics cards, and the virtual machine that ran the game's window did the work in this report. The game's look on the web, which the title sequence borrows, is treadcore.org's.

Appendix A. The 55 inputs of a world champion

What crucible's world network reads each step (sense() in src/crucible.cu), in the order the film's top-left corner draws them, eleven to a row. Rays turn with the tank: ray 0 points ahead, each next ray 30 degrees clockwise. A world champion already senses a pillbox's ring (inputs 49 to 52), which the game's own nets did not until section 146 tried it.

Appendix B. Making a film

# from orrery's checkout; QUEUE is the planner's queue folder
python3 tools/montage.py QUEUE make                 # the milestones since the last film
python3 tools/montage.py QUEUE make --since start   # the whole ladder
python3 tools/montage.py QUEUE make --chapters 8 --duels 32 --host calber
python3 tools/montage.py QUEUE status               # what it is doing now
ORRERY_OUTPUT=~/Movies python3 tools/montage.py QUEUE make   # put the finished film elsewhere

A film writes archive/montages/NNNN/ (montage.mp4, summary.json with the chapter marks, mind.json, the poster) and output/treadcore-montage-NNNN.mp4 with its .txt. The planner makes one by itself every five new milestones. On orrery's Montage page, Make montage does the same, Play opens the film in the machine's player, and Play mind animates its corners in place.