Emulator facts for kids
In the world of computers, an emulator is like a special program or piece of equipment that makes one computer system (called the host) act exactly like another computer system (called the guest). This means the host computer can run software or use devices that were made for the guest system.
Think of it this way: many printers are designed to act like HP LaserJet printers. This is because lots of software is made for HP printers. If a different brand of printer can act like an HP printer, then any software made for an HP printer will also work on it! Since the 1990s, many people who love video games have used emulators. They use them to play classic arcade games from the 1980s or to play old video game consoles on their newer computers.
A hardware emulator is a physical device. For example, some Macintosh computers in the 1990s had a special card. This card let them run programs made for personal computers (PCs). In theory, any computer system can be made to act like another. But in real life, it can be hard, especially if you don't know exactly how the original system works. Also, the emulator might not run as fast as the original hardware.
Contents
What are the types of emulators?
Most emulators copy how a computer's parts work. If the software needs an operating system, that also needs to be copied. Both the operating system and the software are then run by the emulator. The emulator also creates virtual versions of other parts, like input or output devices. For example, if writing to a certain memory spot should show something on the screen, the emulator makes that happen.
Some older computers, like the Commodore 64, had software that used very clever tricks. These tricks depended on the exact way the computer's parts worked. So, emulating these systems needs to be super accurate, down to how fast the clock ticks.
However, newer systems, like the PlayStation 4, don't use these tricks as much. For them, a simpler program that translates commands might be enough. This is like a "compatibility layer." It changes commands from one system into commands for the computer you are using. For example, some systems use a Linux compatibility layer. This lets them run software made for Linux.
Developers who make software for embedded systems or video game consoles often use very accurate emulators. They use these "simulators" to test their software before it's put on the real hardware. This helps them find and fix problems early.
Logic simulators
Logic simulation uses a computer program to copy how a digital circuit works. This is done after the circuit is designed but before it's actually built.
Functional emulators
Functional simulation uses a computer program to copy how another program runs. This other program is written in a special computer language, not in the computer's direct code. This helps programmers find mistakes in their code without having to turn it into a final program first.
Video game console emulators
Video game console emulators are programs that let your computer or game console act like another game console. People mostly use them to play older video games from the 1980s to the 2000s on their modern computers. They are also used to change games into other languages or to create new games for old systems. The Internet has made it easy for these emulators to spread.
Some fake emulators exist that are actually harmful software. These often claim to run games from very new consoles, like the Xbox One, which is usually not possible.
Legal rules for emulators
As computers and the Internet got better, emulators became more advanced. The time it took to create an emulator for a new console got shorter. This made console makers try to stop unofficial emulators. However, court cases have shown that emulation itself is legal in the United States. But sharing copyrighted game code without permission is still against the law.
It is legal to make a copy of a machine's original BIOS (a basic startup program) if you own the machine legally. To avoid needing a BIOS file, some emulators can copy the BIOS's actions in a different way. This might make the emulation a tiny bit less accurate.
Terminal emulators
Terminal emulators are programs that let modern computers connect to older, larger computer systems. Old terminals, like the IBM 3270, are not made anymore. Instead, software on your computer pretends to be one of these old terminals. This lets you see and interact with programs running on the older systems.
Other types of emulators
There are other kinds of emulators too:
- Hardware emulator: This is when one piece of hardware acts like another piece of hardware.
- In-circuit emulator: A hardware device used to find and fix problems in software for small, built-in computer systems.
- Floating-point emulator: Some computer parts only do simple math. If a computer doesn't have special parts for complex math, the main computer chip can pretend to do it using simpler steps.
- Instruction set simulator: This copies how a computer's main chip works by reading its instructions and keeping track of its internal memory.
- Network emulation: This tests how real programs work over a pretend network.
- Server emulator: For online video games, this is an unofficial server that acts like the official game server.
- Semulation: This is when you control an emulator using a simulator.
How emulators are built
An emulator is usually split into different parts, like building blocks. Each part copies a different part of the original computer.
Most emulators have:
- A CPU emulator (or CPU simulator), which copies the main brain of the computer.
- A memory part, which copies the computer's memory.
- Different parts that copy input/output (I/O) devices, like keyboards or screens.
The connections between these parts (called buses) are often not copied exactly. Instead, the virtual devices talk directly to the CPU or memory.
Memory part
The memory part of an emulator can be as simple as a list of numbers. But it gets more complex if the original computer has advanced ways of managing memory. Emulators usually have special ways to read from and write to the computer's memory. This makes sure that every action goes to the right place.
CPU simulator
The CPU simulator is often the most complex part. Many emulators use ready-made CPU simulators so they can focus on making the rest of the machine work well. The simplest CPU simulator is an "interpreter." This program reads each instruction from the emulated program and then performs the same action on your computer. This works by having variables (like placeholders) for each part of the simulated CPU.
Interpreters are popular because they are easier to build. They work well for emulating computers that are much older than your current machine. However, if the emulated computer is almost as fast as your computer, the interpreter might be too slow.
Newer methods, like "dynamic recompilation" or "Just In Time (JIT) compilers," help with this speed problem. They translate parts of the old program's code into code your computer can run, but only when it's needed. This translated code is saved so it doesn't have to be translated again. Sometimes, you might even want the emulator to run slower. This is because some old games were designed for slower computers. If they run too fast, the game might not work correctly.
Input/output (I/O)
Most emulators treat each input/output device (like a keyboard, mouse, or screen) as a special case. This can make them run faster because each part is made to fit the device it's copying.
Even when each device is special, there's usually a basic system for:
- Handling "interrupts," which are signals that tell the CPU something needs attention.
- Reading from and writing to the computer's physical memory.
Why are emulators used?
For keeping old things alive
Emulation is a way to save old digital things and fight against them becoming unusable. It focuses on making an old computer environment work again. This can take a lot of time and effort, but it's valuable because it keeps a strong link to the original digital item. Emulation helps you use old programs or operating systems on your current computer, making them work just like they did originally.
One expert, Jeffery Rothenberg, said that the best way would be a single, long-term solution that works for all types of digital items. This means that if a new version of a program comes out, instead of fixing problems for every old file, you could just use an emulator for the old program. This would let you open all your old files easily.
In new media art
Because new media art often uses digital formats, emulation is very important for saving it. Some artists focus on bringing old technologies back to life in their art. They understand how important it is to save digital culture. The goal of emulation in new media art is to save digital art forever, so it doesn't depend on old hardware that breaks down. The interesting part is that the emulator itself also needs to be made to work on future computers!
In designing future systems
Emulation is often used when designing new computer systems. It helps developers find and fix problems in the design even before the system is built. This is very helpful for designing systems with many main chips, where errors can be hard to find without a controlled environment. It also lets software be developed before the actual hardware is ready.
Emulator vs. simulator
The word "emulator" was first used in 1963 at IBM. They found that using special instructions in hardware made copying old IBM computers much faster than just using software. Before this, they used "simulators," which were purely software programs.
In the 2000s, it became common to use "emulate" for software that copies a machine running computer code. "Simulation" often means a computer program that copies an idea or model, like in network simulation. Some people still prefer the old meaning, but today, "emulation" usually means copying a whole machine, while "simulation" means copying a model.
Emulator vs. hardware virtualization
Hardware virtualization is when a computer acts like many different computers at once. It hides the real parts of the computer from the users. Instead, it shows them a pretend computer. The software that controls this is called a "hypervisor." Each hypervisor can manage many pretend computers.
See also
In Spanish: Emulador para niños
- List of emulators
- List of computer system emulators
- QEMU
- Q (emulator)
