Rendering to Texture Test

What is this tool?

The Rendering to Texture Test measures the part of the GPU pipeline that games lean on for post-processing: rendering into off-screen textures and reading them back. It uses real WebGL2 framebuffer objects, texture attachments and ping-pong render targets — not a simulation — and reports honest frame metrics.

The first pass renders a procedural ray-marched scene into a texture; the next passes ping-pong a Gaussian/bloom convolution between two textures (the heavy setting adds chromatic aberration); a final pass composites to the screen with a vignette. Every framebuffer is validated as complete before use.

You control the render-target size, the number of passes, the texture format and filtering, and the post-processing weight, so you can push the exact part of the pipeline you care about. No temperature, power, clock or utilisation figure is produced — a browser cannot read them.

How to use it

1. Set the render-target size and passesTarget Size runs 512, 1024, 2048 (default) or 4096, capped at your GPU's maximum texture size; Passes are 1, 2, 4 or 8. Larger targets and more passes mean far more texture bandwidth.
2. Choose format and filteringFormat is RGBA8 or RGBA16F, where RGBA16F is offered only if your GPU supports the EXT_color_buffer_float extension. Filtering is linear or nearest.
3. Set complexity, post-processing and scaleScene Complexity (low-extreme) drives the first pass; Post-Processing (off / basic / medium / heavy) adds convolution passes and, at heavy, chromatic aberration; Render Scale super-samples the canvas.
4. Run for a set durationChoose a duration (30 seconds by default). Every valid frame is timed from the first one — there is no warm-up window on this tool — and the metrics update live.

What the results mean

Average and 1% low FPS

Average FPS is 1000 divided by the mean frame time; the 1% low is the mean of the slowest 1% of frames as an FPS. Together they separate raw throughput from worst-case hitching.

Frame time and jitter

Wall-clock frame interval from performance.now() (average, min and max) with jitter as the standard deviation of frame times. A frame over 33.33 ms counts as a drop.

Stability

Stability is 100 × (1 − min(1, stdDev / avgFrameTime)) as a percentage — high when the texture pipeline keeps a steady pace, low when bandwidth pressure makes it uneven.

Resolution and configuration

The active render-target size, format, pass count and render scale are reported so a result is always tied to the exact pipeline that produced it.

What it can detect

• How your GPU handles multi-pass render-to-texture and post-processing workloads
• The cost of larger render targets, more passes and heavier convolution
• Whether your GPU supports floating-point RGBA16F render targets at all
• Texture-bandwidth pressure, seen as falling stability as target size and passes climb

Limits worth knowing

A browser can only report what the platform gives it. These are the honest boundaries of this page, so a result is never read as more than it is.

• It cannot read GPU temperature, power, clocks, utilisation or VRAM. GPU identity comes only from WEBGL_debug_renderer_info, which some browsers mask.
• It reports a metric set, not a single composite score — there is no fabricated points figure.
• There is no warm-up exclusion, so the first frames of a run include shader-compilation cost, and no tab-blur pause, so backgrounding the tab distorts the numbers.
• RGBA16F render targets require the EXT_color_buffer_float extension; where it is missing the option is disabled rather than silently downgraded.
• Target sizes above your GPU's maximum texture size are rejected, and frame rate is capped by the display refresh rate via requestAnimationFrame.

Tips

• Raise the pass count to stress bandwidth and the target size to stress memory — pushing them separately tells you which limit your card hits first.
• If RGBA16F is greyed out, that is your GPU or browser lacking EXT_color_buffer_float, not a bug; stay on RGBA8.
• Keep the tab focused: with no warm-up and no visibility pause, this tool's numbers are especially sensitive to alt-tabbing mid-run.

Troubleshooting

Related documentation

• DisplayShader Performance TestMeasure fragment-shader throughput with a real WebGL2 ray-marcher and a four-tier complexity sweep.
• DisplayVolume Shader BenchmarkA repeatable volumetric-shader benchmark with a warm-up, a transparent score and a controlled comparison mode.
• Display3D Rendering Performance TestBenchmark your WebGL 3D graphics rendering performance, real-time FPS, frame timing, and pacing stability.
• DisplayGPU BenchmarkRun a real browser-based graphics benchmark to measure your GPU rendering performance, FPS, frame time, and WebGL capability.