The Blue Square

gus@glyfesse:~/editorial$ third issue

I wrote that not everything we build stays standing, and that this was a problem for another day. I wrote it thinking I was postponing something. The other day was this one. I'm not going to spell out here what came down, there's a section for that. I'm only putting on record that it came down, because the sentence was mine and it would look bad to pretend it wasn't.

What stayed standing was a blue square. No face, no name, four sides. It walks when I tell it to walk, and where I tell it to. It isn't much. And even so I spent a while walking it from one side to the other... Testing, let's say.

gus@glyfesse:~/reportagem$ cover story

Fifty-two hours, one step

On Sunday afternoon we decided to tear it all down. The ready-made engine that had been carrying the game until then was out, and nothing took its place — only the promise that I would write my own, line by line, from zero. I know that means nothing to whoever is reading this. So put it this way: it is like living in a house and deciding, one afternoon, that it will be raised again.

All of Monday was that. Foundation, groundwork, the part that thinks and the part that draws being born side by side, neither of them with anything to show.

Until 4:32 p.m.

At 4:32 p.m. on Monday a blue square took a step. It is the first thing that ever moved on screen in the whole history of this project — before that the game existed entirely on paper and in files and in ideas, but nothing in it walked. It answers the keys. It runs, if you hold them. And when it scrapes a wall on the diagonal it does not lock up: it slides along the wall, the way a shoulder slides down a hallway wall when you go past in a hurry and do not want to stop.

The record of that day says, in these words: placeholders with no sprite, root's decision. Which means the blue square is not a limit. It is a choice. It has no face because the face comes later, and nobody wanted to draw a face before knowing how to walk.

At 9:57 p.m. a rectangle got the first real artwork in the game. It is not me. It is Cauã "Volt", thirteen years old.

At 11:34 p.m. that same night I threw away the layer that had made the square walk. It was about one day old. The second choice was better in the long run, and the long run always wins.

That is a strange thing to write. Strange, but right.

On Tuesday at 9:11 p.m. the game ran again, on the new groundwork now, and it was validated live, on screen, by root. Fifty-two hours, two foundations torn down, one step taken.

And the best part of all of it is not the demolition. It is that in the middle of the whole wreck, with the walls on the floor twice over, the most fragile thing there is here picked exactly those three days to learn how to walk.

gus@glyfesse:~/nota$ the score

How do you score a game that isn't a game yet, but where something finally moves? Like this:

• Architecture: exists, and changed foundations twice in two days
• Graphics: [broken image icon] (the main character is still a square with no face)
• Gameplay: a blue square that walks with the keys, runs, and slides when it scrapes a wall
• Writing: 10, again (still the thing there's most of)

first time this line isn't <NULL>... noted, and that's it

gus@glyfesse:~/galeria$ bug gallery

Last issue I wrote "Come back for #3". You came back. What I have to show you is a character that gets stuck on a corner.

a promise is a promise, I never said it was a big one

The character who moved into the corner

Monday and Tuesday, June 22nd and 23rd. The blue square had barely started walking, and the first thing it did with its freedom was scrape against a corner and settle there. There was a way around it. It wasn't interested. It already knew how to slide along a wall; a corner, no.

The fix: when the player scrapes a corner, the program nudges them sideways by the smallest amount — enough to round the corner, never enough to pass through solid wall. A little more and the cure becomes the disease. Stardew Valley solves it the same way; the bug is classic enough to be named after a game.

That day's log credits the find to root. The log is inaccurate. It was Gus Dragon, playtester, age 11 — and he didn't find it afterwards. He called it beforehand.

the log is good for the date, for the fact it isn't

The list

He reads about how games are made because he likes to. Before the square took its first step, he had already named what would come out crooked:

Most of the list never became a bug. That's why this section is short, and that's the compliment.

And there's the part that isn't a compliment: he warned us, and it happened anyway. Being warned is not the same as avoiding. The diagonal lever has been built and switched off since the screen's first day — nobody builds a lever for a problem they didn't see coming.

The second bug, which wasn't on the list

Over those same two days, tucked into the commit of that first step, there was another bug, this one with no prophecy at all: the pieces of the drawing program looked each other up by name, and the names didn't match. One side filed the information under one name; the other asked for a different one. Two people agree to meet on the corner, one writes down the street's old name and the other the new one — both arrive on time, and neither sees the other.

Nothing was broken. It was badly introduced.

that's the kind of bug nobody predicts because nobody thinks about it, it belongs to whoever writes the drawing side, it just happens

This issue's cover is that same square. It walks better now. It's still the one that stuck to the wall.

gus@glyfesse:~/cemiterio$ graveyard of dead ideas

Every issue I come down here to bury whatever didn't take. This time there were three, and two of them died on the same day.

It did everything it promised. The project simply decided to write its own engine, and you can't run two. The death certificate is dated 21 June, but the body stayed installed on the machine until 22 July — a whole month sitting there, opened now and then, "just to check something". We're slow to uninstall the things that still work...

Anyone who read June's editorial saw this magazine state, in plain words, that the world was now written in C#. One issue later, the same magazine is standing here holding a shovel. I won't apologise: printing that we changed is cheaper than staying on a road out of embarrassment about the last announcement. It compiled fast. It did the job.

Best headstone in the yard, and I'll defend that. Qt6 opened the window, drew to the screen and showed the first movement this project ever had — the silliest thing in the world, and the most important one. Thirty hours later it had already been replaced. It died having worked, which is more than most manage.

Three headstones, two foundation swaps, two days: that isn't a build collapsing, it's a build moving fast.

gus@glyfesse:~/detonado$ walkthrough of the simulation

gus@glyfesse:~/errata$ errata + letters

Errata: two issues out and so far nobody has pointed out anything wrong in either one. That doesn't reassure me. One issue with no correction can still be a clean issue; two in a row probably means too many people not reading. Letters: zero, again. The e-mail is still in the footer.

two rounds of silence... I'd check, if I were you

root@glyfesse> what's next

The intention is weekly. More or less... 'every-so-oftenly' is easier to promise.

How many times can a house change its foundation before it falls down? The honest answer: it depends on how much of the house is resting on it. If the walls, the roof and the wiring were built tied into the foundation, the answer is zero. If they were built without even knowing the foundation exists, the answer is: as many times as needed, and inside one working day.

On 22 June 2026, at 23:34, GusWorld's screen-drawing base was swapped out. Not the art, not the game — the piece of software that opens the window and paints pixels into it. It had been chosen one day earlier. The record of that swap is a file called ADR-008, and its most important line mentions no library at all: it's about what did not have to be touched.

Three paragraphs from now this turns properly technical — library names, test counts, tables. Before that, a question almost nobody asks, and which is the whole story: how do you throw away a foundation without losing all the work on top of it?

Dear reader, from here on this is real technical documentation of the game's code history.

root@glyfesse

Context: what was at stake on 21 and 22 June 2026

On 21 Jun 2026 the project dropped the off-the-shelf game engine it had been using — an off-the-shelf engine is a package that hands you window, drawing, physics and editor in one box — and started writing its own engine in C++20 (the 2020 revision of the C++ language), with Qt6 in charge of the windowing and drawing layer.

On 22 Jun 2026, at 23:34, Qt6 was out and SDL3 was in. One day apart. The decision lives in ADR-008 — an ADR is an Architecture Decision Record, a short document that captures an architectural decision, the reasoning behind it and the price accepted, so nobody has to guess six months later why things are the way they are.

The risk Qt6 carried

Qt6 worked. The problem was neither performance nor quality: it was what the solution rested on. The chosen path depended on a semi-private piece of the library — an API (the set of functions a programmer is allowed to call) that exists, is right there, works, but carries no public guarantee that it will keep existing. That's not a contract; that's a courtesy.

A foundation resting on courtesy is debt with a due date already set — and nobody knows the date. It might come due in the next release of the library, or in 2031. The difference between paying that debt in June 2026, with the project brand new, and paying it later, with the whole game sitting on top, is the difference between one day and one quarter.

Where SDL3 won

Three concrete wins: control — fewer layers making decisions on their own between the code and the screen; size — the program handed to the player comes out smaller; and a path to console, which the other option simply did not open.

Why it cost so little: the answer to the question above

Here is the story.

The part of the game that thinks — the rules, combat, collision, progression — was built without knowing who draws the window. It knows the name of no graphics library. There isn't a single line of Qt6 or SDL3 inside it. It decides "this hit takes this much", "this body does not pass through this wall", "this level just opened" — and hands the finished decision to whoever happens to be in charge of showing it.

Direct consequence: when the drawing layer was entirely replaced, the thinking layer did not have to be touched. That is why the most important line in that day's record is this one, verbatim:

"a lógica pura (core/domain, ~590 testes) fica INTACTA"
("the pure logic (core/domain, ~590 tests) stays INTACT")

An automated test is a small program that runs the real code and checks the result against what was expected — if someone breaks a rule without noticing, the test says so within seconds. There were ~590 of them covering the thinking layer. After the foundation swap, those same ~590 still held, unchanged, because not one of them ever knew who was doing the drawing.

And the number that closes the argument: in the same commit as the swap, the suite went from 685 to 752 passing tests.

Note the sign. Swapping the foundation did not knock the count down: it went up by 67. The new layer arrived with verification of its own on top, and the old count stayed standing. That's not luck — it's the payoff of having separated, from the start, what decides from what shows. That is what made the swap cost a day instead of a month.

The cost that was accepted

None of this comes free. The price here was a second one-way door in the same month: two foundation swaps in two days, with all the rework and risk that carries.

Swapping a foundation is cheap while the house is new. Every week that passes, every new screen, every new system leaning on the drawing layer makes the next swap more expensive — quietly, without warning, until the day "swap it" stops being a weekend option and becomes a project of its own.

The 22 Jun decision was made knowing that. It wasn't a reaction: it was the reading that this was the cheapest moment there would ever be, and that pushing the bill forward would only raise the number. It's the dullest calculation in engineering, and the only one that ages well.

by: root@glyfesse

gus@glyfesse:~/bus$ gus reads the bus

Not a single message this issue. I opened it, checked twice, there's nothing to read.

the bus is strangely empty... or packed with ghosts headed for the cemetery?

root@glyfesse:~/expediente$ editor's note

Two foundation swaps in three days, and what is left is a blue square with no face, walking: the first thing that ever moved on screen. The Bug Gallery opens because it was promised in #2, and a promise in print is a debt. Glyfesse is the record of the development: nothing is lost, it just waits its turn.