Other intersting projects I've worked on. Usually not games.
(Dates may be slightly off)
Went a bit far trying to upgrade the old (8088 + CGA) emulator and ended up with a very different 386 + VGA emulator which could boot Linux and Windows 95.
I didn't intend to port this to run on a pico but ended up doing it anyway.
Using my recent board with a large amount of IO to answer the question "can I connect an ATA hard drive to a microcontroller?" (and also a CD drive and an SSD later).
Definitely no confusion caused by using PIO to implement PIO.
A new version of the GBA cartridge reader, using the excuse of making an RP2350-based design.
This one can also read Game Boy carts and has room for expansion (or repurposing as a general purpose dev board).
Back here again to port the other game... Which I didn't do first because it needed more work to restore the "lores" 320x200 graphics, and was generally less stable.
Running on the handheld so I could pretend I didn't get distracted again.
Escaping from the game porting distraction, I updated the display board and made the case... more purple?
Now that I'd replaced every part, I could build another one using the original parts (and some hacking). Like the Ship of Theseus, but with handheld consoles and 3d-printed parts...
After the source code was released, I had to get it running on something silly. Eventually I had the new PICOLIB code running on a handful of RP2350 boards.
Of course, I had to get it to compile and run on anything first.
Continued work on the previous prototype.
On the hardware side there were some new cases, and a new version of the input board (which works this time).
For software there's some sensor experiments, launcher improvements and of course it runs DOOM now.
Combining the previous two boards into something very close to a finished device...
A much more functional successor to the 3.5" board with working display, power button, microSD slot, sound and battery power.
Oh, and connectors that are the right way around.
(Using a different display because... reasons)
Almost working version of my own gamepad board with a joystick, four buttons and an LED. Made a few mistakes with the LED and had to disconnect red to get anything to work.
Good enough to start working on bigger things though...
Added Wi-Fi and tried to find something to use it for. Ended up using it to get the time and calculated local (-ish) sunrise/set times to display a day/night cycle.
Two things I can't escape from:
So why not do both at the same time?
Kinda slow and about as hacky as the other devices, but it works.
Got some new mini gamepads so had to try combining them with some displays!
May have went a little too far.
As my PicoVision 3D demo was somewhat over-engineered for a one-off demo, I started turning it into a reusable 3D engine.
Didn't get very far with trying to do anything with it though.
It's a bit hard to assemble, the power button doesn't work and the I2C connectors are all backwards but... the display works.
Back to working on this as the new RP2350 soles the multiple games problem with its address translation feature. A lot closer to merging now...
A big pile of GBA test ROMs (mostly display related). A lot of these written while working on DaftBoyAdvance, but made buildable without hacks now.
More case printing! It may have taken more than two years, but now it looks like a finished thing.
Everyone's favourite handheld computer from the early 2000s! Okay, not really but I have a pile of these things.
Technically a much older project (predates DaftBoy) but I upgraded it with features from my newer emulators, allowing silly things like connecting them together and to a PC.
PicoVision emulating a PC (XT). A slightly silly idea that I wanted to see how far I could get with.
Managed to boot to BASIC, then DOS and finally Windows (1.0).
A fully custom board based on the prototype that fits in a cartridge. Makes a few sacrifices to squeeze in a microSD slot.
Another case, but a bit more fancy with my new multi-material powers.
(Earlier version made in May for my pre-release device)
Attempted to recreate an old uh, brick-based train game.
Got the trains mostly working at least.
Some additional silliness: wheee and loooong
(Also, the image here is demonstrating the "winter" easter egg)
It's a keyboard. It has a Raspberry Pi 5 on it. (Also usable without one.)
All the switches are the wrong way up for the backlight to work, whoops.
Got a new printer, started sorting out things that could do with a case.
(Making my modified PicoSystem significantly less stabby)
Started working on a new launcher for small things. Spent a lot of time on the scrolling.
A board to connect a PGA2040 to a GBA's cartridge slot. Wrote a bunch of code to get it to pretend to be a cartridge, then ported the 32blit SDK to it.
Some additional posts:
Perhaps slightly over-complicated USB cable test thing. Because I have too many cables.
... and then I bought more to test it.
Built a significantly less functional board a few months earlier.
Tile-based renderer rendering a model of a PicoVision on a PicoVision. (Maybe the model is running the same code, who knows?)
Uses both cores and ALL the interpolators.
Definitely not motivated by any kind of demo competition or anything.
Big pile of cleanups in an attempt to add PicoVision support (had some fun problems to debug). Didn't get that far but it can emulate a Tufty slightly better than before.
Because I have to port it to the shiny new device with video output!
Also resulted in a bunch of improvements to the experimental launcher code due to finally having something that can do hires output and has an SD card slot. Still sitting on a branch though...
Needed something to test the new compilers. Runs on GBA and PicoSystem and fails in some way on most emulators.
Mashed the two recompilers together into something slightly more generic, gaining x86 support for DaftBoyAdvance... but losing the Thumb->Thumb translator. Also probably broke Windows support (mumble calling conventions mumble).
Somehow ended up generating smaller code and getting faster in the process.
Experimentally ported to DERP, which has a lot more of a performance impact.
In a burst of activity this very serious emulator gained:
The USB support is good enough to handle the UF2 loader, which is much less convenient than running DERP_SDL file.uf2 but uh, why not?
Some attempt to make this into an actual game. Includes a clock, bars that go down and "using" objects to make them go up again.
Also a "build" mode and less rainbows.
Porting a big pile of the 32blit launcher/API stuff to the "pico" port. Allows fun features like multiple games (at this point just the launcher + one game) and running the same game build on different devices.
Sitting on a branch somewhere until I get around to cleaning up and merging...
Okay, so maybe it is... but it's really high-level as emulating all the peripherals would be too much work. Fortunately I just needed to translate the firmware API and almost everything works at reasonable speed.
Definitely not the same shape as a handheld game console that I've written an emulator for.
Last years demo, but with 4x the panels! (and some 3D-printed brackets)
Because I didn't already have enough emulators, I decided to remove half of DaftBoyAdvance's CPU core then hack on extra bits until I had created:
Daft's Emulator for RP2040.
Which is a sensible name and not a joke at all because I definitely expected it to go somewhere. At this point there are just enough of the peripherals stubbed out to run PicoSystem games (without any sound).
Learning my lesson from the previous one I... did the same thing again?
This one only does Thumb -> Thumb. So no Arm mode and it only runs on the same arch as it's emulating... and isn't much faster.
Uh...
32blit with a Pico W connected via I2C that can download games directly from BlitHub.
I should maybe dig up the code for this... Probably got the firmware changes in somewhere though.
A Game Boy emulator with a JIT recompiler is a silly idea and I didn't...
Okay I did. Has x86(_64) and Thumb targets, passes all the same tests and is ~1.2x-2x faster... which is completely unnecessary as it could already do 80-100x speed.
I guess if nothing else, I learned something?
PGA2040-based GBA Cartridge reader that presents the cartridge as a USB mass storage device with two files. (Goes well with having an emulator lying around...)
Built a giant mess of wires a month earlier that sort-of worked sometimes.
Found a mostly-working +2 and the Game Boy's CPU is similar so... this happened.
Doesn't look like I released anything though...
Use a PicoSystem as a basic gamepad! (Because real gamepads are a massive pain to get working...)
(Can't really get a good picture for this so imagine the screen is off...)
Mostly just a demo of a very colourful house at this point. Added some furniture a bit later.
A little demo of falling snow, because someone bought an Interstate 75 + a panel and I couldn't just leave it lying around doing nothing!
Also made me realize that I have Twitter notifications turned on, as people apparently liked that one.
Okay, 99% of the code here is PicoDVI, which is very cool but not mine...
Connecting a GBA to a big screen with a < £4 microcontroller board (and a lot of jumper jerky) still seems worth mentioning here though.
Tweeted a few more pictures of this.
Also built a Tiny2040-based link cable (multiplayer-mode PIO hacks). Which was very useful for booting test ROMs for emulator stuff...
Ended up back here after just over a year (and a lot of lessons learned from improving the non-advance version...)
After a few more months of hacking it now actually works (most of the time) for the games I own.
Somehow still runs on in the 32blit (with a little hacking) and isn't entirely unusable... (That wasn't a goal while working this emulator as I thought it was unreasonable, but apparently not?)
DaftBoy32 ported to run on the PicoSystem (with everything from the 32Blit version... except the performance). Also included a huge amount of accuracy and performance fixes.
(A more hacky partial PicoSystem port existed in July, and an even hackier "pico" port existed in April.)
Existed as a bunch of hacks for most of the year (running on a Pico Explorer Base, then a VGA Demo Board). Became a lot more useful with the PicoSystem and ended up getting merged. (It's almost like the SDL Emscripten port again!)
(The date is when it was merged)
I still have a bunch of patches for using the SDK on pretty-much everything that has a screen of some kind....
"Mode7" style kart racing game. Still a bit unfinished (content problems as usual).
Was ported to the PicoSystem later, surprisingly.
Another 32blit port of some old JS stuff, this time my unfinished Tetris clone. (The original code was called "ketris", if you recognise that you win a prize.)
Was ported to the PicoSystem later.
A 32blit remake of the best word game on this site. Has most of the game, though is missing anything related to leaderboards.
Source is here. (Unlike the original JS/PHP version which is still super-secret... or something)
An attempt to write a GBA emulator based on DaftBoy. Got as far as running a game in about a month... with no sound and extremely basic display handling (no rotating/scaling anything).
Also really slow... and inaccurate.
A 32Blit Game Boy Emulator.
Needed something to do after DOOM, decided to build an emulator. Got to the point of running Tetris in about a week. And then significantly longer fixing bugs...
Not the most accurate emulator ever, but does run the few ROMs I had around to test with.
In July/August it got (partial) Game Boy Color support (and a pile of fixes).
The source was released in Jan 2021... with even more fixes!
It didn't run DOOM... It does now!
I think this is my first port of anything. It involved a lot of memory trimming and allocation adjustments. Also resulted in more API improvements, including adding a palleted scren mode to the API.
Get the source here.
(Image is from an early video, it does fill the screen now.)
The logical next step after audio, right?
This was made easier by the fact that the hardware has a JPEG decoder, just had to add an API for it...
Get the source here.
(Yes, the screenshot is from the music player. The UI is mostly the same and if a video was playing it would just be a picture of a video...)
MP3/Ogg Vorbis player for the 32Blit console.
Wanted to see if it was practical to stream audio into the recently added audio buffer support. After finding a small MP3 decoder this grew into a full music player app.
Also resulted in some API improvements and bugfixes for the 32Blit code.
Get the source here.
This started as something I was working on for myself, but quickly ended up with more contributors.
The date above is when it was merged upstream, which was slighly unexpected as this was one of my first open-source projects.
