My thoughts on the Thumby after making a simple game

posted March 30th, 2022

Last year, I backed a Kickstarter project called Thumby, a very (very) tiny game console. It has an RP2040 processor, a 72 x 40 monochrome display, and is only 18 x 30 mm. They arrived last week, here they are next to an Adafruit PCB ruler!

A clear Thumby and a pink Thumby next to a ruler.

smol

First impressions

I was expecting to be surprised by how small it is, but… I guess Thumby is a descriptive enough name that it’s exactly what I expected.

The screen is crisp, but it’s so small that it’s not very comfortable to look at for long periods of time. The buttons feel nice and clicky, but they cramp up my hands pretty quick, and I found that going between the 4 directions on the D-pad can be error-prone.

To be honest, these things were also expected, and the Thumby really is mostly a novelty. It’s impressively small for a functioning handheld, and it’ll be a cool trinket to keep on your keychain or something, but you definitely shouldn’t expect to be gaming on this for long periods of time. At best, it might be a good time waster during a short commute, but at that point I would probably just resort to playing a game on my phone instead of squinting at a tiny Game Boy.

All that aside, I spent about an hour making a simple game for it last night, and it was a pretty fun experience! The editor is easy to run, the API is small, and the hardware is somewhat cheap (the Kickstarter campaign is over, but you can buy one for $20 - $25 USD on IndieGoGo), so I can see it being a great experience for someone getting started with programming to go from coding a game to having it running on an actual physical game console.

The bad parts

I know I said it was a fun experience coding for it, but I’m going to get the bad stuff out of the way first (aside from what I already said above).

I’m not a fan of their editor. It’s a browser-based app that you can access here. This means that, if you want to upload programs to your Thumby with it, you’ll have to use a Chromium-based browser, as Firefox doesn’t (and won’t for the foreseeable future) support the Web Serial API (for good reason, given that it’s a dangerous API that should never have made it into browsers in the first place, but that’s a rant for another time).

Connecting my Thumby to the editor didn’t always work, sometimes I had to turn it off and on again, or unplug the cable and plug it back in, before Chromium would recognize it.

Another pain point is the lack of proper autocompletion. The editor seems to only do very basic completion based on Python keywords and variable names you’ve used in your file. This means that I often had to check the API documentation in another tab to find the Thumby API function I needed, or remember the arguments.

I write code for a living, so maybe I’m outside the target audience, but I would have preferred if they had focused on creating tooling like a CLI for emulating, building, and uploading Thumby programs, that could then have editor plugins built around them. This would solve browser engine incompatibilities, as well as allowing the use of existing, robust Python language servers.

I have very little experience with Micropython, so it’s possible that tooling like that already exists and can be used with the Thumby. If that’s the case, I think documenting it could help with providing a better developer experience.

Aside from Micropython, they also provide an Arduino library and documentation on using the Arduino IDE to program your Thumby. From what I can tell, this doesn’t provide you with the ability to emulate your programs on your computer though, like you can with the browser-based Micropython environment.

Again, I think most of these criticisms stem from already having a lot of programming experience, and I think over time many of them will be solved by either the creators of Thumby, or the community coming up with other solutions.

I also found the Thumby API documentation a bit lacking in some places, but luckily the Thumby comes with a few preloaded games, along with an “arcade”, where you can download more games right from the editor. This meant that there was plenty of example code to look at when needed, and I’m sure the documentation will get better with time.

Making a game

Like I said before, coding a game for the Thumby was a lot of fun! I haven’t felt that same way while coding in a long time. I think it’s a mix of the simple API, a quick feedback loop using the emulator built in to the editor, and the final result of getting to play your game on physical hardware.

Over the course of about an hour, I made a little game where you’re falling, and you have to move left and right to avoid obstacles. The obstacles get faster over time, and you keep playing until you hit one, which causes the game to end and gives you your final score.

Here’s a video of the game in action:

Me playing the Thumby game I made in the web-based emulator

(I would record it on the actual device, but that’s difficult to do when the screen is barely 1 cm across!)

While coming up with an idea, I thought making a vertical game could be cool, and that fits perfectly with the falling idea, since you can see the obstacles coming towards you from further away!

I ended up making it so that you turn the thumby clockwise, and use the A and B buttons to go left and right. I found that turning it the other way, and using the D-pad, was less precise, and it also meant that your left thumb covers some of the screen.

Timers

The first thing I wanted to figure out was how to have time-based events (like “spawn an obstacle every X seconds”). The answer was just what I expected, and something that I’ve done in game engines before.

Python’s time library provides the method ticks_ms(), which gives you how many milliseconds have passed since an arbitrary point in time (in this case, it’s since your program started).

To schedule something to happen in, for example, 3 seconds, I’d set a timer variable to 3000 ms, and decrement it in every iteration of my game loop, by how much time has passed since the last iteration. Once my timer reaches 0 (or less), I know 3 seconds have passed:

timer = 3000
prevTime = time.ticks_ms()
while (True):
	timer -= time.ticks_ms() - prevTime
	if timer <= 0:
		# Timer ended!
	prevTime = time.ticks_ms()

Drawing to the screen

The Thumby editor has a bitmap editor, and you can easily create and draw sprites. For my game though, I just used simple shapes. The API is about what you’d expect, and lets you draw lines and rectangles.

Something to remember is that the Thumby’s screen doesn’t entirely fill the black area of the Thumby. You can see this in the video of the game above. This means that you might want to add lines showing where the border of the actual screen is, if there’s a chance the player might try to go too far.

Displaying text

The Thumby API has some decent functions for displaying text. You can create and load custom fonts (it comes with 2 fonts by default), and easily write strings to the screen.

Unfortunately it seems like the Thumby API doesn’t support rotated text, so like you saw in the video, my game’s title screen and game over screens were horizontal, and I didn’t show a score counter during the game. You could probably work around this though, maybe with a custom font, or drawing the text yourself.

Conclusion

Those are the only issues or problems that I can remember having to solve. Other than that, it was a pretty straightforward process - like I said, it only took about an hour to make this game, which isn’t bad considering it’s my first time coding for the device!

The final program was ~120 lines, you can find it here: thumby-fall.py

I don’t think I’ll be doing much more coding for the Thumby, and after playing all the games I could find for it (at least from the editor’s arcade), I still think that overall the Thumby is a novelty.

Hopefully that doesn’t sound too dismissive or negative - it’s not a bad thing that it’s a novelty, it just isn’t a console in the same way that a Game Boy or Nintendo Switch is. It’s very unlikely that when I feel like doing some gaming I’ll reach for the Thumby. Although it is a really cool showcase of:

So, do I recommend the Thumby? If you’re expecting your next primary handheld gaming console, then no. But if you want a cute little trinket that actually works, or if you want to do some coding and have your game running on a physical console, I’d say yes!