There's a tiny section of the video game market that is developing games like it's the 90s/00s. As far as I am aware, none of these games are "pure", but lean heavily into the aesthetic and tech available at the time, and take advantage of the advances made since then.
I'm currently developing Metropolis 1998 https://store.steampowered.com/app/2287430/Metropolis_1998/
The game is 2D (sprite based), stylized in the classic isometric perspective that was common in the 90s/00s (Rollercoaster Tycoon, SimCity 2000/3000, XCom, Zoo Tycoon, etc). A lot of these games used 3D models to output sprites, though I decided to take the hand-pixeled approach.
Other games in this area include:
D.O.R.F Real Time Strategy https://store.steampowered.com/app/2388620/DORF_RealTime_Strategic_Conflict/
A beautiful looking RTS reminiscent of Command and Conquer and Starcraft.
Factorio https://store.steampowered.com/app/427520/Factorio/
I think everyone knows of this game.
If I missed any, please list them in the comments!
https://www.youtube.com/watch?v=t2kdKB18c7I&t=204s
Even something as simple as "what is the algorithm to determine which isometric tile the user is clicking on in 2D/3D space" had to be solved from scratch :(
Recently I added multi-floor buildings, which transitioned the game into 3D space (where as before, flat terrain and single story buildings meant the Z (height) position of everything was 0). Some of the functionality of the game relied on looking up what pixel (object) was under the mouse. This was relatively easy to do before building height. I looked up all the objects in a cone moving towards the camera (so down in screen space) and determined which one was "closest" to the camera by sampling the sprite image and comparing the world.y position.
This method falls apart when there are multi-story buildings, since a really tall building could be blocking the view of something further up the map. I came up with a solution that uses a 2nd buffer that draws everything to a tiny 3x3 texture, but instead of drawing the sprite, it draws a UUID encoded as pure color (by using the Vertex shader color property). On the CPU side of things, I take this color, convert it back into an unsigned int, look up the element position in a (C++) vector, and grab the basic properties of the object from there. The reason the texture has to be so small is because it is stored on the GPU, and needs to be converted into an image format for the CPU. It would be very expensive to send back the entire screen as an image to the CPU every frame.
Source: I was a video game developer in 1998.
Talking about late 90s early 2000s I'm hoping at some point prerendered backgrounds come back just like prerendered sprites. Some fixed function graphics programming would be fun too.