Oh well
I personally have been looking off and on at providing an "app relay" using it, where people can get an OSS, self-hostable (if desired), zero config way to remotely access their app/data on their network. This would be separate than a "network relay" (a la Tailscale), as this is done selectively as part of the application server and client, requires no knowledge or configuration as the user, and exposes a much smaller surface area.
Here's an example of my implementation of the original Tamagotchi: https://news.ycombinator.com/item?id=45737872 (https://github.com/agg23/fpga-tamagotchi)
Nothing special happens when fast forwarding, other than you can kill your Tamagotchi very quickly :P
I've talked to the Amaranth people. I'm not incredibly interested in using real programming languages to write HDL, but I think I like keeping programming and hardware separate in some ways.
The Analogue Pocket is fantastic for getting started with FPGAs because everything you need is built into the device and it's not "too" expensive. You do lack Pmods. There is the fully open source Game Bub (https://www.crowdsupply.com/second-bedroom/game-bub) as a cool new platform to target, but it will have orders of magnitude fewer users than the Pocket. NOTE: I am extremely biased about the Pocket; I have a working relationship with Analogue and own the main platform ports to the Pocket (for example NES, SNES, and many more).
https://github.com/agg23/fpga-tamagotchi
After being thrust headfirst into FPGA development thanks to the Analogue Pocket, my first from scratch creation was a gate level implementation of the original Tamagotchi toy.The core, running on both the Analogue Pocket and MiSTer platforms, lets users re-experience the very first Tamagotchi from 1996 with accurate emulation, but modern features. The core has savestates (which is much harder...
From my perspective I was just interested in the excellent industrial design, which is something that is virtually impossible for a DIY setup to attain.
I recently had a friend with similarly good vision try it out, and he didn't think it was so bad until I mirrored the Mac display, and he agreed it was unusable.
Very disappointing for me, as this was something I was looking forward to for a long time.
It seems like the tool is missing some of the better deals, like Optiplex 3070 with 9th gen i5s for ~$100, entire working system included (this is what I ended up buying).
----
Now, 8 years later, I'm really wishing I had designed my own ring. I would prefer to avoid the cliche metals (silver, gold, platinum), and I can't wear silver anyway (allergic). I would really like to find an interesting or unusual metal (scientifically or just in general) that isn't going to cause issues due to its hardness if my finger swells (titanium or tungsten are very difficult to cut off in those situations).
Does anyone have any material suggestions?
I discovered recently that I can focus fine on my hand a few inches from my face in real life, but the default onscreen keyboard position on Vision is too close for me to see clearly, even though its "much further away".
It may sound like shilling, but the Analogue Pocket is actually an excellent development platform because it's everything all in one; you don't need to figure out how to take input, load data, or output to HDMI, because that's all taken care of you automatically. Now you pay for that in having a $200-250 price tag, plus ~$50-70 for your JTAG adapter, but I think it's excellent for starting.
For OSS, I would probably recommend a Lattice FPGA. Gowin FPGAs are really, really cheap (Tang Nano 9k), and _partially_ support an OSS toolchain, but it's missing many core components, and I've actually found bugs in the hardware (confirmed by others), so probably stay away.
The DE-10 Nano is very capable, though fairly sought after at this point. It has a decent amount of IO, and can run the MiSTer retrocomputing project, which has the largest collection of OSS cores out there.
----
However, probably before you even buy any hardware, play with simulations. Choose your HDL (Verilog is US focused, VHDL is EU focused) and choose a simulator. For VHDL, you can use GHDL and GTKWave for an entirely OSS setup. For Verilog, I would recommend downloading the closed source Intel ModelSim, but you can also produce very fast, C++ controlled simulations using Verilator.
In any case, start simulating and looking at waveforms. Debugging multiple sets of nets at once is a very interesting experience and is at the core of what you're doing when working with FPGAs (verification is something like 80-90% of the time), so you can learn a lot without any hardware just working on that. If you use Verilator, you can have psuedo LEDs or even a display to draw on.
Now for the vast majority of users, this does not matter at all. As much as I like to think I can tell, it's probably placebo or the slightest feeling like something is not right. But I think it's a worthwhile reason to have a different method of replicating these old and eventually dying machines, and it's much more intellectually interesting as you say.
I have always been a big advocate of learning while doing, especially in software. Find something, preferably small, that you want to build (your Pong), and work on making it a reality. Maybe it's making Snake entirely in HDL. Maybe it's playing around with LiteX on your preferred development platform so you can build something cool with the RISC-V processor (I don't suggest this though, start with learning a normal HDL). Maybe it's simply looking through one of the existing retrocomputing cores, trying to figure out how stuff ticks.
Until you get to the CPU design level, the general concepts you'll encounter will be fairly simple. I think it's enough to just play around with blinking lights, learning how parallel synchronous logic works, relative to how we think of software working.