WEBVTT - How Video Game Emulators Work 0:00:04.160 --> 0:00:07.160 Get in texts with technology with tex Stuff from how 0:00:07.240 --> 0:00:13.960 stuff works dot com. Hey there, and welcome to tex Stuff. 0:00:14.000 --> 0:00:17.439 I'm your host, Jonathan Strickland, senior writer for house stuff 0:00:17.480 --> 0:00:20.560 Works dot com. And before I get into any of 0:00:20.560 --> 0:00:22.560 this episode, I would like to let you guys know 0:00:23.040 --> 0:00:26.439 I've got a cold. It's a bad one. Earlier this 0:00:26.520 --> 0:00:30.479 week I was unable to speak. The people around me 0:00:30.560 --> 0:00:33.560 rejoiced because they got peace and quiet for a minute. 0:00:34.280 --> 0:00:36.960 But just letting you guys know, in case you're wondering, 0:00:37.000 --> 0:00:39.760 like why is Jonathan sound so weird or rather more 0:00:39.840 --> 0:00:43.720 weird than he normally sounds, is because I am recovering 0:00:43.800 --> 0:00:47.640 from said cold and my voice is probably somewhere between 0:00:47.680 --> 0:00:51.479 eighty and nine percent back. So um, got that out 0:00:51.520 --> 0:00:53.960 of the way. Today's episode is actually coming to us 0:00:53.960 --> 0:00:58.680 courtesy of a little listener mail, or actually it's from 0:00:58.680 --> 0:01:02.040 a listener tweet. I remember the tech stuff twitter handle 0:01:02.240 --> 0:01:05.880 is text stuff hs W, so if you tweet me there, 0:01:06.440 --> 0:01:09.479 I will see it. Uh. And this one comes from Dan, 0:01:09.600 --> 0:01:12.120 who says I'd love to hear a show on how 0:01:12.240 --> 0:01:16.240 video game emulators work. So today we're gonna explore what 0:01:16.319 --> 0:01:20.480 an emulator is, why they're necessary, and how they work. Now, 0:01:20.520 --> 0:01:21.920 first of all, I should say there are a lot 0:01:21.920 --> 0:01:25.480 of different types of emulators. Uh, it's not just for 0:01:25.560 --> 0:01:28.880 the video game world, but I'm gonna focus specifically on 0:01:29.280 --> 0:01:31.600 video games. And you might wonder, all right, so what 0:01:31.680 --> 0:01:34.200 is an emulator. Well, it does what it sounds like, 0:01:34.280 --> 0:01:38.800 It emulates some other technology, which means it's attempting to 0:01:38.880 --> 0:01:42.960 replicate how another technology works or or what it does. Now, 0:01:43.040 --> 0:01:46.199 sometimes the emulator does this in a very different way 0:01:46.319 --> 0:01:49.520 than the original technology did. And more often than not, 0:01:49.600 --> 0:01:53.200 an emulator relies on software at least partly to replicate 0:01:53.240 --> 0:01:57.240 a particular piece of a hardware's functionality. So you can 0:01:57.240 --> 0:02:02.320 think of emulators as being at least partly of actual machine. Uh, 0:02:02.360 --> 0:02:05.760 some of the components may actually be physical parts that 0:02:05.880 --> 0:02:11.040 are original to whatever the technology you're trying to emulate was. 0:02:11.600 --> 0:02:14.600 Other components are going to be purely software. And it's 0:02:14.600 --> 0:02:18.080 helpful to use a little analogy here to understand what 0:02:18.200 --> 0:02:21.840 an emulator tries to do. So let's say you've got 0:02:21.880 --> 0:02:24.240 two people, and you know what, let's give them some 0:02:24.360 --> 0:02:26.280 random names. So, just picking out of the air, I'm 0:02:26.280 --> 0:02:29.920 gonna go with Josh and Chuck. Now, both Josh and 0:02:30.040 --> 0:02:33.000 Chuck are in a jungle, but they are separated, so 0:02:33.080 --> 0:02:38.400 they're each individually in a jungle. Both are running from something. Uh, 0:02:38.480 --> 0:02:41.600 let's say they're being chased by aggressive badgers. So both 0:02:41.639 --> 0:02:44.440 of them have managed to put some distance between themselves 0:02:44.520 --> 0:02:47.600 and the furballs of fury chasing them. And then each 0:02:47.639 --> 0:02:50.720 of them individually comes to the edge of a pit 0:02:51.040 --> 0:02:53.800 two different pits, So Josh is at one pit, Chuck 0:02:53.919 --> 0:02:56.600 is at a different pit. There's no way around the pits. 0:02:56.680 --> 0:02:59.320 There's too much overgrowth on either side, so you have 0:02:59.360 --> 0:03:01.760 to go over it somehow, but you can't go around, 0:03:02.120 --> 0:03:03.760 and they each have a short amount of time to 0:03:03.800 --> 0:03:07.760 figure out a way around or rather over, their respective pits. 0:03:08.639 --> 0:03:11.960 So Josh decides what he's gonna do is fashion a 0:03:12.040 --> 0:03:14.920 makeshift bridge out of some branches on the ground and 0:03:14.960 --> 0:03:17.080 some vines, and so he binds them together and he 0:03:17.400 --> 0:03:20.560 lays the bridge across the pit. He crosses gingerly across, 0:03:20.639 --> 0:03:23.359 because you know, we know that Josh's sense of balance 0:03:23.480 --> 0:03:27.120 is somewhat precarious under the best of circumstances, gets to 0:03:27.160 --> 0:03:29.000 the other side, and then he kicks the bridge back 0:03:29.040 --> 0:03:31.360 into the pit so that the badgers can't just follow 0:03:31.440 --> 0:03:35.360 him across, and then he continues on his merry way. Meanwhile, Chuck, 0:03:35.520 --> 0:03:38.360 on the other hand, uses a vine to tie it 0:03:38.400 --> 0:03:40.440 to a branch and use that as kind of a 0:03:40.480 --> 0:03:43.960 grappling hook. He tosses it up into the limbs overhead 0:03:43.960 --> 0:03:47.520 and it catches, and so then he swings Tarzan like, 0:03:47.680 --> 0:03:51.080 bellowing the whole time, and he gets to the other side. 0:03:51.320 --> 0:03:55.440 Then he jerks the vine and dislodges the branch so 0:03:55.520 --> 0:03:57.280 that it falls down and throws that into the pit 0:03:57.440 --> 0:04:01.080 just in case. Badgers can also swing across pits, but 0:04:01.160 --> 0:04:04.360 that's because he has not yet read how Badgers work 0:04:04.440 --> 0:04:08.160 on How Stuffworks dot Com. So both Josh and Chuck 0:04:08.560 --> 0:04:11.920 got across their respective pits, but they both did so 0:04:12.000 --> 0:04:14.960 in very different ways. The end result was the same, 0:04:15.720 --> 0:04:19.240 but the pathway was different. That's sort of what emulators do. 0:04:19.320 --> 0:04:23.960 They're meant to produce a result that's identical to another technology, 0:04:24.000 --> 0:04:27.160 even if the pathway to get there is very different. 0:04:27.800 --> 0:04:30.280 A video game emulator is really meant to replicate how 0:04:30.279 --> 0:04:32.839 a specific machine works so that you can play the 0:04:32.880 --> 0:04:36.600 games that were designed for that machine, typically on a 0:04:36.600 --> 0:04:40.400 computer a PC. So an emulator could be a specific 0:04:40.560 --> 0:04:44.600 arcade game emulator, like for a very specific title, or 0:04:44.640 --> 0:04:47.680 it could be a video game console emulator, which means 0:04:47.720 --> 0:04:51.120 it could act like a video game console virtually and 0:04:51.160 --> 0:04:54.200 you could play the games made for that console on 0:04:54.279 --> 0:04:56.200 your computer. The end result is that you can play 0:04:56.240 --> 0:04:59.679 those games meant for one device on a totally different device. 0:04:59.839 --> 0:05:02.680 And and as I said before, typically we're talking about 0:05:02.720 --> 0:05:06.640 a personal computer. Now, emulators are not the same thing 0:05:06.800 --> 0:05:11.880 as ports. Supported game is one that developers originally created 0:05:12.040 --> 0:05:15.839 for one architecture system, and then they adapt that game 0:05:15.880 --> 0:05:20.160 for a totally different system. So the easiest example is 0:05:20.279 --> 0:05:23.520 a game that originally comes out on the PlayStation might 0:05:23.560 --> 0:05:27.560 get ported to the Xbox. These are totally different architectures. 0:05:27.600 --> 0:05:30.640 The video game consoles work in very different ways, so 0:05:30.680 --> 0:05:36.120 you can't just reformat and put it on an Xbox 0:05:36.160 --> 0:05:38.360 one disc and expected to work. You actually have to 0:05:38.520 --> 0:05:41.120 redesign parts of the game. That's what porting is all 0:05:41.160 --> 0:05:45.880 about now. Because each system, whether it's Xbox or PlayStation 0:05:45.960 --> 0:05:48.960 or mac Os or Windows, works in a very specific way. 0:05:49.040 --> 0:05:53.520 Those programs are not compatible, but apport can be reworked 0:05:53.760 --> 0:05:56.480 so that it will operate on those new systems. Now, 0:05:56.480 --> 0:05:59.120 an emulator is different. An emulator can run a game 0:05:59.160 --> 0:06:02.520 mint for once system on a totally different system because 0:06:02.560 --> 0:06:05.760 the emulator is doing the work. So instead of giving 0:06:06.040 --> 0:06:08.960 a game to a new group of developers and saying 0:06:09.360 --> 0:06:12.480 I need you to make this version of the game 0:06:12.520 --> 0:06:15.839 playable for this other system, you have a piece of 0:06:15.880 --> 0:06:20.600 software that pretends that it is the other system, and 0:06:20.680 --> 0:06:23.360 that way you don't have to have developers change the 0:06:23.400 --> 0:06:26.800 code of the end of the original game. You do 0:06:26.839 --> 0:06:30.159 have to have developers create the emulator. So it really 0:06:30.200 --> 0:06:33.599 just shifts the work from adapting a game to a 0:06:33.640 --> 0:06:37.320 different system to adapting an emulator to be able to 0:06:37.400 --> 0:06:41.039 work on whatever target machine you're talking about. Like I said, 0:06:41.080 --> 0:06:44.560 typically PC, more often than not it's a Windows based PC, 0:06:44.720 --> 0:06:47.200 but you also see them for Unix and mac os, 0:06:47.240 --> 0:06:50.400 so it's not like it's it's exclusive to Windows machines. 0:06:51.800 --> 0:06:56.000 Now it's necessary because video game consoles and even arcade 0:06:56.040 --> 0:06:59.560 games like the old arcade game cabinets, they have specific 0:06:59.640 --> 0:07:03.720 hardware and software architecture to them. So some of those 0:07:03.720 --> 0:07:06.920 old arcade machines don't really even have much software at all. 0:07:06.960 --> 0:07:11.640 It's like the lightest level of software. It's mostly circuitry, 0:07:11.800 --> 0:07:16.960 like hard coded circuitry. The game itself is represented in 0:07:17.000 --> 0:07:21.320 the circuits that are on the board within the arcade cabinet. 0:07:21.960 --> 0:07:24.920 It's kind of like the old cartridge based systems if 0:07:24.960 --> 0:07:27.640 you had one of those, like the old Nintendo Entertainment 0:07:27.640 --> 0:07:31.800 System or Super Nintendo or the Tari. Those are video 0:07:31.840 --> 0:07:35.280 games that would be programmed onto a circuit board that's 0:07:35.320 --> 0:07:38.800 housed inside of a cartridge, and you insert the cartridge 0:07:38.840 --> 0:07:42.720 into the video game console and some contacts between the 0:07:42.760 --> 0:07:46.600 console and the cartridge allow the console to read that 0:07:46.680 --> 0:07:50.520 information and then you're able to play the game. Uh. 0:07:51.320 --> 0:07:56.880 Obviously you don't have, for most PCs, a cartridge based 0:07:56.920 --> 0:08:00.920 system that can accept these games in this way. Now, 0:08:00.920 --> 0:08:04.760 in the olden days, arcade games contained a circuit board 0:08:04.880 --> 0:08:09.360 unique to that particular game. So, in other words, a 0:08:09.360 --> 0:08:13.000 an Asteroids machine was an Asteroids machine. That's all there 0:08:13.040 --> 0:08:15.800 was to it, because the circuit board had the Asteroids 0:08:15.880 --> 0:08:19.080 game on it. If you opened up a Pacman machine 0:08:19.120 --> 0:08:21.200 and you opened up a Donkey Kong machine, you'd find 0:08:21.240 --> 0:08:23.800 two different circuit boards. The pac Man one of the 0:08:23.840 --> 0:08:26.600 Donkey Kong one would be unique to those arcade games. 0:08:27.200 --> 0:08:32.120 They did have a very low level of software on 0:08:32.280 --> 0:08:36.400 the machines on the circuit boards called BIOS now that 0:08:36.440 --> 0:08:40.640 stands for Basic Input output system, and really it's just 0:08:40.679 --> 0:08:44.280 a foundational software layer. It's really just meant to be 0:08:44.400 --> 0:08:49.120 responsible for managing the relationship between input devices like a 0:08:49.160 --> 0:08:51.880 push button or a joystick or that sort of stuff, 0:08:52.640 --> 0:08:58.040 and the output devices like the monitor or even just 0:08:58.160 --> 0:09:01.880 what the game is supposed to do whenever you enact 0:09:02.200 --> 0:09:05.920 on those input devices. So the input could be a 0:09:06.000 --> 0:09:09.280 jump button, for example, you press the button and the 0:09:09.360 --> 0:09:12.920 output is you see your character jumping on the display. 0:09:13.520 --> 0:09:16.319 But keep in mind, the actual output is really the 0:09:16.360 --> 0:09:20.880 code for jumping and a signal to the arcade machines display. Right, 0:09:20.920 --> 0:09:24.040 the display is not making your character jump. That's being 0:09:24.080 --> 0:09:27.720 controlled by the code of the arcade machine itself. It's 0:09:27.800 --> 0:09:30.640 reflected on the monitor in a way that you can 0:09:30.679 --> 0:09:35.000 see by having the little character jump up in the air. Now, 0:09:35.040 --> 0:09:39.000 the game's circuit board handled everything else in those old 0:09:39.040 --> 0:09:43.360 machines besides that input output. The hardware was handling everything. 0:09:43.840 --> 0:09:46.200 It was just programmed directly onto the circuit board that 0:09:46.280 --> 0:09:50.640 include the game's sound, its graphics engine. It's logic if 0:09:50.640 --> 0:09:52.840 you had an arcade cabinet and you wanted to switch 0:09:52.880 --> 0:09:55.920 out games. Let's say you've got a Pacman cabinet and 0:09:56.000 --> 0:09:58.360 you think, I'm gonna put Donkey Kong in this cabinet 0:09:58.360 --> 0:10:00.439 and I'm gonna I want to switch out the games. 0:10:00.480 --> 0:10:02.520 What you had to do was gut the machine. You 0:10:02.520 --> 0:10:06.559 had to take all that circuitry and those connections out 0:10:06.679 --> 0:10:10.000 of the machine, the pac Man machine, and replace them 0:10:10.040 --> 0:10:13.520 with the ones from a Donkey Kong machine. You couldn't 0:10:13.559 --> 0:10:16.000 just swap out a certain element. You had to do 0:10:16.080 --> 0:10:20.960 pretty extensive surgery. Uh. It took some time, usually, you know, 0:10:20.960 --> 0:10:23.640 a half hour an hour easy to to switch these 0:10:23.679 --> 0:10:27.200 things out. Later on, it got a little simplified. First 0:10:27.240 --> 0:10:30.920 it got simplified in the the adoption of some more 0:10:31.240 --> 0:10:35.360 standardized connectors. So that meant that you could start to 0:10:35.400 --> 0:10:38.359 disconnect a circuit board from the rest of a system, 0:10:38.440 --> 0:10:42.280 and assuming that the control scheme is similar from the 0:10:42.280 --> 0:10:45.680 old game to the new game, you could plug the 0:10:45.760 --> 0:10:48.640 new circuit board into a cabinet and it would work 0:10:48.640 --> 0:10:51.559 pretty well. Uh. Now, obviously that only works if your 0:10:51.559 --> 0:10:54.839 control scheme is the same. So, for example, if you're 0:10:54.840 --> 0:10:57.920 playing pac Man, there's no jump button, right, there's a 0:10:58.040 --> 0:11:00.680 player one, a player two, and then there's the joystick 0:11:00.760 --> 0:11:04.840 that has for motion control, and you just control the 0:11:04.840 --> 0:11:08.080 the pac Man character that way. But let's say you 0:11:08.080 --> 0:11:11.240 wanted to play Centipede. Centipede is a very different type 0:11:11.280 --> 0:11:14.160 of game. Has a rollerball controller, so you have a 0:11:14.200 --> 0:11:17.320 ball that you uh, you swipe and you can move 0:11:17.360 --> 0:11:19.920 your character that way, and it has a fire button 0:11:20.000 --> 0:11:23.360 where you shoot whenever you press the button. So if 0:11:23.400 --> 0:11:27.240 you were to switch out the pac Man to the 0:11:27.320 --> 0:11:32.040 Centipede boards, assuming that they had these universal connectors, you 0:11:32.120 --> 0:11:35.000 still would have to switch out the control system as well, 0:11:35.200 --> 0:11:37.520 or else you wouldn't really be able to control the 0:11:37.559 --> 0:11:39.880 game Centipede the way it was meant to be played, 0:11:40.320 --> 0:11:42.960 particularly since you wouldn't have a fire button, that would 0:11:43.000 --> 0:11:47.960 be a problem. Later on, arcade manufacturers would create machines 0:11:48.000 --> 0:11:50.120 that had the basic hardware set up so that different 0:11:50.160 --> 0:11:52.720 games could be plugged into the system, more like a 0:11:52.800 --> 0:11:56.079 video game console. So this was even simpler than the 0:11:56.160 --> 0:12:00.440 universal kind of standardized controls UH. This was more about, 0:12:00.480 --> 0:12:05.280 like uh, a set structure where you plug in a 0:12:05.400 --> 0:12:08.840 chip essentially that has the game on it and everything 0:12:08.840 --> 0:12:11.439 else remains the same, so kind of like a video 0:12:11.440 --> 0:12:13.960 game console, where if you're playing a Nintendo and you 0:12:14.000 --> 0:12:20.160 wanted to stop playing Super Mario Brothers instead play Gumshoe. 0:12:20.600 --> 0:12:24.040 Then you could turn off the console, pull one cartrid, 0:12:24.080 --> 0:12:25.800 shop put the other cartridge, and turn it on and 0:12:25.800 --> 0:12:27.959 there you go. Same sort of thing with these old 0:12:28.040 --> 0:12:31.200 arcade machines. Once they got to this level of sophistication, 0:12:32.480 --> 0:12:33.520 it was still a bit of a pain in the 0:12:33.600 --> 0:12:35.880 butt because he still had to open everything up and 0:12:35.880 --> 0:12:38.200 and get in among all the wires and stuff. But 0:12:38.200 --> 0:12:41.440 it was still way faster than the old days where 0:12:41.440 --> 0:12:45.880 you had to replace everything. Essentially. Now the games themselves 0:12:46.080 --> 0:12:50.320 are called ROMs r O M. S Now r O 0:12:50.559 --> 0:12:54.239 M is an acronym. It stands for read only memory. 0:12:54.600 --> 0:12:57.920 That meant the player or anyone else couldn't write anything 0:12:57.960 --> 0:13:01.040 to the game. Now, they might have something on the 0:13:01.040 --> 0:13:04.680 circuit board, some some temporary memory in the arcade machine 0:13:04.679 --> 0:13:07.000 that would allow players to put in initials next to 0:13:07.080 --> 0:13:10.640 high score, and that would be stored in that memory chup, 0:13:10.720 --> 0:13:13.679 but the game itself was immutable. You could not change 0:13:13.800 --> 0:13:16.840 the game. It was the computer equivalent of being set 0:13:16.880 --> 0:13:20.760 in stone. So in the emulator world we generally refer 0:13:20.920 --> 0:13:24.960 to game files as in the software that represents that 0:13:25.080 --> 0:13:29.040 game as a ROM. If you've ever used an emulator, 0:13:29.400 --> 0:13:32.960 you're probably familiar with ROMs. And there's a big legality 0:13:33.080 --> 0:13:36.200 question people have when it comes to ROMs, and I'll 0:13:36.200 --> 0:13:38.240 get to that later in the episode. At the end, 0:13:38.640 --> 0:13:42.000 I'm gonna spend time talking about the legality of read 0:13:42.080 --> 0:13:45.640 only memory files and whether or not it is legal 0:13:45.679 --> 0:13:48.320 to download them, But for now, let's just focus on 0:13:48.360 --> 0:13:50.439 the technical side of things. We'll get to the legal 0:13:50.480 --> 0:13:53.920 stuff at the end. So you've got various types of games, 0:13:54.040 --> 0:13:57.480 each designed to run on specific hardware. And there are 0:13:57.520 --> 0:13:59.959 the standalone arcade machines that each had their own pecure, 0:14:00.160 --> 0:14:03.360 your architecture. They're the later arcade machines that could accept 0:14:03.360 --> 0:14:06.160 different chips, with each chip containing a different game. And 0:14:06.200 --> 0:14:08.960 then there are the video game consoles and their proprietary 0:14:09.000 --> 0:14:12.480 game technologies. You even got old computer games that were 0:14:12.520 --> 0:14:15.200 designed to run on slower machines with much less computing 0:14:15.280 --> 0:14:18.839 power than today's PCs. Uh. A lot of those are 0:14:18.880 --> 0:14:22.400 impossible to play on on later machines because they just 0:14:22.520 --> 0:14:25.120 they can't handle the fact that they've got access to 0:14:25.160 --> 0:14:27.640 all that processing power. So you might even need an 0:14:27.640 --> 0:14:33.160 emulator for a PC based game on a PC if 0:14:33.160 --> 0:14:35.560 it's old enough. If it's an old game, you may 0:14:35.640 --> 0:14:37.960 need an emulator in order to run it a virtual 0:14:38.000 --> 0:14:41.760 machine of some sort. Emulators are what let you run 0:14:41.760 --> 0:14:44.600 those games designed for those older or other devices on 0:14:44.640 --> 0:14:48.200 a modern machine. So I've got more to say about this, 0:14:48.720 --> 0:14:51.560 but before I get into it, let's take a quick 0:14:51.600 --> 0:15:04.240 break to thank our sponsor. Alright, we're back now. There 0:15:04.240 --> 0:15:09.600 are two big categories for emulators, and this doesn't depend 0:15:09.680 --> 0:15:12.720 upon the type of console or game you're trying to emulate. 0:15:12.800 --> 0:15:16.160 It's universal. These two big categories are universal no matter 0:15:16.200 --> 0:15:20.800 what system you're trying to emulate. Um so all different systems, 0:15:20.840 --> 0:15:23.960 all different arcade games. Emulators can fall into one of 0:15:24.000 --> 0:15:29.200 two categories. There's low level emulation and there's high level emulation. 0:15:30.120 --> 0:15:33.520 And it might be a little counterintuitive what these mean, 0:15:34.520 --> 0:15:38.120 but with low level emulation, programmers are trying to create 0:15:38.160 --> 0:15:42.560 software and or hardware that can pretend to be the 0:15:42.640 --> 0:15:47.440 emulated hardware. In other words, you're trying to replicate the 0:15:47.520 --> 0:15:52.680 actual mechanics, although it's not mechanical, it's electronic, but the 0:15:52.720 --> 0:15:58.040 actual uh physical process. I guess physical process doesn't really 0:15:58.040 --> 0:16:01.880 work either, right, The actual logical process of the original 0:16:02.200 --> 0:16:06.080 game system or arcade machine. So you want your system 0:16:06.320 --> 0:16:10.400 to look from a high level as close to that 0:16:10.480 --> 0:16:14.320 original system as you possibly can get it. Sometimes that 0:16:14.360 --> 0:16:18.760 actually means including original hardware from the target machine with 0:16:18.920 --> 0:16:21.960 the emulator, so that means you're not just replicating the 0:16:21.960 --> 0:16:24.400 target machine, you're using some of its actual parts. You're 0:16:24.440 --> 0:16:30.360 you're in part rebuilding the actual original machine. In fact, 0:16:30.360 --> 0:16:33.360 the first couple of models of the PlayStation three actually 0:16:33.360 --> 0:16:37.800 contained elements of the PlayStation two inside it in order 0:16:37.840 --> 0:16:40.960 to provide some backwards capability. So if you wanted to 0:16:40.960 --> 0:16:43.440 play a PlayStation two game on one of those early 0:16:43.680 --> 0:16:47.480 PS three models, instead of it using the typical PS 0:16:47.600 --> 0:16:50.880 three equipment inside the console, it would actually hand that 0:16:51.000 --> 0:16:54.400 off to the PS two elements. So it's almost like 0:16:54.480 --> 0:16:58.000 having two different video game consoles in the same box. 0:16:58.880 --> 0:17:01.560 You didn't know it as as a consumer, like, you 0:17:01.600 --> 0:17:04.320 don't see any of that happening. It's all happening inside 0:17:04.359 --> 0:17:08.560 the console. But it wasn't a p S three system 0:17:08.600 --> 0:17:11.679 reading the information and then playing it on your screen. 0:17:11.720 --> 0:17:14.399 It was actually a PS two system housed inside that 0:17:14.480 --> 0:17:20.240 PS three um. So the p S three's core system 0:17:20.359 --> 0:17:23.679 was acting as the emulator, but it was using PS 0:17:23.720 --> 0:17:28.800 two hardware to actually read the information off of disks. Now, 0:17:28.840 --> 0:17:31.800 if you're using something like a Nintendo sixty four emulator, 0:17:31.880 --> 0:17:34.479 the emulators trying to replicate the way the in sixty 0:17:34.480 --> 0:17:37.680 four is hardware worked, and the more sophisticated that target 0:17:37.720 --> 0:17:41.240 system is, the more difficult this is to do so 0:17:41.359 --> 0:17:45.040 with low level emulation, the amount of processing power you 0:17:45.080 --> 0:17:48.080 need on your computer to run the emulator so that 0:17:48.160 --> 0:17:49.920 you can play those games the way they were meant 0:17:49.960 --> 0:17:55.120 to be played. That processing power demand increases as the 0:17:55.160 --> 0:17:59.760 complexity of the video game system you're emulating increases, which 0:17:59.760 --> 0:18:03.119 makes sense, right. The more complicated the system, the greater 0:18:03.200 --> 0:18:09.160 the demands are in processing powers, particularly if the system 0:18:09.240 --> 0:18:14.480 you're trying to emulate is remarkably different from PC architecture, 0:18:15.119 --> 0:18:19.080 because your processors having to handle all of those differences 0:18:19.840 --> 0:18:22.600 and it ends up creating a bigger drain on the 0:18:22.640 --> 0:18:27.240 processors ability. So if you've ever played a video game 0:18:27.240 --> 0:18:30.040 emulator and you've run a game and you're thinking this 0:18:30.160 --> 0:18:33.040 thing is slow as molasses. I'm barely able to get 0:18:33.080 --> 0:18:37.240 this character moving, it's probably because you're experiencing that problem 0:18:37.320 --> 0:18:42.000 that the emulator is probably a low level emulator. It's 0:18:42.000 --> 0:18:45.120 trying to replicate that original system as closely as possible, 0:18:46.080 --> 0:18:49.280 and as a result, your processor is having to work 0:18:49.720 --> 0:18:52.440 super hard to keep up, even though the game might 0:18:52.480 --> 0:18:55.800 be fairly simple. It can be very frustrating because you 0:18:55.840 --> 0:18:58.840 might be playing a game that came out in like 0:18:58.920 --> 0:19:02.399 the late eighties, and you're thinking, it's twenty seventeen. My 0:19:02.480 --> 0:19:05.760 computer should be able to run this with no problem. 0:19:05.760 --> 0:19:09.399 But the truth is the processors trying to handle a 0:19:09.520 --> 0:19:14.440 system so different from itself that that's what's causing the slowdown. 0:19:14.560 --> 0:19:18.359 I experienced this with a friend who had uh A 0:19:18.760 --> 0:19:23.119 a an arcade emulator, and he's had ghosts and goblins 0:19:23.280 --> 0:19:25.159 on there. And I love that game. I loved it 0:19:25.160 --> 0:19:27.600 when it came out, but as I started to play it, 0:19:27.920 --> 0:19:31.119 I thought, this game is way slower than I remember it, 0:19:31.160 --> 0:19:34.320 and I just remember getting incorrectly. Nope. Turned out it 0:19:34.359 --> 0:19:39.000 was because the emulator was putting too great a demand 0:19:39.240 --> 0:19:43.280 on his systems processor and as a result, the game 0:19:43.320 --> 0:19:45.159 I was playing was much slower than what it was 0:19:45.200 --> 0:19:49.520 supposed to be. And it's really hard to make low 0:19:49.600 --> 0:19:53.679 level emulators efficient. Some games and game system systems require 0:19:53.760 --> 0:19:58.400 multiple synchronization processes to make sure all the emulated components 0:19:58.440 --> 0:20:02.080 are working together properly. So the more frequently that happens, 0:20:02.080 --> 0:20:04.639 the more times an emulator has to say, hey, is 0:20:04.680 --> 0:20:07.600 everything all right and send that message out to all 0:20:07.600 --> 0:20:10.600 the different components and wait for a response, the more 0:20:10.640 --> 0:20:15.239 demands it places on that processor. Uh So, if you 0:20:15.280 --> 0:20:18.199 want to have a really good low level emulator, you 0:20:18.240 --> 0:20:22.720 need a a computer with like a screaming fast processor. 0:20:23.760 --> 0:20:26.399 And and that could be again a little counterintuitive. You 0:20:26.480 --> 0:20:29.640 might think, well, this game can run the latest computer 0:20:29.800 --> 0:20:34.240 games with no frame rate issues. Um at the highest 0:20:34.240 --> 0:20:37.040 graphics setting, everything's awesome. But when I try to run 0:20:37.080 --> 0:20:40.400 this emulated game, everything slows down. Why is that? It's 0:20:40.440 --> 0:20:44.600 because of this. Now, then you have high level emulation. 0:20:44.840 --> 0:20:49.119 This is very different. High level emulation simulates the functions 0:20:49.160 --> 0:20:53.919 of hardware, but doesn't try to replicate those functions. So, 0:20:53.960 --> 0:20:56.320 in other words, all it wants to do is get 0:20:56.359 --> 0:20:59.840 to that end result. It doesn't care if it follows 0:20:59.880 --> 0:21:02.120 the same path as the hardware. So this gets back 0:21:02.440 --> 0:21:05.280 to that Josh and Chuck example I gave at the 0:21:05.280 --> 0:21:07.919 top of the show. Both the vine and the bridge 0:21:07.920 --> 0:21:11.000 will get Chuck and Josh across the pit, but they 0:21:11.000 --> 0:21:13.760 do it in different ways. The end result is the same. 0:21:14.119 --> 0:21:17.760 That's what high level emulation aims to do, so we 0:21:17.880 --> 0:21:23.040 call this abstraction. We are able to create an environment 0:21:23.400 --> 0:21:25.560 in which a game will work even if you're using 0:21:25.640 --> 0:21:30.880 totally different hardware because of this level of abstraction. This 0:21:30.960 --> 0:21:35.000 is particularly handy for game developers, not just people who 0:21:35.040 --> 0:21:37.880 want to play games, but people who are making games, 0:21:38.600 --> 0:21:42.359 because you can develop a game for a specific system 0:21:42.480 --> 0:21:47.040 using a level of abstraction, and you can use whatever 0:21:47.040 --> 0:21:50.760 system you prefer to develop on. So let's say you're 0:21:50.760 --> 0:21:55.240 a developer and that you use a Mac as your computer, 0:21:55.720 --> 0:21:59.320 but you're developing a game for the Xbox. A level 0:21:59.400 --> 0:22:02.240 of abstract action allows you to do this on a 0:22:02.320 --> 0:22:06.040 virtual level, so that you're developing an Xbox game in 0:22:06.119 --> 0:22:09.840 a Mac environment and you don't have to have special 0:22:10.160 --> 0:22:13.280 equipment or anything like that. You've abstracted all of the 0:22:13.320 --> 0:22:19.879 elements into a virtual realm. So high level emulation uses 0:22:20.040 --> 0:22:24.959 shorthand for basic operations instead of a specific pathway. So 0:22:25.040 --> 0:22:28.440 a low level emulator would try to replicate the exact 0:22:28.520 --> 0:22:32.080 way a game saves information. For example, a high level 0:22:32.080 --> 0:22:35.240 emulator would just say save this data to the storage drive, 0:22:35.640 --> 0:22:40.720 and firmware would actually handle the transaction. So the software 0:22:40.760 --> 0:22:42.679 hands it off to the firmware that says, all right, 0:22:42.720 --> 0:22:45.480 what's the most efficient way for me to do the 0:22:45.560 --> 0:22:48.280 task I've been asked to do? That puts the least 0:22:48.320 --> 0:22:51.560 demand on the processor. It's kind of like a voice 0:22:51.560 --> 0:22:54.760 activated assistant in a way. As these systems get more robust, 0:22:54.880 --> 0:22:57.919 you can ask for the same information in many different ways. 0:22:58.200 --> 0:23:00.359 So for example, if I had an eye phone, I 0:23:00.400 --> 0:23:03.760 could ask Siri what is the weather like outside? Or 0:23:04.280 --> 0:23:06.800 I could ask Siri is it raining? Now? Both of 0:23:06.800 --> 0:23:09.919 those questions will get me a weather answer from Siri 0:23:10.400 --> 0:23:13.159 because the system can actually handle the different ways to 0:23:13.240 --> 0:23:17.879 request essentially the same information. Hardware abstraction does something similar, 0:23:17.920 --> 0:23:20.440 and it interprets a request and then it does the 0:23:20.520 --> 0:23:24.680 leg work work to fulfill that request. Now, there are 0:23:24.720 --> 0:23:29.600 three main ways that high level emulators simulate hardware functions. 0:23:30.240 --> 0:23:34.200 The first is called interpreting. The emulator will go through 0:23:34.280 --> 0:23:38.240 the code of the game line by line in chunks 0:23:38.320 --> 0:23:41.640 and replicate what the instructions are supposed to do. So 0:23:42.000 --> 0:23:45.280 interpreting makes sense right like you you It's kind of 0:23:45.320 --> 0:23:48.080 like if you were to read a story and then 0:23:48.160 --> 0:23:51.360 tell somebody what does the story say? Like, what are 0:23:51.400 --> 0:23:53.280 the what are the basic points of the story. Or 0:23:53.280 --> 0:23:55.760 you're trying to tell someone about a movie you've seen, 0:23:56.119 --> 0:23:59.480 and you're giving them kind of a high level bullet 0:23:59.520 --> 0:24:03.720