Technology · Shipping

Ten releases
in forty-seven days.
What the gaps measured.

Three of them went out on the same day. One was never meant for players. The longest gap of the ten changed less underneath than one of the shortest. Here are the real dates.

By Marcin Firmuga·2026-10-19·10 min read·Technology

Scaling Laws went public on 30 August 2026. By 16 October there had been ten releases. I did not plan a cadence and I did not announce one, which turns out to be the only reason the record is worth reading: nothing here was shaped to fit a schedule, so the intervals say something.

VersionDateGapChangelog linesSave format
0.1.030 Augfirst70
0.2.06 Sep+7 days747
0.3.013 Sep+7 days850v56
0.3.113 Sepsame day35
0.4.013 Sepsame day96
0.5.020 Sep+7 days551v57
0.6.028 Sep+8 days277v67
0.6.129 Sep+1 day85v71
0.6.21 Oct+2 days180
0.7.016 Oct+15 days745v72

Four shapes in there, and each one taught a different thing.

The four weeks that looked like a rhythm

30 August, 6 September, 13 September, 20 September. Four releases, seven days apart each time. If you had asked me on 20 September what my release cadence was, I would have said weekly and believed it.

It was not a cadence. It was four consecutive weeks in which the work happened to fit a week, and I had mistaken a coincidence for a commitment. The proof arrived the first time a piece of work was larger than seven days, and I will come back to it.

What the first one did get right was its own reason. The 0.1.0 entry says the build is deliberately unpolished, that the art is partial and several screens are plain, and that the point of shipping then was to find out whether the economy was interesting before any more time went into how it looked. That decision held up. Every correction in the nine releases after it came from somebody playing, and none of them would have arrived if I had spent September on the art.

The day three releases went out

13 September has three entries: 0.3.0, then 0.3.1, then 0.4.0.

0.3.0 is the largest changelog of the ten, 850 lines. 0.3.1 went out, in the changelog's own words, within an hour of it. Its opening line is the useful part:

A patch. Two faults found by the author within an hour of 0.3.0 going up, both of them only reachable by loading a save rather than starting a campaign.

That sentence is the whole lesson of the day, and it is not about speed. Both faults needed a loaded save. A new campaign could not reach either of them. Which means I had tested 0.3.0 along the path I had just been building, over and over, and had not once opened it the way a returning player does.

One of the two was properly bad. Loading a save put you in an office that was not there: a wall, some furniture, a bench, no floor and no desks. Nothing failed and nothing was logged, because the room removed itself. The sweep that dims the hand-placed objects in the starting house so they do not show through a rented floor runs once and caches its answer, and a loaded room stands in exactly the house's own space, so on first run with a room already loaded it collected that room as somebody else's furniture. 96 of the 115 pieces of the office were switched off, measured on the way to the fix.

The habit this cost me, and it is one line

A new campaign starts in the garage. Any fault that needs a populated save is invisible from there, and a solo developer starting a fresh campaign to test is doing the most convenient thing, not the most informative one.

Load a save before you ship. Not a test save: the oldest one you still have. That single habit would have deleted 0.3.1 from this table entirely, and it costs thirty seconds.

0.4.0, later the same day, is a different kind of entry. It made the server room fillable by hand, and the reason it had never worked is worth quoting because it is a shape that recurs: the floor emptied every cabinet and refilled it from scratch on every tick, so anything a player placed by hand was wiped a fraction of a second later. The feature was not missing. It was being undone faster than a person could see.

The release that was not for players

0.6.1 went out one day after 0.6.0, and its changelog entry opens by telling you not to take it:

**A test build, not the release.** 0.6.2 is the one that goes out. This exists so the game can be opened in fullscreen on two machines that have been describing two different screens for three days, and so the second of them can finally say what it is drawing.

Two machines had been disagreeing about the same interface for three days. One of them was not mine to sit in front of. There is no way to debug that remotely except to put a build in front of it that can describe itself, so 0.6.1 added one line to the settings sheet naming the window, the logical page the interface is laid out on, the scale between them and the window's aspect ratio.

I think publishing it was right, and labelling it was what made it right. A version number is cheap. A player who downloads the wrong build and has a worse time is not. The entry names its own successor in the first sentence, which costs nothing and removes the only real risk.

The same release also carried the distribution licence fault: $1.2M to arrange, 270 days of term, and for the whole of that term it changed nothing, because the line that was supposed to widen your audience had no caller anywhere in the game and the line that charged the partner their thirty per cent was named only inside its own catalogue. Both were wired at once, deliberately, because connecting the reach without the cut would have handed out twenty-two per cent more audience for free.

The fifteen-day gap, and why I did not split it

0.6.2 on 1 October, 0.7.0 on 16 October. Fifteen days, more than double any other gap in the table, and the only point where the weekly story visibly broke.

The headline of 0.7.0 is a player paying eighty million dollars for something the game then refused to admit he owned. The own-datacenter tier asks for $80,000,000 in the bank and costs exactly $80,000,000 to commission, so paying for it dropped the company back under its own gate in the same tick. The ladder went on demanding the money that had just left, and the compute page, which picks a tier by asking the same question, quietly sold everything into colocation instead. Colocation stops at 2,500 kW against the datacenter's 40,000. From the player's chair the button simply did nothing.

I could have shipped a weekly release on 8 October with half of that repaired. I am fairly sure it would have been worse than waiting, for one specific reason: the second half of the fault was that the research requirement existed only on the screen. TryOrderDatacenter read the catalogue directly and never asked the research tree, so the gate the interface draws was a suggestion to anything calling the simulation another way. That half was found by reading the surrounding code, not reported, and it was found because there was no release to get out on the Thursday.

Reported twice Francisco reported the datacenter button twice. The first description did not make the second half findable; the second one did. A gap is also time for a second description to arrive.

The measure that disagrees with all of this

Here is the part that changed how I read my own release history.

The save format version only goes up when stored data genuinely changes shape, because each step is a migration somebody had to write. You cannot inflate it with intent. Compare it to the gaps:

ReleaseGapSave migrations it carried
0.5.07 days1  (v56 → v57)
0.6.08 days10  (v57 → v67)
0.6.11 day4  (v67 → v71)
0.7.015 days1  (v71 → v72)

The longest gap of the ten carried one migration. An eight-day gap carried ten, and a one-day gap carried four. Gap length and depth of change are not correlated here. They are not even loosely related.

It makes sense once stated: 0.6.0 added systems, which is what changes the shape of stored data. 0.7.0 was mostly repairs and screens, which take calendar time and touch almost nothing a save file has to remember. And the changelog length is a third measure that agrees with neither, because it records how much there was to explain.

So there are three numbers available for any release and they answer three different questions. A version number is a decision somebody made. A migration count is a count. Changelog length is a measure of explanation. None of them is "how much better is the game", and nothing in the table is.

What I would keep, and what I dropped

Kept: shipping before it looks finished. The 0.1.0 reasoning held. Every useful correction in forty-seven days came from somebody playing, and none of them was about the art.

Kept: the same-day patch. An hour after a release is the right response to a fault you can see. The patch was never the problem.

Kept: labelling a build that is not for players, in its own first sentence, naming what to take instead.

Dropped: the belief that a weekly number was a commitment. Nobody had asked for one. I had inferred it from four weeks of coincidence and then felt behind for a fortnight over a promise that existed only in my own head.

Added: load an old save before shipping. Thirty seconds, and it removes the entire class of fault that produced the only patch release in the table.

If you are deciding your own cadence

  1. Do not announce an interval you have not survived four times under load. Four weeks of a week fitting is not evidence that weeks fit.
  2. Write the gap down with the release, then look at the column after a couple of months. The shape is invisible release by release and obvious in a table.
  3. Count your migrations, not your versions. It is the one number in this record that nobody can tilt.
  4. Treat a long gap as the cost of not shipping something half-wired, and say so in the changelog. "This took fifteen days because the second half of the fault was not visible yet" is a sentence players accept easily.
  5. Test along the path a returning player takes, not the one you have been building all week.

Ten releases, forty-seven days, one patch, one build that told you not to take it, and one gap more than twice as long as any other. Nothing about that pattern was planned, and that is the only reason it is worth anything as data.

Questions people ask about this

How often should a solo developer release updates?

On whatever interval the work finishes on, which is not fixed. Four weekly releases in a row here were really four weeks where the work happened to fit a week. When one piece was larger, the choice was a fifteen-day gap or a half-wired system, and the gap was better. Nothing external required a weekly number.

Is it bad to ship a patch on the same day as a release?

No, that is the system working. What is worth examining is the class of fault. Both faults in that patch needed a loaded save, which says the release was tested along the path just built rather than the path a returning player takes. The patch was right; the habit behind it was not.

Does a longer gap mean more changed?

No. Here the eight-day release carried ten save migrations and the fifteen-day one carried a single migration. Gap length measures how long the work took, not how deeply it reached.

What is a reliable measure of how much a release changed?

The save format version is the closest honest one, because a migration gets written only when stored data really changes shape, so the count cannot be inflated. A version number is a decision; a migration is a count. Changelog length measures something else again: how much there was to explain.

Is it ever right to publish a build not meant for players?

Yes, when publishing is the only way to get information you cannot otherwise get. One release here existed so a second machine, which had been describing a different screen for three days, could report what it was drawing. It said so in its first line and named the release to take instead.

Every date, gap and migration count in this article is from the public changelog of Scaling Laws, an AI company tycoon released as a free build with the source open. You can check the whole table yourself.

The game page and the changelog · How the migrations are written