First of all, regardless of the system, a lot of gameplay happens online these days. People are spread out, pandemics happen etc.
And sometimes chat plus rolling real dice isn't enough, for which "Virtual Tabletops" were created. Let's take a popular one as a prime example. Foundry VTT[1] is a self hosted node application that you actually buy, no subscription (there are subscription-based hosters, if you don't have the skills/server for that). And it exposes a lot of its internal API to extension writers. So you can do almost anything to extend it, to local macros (e.g. click one button and your big bad superhero enemy icon turns invisible, an explosion happens and damage is rolled), extension modules (add UI elements, dialogs etc.) to whole rulesets.
It's a tinkerer's dream and for people inclined that way a good way to spend some time between games. You might start your "career" with an existing adventure, and then spend the preparation time not on drawing the map, but importing that setup into your virtual game environment, so that everything runs smoothly. Just like in the olden times, one would buy the miniatures and carefully paint them.
Speaking of drawing maps, I also wasted way too much time in Dungeondraft[2], a rather neat map drawing program. It uses the Godot toolkit and lets you draw with blended terrain textures and line segments that turn into walls and doors. The result is good looking, even if you don't have any drawing skills. Way different from the graph paper looks of the 80s.
As for rules systems, you'll find that they almost mirror the programming language confusion and associated camps. Everything started with strict subdivisions, like the infamous "levels" that measured your hero's progress (something between a military rank and a Campbellian hero's journey) and classes (wizard/warrior etc., basically your military unit type or Jungian archetype). Compare that to the structured programming era. Progress over what happened before, still used by some with few changes, but maybe not the non-plus-ultra of the field. (And with some opinionated writing that still gets passed around as gospel, although compared to RPGs, Dijkstra was at least right)
That's D&D, Pathfinder, and for the retrocomputing charm, everything that falls under the OSR (Old School Renaissance), i.e. old versions of D&D, often slightly hacked.
In imperative programing, you focus on the computer model, and opposed to that you get your languages that feature more on the math-y/theoretical side of things. In games, that would be those rule set that focus more on the story as it happens on the table, rather than rules as the "physics engine" from which those stories emerge. That's our functional programming side of RPG-dom. Quite en vogue these times, so a lot of the games that are mentioned in the video and the whole "Powered by the Apocalypse" thread in this post would fall under that. As with PLs, those can be rather "conventional", but with different approaches to purely focused on telling stories, just like you can go from ML to Coq.
As your third tier, not as popular as it once was, but still part of a lot of systems, you got the trend where you wanted to escape the class/level simplicity and actually make your "physics engine" more realistic. This often resulted in games where creating your hero didn't just mean picking a vague class and starting out at "1st level", but spending a budget of "points" on various properties, allowing more freedom and fewer artificial constraints. Combat and other decision making endeavors were often more complex and tried to adhere to real-world elements. So you didn't just have one "attack roll" like in a board game, you had attacks, parries, determined the location where you hit your fencing partner, could even do specific martial arts maneuvers etc. Let's call this the Object-Oriented phase of RPGs. Mostly because it got popular in the same time and we need to fill out our pillars, not because it's a literal match.
And just like OOP it's both not as popular anymore, but has crept in a lot of other systems. "Point-buy" is regarded as more fair than just rolling dice to see how good your hero starts out, and thus even used in games that focus more on story. And some of the more "real world" games elements are used, even in old-fashioned class/level games.
D&D is basically the C family, and you get everything in there, from modern C++, where you try to stick to new and clean approaches, but often the old legacy issues shine through (Pathfinder) to people trying to keep it simple yet somewhat modern (C11 => D&D 5th edition), to some people arguing that there never was anything wrong about ANSI or even K&R C (clones of old systems like Old School Essentials, Labyrinth Lord and OSRIC). Heck, even B seems to be around ("Zero edition D&D")
Pathfinder 2nd edition might be close enough to Rust (or Go?). Enthusiastic fanbase, tries to stick with the gameplay established by D&D, but be more safe/balanced about it. Looks a bit weird, but you get used to it.
FATE is Python. Tries to be a bit functional, a bit OOP, a bit traditional, but above all easy to use.
GURPS was Ada. Tried to make it all thoroughly designed and militaristic/industrial. Never quite accepted.
And these days you get a whole lot of new "languages" that people try to sell you on, often half implemented, not substantially different from others.
Heck, there's even ML happening, with "GM emulators" and "solo engines". With prettty much the same results.