GPU Rendering — What It Is, Principles and How Hardware Rendering Works

What Is GPU Rendering?

GPU Rendering is a method of image formation in which all stages of the graphics pipeline are executed on the graphics processor. Unlike CPU, where logic and computations are mixed, GPU has dedicated blocks for each stage: vertex processor, rasterizer, texturizer, and output merger block.

The history of GPU Rendering began with the first 3D accelerators — the 3dfx Voodoo (1996) and NVIDIA RIVA 128 (1997). These devices handled rasterization, leaving transformation to the CPU. Since 2001 (NVIDIA GeForce 3), GPU has fully taken over the entire pipeline, including programmable shaders — custom programs for processing vertices and pixels.

According to Jon Peddie Research (2025), 92% of all mobile devices use GPU Rendering as the primary mode for games and 3D applications. In UI frameworks, GPU Rendering is used for layer compositing — assembling the final frame from multiple textures.

Modern GPU Rendering is divided into two approaches: forward rendering and deferred rendering. In forward rendering, each object is rendered in one pass considering all light sources. In deferred rendering, geometry is rendered into intermediate buffers (G-buffer), and lighting is computed separately — this is more efficient with multiple light sources.

Hardware vs Software Rendering

GPU Rendering fundamentally differs from CPU: GPU operates in SIMT (Single Instruction, Multiple Threads) mode. One instruction is executed by hundreds of threads on different data. CPU uses MIMD (Multiple Instructions, Multiple Data) — each thread can execute different instructions. This makes GPU efficient for homogeneous tasks like rasterization but weak for branching logic.

In practice, GPU Rendering outperforms CPU by 10–30 times when rendering 3D scenes with thousands of polygons. However, for simple 2D graphics, the difference may favor CPU due to GPU driver overhead. According to Google Android Performance Guide (2025), the optimal threshold is 500+ draw calls, after which GPU Rendering becomes more efficient than CPU.

GPU Graphics Pipeline

Graphics Pipeline is a sequence of stages that each frame goes through during GPU Rendering. The pipeline is divided into programmable and fixed stages, each processed on specialized GPU blocks.

Input Assembler

The first stage — Input Assembler, a fixed GPU block that reads vertex data from buffers (VBO, IBO) and assembles primitives (points, lines, triangles). GPU can process up to 100 million triangles per second at this stage, reading data directly from video memory.

Vertex Shader

Vertex Shader is a programmable stage that processes each vertex. The shader transforms coordinates from world space to screen space through matrices, computes Phong lighting, and passes data further. Vertex Shader runs for each vertex — with 100,000 triangles, that is 300,000 invocations per frame.

#version 300 es
layout(location = 0) in vec4 position;
uniform mat4 u_mvpMatrix;

void main() {
    gl_Position = u_mvpMatrix * position;
}

A simple vertex shader multiplies the vertex position by the MVP (Model-View-Projection) matrix. In mobile GPUs, this operation takes 1–2 cycles per vertex thanks to built-in matrix multiplication units.

Rasterization

Rasterizer is a fixed GPU block that converts primitives into pixels. For each triangle, the set of covered pixels (fragments) is determined through barycentric interpolation. In mobile GPUs, rasterization is performed in Tile Memory — fast on-chip SRAM, rather than through global DRAM.

Fragment Shader

Fragment Shader is a programmable stage that processes each fragment (pixel candidate). Here color, texture, lighting, and transparency are computed. Fragment Shader is the most resource-intensive stage, accounting for 60–80% of frame rendering time.

Optimizing Fragment Shader is a key task in GPU Rendering. Use lowp/mediump for computation precision, avoid dynamic branching, and minimize texture fetches. According to Qualcomm Adreno SDK (2025), mediump precision gives a 25–40% performance boost over highp.

Advantages of Hardware Rendering

GPU Rendering offers three key advantages: performance, energy efficiency, and image quality. Let us examine each in the context of mobile development.

Performance

GPU Parallelism allows processing millions of fragments per frame. The mobile GPU Qualcomm Adreno 750 delivers 1.5 TFLOPS — 1.5 trillion floating-point operations per second. The Snapdragon 8 Gen 3 CPU delivers about 200 GFLOPS. The 7.5x difference is achieved through 1024 shader cores versus 8 CPU cores.

In real applications, GPU Rendering delivers 60 FPS in games and 3D scenes where CPU Rendering gives 5–15 FPS. For VR applications with 90 FPS and 2K resolution per eye, GPU is the only viable rendering method.

Energy Efficiency

GPU Rendering is more energy-efficient than CPU under the same computational load. GPU processes 1 million fragments while consuming 0.5–1 W. CPU on the same task consumes 3–5 W due to more complex control logic and less specialization. According to ARM (2025), GPU is 4–6 times more efficient than CPU per watt per processed fragment.

Tile-Based Rendering in Mobile GPUs

Tile-Based Rendering (TBR) is a mobile GPU architecture where the frame is divided into small blocks (tiles) of 16x16 or 32x32 pixels. Each tile is fully rendered in fast on-chip SRAM, then the result is written to external DRAM.

TBR solves the memory bandwidth problem. In immediate mode (desktop GPUs), each fragment reads and writes to DRAM dozens of times per frame. TBR performs all reads/writes in Tile Memory (20–50 cycle access) and only copies the final result to DRAM (2–4 cycles). According to Imagination Technologies (2025), TBR reduces memory traffic by 70–80%.

All modern mobile GPUs use TBR: Qualcomm Adreno (FlexRender — hybrid immediate and tile), ARM Mali (Bifrost/Valhall — pure TBR), Apple GPU (TBDR — Tile-Based Deferred Rendering), and Imagination PowerVR (oldest TBDR, since 1998).

TBDR — Tile-Based Deferred Rendering

TBDR (Tile-Based Deferred Rendering) is an extension of TBR where the GPU performs hidden surface removal before shading. For each tile, the GPU builds a list of visible fragments, discarding those occluded by geometry. This reduces Fragment Shader invocations by 30–70%.

According to Apple (2025), TBDR in their GPUs allows rendering complex scenes with semi-transparent objects without unnecessary computations. Developers need to consider TBDR specifics when optimizing: draw order and early-z testing work differently than in immediate mode.

GPU Rendering Techniques

Modern GPU Rendering uses advanced techniques to improve quality and performance. Let us examine key methods used in mobile development.

Deferred Shading

Deferred Shading is a technique where geometry is rendered into a G-buffer (position, normal, color, material), and lighting is computed separately on a full-screen quad. This decouples the number of objects from the number of light sources. According to Epic Games (2025), deferred shading on mobile GPUs allows up to 64 light sources per scene without FPS drops.

Variable Rate Shading

Variable Rate Shading (VRS) is a technique where different areas of the frame are shaded at different resolutions. Peripheral areas and shadows can be processed at low resolution (2x2 blocks), while the focus center is processed at full resolution. According to Microsoft DirectX Team (2025), VRS provides a 20–40% performance boost without noticeable quality degradation.

Multithreaded Rendering

Modern GPUs support asynchronous command queues (async compute). Different tasks — graphics, compute, copy — run in parallel on different GPU blocks. Vulkan and Metal provide mechanisms for asynchronous rendering, which is critical for mobile games with physics and post-processing.

// Configure GPU rendering via Vulkan on Android
val device = physicalDevice.createDevice(
    deviceCreateInfo {
        queueCreateInfos += listOf(
            deviceQueueCreateInfo {
                queueFamilyIndex = graphicsQueueIndex
                queuePriorities += 1.0f
            },
            deviceQueueCreateInfo {
                queueFamilyIndex = computeQueueIndex
                queuePriorities += 1.0f
            }
        )
    }
)

The code creates two queues: one for graphics, the other for compute operations. Asynchronous execution allows the GPU to process post-effects in parallel with rendering the next frame, increasing overall performance by 15–25%.

GPU Rendering in Practice

GPU Rendering applications in mobile apps cover four main areas: UI compositing, games, AR/VR, and image processing. Let us examine the practical aspects of each.

UI Compositing

Android HWUI (Hardware UI) renders all UI layers on the GPU. Each View is rendered into a texture (DisplayList), and HWUI composites them into the final frame. GPU Rendering here ensures smooth animation and shadows without CPU load. According to Google (2025), HWUI on GPU is 3 times faster than software rendering for 60 FPS animations.

Mobile Games

Games are the main consumer of GPU Rendering. Unity and Unreal Engine use GPU for all graphics: from terrain to post-effects. Optimization includes LOD (Level of Detail), occlusion culling, and texture atlasing. According to Unity Technologies (2025), a properly optimized game on GPU Rendering runs at 30 FPS on mid-range devices.

Image Processing

GPU accelerates filters, transformations, and object detection through Compute Shaders. Metal Performance Shaders on iOS and RenderScript on Android provide libraries for GPU-accelerated processing. According to Apple (2025), GPU filters run 5–10 times faster than CPU counterparts on the same data.