RetroArch

Cross-platform, sophisticated frontend for the libretro API. Licensed GPLv3.

11,633

1,926

11,633

2,894

View on GitHub

Top Related Projects

ppsspp

12,458

A PSP emulator for Android, Windows, Mac and Linux, written in C++. Want to contribute? Join us on Discord at https://discord.gg/5NJB6dD or just send pull requests / issues. For discussion use the forums at forums.ppsspp.org.

dolphin

13,959

Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

pcsx2

13,304

PCSX2 - The Playstation 2 Emulator

OpenEmu

16,645

🕹 Retro video game emulation for macOS

BizHawk

2,416

BizHawk is a multi-system emulator written in C#. BizHawk provides nice features for casual gamers such as full screen, and joypad support in addition to full rerecording and debugging tools for all system cores.

Quick Overview

RetroArch is a frontend for emulators, game engines, and media players. It enables you to run classic games on a wide range of computers and consoles through its slick graphical interface. RetroArch is the reference implementation of the libretro API, allowing you to run multiple emulator cores from a single, unified interface.

Pros

Cross-platform compatibility (runs on Windows, macOS, Linux, Android, iOS, and various consoles)
Supports a wide range of emulator cores for different gaming systems
Unified interface for all emulators, providing a consistent user experience
Advanced features like shaders, netplay, and achievements

Cons

Can be complex to set up and configure for beginners
Some users may find the interface less intuitive compared to standalone emulators
Occasional compatibility issues with certain cores or games
Legal concerns regarding ROM usage and distribution

Getting Started

To get started with RetroArch:

Download RetroArch from the official website: https://www.retroarch.com/
Install RetroArch on your system
Launch RetroArch and navigate to "Online Updater" to download cores
Load content by selecting "Load Content" and choosing your ROM file
Configure controls and other settings as needed

For developers interested in creating libretro cores:

Clone the libretro repository: git clone https://github.com/libretro/RetroArch.git
Follow the build instructions in the README for your specific platform
Refer to the libretro API documentation to create or port emulator cores

Note: Always ensure you have the legal right to use any ROM files or game content you load into RetroArch.

Competitor Comparisons

ppsspp

12,458

Pros of PPSSPP

Specialized for PSP emulation, offering optimized performance
Built-in game-specific compatibility fixes and enhancements
User-friendly interface designed specifically for PSP games

Cons of PPSSPP

Limited to PSP emulation only
Lacks the multi-system support and extensive plugin ecosystem

Code Comparison

PPSSPP (C++):

void PSPMixer::Mix(short *stereoout, int numSamples) {
    memset(stereoout, 0, numSamples * 2 * sizeof(short));
    for (int i = 0; i < MAX_CHANNELS; i++) {
        if (channels[i].sampleAddress != 0) {
            MixChannel(i, stereoout, numSamples);
        }
    }
}

RetroArch (C):

static void audio_driver_mixer_mix_samples(float *buffer, size_t num_frames) {
   unsigned i;
   for (i = 0; i < num_streams; i++)
   {
      if (streams[i].stopped)
         continue;
      audio_mixer_mix(&streams[i], buffer, num_frames);
   }
}

Both projects handle audio mixing, but PPSSPP's implementation is tailored specifically for PSP audio, while RetroArch's approach is more generalized to accommodate various systems. PPSSPP uses C++ with object-oriented design, whereas RetroArch employs C for broader compatibility across platforms and architectures.

dolphin

13,959

Dolphin is a GameCube / Wii emulator, allowing you to play games for these two platforms on PC with improvements.

Pros of Dolphin

Specialized emulator for GameCube and Wii, offering high accuracy and performance
Advanced features like netplay, TAS tools, and graphics enhancements
Active development with frequent updates and improvements

Cons of Dolphin

Limited to GameCube and Wii emulation only
Steeper learning curve for configuration and optimization
Larger file size and resource requirements

Code Comparison

Dolphin (C++):

void VideoBackendBase::ShowConfig(void* parent_handle) {
  if (!m_initialized)
    InitBackendInfo();
  ConfigureVideo(parent_handle);
}

RetroArch (C):

void video_driver_show_config(void *data) {
   if (!video_driver_is_initialized())
      video_driver_init_internal();
   if (current_video && current_video->show_config)
      current_video->show_config(data);
}

Both projects use similar approaches for video configuration, but Dolphin's implementation is more object-oriented due to C++, while RetroArch uses a more procedural style in C.

RetroArch is a multi-system emulator frontend supporting various cores, while Dolphin focuses solely on GameCube and Wii emulation. RetroArch offers broader compatibility across platforms and systems, but Dolphin provides a more specialized and optimized experience for its target consoles.

pcsx2

13,304

PCSX2 - The Playstation 2 Emulator

Pros of PCSX2

Specialized for PlayStation 2 emulation, offering more accurate and optimized performance
More extensive PS2-specific features and compatibility options
Active development focused solely on improving PS2 emulation

Cons of PCSX2

Limited to PlayStation 2 emulation only
Potentially more complex setup for casual users
Separate GUI and command-line versions, which may be confusing for some users

Code Comparison

PCSX2 (C++):

void GSState::Flush(GSFlushReason reason)
{
    if(m_dev->IsDeviceLost(true)) return;
    // ... (implementation details)
}

RetroArch (C):

void video_driver_get_video_output_size(void *data)
{
   video_driver_state_t *video_st = &video_driver_st;
   // ... (implementation details)
}

RetroArch provides a more generalized approach for multiple systems, while PCSX2 focuses on PS2-specific optimizations. PCSX2's code tends to be more complex due to its specialized nature, while RetroArch's codebase is designed for flexibility across various emulators and platforms.

OpenEmu

16,645

🕹 Retro video game emulation for macOS

Pros of OpenEmu

User-friendly interface designed specifically for macOS
Integrated library management with cover art and metadata
Seamless drag-and-drop ROM importing

Cons of OpenEmu

Limited to macOS platform
Fewer supported systems compared to RetroArch
Less customization options for advanced users

Code Comparison

OpenEmu (Objective-C):

- (void)loadROMAtPath:(NSString *)path
{
    NSError *error = nil;
    OEGameCore *core = [self gameCoreForROMAtPath:path error:&error];
    [self loadGameCore:core withROMAtPath:path error:&error];
}

RetroArch (C):

static bool load_content(const char *path, unsigned type, struct retro_game_info *info)
{
   bool ret = false;
   switch (type)
   {
      case CORE_TYPE_PLAIN:
         ret = load_content_core(path, info);
         break;
      // ... other cases
   }
   return ret;
}

OpenEmu focuses on a streamlined, macOS-native experience with a polished UI and simplified ROM management. RetroArch offers broader platform support, more extensive customization, and a larger selection of emulated systems. OpenEmu's code emphasizes Objective-C and macOS integration, while RetroArch uses C for cross-platform compatibility and lower-level system access.

BizHawk

2,416

Pros of BizHawk

Specialized for Tool-Assisted Speedruns (TAS) with advanced frame-by-frame control
Extensive Lua scripting capabilities for automation and analysis
Built-in tools like RAM watch, hex editor, and input display

Cons of BizHawk

Limited platform support (primarily Windows)
Smaller community and fewer available cores compared to RetroArch
Less focus on general emulation and more on TAS-specific features

Code Comparison

BizHawk (C#):

[LuaMethodExample("gets the screen position of the mouse cursor")]
public static int client_getmousexy(IntPtr L)
{
    Point p = GlobalWin.DisplayManager.UntransformPoint(Control.MousePosition);
    L.PushInteger(p.X);
    L.PushInteger(p.Y);
    return 2;
}

RetroArch (C):

static int16_t input_state_poll_late(unsigned port, unsigned device,
      unsigned idx, unsigned id)
{
   if (!input_driver_block_libretro_input)
      return input_driver_state_wrapper(port, device, idx, id);
   return 0;
}

The code snippets highlight BizHawk's focus on Lua scripting and user interface interactions, while RetroArch emphasizes low-level input handling across multiple platforms and devices.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

RetroArch

RetroArch is the reference frontend for the libretro API. Popular examples of implementations for this API includes video game system emulators and game engines as well as more generalized 3D programs. These programs are instantiated as dynamic libraries. We refer to these as "libretro cores".

libretro

libretro is an API that exposes generic audio/video/input callbacks. A frontend for libretro (such as RetroArch) handles video output, audio output, input and application lifecycle. A libretro core written in portable C or C++ can run seamlessly on many platforms with very little to no porting effort.

While RetroArch is the reference frontend for libretro, several other projects have used the libretro interface to include support for emulators and/or game engines. libretro is completely open and free for anyone to use.

libretro API header

Binaries

Latest binaries are currently hosted on the buildbot.

Support

To reach developers, either make an issue here on GitHub, make a thread on the forum, chat on discord, or visit our IRC channel: #retroarch @ irc.freenode.org. You could create a post in Reddit with Technical Support flair.

Documentation

See our Documentation Center. On Unix, man-pages are provided. More developer-centric stuff is found here.

Related projects

Cg/HLSL shaders: common-shaders
slang shaders: slang-shaders
GLSL shaders: glsl-shaders
Helper scripts to build libretro implementations: libretro-super
GitHub mirrors of projects, useful for generating diff files: libretro-mirrors

Philosophy

RetroArch attempts to be small and lean while still having all the useful core features expected from an emulator. It is designed to be very portable and features a gamepad-centric and touchscreen UI. It also has a full-featured command-line interface.

In some areas, RetroArch goes beyond and emphasizes on not-so-common technical features such as multi-pass shader support, real-time rewind (Braid-style), video recording (using FFmpeg), run-ahead input latency removal, etc.

RetroArch also emphasizes being easy to integrate into various launcher frontends.

Platforms

RetroArch has been ported to the following platforms:

Android (2.x to most recent version)
Apple iOS
Apple macOS (PPC, x86-32 and x86-64)
Apple tvOS
Blackberry
DOS
Emscripten (WebAssembly and JavaScript)
FreeBSD
Haiku
Linux
Original Microsoft Xbox
Microsoft Xbox 360 (Libxenon/XeXDK)
Microsoft Xbox One
Microsoft Xbox Series S/X
Miyoo
NetBSD
Nintendo NES/SNES Classic Edition
Nintendo GameCube
Nintendo Wii
Nintendo Switch
Nintendo Wii U
Nintendo 3DS/2DS
OpenBSD
OpenDingux
PlayStation2
PlayStation3
PlayStation4
PlayStation Portable
PlayStation Vita
Raspberry Pi
ReactOS
Redox OS
RetroFW
RS90
SerenityOS
Solaris
Windows NT 3.5
Windows 95
Windows 98
Windows 2000
Windows XP
Windows Millennium
Windows Vista
Windows 7
Windows 8
Windows 10
Windows 11

Dependencies (PC)

There are no true hard dependencies per se.

On Windows, RetroArch can run with only Win32 as dependency.

On Linux, there are no true dependencies. For optimal usage, the following dependencies come as recommended:

GL headers / Vulkan headers
X11 headers and libs, or EGL/KMS/GBM

OSX port of RetroArch requires latest versions of Xcode to build.

RetroArch can utilize these libraries if enabled:

nvidia-cg-toolkit
libfreetype2 (TTF font rendering on screen)

RetroArch needs at least one of these audio driver libraries:

ALSA
OSS
RoarAudio
RSound
OpenAL
JACK
SDL
PulseAudio
PipeWire
XAudio2 (Win32, Xbox 360)
DirectSound (Win32, Xbox 1)
CoreAudio (OSX, iOS)

To run properly, RetroArch requires a libretro implementation present; however, as it's typically loaded dynamically, it's not required at build time.

Dependencies (Console ports, mobile)

Console ports have their own dependencies, but generally do not require anything other than what the respective SDKs provide.

Requirements

OpenGL1

Your videocard needs to at least support the OpenGL 1.1 spec.

Shaders: N/A

Menu driver support: MaterialUI, XMB, Ozone and RGUI should all work correctly. XMB won't have shader pipeline effects because of the aforementioned lack of shader support.

OpenGL2

Your videocard needs to at least support the OpenGL 2.1 spec.

Shaders: You can choose between either NVIDIA Cg shaders (deprecated, requires separate runtime to be installed on your system), or GLSL shaders.

Menu driver support: MaterialUI, XMB, Ozone and RGUI should all work correctly.

OpenGL3

Your videocard needs to at least support the OpenGL 3.2 core feature spec.

Shaders: You will be able to use modern Slang shaders with this driver.

Menu driver support: MaterialUI, XMB, Ozone and RGUI should all work correctly.

Direct3D 11

Your videocard needs to at least support the Direct3D11 11.0 spec. The card also needs to support at least the Shader Model 4.0.

Shaders: You will be able to use modern Slang shaders with this driver.

Menu driver support: MaterialUI, XMB, Ozone and RGUI should all work correctly.

Vulkan

Your videocard needs to at least support the Vulkan 1.0 spec.

Shaders: You will be able to use modern Slang shaders with this driver.

Menu driver support: MaterialUI, XMB, Ozone and RGUI should all work correctly.

Configuring

The default configuration is defined in config.def.h. It is not recommended to change this unless you know what you're doing. These can later be tweaked by using a config file. A sample configuration file is installed to /etc/retroarch.cfg. This is the system-wide config file.

RetroArch will on startup create a config file in $XDG\_CONFIG\_HOME/retroarch/retroarch.cfg if it does not exist. Users only need to configure a certain option if the desired value deviates from the value defined in config.def.h.

To configure joypads, use the built-in menu or manually configure them in retroarch.cfg.

Compiling and installing

Instructions for compiling and installing RetroArch can be found in the Libretro/RetroArch Documentation Center.

CRT 15Khz Resolution Switching

CRT SwitchRes will turn on, on the fly. However, you will need to restart RetroArch to disable it. With CRT SwitchRes enable RetroArch will start in 2560 x 480 @ 60.

If you are running Windows, before enabling the CRT SwitchRes options please make sure you have installed CRTEmudriver and installed some modelines. The minimum modelines for all games to switch correctly are:

2560 x 192 @ 60.000000
2560 x 200 @ 60.000000
2560 x 240 @ 60.000000
2560 x 224 @ 60.000000
2560 x 237 @ 60.000000
2560 x 256 @ 50.000000
2560 x 254 @ 55.000000
2560 x 448 @ 60.000000
2560 x 480 @ 60.000000

Install these modelines replacing 2560 with your desired super resolution. The above resolutions are NTSC only so if you would be playing any PAL content please add PAL modelines:

2560 x 192 @ 50.000000
2560 x 200 @ 50.000000
2560 x 240 @ 50.000000
2560 x 224 @ 50.000000
2560 x 288 @ 50.000000
2560 x 237 @ 50.000000
2560 x 254 @ 55.000000
2560 x 448 @ 50.000000
2560 x 480 @ 50.000000

Some games will require higher PAL resolutions which should also be installed:

2560 x 512 @ 50.000000
2560 x 576 @ 50.000000

Ideally install all these modelines and everything will work great.

Super Resolutions

The default super resolution is 2560. It is displayed just under the CRT switch option, which can be found in video settings. This can be changed within the retroarch.cfg. The only compatible resolutions are 1920, 2560 and 3840. Any other resolutions will be ignored and native switching will be activated.

Native Resolutions

If native resolutions are activated you will need a whole new set of modelines:

256 x 240 @ 50.006977 SNESpal
256 x 448 @ 50.006977 SNESpal
512 x 224 @ 50.006977 SNESpal
512 x 240 @ 50.006977 SNESpal
512 x 448 @ 50.006977 SNESpal
256 x 240 @ 60.098812 SNESntsc
256 x 448 @ 60.098812 SNESntsc
512 x 240 @ 60.098812 SNESntsc
512 x 224 @ 60.098812 SNESntsc
512 x 448 @ 60.098812 SNESntsc
256 x 192 @ 59.922745 MDntsc
256 x 224 @ 59.922745 MDntsc
320 x 224 @ 59.922745 MDntsc
320 x 240 @ 59.922745 MDntsc
320 x 448 @ 59.922745 MDntsc
320 x 480 @ 59.922745 MDntsc
256 x 192 @ 49.701458 MDpal
256 x 224 @ 49.701458 MDpal
320 x 224 @ 49.701458 MDpal
320 x 240 @ 49.701458 MDpal
320 x 288 @ 49.701458 MDpal
320 x 448 @ 49.701458 MDpal
320 x 480 @ 49.701458 MDpal
320 x 576 @ 49.701458 MDpal
256 x 288 @ 49.701458 MSYSpal
256 x 240 @ 60.098812 NESntsc
256 x 240 @ 50.006977 NESpal
640 x 237 @ 60.130001 N64ntsc
640 x 240 @ 60.130001 N64ntsc
640 x 480 @ 60.130001 N64ntsc
640 x 288 @ 50.000000 N64pal
640 x 480 @ 50.000000 N64pal
640 x 576 @ 50.000000 N64pal
256 x 252 @ 49.759998 PSXpal
320 x 252 @ 49.759998 PSXpal
384 x 252 @ 49.759998 PSXpal
640 x 252 @ 49.759998 PSXpal
640 x 540 @ 49.759998 PSXpal
384 x 240 @ 59.941002 PSXntsc
256 x 480 @ 59.941002 PSXntsc
352 x 240 @ 59.820000 Saturn/SGFX_NTSCp
704 x 240 @ 59.820000 SaturnNTSCp
352 x 480 @ 59.820000 SaturnNTSCi
704 x 480 @ 59.820000 SaturnNTSCi
352 x 288 @ 49.701458 SaturnPALp
704 x 288 @ 49.701458 SaturnPALp
352 x 576 @ 49.701458 SaturnPALi
704 x 576 @ 49.701458 SaturnPALi
240 x 160 @ 59.730000 GBA
320 x 200 @ 60.000000 Doom

// Arcade

400 x 254 @ 54.706841 MK
384 x 224 @ 59.637405 CPS1

These modelines are more accurate giving exact hz. However, some games may have unwanted results. This is due to mid-scanline resolution changes on the original hardware. For the best results super resolutions are the way to go.

CRT resolution switching & MAME

Some arcade resolutions can be very different from consumer CRTs. There is resolution detection to ensure MAME games will be displayed in the closest available resolution but drawn at their native resolution within this resolution. Meaning that the MAME game will look just like the original hardware.

MAME ROMs that run in a vertical aspect like DoDonPachi need to be rotated within MAME before resolution switching and aspect correction will work. Do this before enabling CRT SwitchRes so that RetroArch will run in your desktop resolution. Once you have rotated any games that may need it turn CRT SwitchRes on.

Socials

The links below belong to our official channels. Links other than this may have been created by fans, independent members or followers. We seriously recommend using our original resources.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot