1. LandOffer
  2. Blog
  3. All articles
  4. Graphics Engineer Portfolio: Pair a Visual Result with a GPU Performance Capture

Job search

Graphics Engineer Portfolio: Pair a Visual Result with a GPU Performance Capture

Pair an original WebGL2 render with actual GPU timer-query captures, pixel-equivalence checks, and a controlled optimization review with honest limits.

10 min readLandOffer team

A graphics engineer portfolio should connect a visible result to the work required to produce it. Preserve the scene, renderer settings, exact timed command region, raw capture, and visual checks beside the image. State whether the number covers GPU commands, CPU work, or presentation; the reader should not have to infer the measurement boundary. If an optimization changes submission counts but barely changes measured GPU time, report that outcome rather than turning fewer draw calls into an invented speedup.

This guide actually rendered an original WebGL2 scene and collected GPU timer-query results in a local Chrome tab on October 23, 2026. It also compared two implementations and exported the actual canvas image. The measurements are GPU elapsed-query values, not JavaScript wall-clock time. The separate editorial illustrations in this article are not screenshots of the measured scene.

An optical workshop pairs a carefully lit sphere study with a separate precision measurement record.

Use LandOffer’s recently posted jobs to identify the rendering, profiling, or visual-quality responsibility your sample should demonstrate. Choose a small scene you own and a performance question that your tools can actually answer.

Choose a question narrower than “make rendering faster”

Our question was whether eight identical opaque fullscreen submissions should be reduced to one while preserving the output. This is an intentionally redundant workload. It does not represent eight different lighting passes, a large game level, or a production renderer’s normal workload.

The authored vertex shader emits one fullscreen triangle. The fragment shader analytically intersects three spheres and a floor plane, then computes diffuse and specular shading, a checker pattern, fog, and a final color adjustment. It uses fixed camera and light values, with no external textures, models, animation, or customer assets.

The baseline submits that same scene eight times. The candidate submits it once. Each draw is opaque, blending and depth testing are disabled, and later draws overwrite the same visible result. Removing a repeated submission is therefore a concrete source-level change whose visual equivalence can be checked.

The authored test asked one question: does removing these redundant submissions reduce the GPU interval under the fixed conditions? That question can be answered with the saved samples even if the result is a very small change. It was not a prediction of an eightfold improvement, and it did not assume whether shader arithmetic, bandwidth, driver behavior, or another component dominated. The capture needed to determine what claim the result could support.

Worked asset one: a complete owned scene and capture packet

The first deliverable contains the original index.html and scene.js, the actual rendered-scene.png, gpu-capture-1.json, gpu-capture-2.json, and gpu-capture-3.json, a native browser screenshot, and a reproduction note. All three raw captures preserve the shader hashes, buffer dimensions, context attributes, and individual query-validity fields. The PNG is the actual canvas output: three shaded red, blue, and yellow spheres above a checker floor. It was not produced by ImageGen or substituted from a tutorial.

The drawing buffer is fixed at 960 by 540 pixels. The canvas is displayed smaller in the page, but the performance record names the actual drawing-buffer dimensions. Antialiasing, alpha, depth, and stencil buffers are disabled for this experiment; the context retains its drawing buffer for export. These conditions are not recommendations for every renderer.

The observed browser user agent reports Chrome 156. The renderer string is “ANGLE (Apple, ANGLE Metal Renderer: Apple M5 Pro, Unspecified Version).” Treat that as the browser’s reported renderer, not an independently audited hardware inventory. The user agent also contains an Intel/macOS compatibility string; we did not use it to infer the machine’s actual processor or operating-system version.

The capability probe found WebGL2 and EXT_disjoint_timer_query_webgl2 available. The elapsed-time query reported 64 counter bits. No browser flags, security controls, global settings, production application, or third-party process were changed to obtain access.

RenderDoc and xctrace command-line tools were unavailable in the inspected environment. The resulting artifact is therefore a GPU timer-query capture, not a RenderDoc .rdc frame-debugger capture. It supplies timed intervals and an owned visual output, but not a debugger’s event list, resource inspection, or hardware-stage analysis.

RenderDoc’s upstream capture guide describes launching an application for capture and saving capture configurations. That is useful context when a supported tool is available. We did not install RenderDoc, inject into another process, or claim a saved configuration was a captured frame.

Keep GPU timing separate from CPU and presentation timing

The Khronos extension specification documents elapsed GPU queries, asynchronous result availability, and the disjoint condition. Our script wraps only the draw submissions in the query. It waits for availability, checks disjoint flags, reads the elapsed nanoseconds, and records graphics errors.

The sample does not use performance.now(), an animation-frame interval, or the time required to submit JavaScript calls as its GPU measurement. Animation-frame callbacks are used only to yield while a query result is unavailable. The number of availability polls is retained, but is not converted into GPU milliseconds.

Clearing, shader compilation, pixel readback, browser compositing, and CPU work are outside the timed region. Consequently, the reported interval is not a complete frame time, total application latency, or display frame rate. Converting its reciprocal into an FPS claim would measure the wrong scope.

Each capture begins with four warm-up queries per variant. These eight queries remain in the file but are excluded from the reported comparison. The retained sequence has sixteen pairs, alternating which variant runs first. That reduces a simple all-baseline-then-all-candidate ordering effect; it does not eliminate temperature, clock, scheduling, or other environmental noise.

A retained query is valid only when the result is available and positive, neither recorded disjoint flag is set, and no graphics error is reported. All three actual captures retained sixteen valid results per variant. The third was an independent reviewer rerun; no controlled power-state comparison between the runs was established. The final context was not lost, and the final graphics error value was zero.

Worked asset two: the controlled comparison and visual gate

The second deliverable is a completed optimization review, with its own question, acceptance conditions, recalculation script, decision, and rejected claims. It uses the scene packet’s raw evidence rather than copying a screenshot into an “after” column and assuming improvement.

The application submits eight draw calls and 24 vertices in the baseline, versus one draw call and three vertices in the candidate. These are counts from the authored submission loop. They are not independently captured hardware counters, and they do not prove that the driver executes eight times as much fragment work.

Three native browser runs produced these GPU intervals. The writer collected the first two; a reviewer independently repeated the same source and supplied the third. Reported renderer and drawing-buffer settings match, while power and other background conditions were not controlled across runs:

Capture and variant Valid samples Median GPU interval Retained minimum–maximum
Run 1, eight draws 16 0.104666 ms 0.103166–0.125291 ms
Run 1, one draw 16 0.103062 ms 0.092833–0.105874 ms
Run 2, eight draws 16 0.105313 ms 0.103333–0.490416 ms
Run 2, one draw 16 0.103041 ms 0.090999–0.103750 ms
Run 3, eight draws 16 0.156125 ms 0.055916–1.697083 ms
Run 3, one draw 16 0.247312 ms 0.050375–1.680250 ms

The table rounds medians to six decimal places; raw integer nanosecond values and exact recalculated medians remain in the JSON analysis. The second baseline’s 0.490416 ms observation is retained in both the raw data and range. It was not removed to make the comparison look cleaner. The offline script recomputes the median and range from every retained sample, so the reader can reproduce both the central value and that outlier.

For the visual gate, the script renders both variants and reads their RGBA buffers outside the timed queries. The Khronos WebGL2 specification describes the typed-array readback as a blocking operation. Keeping that readback outside the query prevents this verification step from being presented as part of the measured draw interval. Each buffer has 2,073,600 bytes. There are zero mismatched bytes, and both variants have the same SHA-256 value in all three captures. The PNG export has a separate file hash; encoded PNG bytes are not the same representation as raw framebuffer bytes.

This check establishes exact equality for this scene, state, and output size. It does not prove equivalence for transparency, different material ordering, animation, or other render states. The full image remains available so a reviewer can inspect what the equal buffers actually depict. Equality means the candidate preserves this baseline output; it does not establish physically accurate lighting or suitability for another rendering task.

Retain the simplification without inventing a bottleneck

The completed decision is to retain the one-draw version because seven identical opaque submissions are unnecessary in this authored scene. The visual gate passes. The first two captures have lower one-draw medians by about 1.60 and 2.27 microseconds. In the independent third capture, the one-draw median is instead higher by about 91.19 microseconds. The timing ranges overlap, and the median direction reverses.

The independent rerun therefore strengthens the refusal to claim a consistent GPU acceleration, let alone an eightfold speedup. Its larger spread is retained without assigning a cause that these records cannot establish. No formal uncertainty test, repeated power-state study, or representative application workload was performed. Reporting only the minimum sample, one favorable run, or the reduction in submitted calls would exaggerate the result.

The comparison also does not identify a shader-ALU or bandwidth bottleneck. The driver and GPU may handle redundant opaque work in ways this timer does not expose. A precise explanation would need additional evidence. The measured outcome supports a narrower conclusion: the source contains fewer redundant submissions with unchanged pixels, while the timing direction changes across the three observed runs.

The trade-off is scope. Combining genuinely different draws, eliminating order-dependent blending, or removing a material pass could change the image. Those are different experiments. This candidate removes no shading feature because all eight baseline submissions used the same shader, uniforms, and opaque output.

The next proposed investigation would use a more representative owned workload, fixed additional test conditions, and a supported frame debugger or relevant counters. Those actions were not performed here. In particular, no hardware counter distinguishes hidden-surface handling, fragment execution, or memory traffic in this packet; none should be filled in from an attractive explanation of the timing. Do not present a future profiling plan as a completed diagnosis merely because the current result is less dramatic than expected.

Matching translucent image proofs are inspected beside a stack of redundant sheets and a cautious measurement notebook.

Make the result independently inspectable

Give a reviewer two routes. The scene route starts with the actual PNG, source, fixed camera and resolution, context attributes, and raw capture. The comparison route starts with the optimization question, submitted-work counts, timed-region definition, validity checks, pixel gate, and retained conclusion.

The package’s analyze-captures.py recomputes medians from the saved integer results and asserts the expected sample counts, disjoint status, graphics-error status, shader hashes, and pixel equality. From the evidence directory, the offline review command is:

python3 analyze-captures.py

That command checks saved capture evidence; it does not acquire a new GPU measurement. A new run requires opening the owned page in a supporting browser and saving the actual new results. Different devices, drivers, power conditions, or browser versions can produce different timings. Existing numbers should never be relabeled as a new device’s benchmark.

Keep raw scene evidence separate from editorial illustrations and presentation graphics. A stylized diagram can explain the review route, but it cannot replace the actual framebuffer image or query results. Source and capture hashes identify the reviewed files; they do not establish that every future environment will reproduce the same performance.

Describe your contribution at the graphics-engineering boundary

A general game-programming portfolio may lead with a playable mechanic, code ownership, and build access. This sample instead leads with an authored rendering pipeline, a GPU-measured region, an output-preservation check, and a restrained optimization decision. It does not claim a complete engine, production game, driver implementation, or profiling work on a former employer’s system.

A supported description is: “Authored a fixed WebGL2 sphere-and-floor scene, captured valid GPU elapsed-query samples, and compared redundant opaque submissions with a one-draw version while verifying exact pixel equality.” Add that the median timing direction reversed in an independent rerun and did not establish consistent acceleration, a general bottleneck, or an eightfold speedup.

Use LandOffer’s current listings to identify relevant graphics responsibilities, then choose the original scene and measured region that explain your contribution. LandOffer does not profile the renderer or certify these performance results. Present the original output, raw timing scope, and actual conclusion together, including the limits that keep the performance claim defensible.

Download the worked example files

Download the curated educational companion. Read PUBLICATION-README.md after extraction for the public file layout, replay commands and requirements. The listed offline Python checks were rerun from the extracted archive in a disposable directory. The earlier local report and commands describe the original evidence environment; use the companion README for the portable layout. No whole evidence directory, credentials or compiler binaries are included.

Sources and Further Reading