vitaGL: an OpenGL wrapper that translates GLSL to the PS Vita's sceGxm

A translation layer, not a driver in the usual sense

vitaGL is described as an open source OpenGL driver for PS Vita development, and the README is precise about what that means: it acts as a wrapper between OpenGL and sceGxm and allows a subset of OpenGL functions to be used with full hardware acceleration by translating the code to its sceGxm equivalent. Sony's sceGxm is the low level graphics interface exposed by the Vita's system software, and writing against it directly means working with its own resource model, its own shader format and its own state machine. vitaGL lets you write against the OpenGL API instead and pays for the translation. The audience is homebrew developers on the Vita, and the project is the piece that made ordinary OpenGL sample code, and ported desktop projects, run on the console. The licence is LGPL-3.0, the code is C, and the repository carries a COPYING file alongside COPYING.LESSER, which is the usual pairing for that licence.

The prerequisite nobody can skip

There is one hard requirement, and the README puts it before anything else. To run homebrew built with vitaGL you need libshacccg.suprx extracted and decrypted on your console, and the README points to a troubleshooting guide that covers the extraction of the shader compiler. That dependency is structural rather than optional. vitaGL compiles GLSL at runtime, and the shader compiler on the Vita is a separate system library, so without it there is no path from a GLSL shader to something the GPU can run. It also means the audience for this project is a specific one: people with a Vita and the willingness to go through that extraction. A developer evaluating the library purely for its technical merit will find a design that is genuinely interesting and a deployment story that is entirely about the console.

Building the library with make install

The build instruction is short, and the Makefile shows what is underneath. The library target is libvitaGL, and the sources are collected from source, source/utils and source/utils/preprocessor, with C and C++ files gathered separately and compiled into objects. The cross toolchain is the Vita one, arm-vita-eabi, with arm-vita-eabi-gcc as the C compiler, arm-vita-eabi-g++ as the C++ compiler, and arm-vita-eabi-gcc-ar for archiving. The compile flags include -O3, -ffast-math, tuning for the cortex-a9, and NEON support, and the git hash of the checkout is baked in as a preprocessor definition, which is why a working tree rather than a release tarball is the intended starting point. A second set of variables handles the samples, with one target per sample directory producing an .smp file and a .smpc file.

TARGET          := libvitaGL
SOURCES         := source source/utils source/utils/preprocessor

PREFIX  = arm-vita-eabi
CC      = $(PREFIX)-gcc
CXX     = $(PREFIX)-g++

The flags in the Makefile are set through conditional blocks, one per feature, so a build is configured by defining variables rather than by editing a header.

A flag table that doubles as the feature documentation

The README's longest section is a table of compile flags, and it is the closest thing the project has to a feature list. The flags fall into groups. Debug flags add logging through the runtime shader compiler, error output via sceClibPrintf, a lightweight on screen debugger, Razor debugger integration for both retail and devkit, a CPU tracer that inserts a sync at every buffer swap, logging of the GLSL translator and preprocessor input and output, and sanity checks for the internal garbage collector and for thread safety. Compatibility flags cover the awkward corners, including a custom heap replacing the sceClibMspace implementation, experimental support for textureSize calls and uniform buffer objects in GLSL, legacy fixed function uniform bindings such as gl_ModelViewProjectionMatrix, storing depth and stencil surfaces in memory for better OpenGL compliance, and the legacy vglDrawObjects pipeline. Every compatibility flag carries its own cost, and the table says so, for example that fixed function shader support makes the shader pipeline slightly slower.

The speedhack flags trade correctness for CPU time

A third group is the one that tells you what the library is really for. These are labelled hack flags in the README, and each one buys speed by giving something up. Faster vertex buffer copying, faster draw call code, a variant that only speeds up large vertex data draws, faster index buffer handling, faster matrix maths, faster sampler resolution, and faster texture uploads for power of two compressed textures all come with warnings. The README is candid about the trade: several of them may cause crashes, some may cause glitches, one disables instanced draws, and another makes glReadPixels faster at the risk of glitched readbacks. The pattern is that the Vita's ARM CPU is the bottleneck, so the library trades strict OpenGL compliance for CPU cycles wherever the difference is invisible in a frame. Disabling texture combiner support with NO_TEX_COMBINER is described as giving faster fixed function pipeline code execution, and NO_DEBUG disables most error handling, which is faster but may produce code that is not compliant with the OpenGL standards.

Samples that show what the subset actually covers

The samples directory is the best evidence of what vitaGL can do, and it is extensive: twenty-three sample projects covering blit framebuffer, camera, draw batching, draw elements, the glesgear sample, illumination models, immediate mode in several variants including texture, compressed texture and YUV texture, fixed function lighting and fog, sphere lighting, model rendering, occlusion queries, resolution change, a rotating cube both standalone and as a sysapp, a skybox with an environment map, screen space ambient occlusion with deferred rendering, uniform buffers, a vertex buffer rotating cube, vertex arrays, and video playback. The spread is informative. Immediate mode, the fixed function pipeline and the legacy vglDrawObjects path all have samples, which tells you the library keeps the old corners working, while the occlusion query, deferred rendering and video playback samples tell you the modern corners are covered too. The samples are built by the same Makefile as the library, one target per directory, so you can compile only the ones you need while testing a port.

Where vitaGL is the wrong choice

The boundaries are sharp. The first is the shader compiler prerequisite, which makes the library unsuitable for anything but homebrew on a console you have modified. The second is the subset wording. vitaGL implements a subset of OpenGL, and the flag table is a catalogue of the places where the subset stops, with workarounds for uniform buffer objects, textureSize, GL_FIXED attributes and texture dimensions other than 2D, all of them marked experimental. Code written for a desktop OpenGL 3 or 4 core profile will not simply work. The third is the GLSL translation step, which introduces a runtime cost and a failure mode of its own, and the debug flags for logging the translator input and output exist precisely because that step is where problems show up. The alternative to name here is writing against sceGxm directly, which removes the translation cost and the subset limit at the price of learning a Sony-specific API, or targeting a different platform entirely, where a desktop OpenGL implementation is simply available. For a Vita homebrew developer with existing OpenGL code, vitaGL is the cheaper path; for anyone else it is a specialised answer to a specialised problem.

Editorial conclusion

Adopt vitaGL if you are writing PS Vita homebrew in C or C++ and want to use familiar OpenGL calls and GLSL instead of writing sceGxm directly, and if you are comfortable with a toolchain that is still built around a shader compiler binary you must supply. Do not adopt it for a commercial title, because the prerequisite is a decrypted shader compiler library, which is a homebrew requirement rather than a shipping one. Verify first that you can obtain libshacccg.suprx for your console and that the OpenGL subset you need is covered, since the library implements a subset rather than the full specification.

Frequently asked questions

Official sources

1. Issues
2. License: LGPL-3.0
3. README
4. Rinnegatamante/vitaGL on GitHub