Blocks and How to Play with Them
It is August 30th of 2007. I am eight years old. I am in a stairwell in a small house situated comfortably in the middle of nowhere. My primary source of communication with the outside is a copper phone line with no filter. And I'm on my parents' computer while they're away.
It's an old Gateway computer. Mid-tower, cow-cube branded--you've probably never seen it before. 256MB of RAM. No dedicated graphics processor. We did happen to have a 720p flat-screen LCD monitor at the time, which was very nice for the era. Most of my time on this computer is spent on either Club Penguin, World of Warcraft, or--what was the name of it?--Sherwood Dungeon. And today, I stumble across Roblox and make an account.
That instant, that "sign up" button, was a pivotal moment in my life--that's how I went from interested in computers and game development, to interested in software engineering, to being an actual software engineer. And I know as a matter of fact that it touched a lot of other lives the same way. And since then--well, things have not been going well for Roblox.
Sorry if this turns into a meander. I feel like that's necessary, though. Something got lost along the way with Roblox--for a brief moment there, it was a series of small, sharded communities, and there was a great deal of support for those small and sharded communities--until suddenly there wasn't, and everything was about making money. Every day it seems more and more like we've replaced a tool for kids to learn and have fun and grow up with, with a child labor sweatshop.
But--that aside--why was it fun then, in that golden age, and why did it stop being fun?
The answer is simple. Bottling it is the hard part.
It was fun because it was just a bunch of kids playing together. When Roblox opened the Developer Exchange, which turned Robux into real, hard cash, things started going sour: over the span of two years, games went from being made for fun, to play with your friends, to being content created to make money. And it kept getting worse. Kids playing together gave way to content creators, building for a corporation whose sole purpose is extracting as much capital as possible from its community. (Not employed by it, mind you; they're mostly independent studios, and Roblox takes its cut either way.) When you make something about money, it becomes a job--and for a lot of people, a job stops being fun. Roblox making money was never the problem; what it makes the money from is.
That's half of it. The other half is moderation. Something that consistently bothers me about large platforms and moderation is that moderating a large platform is inherently an intractable problem. Aside from Roblox, I spent a lot of time in Garry's Mod, and my fair share of it as a volunteer moderator for a lot of servers. That is the only way I have ever seen in my life, in a social game, for moderation to scale effectively. Smaller communities, self-moderated, on a larger platform. The same holds true for any forum of the past, present, and future. You cannot hope to cram three hundred million people in a room and expect a C-suite to know how to manage that.
That's why, lately, federation seems to be the ultimate solution for managing community moderation--federation with the ability to select who you're federating with, and to establish a larger moderation policy across those communities. I've seen this happen on a small scale recently with Space Station 13--which I have been a major part of, moderation-wise, having helped establish /tg/station's 501(c)(3) foundation. And in Space Station 14, where, despite--well, let's just call it complications--the community survived just fine with its usual set of moderation rules.
So I wanted to build something that solves both. Also just to have a bit of fun along the way. That's Blocks.
Blocks will be free and open source software, released under the AGPLv3. There is no foundation yet, and if there were, it would operate solely on donations and run no game servers of its own. The servers belong to the communities that run them, and so does almost all of the moderation.
It started as a mostly clean-room player for classic Roblox places. Since then, it's not so much widened as wandered--meandered, even--through the different eras, along with a healthy splash of paint from modern rendering techniques and, you know, just a bit of polish and some sparkles here and there that don't break the era feel, but make it feel like when you were a kid again. And it certainly doesn't hurt to also include support for other assets from the era--Source Engine models and levels, blocky voxels, you know the type.
Playing with Blocks
It is 2008. I am in Script Builder, and nograpes has just built a new flying fortress. Nobody asked them to. Nobody paid them to. They did it because they could, and because the rest of us were there to watch.
The first thing I want Blocks for is Script Builder. Script Builder was a Roblox game, from 2008 to 2015 or so--anaminus to billiland, for those who were there--with a small and regular community of people who would just show up and run sandboxed Lua scripts. They pulled off amazing feats--the most creative things you could possibly imagine--and it was an honor to be among them. Starting in 2009, Canadian's Turf did much of the same in Garry's Mod. It started off as a small server with a popular YouTuber heading it up, and over the years the Garry's Mod part has fallen away--but virtually everybody who was a regular contributor there has turned into a real-world electrical, mechanical, or software engineer. We're all still in touch.
That's the first use case: letting small communities build things for fun. Playing with blocks, as a child would. Except it isn't just that we played with blocks--it's that we grew up playing with those blocks together. It was collaboration. It was competition. It was so much more than just one kid playing with blocks. It was an arts and crafts room full of kids, joined by copper line rather than being there in person. And it was incredible.
Learning to Share
It is 2015. I am in ByB, a Garry's Mod DarkRP server, and I've just begun raiding someone's base. I have no idea who made it, and I don't need to. I'm having fun. And this base belongs in the Louvre.
The second is for those creative types to share what they built with the non-creative types. This is where classic Roblox games, or things like DarkRP, come into play: a few people put together a game or a game mode, and a lot of other players show up just looking to have a good time.
And this is where Roblox's monetization model has had a wider impact than Roblox, on the greater modding scene. The thing I see a lot of nowadays on modern DarkRP servers and on Grand Theft Auto V servers is that they monetize the absolute hell out of it: VIP ranks, pay-to-win perks, a web store bolted onto the side. It's reached the builders, too--scripts get sold to server owners, so even the building is a job. There's no point in doing any of this stuff other than for somebody to make money.
So how do we keep the money out?
The honest answer is that we can't, entirely. Free software can be used for any purpose, selling things included. I can't add a "no selling" clause without Blocks no longer being free software, and the AGPLv3 lets anyone strike a clause like that out anyway. Nor is there a central server to enforce one from--there isn't meant to be. What we can do is keep the money from being the point.
Some of that is just what Blocks won't build. There's no currency, no store, and no buy button; the era's purchase service and its game passes simply aren't there. A server can still bolt a web store onto the side, but nothing in the game is reaching for a kid's wallet. And the exits stay open. A place is a file, and a server is something anyone can run, so if a community starts squeezing its players, the builders and the players can pick up their blocks and leave.
The rest is the league. I'm modeling this on the Website League, a small federated social network: one allowlist, which doubles as its list of members, and one baseline code of conduct that every node follows, with each node free to add its own rules on top--all stewarded by a group that decides by consensus. It's a central authority that's loosely federated. I mean, it's in the name. The central Blocks league would work the same way: shared accounts and identity, global bans, and a baseline every server agrees to. To start with, it won't even be an entity--no registered 501(c)(3), nothing of the sort--just a loose-knit cluster of people who want to run it. Donating to a server is fine, but what a donation buys stays strictly cosmetic. And the central league has to be safe for kids, which means, among other things, no bigotry. (The Website League goes a step further and turns away anyone whose politics lean right. I think that's overqualified; what I'm after is eliminating bigotry, not politics.)
Global bans are the one place the league reaches past a server's own moderators, and they're deliberately narrow. This one comes from my time on /tg/station: if we receive credible reports of something like CSAM or doxing, or equivalent, with reliable evidence, then we just ban the person from the top. It's controversial, especially in a federation, but I feel like it's necessary.
Ideally, anyone should be able to run a league, and anyone will be able to. The central one is just the one I'd vouch for. If it ever stops deserving that, the same exits apply: take your server, take your players, and federate somewhere else.
What the Blocks Are Made Of
Everything here runs in the browser, on WebAssembly. Nobody needs to install anything--and that isn't just a convenience. That Gateway in the stairwell has a successor, and it's a school Chromebook: locked down, nothing installable, and for a lot of kids, the only computer they've got. If Blocks needs an installer, it isn't for them. So it doesn't.
Drawing Blocks
Now, the blocks themselves. Blocks doesn't draw meshes. Every part on the screen is one flat rectangle covering wherever the part could possibly appear, and every pixel in that rectangle casts a ray at the part and solves for where it hits, exactly. A brick's edges stay sharp at any distance, because a brick isn't a model; it's a formula. This is box splatting, from Majercik et al. (2018).
Majercik's box is three slabs, each the space between a pair of parallel planes, and a ray is inside the box wherever it's inside all three at once. But the era's bricks aren't plain boxes. Every edge is beveled, cut 0.065 studs in at 45 degrees--I measured it off the old clients' own meshes. Of course I did. A beveled box turns out to be nine slabs: the three you had, plus two diagonal ones for each pair of axes. Same algorithm, six more planes, and whichever slab the ray enters last hands you the surface normal for free. (The crystal in this page's header is the same trick: an octahedron with its edges chamfered, ten slabs.)
That's what modern hardware buys us: bevels for cheap--not a single extra triangle or byte of mesh, just a little more arithmetic per pixel. In the era, they were anything but; Roblox Studio in 2008 decided whether you got bevels at all by how much video memory your computer reported. Now everybody can have them, if they want them. On my machine, turning them off still buys back a tenth to a fifth of the GPU's time on a busy frame, which is exactly why they're a knob.
And everything is a knob. We didn't just build an era; we built all of the eras, and you choose what's turned on. Bevels on or off, and how deep. Faceted shading, banded, or the old per-vertex lighting with the era's slightly crooked normals. The original sky or a moving one, with or without a sun and moon. Night by each place's own hour, under the 2008 client's own 2,497 stars--or under ours, twinkling. Pick what you remember, turn off what you don't, and play.
Studs, Inlets, Bumps and Parallax
Then there are the faces. Studs on top, inlets underneath, and welds, glue, and the rest wherever a builder put them--if there's one thing that says 2008 about a brick, it's the studs. The era client kept every pattern in one little texture, a strip 64 pixels wide: studs, inlets, welds and glue, stacked on a background of exactly middle gray, so that multiplying it into a brick's color leaves the plain parts alone.
If you have the era's own content on your machine, Blocks reads that strip and uses it. If you don't, it uses ours, and ours wasn't traced. A program draws it from a handful of constants--each pattern a height field and a tint, lit from the same corner the era lit its studs from--and a test holds the committed image to that program, byte for byte. No era pixel is copied, and the stud tops carry no logo; that one's somebody else's. (I did cut the welds in, where the era raised them. A weld is a seam.)
Even laying the strip onto a brick took measuring. The 2008 client doesn't compute its texture coordinates; somebody authored them by hand, face by face, so I read them back off it, face by face, with a lopsided glyph that shows at a glance which way is up and whether it's been mirrored.
The trouble with a baked texture is that it's a picture of one light. The era's studs are lit from the upper left, forever, whatever the sun is doing. So that's a knob too. Baked is the default, because it's what the era drew. Bump tilts each pixel's normal by our relief map, so the studs catch the scene's actual sun. And Parallax marches each pixel's ray through the relief's heights until it meets a stud, so they read as raised even at a glancing angle. None of it adds a vertex--there aren't any to add--and on my machine, even parallax keeps a busy frame under a millisecond at 720p.
Dropping Blocks
Physics has the longest history of anything in here, and most of that history is me throwing engines away.
It started with Box3D. I translated it into Rust, checked against the original C the whole way, and then kept at it until the port ran 10 to 20 percent faster than the original. And then I stopped trusting it. A port checked against its original can only ever tell you whether it matches, never whether it's right--and stacks of era bricks, the one thing it had to get right, kept falling over.
So in September I started over, measure-first: an engine of my own, every stage checked against closed-form answers and slow, obviously-correct references, and every stage swappable, so AVBD, XPBD and the rest could be tried side by side. It's still in the repository, kept as the measuring stick the next one is held to.
Because then I started over again. The engine Blocks runs today is the third, and its best feature is that every
quantity has a name. A vector is three numbers; a velocity is three numbers with a meaning. So here, a velocity is a
Velocity, a displacement is a Displacement, and the compiler refuses to add one to the other, because a velocity
plus a displacement is nothing. A velocity over a duration is a displacement, and that's a function with a name and a
comment saying why it holds. You can read the solver knowing the mathematics and not the engines, which was the whole
point.
It's also deterministic to the bit: the same scene steps to the same bits on x86 and on ARM, and a step's cost is counted in instructions, so a slowdown is the difference of two integers. And it's held to the era, not to a modern engine's defaults--the era's tick of a thirtieth of a second, its gravity of 196.2 studs per second squared, its friction, its bounce, all measured off the 2008 client.
Scripting Blocks
The era's places run Lua 5.1, so Blocks runs Lua 5.1: a machine rebuilt from scratch in Rust, without a single line of
unsafe in it. Its bytecode format is the reference's, intact, because some of the era's scripts load bytecode the old
client's compiler wrote.
A from-scratch Lua is a fool's errand without something to hold it to, and we had two somethings. The first is Lua's own official test suite. The second is the archive: over thirty thousand old place and model files, nearly ten million scripts inside them, and more than three hundred thousand distinct ones. That's the language as the people who used it actually wrote it, and plenty of it never compiled. A script that was broken in 2009 has to be refused here with the message it got in 2009.
So every one of those scripts went through the reference compiler, and then through ours. All 328,267 that the reference accepts compile here to the identical bytes, and all 6,626 it refuses are refused with the identical message. That corpus is the only reason building it from scratch was feasible at all: whenever we got something wrong, three hundred thousand scripts from the era said exactly where.
It is November of 2026. I am 27 years old. I am living overseas now, far from my old problems. I have a 20G fiber uplink. And somewhere, right now, there's a kid in a stairwell. Eight years old, maybe. Middle of nowhere. A school Chromebook they can't install anything on, and the only social life they've got, coming in over a line.
This one's for them, and a browser is all they need.
Here. Play with some blocks.
A playable demo is coming soon.