Computer specifications

See this revision of the page if you're looking for detailed information for older days and hardware.

Intel 4004 Visual Transistor-level Simulation

Emulator performance is primarily dependent on the CPU's speed, as the CPU undertakes the demanding task of mimicking another system's hardware. While the GPU typically rendering visuals and enhances graphics through applying graphical and post-processing enhancements features, a sufficiently fast CPU is crucial for achieving full-speed emulation. This makes the CPU the most critical component when building or upgrading a PC for emulation, particularly for accurately recreating performance-demanding systems. Some emulators offer Software Rendering, where all graphics processing is handled by the CPU, which is a method that significantly increase CPU performance demand. In recent years, choosing the right GPU for emulation is more important now than it used to be; with the recent advancements like compute shader renderer implementations and emulators like Eden, Ryubing, Cemu, Xenia Edge, ShadPS4 heavily utilizing GPUs and its features.

Recommended Specifications

What kind of EMULATION can you do with your PC?

This list excludes inactive or unsupported emulators as much as possible, see History of emulation page for older software emulators. For seeing recommended specifications for obsolete, non-active and older emulators, see this page. We also discourage recommending outdated hardware (this does not apply to GPUs that have moved off the mainline feature-driver branch but remain supported via the maintenance-mode / legacy driver branch; such GPUs may still be included in our guidelines) or operating systems.[5] Why? In the '90s and '00s, there are various popular tools and webpages for users to check system compatibility for games and software. Similarly, this page aims to guide emulation users by highlighting the system requirements for modern, actively maintained emulators. These emulators implement and rely on up-to-date frontends, standards, compiler features, functions, libraries and APIs from time to time (see the high and low-level emulation#Future Outlook section), which usually depends on actively maintained and supported operating system versions and hardware via drivers. We recommend using official binaries rather than building software yourself without serious patching.[6] There are even some interesting discussions happening about ISA support for emulators.[7][8][9]

Windows: 10 (64-bit) based on servicing supported build or later

Linux: Distributions based on 64-bit active kernel releases/EOL

macOS: still maintained version

Android: still maintained version

iOS: still maintained version

Only emulators that are recommended in the EmuGen Wiki are listed here.
If you're editing this table, please provide the official system requirements page URL in the Official Links section. This page offers unofficial guidelines and recommendations to help you decide.
This guideline targets moderate hardware requirements for emulators to ensure the emulated device realistically matches typical native hardware behavior, not merely the minimum needed to function. Game-specific exceptions are noted in the "Notes" section.

WIP: PC-9800 series, FM Towns, Apple II line, Classic Mac OS, Sharp X68000, ZX Spectrum, Amstrad CPC, MSX 1/2

Emulator and system		CPU Demand	GPU Demand		Notes	Official Links
			Native	Enhancements
RetroArch Genesis Plus GX	SMS	▰▱▱	▰▱▱	▰▱▱	—	?
	MD • Mega CD				—	?
RetroArch Stella	VCS	▰▱▱	▰▱▱	▰▱▱	—	?
RetroArch Atari800	Atari 8-bit	▰▱▱	▰▱▱	▰▱▱	—	?
RetroArch Hatari	Atari ST	▰▱▱	▰▱▱	▰▱▱	—	Official requirements
TouchHLE	iOS 1~4	▰▱▱	▰▱▱	▰▱▱	—	?
RetroArch Mednafen	PC-FX	▰▱▱	▰▱▱	▰▱▱	—	?
	Atari Lynx				—	?
	Virtual Boy				—	?
	Saturn	▰▰▱			— Some titles may run on ▰▱▱ perf. level CPU hardware.	?
RetroArch FinalBurn Neo	2D arcade boards	▰▱▱	▰▱▱	▰▱▱	—	?
RetroArch MAME	3D arcade boards	▰▰▰	▰▱▱	▰▱▱	— Some 3D titles may run on ▰▰▱ perf. level CPU hardware.	John IV's MAME Benchmarks
RetroArch VICE	PET • CBM-II • VIC-20 • C64 • C128	▰▱▱	▰▱▱	▰▱▱	— Commodore 64 emulation demand metrics are based on x64sc version of VICE.	Manual
RetroArch PUAE	Amiga 4000	▰▱▱	▰▱▱	?	—	?
	CD32
86Box	Standard PC	▰▰▰	▰▱▱	▰▱▱	— 86Box has OpenGL 3.0 renderer. — The Standard PC's demand metrics are based on a Windows 98 guest with a Celeron 300A and a Voodoo 3. In certain situations 🔥 perf. level CPU is needed. — IBM PC-compatible's demand metrics are based on a MS-DOS 6 guest with a 486DX2 and a S3 Trio64.	Official requirements Host machine survey
	IBM PC-compatible	▰▱▱	▰▱▱	▰▱▱
xemu	Xbox	▰▰▱	▰▱▱	▰▰▱	— Some titles may run on ▰▱▱ perf. level CPU hardware. Due to Xemu's work-in-progress nature, certain games require ▰▰▰ CPU or enhancement features require 🔥 GPU.[10]	Official requirements Performance guide
BigPEmu	Jaguar • Jaguar CD	▰▱▱	▰▱▱	▰▱▱	—	User manual#Troubleshooting
RetroArch Flycast	Dreamcast	▰▱▱	▰▱▱	▰▱▱	—	?
DuckStation	PlayStation	▰▱▱	▰▱▱	▰▱▱	—	Official requirements
Ares	Nintendo 64	▰▰▱	▰▱▱	▰▰▱	—	SoullessSentinel's comment
	SNES	▰▱▱	▰▱▱	▰▱▱	— Pixel-accuracy mode may require a ▰▰▱ tier CPU for certain titles.	?
	NES				—
	PCE • PCE-CD • PCE2
	Sega 32X • Sega CD 32X
	LaserActive
	Neo Geo Pocket • Color
	WonderSwan • Color
PPSSPP	PSP	▰▱▱	▰▱▱	▰▱▱	— MSAA requires the VK_KHR_depth_stencil_resolve extension.[11]	Official requirements
Vita3K	PS Vita	▰▰▱	▰▱▱	▰▱▱	—	Official requirements
PCSX2	PlayStation 2	▰▰▱	▰▱▱	▰▰▱	— Additionally requires the extensions GL_ARB_shading_language_420pack, GL_ARB_copy_image, and GL_ARB_clip_control — Certain games require ▰▰▰ perf. level CPU hardware. — Some titles may run on ▰▱▱ perf. level CPU hardware. — If you plan to use ParaLLEl-GS renderer with enhancements, 🔥 perf. level GPU is recommended.	Official requirements
Dolphin	GameCube • Wii	▰▰▱	▰▱▱	▰▰▱	— Certain games require ▰▰▰ perf. level CPU hardware. — Some titles may run on ▰▱▱ perf. level CPU hardware.	Performance guide
RetroArch SameBoy	Game Boy • Game Boy Color	▰▱▱	▰▱▱	▰▱▱	—	?
RetroArch mGBA	Game Boy Advance	▰▱▱	▰▱▱	▰▱▱	—	Official requirements Official requirements #2
RetroArch MelonDS DS	Nintendo DS • DSi	▰▱▱	▰▱▱	▰▱▱	— melonDS has compute shaders support.	Official site
Azahar	Nintendo 3DS • new 3DS	▰▰▱	▰▱▱	▰▱▱	—	Official requirements
RPCS3	PlayStation 3	▰▰▰	▰▱▱	▰▰▱	— Some titles that aren't SPU heavy may run on ▰▰▱ perf. level CPU hardware.	Official requirements CPU Tier List for RPCS3 Requirements (2026)
Cemu	Wii U	▰▰▱	▰▱▱	▰▰▱		Official site
Xenia Edge	Xbox 360	▰▰▱	▰▰▱	🔥	— Some games manage to run just fine on ▰▱▱ performance GPUs.	Official requirements
Eden	Switch	▰▰▱	▰▱▱	▰▰▰		Official requirements nx optimizer's recommendations
ShadPS4	PlayStation 4	▰▰▱	▰▰▱	🔥	— Needs VK_KHR_swapchain and VK_KHR_push_descriptor extensions — Some games manage to run just fine on ▰▱▱ performance GPUs.	Official requirements

Demand Levels

The demand levels provide a rough indicator of hardware intensity. Colors represent low (green), medium (orange), and high (red) demands. Below are separate tables standardizing typical examples for CPU and GPU across emulators.
For emulator-specific variations (e.g., lower-end titles or enhancements), refer to the "Notes" and "Enhancements" columns in the main table.
If your CPU's PassMark Single-Thread score is < 1500 and/or ISA level is x86-64 (v1), some ▰▱▱ low-demand emulators may still run adequately, but upgrading your CPU is strongly recommended at that point.
Likewise, if your GPU's PassMark G3D score is < 3000, API support is limited to older version of OpenGL, or Direct3D, and/or the hardware is so old that it isn't even covered by a maintenance-mode / legacy driver branch: although some ▰▱▱ low-demand emulators may still function, a GPU upgrade is strongly recommended at that point.

---

CPU Demand	PassMark Single-Thread	CPU-Z Bench 1T	ISA	RAM	Example CPUs	Budget (CPU+MOBO+RAM)
▰▱▱	1500 2000	260 350	x86-64 (v2)	OS recommended	i3-2130 • FX-4170 (2C/4T) Pentium G4560 (2C/4T)	🥔
▰▰▱	2500 3000	480 600	x86-64 (v3)	8 GB 16 GB	Ryzen 3 4100 (4C/8T) i5-11400F • Ryzen 5 5500 (6C/12T)	~$200 ~$300
▰▰▰	3500 4500	700 880	x86-64 (v4)	≥16 GB	Ryzen 5 7500F • i5-12400F* (6C/12T) Ryzen 5 9600X (6C/12T)	~$400 ~$500
🔥	≥5500	≥1000			Ryzen Zen 6 Medusa • Core Ultra Series 4 Nova Lake	~$???

GPU Demand	PassMark G3D	API Support	VRAM	Example GPUs	Budget (GPU)
▰▱▱	3000	OpenGL 4.6 Vulkan 1.3 Direct3D 12_1 and/or Shader Model 6.6	4 GB	Radeon 740M	🥔
▰▰▱	11000		6 GB	GTX 1660 • RX 5600	~$200
▰▰▰	16000		8 GB	RTX 3060 • RX 7600	~$300
🔥	≥20000		≥8 GB	RTX 5060 • RX 9060 XT	~$400

Popular Pre-Built, Handheld, Mobile and APU Systems for Comparison
Synthetic benchmark scores (particularly for Apple Silicon and Intel Core Ultra series) should be taken with a grain of salt. They do not accurately predict real-world emulation performance (1:1) due to several critical factors; as detailed in Emulation Outlook. Real-world emulation relies on various things such as instructions that synthetic tests rarely replicate perfectly, Architectural Differences, Optimization Gaps, Thermal and Power Throttling as noted in the architecture recommendation and demanding emulation sections already.

CPU Demand	GPU Demand	PassMark Single-Thread • PassMark G3D	PassMark Android • PassMark iOS	ISA • API Support	System	Budget (System)
▰▱▱	▰▱▱	-	8500	ARMv8.2-A • OpenGL ES 3.1, Vulkan 1.2	Raspberry Pi 5	$150
		-	12500	ARMv8.2-A • OpenGL ES 3.2, Vulkan 1.1	Retroid Pocket 5[12]	$200
		CPU: 2200 • GPU: 3000	-	x86-64 (v3) • OpenGL 4.6, Vulkan 1.3	Steam Deck[13]	$400
▰▰▱	▰▰▱▱	-	23000	ARMv9.2-A • OpenGL ES 3.2, Vulkan 1.3	OnePlus CPH2645	$600
		-	45000	ARMv9.4-A • OpenGL ES 3.2, Metal 3	iPhone 17e	$600
▰▰▰▱	▰▰▱	CPU: 3300 • GPU: 11000	-	x86-64 (v4) • OpenGL 4.6, Vulkan 1.3	Steam Machine	$1050
▰▰▰		CPU: 4000 • GPU: 16000			GPD Win 5 AMD Ryzen AI Max 385 with Radeon 8050S	$1500

Before diving in

Semiconductor industry categorization

The semiconductor industry, particularly for CPUs, GPUs, and other processors, involves a complex supply chain with distinct roles. Companies are typically categorized based on their primary functions: designing chips, manufacturing them, or assembling/finalizing products like graphics cards.

Chip Designers (Fabless Semiconductor Companies)

These companies focus on designing the architecture and intellectual property (IP) of chips but do not own manufacturing facilities ("fabs"). They outsource production to foundries.

• NVIDIA (designs GPUs such as GeForce RTX)
• AMD (designs CPUs such as Ryzen and GPUs such as Radeon)
• Qualcomm (designs mobile SoCs such as Snapdragon)
• Apple (designs custom silicon such as Apple Silicon M-series and A-series)
• Arm (designs CPU/GPU core architectures licensed to others)

Chip Manufacturers / Foundries

These companies physically produce silicon wafers and chips using advanced process nodes (e.g., 3 nm, 2 nm). They can be "pure-play" foundries (manufacturing only for third parties) or integrated.

• TSMC – world's largest pure-play foundry; manufactures for NVIDIA, AMD, Apple, etc.; leader in advanced nodes (2 nm in production ramp as of 2025)
• Samsung Foundry – pure-play foundry division of Samsung; competes directly with TSMC (notable for 3 nm GAA transistors)
• Intel Foundry – Intel's foundry business (formerly Intel Foundry Services)
• GlobalFoundries
• SMIC

Integrated Device Manufacturers (IDMs)

Companies that both design and manufacture their own chips in-house.

• Intel (designs and manufactures x86 CPUs)
• Samsung (for its own Exynos SoCs, memory, etc.)
• Micron (DRAM and NAND flash)

Board Partners / Add-in-Board (AIB) Partners

Companies that take finished GPU dies (from NVIDIA or AMD) and design complete graphics cards, including PCB, cooling, power delivery, and branding.

• ASUS (ROG Strix, TUF Gaming series)
• EVGA (historically major NVIDIA partner; exited new GPU production in 2022)
• MSI
• Gigabyte / Aorus
• Zotac
• Palit, Galax, PNY, etc.

The modern GPU supply chain is often described as the "fabless → foundry → AIB" model: a chip designer (e.g., NVIDIA) sends designs to a foundry (e.g., TSMC), which produces the dies, and then AIB partners turn those dies into retail graphics cards.

History of Firmware stack

Technology	Key Milestones and Description
Early BIOS	Originated in 1975 with Gary Kildall's CP/M OS as machine-specific boot code. Standardized in IBM PC (1980s) as proprietary ROM-based firmware for hardware initialization and booting. Reverse-engineered by companies like Phoenix, AMI, and Award for compatible systems. Limited to 16-bit real-mode, small drives (MBR), and basic peripherals.
Transition to UEFI	Developed by Intel in early 2000s to overcome BIOS limitations (e.g., 16-bit constraints, no support for >2TB drives). Introduced 64-bit support, GPT partitioning, Secure Boot, modular drivers, and faster boot times. Wide adoption in 2010s; required for Windows 8 (2012) features like Secure Boot. Compatibility Support Module (CSM) retained for legacy BIOS modes. Now standard, mandatory for modern OS (e.g., Windows 11 requires UEFI + Secure Boot + TPM 2.0).
AMD-Specific: AGESA	Introduced ~2003–2007 as proprietary library for initializing AMD64 processors, memory, chipsets, and controllers. Provided as binary blobs to motherboard vendors for integration into BIOS/UEFI. Enabled rapid platform development; briefly open-sourced in 2011 (stopped after Family 15h). Evolved with UEFI; critical for long-lived sockets like AM4/AM5. Updates (e.g., ComboPI versions) add CPU support, fixes, and security patches.
Shift to Open-Source: openSIL	Announced April 2023 as modular, C-based open-source stack (MIT-licensed on GitHub) to replace AGESA. Components: Silicon Library (low-level init), Platform Library (board-specific), Utilities Library (shared functions). Goals: Transparency, community auditing, security, faster integration, reduced closed-source reliance. Proof-of-concept on EPYC Genoa/Turin and Phoenix (Zen 4). Production rollout: 6th Gen EPYC "Venice" (Zen 6 server) in 2026 (first full openSIL, code release ~1 quarter post-launch). Client Ryzen "Medusa" (Zen 6) openSIL support in 1H 2027. AGESA phased out progressively (full replacement likely by Zen 7 or later). Reflects industry trend toward open firmware for enterprise and hyperscalers.

UEFI and AGESA/openSIL operate at different layers of the PC boot process and are not direct competitors. UEFI is the overall firmware interface standard, while AGESA and openSIL are AMD-specific components that provide low-level silicon initialization and are integrated into a host firmware (typically UEFI, but potentially others like coreboot).

Aspect	UEFI	AGESA / openSIL
Role	Full firmware interface: provides boot services, runtime services, driver model, Secure Boot, GUI setup, and OS handoff.	AMD-specific silicon initialization library: handles early CPU, memory, chipset, and controller setup.
Scope	Complete boot environment (replaces legacy BIOS).	Low-level hardware initialization for AMD processors only (called by the host firmware).
Vendor/Standard	Industry standard defined by the UEFI Forum (Intel-initiated, supported by AMD, ARM, etc.).	AMD-exclusive (AGESA proprietary; openSIL open-source under MIT license).
Integration	Host firmware (e.g., AMI Aptio, Phoenix SecureCore, TianoCore reference implementation) used on most modern motherboards.	Provided to motherboard vendors as a library/blob (AGESA) or source code (openSIL) to integrate into the host firmware.
Open-Source Status	Partially open (e.g., EDK II/TianoCore reference is open-source).	AGESA: Proprietary binary blobs. openSIL: Fully open-source (GitHub-hosted).
Compatibility	Cross-platform (Intel, AMD, ARM systems).	AMD x86 platforms only.
Key Features	Bootloader services Driver model Secure Boot GUI setup OS handoff	Processor core initialization Memory training and configuration Power management setup Chipset and HyperTransport/Link initialization Modular components in openSIL (Silicon, Platform, Utilities Libraries)

Marketing tricks

• The RGB Premium: Lighting (Red-Green-Blue) has zero impact on performance but often adds a price markup. In many budget builds, users spend money on "pretty" fans or RAM sticks that would have been better spent jumping to the next tier of GPU or CPU.

• The DRAM Heatsink Illusion: High-performance DDR4 and DDR5 RAM often come with massive, aggressive-looking metal heat spreaders. While some heat dissipation could be necessary for very high-voltage overclocking, nearly all "gaming" heatsinks are purely aesthetic. In many cases, these tall heatsinks actually cause "clearance issues," preventing large, high-quality CPU air coolers from fitting in the case.

• "Gaming" Branding: Labels like "Ultra-Gaming," "Military Class," or "Strix/TUF/Predator" are often used to justify higher price tags on motherboards and GPUs that utilize the exact same silicon as their "Pro" or "Classic" counterparts. Always check the VRM (Voltage Regulator Module) quality and Port IO rather than the branding on the box.

• The "VRAM Trap": Lower-tier GPUs are sometimes sold with high amounts of VRAM (e.g., a weak GPU with 4GB of VRAM) to trick casual buyers into thinking it's more powerful. If the GPU's memory bus or core clock is slow, that extra VRAM is essentially "parking space" that the card isn't fast enough to actually use effectively.

• The 80 Plus Efficiency Trap: While the 80 Plus certification (Bronze, Gold, Platinum) is a legitimate measure of energy efficiency, it is frequently marketed as a proxy for build quality or component reliability. An "80 Plus Gold" unit can still utilize low-tier secondary capacitors or sleeve-bearing fans that fail prematurely. Efficiency only measures the ratio of AC power input to DC power output; it does not guarantee voltage ripple suppression or long-term durability. See PSU section for more information.

• The AIO "Performance" Premium: Marketing for closed-loop All-in-One (AIO) liquid coolers often implies they are inherently superior to air cooling. In reality, high-end dual-tower air coolers often match low or mid-tier AIOs in thermal performance and noise levels while being significantly cheaper.
  • Why high-end air coolers perform well: High-end air units utilize 6 to 8 high-diameter (6mm–8mm) sintered powder heat pipes (more efficient than budget "grooved" pipes) and soldered fin-stacks that maintain a permanent thermal bridge. The copper base plates are milled from high-purity C1100 nickel-plated copper to a slight convex shape. This convexity, paired with high-tension spring-loaded mounting brackets, ensures maximum mounting pressure against the CPU's Integrated Heat Spreader (IHS). Proper contact interface is the most crucial factor for thermal performance. High-end air coolers use specific base geometries to match socket characteristics: High Base Convexity (HBC) for Intel's bowed LGA1700/1851 sockets, or Low Base Convexity (LBC) for flatter AMD AM5 surfaces. This ensures the copper makes direct, high-tension contact with the hottest part of the CPU. Brands like Thermalright have gained significant market share by providing exceptional default Mounting Pressure and base flatness in affordable models (e.g., Peerless Assassin/Phantom Spirit), often outperforming more expensive rivals by minimizing the Bond Line Thickness of the thermal interface. These units feature fans with Fluid Dynamic Bearings (FDB) or SSO2 systems for longevity and are optimized for Static Pressure (>2.0 mmH₂O) rather than just raw CFM to force air through dense fin-stacks.
  • Comparing to AIOs: While AIOs have higher thermal inertia (the liquid coolant acts as a massive "buffer" for short-term burst loads), high-end air coolers are equally effective for sustained, long-term workloads once the AIO's liquid has reached thermal equilibrium. Most importantly, air coolers have fewer points of failure: no pumps to die or coolant to permeate. AIOs are often sold on "aesthetic clean looks" rather than functional longevity. Air coolers lack the permeation issues of AIOs; while rubber AIO hoses slowly lose liquid over years, the hermetically sealed copper heat pipes in a premium air cooler can remain functional for decades. See Cooling section for more information.
  • Thermal Interface Material (TIM): The final bottleneck is the Thermal Interface Material (TIM). Performance is defined by two factors: Thermal Conductivity (W/mK) — how much heat the material moves. Standard pastes offer ~8–12 W/mK. Reliable but can "pump out" over years of thermal cycling. Liquid Metal offers extreme conductivity (~73 W/mK) but is electrically conductive and can gall (stain/react with) copper or aluminum if not handled with extreme care. Thermal Resistance (mm² · K/W) — how much the material's thickness and contact quality "fight" heat movement. Phase-Change and Graphene Sheets have lower values than standard pastes on paper, but their ultra-low Thermal Resistance and lack of "pump-out" make them superior for long-term high-pressure mounts.

• False "Future-Proofing": Vendors often upsell premium motherboards by highlighting newer standards. For instance, PCIe 5.0 support for GPUs or SSDs: since most hardware in current-gen rarely saturates PCIe 4.0 x16 bandwidth, the "future-proofing" benefit is often theoretical. By the time most consumer GPUs actually require PCIe 5.0 bandwidth to avoid bottlenecks, the CPU platform and DDR standard will likely be obsolete, making the initial price premium a poor investment compared to buying current-tier performance.

• Phase Count Inflation & Power Stage Quality: Motherboard VRM marketing often boasts high "phase counts" (e.g., 16+2+1). Manufacturers frequently use "doublers" or parallel power stage configurations to inflate these numbers. While a robust VRM is necessary for extreme overclocking on flagship CPUs, a mid-range user gains zero performance from a 20-phase board over a well-designed 8-phase board; the extra phases simply add cost and unnecessary complexity without improving instruction throughput.
  • What actually matters in VRM design: The quantity of phases is secondary to the quality of the Power Stage ICs and the PWM Controller. Check specialized VRM spreadsheets or teardowns for actual IC models rather than the number of chokes on the PCB. For detailed analysis, refer to buildzoid on YouTube.
  • Amperage Ratings: A "20-phase" board using cheap 40A or 50A discrete MOSFETs often has worse thermal efficiency and voltage stability than a "10-phase" board utilizing high-end 90A or 105A Smart Power Stages (SPS) (e.g., Renesas ISL99390 or Monolithic Power Systems MP87992).
  • SPS vs. Discrete: Modern high-end boards use Integrated Power Stages (DrMOS/SPS) which combine the high-side MOSFET, low-side MOSFET, and driver into one IC. These offer precise current and temperature monitoring that basic discrete setups lack.

• The "1ms" Response Time Myth: Monitor manufacturers often advertise a "1ms Response Time" to target gamers. Real-world average response times across the entire color transitions are typically much higher.

• Sequential vs. Random Storage Speeds: NVMe SSDs are marketed almost exclusively on Sequential Read/Write speeds (e.g., 7,500 MB/s). These speeds only apply when moving massive, contiguous files. For OS snappiness, application launching, and game load times, Random 4K Read/Write performance and IOPS are the actual bottlenecks. Most users pay a premium for sequential speeds they will never utilize in daily tasks. See Storage section for more information.

• Megahertz Myth: Higher clock speeds don't always mean better performance, especially when comparing two different CPU architectures. There are other factors due to architectural differences that affect performance; e.g., fewer pipeline stages, wider execution units. Similarly, some older CPUs that have high clocks but weaker single-threaded performance and shared FPUs (e.g., FX-4350 has 2 FPUs for 4 cores), making them poor choices for emulation.

• Process Nodes: Since at least 1997, "process nodes" have been named purely on a marketing basis, and have no direct relation to the dimensions on the integrated circuit; neither gate length, metal pitch or gate pitch on a "28 nm" device is twenty-eight nanometers.[14] A common source of confusion arises from the difference between generic "7 nm node" standards (such as the IRDS/IEEE roadmap) and actual vendor implementations. The IRDS values represent theoretical, retrospective ideals rather than real-world fab measurements. Similarly to board partners for GPUs, vendor processes differ significantly from one another (e.g., exact stack height, inner/outer spacer materials, and how each company integrates it with backside power delivery; Intel PowerVia, TSMC Super Power Rail later, etc). For instance;
  • TSMC N7: CGP = 57 nm, MMP = 40 nm
  • Samsung 7LPP: CGP = 54 nm
  • Intel 7 (formerly 10 nm): CGP = 60 nm

Transistor types through history

As process nodes have shrunk, the fundamental transistor structure (transistor types through history) has evolved from planar designs to various multigate architectures to maintain electrostatic control, reduce leakage, and allow further scaling: Planar bulk MOSFET (1960s–~2011): Classic single-gate flat transistor used from micron-era nodes down to ~22 nm. Planar double-gate MOSFET (DGMOS) (research 1990s–2000s): Thin-body planar transistor with top and bottom gates; explored by IBM and others but never entered volume production. FlexFET (early 2000s): Independent double-gate planar SOI transistor developed by American Semiconductor; used in some radiation-hardened and flexible-electronics applications. FinFET (Tri-gate) (commercial 2011–present): First mainstream 3D multigate transistor; gate wraps the channel on three sides. Introduced by Intel at 22 nm (Ivy Bridge), later adopted by TSMC/Samsung at 16/14/10/7/5 nm and Intel up to Intel 4. GAAFET (Gate-All-Around FET) / Nanosheet FET (commercial 2022–present): Gate completely surrounds the channel. Generic term for the architecture. Below "3 nm", all leading logic processes (TSMC N3E/N2, Samsung SF2, Intel 18A) are GAA-based; FinFET is no longer scalable for cutting-edge density. MBCFET (Samsung's branded GAAFET using stacked nanosheets, debuted with 3 nm class nodes in 2022). RibbonFET (Intel's branded GAAFET nanosheet implementation, first used in Intel 20A (2024–2025) and continued in 18A).

Metal layers
Lower metal layers (M0/M1) are used for dense local interconnect near the transistors, while higher layers (M2+) are thicker, wider routing layers for long-distance signals and power delivery; therefore, only the tightest layers define density scaling.

This table includes several projected and estimated values and is not intended to represent 100% confirmed specifications
CPU Peak FP32 reports the maximum theoretical floating-point performance for vector math. PassMark STR (Single Thread Rating) reflects real-world single-core instruction throughput (higher is better).
Physical dimensions are key scaling metrics: Gate Length shrinks slowly in modern nodes (~20nm) while Contacted Gate Pitch (CGP) is the primary density metric. Min. Metal Pitch (MMP) refers to the tightest metal layers (M0/M1) that define transistor density, distinct from wider top layers.
Second section of the table is for consumer mid-tier discrete GPU process node evolution.

CPU / APU	Marketed Node	Gate Length	CGP	MMP	CPU Transistor Count	GPU Transistor Count	Die Size	Transistor Density	CPU Peak FP32	PassMark STR	GPU Peak FP32	Power	Min. ISA	Yield / Cost
Intel i486DX2-66 (P24, 1992)	800 nm (Intel)	≈ 800 nm	≈ 1500 nm (est.)	≈ 1000 nm (est.)	~1.2 M (1 core + 8 KB L1)	—	~81 mm²	~0.015 MTr/mm²	~0.06 GFLOPS (FPU)	—	—	~5 W	x86 (i486 baseline)
Celeron 300A (Mendocino, 1998)	250 nm (Intel)	≈ 250 nm	500–600 nm	300–350 nm	~18.9 M (1 core + 128 KB L2)	—	110 mm²	~0.17 MTr/mm²	0.6 GFLOPS (FPU)	~65 (est.)	—	~17 W	x86 (i686 baseline)
Intel Pentium III (OG Xbox, 2001)	180 nm (Intel)	≈ 180 nm	250–280 nm	110–120 nm	~28.1 M (P3/Celeron, 128 KB L2)	—	~95 mm²(CPU est.)	~0.3 MTr/mm² (CPU est.)	2.9 GFLOPS (SSE)	~150 (est.)	—	~20–30 W	x86 (SSE baseline)
AMD Athlon 64 (Clawhammer, 2003)	130 nm (SOI)	70–80 nm	190–200 nm	160 nm	105.9 M (1 core + 1 MB L2)	—	144 mm²	~0.74 MTr/mm²	~9.6 GFLOPS (SSE)	622	—	89 W TDP	x86-64 (v1)
Intel Core 2 Duo E8500 (Wolfdale, 2008)	45 nm (Intel)	≈ 35 nm	120–130 nm	90–100 nm	410 M (2 cores + 6 MB L2)	—	107 mm²	~3.8 MTr/mm²	50.6 GFLOPS (SSE)	1 323	—	65 W	x86-64 (v2)
Jaguar APU (PS4 Launch 2013)	28 nm (TSMC HPM)	≈ 25 nm	112 nm	80 nm	~450 M (2×4-core + L2)	~1.31 B (GCN 1.0)	347 mm² APU ~160 mm² CPU	~1.3 MTr/mm² CPU ~5.1 MTr/mm² APU	102.4 GFLOPS (SSE/AVX)	~545 (est.)	1840 GFLOPS (18 CU)	~75–100 W (APU)	x86-64 (v2)	~$60 ($83 in 2026)–$80 ($111 in 2026) / die
Intel Core i7-6700K (Skylake, 2015)	14 nm (Intel)	≈ 20 nm	70–78 nm	42 nm (Mx)	1.75 B (4-core + iGPU + L3)	~0.184 B (HD 530)	122 mm² (uncore) 82 mm² (CPU est.)	~14.3 MTr/mm²	270 GFLOPS (AVX2)	2 498	347 GFLOPS (24 EUs)	91 W TDP	x86-64 (v3)
Zen 2 APU (PS5 Oberon, 2020)	7 nm (TSMC N7)	≈ 18–20 nm	54–57 nm	36 nm	~2.8 B (8 cores + 8 MB L3 est.)	~7.8 B (RDNA 2, 36 CUs)	308 mm² (full APU)	~34.4 MTr/mm² (APU)	~448 GFLOPS (AVX2 est.)	~2 050 (est.)	10280 GFLOPS (36 CU est.)	~180 W (max)	x86-64 (v3)	~$100 ($124 in 2026)–$120 ($149 in 2026) / die
Intel Core i5-12600K (Alder Lake, 2021)	Intel 7 (10 nm)	≈ 17–18 nm	54 nm	30 nm (M0)	~3.4 B (6P) ~1.1 B (4E) ~5.3 B (uncore)	~0.8 B (Xe-LP)	205 mm² ~64 mm² (P) + ~16 mm² (E)	~73 MTr/mm² (avg) ~80 MTr/mm² (P) ~65 MTr/mm² (E)	~650 GFLOPS (AVX2) 860 w/ AVX-512 if available	3 922	1230 GFLOPS (32 EUs)	125 W (PL1) 150 W (PL2)	x86-64 (v3) v4 if available
AMD Ryzen 5 9600X (Zen 5, 2024)	4 nm / TSMC N4P	≈ 14–15 nm	51 nm	28 nm (M0)	~8.3 B (8-core CCD, 6 active)	~0.15 B (on I/O Die est.)	70.6 mm² (CCD)	~118 MTr/mm²	1040 GFLOPS (AVX2) 2080 w/ AVX-512	4 566	~1130 GFLOPS (2.2GHz, 2 CU, RDNA 3+)	65–88 W	x86-64 (v4)
AMD Ryzen 5 Medusa (Zen 6, 2026-27) Future projection	~3 nm (TSMC N3E)	≈ 12–15 nm (est.)	~45–50 nm (est.)	~22–25 nm (est.)	~12–16 B (12-core CCD est., 8 active)	?	~100 mm² (CCD est.)	~130–150 MTr/mm² (est.)	~1470 GFLOPS (AVX2 est.) ~2900 w/ AVX-512	~5 400 (proj.)	~1540 GFLOPS (est.) (3GHz, 2 CU, RDNA 4 or 5)	~90–120 W TDP	x86-64 (v4)
GPU	Marketed Node	Gate Length	CGP	MMP	CPU Transistor Count	GPU Transistor Count	Die Size	Transistor Density	CPU Peak FP32	PassMark G3D	GPU Peak FP32	Power	API Shader Model	Yield / Cost
Radeon 8500 (R200, 2001)	150 nm (TSMC)	≈ 130–140 nm	~450 nm	~300 nm	—	60 M	108 mm²	0.56 MTr/mm²	—	7	55 GFLOPS	40 W
NV2A (Xbox GPU, 2001)	150 nm (TSMC)	≈ 130–140 nm	~450 nm	~300 nm	—	57 M	≈ 115 mm²	0.50 MTr/mm²	—	—	233 GFLOPS (fixed-function est.)	233 MHz core ~30–35 W	DirectX 8.1 SM 1.1–1.3 equiv.
Radeon 9700 PRO (R300, 2002)	150 nm (TSMC Low-k)	≈ 130 nm	~450 nm	~300 nm	—	107 M	218 mm²	0.49 MTr/mm²	—	54	260 GFLOPS	65 W	DirectX 9.0 Shader Model 2.0
GeForce 6600 GT (NV43, 2004)	110 nm (TSMC)	≈ 95 nm	~340 nm	~220 nm	—	146 M	156 mm²	0.94 MTr/mm²	—	143	320 GFLOPS	65 W	DirectX 9.0c Shader Model 3.0
GeForce 7600 GT (G73, 2006)	90 nm (TSMC)	≈ 80 nm	~300 nm	~180 nm	—	177 M	127 mm²	1.39 MTr/mm²	—	237	360 GFLOPS	40–56 W	DirectX 9.0c Shader Model 3.0
HD 3870 (RV670, 2007)	55 nm (TSMC)	≈ 45 nm	180 nm	110 nm	—	666 M	192 mm²	3.5 MTr/mm²	—	552	800 GFLOPS	105 W
HD 4870 (RV770, 2008)	55 nm (TSMC)	≈ 45 nm	180 nm	110 nm	—	956 M	263 mm²	3.6 MTr/mm²	—	1 385	1150 GFLOPS	160 W
HD 5870 (Cypress, 2009)	40 nm (TSMC)	≈ 35 nm	140 nm	90 nm	—	2.15 B	334 mm²	6.4 MTr/mm²	—	2 180	2720 GFLOPS	188 W
HD 6870 (Barts XT, 2010)	40 nm (TSMC)	≈ 35 nm	140 nm	90 nm	—	1.70 B	255 mm²	6.7 MTr/mm²	—	2 206	2016 GFLOPS	151 W
HD 7870 (Pitcairn, 2012)	28 nm (TSMC)	≈ 24 nm	90 nm	64 nm	—	4.31 B	212 mm²	20.3 MTr/mm²	—	4 570	2560 GFLOPS	175 W
GTX 970 (GM204, 2014)	28 nm (TSMC)	≈ 24 nm	90 nm	64 nm	—	5.2 B	398 mm²	13.1 MTr/mm²	—	9 650	3900 GFLOPS	145 W
GTX 1070 (GP104, 2016)	16 nm (TSMC 16FF+)	≈ 20 nm	78 nm	44 nm	—	7.2 B	314 mm²	22.9 MTr/mm²	—	13 500	6500 GFLOPS	150 W
RTX 2060 (TU106, 2019)	12 nm (TSMC N12)	≈ 18 nm	66 nm	40 nm	—	~6.8 B (CUDA/shaders) ~1.7 B (RT cores) ~2.3 B (Tensor cores)	445 mm²	24.3 MTr/mm²	—	14 110	6500 GFLOPS	160 W
RX 5600 XT (Navi 10, 2020)	7 nm (TSMC N7)	≈ 18–20 nm	57 nm	40 nm	—	10.3 B	251 mm²	41.0 MTr/mm²	—	15 920	7190 GFLOPS	150 W	DirectX 12 Shader Model 6.5
RTX 3060 (GA106, 2021)	8 nm (Samsung 8N)	≈ 16–18 nm	64 nm	44 nm	—	~8.1 B (CUDA/shaders) ~1.4 B (RT cores) ~2.5 B (Tensor cores)	276 mm²	43.5 MTr/mm²	—	17 000	12700 GFLOPS	170 W
RX 7600 (Navi 33, 2023)	6 nm (N6) 5 nm (N5)	≈ 14–16 nm	51 nm	28 nm	—	~18.1 B (shaders) ~1.4 B (RT) ~1.3 B (AI/matrix)	204 mm²	102 MTr/mm²	—	16 580	21800 GFLOPS	190 W
RTX 4060 (AD107, 2023)	4N (TSMC N4)	≈ 12–14 nm	49 nm	28 nm	—	~11.2 B (CUDA/shaders) ~2.1 B (RT cores) ~5.6 B (Tensor cores)	144 mm²	131 MTr/mm²	—	19 550	15100 GFLOPS	115 W
RX 9060 XT (Navi 44, RDNA 4, 2025)	4NP (TSMC N4P)	≈ 12–14 nm	49–51 nm	28 nm	—	~22.4 B (shaders) ~1.9 B (RT) ~2.2 B (AI/matrix)	200 mm²	132.5 MTr/mm²	—	19 850	20000 GFLOPS	160 W
RTX 5060 (GB205, Blackwell, 2025)	4NP (TSMC N4P)	≈ 12–14 nm	49 nm	28 nm	—	~18.5 B (CUDA/shaders) ~3.8 B (RT cores) ~8.8 B (Tensor cores)	263 mm²	118 MTr/mm²	—	20 850	25000 GFLOPS	170 W

CGP Scaling and Microprocessor Law Eras

Recommended Reading

Check out the Displays, Controllers, and Input lag pages for additional context. Websites like PCPartPicker can help with hardware selection.

Demanding Emulation

Main article: #Recommended Specifications

If you're aiming for demanding emulation ▰▰▱ and ▰▰▰ (e.g., 3D arcade boards, Pentium II emulation, PS2, Xbox, GameCube, or newer systems), avoid mobile devices and low-power Single Board Computers (SBCs) like the Raspberry Pi. ARM architectures (predominantly found in mobile and handheld systems) performance is generally insufficient for these tasks due to thermal and power limitations. Even recent Android-based handhelds such as Retroid Pocket 5, or handheld gaming computers such as the Steam Deck, may struggle to meet the requirements. Mini-PCs offer a significant leap in performance for emulation. However, while mobile and handheld SoCs excel in short, bursty synthetic benchmarks, they lack the sustained multithreaded performance of an actively cooled, dedicated desktop system during prolonged, demanding workloads. For example: the moment you hit "Export" or apply heavy multi-layered effects (like noise reduction), the A19 drops back down to Earth. Because it only has 2 performance cores (assisted by 4 high-efficiency cores), it lacks the raw multithreaded muscle of a desktop. That is why you should always look for sustained power target performance; such paper tiger mobile chips simply cannot compete with a desktop PC featuring a dedicated graphics card, which will export that same timeline 3 to 4 times faster.

Currently, FPGA-based retro hardware recreations (such as MiSTer FPGA or Analogue consoles like Mega Sg, Super Nt, and Duo) do not support emulation of demanding systems.

For notebook/laptop and handheld gaming computers

Look for a CPU such as Zen 4 or newer Ryzen notebook APUs (7040 series or later) or Ryzen handheld APUs (Z1 or later) that offers AVX-512 support. Ideally, opt for Zen 5-based processors featuring Radeon 8000S-series integrated graphics (such as the Ryzen AI Max 300 or 400 series) or newer. Desktop CPUs outperform laptop variants due to higher clock speeds and superior cooling. Mobile GPUs with the same name as desktop parts (e.g., RTX 4060 mobile) are significantly slower—typically 50–60% of desktop performance. Power limits are usually 80–140 W for the GPU (compared to 200 W+ on desktop). Under prolonged load, clock speeds drop noticeably, and single-thread CPU performance suffers most. Some "desktop-replacement" laptops use actual desktop CPUs, but they are very heavy (>4 kg), loud, and expensive.

Architecture Recommendation

For both development and end-user performance, x86-64 (AMD64/Intel 64) remains by far the most practical target architecture. Other architectures (e.g., PowerPC, SPARC, MIPS, IA-64, Alpha, PA-RISC, 68000) lack support. In cases where emulation is possible, it typically requires an additional layer of x86 emulation just to run the emulator itself on the non-x86 host, resulting in degraded performance. Native emulators for these are rare or outdated.

Development and maintenance of software emulators and related libraries on ARM-based systems receive considerably less attention than on x86. Several developers have cited the often hostile or "toxic" community surrounding certain ARM-focused emulation projects as a contributing factor. Additionally, the vast majority of ARM users are on battery-powered mobile devices (smartphones and tablets), which inherently have stricter thermal and power limitations compared to the typical x86 user base found on desktops, laptops, mini-PCs, and high-performance handheld gaming computers.

Developers targeting complex emulation projects benefit enormously from deep familiarity with the x86/x86-64 instruction set architecture (ISA), its extensions (SSE, AVX, etc.), and the mature tooling ecosystem built around it over decades. Desktop-class operating systems (Windows and Linux on x86) provide fairly stable, well-documented drivers, libraries, system functions, and graphics APIs (OpenGL, Vulkan, Direct3D) that emulator authors rely on heavily. Equivalent low-level APIs and driver quality on ARM Linux or mobile platforms are often less mature, more fragmented, or simply absent, making performance-critical development far more difficult.

The professional toolchain—IDEs (Visual Studio, CLion), debuggers (WinDbg, x64dbg, GDB/LLDB with full extensions), profilers (VTune, RenderDoc, PIX), and reverse-engineering tools (Ghidra, IDA Pro, Binary Ninja)—was developed and remains most mature on x86-64. On ARM, many of these tools are either unavailable natively, run under emulation with reduced functionality, or suffer from missing features and instability that make day-to-day development noticeably harder.

For demanding emulation, dynarec and Just-In-Time (JIT) compilation support is vital for good performance. Apple Silicon (macOS) is not an exception within the ARM world; unlike iOS/iPadOS where 'jailbreaking' might be needed to enable JIT, emulators on Mac systems typically utilize JIT without such modifications. However, graphics performance in emulation on Macs is significantly influenced by Apple's native Metal API. Software relying on Vulkan or OpenGL may use wrappers like MoltenVK to run on Metal, or may use older, deprecated versions of OpenGL, which can impact efficiency compared to native Metal implementations. See high and low-level emulation for more information about which methods are used when emulating components or entire systems.

Overclocking (advanced)

Overclocking your CPU, GPU and DRAM, including boosting clock speeds and tightening memory timings, can potentially increase emulation performance, particularly on desktop PCs with robust cooling like AIO, custom water cooling, or delidded chips with liquid metal.

Efficient and high-quality VRM components (capacitors, chokes, MOSFETs) with good thermal performance are crucial for longevity of your motherboard and CPU. Optimizing Load-Line Calibration (for balanced vDroop and low voltage ripple/minimal VPPmax) and VRM switching frequency (e.g., 250–300 kHz) help minimize heat while maintaining stability and sustained overclocks.[15] Keep CPU voltages within safe limits to prevent degradation, and maintain load temps below recommended levels with efficient cooling and profiles. Both voltage and temperature thresholds vary by chip, so verify your specific hardware specifications.

For heavy emulation workloads, you can reduce voltage and heat while preserving high clocks. The "silicon lottery" affects overclocking potential due to manufacturing tolerances and binning, so test stability thoroughly to avoid crashes or WHEA errors. Always verify your PSU, voltage regulator and VRM limits before attempting overclocking. Laptops and handhelds have limited thermal capacity, making overclocking riskier and less effective.

For NVIDIA GPUs, managing power states (P-states) is critical when overclocking. Many applications default to P2 states (balanced 3D/compute mode with lower memory clocks) instead of P0 (max performance). You can force P0 via tools like NVIDIA Inspector or nvidia-smi (nvidia-smi -pm 1) for consistent core and memory clocks. Alternatively, use MSI Afterburner's voltage/frequency curve to target stable undervolts (e.g., 0.95–1.0V at 2.7–3.0 GHz) for efficiency. Monitor P-states to avoid throttling, especially in GPU compute-heavy emulators.

Software tools cannot match the precision of hardware-based measurements (e.g., using an oscilloscope connected to CPU die-sense pins, with ~150 μs transients). HWiNFO and similar tools rely on motherboard sensors and polling intervals (typically milliseconds), which are too slow to accurately measure rapid voltage fluctuations (microsecond range) like Vppmax (peak-to-peak voltage ripple) during load transitions.

Videos

High-end cooling and overclocking techniques utilized by enthusiasts (not LN2 extreme cooling). For example: utilizing a Watercool MO-RA IV 600 radiator (mounted on a balcony for sub-ambient air intake) with Koolance EXC-900 chiller to maximize thermal headroom. The CPU is delidded for direct-die cooling, significantly reducing the thermal resistance between the silicon and the water block. Die lapping/thinning involves physically grinding down the silicon crystal of the die itself to improve heat transfer. These videos demonstrate real-world testing of high-end emulation performance under sustained, high-frequency overclocks that would be impossible on standard consumer cooling. See also Intel-based PC emulator comparisons for additional high-end emulation testing.

Load video

YouTube

YouTube might collect personal data. Privacy Policy

Continue Dismiss

Load video

YouTube

YouTube might collect personal data. Privacy Policy

Continue Dismiss

Load video

YouTube

YouTube might collect personal data. Privacy Policy

Continue Dismiss

Load video

YouTube

YouTube might collect personal data. Privacy Policy

Continue Dismiss

Load video

YouTube

YouTube might collect personal data. Privacy Policy

Continue Dismiss

Modern Hardware Issues

Also see High and low-level emulation#Modern Graphics Backends section.

Hardware	Issues	Impact on Emulation	Mitigation	Description
Intel CPUs (Raptor Lake+)	Voltage instability, crashes	Crashes, stuttering	Update BIOS/microcode, use Windows 11, disable E-cores	The issue of voltage instability and crashes with recent Intel CPUs has been widely reported since late 2023. While Intel has identified microcode issues and motherboard manufacturers have released numerous BIOS updates to address this, it's not a single, universally "fixed" problem. The situation often varies by specific motherboard model, BIOS version, and even silicon lottery. Users often need to apply the latest BIOS, and some still experience issues depending on their specific workload or system configuration. Therefore, it's an ongoing effort that requires continuous updates from both Intel (microcode) and motherboard vendors (BIOS).
Intel CPUs (Raptor Lake+)	OS scheduler issues	Stuttering, reduced FPS	Use Windows 11, CoreDirector tool	Hybrid CPU architectures featuring performance cores (P-cores) and efficiency cores (E-cores)—introduced with Intel's 12th Generation and continued in subsequent architectures like Raptor Lake—rely on advanced OS scheduling to allocate tasks efficiently. The Windows 11 scheduler was specifically designed for these hybrid layouts and generally outperforms Windows 10 in task distribution. However, edge cases remain. Demanding applications like certain emulators can still benefit from manual core affinity tools (such as Process Lasso or CoreDirector), though many modern emulators have begun implementing native core pinning. While performance has substantially improved, scheduler optimization remains an ongoing development, and some workloads may still require manual tuning to achieve an ideal balance.
Intel ARC GPUs	DirectX 9.0c (also see Windows NT 5.x emulators)	Latency, graphical glitches	Use DirectX 12/Vulkan, update drivers	At the launch of Intel Arc GPUs, DirectX 9 support was notably poor because Arc GPUs handle DX9 API calls via a wrapper (D3D9On12), rather than natively. Intel acknowledged this and consistently released driver updates throughout 2022 and 2023 that significantly improved DX9 support in many titles. While performance has improved dramatically, it's still a wrapper, which can inherently introduce some overhead or minor compatibility quirks compared to native DX9 support on older hardware.
Intel ARC GPUs	Driver stability	CPU overhead, game-specific bugs	Driver updates	Intel Arc GPUs are a relatively new architecture, so driver maturity takes time. They have been on an aggressive schedule of driver releases so far, frequently addressing bugs, improving performance and reducing CPU overhead in various games and applications. While each update brings progress, new issues can sometimes emerge or existing ones might require further refinement.
AMD RX and RX XT GPUs	Vulkan performance	Performance drops, artifacts	Use DirectX, update drivers	Specific emulators can expose unique behaviors or bugs: issues like performance drops due to "barrier region bit" or driver timeouts are examples of ongoing challenges that require continuous driver refinement. Interestingly, the barrier and driver timeout bugs have almost exclusively been a Windows driver issue. If you run the same RX cards on Linux using the open-source RADV Mesa driver, these Vulkan emulation issues are virtually non-existent. In PCSX2, if you still experience a driver timeout/crash while using Vulkan on an RX card, it is usually tied to upscaling (e.g., running at 4x or 8x native resolution) mixed with High/Maximum Blending Accuracy.
Nvidia GPUs	Driver regressions	Crashes, micro-stuttering, driver timeouts (TDRs), and geometry/texture flickering.	Roll back drivers, use DDU for a clean install, or adjust emulator-specific synchronization settings.	Recent "Game Ready Driver" updates can introduce regressions in complex graphics pipelines. A prominent example is RPCS3's ZCULL (Z-Cull) Accuracy, where strict synchronization can trigger driver timeouts, severe stutters or graphical issues on recent drivers. Setting ZCULL Accuracy to 'Relaxed' fixes almost all of the issues. However, it's worth noting that some minor depth-buffer desync can still happen on occasion. Don't be surprised if you catch a tiny bit of graphical issue and flickering every now and then, a behavior that also occasionally impacts Xbox 360 emulation via Xenia Canary and Xenia Edge.
Fixed
AMD RX and RX XT GPUs	OpenGL performance	Slow rendering, graphical bugs	Switch to alternative renderer backends ✔️ Fixed with Adrenalin 22.7.1 See AMD Driver Update	For many years, AMD's OpenGL driver performance and stability have generally been considered less robust than Nvidia's, particularly for applications and emulators that used OpenGL. While AMD has made strides, and modern emulators often offer DirectX 11/12 or Vulkan backends as well, native OpenGL performance can still be a weaker point. The common mitigation of switching to alternative backends indicates that while there are ways to achieve good performance, the core OpenGL driver may not always be optimal.
AMD RX and RX XT GPUs	Fragment shader interlock	Suboptimal performance	Use Adrenalin 24.12.1 or later, test configurations	VK_EXT_fragment_shader_interlock was added in Adrenalin 24.12.1. However, the presence of a feature doesn't always equate to immediate, fully optimized performance that matches competitors in all scenarios. While the feature now exists natively, its implementation may still benefit from further optimization or refinement for specific emulator workloads or hardware interaction.

Build Guide for Emulation

Aspects to prioritize: Instead of sinking hundreds of dollars into RGB gimmicks and bloated configuration drivers, focus on objective engineering. For emulation, fast-paced retro shooters, and single-threaded workloads, you can achieve elite performance by hunting second-hand enterprise and vintage hardware.

X86 (recommended)

CPU

• Prioritize Single-Core Performance: This is the top factor for emulator performance. Focus on CPUs with high Instructions Per Clock (IPC), typically found in newer generations and architectures. Shader stutters are totally normal for ≥ seventh-gen emulation. If available, using Pre-built Shader Caches (if compatible) or Async Shader Compilation option (if available) can cut down stutter intervals (faster compilation = smoother runs). See TechPowerUp emulation chart, CPU Tier List for RPCS3 and John IV's MAME Benchmarks for benchmarks with emulators. If you don't have the time to research, it is recommended to get one of the most single-thread price/performance value chip on the market while considering the factors mentioned below.

• AVX2 and x86-64-v3 Support: Consider this a baseline requirement for a modern emulation build. Many emulators use AVX2 instructions to significantly speed things up nowadays. Ensure any CPU you consider supports it.

• AVX-512 and x86-64-v4 exist and can offer benefits in specific emulators due to more registers or specific instructions, but support is less widespread, hardware implementations vary, and it's less critical than strong AVX2 support for most users currently. Early implementations sometimes required multiple clock cycles for certain operations or could cause the CPU to downclock significantly under heavy load due to power/heat constraints, potentially negating performance gains in some scenarios. Newer implementations are better (e.g., Zen 5). The AMD Zen 5 desktop address the limitations of prior designs by implementing a native 512-bit vector datapath in the Floating-Point Unit, which allows most AVX-512 instructions to execute in a single clock cycle, significantly doubling the vector throughput compared to the double-pumped 256-bit AVX-512 execution used in Zen 4. Critically, Zen 5 was designed for power efficiency, allowing it to execute heavy AVX-512 code with minimal to no frequency downclocking, directly solving the major performance-negating issue that plagued older, high-end Intel Skylake-X and similar implementations. This consistency and the native throughput make Zen 5's AVX-512 support a more reliable and substantial performance booster for optimized applications, including emulators that benefit from the instruction set's features like the doubled number of registers (32 ZMM) and specialized instructions like VNNI. Looking ahead, AMD's Zen 6 architecture (confirmed via znver6 ISA manuals and GNU compiler patches) introduces further extensions, including AVX-512-BMM, AVX-IFMA, AVX-NE-CONVERT, and AVX-512-FP16. However, because these new extensions primarily target machine learning inference, low-precision AI data types, and specific cryptographic/mathematical matrix operations, they are unlikely to yield meaningful performance breakthroughs for core console emulation workloads. There are various rumours about power consumption of AVX-512 since the Skylake X's implementation, see this video, which addresses those concerns. Also see uops.info, and PlayStation 3 emulators#Emulation issues section for more information. That is to say, the kinds of AVX-512 optimizations that RPCS3 (and other emulators such as Yuzu, Citra, Vita3k, Xenia) makes are actually fairly broadly applicable across consoles. But since any machine that supports AVX-512 should be fast enough to run older systems like N64 or PS2 games at full speed, the gains would be in power efficiency rather than performance.[16]

• Future-looking tech to watch: Intel's patented Software-defined super cores (SDC) concept could potentially improve single-threaded IPC in coming generations by allowing software to dynamically fuse multiple physical cores into a virtual "super core" for demanding single-threaded sections (like heavy emulator CPU loops). This would split instructions across cores while preserving program order and OS transparency, offering higher effective performance without traditional core-widening power costs. (See patent EP4579444A1 on Google Patents and coverage from Tom's Hardware, TechPowerUp). As of 2026 this remains patented research, not yet in consumer hardware — but if realized, it may further reduce the need for extreme single-core clock chasing in emulation builds.

• Core Count: Multithreading is often irrelevant prior to PlayStation 3 emulation. While CPUs with very high IPC performance are usually recommended for emulation, most modern CPUs feature 6 or more cores with higher clock speeds than earlier-generation HEDT CPUs. This advancement means that selecting a modern higher core-count CPU no longer presents a disadvantage; in fact, it often offers superior performance for emulation due to higher clock speeds.

• Minimum: Aim for at least 6 cores / 12 threads. If using a 12th Gen Intel CPU or newer, this refers to P-cores rather than physical cores. E-cores are generally not suitable for emulation, since emulators like PCSX2 and other updated popular emulators will pin workloads to the performance cores.
• Recommended: 8 cores / 16 threads is a good sweet spot for handling demanding emulators alongside module compilation and shader compilation and background tasks.

• If you're into virtualization, look for AMD-Vi or Intel VT-d supported chips and IOMMU supported motherboards.[17][18][19]

RAM

Memory performance is often an over-emphasized factor in PC building. Beyond simple capacity, emulators are primarily sensitive to memory latency because of its direct impact on CPU IPC performance. For this reason, you should prioritize low latency over raw DRAM bandwidth when optimizing for emulation.

• Dual-Channel: Do not use a single stick of RAM. Always install modules in pairs (2x8GB, 2x16GB, etc.) to enable dual-channel mode. Running in single-channel cuts theoretical bandwidth in half.
• Capacity: While 16GB is the modern baseline, 32GB is the recommended "sweet spot" for power users who multitask or use high-resolution texture packs.
• Memory Rank (Single vs. Dual): While Dual-Channel refers to the number of communication paths, "Rank" refers to how memory chips are grouped on a single stick.
  • Rank Interleaving: Dual-Rank (2R) configurations allow the CPU to access one "rank" of memory while the other is refreshing or preparing data. This "interleaving" can provide a performance boost in CPU-bound scenarios.
  • The 2-Stick Sweet Spot: To achieve the best performance without stressing the motherboard's traces (see Topology below), aim for two Dual-Rank sticks.
    • In DDR4, this is usually found in 16GB or 32GB sticks.
    • In DDR5, high-density chips mean most 16GB sticks are Single-Rank; you generally need 32GB sticks (64GB kit) to ensure a Dual-Rank configuration.
  • 4-Stick Caveat: Using four Single-Rank sticks effectively creates a Dual-Rank environment per channel, but this is harder on the Integrated Memory Controller (IMC) and often limits your maximum stable frequency.

For those looking to maximize performance, the specific physical, signaling and electrical characteristics of the memory subsystem matter:

• Mainboard Topology: The physical layout of the motherboard's traces affects signal integrity. Most consumer boards use a Daisy Chain layout (optimized for 2 sticks). Using 4 sticks on these boards creates electrical "stubs" that can severely limit stable overclocking frequencies compared to a 2-stick configuration.
• Module Standards: Be aware of the mechanical and electrical differences between standard UDIMM, the newer CUDIMM (which incorporates a clock driver on the module for higher stability at extreme speeds), and the SFF-focused CAMM2 standard. Reference: DIMM vs. CUDIMM vs. CAMM2.
• Memory ICs & Binning: The quality of the underlying silicon chips (ICs) dictates how tightly you can tune your timings.
  • Top-Tier ICs: Target kits using Samsung B-die (DDR4) or Hynix A-die/M-die (DDR5) for the best frequency-to-latency ratios.
  • Revisions: Even within the same model, manufacturers may swap ICs. Specific revisions (e.g., v5.56 for certain Corsair kits) can indicate a change in the underlying chip supplier, affecting stability at XMP/EXPO profiles.
• QVL (Qualified Vendor List): Always check your motherboard manufacturer's QVL to ensure the specific kit and its revision have been verified to run at rated speeds on your board's BIOS.

For deep technical dives into memory PCB layouts, VRMs, and silicon binning, refer to buildzoid on YouTube. If you want to keep it simple: prioritize getting two sticks of RAM to ensure dual-channel performance, and choose a total capacity that fits your needs and budget.

GPU

Choosing the right GPU for emulation is more important now than it used to be. This increased importance is due to recent advancements like compute shader renderer implementations. Actively maintained popular emulators may leverage specific modern GPU hardware features and APIs for optimized rendering. Graphical and post-processing enhancements (e.g., resizable internal resolution, texture filtering hacks, aspect ratio hacks, texture replacement, ray-tracing/screen-space ray-traced global illumination shaders, internal framerate hacks, frame generation technologies, AI powered filters, post-processing options such as shader chains/presets offered by modern emulators, or using EmuVR instead of standalone emulator software) demand higher GPU performance.

• Minimum: Direct3D 12 (Feature Level 12_1) and/or Shader Model 6.6 supported GPUs.
• Recommended: Vulkan 1.4 (see Vulkan Database / Khronos List), or Direct3D 12 Ultimate (Feature Level 12_2) and Shader Model 6.8 support (see TPU GPU Database).
  • References: Khronos Vulkan Registry and List of Vulkan extensions used in RPCS3.
• GPU with drivers still up-to-date.
• If you're heavily into virtualization, you could look for a GPU that supports SR-IOV or GPU Paravirtualization.
• Choose one of the latest GPU models available on the market within your budget. See these webpages: [20] [21]

Cooling

See GamersNexus Cooler Reviews.

PSU

See this PSU Tier List and thefpsreview.com's PSU reviews.

ARM

CPU

• Minimum: A core with SVE (Scalable Vector Extension) support. SVE was introduced in ARMv8.2-A, but remained optional for many years. Nearly all smartphone and application processor cores based on ARMv8.2-A through ARMv8.5-A (including Cortex-A75, A76, A77, A78, and derivatives such as Kryo 300/400/500 series) do not implement SVE. They only support fixed 128-bit NEON/ASIMD. The earliest widely available consumer core with SVE is the Cortex-A710 (ARMv8.6-A). Choose a device with A710 or newer if possible.
• Recommended: A core with SVE2 support. SVE2 is mandatory starting with ARMv9.0-A and is present in ARMv9.2-A cores. Cortex-A715, A720, X3, X4, X925, and newer; or recent Qualcomm Kryo cores based on ARMv9-A (Kryo Mobile 8 series and later).

GPU

Choose Snapdragon Adreno platforms for GPU as much as possible due to better driver support and potentially better capabilities regarding API and libraries.

Storage

Storage is a critical component when building a system for emulation and preservation, as it affects capacity and data longevity. Recommended to see storagereview.com's reviews for SSDs, backblaze's hard drive failure rates chart for HDDs.

Types of approach and storage

• Hot Storage: Data you access frequently, like emulators, ROMs, or save files. SSDs (especially NVMe) are best for hot storage due to their performance.
  • Solid-State Drives (SSDs) with DRAM Cache: These are useful for heavy workloads like frequent data transfers and read/write tasks, minimizing latency, and ensuring consistent efficiency during sustained, high-intensity workloads.
• Cold Storage: Data accessed infrequently. HDDs or NAS are cost-effective for cold storage, prioritizing capacity and reliability over performance.
  • Hard Disk Drives (HDDs): These are ideal for "cold storage" (long-term archival of multimedia disc and disk images, proper literature scans, audiobook, or backups etc.) where access speed is less critical. Make sure the drive is CMR, not SMR.
  • Network-Attached Storage (NAS): NAS is perfect for securely storing and sharing large game archives across multiple devices, with redundancy options like RAID to protect against data loss.
  • Cloud Storage: Cloud storage is perfect for secure, scalable backups of game archives with protection against local drive failures. It can be a strong alternative to NAS for users with a robust internet connection, offering similar off-site redundancy without the need for local hardware setup.
• Hybrid Approach: Combine a smaller SSD (1TB) for hot storage with a larger HDD (8TB+) or NAS for cold storage to balance performance and capacity.

Peripherals

Main article: Input lag

Main article: Controllers

Main article: Displays

• Mouse: Modern marketing often pushes hyper-inflated CPI/DPI numbers, but these are rarely native hardware resolutions. Instead, manufacturers use a digital multiplication matrix and firmware interpolation to artificially scale up a lower native sensor resolution. This digital processing forces the mouse microcontroller (MCU) to run aggressive smoothing and ripple-reduction algorithms to clean up the jittery, upscaled path—introducing artificial tracking latency and pixel-skipping. For a cheaper and good enough tracking experience, consider affordable, retro optical mice like the Microsoft Wheel Mouse Optical 1.1A (WMO 1.1A) or IntelliMouse 3.0. The STMicroelectronics MLT04 sensor inside these mice features excellent, prediction-free, zero-interpolation native tracking. While natively locked to a low 400 DPI, you can use community USB polling rate overclocking tools (such as hidusbf) to safely force the hardware polling rate from 125 Hz to 500 Hz or 1000 Hz.
• Keyboard: Avoid expensive, thin, plastic "gaming" RGB mechanical keyboards with soldered linear switches. Some of these cost as much as retro buckling-spring keyboards, such as the classic IBM Model M or modern Unicomp boards.
  • Spring-over-dome / High-Quality Rubber Domes: Vintage enterprise keyboards like the IBM KB-9910 utilize thick, high-durability rubber sheets and snappy sliders. They offer good structural stability, crisp actuation tactile bumps, and can easily be pulled out of e-waste or thrift stores for under $10.
• Case: Vintage beige or black steel ATX cases from the late 90s to mid-2000s cost next to nothing. Unlike modern thin aluminum and tempered glass chassis, heavy-gauge vintage steel is exceptionally good at absorbing high-frequency fan whine and coil whine.
  • Modification Note: Ensure the case adheres to the standard ATX specification. You may need to use a rotary tool or a step-drill bit to expand old, restrictive 80mm fan mounts into high-airflow 120mm layouts to properly feed modern hardware.
• VGA CRT Monitors: For retro emulation, a quality VGA CRT monitor (e.g., Sony Trinitron, ViewSonic, or high-end Dell models) is superior to low-tier LCDs. They offer true zero sample-and-hold motion blur, instantaneous pixel response times, and perfect black levels. Because CRTs handle multisync resolutions natively without digital interpolation artifacts, you can drop your rendering resolution down to 1024x768 or 1280x1024 for demanding tasks—maintaining pristine visual clarity while saving massive amounts of GPU rendering power.
• Audio Systems: Modern audio marketing pushes consumers toward expensive "Hi-Fi" or "Gaming" headphones that often feature thin, short-lifespan drivers, flaking faux-leather pads, and fragile plastic headbands. Furthermore, long-term, high-volume headphone use puts direct acoustic pressure on the tympanic membrane, increasing the risk of permanent hearing damage and ear canal fatigue. Instead, look for second-hand, high-end home media shelf systems from the late 90s and 2000s, such as the Sony MHC-WZ8D.
  • These legacy systems support an array of physical formats (Audio CD, VCD, SVCD, DVD, and Cassette) and feature robust, heavy-gauge internal power transformers with discrete amplifier circuits. When paired with their native multi-way wooden speaker cabinets, they deliver rich, expansive sound stages and hardware-driven bass that cheap plastic desktop speakers or thin headphone drivers cannot physically replicate. Because they fill the room rather than sealing off your ears, they provide a much safer, fatigue-free listening experience for long gaming or emulation sessions, and can often be found on local classifieds for a fraction of their original launch price.
• Smartphone as a Webcam (via Iriun/Camo/DroidCam): Spending $100 to $200 on a dedicated "Pro" USB webcam for standard video conferencing and presentations is an absolute waste of money. Consumer webcams are structurally limited by tiny, cheap image sensors and poor low-light optics, resulting in grainy, heavily compressed video if your room lighting isn't perfectly studio-grade.
  • The smartphone you already own contains a highly sophisticated camera array, featuring superior dynamic range, rapid autofocus, and dedicated Image Signal Processing (ISP) silicon. By utilizing software tools like Iriun Webcam, Reincubate Camo, or DroidCam over a high-bandwidth USB connection (or stable Wi-Fi), you can pipe your phone's main rear camera directly into your PC as a virtual webcam. This setup instantly outperforms expensive dedicated webcams in clarity, color accuracy, and low-light handling for absolutely zero hardware cost.
  • Always use the phone's rear camera instead of the front selfie camera, as the rear sensor is significantly larger and utilizes better optics. Pair it with a cheap $5 flexible tripod or phone clamp for stable positioning.
• Mousepad: A common misconception is that mousepads are an aesthetic luxury or purely for wrist comfort. From an engineering standpoint, they are a functional extension of the mouse's optical sensor tracking system.
  • An optical mouse does not track by rolling over a surface; it is a high-speed camera (imaging array) that takes thousands of microscopic black-and-white pictures per second of the surface beneath it. The mouse's internal Digital Signal Processor (DSP) compares these sequential images, analyzing the movement of microscopic shadows and highlights to calculate distance and direction vectors.
  • If a mouse is used on a perfectly smooth, uniform, or semi-glossy desk surface, the sensor's camera sees a featureless, blank void. Without distinct contrast points, the DSP cannot detect changes between image frames, resulting in pixel-skipping, cursor jitter, or complete tracking loss.
  • You do not need a $50 "premium branded" gaming mousepad. A cheap, stitched-edge cloth pad—or even a large sheet of dense, matte-finish desk blotting paper—provides the exact random microscopic fabric weave (micro-texture) needed to create high-contrast shadows under the mouse's LED/laser illumination. This ensures 100% accurate, raw sensor tracking for a few dollars.
• Gamepad: Avoid dropping over $100 on heavily marketed "pro" or "gaming" controllers from "Gamer" brands, which frequently suffer from premature stick drift, fragile microswitches, and planned obsolescence. Instead, look for a genuine, retro controllers like DualShock 2 (DS2) featuring true analog pressure-sensitive buttons. If buying retro, verify the controller is an original OEM model, as cheap clones feature terrible, blocky deadzones. For modern alternatives, look for affordable, wired third-party controllers that prioritize robust build quality specifically targeting stable analog stick deadzones and a hardwired USB connection. Opting for a wired controller completely eliminates the artificial lifespan limitation of non-replaceable internal lithium batteries, ensuring the hardware remains functional for decades at a fraction of the cost.

Smart Spec vs. Marketing Gimmicks

Component	Marketing Trap (Avoid)	Practical Alternative (Buy Second-Hand / Value)
Mouse	$150 "Ultra-Gaming" 16K DPI mice with bloated software.	Microsoft WMO 1.1A or IntelliMouse (Overclocked via OS).
Keyboard	$120+ RGB mechanical decks with cheap plastic chassis.	Vintage IBM Buckling Spring or enterprise IBM KB-9910 dome-switch.
Case	$100+ Glass "aquarium" cases with proprietary RGB hubs.	Second-hand heavy steel retro ATX case modified for modern 120mm airflow.
Display	$300 "1ms response" marketing-myth flat panel LCDs.	Quality vintage VGA CRT Monitor for zero motion blur and native scaling.
Cooler	$150 RGB liquid AIO with multiple failure points.	$35 Dual-tower, high static pressure Air Cooler (e.g., Thermalright).

Operating System

For performance comparison: See Timing and Synchronization, Platform-Specific Memory and I/O Optimization sections and RPCS3's SPURS Test v1.2.1 Benchmark Results.

Prerequisites and Dependencies (Windows): For fresh Windows installations, installing commonly required runtime packages is recommended, as many applications rely on them. These include the Visual C++ Redistributable Runtimes All-in-One and the DirectX Runtime Offline Installer. Applications built with a statically linked C++ runtime do not require external VC++ redistributables, since all needed components are embedded in the executable. However, most software still depends on shared system libraries, so missing dependencies are a common cause of launch errors.

Recommended OS Settings: For the best emulation performance and compatibility, configure your OS settings using the guidelines below:

• Hardware-accelerated GPU scheduling (HAGS): Enable to improve VRAM management. Disable it only if you experience micro-stuttering, unique graphical issues that other users don't seem to encounter, or crashes.
• Game Mode: Enable. On Windows, Game Mode prioritizes system resources for the active emulator and prevents background processes or Windows Updates from causing frame drops. If you are on Linux, you can try using Feral GameMode (`gamemode`) for emulators that have resource prioritization issues. It dynamically switches your CPU governor to performance mode, optimizes process priorities, and maximizes GPU clock rates while an emulator or game is active. Run your emulators using the `gamemoderun` prefix (e.g., `gamemoderun Ryujinx`), or append `gamemoderun %command%` in Steam or front-end launch options.
• Resizable BAR / Smart Access Memory (SAM): Enable. Modern graphics-heavy emulators benefit significantly from allowing the CPU direct, unrestricted access to the GPU's entire VRAM pool.
• Windows Display Scaling (DPI): Global Windows scaling can cause blurry video or broken mouse-input coordinates. Keep your Windows desktop scaling to %100, and turn off automated Windows adjustments under `Settings > System > Display > Advanced scaling settings`. Always configure auto full-screen scaling directly within your GPU control panel instead.
• Mouse Acceleration Fix: Use the MarkC Windows Mouse Acceleration Fix via the `100 Scaling - No Mouse Accel.ps1` script to ensure exact 1:1 mouse tracking.
• Refresh Rate and VRR: Set your display refresh rate to its maximum supported value and enable Variable Refresh Rate (G-Sync / FreeSync) to eliminate screen tearing and minimize latency.
• Hyper-V: On Windows, Hyper-V features can negatively affect performance to varying minor degrees. There is no comparable performance problem with KVM on Linux. See the Hypervisors#Performance_impact section for more detailed information.
• Drivers: When updating or troubleshooting graphics drivers, it is always recommended to use Display Driver Uninstaller/DDU to completely remove old driver and it's remnants. NVIDIA users can use the NVCleanstall tool to install fresh drivers without bloated telemetry components. It is best practice to keep stock global settings in your GPU control panel; you can manage them via tools like nvidiaProfileInspector. Always avoid installing bloated, resource-heavy motherboard utility software suites (such as proprietary companion apps, optimization managers, or complex RGB tools). Even manual driver installation is mostly optional nowadays, as modern operating systems automatically bundle functional network and basic chipset drivers right out of the box.

Portable Software Considerations: Portable builds of emulators or tools can be useful in non-personal computer environments, plug-and-play setups, multi-boot testing, and guest-account scenarios. "Portable" does not mean the application has no OS-level dependencies; many portable programs still require runtimes such as DirectX, .NET, VC++ redistributables, codecs, etc. According to the Portable Freeware definition, an application is considered stealth when it leaves no persistent registry entries and writes no permanent files outside its own directory after being launched, used, and closed. OS-generated entries (Windows MRU lists, DirectX registration, temporary files in system Temp folders) are generally not counted. Note: "Stealth" refers only to not leaving behind application data; it does not imply anonymity or that system administrators cannot track activity. The ideal definition of portable software includes the following characteristics:

• Runs without installation.
• Functions on older or unpatched Windows versions.
• Minimal coupling to system components such as Internet Explorer, DirectX, system codecs, or .NET (unless necessary for core functionality).
• Writes its configuration files to its own directory rather than the registry or user profile.
• Leaves no permanent traces on the host machine (in ideal/"stealth" cases).
• Works under guest or limited user accounts.
• Tolerates USB drive letter changes.

In practice, few applications meet all of these requirements. Portability can be evaluated at two levels:

• Executable portability: the program runs without installation.
• Settings portability: configuration files are kept within the application directory.

Dependencies related to intended functionality (e.g., IE-based UI for a feed reader, DirectX for a game) are acceptable; unnecessary dependencies are discouraged. On Linux, portable programs often rely on static linking, where required libraries are embedded directly into the executable and configuration files reside alongside the binary. However, the GNU C Library (glibc) is generally not statically linked because updates frequently address security issues and hardware-compatibility improvements. As a result, fully static Linux applications are uncommon. Unlike Windows portable applications (which commonly store settings in the same directory as the executable), this is considered inelegant in Linux environments. Linux programs usually place their configuration files in plain-text form under the user's $HOME/.config directory. This makes them less convenient to back up compared to portable software on Windows, but it is simple to version-control with systems like Git. When reinstalling Linux, users typically use distro-wide portable packages (AppImage) or reinstall software through the package manager and restore their configuration files by copying them back into the home directory. Static binaries contain fixed versions of all embedded libraries. Updating the OS will not update these internal copies, meaning old bugs and security vulnerabilities remain inside the program until it is rebuilt. This is a primary reason why many Linux environments discourage fully static applications. Historically, Windows software often suffered from "DLL Hell": missing, overwritten, or incompatible shared libraries could break installed programs. Portable apps avoided these problems by shipping their own libraries. Native Linux packages rely on strict dependency resolution. If required libraries are missing or incompatible, the package simply cannot install or update. Packages built for one distribution often cannot be used on another due to differing package structures. Flatpak, AppImage, and Snap formats provide per-application libraries or runtime environments to enable cross-distribution portability. This improves convenience but can preserve outdated libraries, depending on update frequency. Users should balance convenience with maintenance and security considerations.

Also see

• Input lag
• Displays and Shaders, presets and filters#Display Hardware Requirements
• Controllers