Vita scene veteran developer xerpi has released vita2hos (Vita to Horizon OS), an interface library that allows running Vita executables on the Nintendo Switch.

This is in very early development phase, and this first release only works with simple homebrew software such as the “cube sample” provided in the homebrew Vita SDK. (video below), but this could ultimately allow to run Vita Games on the Nintendo Switch, likely full speed performance out of the box.

What is Vita2hos for Nintendo Switch

Vita2hos is a “translation layer”, an API that reroutes Vita routine calls to Native Switch equivalents.

In other words, it is not an “emulator” in the technical sense, as it is not trying to mimic the Vita CPU/GPU, but instead reroutes libraries with native Switch counterparts. This is very similar to what Wine does for running Windows on Linux, or to what some recent Android game ports on vita have been doing. (And for what it’s worth, similar to what we were doing with PSP’s HBL/VHBL in some cases when some specific modules could not be accessed)

According to vita2hos readme, Vita executables are ARM7 based, and can be run natively on the Switch’s ARM8 processor. This means that overall the binary code is interpreted the same, and as such there is no need to emulate the Vita CPU on Switch via binary recompilation. The routines from modules loaded by the game however, need a native equivalent on the Switch, and vita2hos is required to “reroute” the functionality, sometimes with additional changes for compatibility.

PlayStation Vita (ARMv7 CPU) executables can be run natively on Nintendo Switch ARMv8 CPU in 32-bit execution mode.

When loading a PlayStation Vita executable, vita2hos redirects the module imports of said executable to jump to routines that implement the same behavior, by using native Horizon OS services, like the one exposed by the original PlayStation Vita OS modules.

A simple example from the source code is the thread creation functionality:

SceUID sceKernelCreateThread(const char *name, SceKernelThreadEntry entry, int initPriority,
SceSize stackSize, SceUInt attr, int cpuAffinityMask,
const SceKernelThreadOptParam *option)
{
    return create_thread(name, entry, initPriority, stackSize);
}

This converts a pretty common Vita routine, into something that will work on the Switch. Notice how some of the parameters of the function (such as cpuAffinityMask) are dropped. This means the functionality will not always be 100% equivalent to that of the Vita, but that kind of approximation might be sufficient to run the majority of games.

The cons of going with such a path are that the results are (at least initially) going to be an approximation of how the Vita behaves. In many cases this might be enough, but for some games this might result in glitches, missing functionality (for example no sound as long as e.g. the mp3 library is not properly “translated”), or simply the game not working.

The pros are that this is only a thin translation layer on top of the executables, meaning that Vita games should be able to run at full speed on the Switch, once vita2hos has matured enough to run more games.

About Vita2hos Alpha 0.1

Here’s what Xerpi has to say about this first release:

Keep in mind this is still in the “proof of concept” stage. While it can run some simple CPU-rendered homebrews (such as VITA-8), there’s still very initial 3D graphics support (it can run vitasdk’s GXM triangle and cube samples by hardcoding vita2hos’s shaders to match the ones the sample uses).

The most difficult task is shader translation from PSVita’s SGX USSE bytecode to Nvidia Maxwell instructions. Ideally, I’d like to use Vita3K’s shader recompiler, or even turn Vita3K into a translation layer (other than also acting as an emulator on x86 systems) so that we don’t have to duplicate a lot of the code.

I have very hacky and PoC support for shader translation using copy-pasted Vita3K and UAM (open source shader compiler for the open-source Switch 3D graphics library: deko3d) code in the vita3k-shader-recompiler-uam branch.

Video showing vitasdk’s GXM cube sample running on the Switch via vita2hos: https://i.imgur.com/w9HPluo.mp4

Download vita2hos Alpha 0.1

In its current state, vita2hos only runs a small subset of very simple Vita homebrew (examples below), but those of you who want to try it can follow the instructions below.

Download vita2hos here.

How can I use it?

1. Copy vita2hos.nsp to your microSD card (i.e. to: atmosphere/vita2hos.nsp)

2. Create atmosphere/config/override_config.ini and add the following lines to it:

   [hbl_config]
   override_any_app=true
   override_any_app_key=R
   override_any_app_address_space=32_bit
   ; adjust the path according to the location of your file
   path=atmosphere/vita2hos.nsp
   

   • Note: As long as this file exists you won’t be able to use the homebrew menu and instead will always run vita2hos.

     A quick workaround would be to rename the file and restart your Switch. Unfortunately override_config.ini doesn’t allow multiple path entries which is why it has to be done this way.

3. Copy a PlayStation Vita executable (.velf or .self/eboot.bin) to the root of your microSD card and rename it to test.elf

4. Boot (or reboot) your Switch and start any game while holding down R

   • Attempting to use vita2hos via applet mode (album button) will currently result in a fatal error and wouldn’t be recommended anyway.

5. Enjoy!

Sample PSVita homebrew:

• VITA-8: download
• vitasdk GXM triangle sample (modified): download
• vitasdk touch sample: download