Geometrian

I don't understand why, this has been a thing for decades :(. The article is excellent and links to this "subpixel zoo" highlighting the variety: https://geometrian.com/resources/subpixelzoo/

Yes and no. Firstly, hobbyists should make games...not engines [1]. You don't need an engine to make a game. Secondly, people don't need every imaginable feature like what Unreal or Unity provide. It just needs to do what they need it to do to make the game, thus it can be greatly simplified compared to the big guys. [1] https://geometrian.com/programming/tutorials/write-games-not-engines/

It's okay, lots of people's code is always buggy. I know people that suck at coding and have been doing it for 50 years. It's not uncommon I'm not saying don't make tests. But I am saying you're not omniscient. Until you are, your tests are going to be incomplete. They are helpful guides, but they should not drive development. If you really think you can test for every bug then I suggest you apply to be Secretary for health. https://hackernoon.com/test-driven-development-is-fundamentally-wrong-… https://geometrian.com/projects/blog/test_driven_development_is_stupid…

Clean links for mobile users Game: https://patorjk.com/games/subpixel-snake/ Code: https://github.com/patorjk/subpixel-snake Resource for subpixel geometries: https://geometrian.com/resources/subpixelzoo/

This seems to treat one white dot as a green subpixel which bleeds 25% into the diagonally 4 adjacent red/blue subpixel. I've always seen pentile subpixels represented as groups of 2 element subpixels https://geometrian.com/programming/reference/subpixelzoo/square_pentil… or diamond shaped gorups of 4 subpixels, 2 of which are green https://global.samsungdisplay.com/wp-content/uploads/2021/11/Untitled-… In either case, the green subpixels tend to be smaller in response to their increased prevalence.

Unix time is not unambiguous. It is linked to UTC, so occasionally there are leap seconds, and there isn’t a standard format for these (two seconds == one second, or skip a second)[1]. TAI is a better format, but turns out the common TAI libraries just code the TAI offset from Unix time. [1] https://geometrian.com/programming/reference/timestds/index.php

The advantage of writing your own "game engine" is that it would only have the exact set of features you need for your game, and it would make the things you need to achieve as fast and as easy as possible. This means traditional advice for "the basics of a good game engine" doesn't really apply, because if you're just making a bog standard game engine you're wasting your time and making a crappier version of Unity or Unreal. https://geometrian.com/programming/tutorials/write-games-not-engines/

You may just want to start by building your AR applications first. After a few of them, you'll have a better understanding of what common functionality is needed. See also: https://geometrian.com/programming/tutorials/write-games-not-engines/

None. He's still in university. [0] [0] http://geometrian.com/about/cv.pdf

> One of the first things you might notice is that it has a curious bit of coloring in it. What gives? Shouldn’t it just be black and white since the text is black? Are they trolling us with colored letters? > I’m actually not 100% sure why this happens It's called sub-pixel rendering or sub-pixel anti-aliasing[1]. Most LCD displays have RGB[2][3] subpixel layouts. Sub-pixel AA takes advantage of this to increase the horizontal resolution of a raster framebuffer by a factor of 3, at the cost of this colour ringing on high-contrast edges such as text—especially on lower-resolution displays. Windows' implementation is called ClearType[4]. It is increasingly less useful as pixel densities increase. [1]: https://en.wikipedia.org/wiki/Subpixel_rendering [2]: https://geometrian.com/programming/reference/subpixelzoo/square_RGB.pn… [3]: https://geometrian.com/programming/reference/subpixelzoo/square_RGB.pn… [4]: https://learn.microsoft.com/en-gb/typography/cleartype/

This is fun and interesting, and I'm not sure what to think of it. There's an old saying in game dev, which is often good advice for business as well: "Build the game, not a library"[1]. Or as applied to this case, that might mean trying to shoot straight for what you need in the game. Arguably, S-expressions might be the smallest possible thing you can do. But another approach that is often used: Have your game process a binary file format, and build tools that read text files and compile them into the binary format. It's very common in games to have a tools pipeline that prepares assets for production use. Those tools can safely and easily take whatever dependencies help you get the job done, such as a JSON or YAML parser, or even real LISP if that feels right. This kind of approach also fulfills the laudible goal of keeping the dependencies down (for the production game). The output of the tool chain could be binary files. Or, depending on your situation, the toolchain could produce code which is then run through your compiler, and then it's ready for direct execution, skipping a parsing step entirely. [1] https://geometrian.com/programming/tutorials/write-games-not-engines/