# PowerVR Native SDK: a C++ framework layer under Vulkan and OpenGL ES > The PowerVR Native SDK bundles a set of C++ libraries with a large set of graphics samples, so application programmers can skip the boilerplate and study real techniques such as deferred shading, ray tracing and compute based post processing. **powervr-graphics/Native_SDK** — C++ cross-platform 3D graphics SDK. Includes demos & helper code (resource loading etc.) to speed up development of Vulkan, OpenGL ES 2.0 & 3.x applications - Repository: https://github.com/powervr-graphics/Native_SDK - Website: https://docs.imgtec.com/sdk-documentation/html/introduction.html - Stars: 780 · Forks: 216 - Language: C++ - License: MIT - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/powervr-graphics-native-sdk ## The Framework exists to delete the boilerplate layer The PowerVR SDK is an open source codebase with two main parts: the Framework and a set of examples. The Framework is a collection of libraries whose stated aim is to make development of OpenGL ES and Vulkan real-time applications much easier by removing boilerplate and raising productivity. Concretely, it covers the lowest-level parts of a graphics engine, namely the main loop, platform abstraction and graphical utilities, so a developer can concentrate on the key graphics API calls for drawing to screen rather than on standard application setup. The repository layout matches that split. A framework directory holds the core libraries, include and lib carry the public headers and shipped binaries, res holds resources, examples contains the sample applications, and external covers the third-party code. Configuration.cmake and the cmake directory drive configuration, and a separate build-android directory exists for the Gradle path. A few examples go further than a utility layer and show how a pseudo-engine can be constructed on top of the Vulkan Framework using the PVRPfx library. That is the strongest signal about who this is for: application and engine programmers who want a working skeleton to start from, not people looking for a new graphics API. ## No system libraries ship with the SDK The single most consequential limitation is stated plainly: the PowerVR SDK does not provide OpenGL ES or Vulkan API system libraries. If the target platform does not already have them, you have to ask the platform provider for those libraries. The SDK is a layer above the API, never a replacement for it. That cuts both ways. On a phone or tablet with a PowerVR GPU you get a driver from the vendor and the SDK handles everything above it, which is the intended deployment. On a desktop without PowerVR hardware you have no native OpenGL ES support at all, and the answer is PVRVFrame, a set of desktop emulation libraries that wrap desktop OpenGL. So the project is really two things joined together: a portable application framework, and an emulation path that lets you run OpenGL ES code on a machine that has no PowerVR silicon. Reading the dependency list, repository layout and the PVRVFrame section together makes the boundary clear. The Framework, the samples and the loader are yours. The driver belongs to whoever built the device. ## Building it: CMake for everything, Gradle for Android The build story is short because the project uses standard tooling. The PowerVR SDK uses CMake for building for any platform, and additionally uses Gradle when building for Android. To build, navigate to the root of the SDK or alternatively to the root folder for any example, create a cmake binary directory, and run CMake from that created folder. For Android, navigate to the build-android folder of the item to build and run the platform specific Gradle wrapper script provided, gradlew.bat/gradlew.sh on Windows and gradlew.sh elsewhere. The two build tools the project relies on: ```bash cmake gradlew.bat/gradlew.sh ``` Detailed instructions live in BUILD.rst at the root of the repository, and .clang-format plus .travis.yml sit alongside CMakeLists.txt as the formatting and continuous integration configuration. The practical advantage of the Gradle path is that you can build one example without configuring the whole SDK, and the practical annoyance is that the Android flow is a separate convention that you have to learn in addition to the CMake one. There is no documented one line installation command in the project description, so a first real use means cloning the repository, building an example, and then wiring your own resources into it. ## PVRVFrame runs OpenGL ES code on a desktop that has no PowerVR GPU PVRVFrame is included as part of the PowerVR SDK and provides a set of desktop emulation libraries for OpenGL ES, wrapping desktop OpenGL, which allows deployment of OpenGL ES applications on desktop Windows, macOS and Linux and can help to speed up development times. Two caveats follow immediately. Performance and capabilities depend on the 3D acceleration present in the system, and the documentation states that the PVRVFrame libraries are not intended to be a completely accurate replication of the behaviour of PowerVR hardware. The three libraries involved are: ```bash libEGL.dll libGLES_CM.dll libGLESv2.dll ``` Finding them is the fiddly part. They can be found pre-installed in the [path-to-sdk]/libs folder. If the SDK was installed using the PowerVR SDK installer, the emulation libraries may already be present in the PATH environment variable if this was requested during installation. Otherwise they can be manually added to the PATH or copied to a DLL-accessible directory prior to running the SDK applications, which may be anywhere in the path, next to the executable, or in system default folders. To install them system-wide on Windows, copy the 64-bit version to %windir%\System32 and the 32-bit version to %windir%\SysWOW64 so that they are automatically selected by the corresponding applications. If you skip that, architecture bites: if the 32-bit libraries are in the PATH, 64-bit applications cannot be run and vice versa. ## The ray tracing samples need Vulkan 1.2.162.1 and real hardware Several examples implement ray tracing techniques: HelloRayTracing, HybridHardShadows, HybridReflections, HybridRefractions, HybridSoftShadows, HybridTransparency, RayTracedHardShadows and RayTracingDenoising. These demos are compatible with RT-ready desktops and laptops running Windows 10 or Linux, and they require hardware or drivers supporting a minimum Vulkan version of 1.2.162.1. That requirement is the practical limit of the project. A developer with an older GPU, a driver from before that Vulkan revision, or a machine outside Windows 10 and Linux cannot run this group of samples at all, and the SDK gives no fallback path. The hybrid naming is worth understanding too: several of the samples are hybrids rather than pure ray tracers, which is the approach you would expect on mobile-class hardware where a full traversal is too expensive. If your target is a phone or tablet, the ray tracing set is not your entry point. The OpenGL ES and OpenCL examples, plus the general Vulkan samples, are the parts of the tree that map onto the hardware the SDK actually targets. ## The neural rendering sample is a sketch, not a shipping technique One example, NeuralNetworkEnvironment, implements a neural rendering algorithm, and the project describes it plainly: it has a non-performant compute shader implementation, and a cooperative matrix implementation which requires the VK_KHR_cooperative_matrix extension. Both paths are worth reading for what they show, and neither is a path you would put into a shipping frame. The compute shader version is the portable one, since it needs nothing beyond standard compute support, and it is described as non-performant. The cooperative matrix version offloads the heavy lifting onto matrix units and is the one that could reach interactive rates, but it depends on an extension that a large share of deployed Vulkan drivers do not expose. The trade-off is therefore availability against speed, and the project states it rather than hiding it. Treat this sample as a reference implementation and a place to see the extension used in context. If you adopt the approach for real work, the first thing to check on your target devices is whether VK_KHR_cooperative_matrix is present. ## The sample tree is where the actual graphics techniques live The examples directory holds OpenCL, OpenGLES, OpenGLSC, Vulkan, assets and common subdirectories, and the samples themselves are mostly code samples with a deliberate bias toward technique rather than toward application shape. They are built on top of the Framework and optimised so that only the relevant code is left, which is what makes them useful as reference code. Three groups stand out. First, the basics of OpenGL ES and Vulkan, in the HelloAPI and IntroducingPVRShell examples. Second, implementations tuned for PowerVR, such as DeferredShading with Pixel Local Storage and transient attachments, and a Gaussian Blur that uses a Sliding Average compute shader to reduce bandwidth. Third, demonstrations of extensions that may improve performance, PowerVR specific or otherwise, including IMGFramebufferDownsample and IMGTextureFilterCubic. The range runs from setting up a simple application using the Framework to implementing more advanced graphics techniques such as physically-based rendering. For a reader deciding whether to adopt the Framework, this is the decisive part of the repository, because the value of a framework is judged by what its samples let you do on the first afternoon. ## Third-party code, MIT licensing, and a last push on 2026-09-22 The PowerVR SDK has a number of third-party dependencies, each of which may have their own license. The dependency list in the project documentation is: ```yaml glm pugixml concurrentqueue glslang tinygltf vma vulkan ``` glm provides OpenGL Mathematics, pugixml is an XML parser with XPath support, concurrentqueue is a lock-free multi-producer multi-consumer queue for C++11, glslang is the shader front end and validator, tinygltf is a header only glTF 2.0 library, vma is the Vulkan Memory Allocator, and vulkan is the source for the formal documentation of the Vulkan API. The SDK itself is published under the MIT license in LICENSE.md, but that grant does not extend to the dependencies, and each of them carries its own terms that you need to read before distributing a binary. None of this is legal advice, it is just the licensing surface you inherit. On upkeep, the repository is not archived, and the last push was on 2026-09-22, carrying release R26.2-v5.17, described as the PowerVR Graphics SDK v5.17 Release. The latest release notes are published on the developer.imaginationtech.com release notes page, and since a single release tag is listed, tracking that page is the practical way to follow changes. Dependency versions are not pinned in the project documentation, so the upgrade cost of the third-party code sits with you when you move between SDK versions. ## Conclusion Adopt the PowerVR Native SDK if you are writing a Vulkan or OpenGL ES application and want a working main loop, platform abstraction and resource loading without writing them from scratch, and if your target hardware is PowerVR. Do not adopt it as a standalone graphics stack, since the SDK ships no OpenGL ES or Vulkan system libraries, and treat PVRVFrame as a desktop convenience rather than a hardware accurate model. Before starting, check that your target platform provider supplies the driver, confirm the Vulkan version your chosen example needs, and read the dependency licenses listed in the project before you ship a binary. ## FAQ ### Does the PowerVR Native SDK include OpenGL ES and Vulkan system libraries? No. The SDK does not provide OpenGL ES or Vulkan API system libraries, so if the target platform does not have them you must ask the platform provider for them. PVRVFrame covers only the case of platforms without native OpenGL ES support where OpenGL itself works. ### How do I build the PowerVR Native SDK on Android? Navigate to the build-android folder of the item you want to build and run the platform specific Gradle wrapper script provided, gradlew.bat/gradlew.sh. For other platforms the SDK uses CMake: navigate to the root of the SDK or of an example, create a cmake binary directory, and run CMake from that folder. ### Can I run the PowerVR Native SDK ray tracing examples on any laptop? No. The ray tracing demos need RT-ready desktops and laptops running Windows 10 or Linux, plus hardware or drivers supporting a minimum Vulkan version of 1.2.162.1. ### Where do I find the PVRVFrame emulation libraries? They can be found pre-installed in the [path-to-sdk]/libs folder, and if the SDK was installed with the PowerVR SDK installer they may already be in the PATH environment variable. Otherwise add them to the PATH manually or copy them to a DLL-accessible directory, and on Windows put the 64-bit copy in %windir%\System32 and the 32-bit copy in %windir%\SysWOW64. ### Does PVRVFrame reproduce PowerVR hardware behaviour exactly? No. The PVRVFrame libraries are not intended to be a completely accurate replication of the behaviour of PowerVR hardware, and their performance and capabilities depend on the 3D acceleration present in the system running them. ### Which third-party libraries does the PowerVR Native SDK depend on? The dependency list names glm, pugixml, concurrentqueue, glslang, tinygltf, vma and vulkan. Each of these may carry its own license, separate from the MIT license the SDK itself uses. ## Sources - [License: MIT](https://github.com/powervr-graphics/Native_SDK/blob/master/LICENSE) - [powervr-graphics/Native_SDK on GitHub](https://github.com/powervr-graphics/Native_SDK) - [Project website](https://docs.imgtec.com/sdk-documentation/html/introduction.html) - [README](https://github.com/powervr-graphics/Native_SDK/blob/master/README.md) - [Releases](https://github.com/powervr-graphics/Native_SDK/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/powervr-graphics-native-sdk