Local co-op died with the living room. Most retro sessions today happen with a friend three states away, and screen-sharing tools like Parsec add a full frame of lag on top of whatever the emulator itself costs you. Netplay skips that tax by syncing inputs, not video, which is why Dolphin, RetroArch, and PCSX2 all ship (or work around) some version of it. This tutorial walks through getting all three working on PC in September 2026, from matching emulator builds to punching through carrier-grade NAT when your ISP won’t let you forward a port.
By the end you’ll have a working netplay session running on at least one of the three emulators, a router configured to pass the right traffic, and a fallback plan (ZeroTier or Radmin VPN) for the increasingly common case where your ISP blocks inbound connections entirely.
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 Emulator Netplay Actually Is
Netplay is not video streaming. Each player runs a full local copy of the emulator and the same ROM or ISO, and only controller inputs travel across the internet. Every machine simulates the game independently and stays in sync because both sides process identical input at identical frames. That’s why Dolphin’s own documentation calls netplay a way to “set up online sessions for any GameCube or Wii title with a local multiplayer mode, without the problems or limitations of the Nintendo Wi-Fi Connection or hassle of the BBA,” according to the Dolphin project.
RetroArch takes a similar approach but describes its own implementation in more technical terms. Per the official Libretro documentation, “RetroArch’s netplay code is based on replay, and provides netplay over unreliable networks free of input latency in the default configuration.” In practice that means RetroArch buffers a few frames of input and replays them if a packet arrives late, trading a small amount of delay for a session that doesn’t fall apart the moment your connection hiccups.
PCSX2 is the odd one out. The PS2 emulator has no general-purpose netplay system built into the mainline app. It does expose the PS2’s original online infrastructure for the handful of games that shipped with real online modes (think SOCOM 2 or Killzone), routed through community-run replacement servers, and a separate community fork called “PCSX2 Online” bolts on peer-to-peer netplay for titles that never had online support. This tutorial covers both paths.
The two implementation styles worth understanding before you pick a tool are peer-to-peer and client-server. Dolphin runs closer to a peer-to-peer model, where the host’s machine coordinates the session but every connected player exchanges input more or less directly, and the newer Host Input Authority option lets the host’s own copy of the game run with less delay at a small cost to everyone else. RetroArch runs a stricter client-server model: the host is the authority for the whole session, clients send their inputs to the host, and the host redistributes the combined state. Neither approach is objectively better — Dolphin’s model tends to feel snappier for the host on a 2-player match, while RetroArch’s model scales more predictably once you add a third or fourth participant or a pile of spectators.
Dolphin vs. RetroArch vs. PCSX2: Choosing the Right Netplay Path
Not every emulator handles online play the same way, and picking the wrong one for your situation wastes an evening before you’ve even loaded a game. Dolphin and RetroArch both treat netplay as a first-class feature with dedicated menus, session lobbies, and years of refinement. PCSX2 treats it as an afterthought the official team never fully built out, which changes the whole approach you need to take.
| Factor | Dolphin | RetroArch | PCSX2 |
|---|---|---|---|
| Netplay model | Peer-to-peer, host input authority optional | Client-server, delay-based replay | No native general netplay; PS2 online + community fork |
| Systems covered | GameCube, Wii only | 100+ systems via libretro cores | PS2 only |
| Max typical players | 2-4, game-dependent | 2+ plus unlimited spectators | 2, fork-dependent |
| Setup difficulty | Low — built-in menu flow | Low-medium — more config options | High — requires a separate fork or workaround |
| Best for | Melee, Smash, GameCube co-op | Retro 2-player classics, spectated matches | Select PS2 titles only |
If you’re choosing where to start, match the tool to the console you actually want to play. Chasing a GameCube fighting game through RetroArch’s Dolphin-adjacent cores isn’t going to be more reliable than just using Dolphin directly, and trying to force a PS2 racing game into online co-op through a half-maintained fork isn’t going to beat a good old-fashioned Parsec session if that fork doesn’t officially support your title. If you’re still deciding which emulator fits your library best before worrying about netplay at all, our best emulators for PC comparison is a good starting point. The rest of this guide walks through the setup for all three, in the order you’re most likely to actually need them.
Prerequisites: Versions, Hardware, and What You Need
Netplay is unforgiving about version mismatches, so confirm you’re on current builds before doing anything else. Here’s what’s current as of September 13, 2026, along with the minimum hardware you’ll want on each end of the connection.
| Emulator | Current version (Sept. 2026) | Netplay type | Default port | Min. OS |
|---|---|---|---|---|
| Dolphin (GameCube/Wii) | Development build 2603a | Native, built-in | 2626 (TCP) | Windows 10 64-bit |
| RetroArch (multi-system) | 1.22.2 (stable) | Native, built-in | 55435 (TCP/UDP) | Windows 10 64-bit |
| PCSX2 (PS2) | 2.8.0 | PS2 online + community fork | Varies by game/fork | Windows 10 64-bit |
Dolphin does not currently ship dated “stable” releases in the traditional sense; it publishes a rolling stream of numbered development builds, and 2603a (from March 2026) was the build referenced in the most recent netplay setup guides at the time of writing. Always grab whatever the current build is from the same channel your netplay partner is using, because Dolphin’s netplay code refuses to sync across mismatched versions. RetroArch, by contrast, has held at 1.22.2 since a November 2025 release and its download page still listed that build as current as of August 24, 2026.
You’ll also want: a legally dumped copy of the ROM/ISO on both machines (identical region and revision), a wired or strong Wi-Fi connection, admin access to your router, and a controller on each end (Xbox, PS5 DualSense, or 8BitDo pads all map cleanly in every emulator covered here). If you haven’t set up controller mapping yet, our Xbox controller PC setup guide covers that first.
Step 1: Confirm Both Sides Have Identical Game Files
Before touching any netplay menu, verify that you and your netplay partner have the exact same dump: same region, same revision, same file format. A US NTSC copy of a game will not sync against a PAL copy, and even a redumped ROM with a different header can throw both Dolphin and RetroArch out of sync within the first few seconds. This is the single most common reason netplay sessions fail before they even start, so don’t skip it to save five minutes.
The cleanest way to confirm a match is comparing file hashes. Open a terminal on both machines and run:
# Windows (PowerShell)
Get-FileHash "C:\ROMs\game.iso" -Algorithm SHA1
# macOS/Linux
shasum -a 1 /path/to/game.isoIf the two SHA-1 hashes don’t match, re-dump or re-source the file rather than assuming a “close enough” copy will work. RetroArch and Dolphin both check a content checksum at session start and will reject a mismatched client outright, which is actually the friendlier failure mode compared to PCSX2’s community netplay fork, which can let a mismatched pair connect and then desync mid-match.
Step 2: Update Both Machines to Matching Emulator Builds
Version mismatches are the second-most common cause of failed netplay sessions, and unlike file hashes, most emulators won’t clearly tell you that’s the problem — you’ll just see a connection that hangs or a session that desyncs a few minutes in. Community netplay guides for Dolphin are explicit that mixed versions “cause immediate desync,” and the same is true in RetroArch, where the netplay protocol version is tied to the core build.
Download links you’ll want bookmarked:
- RetroArch 1.22.2: retroarch.com
- Dolphin development builds: github.com/dolphin-emu/dolphin
- PCSX2 2.8.0: pcsx2.net
Agree on a version with your netplay partner before your session, not during it. If you’re setting up a recurring group (a weekly Melee night, a co-op GameCube campaign), pick a build and both agree not to auto-update until everyone’s ready to move together. If you haven’t installed RetroArch or Dolphin at all yet, work through our dedicated RetroArch setup guide or Dolphin emulator setup guide first, then come back here for the online piece.
Step 3: Set Up Dolphin Netplay (GameCube and Wii)
Dolphin’s netplay session is started before you load a game, not after — a detail that trips up a lot of first-time hosts who go looking for a netplay option inside the game itself. According to Dolphin’s own guidance, “a Netplay Session in Dolphin is started before actually running a game.”
To start as host:
- Open Dolphin and click Tools → Start NetPlay
- Enter a nickname and choose Host
- Select the exact game file both sides confirmed in Step 1
- Leave “Enable Chunked Upload” and “Host Input Authority” at their defaults unless you know you need otherwise — Host Input Authority reduces the host’s own lag at the cost of a bit more lag for everyone else, which is usually the right trade for a 2-3 player session
- Click Start
Dolphin will display your external IP address and the port it’s listening on (2626 by default) in the lobby window. Send that IP and port combination to whoever’s joining — this is also the point where you need port forwarding sorted, which we cover in Step 8. A successful host session shows something close to this in the lobby chat log:
[NetPlay] Started hosting on port 2626
[NetPlay] Player "HostName" (P1) - Ping: 0ms - Ready
[NetPlay] Waiting for players to connect...
[NetPlay] Player "GuestName" (P2) has joined
[NetPlay] Player "GuestName" (P2) - Ping: 42ms - Ready
[NetPlay] Game hash verified: MATCH
[NetPlay] All players ready. Starting game in 3...2...1...If you see a hash mismatch warning instead of “MATCH,” stop and go back to Step 1 before starting — launching anyway almost guarantees a desync within the first minute of play.
Step 4: Join a Dolphin Netplay Session as a Client
On the joining machine, open Dolphin, go to Tools → Start NetPlay, but this time select Connect instead of Host. Enter the host’s IP address and port (2626 unless they changed it), then hit Connect. If the connection succeeds you’ll land in the same lobby as the host and see everyone’s nickname and ping.
A few things worth checking before the host hits start: confirm every player shows a green “ready” indicator, confirm the game hash matches (Dolphin will flag a mismatch in red), and agree verbally on who’s Player 1 vs Player 2 if the game cares about controller port order — some GameCube titles hardcode behavior to a specific port.
Dolphin also supports a traversal-server connection method that skips manual IP entry in favor of a short room code, useful when the host doesn’t want to read their public IP out loud. It’s slightly less reliable than direct IP connection because it depends on Dolphin’s traversal infrastructure staying up, so treat direct-connect as your primary method and the room code as the fallback.
Step 5: Set Up RetroArch Netplay (Multi-System)
RetroArch’s netplay works across every libretro core it supports, from NES to PSP, which makes it the most flexible of the three tools here — but also the one where core compatibility varies the most. Not every core supports netplay cleanly, and cores with heavy internal timing quirks (some N64 and PS1 cores in particular) are more prone to desync than 8- and 16-bit cores.
To host a session, load your content as normal, then open the Quick Menu and navigate to Netplay. The official Libretro documentation puts it plainly: “If you are going to host a game, simply configure your network parameters and ‘Start Hosting’ from the netplay menu.”
Before hosting, set these values under Settings → Network:
# retroarch.cfg — relevant netplay keys
netplay_ip_port = "55435"
netplay_nickname = "YourName"
netplay_public_announce = "false"
netplay_use_mitm_server = "false"
netplay_delay_frames = "3"Setting netplay_public_announce to false keeps your session private and off RetroArch’s public lobby list — you’ll share the connection info directly instead. netplay_delay_frames controls how many frames of input delay RetroArch buffers before replaying; higher values smooth out unstable connections at the cost of feeling less responsive, and 3-6 frames is a reasonable starting point for a same-continent connection.
Step 6: Join a RetroArch Session and Use Spectator Mode
Joining works from the same Quick Menu → Netplay screen: choose “Connect to Netplay Host,” enter the host’s IP and port (55435 unless changed), and hit connect. RetroArch’s documentation confirms the tool “allows a second (or further) player, or spectators, to be connected via the Internet,” so beyond simple 1v1 play, RetroArch supports multiple simultaneous players on cores that natively support more than two controllers, plus spectators who can watch without occupying a player slot.
To join purely as a spectator, toggle Spectator Mode to ON before connecting. This is useful for coaching, casting a friend’s run, or just checking a connection works before committing a controller port to it. Note that RetroArch treats save states and core resets as host-authoritative during netplay — only the server (host) can load a save state or reset the core mid-session, which prevents clients from accidentally desyncing the match by loading their own local save.
Step 7: Set Up PCSX2 Online Play and the Netplay Workaround
PCSX2 2.8.0, released August 28, 2026, still doesn’t include a general netplay system in the mainline build. What it does have is support for the PS2’s original network infrastructure — useful only for the specific games that shipped with real PS2 online modes. To use it, both players need the same title, and the online mode routes through community-maintained replacement servers since Sony shut down the original PS2 online services years ago.
For everything else — turning a purely single-player or local-only PS2 game into an online co-op or versus session — the community has settled on a separate fork, commonly referred to as “PCSX2 Online,” that adds peer-to-peer netplay on top of the mainline codebase. It is not maintained by the official PCSX2 team, moves on its own release schedule, and typically lags a version or two behind mainline PCSX2, so check compatibility with your specific game before committing a whole evening to it.
If your goal is a smoother path to PS2 co-op without chasing a community fork’s release notes, a Parsec-style remote session (where one player hosts and the other streams video/input) remains the more reliable fallback for titles the fork doesn’t support well — it costs you a frame or two of extra lag but skips the sync fragility entirely. If you haven’t installed the base emulator yet, start with our PCSX2 PS2 emulator setup guide before attempting any of the online workarounds above.
Step 8: Configure Router Port Forwarding
Whoever hosts the session needs their router configured to pass inbound traffic on the emulator’s netplay port to the hosting PC. Log into your router’s admin panel (usually 192.168.1.1 or 192.168.0.1 in a browser) and find the Port Forwarding section, sometimes labeled Virtual Server or NAT Forwarding depending on the manufacturer.
| Emulator | Port to forward | Protocol | Direction |
|---|---|---|---|
| Dolphin | 2626 | TCP | Host only, inbound |
| RetroArch | 55435 | TCP + UDP | Host only, inbound |
| PCSX2 Online (fork) | Varies by build | TCP/UDP | Host only, inbound |
A generic router rule looks like this (exact field names vary by brand):
Service Name: Dolphin-Netplay
External Port: 2626
Internal Port: 2626
Protocol: TCP
Internal IP: 192.168.1.XXX (your PC's local IP)
Enable: YesOnly the host needs to forward a port — clients connecting outbound don’t need any router changes. Set your hosting PC to a static local IP first (either through your router’s DHCP reservation or a manual static IP in Windows network settings), because a forwarded port pointed at a dynamic IP will silently stop working the next time your PC’s lease renews and it grabs a different address.
Step 9: Use NAT Traversal Tools When Port Forwarding Fails
Port forwarding doesn’t work for everyone. If your ISP puts you behind carrier-grade NAT (common on many cellular and some newer fiber/cable connections), you don’t have a public IP to forward a port on at all, and no amount of router configuration will fix that from your end. If a forwarded port simply won’t connect from outside your network no matter what you try, this is the most likely cause, and a NAT traversal tool is your fastest way around it.
| Tool | Type | Free tier limits (2026) | Best for |
|---|---|---|---|
| ZeroTier | Software-defined virtual LAN | 10 devices, 1 network, 1 admin | Small, recurring groups |
| Radmin VPN | Virtual LAN client | Free, vendor claims 60M+ total users | Quick one-off sessions, Windows-first |
| Hamachi | Virtual LAN client | Free tier capped at 5 devices per network | Legacy setups, simple pairing |
All three work the same way conceptually: they create a virtual private network that both machines join, and once connected, each PC sees the other at a private IP (like 26.x.x.x for Hamachi or ZeroTier’s own address space) as if they were on the same LAN. From there, host and connect inside Dolphin, RetroArch, or PCSX2 using that virtual IP instead of a public one, and skip port forwarding entirely since the traffic tunnels through the VPN’s own relay infrastructure.
ZeroTier’s free “Personal” plan was reduced during 2025 from a more generous allowance down to 10 devices and a single network per account, which is still plenty for a regular two-to-four-player netplay group but worth knowing if you’re setting up a larger community. A basic ZeroTier join looks like this once both machines have the client installed:
# Windows PowerShell, after installing the ZeroTier client
zerotier-cli join
# Verify the connection came up
zerotier-cli listnetworks Radmin VPN skips the network-ID step in favor of a simpler create-network/join-by-name flow inside its GUI, which makes it the faster option for a one-off session with someone you’re not going to be gaming with regularly. Whichever tool you pick, expect a small latency penalty compared to direct connection since your traffic is routing through the VPN provider’s relay servers rather than going peer-to-peer — usually a non-issue for turn-based or slower-paced games, more noticeable in twitchy fighting-game netplay.
Step 10: Test Your Connection and Measure Latency
Before committing to a full session, ping your netplay partner to get a baseline latency number. From a terminal:
ping 203.0.113.45 -n 20
# Example output
Pinging 203.0.113.45 with 32 bytes of data:
Reply from 203.0.113.45: bytes=32 time=38ms TTL=54
Reply from 203.0.113.45: bytes=32 time=41ms TTL=54
Reply from 203.0.113.45: bytes=32 time=36ms TTL=54
...
Average = 39ms, 0% packet lossThere’s no single official threshold for “playable” that applies across every game and emulator, since tolerance depends heavily on genre and how much input delay you’ve configured. As a practical rule of thumb from the emulation community: turn-based and slower action games stay comfortable well past 100ms, platformers and most GameCube/Wii titles start feeling off somewhere past 60-80ms round trip, and frame-precise fighting games or Melee-style netplay want to stay under 40-50ms if at all possible. Packet loss matters more than raw latency in most cases — a stable 80ms connection plays better than an unstable 30ms one that drops packets under load.
If your ping numbers look rough, try a wired ethernet connection instead of Wi-Fi on both ends before touching any emulator settings — it’s the single highest-impact change you can make, and it costs nothing.
Step 11: Tune Netplay Settings for Lower Lag
Once basic connectivity works, a few settings tweaks squeeze out meaningfully lower input lag:
- In Dolphin, enable Host Input Authority when the host has the best connection of the group — it shifts sync responsibility toward the host, cutting the host’s own perceived lag noticeably at a small cost to everyone else
- In RetroArch, lower
netplay_delay_framesgradually (try 2, then 1) only if your connection is stable enough to avoid stutter — going too low on an unstable link causes visible rollbacks - Close background bandwidth users on both machines — cloud backup syncs and game-client auto-updates are common, invisible sources of jitter during a session
- Disable Wi-Fi power-saving mode in Windows network adapter settings if you must use wireless, since it can introduce intermittent latency spikes as the radio cycles down
If you’re doing this seriously — a recurring competitive Melee or Smash Ultimate netplay group, for example — a wired connection and a dedicated router QoS rule prioritizing the emulator’s netplay port over other household traffic makes a bigger difference than any in-emulator setting.
Step 12: Run a Full Netplay Session Start to Finish
Putting it all together, here’s a complete Dolphin session from a cold start, which you can adapt to RetroArch by swapping in its own menu paths:
- Both players confirm identical game file hashes (Step 1)
- Both players confirm they’re on the same Dolphin build (Step 2)
- Host forwards port 2626 on their router, or both players join a shared ZeroTier network if port forwarding isn’t possible (Steps 8-9)
- Host opens Dolphin → Tools → Start NetPlay → Host, selects the game, and clicks Start
- Host shares their IP (or ZeroTier virtual IP) and port with the client
- Client opens Dolphin → Tools → Start NetPlay → Connect, enters the host’s address, and connects
- Both players verify a green “ready” status and matching game hash in the lobby
- Host clicks Start Game once everyone’s ready
Expect the game to launch simultaneously on both machines with a short synchronization pause — this is normal and shouldn’t take more than a few seconds. If one side loads noticeably faster and sits waiting, that’s fine; Dolphin holds the faster machine until both are ready to avoid an early desync.
Common Pitfalls When Setting Up Emulator Netplay
Most failed netplay sessions trace back to one of a handful of repeat offenders. Working through these before you troubleshoot anything deeper will save you most of the frustration.
- Mismatched ROM dumps. A different region, revision, or even a different dumping tool can produce a file that looks identical but hashes differently, which is enough to break sync in Dolphin and RetroArch alike.
- Mismatched emulator builds. One player on a newer Dolphin dev build than the other is one of the most common causes of an “immediate desync” reported in community netplay guides.
- Forwarding the wrong port or protocol. RetroArch needs both TCP and UDP forwarded on 55435 — forwarding only one will make outbound connections work while inbound joins silently fail.
- Assuming port forwarding will work behind CGNAT. If you don’t have a public IP assigned to your router at all, no port forwarding configuration can fix that — you need a VPN-style workaround instead.
- Loading a local save state mid-session in RetroArch. Only the host can trigger a save-state load or core reset during netplay; a client attempting it either gets rejected or, in older builds, desyncs the whole session.
- Ignoring firewall prompts. Windows Defender or a third-party firewall silently blocking the emulator’s inbound port is easy to miss since the emulator itself gives no error — it just never receives a connection attempt.
Troubleshooting Emulator Netplay Issues
If you’ve followed the steps above and something still isn’t working, work through these in order — they’re listed roughly from most to least common.
| Symptom | Likely cause | Fix |
|---|---|---|
| Client can’t connect to host at all | Port not forwarded, or host behind CGNAT | Re-check router forwarding rule; if using a mobile/newer ISP connection, switch to ZeroTier or Radmin VPN |
| Connection works locally, fails over internet | Forwarded to wrong internal IP after DHCP lease renewed | Set a static local IP or DHCP reservation for the host PC |
| Session desyncs a few seconds after starting | Mismatched ROM hash or emulator build | Re-verify file hashes and update both sides to the identical build |
| Connection succeeds but game never launches | One player has a different game selected/loaded | Confirm both players selected the exact same file in the host/join dialog |
| Heavy input lag despite low ping | Delay frames set too high, or Wi-Fi power saving enabled | Lower netplay_delay_frames gradually; disable adapter power management |
| Random stutter every few seconds | Packet loss or background bandwidth usage | Switch to wired ethernet; pause cloud syncs and auto-updates during play |
| RetroArch client can outbound-connect but nobody can join them as host | Only TCP forwarded, UDP missing (or vice versa) | Forward both TCP and UDP on port 55435 |
| PCSX2 community netplay fork won’t launch a specific game | Fork lags behind mainline PCSX2 compatibility | Check the fork’s own compatibility list before committing; fall back to Parsec-style remote play if unsupported |
Advanced Tips for Competitive and Tournament Netplay
Once basic sessions are reliable, a few refinements matter more for competitive play than casual co-op:
- Use spectator mode for coaching or casting. RetroArch’s built-in spectator slots let a third party watch a match live without touching a controller — useful for reviewing a Melee set or teaching a newer player without interrupting the game.
- Pick the geographically closer host. Whoever hosts effectively sets the latency floor for everyone else in Dolphin’s host-authority model — put the player with the best, most central connection in the host seat rather than defaulting to whoever suggested game night.
- Standardize on a build across your whole group, not just per-session. A recurring netplay group that agrees on a fixed emulator version (and pins it, rather than auto-updating) avoids the “works for two of us, not the third” problem entirely.
- Log your session settings. If you run regular tournaments or league play, keep a shared doc of agreed netplay_delay_frames, host-authority settings, and accepted ROM hashes so disputes about “bad netplay” have an objective reference point.
- Test your NAT traversal fallback before you need it. Don’t discover you’re behind CGNAT five minutes before a scheduled match — confirm port forwarding works (or set up ZeroTier in advance) during a low-stakes practice session.
Setting Up a Recurring Netplay Group Without Repeating This Whole Process
Everything above assumes a one-off session, but most netplay actually happens in recurring groups — the same three or four friends running through a GameCube campaign together every Thursday, or a small local RetroArch tournament scene that meets monthly. If that’s your situation, a bit of upfront organization turns a 20-minute setup ritual into something closer to two minutes.
- Create a shared document (or a pinned message in your group’s Discord) listing the agreed emulator build, the exact ROM hashes everyone verified, and whichever NAT traversal network ID you’re using, so nobody has to re-derive any of it from memory
- Rotate the host role deliberately based on connection quality rather than by habit — the person hosting sets the experience floor for everyone else, especially in Dolphin’s host-authority model
- Set a group policy on emulator updates: agree on a day everyone updates together rather than letting one person jump to a new build mid-season and break sync for the rest of the group
- Keep your ZeroTier network (or Radmin VPN network name) persistent rather than recreating it each session — once everyone’s joined once, reconnecting takes seconds instead of minutes
- If your group plays multiple systems across Dolphin, RetroArch, and the PCSX2 fork, keep separate notes per emulator since port numbers, build requirements, and connection steps differ enough to cause confusion under the pressure of “we’re all waiting to start”
Groups that skip this step tend to burn their first 15-20 minutes of every session on the same “wait, what version are we on” conversation. Writing it down once pays for itself after the second session.
Legal Considerations for Netplay and ROM Ownership
Netplay doesn’t change the underlying legal reality of emulation: playing a game you don’t legitimately own is not made legal by playing it online with a friend instead of alone. The standard, widely cited guidance across the emulation community remains dump your own copies from cartridges, discs, or digital purchases you actually own, and don’t distribute ROM or ISO files to your netplay partner — each player needs to source their own copy independently. This matters more in a netplay context than solo play because the setup inherently requires coordinating with another person about which exact file they have, which can create a temptation to just send the file rather than have both sides dump it themselves. Don’t do that; it’s the difference between a personal backup (broadly treated as a gray area when sourced from owned media) and unauthorized distribution (which is unambiguously copyright infringement in most jurisdictions, including the US).
Frequently Asked Questions
Do both players need the exact same emulator version for netplay to work?
Yes, for Dolphin and RetroArch. Both tools validate the netplay protocol version at connection time, and community guides consistently report that a mismatch causes an immediate desync rather than a graceful error, so update both machines to the same build before starting.
What ports do I need to forward for netplay?
Dolphin defaults to TCP port 2626. RetroArch defaults to port 55435 over both TCP and UDP. PCSX2’s community netplay fork varies by build, so check that project’s current documentation. Only the hosting player needs to forward anything — the joining player connects outbound, which doesn’t require router changes.
Can I do netplay without forwarding a port on my router?
Yes, with a caveat. Tools like ZeroTier, Radmin VPN, or Hamachi create a virtual LAN that both machines join, letting you connect using a private virtual IP instead of forwarding anything publicly. This is also the only realistic option if your ISP puts you behind carrier-grade NAT, since there’s no public IP available to forward a port on in the first place.
Does PCSX2 support real online netplay in 2026?
Not natively, no. PCSX2 2.8.0 supports the original PS2 online infrastructure for games that shipped with genuine online modes, routed through community replacement servers, but it has no general netplay system for arbitrary local-multiplayer or single-player titles. A separate, unofficial community fork adds peer-to-peer netplay for a subset of games, and Parsec-style remote play remains a fallback for everything else.
How much latency is too much for emulator netplay?
It depends heavily on the game and genre rather than a single fixed number. Slower-paced or turn-based games tolerate well over 100ms comfortably. Most platformers and general GameCube/Wii titles start feeling laggy somewhere past 60-80ms round trip. Frame-precise competitive games like Melee-style netplay want to stay under roughly 40-50ms for a genuinely responsive feel. Packet loss and jitter generally hurt more than raw ping.
Can someone watch a netplay match without playing?
In RetroArch, yes — toggle Spectator Mode before connecting and you’ll join the session without occupying a controller slot. Dolphin doesn’t have an equivalent dedicated spectator mode built in; watching a Dolphin netplay session typically means screen-sharing the host’s or a player’s own view separately.
Is it legal to use netplay with ROM files?
The legality hinges on how you obtained the game files, not on the fact that you’re playing over a network. Dumping a ROM or ISO from hardware or a digital copy you personally own sits in the same legal territory emulation communities have operated in for decades. Sending a copy of that file to your netplay partner instead of having them dump their own crosses into unauthorized distribution, which carries real legal risk independent of the emulator you’re using.
Why does my RetroArch session connect but never actually start the game?
This almost always traces back to a content mismatch — one player has a different ROM, a different revision, or even a different core version loaded. Re-confirm the file hash on both machines using the steps in this guide, and make sure you’re both running the identical RetroArch core, not just the identical RetroArch version.
Related Coverage
- Panda3DS Setup: 3DS Emulator in 12 Steps, 60 Min [2026]
- Dolphin Triforce Arcade Setup: 12 Steps, 90 Min [2026]
- EmulatorJS Setup: Pokémon in Your Browser, 13 Steps [2026]
- Citron Neo Setup for Pokémon Legends Z-A: 12 Steps [2026]
- PS5 Game Sharing Between 2 Consoles: 12 Steps [2026]
