Retroarch — download free

Generating a joypad profile

If your joypad is not recognized by RetroArch even after updating the profiles, you can generate a profile from the menu.

The first step is to proceed to a manual mapping of your pad. For this, unplug all the other joypads, and use Settings->Input->User 1 Binds->User 1 Bind All.Make sure that your mapping is perfect by testing every button in the menu and in some games.

Finally, use Settings->Inputs->User 1 Binds->User 1 Save Autoconfig and the profile will be saved to your disk.

You can now do a Settings->Inputs->User 1 Binds->User 1 Bind Default All to reset the manual settings. Otherwise they would take precedance over the profile you generated.

Unplug your joypad an re-plug it. See if it is auto configured.

If you are happy with your profile, you can write the input descriptors part and submit your profile in our git repository.

Environment configuration¶

We recommend MinGW-W64 from MSYS2. You can download MSYS2 installer from here.

Follow the installation instructions and once finished start the MSYS2 shell.

MSYS2 shell is a maintenance shell. We are going to use this shell to install the toolchain and other packages. First order of business is to update MSYS2. Start the MSYS2 Shell and run the following commands:

Close MSYS2 shell and start it again, and:

Restart MSYS2 once again. In some cases you may find out that the shell starting scripts don’t work. If so check the following Note.

Warning

If you are updating from a very old MSYS2 installation you may need to update your shortcuts to reflect changes in MSYS2’s subsystem. If the shell no longer works properly you need to update your shortcuts with the following targets:

• MinGW-w64 Shell:
• MinGW-w32 Shell:
• MSYS2 Shell:

Now we can start installing the packages we actually need.

For 32-bit builds:

For 64-bit builds:

You might want to install Qt too if you want to be able to use the desktop GUI.

For 32-bit builds:

For 64-bit builds:

The NVIDIA CG toolkit package hasn’t been updated for a while so you need to download that package manually and install with pacman. You can download the packages from sourceforge at the following locations: 32-bit / 64-bit. Alternatively you can use the following commands directly:

For 32-bit builds:

For 64-bit builds:

Once these packages are installed close MSYS2 shell and open MinGW-w32 shell or MinGW-w64 shell depending on the platform you want to build for.

You’ll need gcc and make:

Favorites

You can now add a game to a ‘Favorites’ list for easy access! This has been an often-requested feature for years, and in the past we always felt that ‘Load Recent’ was good enough. However, if you load a lot of content, that can easily get cluttered over time.

To add a game to the Favorites list, do the following:
1 – Once a game is running, go to ‘Quick Menu’.
2 – Select ‘Add To Favorites’.
3 – Once added, you can now start the game at any time from the Favorites list.

On RGUI – go to Load Content -> Favorites.
On MaterialUI – go to the Playlists tab -> Favorites.
On XMB – go to the Favorites tab.

To add a game to the ‘favorites’ list, inside Quick Menu, select ‘Add To Favorites’. It should now be added to the Favorites list. You can access the ‘Favorites’ list inside MaterialUI by going to the Playlists tab. On RGUI, you go to Load Content -> Favorites. On XMB, you go to the Favorites tab instead.

State of the port

What works

* (Core-related) CatSFC / SNES. Works fine. Should run at fullspeed for most games (dip to 42fps on Yoshi’s Island intro screen (SuperFX2 game), seems to be fullspeed otherwise).
* (Core-related) FB Alpha CPS1. Works fine. Fullspeed. Runs all games. Use an older FBA romset.
* (Core-related) FB Alpha CPS2. Works fine. Fullspeed. Runs all the big CPS2 ROMs. Use an older FBA romset.
* (Core-related) FB Alpha Neo Geo. Works fine. Fullspeed. Not all big ROMs will work right now though. KOF 96 could be loaded (about 23/24MB). Might have to play around with heap to be able to get bigger ROMs to load. For now expect same size limitations as the Wii port. Hopefully we can get past this soon.
* (Core-related) FCEUmm. Works fine. Fullspeed.
* (Core-related) Genesis Plus GX. Works fine. Fullspeed.
* (Core-related) Mednafen Neo Geo Pocket Color. Works fine. Framerate at around 52/53fps. There might be a new Neo Geo Pocket Color core coming soon (not Mednafen NGP) which would run at fullspeed with no problems.
* (Core-related) Handy / Lynx. Works fine. Fullspeed.
* (Core-related) Mednafen Wonderswan. Works fine. Fullspeed.
* (Core-related) Mednafen Virtual Boy. Works. Too slow (around 26fps). Corrupted pitch (likely due to 32bit color). Speedups/idle loop optimization hacks MIGHT bring this fullspeed later on.
* (Core-related) NXEngine / Cave Story. Works fine. Fullspeed.

What doesn’t work

* ROMS have to be currently unzipped now (EXCEPT for the FB Alpha ROMs).
* No core switching yet from inside RetroArch. For now, each core is a standalone program.
* Add Content -> Download Content currently doesn’t work. If you do try it, you might have to restart.
* History list doesn’t work yet.
* Save states can be saved, but cannot be loaded yet. We need to figure out why.
* Threading needs to be still implemented.
* (Core-related) 2048 core. ‘Start content’ does not work yet like it should. Wait until we fix this.
* (core-related) Prboom/Doom core. Crashes after loading a Doom WAD. Wait until we fix this.
* (Core-related) Picodrive core. Crashes after loading a ROM. Wait until we fix this.
* (Core-related) QuickNES core. Doesn’t load a ROM. Wait until we fix this.
* (Core-related) Gambatte core. Doesn’t load a ROM. Wait until we fix this.
* (Core-related) SNES9x Next core. Doesn’t load a ROM. Wait until we fix this. Will likely be too slow compared to CatSFC anyway, so not sure if worth it for Vita.
* (Core-related) DOSBox core. Haven’t tried this yet. Likely too slow to be worthwhile.

Future plans

* More cores, fix remaining cores that are broken.
* Try to get Cg runtime working so we can have Cg shaders running.
* Try to get multiple gamepads working on PS TV.
* More.

A sneak peek at 1.3.7 features

Since this is a current nightly snapshot release, Vita users are able to get a sneak peek at some of the features that will be part of RetroArch 1.3.7 for the other platforms.

• Improved error handling. When loading the wrong ROM into a core, most cores should be able to now gracefully exit instead of just quitting or crashing RetroArch.
• Much more complete info message system. Press ‘Select’ on any entry and 99% of the time it should show you a handy help message explaining to you what each setting does. The ‘English’ language setting is currently the one that is most complete, for all other languages we need to wait until translators have finished adding all the help messages in their own language.

Review

RetroArch is a cross-platform emulator of several video game consoles and gaming systems.

It can be said that in the world of video games “retro” is out of fashion. Never before has it been so easy to emulate the old video game consoles. Thanks to the power of today’s computers, emulate old game consoles is something that is not a problem. In addition, the emulation has ceased to be something exclusive to PC, and now can be used in mobile phones and tablets to play “old school” video games.

RetroArch emulates various video game systems from different video games companies. We can think of this program as a “Front-end” for different programs of emulation, but with the difference that the program itself includes emulators required to run the games of the supported machines. That is to say, we will not have to install a Super Nintendo or Play Station emulator to make use of this program, but installing RetroArch we will be able to play Super Nintendo and Play Station ROMs without the need to install any other software emulator.

This is a list of the emulated systems and the emulator that is used internally:

• NeoGeo (FinalBurn Alpha)
• Arcade (MAME)
• Atari 2600 (Stella)
• Cave Story (NXEngine)
• Dinothawr
• Doom (PrBoom)
• TWO (DOSBox)
• Game Boy / Game Boy Color (Gambatte and TGB-Dual)
• Game Boy Advance (Mednafen VBA, Meteor and VBA Next)
• Lynx (Handy)
• Neo Geo Pocket Color (Mednafen Neopop)
• NES/Famicom (bNES, FCEUmm, NEStopia, QuickNES)
• Nintendo 64 (Mupen64p)
• Nintendo DS (DeSmuME and DeSmuME-future)
• PC Engine/TurboGrafx-16 (Mednafen PCE Fast)
• PlayStation 1 (Mednafen PSX)
• Quake 1 (TyrQuake)
• ScummVM
• Sega Master System/Game Gear/Mega Drive/MegaCD/32X (Genesis Plus GX and Picodrive)
• Super Nintendo/Super Famicom (bSNES, Snes9x)
• Other (MESS)
• Virtual Boy (Mednafen VB)
• WonderSwan Color (Mednafen Cygne)

Therefore the only thing we need to play are video games ROMs we want to play, because software emulators are built into the program itself.

When we launch the program, main screen appears. To navigate through the menu, we will do it with the keyboard:

• Move through the options = arrow keys
• OK = X
• Go back = Z

This program defines emulators as “Cores”, and to load emulators ROMs we have several options. The simplest option is to select the option “Load Content (Detect Core)”, and navigate through system directories until we select the ROM we want to load. Once we’ve selected the ROM, the program asks wich “Core” (emulator) we want to use. If, for example, we have selected a Mega Drive/Genesis ROM, we will be able to choose between the emulator Genesis Plus GX and Picodrive.

To access the latest ROMs that we have played, we must enter into the option “Load Content (History)”.

Keys setting is done by using text file ”retroarch.cfg”. In the mobile devices, gamepad buttons are displayed on the screen of the game, although there is also the possibility to use a PlayStation 3 or Xbox 360 controller to control emulated games.

As we see, this system is ideal to start playing immediately ROMs of our favorites video consoles. For those who don’t want to get embroiled in configure a multitude of emulators, this is a perfect solution. However, for those more advanced users, it may not be the best solution, as the default emulators included may not be the most optimal for the PC on which it is running. However for mobile systems (Android, iPhone, iPad), it’s the best multi-system emulator that currently exists.

Core Compilation¶

Fetching Cores

You can find the cores on libretro’s GitHUB organization.

We have an all-in-one tool to fetch and compile cores which you can use to streamline the process.
You can obtain the tool by using these commands:

Then you can fetch one or all the cores by using libretro-fetch.sh

Fetch all cores:

Fetch one core:

Note

Replace corename with the name of the core you want to fetch, for example gambatte

libretro-super

The easiest way to build all the cores is to use libretro-build.sh from within libretro-super’s source tree:

In case you only want to build one and/or more cores instead of all, you can specify the cores you want to build after the first command in no particular order:

Once compilation has finished, you can find the libretro cores inside dist/win.

Manual Fetching and Compilation

Get the core’s source tree. As an example we’ll use fceumm

Then compile the core:

Optionally strip the build product:

Most cores will build with these instructions. You might need to browse to a subdirectory in some cases.

Future blog posts

There might eventually be some future blog post by Themaister going into more technical detail on the inner workings of ParaLLEl RDP. I will also probably release a performance test-focused blog post later testing a variety of different GPUs and how far we can take them as far as upscaling is concerned.

I can already tell you to neuter your expectations with regards to Android/mobile GPUs. I tested ParaLLEl RDP with 2x upscaling on a Samsung Galaxy S10+ and performance was about 36fps, this is with vsync off. With 1x native resolution I manage to get on average 64 to 70fps with the same games. So obviously mobile GPUs still have a lot of catching up to do with their discrete big brothers on the desktop.

At least it will make for a nice GPU benchmark for mobile hardware until we eventually crack fullspeed with 2x native!

Next-frame response time indistinguishable from real hardware

RetroArch is truly in a league of its own when it comes to input responsiveness, and it keeps confounding even us here at Libretro. Several independent researchers did their own research on RetroArch’s latency and came away being quite blown away by the results, completely shattering several long-held myths that up until now had been accepted as gospel in emulation circles:

• That emulation will always have an implicit 3 to 5 frames of input lag, and that therefore FPGA-based hardware will always hold a distinct advantage over software-based emulation.
• That there’s nothing one can do to avoid this

RetroArch shatters these myths. It has been demonstratedy by independent researchers that a next-frame response time (≤16ms!) achievable with RetroArch! This means zero frames of input lag is achievable, indistinguishable from real hardware.

Whoever told you that input lag was a given with emulators and that you needed FPGA in order to avoid this latency, should get him/herself acquainted with RetroArch. Post-RetroArch, latency indistinguishable from real hardware is perfectly possible!

Check out people’s findings here on our forum and participate, don’t just take our word for it! Link here.

Your browser does not support the video tag.

Renaming entries inside playlists

You can now rename an entry from any playlist!

To do this, do the following:

1 – Go to a playlist of any type (it can be the history list, a system playlist, favorites, music/video/images playlists, etc).
2 – There should be an option called “Rename”. Select it. If you are using MaterialUI and/or XMB, an onscreen keyboard will now pop up. Input the new title for the entry and then hit either the Enter key on your keyboard ,the Start button on your gamepad or press the ‘Enter’ key on the onscreen overlay in order to confirm the changes.

You can now rename any entry! Say for instance you loaded a Quake data file. Instead of the playlist showing ‘PAK0.PAK’, you can rename it to Quake 1 instead.

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.

Overlays show button presses

Previously, overlays would only show button presses if they were actually being clicked on by either the touchscreen or the mouse.

A user submitted a bounty to make onscreen reactions possible through the gamepad and/or keyboard. A bounty hunter has now successfully completed this bounty and has been paid out. We have enabled this feature by default. If you want to turn it off, you can do so by doing the following:

1 – Go to Onscreen Display -> Onscreen Overlay.
2 – Go to ‘Show Inputs on Overlay’. Set this to off if you don’t want the overlay to react to keyboard/gamepad input, turn it on if you want this to happen (turned on by default).

Nintendo 3DS regression fix – all cores were running slower

A serious issue has been fixed in the Nintendo 3DS RetroArch port which compelled us to push this release sooner rather than later.

It appears that by mistake, rewind was always forcibly enabled in the 3DS port, which led to a halving of performance. This should now be fixed.

Renaming entries inside playlists

You can now rename an entry from any playlist!

To do this, do the following:

1 – Go to a playlist of any type (it can be the history list, a system playlist, favorites, music/video/images playlists, etc).
2 – There should be an option called “Rename”. Select it. If you are using MaterialUI and/or XMB, an onscreen keyboard will now pop up. Input the new title for the entry and then hit either the Enter key on your keyboard ,the Start button on your gamepad or press the ‘Enter’ key on the onscreen overlay in order to confirm the changes.

You can now rename any entry! Say for instance you loaded a Quake data file. Instead of the playlist showing ‘PAK0.PAK’, you can rename it to Quake 1 instead.

Why is it needed?

RetroArch works on a lot of different platforms. Each of these platforms have one or more input systems. And these input systems differ widely in the way they enumerate the pad buttons. For this reason, your joypad buttons may be mapped differently depending on if you are using Windows, Mac or Linux.

Traditional emulators lets you map each button of your pad to the original pad of the emulated system. For example, this is how OpenEMU joypad configuration interface looks like:

RetroArch also allows this kind of manual mapping. However, we’re trying to go further by detecting your joypad and automatically configuring it. So this step becomes obsolete.

Configurable latency mitigation tools

RetroArch provides you with all the tools you need to combat latency in your games. This includes options such as:

• Frame Delay
• Synchronization Fences (GPU Hard Sync)
• Video drivers for new graphics technology APIs like Vulkan, which can drive latency down even further.
• Maximum amount of configurable swap chains.
  • Can be set from 1 to 3 depending on your video driver, your GPU, and the video context driver that is being used by RetroArch.
  • Vulkan supports this feature natively, but video drivers might not implement setting lower max swapchains.
• You can choose between different audio drivers which can have an effect on overall perceived latency
  • Windows: You can choose between WASAPI (available since Windows 7), XAudio (available since Windows XP), and DirectSound.
  • Linux: Depending on the build, you can choose between ALSA, PulseAudio, OSS, and audio servers like JACK.
• Adjustable audio buffering for lower/higher audio latency
• Adjustable audio resampler quality
• Several video context drivers to choose from
  • Linux: Some video driver contexts like DRM/KMS on Linux allow for granular swapchain control, which should allow for an even better gameplay experience. It also allows you to boot RetroArch without an active X Server running (assuming your video driver supports this).
  • Wayland is supported on Linux. This is an advanced display server that is being increasingly pushed as a replacement for X11. Note that whether or not you can use this depends on your video driver.
• Ability to turn off window compositing for better latency results (NOTE: This is only possible on Windows 7, Microsoft disallows this on Windows 8 and later)
• Configurable swap interval

Where LLE wins

Conversely, there are parts where LLE wins over HLE, and where HLE can’t really go –

* HLE tends to struggle with decals, depth bias doesn’t really emulate the RDP’s depth bias scheme at all since RDP depth bias is a double sided test. Depth bias is also notorious for behaving differently on different GPUs.
* Correct dithering. A HLE renderer still has to work with a fixed function blending pipeline. A software rendered rasterizer like ParaLLEl RDP does not have to work with any pre-existing graphics API setup, it implements its own rasterizer and outputs that to the screen through compute shading. Correct dither means applying dither after blending, among other things, which is not something you can generally do . It generally looks somewhat tacky to do dithering in OpenGL. You need 8-bit input and do blending in 8-bit but dither + quantization at the end, which you can’t do in fixed function blending.
* The entire VI postprocessing pipeline. Again, it bears repeating that not only is the RDP graphics being upscaled, so is the VI filtering. VI filtering got a bad rep on the N64 because this overaggressive quasi-8x MSAA would tend to make the already low-resolution images look even blurrier. But at higher resolutions as you can see here, it can really shine. You need programmable blending to emulate the VI’s coverage, and this just is not practical with OpenGL and/or the current HLE renderers out there. The VI has a quite ingenious filter that distributes the dither noise where it reconstructs more color depth. So not only are we getting post-processing AA courtesy of the RDP, we’re also getting more color depth.
* What You See Is What You Get. This renderer is the hypothetical what-if scenario of how an N64 Pro unit would look like that could pump out insane resolutions while still having the very same hardware. Notice that the RDP/VI implementations in ParaLLEl RDP have NOT been enhanced in any way. The only real change was modifying the rasterizer to test fractional pixel coordinates as well.
* Full accuracy with CPU readbacks. CPU can freely read and write on top of RDP rendered data, and we can easily deal with it without extra hacks.

Known issues

• The deinterlacing process for interlaced video modes is still rather poor (just like Angrylion), basic bob and weave setup. There are plans to come up with a completely new system.
• Mario Tennis glitches out a bit with upscaling for some reason, there might be subtle bugs in the implementation that only manifest on that game. This seems to not happen on Nvidia Windows drivers though.

RetroArch Compilation¶

Building RetroArch

The first step is to obtain RetroArch’s source tree.
You can find the repository directly at GitHub

Start the MINGW64 or the MINGW32 shell depending on what you want to compile and run the following commands:

For subsequent builds you will need to pull the changes from the repo

To compile RetroArch run the following commands inside RetroArch’s source tree:

For development purposes you might want to run a debug build instead. In such case use the following commands:

To facilitate debugging you can get an integrated crash handler by replacing the configure step with (debug builds only):

1

After a few minutes you should be able to find retroarch.exe under that directory. To start the newly compiled retroarch you can use:

Packaging RetroArch

You might not be able to start your own build outside that environment. You might want to try to get all the required DLLs by running the following script in your destination RetroArch folder (not the git repo folder):

If Qt is enabled for your build (detected automatically by default), the following is also needed:

If you really want to get the required libraries for distribution or for personal use on other devices and LDD doesn’t work for you for whatever reason, then you can try Dependency Walker.

Tip

If you’re building frequently you may want to add ccache to the mix to speed up the build process.
Install ccache via the package manager and the prepend the ccache symlink directory to your build environment path as shown below.

For further instructions check the

Install ccache for 32-bit builds:

Install ccache for 64-bit builds:

Configure paths for 32-bit builds:

Configure paths for 64-bit builds:

Tip

You can add this to /etc/profile under both the 32-bit and 64-bit setups by adding to the front of the PATH variables found in and , around line 50 of profile, to ensure the proper binaries are loaded for each development environment.

From our own buildbot, the times with and without ccache are the following:

Without ccache:

1
2
3

With ccache:

1
2
3

Tip

You can also strip the debug symbols of the build product to save some space.

Strip retroarch:

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.

Benefits

With RetroArch joypad auto configuration system, your joypad will be recognized and will work out of the box. This allows:

• To plug many different joypads and have them attributed to each players like it would work on a real game console.
• To unplug the second joypad, and replace it by another one, even if it’s of a different brand and model.

Having automatically configured joypads makes it a lot easier to navigate the RetroArch Menu with the joypad. This is very convenient when running RetroArch on a game console, where a keyboard and a mouse are not always available. It is also what makes RetroArch suitable to build your own game console using Lakka or a similar OS.

Won’t be done – where HLE wins

Therefore, the following requests will not be pursued at least in the near future:

* Widescreen rendering – Can be done through game patches (ASM patches applied directly to the ROM, or bps/ups patches or something similar). Has to be done on a per-game basis, with HLE there is some way to modify the view frustum and viewport dimensions to do this but it almost never works right due to the way the game occludes geometry and objects based on your view distance, so game patches implementing widescreen and DOF/draw distance enhancements would always be preferable.

So, in short, yes, you can do this with ParaLLEl RDP too, just with per-game specific patches. Don’t expect a core option that you can just toggle on or off.
* Rendering framebuffer effects at higher resolution – not really possible with LLE, don’t see much payoff to it either. Super-sampled framebuffer effects might be possible in theory.
* Texture resolution packs – Again, no. The nature of an LLE renderer is right there in the name, Low-Level. While the RDP is processing streams of data (fed to it by the RSP), there is barely any notion whatsoever of a ‘texture’ – it only sees TMEM uploads and tile descriptors which point to raw bytes. With High Level emulation, you have a higher abstraction level where you can ‘hook’ into the parts where you think a texture upload might be going on so you can replace it on the fly. Anyway, those looking for something like that are really at the wrong address with ParaLLEl RDP anyway. ParaLLEl RDP is about making authentic N64 rendering look as good as possible without resorting to replacing original assets or anything bootleg like that.
* Z-fighting/subpixel precision: In some games, there is some slight Z-fighting in the distance that you might see which HLE renderers typically don’t have. Again, this is because this is accurate RDP emulation. Z-fighting is a thing. The RDP only has 18-bit UNORM of depth precision with 10 bits of fractional precision during interpolation, and compression on top of that to squeeze it down to 14 bits. A HLE emulator can render at 24+ bits depth. Compounding this, because the RSP is Low-level, it’s sending 16-bit fixed point vertex coordinates to the RDP for rendering. A typical HLE renderer and HLE RSP would just determine that we are about to draw some 3D geometry and then just turn it into float values so that there is a higher level of precision when it comes to vertex positioning. If you recall, the PlayStation1’s GTE also did not deal with vertex coordinates in floats but in fixed point. There, we had to go to the effort of doing PGXP in order to convert it to float. I really doubt there is any interest to contemplate this at this point. Best to let sleeping dogs lie.
* Raw performance. HLE uses the hardware rasterization and texture units of the GPU which is far more efficient than software, but of course, it is far less accurate than software rendering.

Overlays show button presses

Previously, overlays would only show button presses if they were actually being clicked on by either the touchscreen or the mouse.

A user submitted a bounty to make onscreen reactions possible through the gamepad and/or keyboard. A bounty hunter has now successfully completed this bounty and has been paid out. We have enabled this feature by default. If you want to turn it off, you can do so by doing the following:

1 – Go to Onscreen Display -> Onscreen Overlay.
2 – Go to ‘Show Inputs on Overlay’. Set this to off if you don’t want the overlay to react to keyboard/gamepad input, turn it on if you want this to happen (turned on by default).

Nintendo 3DS regression fix – all cores were running slower

A serious issue has been fixed in the Nintendo 3DS RetroArch port which compelled us to push this release sooner rather than later.

It appears that by mistake, rewind was always forcibly enabled in the 3DS port, which led to a halving of performance. This should now be fixed.

Cargar roms en RetroArch para PSP

1. Una vez que tengamos el programa RetroArch abierto, para cargar un juego vamos a seleccionar el contenido (el juego / rom) con la opción Load Content. Se utiliza el botón círculo (O), para seleccionar las opciones de los diferentes menús.
2. Seleccionamos la ruta en donde se encuentra la rom (juego). *En RetroArch puedes predefinir esa ruta en Configurations; para que no tengas que navegar por todas las carpetas cada vez que vayas a abrir un juego nuevo.
3. Selecciona el juego que vas a emular para jugar.
4. Dependiendo del juego, te aparecerán diferentes opciones (cores) para emularlos. Algunos pueden funcionar mejor que otros en ciertos juegos.
5. Presiona círculo y se abrirá la rom del juego para que comiences a jugar.

Prerequisites¶

This is probably the most straightforward way to install RetroArch.

• HENkaku (latest version)
• VitaShell

Downloading and Installing

We’re gonna download two files to get the full experience. One of these files is the version of RetroArch and the other is the package with assets.

Downloading

You can download a stable RetroArch by clicking here. If you want to install the Nightly version, you can also use this link.

From now on, there are two ways to download our assets. This option will affect your setup method. We’re going use the bundle this time.

RetroArch’s data

You can download file from this link or nightly.

Bundle

You can download file from this link.

Installing

Both installation methods will give you the same result. Nightly files will give you the latest developments. This is sometimes dangerous and sometimes innovative. We will use the Stable version and recommend it.

Installing with RetroArch’s Data

Connect your PS Vita with your PC via VitaShell. Just move folder inside downloaded archive to PS Vita directory. Move your to root of your sdcard. Disconnect PS Vita from your PC. Enter the directory, you will see a lot of files, scroll down to the bottom until you see . Press your selection key, it can be O or X. You may receive a warning asking for the reliability of the file you downloaded, if you downloaded this file from our channels, you can accept and continue.

Installing with Bundle

Connect your PS Vita with your PC via VitaShell. Move your to root of your sdcard. Disconnect PS Vita from your PC. Enter the directory, you will see a lot of files, scroll down to the bottom until you see . Press your selection key, it can be O or X. You may receive a warning asking for the reliability of the file you downloaded, if you downloaded this file from our channels, you can accept and continue.

Once the installation is complete, run the RetroArch once and you will see that Fonts and Images are missing. Close and connect PS Vita to PC with . Once you have made the connection, move the files of the downloaded archive to. After successful file transfers, close the application and run RetroArch again.

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
• 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.

How to install

1. Extract the contents of this 7zip archive to a folder somewhere on your PC. This will extract a bunch of vpk files to your harddrive.
2. On the PS Vita/PS TV, make sure the HENkaku exploit has already been installed. Go to the bubble ‘molecularShell’ and start it. Once inside the filebrowser, press ‘Select’ to start the FTP server. Write down the FTP server address you see here.
3. Go back to your desktop PC, start up an FTP client, and input the IP address and port that was displayed on your PS Vita/PS TV. Transfer the vpk files to some place on either ur0: (internal storage) or ux0: (this being your Memory Card).
4. On the PS Vita/PS TV, press circle to go back. Then once back inside the filebrowser, go to the directory where you extracted the vpk files. Install the cores you want.
5. Exit the ‘molecularShell’ program. You should now be back inside the home screen. From here,
RetroArch bubbles should start appearing in the menu. You can now use RetroArch.

Netplay[edit]

You must specify whether you will be hosting (server) or joining (client) the game. If joining, you must also enter the host’s IP address in the field below. Make sure your firewall is open on port 55435 (default; you can change it if you like) and that the port is forwarded in your router, if applicable. You can also specify ‘spectator mode,’ which will allow an arbitrary number of spectators to join and watch you play without being able to play themselves.

Delay frames denote the maximum number of frames RetroArch’s libretro cores will need to emulate at once to maintain synchronization due to actual network latency. You can figure out an appropriate ballpark for this number by pinging the other player and dividing the time (in milliseconds) by 16 (roughly the number of milliseconds in a frame from a game running at 60 fps). If the gameplay is a bit choppy, try increasing the number of delay frames a bit.

Similar to the GGPO platform, RetroArch creates a constant stream of savestates which, along with button presses, are exchanged and compared between the server and client machines. If the savestates start to diverge, the game rolls back in time to a point where they both agree and then the libretro cores emulates the missing frames all at once to get back to the appropriate spot. This gives the illusion of completely lagless inputs, which is invaluable for twitchy, fine controls.

If you try to connect to a server and it immediately says client disconnected, open your log and make sure your ROMs match exactly (it will complain about a hash mismatch otherwise). If it gives you a weird time-out error, just close the window and try to connect again and it should work itself out (sometimes excessive spikes in network latency can cause the states to diverge catastrophically, resulting in this error).