BizHawk sits in an odd spot in the Windows emulation world. It isn’t trying to be RetroArch, and it doesn’t chase pixel-perfect GPU shaders the way Dolphin or PCSX2 do. Instead, it’s the tool speedrunners, tool-assisted-speedrun (TAS) creators, and rerecording enthusiasts reach for when they need frame-perfect input control across more than 45 systems, from the Atari 2600 to the Sega Saturn to an experimental PSP core added this year. Version 2.11.1 shipped on May 1, 2026, and if you’ve never installed it, the setup has a handful of Windows-specific quirks that trip people up: SmartScreen blocks, a missing Visual C++ runtime, firmware folders that silently fail, and a save system that does not work the way you’d assume. This tutorial walks through the entire process on a clean Windows 11 machine, step by step, with the exact files, folders, and settings you need.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What BizHawk Actually Is, and Why It’s Different From RetroArch
BizHawk is an open-source, multi-system emulator written in C#, maintained by the TASEmulators team on GitHub, where the project currently sits at 2,748 stars and 466 forks. Unlike RetroArch, which acts as a front-end wrapping dozens of independently developed “cores” through the libretro API, BizHawk builds most of its own cores in-house under the “-Hawk” naming scheme: NesHawk, GBHawk, A7800Hawk, C64Hawk, and so on, alongside ported cores mainly sourced from the Mednafen project for systems like the PS1, Saturn, and PC Engine.
The practical difference matters for anyone deciding which emulator to install first. RetroArch is built for convenience: one interface, shaders, netplay, and a huge core library you download on demand. BizHawk is built for precision: frame-by-frame rewinding, full movie recording and playback (rerecording), a dedicated TAStudio editor for frame-by-frame input editing, and Lua or C#-based scripting hooks into emulated memory. If your goal is casual couch gaming with shaders and a slick UI, RetroArch remains the better starting point. If your goal is speedrun practice, routing, memory manipulation, or building tools that read game state in real time, BizHawk is the one built for that job.
The current stable release, 2.11.1, added an experimental PPSSPP core for PlayStation Portable emulation on top of the existing lineup, alongside a batch of core fixes. Systems supported natively range across 3DO, Apple II, arcade machines (through an embedded MAME core), Atari’s full console lineup (2600, 7800, Jaguar, Lynx), Commodore Amiga and C64, ColecoVision, Game Boy through Game Boy Advance, N64, both Super Nintendo and Famicom/NES, Sega’s console lineup up through Saturn, Neo Geo Pocket, Nintendo DS/DSi, and even a Nintendo 3DS core called Encore. TASVideos, the community hub for tool-assisted speedruns, lists more than 45 systems total as eligible for movie submissions built with BizHawk.
Understanding BizHawk’s Movie Files and Rerecording System
The feature that separates BizHawk from nearly every other Windows emulator is its movie format, saved with a .bk2 extension. A BizHawk movie is not a video recording — it’s a deterministic log of every single input across a full playthrough, frame by frame, paired with a save state marking the exact starting point. Play the same movie file back against the same ROM and firmware, and BizHawk reproduces the exact same sequence of events every time, down to the frame, as long as nothing about the emulated environment changed between the recording and the playback.
This determinism is what makes “rerecording” possible: rather than replaying a movie start to finish and accepting whatever happens, you can rewind to any earlier point, adjust a handful of frames of input, and resume recording from there. TAStudio (covered in more detail further down) builds an entire editing workflow on top of this idea, letting you treat a full playthrough like a timeline you can scrub, splice, and fine-tune rather than a single continuous take. It’s also why file integrity matters so much for TAS work specifically — a bad ROM dump, a mismatched firmware revision, or a different BizHawk version can each break determinism and desync a movie partway through playback, which is precisely why the pitfalls and troubleshooting sections below spend so much time on dump verification and version consistency.
Building a Legal ROM and Firmware Library
Before you get to the installation steps, it’s worth being specific about where your game files and firmware should actually come from, since this is the part of any emulation setup guide that carries real legal weight. Cartridge-based systems (NES, SNES, Genesis, Game Boy family, N64) can be dumped using commercially available cartridge readers that connect over USB and read the ROM chip directly, producing a binary file identical to what’s stored on the physical cartridge you own. Disc-based systems (PS1, Saturn, Sega CD) are dumped from the physical disc using standard disc-imaging software, similar in principle to ripping an audio CD, though certain systems require specific imaging tools to capture subchannel data correctly.
Firmware and BIOS files follow the same logic: dumping tools exist for extracting a console’s internal boot ROM directly from the hardware, and that dump is legally yours to use once you’ve extracted it from a unit you own. What you should avoid entirely is downloading pre-made ROM or firmware packs from file-sharing sites, torrent trackers, or “everything included” emulator bundles. Beyond the obvious copyright exposure, these files are frequently modified, incorrectly dumped, or bundled with unrelated software you didn’t ask for — and as covered in Step 9, a bad dump is one of the more common causes of unpredictable behavior once you start actually playing.
Prerequisites: What You Need Before You Start
Before downloading anything, confirm your machine meets the baseline requirements. BizHawk’s own GitHub readme states the project follows Microsoft’s own support lifecycle, which means it officially expects Windows 11 21H2 or later, or Windows 10 22H2 or later. Older systems aren’t guaranteed to work, and the team explicitly says it won’t troubleshoot issues on unsupported Windows versions. A legacy backport, version 1.13.2, exists for Windows XP, 7, and 8.1 32-bit systems, but it’s unmaintained, missing most modern features, and carries known bugs that will never be fixed.
- Operating system: Windows 10 22H2+ or Windows 11 21H2+, 64-bit only
- CPU architecture: x86_64 (EmuHawk does not run on ARM64 Windows devices)
- Disk space: roughly 300-500MB for the emulator itself, plus space for your legally owned ROM backups and firmware dumps
- Runtime dependency: the Microsoft Visual C++ Redistributable (x64) — as of BizHawk 2.10 and later, this is the only prerequisite EmuHawk needs to launch
- Input hardware: a keyboard at minimum; a USB or Bluetooth gamepad is strongly recommended for anything beyond menu navigation
- Legally dumped firmware/BIOS files for any system that requires them (PS1, Saturn, Game Boy Advance BIOS, and others), pulled from hardware you own — BizHawk does not ship any copyrighted firmware
One detail that surprises people coming from other emulators: BizHawk does not require the .NET 8 runtime (a.k.a. .NET Core) on Windows. That dependency only applies to the Linux/Mono build. On Windows, the single blocking dependency for modern releases is the Visual C++ Redistributable, which is a small, free download directly from Microsoft.
Step 1: Confirm Windows Version and Architecture
Open Settings > System > About and check the “Windows specifications” section. You’re looking for two things: the edition (Windows 10 or 11) and version number, and confirmation that “System type” reads “64-bit operating system, x64-based processor.” If your version number for Windows 10 is older than 22H2, run Windows Update first — BizHawk’s team has said they will not spend time debugging problems that only appear on outdated Windows builds.
Step 2: Download the Latest BizHawk Release
Go to the official BizHawk releases page on GitHub and download the file named BizHawk-2.11.1-win-x64.zip (the exact filename will update as new point releases ship, but the naming pattern stays consistent: BizHawk-<version>-win-x64.zip). Avoid third-party mirror sites; the GitHub releases page is the only source the development team maintains and verifies.
If you want bleeding-edge fixes that haven’t made it into a numbered release yet, BizHawk also publishes automated development builds through GitHub Actions and GitLab CI on every commit to the main branch. These are useful if you’re chasing a specific bug fix, but the project recommends sticking to numbered releases for anything where stability matters, such as recording a TAS movie you don’t want desyncing later.
Step 3: Install the Visual C++ Redistributable
This is the step almost everyone skips, and it’s the single most common reason EmuHawk refuses to launch. Download and run the official 64-bit Visual C++ Redistributable from Microsoft directly:
# Direct Microsoft download link (safe to run from PowerShell)
Invoke-WebRequest -Uri "https://aka.ms/vs/17/release/vc_redist.x64.exe" -OutFile "$env:TEMP\vc_redist.x64.exe"
Start-Process "$env:TEMP\vc_redist.x64.exe" -ArgumentList "/install /quiet /norestart" -WaitIf you’re running an older BizHawk build (pre-2.10) rather than the current 2.11.1, use the dedicated BizHawk-Prereqs installer instead, which bundles every legacy dependency those older builds needed (DirectX runtime components, older VC++ versions, and so on) into a single installer. Current releases don’t need it, but it’s still there for anyone running an older archived version for compatibility reasons.
Step 4: Extract BizHawk Into Its Own Dedicated Folder
Create a folder — something like C:\BizHawk\ — and extract the full contents of the zip there. Do not extract new versions into a folder that already contains an older BizHawk install. The project’s own documentation is blunt about this: mixing files from different releases can cause crashes, missing dependencies, broken cores, or movie desync during playback. If you plan to keep multiple versions around (common if you’re TASing and need a specific version a submission was recorded on), give each version its own separate folder, for example C:\BizHawk\2.11.1\ and C:\BizHawk\2.9.1\.
C:\BizHawk\
└── 2.11.1\
├── EmuHawk.exe
├── Firmware\
├── Lua\
├── ExternalTools\
└── dll\You can move or rename this folder freely, even to a different drive, as long as everything inside stays together.
Step 5: Launch EmuHawk.exe for the First Time
Double-click EmuHawk.exe. On a fresh Windows install, expect one or both of these interruptions:
- Windows SmartScreen: a blue dialog claiming “Windows protected your PC.” Click “More info,” then “Run anyway.” This appears because EmuHawk is an unsigned, community-built executable, not because anything is actually wrong with the file.
- Third-party antivirus warnings: some antivirus suites flag EmuHawk.exe heuristically because it dynamically loads emulation cores and injects Lua at runtime — behavior that superficially resembles malware. Whitelist the BizHawk folder if your antivirus quarantines any files inside it.
If EmuHawk still won’t open and instead throws a dialog reading “EmuHawk needs X in order to run,” that “X” is almost always the Visual C++ Redistributable from Step 3. Go back and confirm it installed correctly.
Step 6: Set Up Your Firmware Folder
Several systems BizHawk emulates — PS1, Saturn, Game Boy Advance, and others — legally require firmware or BIOS files to boot games, the same way the real hardware needs its internal boot ROM. BizHawk does not, and will not, ship these files, since they’re copyrighted by the original hardware manufacturers. You need to dump them yourself from console hardware you own.
Drop your dumped firmware files into the Firmware subfolder inside your BizHawk install directory. Filenames and subfolder structure inside that folder aren’t strictly enforced — BizHawk scans the contents and identifies files automatically. When you load a game that needs firmware BizHawk can’t find, you’ll see a “You are missing the needed firmware files” dialog listing exactly what’s absent. To manage this more precisely, open Config > Firmwares, which shows every required and optional firmware file in red (missing) or green (detected). Right-click any entry to manually point BizHawk at a specific file, useful when a system has multiple valid firmware revisions and you need to force one.
You can also relocate the entire firmware folder — handy if you run multiple BizHawk versions and don’t want to duplicate firmware files in each one. Go to Config > Paths, select the “Global” tab, and change the “Firmware” path to a shared external location.
Step 7: Configure Controllers and Hotkeys
BizHawk splits input configuration into two separate windows, both under the Config menu:
- Config > Controllers: maps your physical keyboard, mouse, and gamepads to the emulated system’s virtual controller (D-pad, face buttons, analog sticks, and so on)
- Config > Hotkeys: maps physical inputs to frontend actions — save states, fast-forward, frame advance, rewind, and pausing
Click into any input box and press the key, mouse button, or gamepad button/axis you want bound. Enable the “Auto Tab” checkbox at the bottom of either window to automatically jump to the next input slot after each binding, which speeds up mapping a full controller considerably. Both windows have multiple tabs, so scroll across all of them — it’s easy to bind the D-pad and face buttons, then forget shoulder buttons or the start/select equivalents sitting on a second tab.
Step 8: Select the Right Core for Multi-Core Systems
A handful of systems BizHawk supports have more than one available core, and the choice affects both accuracy and speed. Open Config > Cores to pick between them. As of the current release, the systems with a core choice are NES, SNES, Game Boy/Color, Super Game Boy, and PC Engine/TurboGrafx-16. In that same menu you’ll find a “GB in SGB” checkbox — when enabled, standard Game Boy and Game Boy Color games load through your chosen Super Game Boy core instead of the standalone GB core, which matters if you’re testing SGB-specific border and palette behavior.
The table below lists a sample of core assignments straight from the project’s own documentation, showing which cores are accuracy-focused (acceptable for official TASVideos submissions) versus speed-focused ports:
| System | Available Core(s) | Accuracy-Focused? |
|---|---|---|
| 3DO | Opera | Yes |
| 3DS | Encore | Yes |
| Apple II | Virtu | Yes |
| Amiga | UAE | Yes |
| Arcade | MAME | Yes |
| Atari 2600 | Atari2600Hawk, Stella | Stella |
| NES/Famicom | NesHawk (plus alternates) | NesHawk |
| Game Boy/Color | GBHawk (plus alternates) | GBHawk |
| Nintendo 64 | Mupen64Plus (Windows only) | Partial |
| PlayStation Portable (experimental) | PPSSPP | New in 2.11.1 |
Bold core names in the official documentation are the ones accepted for competitive TAS submissions on TASVideos; the rest exist for casual play or as ports where accuracy tradeoffs are acceptable for general use.
Step 9: Load a Game and Verify the Dump Is Good
Use File > Open ROM and select a game file you’ve legally dumped from a cartridge or disc you own. Once loaded, glance at the far left of EmuHawk’s status bar (toggle it on via View > Display Status Bar if it’s hidden). BizHawk checks the loaded file against a database and shows one of three indicators:
- Green checkmark: a “known good” dump, matching a verified hash
- Red circle with “!”: a “known bad” dump, typically created by an incorrect or corrupted dumping process
- Question mark icon: a file not present in BizHawk’s database at all — not necessarily bad, just unverified
If you consistently see red “!” icons on files you’ve dumped yourself, re-check your dumping hardware and process rather than assuming the emulator is broken.
Step 10: Understand Save States vs. SaveRAM (This Trips Up Everyone)
This is the single most misunderstood part of BizHawk for people coming from other emulators. Save states (10 slots, plus unlimited named states) capture the entire emulated system’s memory at an instant and are BizHawk’s version of a quicksave. In-game saves — the “save your progress” feature built into a game itself — are a separate mechanism BizHawk calls SaveRAM, and it behaves differently than you’d expect.
When a game performs an in-game save, BizHawk writes that data into the host system’s RAM along with the rest of the emulated hardware state — it is not automatically written to a file on your disk. You have to manually flush it using File > Save RAM > Flush Save Ram, with the default hotkey Ctrl+S. The File > Save RAM menu item is printed in bold whenever the emulated game performs a save action, so watch for that visual cue. The resulting .SaveRAM files live in system-specific subfolders inside your BizHawk directory, and you should back them up periodically.
BizHawk does offer automatic flushing under Config > Customize > Advanced > AutoSaveRAM, but the project’s own documentation carries a direct warning: automatic flushing is extremely unreliable, isn’t actively maintained, and may corrupt previous saves. Build the habit of manually flushing every time you save in-game, and keep backups of your flushed files.
Step 11: Set Up Lua Scripting and External Tools
One of BizHawk’s defining features is programmatic access to emulated memory through Lua scripts or full external tools written in C# or another .NET language. Open Tools > Lua Console to get started. The window splits into a loaded-script list and a console output pane. Drag and drop any .lua file directly onto the console or game window to load and immediately run it — no need to use the “Open script” button every time.
-- Minimal BizHawk Lua script: print the current frame count
-- and read one byte from emulated memory each frame
while true do
local frame = emu.framecount()
local health = memory.read_u8(0x0A2C) -- example address, game-specific
gui.text(10, 10, "Frame: " .. frame)
gui.text(10, 24, "Health byte: " .. health)
emu.frameadvance()
endRunning scripts display a “▶” icon next to their name in the list; stopped scripts show “⏹,” and paused ones show “⏸.” Use “Toggle script” to pause/stop, and “Reload script” to pull in file changes without closing the console — useful when iterating on a script during a live session.
If a Lua script’s GUI needs get complicated, the project recommends switching to a full external tool built in C# instead, since building complex interfaces in Lua is described in BizHawk’s own documentation as “fiddly.” The external tools wiki documents the API and a community catalog of existing tools you can study or reuse.
Step 12: Automate Launches With Command-Line Arguments
EmuHawk accepts command-line arguments for automating launches — handy if you’re batch-testing ROMs, launching from a frontend, or auto-loading a Lua script every time. On Windows 10 and later, PowerShell is the easiest way to pass them:
# Navigate to your BizHawk folder first
cd C:\BizHawk\2.11.1
# Launch with a Lua script and a specific ROM preloaded
./EmuHawk.exe '--lua=C:\path\to\script.lua' 'C:\path\to\rom.n64'This same argument structure is documented directly in BizHawk’s argument parser source and works identically whether you’re scripting a batch test run or wiring BizHawk into a custom launcher like Playnite or LaunchBox.
Complete Working Project: A Portable Multi-System TAS Practice Rig
Here’s how the individual steps above combine into a single, self-contained setup you can drop on a USB drive or a secondary partition and carry between machines. The goal: a folder that boots straight into a practice session for three systems (NES, SNES, and Genesis) with save states, a memory-watch Lua overlay, and flushed saves all preserved between sessions.
- Extract BizHawk 2.11.1 into
D:\RetroRig\BizHawk\on a portable drive. - Install the Visual C++ Redistributable on the host machine you’re currently using — this one dependency has to be present on whatever Windows PC you plug the drive into, since it isn’t portable itself.
- Create three subfolders under your drive root:
D:\RetroRig\ROMs\NES\,...\SNES\, and...\Genesis\, and copy in ROM backups you’ve personally dumped from cartridges you own. - Copy any required firmware (Genesis doesn’t strictly need it, but Sega CD add-ons would) into
D:\RetroRig\BizHawk\Firmware\. - In
Config > Cores, set NES to NesHawk and confirm SNES is on its default accuracy-focused core. - Bind a gamepad through
Config > Controllers, and set frame-advance plus save-state hotkeys throughConfig > Hotkeys. - Save a starter save state (Shift+F1 by default) immediately after the title screen for each game, so every practice session starts from a known point.
- Drop the memory-watch Lua script from Step 11 into
D:\RetroRig\BizHawk\Lua\so it’s always available via drag-and-drop. - Create a simple batch launcher at the drive root for one-click access:
@echo off
REM launch_nes.bat - portable NES practice launcher
cd /d "%~dp0BizHawk"
EmuHawk.exe "--lua=%~dp0BizHawk\Lua\watch.lua" "%~dp0ROMs\NES\game.nes"- Flush SaveRAM manually (Ctrl+S) at the end of every session before ejecting the drive, and periodically copy the
.SaveRAMsubfolders to a second location as a backup. - Test the whole rig on a second Windows machine before relying on it, confirming the VC++ Redistributable is installed there too.
The result is a folder you can hand off, back up, or move between a desktop and a laptop without reinstalling anything beyond that one system-level runtime dependency.
5 Common Pitfalls When Setting Up BizHawk on Windows
- Mixing files from two different BizHawk versions in one folder. This is explicitly called out in the official documentation as a cause of crashes, missing dependencies, and movie desync. Always extract each version to its own clean folder.
- Skipping the Visual C++ Redistributable. This single missing runtime is behind most “EmuHawk won’t launch” reports. Install it before you do anything else.
- Assuming SaveRAM auto-flushes reliably. It doesn’t, by the project’s own admission, and can corrupt earlier saves. Flush manually with Ctrl+S and keep backups.
- Downloading ROMs instead of dumping your own. Beyond the legal exposure, ROMs sourced from random sites are far more likely to be bad or modified dumps, which show up as a red “!” indicator and can behave unpredictably, especially during TAS recording where determinism matters.
- Expecting macOS or ARM support. EmuHawk’s current builds are Windows/Linux x86_64 only. Apple Silicon and ARM64 Windows aren’t supported; the only macOS path is an old, unmaintained 1.x backport running under Rosetta.
8 Troubleshooting Fixes for the Most Common BizHawk Errors
- “EmuHawk needs X in order to run” on launch: install the 64-bit Visual C++ Redistributable from the official Microsoft link in Step 3, then relaunch.
- Windows SmartScreen blocks the executable: click “More info,” then “Run anyway.” This is standard behavior for unsigned open-source executables, not a sign of a corrupted download.
- Antivirus quarantines EmuHawk.exe or a core DLL: add an exclusion for your BizHawk install folder. The heuristic flag is a false positive triggered by dynamic core loading and Lua injection, both normal BizHawk behavior.
- “You are missing the needed firmware files” dialog: open
Config > Firmwares, confirm which entries are red, and copy the matching dumped firmware into the Firmware folder, then click “Scan.” - Controller inputs do nothing in-game: confirm you bound the controller under
Config > Controllers, not justConfig > Hotkeys— these are two separate mapping systems and it’s easy to configure only one. - A ROM loads but shows a red “!” bad-dump icon: re-dump the game from your original hardware; the file doesn’t match a known-good hash and may behave incorrectly, especially with save states or TAS recording.
- In-game save disappeared after closing BizHawk: you didn’t flush SaveRAM before exiting. Use
File > Save RAM > Flush Save Ram(Ctrl+S) before closing, every time. - N64 core behaves oddly or is missing entirely on Linux builds: Mupen64Plus, BizHawk’s N64 core, is a notable omission on the Linux/Mono build. If you need N64 emulation, use the Windows build instead.
Advanced Tips for TAStudio, Movies, and External Tools
Once basic setup is out of the way, BizHawk’s deeper features are where it earns its reputation in the speedrunning and TAS community. TAStudio, accessible once a game is loaded, gives you a frame-by-frame grid of every input across an entire recorded movie. Double-clicking an analog input cell enters analog editing mode (the cell changes color), and you can then adjust values with arrow keys, direct numeric entry, mouse dragging, or the Virtual Pad tool while TAStudio’s recording mode is active. Holding Shift or Control while clicking the Frame# column lets you select multiple rows and edit them all in one pass — essential when you need to nudge dozens of frames of analog stick input at once rather than one at a time.
For anyone building actual TAS submissions, BizHawk’s official documentation on the topic is admittedly thin — the project points users to TASVideos’ own BasicTools guide and community video tutorials rather than maintaining an in-house walkthrough. If you’re aiming for an official submission, expect to spend time in the wider TASVideos community learning conventions before your movie file is accepted.
DiscoHawk, a disc image converter bundled with BizHawk, is worth knowing about if you’re working with disc-based systems like PS1 or Saturn and need to convert between disc image formats before BizHawk will load them cleanly. It ships as part of the same download and doesn’t require separate installation.
If you outgrow Lua scripting, external tools written in C# or another .NET language plug into the same hooks with a full GUI toolkit behind them instead of Lua’s more limited drawing primitives. The community maintains a growing catalog of these on the external tools wiki, which is a faster starting point than writing one from scratch.
BizHawk vs. RetroArch vs. Standalone Emulators: Choosing the Right Tool
None of these tools are strictly “better” — they’re built for different jobs, and plenty of Windows users end up running more than one side by side.
| Factor | BizHawk | RetroArch | Standalone (PCSX2, Dolphin, etc.) |
|---|---|---|---|
| Primary audience | Speedrunners, TAS creators, tool builders | Casual multi-system players | Players wanting max accuracy for one system |
| Rerecording / movie support | Built-in, core feature | Limited | Rare or absent |
| Scripting | Lua and C#/.NET external tools | Limited Lua support in some cores | Varies widely by project |
| Shader/visual polish | Minimal | Extensive shader library | Project-dependent, often strong |
| System coverage | 45+ systems in one app | Dozens of cores, one interface | One system per application |
| Windows dependency | VC++ Redistributable only | Varies by core | Varies by project |
Emulation Legality: What Windows Users Need to Know in 2026
Emulator software itself is generally legal to write, distribute, and run — courts have repeatedly upheld this in the US. The legal risk sits entirely on the ROM and firmware side: dumping games and BIOS files from hardware and physical media you personally own is on far firmer ground than downloading them from the internet. Nintendo’s 2024 lawsuit against Tropic Haze, the developer behind the Switch emulator Yuzu, is the case that reset expectations across the whole emulation space. Nintendo argued Yuzu existed specifically to circumvent Switch encryption and facilitate piracy, and the case ended in a $2.4 million settlement along with a permanent shutdown of the project, as Engadget reported at the time. Legal analysis of the case since has focused specifically on tools that bypass encryption and traffic in decryption keys, as detailed by PC Gamer’s coverage of the settlement terms.
BizHawk doesn’t touch that specific legal territory — it targets systems with no active encryption scheme comparable to the Switch’s, and the project doesn’t distribute or bundle any copyrighted BIOS or firmware. That said, the broader lesson from the Yuzu case still applies to any Windows emulation setup: dump your own firmware and games from hardware you own, don’t download ROMs from third-party sites, and treat any emulator that ships copyrighted firmware pre-loaded as a red flag rather than a convenience.
Performance Expectations and Hardware Notes
Because BizHawk’s cores mostly target older 8-bit, 16-bit, and early 3D-era hardware, performance demands are modest by 2026 standards. Systems through the SNES/Genesis generation run comfortably on nearly any CPU built in the last decade. N64 and PS1 emulation are more demanding but still run well on mid-range hardware from the last five years. The newly added experimental PSP core (via PPSSPP) is the heaviest workload in the current core lineup, and being marked experimental in 2.11.1 means expect some rough edges and higher CPU usage relative to a dedicated, mature PPSSPP standalone build.
Where BizHawk uses more resources than a comparable standalone emulator is during active TAS work: running Lua scripts every frame, rendering TAStudio’s full input grid for a long movie, and keeping multiple save states in memory all add overhead a casual play session wouldn’t otherwise carry. If you’re TASing a long movie on an older laptop, expect noticeably lower headroom than simply playing the same game casually.
Storage is the other resource worth planning for if you’re building out the full portable rig described above. Save states for later, more complex systems (N64, PS1, Saturn) can run several megabytes each, and TAStudio project files for a long TAS attempt with many branches can grow into the hundreds of megabytes once you factor in the underlying movie data and cached greenzone frames TAStudio keeps around for fast rewinding. None of this is a problem on a modern SSD, but it’s worth budgeting more than the bare 300-500MB install footprint if you’re planning serious TAS work rather than just casual play.
Keeping BizHawk Updated Without Breaking Your Setup
Because BizHawk explicitly warns against mixing files between versions, updating isn’t as simple as extracting a new zip over an old install. The safest update path is to extract the new version into a fresh, separate folder — following the same version-numbered folder structure from Step 4 — and only migrate the specific files you need across: your Firmware folder contents, any custom Lua scripts, and your .SaveRAM files if the new version doesn’t already ship with a save-import path. Test that your existing games still load and save states from the old version still play back correctly before deleting the previous install, particularly if you have unfinished TAS work tied to a specific version’s core behavior.
Keep an eye on the full release history on TASVideos before upgrading mid-project. Core-level changes between versions, even small accuracy fixes, can be enough to desync a movie recorded on an older release, which is exactly why competitive TAS submissions typically specify the precise BizHawk version used.
Frequently Asked Questions
Is BizHawk free to use?
Yes. BizHawk is open-source and free, distributed through GitHub under its own license terms, with no paid tier or subscription.
Does BizHawk run on Windows 11 without issues?
Yes, Windows 11 21H2 or later is one of the two officially supported operating system baselines, alongside Windows 10 22H2 or later.
Can I use BizHawk instead of RetroArch for everyday retro gaming?
You can, but it’s not really built for that use case. RetroArch’s shader library, netplay, and unified UI are aimed at casual play, while BizHawk’s strengths (rerecording, TAStudio, Lua scripting) matter most to speedrunners and tool-assisted-speedrun creators.
Why does EmuHawk say it needs a missing component to run?
Almost always this means the 64-bit Visual C++ Redistributable isn’t installed. Download it directly from Microsoft’s official link and reinstall it, then relaunch EmuHawk.
Does BizHawk support Nintendo Switch emulation?
No. BizHawk’s system list tops out around the Nintendo 3DS and DS/DSi generation, plus a wide spread of older consoles and computers. It has no Switch core and isn’t positioned to add one.
Why did my in-game save disappear after I closed BizHawk?
SaveRAM isn’t written to disk automatically in a reliable way. You need to manually flush it with File > Save RAM > Flush Save Ram (Ctrl+S) before closing the emulator.
Can BizHawk run on macOS?
Not officially for current releases. Apple Silicon and Intel Mac users are limited to an old, unmaintained 1.x backport running through Rosetta, or running BizHawk inside a Windows/Linux virtual machine instead.
What’s new in BizHawk 2.11.1?
The headline addition is an experimental PPSSPP core, giving BizHawk PlayStation Portable emulation for the first time, alongside a batch of fixes across other existing cores.
Related Coverage
- How to Install Batocera 43.1: 200+ Systems in 13 Steps [2026]
- TeknoParrot Setup on Windows: 12 Steps, 60 Min [2026]
- How to Set Up Wiimmfi for Pokemon DS Games: 12 Steps [2026]
- RetroArch BIOS Files: How to Legally Set Up 12 Systems [2026]
- How to Set Up GeForce NOW: 12 Steps, $19.99/Mo [2026]
