2026-08-21

[markaren]

211 commits since 2026-08-09.
Tagging 2026-08-21 publishes 2026.08.21 to PyPI.

The short version: splats stopped being only a backdrop, particles became a first-class
GPU object, an external CUDA producer can write threepp's vertex buffers in place, and the
bit-exact-replay claim the sensor suite has been making is now measured rather than asserted.

Performance figures below are quoted from the commits that measured them, on the hardware those
commits name. They are reported, not re-benchmarked for this release.

---

⚠️ Breaking and behaviour changes

Read this section before upgrading — three of these break at compile time and two change what
existing scenes produce.

createRenderer is gone from the library

threepp::createRenderer and threepp/renderers/RendererFactory.hpp were removed (acd5657b).
Its no-preference overload printed a console menu and blocked on std::cin — a demo convenience,
not API. threepp/threepp.hpp no longer includes it, so this breaks every program that only
included the umbrella header, whether or not it named the factory. It survives only as
examples/libs/renderer_factory.hpp, which is not installed.

// before
auto renderer = createRenderer(canvas);

// after — pick one explicitly
std::unique_ptr<Renderer> renderer = useVulkan
    ? std::unique_ptr<Renderer>(std::make_unique<VulkanRenderer>(canvas))
    : std::unique_ptr<Renderer>(std::make_unique<GLRenderer>(canvas));

doc/getting_started.md was rewritten accordingly.

The editor document model left the installed include tree

37 public headers (all of threepp/extras/editor/*, plus detail/ConfigCodec.hpp) moved out of
include/ into the new static library threepp_editor_core (08d0b2a1). The include prefix is
unchanged — threepp/extras/editor/SceneDocument.hpp still names the same file — but the target
has no install rule, so an installed-package consumer cannot reach it by adding a header path;
they must consume the source tree and link threepp_editor_core.

Rationale: several of those headers change meaning under macros (PhysX, V-HACD) that the
installed library cannot own, so install(DIRECTORY include/) was shipping all 49 of them
compiled to their most-disabled variant.

The same seed no longer produces the same content

Eighteen private mt19937 and hand-rolled generators were replaced by one seedable
threepp::math::Rng (splitmix64, order-independent fork(stream), a (seed, slot, stream)
counter mode, Fisher-Yates shuffle) — c1e98ea1, e452b52d. Migrated: trees, terrain, textures,
grains, the ocean spectrum, the blue-noise tile, flocks, fire, splats, the perch bake.

The motive is that std::uniform_real_distribution and std::shuffle are free to differ between
standard libraries, so "same seed" never meant "same bytes" across platforms. It does now — but
any golden image, saved procedural scene or recorded dataset regenerated after upgrading will
differ from one generated before it. Sensors keep their own generators; those are unaffected.

The Vulkan mesh path now honours BufferGeometry::drawRange

Previously only the line/points overlay did, so a Vulkan mesh always drew, copied and traced its
full buffer capacity (43f6ed12). The indirect build now clamps each draw to the range (base LOD
level only) and carries the start through firstVertex — exactly GL's semantics.

This changes what existing scenes draw if they set a draw range and relied on Vulkan ignoring
it. For interop producers the old degenerate-tail contract is dead: unused capacity now costs
VRAM but no bandwidth.

Smaller behaviour changes

• LidarReturn grew a field — int32_t returnKind (with enum class LidarReturnKind { Surface, VolumeScatter }). Source-compatible for member access, but the struct's size and
  layout changed: relevant if you binary-log returns or brace-init without designators.
• Mesh gained two virtuals — raycastBoundingSphere() / raycastBoundingBox(). An ABI
  change to a widely derived class. Consequently SkinnedMesh picking now uses posed-skeleton
  bounds instead of bind-pose bounds (68287ffd), so raycast results against skinned meshes
  change — they were previously unpickable in any pose but the bind pose.
• EffectComposer intermediates default to half-float, not UnsignedByte (60610e28).
  2× memory on every composer target, and readbacks from those targets are now half-float. The
  commit measures the reason: on a 64-pixel dark ramp, 11 distinct output levels with byte
  targets against 47 with half-float.
• TerrainParams::aoStrength defaults to 0, was 0.5 (ca5970be) — terrain built from
  defaults now renders without baked AO.
• PbdParticles raises speculative CCD by default — grains were falling through a 0.4 m floor.
• A Vulkan canvas starts hidden and is shown after the first present; Canvas::showWindow()
  is new (82929327). Anyone driving a Vulkan canvas without going through render() sees
  different behaviour.
• THREEPP_WITH_VULKAN is now PUBLIC on the threepp target, and config.cmake.in gained
  find_dependency(Vulkan) (b2a5d0d7). Consumers that restated the macro can stop; consumers
  that didn't were silently compiling the OpenGL-only variant of twenty public headers, which
  violated the ODR when two targets in one binary disagreed.
• threepp_data is fetched by URL, not git clone (744a30aa). A mirror or offline cache
  keyed on the git clone will miss; FETCHCONTENT_SOURCE_DIR_THREEPP_DATA is unaffected.
• Examples removed — tps_shooter and NorwayDrive, and FPS/fps_ragdoll.hpp is gone with
  FPS reduced to a shooting range (2994c48a, aec9714b). The demos no longer need a Mixamo character.

---

Splats grow up

Gaussian splats were previously "a backdrop, not a simulation asset". That is now only half true,
and the README limits section has been rewritten to say exactly which half.

• splats::bakeSurface (903e36c3, 0240b40b, 8f2dca05) renders a cloud from a pose set,
  reads the median-depth AOV, fuses it into a block-sparse TSDF and marches out a triangle mesh.
  One bake, three consumers: PhysxWorld::addStaticTrimesh, a lidar target, a depth-sensor target
  — the physics side took no new code. A robot can stand on a scan.
  Measured at 5 cm voxels: a ball dropped on a baked plane rests 3.6 mm off; 9 of 9 lidar
  beams return it at 3.4 mm range error. Those figures mean nothing without the voxel size.
• Sensors can see a baked scan, behind two independent gates: splats::makeSensorMesh puts
  the mesh on VulkanRenderer::kSensorOnlyLayer (31), and the scene master
  setSensorOnlySurfaces(bool) is off by default — a scene that never opts in senses and
  renders exactly as it did before the feature existed.
• Splats appear in traced reflections (b09a81a8, c8f4b889) — strictly, a stand-in does.
  Each cloud bakes an rgba16f density/radiance volume (≤128³, ~13 MB) that the water, glass and
  glossy reflection legs march. Primary view only; THREEPP_VK_SPLATVOL_OFF=1 restores the old
  behaviour, THREEPP_VK_SPLATVOL_RES and THREEPP_VK_SPLATVOL_SIGMA tune it. Cost: +0.028 ms
  median on the deferred shade. Transmission legs — a splat seen through glass — deliberately
  do not march it yet.
  The tile rasterizer composites the cloud after the deferred shade, so no traced leg can see
  the real splats even in principle. This is why it is a baked stand-in.
• Splat depth AOV can carry median distance (1b5d509e) — SplatDepthMode{Off, Expected, Median}, which is what makes the surface bake tractable.
• A scan is authorable in the editor — the baked surface is visible while you author it
  (0e235b67), and a scanned floor is something you can stand on (8f2dca05).
• Splat wireframes occlude correctly on Vulkan (eb0fea99, 32825200); a secondary view
  rasterizes the cloud when it asks (952bbd1a); baking from inside a room works (ee1775c3).

Still true, and deliberately so: splats go into no acceleration structure, so they cast no
shadows and contribute nothing to GI, and neither SplatCloud nor ParticleField is serialized
into a scene document.

---

ParticleField — a new Vulkan scene object

A particle type whose count the CPU never walks (phases F0–F6, 4a050ca7 … 278c84f7).
Vulkan only; on OpenGL it degrades to an inert placeholder geometry rather than crashing,
the same way Ocean does.

Three ownership modes — HostRing (CPU submits into a ring of host-visible buffers),
Renderer (a compute pass writes positions from a closed-form emitter; nothing crosses the bus),
and Interop (a foreign device API owns them, e.g. GPU PhysX).

Three live representations — MeshRepr (instanced geometry in one draw), BillboardRepr
(lit, glowing, fogged, distance-LOD), and DensityRepr (marched per pixel, so it participates in
fog, receives light and is visible to lidar). TracedRepr is stored and consumed by nothing yet.

Reported numbers: 500k grains as one draw went from 8–9 fps to 41–43 fps (f1115c60; the
commit body doesn't name the machine, unlike the rest of the benchmarks here). At 300k particles
the Renderer mode's host cost is 0.0020 ms — the same as at 10k — with GPU cost 0.139 ms
(emit 0.0120 + density scatter 0.1268).

Also shipped: FireEffect, a campfire/flame preset over the density representation with
blackbody emission; emitter FOLLOW/WRAP modes for weather that surrounds the camera; snow
that rests and rain that splashes; and demos vulkan_fire, vulkan_snow, vulkan_fjord,
vulkan_lidar --dust, granular_conveyor.

Lidar sees the dust (5c39b8fa) — a medium is not geometry, and --dust gives you a paired
clean trace to measure the degradation against (LidarDegradation, C++ only; Python can read
return_kind but cannot arm the paired trace).

---

Zero-copy CUDA interop

An external GPU producer can write a mesh's vertex buffers in place. NVIDIA only by
construction, and the POSIX/_OPAQUE_FD branch is marked in-source as written but untested —
no CI job has both Vulkan and CUDA.

• C++ — VulkanRenderer::enableVertexInterop(mesh, deviceCopy, validate) returns a
  VertexInteropHandle; the renderer exports position and normal buffers as dedicated external
  memory, runs your copy once per frame inside render(), then copies into the buffers everything
  already reads and refits the BLAS. Every failure path is a null handle, never a throw.
  Also enableParticleFieldInterop, and PbdParticles::Group::registerVulkanMemory /
  copyPositionsToVulkan for the PhysX→Vulkan device-to-device path.
• Python — threepp.cuda_interop.VkInteropArray imports the allocation through the CUDA
  driver API via raw ctypes (no cuda-python dependency — "the whole surface is four driver entry
  points"), and guards the things that fail silently: primary-context binding, pointer-context
  match, range size. GLRenderer.gl_buffer_id() exposes the OpenGL equivalent — the C++ accessor
  already existed, the Python reach is what's new.
• Two NVIDIA Warp examples — warp_fluid.py (position-based fluids, wp.HashGrid, GPU
  marching-cubes surfacing, drawn as refracting water) and warp_nebula.py (18M additive points
  by default). Both degrade cleanly on an older threepp or without CUDA rather than exploding.
  warp_nebula went from 19 to 51 fps across 3affa475/cf60edcb.
• warp_fluid.py --obstacle <model> (6220a802) — collide the fluid against an arbitrary
  mesh instead of the built-in box, via a signed distance field baked once at startup. Takes
  anything ModelLoader reads (.stl, .obj, .gltf/.glb, .dae); a STEP/IGES solid has no
  triangles of its own, so tessellate it first. Multi-part assemblies arrive assembled, the mesh
  is auto-fitted (CAD is in millimetres as often as metres), and it sweeps like the box did.
  Measured at 337k particles on an RTX 4060 laptop: sim 29.7 ms against the box's 30.8 — an
  arbitrary mesh collides for the price of the block it replaced.
  The bake reports whether the mesh is closed, because an open shell yields an unsigned field
  that still repels at the surface: the fluid looks right while nothing can be pushed back out.

---

Determinism, measured

The sensor suite has claimed bit-exact replay for a while. This release audits that claim,
finds three real leaks, fixes them, and narrows what's left.

• VulkanRenderer::setSimTime(double) (734887e9) pins every frame-path wall-clock read —
  TAA blend dt, shade animation time, DLSS/FSR deltas, ocean foam decay, grass/displacement
  timestamps, the cloud clock — to an app-driven simulation clock. Unset, everything falls back
  to the wall clock, byte-unchanged.
• The probe-GI "benign race" was not benign (d94d96c9, 4044fc45) — probe_update was the
  last determinism leak. With it fixed, the whole pipeline replays bit-exactly: 5 fresh
  processes × 120 frames, 6/6 streams identical, beauty pass included.
• Lidar instance ids were the raw index, not the label (f8efa781, df55af8d). The audit's
  --idstability axis caught 1760 pillar beams flipping label 3→2 across scene churn,
  deterministically — the label API never reached the returns. Returns now translate through the
  stable-id table. This one silently corrupted any dataset that relied on setObjectInstanceId.
• The TLAS was rebuilding every frame all along (f8efa781) — found by the same audit.
• replay_audit (8ec401e3, d76c8653, 4997bd5e) is the tool that proves it, with
  bisection instruments (aov_audit, taasplit, dumprgb) that split the frame to localise a
  divergence.
• The one exception, stated in the header: a ParticleField fed by GPU PhysX through
  Ownership::Interop forfeits byte-reproducibility, because the bytes are authored on the other
  side of the import. Gate those by tolerance, never by compare.
• The particle-field determinism flake was the TAA clock, not the field (31d708a9).

---

Ray-traced acoustics (#420)

AcousticScene traces occlusion and transmission through scene geometry — entry and exit of a
solid counts as one wall — and probes the room with bounced rays for an Eyring RT60 and openness
estimate. Sources get a low-pass occlusion splice (20 kHz → 600 Hz) and a shared Freeverb bus.
Needs no PhysX: the examples' BVH was promoted into the core library as
threepp/utils/BVH.hpp with raycast/raycastAny.

Authorable per mesh in the editor via AcousticSurfaceConfig, and live in the player (it rides
AudioPlaySession). Example examples/audio/acoustics with a headless --selftest.

---

Hardware-in-the-loop flight

A real, unmodified ArduCopter flies a threepp PhysX quad in lock-step (19436aec) over
ArduPilot's JSON backend: one servo packet is exactly one PhysX substep, and threepp's timestamp
drives SITL's clock. Graduated from a demo into extras/uav (3700a913) —
SitlBridge, QuadSim, FrameConv, DroneVisual, MavlinkOut, ProximityScan,
DownwashEffect. Documented in doc/ardupilot_sitl.md, which the README now links.

• The proximity ring is a real lidar (2c5f040e, 08663c0c) feeding ArduPilot's own
  obstacle avoidance — BendyRuler flies the forest (6e469306), and the autopilot proves it
  brakes (34ea8e75). It survives a SITL reboot.
• Brownout (aa6c2dfb and five follow-ups) — conserved rotor-wash dust that swallows the
  landing, built on ParticleField. The rangefinder flies through it.
• Live flights can be recorded (3ae4e12d); the demo survives the Vulkan deferred renderer.

---

Editor

• Particle fields and granular grains are authorable (a9f61d69). Note the commit's own
  status: phases 1–3 are verified (selftest 741 GL / 753 Vulkan, PlayerCore_test,
  EditorParticleConfig_test); phase 4, the granular runtime, compiles and links but its
  suites have not been run.
• Prefabs (8b574779) — save any subtree as a document, add it back anywhere.
• Terrain is a re-editable mesh with a Sculpt tool (47487776, 9fc713fc, f4ef1c5a) —
  raise/lower/smooth/flatten brushes, and the sculpt layer is recovered as
  currentHeights - base(configBefore) so a parameter edit re-lands it on the new base.
  Triangles and splat albedo bake into the document, so a saved scene renders and collides with
  no editor present, and the collider cooks from the sculpted geometry (b78c6369).
• A rigged character you can walk around (76970c0c) — tick "Simulate as Character", press
  Play, WASD on a PhysX capsule controller. Clip roles are read from each clip's own root motion
  rather than its name, because names are useless as a key across Mixamo packs.
• Single-file .tpz scene archives (6dfeb43e, 07928f06, c4c7f7c3, 37bb30d9) — an
  uncompressed zip holding scene.json beside the assets its urls point at, textures kept as the
  bytes they arrived as, a linked .glb riding inside once however many subtrees point at it.
  Measured on a 539-node scene: 220.8 MB → 112.5 MB, load 5.9 s → 1.3 s.
• Viewport context menu with pick-reveals-hierarchy (3b95b8b6), the inspector's undo ceremony
  written once (5bf104a6), console lines wrap, hierarchy indent tightened, selftest cut into
  named sections that report a failing line (9d2ce4dd).
• Closing the window mid-Play leaked the PhysX foundation (f363008c).

---

Also new

• Python: BufferGeometry readback (2ba72d74) — get_attribute(name) returns an
  (N, item_size) float32 array, get_index() a flat uint32 array (or None for a triangle
  soup), and attribute_names() lists what a geometry carries. set_attribute has had no
  counterpart until now, which was fine while Python authored the vertices and a dead end the
  moment a loader did: a model read by ModelLoader was a BufferGeometry full of triangles
  with no way out, so anyone wanting them had to re-parse the file in Python, one format at a
  time. Returns copies — the backing storage is reallocated by set_attribute and freed by
  dispose, so a view would dangle. Typed in the stub as NDArray[float32] | None rather than
  Any, which matters now that py.typed ships.
• TrackballControls (e1450a7a) — full SO(3) rotation including roll, carrying camera.up
  with it, for objects with no meaningful up. Two deliberate departures from the three.js r129
  original: it guards the degenerate axis when the drag runs parallel to the eye vector, and it
  fixes orthographic pan (upstream scales by eye.length(), meaningless for an ortho frustum).
• Bird flocks (#421, d8e21a29) —
  threepp::Flock, boids with perching, CPU-baked and asset-free. Example flock_demo.
• PhysX PBD particles (54419033) — PbdParticles, ChuteEmitter, GranularVisual.
  The belt carries the grains with no particle-specific coupling at all (d80aa6b2), conveyors
  learned bends (d4662bd0), and granular_conveyor scales to 300k with a --field pf|im A/B
  and a --feed dtod device-to-device path.
• CameraSensor captures on Vulkan (89b7dbbf) — it used to return false on any backend
  without render targets; it now lazily attaches a persistent secondary view. Three consequences
  the header spells out: one frame of latency, the first capture or two return false while it
  warms up, and per-view visibility does not exist. New renderSplats member (default true) —
  on an RTX 4070, one 256×192 secondary view: 60k splats 2.40 → 5.05 ms/frame, 500k splats
  2.54 → 9.90.
• Canvas::Parameters::position(x, y) plus runtime setPosition()/position(), in
  outer-frame coordinates so a requested (0,0) doesn't tuck the title bar off-screen
  (f2997bdc). Exposed to Python. Wayland ignores the move; the protocol has no client-side
  positioning.
• A birch that hangs (d8166d7b) — pendant shoots, drooping cards, dark twigs; and canopies
  stopped being a hundred giant leaf balls (6cc103f9).

---

Performance

• Per-mesh work is paid per mesh, not per instance (9d4220a3) — the new EntrySpan. At
  115.6k static instances: frustum cull 12.00 → 0.004 ms, motion matrices 11.31 → 0.006,
  indirect build 3.83 → 0.026, ensureSceneBuilt 8.36 → 0.080. At 100k moving grains: emissive
  walk 220.93 → 0.008 ms, motion 54.5 → 11.3, cull 43.1 → 5.6.
  (This invalidates the 300k-grain table in 6ad7cb56 — that was the pre-EntrySpan
  measurement, taken in the same release.)
• Hidden-window present stall named (2f7cedb2) — a hidden-window vkQueuePresentKHR cost
  5.5–10.6 ms of host time per frame on Windows/NVIDIA, entirely outside cpuFrameMs so no
  counter had ever seen it. A headless canvas now pins one swapchain image per in-flight slot and
  never presents.
• A dirty material sends its own entries, not all 78,400 (2f22cd25).
• Per-frame dynamic geometry graduates to an in-frame refit path (inside d8e21a29) — after
  three consecutive dirty frames, a record moves to staging upload + GPU copy + BLAS refit
  recorded into the frame command buffer, replacing a device-wide drain plus two submit-and-wait
  one-shots every frame. This matters to anyone doing CPU vertex animation — trails, ribbons,
  procedural deformation — not just to birds.
• Denoiser: the wide à-trous passes skip converged pixels (af2be06a), using variance both
  channels already propagate. On an RTX 4070 ocean bench: 1.35 ms mean, against 2.15 at
  global-4 and 1.29 at hard-2 — i.e. nearly the cost of two passes with the quality of four.
  The default is 4 passes; THREEPP_DENOISE_ATROUS_PASSES (2..4) stays for A/B.
  (An earlier commit in this range moved the default to 2; this one moved it back. The shipped
  default is 4.)
• Ocean foam accumulator drops to 1 m/texel and skips frames (9a66d68d).
• The GPU can expand instances and agrees with the CPU bit for bit (128bdd80) — opt-in,
  not on by default (09aad227).
• Skinned animation juddered at a steady 60 fps (db95d256) — one bone-matrix buffer, two
  frames in flight.
• The GIL is released across PhysX steps, GPU frames and readbacks (0431a0f2) — 771 defs
  had zero call_guard before this. Contract change worth knowing: calls that used to be
  serialised by the GIL now genuinely overlap. Measured by stamping wall-clock inside the stall
  windows: 3.5M spinner iterations inside one 450 ms step.
• spot_slam holds 60 fps, from 28.9 (52669732) — the scan stops waiting for the frame it
  just drew (fire/deliver split, 31 ms → 2 ms), plus render_scale 0.5 with FSR.

---

Fixes

• GL: the shadow map was cleared to the renderer's clear colour, not white (70186d82) —
  directional, spot and point shadows put everything the light reached in shadow.
• GL: the composer's background was sRGB-encoded twice and its intermediates were 8-bit
  linear (60610e28) — bloom's 0x05050a arrived as (38, 38, 56).
• GL: the texture bind cache wrote to a copy — an auto that should have been auto&, so
  the cache had never hit since the port (f92dd252).
• Screenshots were sized by the window, not the framebuffer (9334df55) — at 1920×1200 this
  read 109,440 bytes past the end of the buffer and died with an access violation, 3 runs out of
  3. A mismatched readback is now an exception rather than a page fault.
• Terrain splat and morph flags never survived a round-trip (b68bdf65).
• A stale DISPLAY no longer kills a headless canvas (f2dccbfa) — a dead X server leaves
  DISPLAY=:1 behind and glfwInit died on it. Observed on Colab. Verified display-free
  end-to-end on WSL lavapipe.
• TAA disocclusion: 300k flakes trailed eight-to-fifteen ghosts each; and two descriptor-pool
  reset bugs silently stopped a field-only scene drawing after 64 frames.
• Add-after-remove crash fixed and pinned (69e322c1); 2× MSAA images clamp to a count the
  device actually has (fd287af1); ProximityScan and tileVariants now build on GCC 11.
• macOS says no properly (2493e48a) — a configure-time warning and a clean runtime failure
  at device selection, plus two portability bugs fixed on the way.

---

Packaging

• Linux wheels: windowed Vulkan was broken for every user since the first release, and is
  fixed (c3ca41f0). Two defects compounding: vcpkg's vulkan-loader port defaults its WSI
  features OFF (upstream defaults them ON), so vkCreateInstance answered
  VK_ERROR_EXTENSION_NOT_PRESENT for the very extensions GLFW had just asked for; and
  auditwheel's renaming meant GLFW's dlopen("libvulkan.so.1") missed the wheel's copy and loaded
  the system loader instead — two loaders in one process. Now asserted in CI.
• Windows wheels shipped unoptimized SPIR-V (bcd4ee6e) — the -Os gate tested
  CMAKE_BUILD_TYPE, which is empty on every multi-config generator, and scikit-build-core
  hard-codes the Visual Studio generator for Windows wheels. The published Windows and Linux
  wheels carried asymmetric shader binaries from the same source and version.
• cuda_interop.py and py.typed now reach the wheel (842f7453) — so the Vulkan zero-copy
  path arrives complete in its first release rather than half-shipped, and PEP 561 type checkers
  stop ignoring the stubs.
• CI runs the Vulkan backend (e12a91cc) — a linux-vulkan-lavapipe job on Mesa's software
  rasterizer under THREEPP_VULKAN_VALIDATION=1 + THREEPP_VULKAN_STRICT_VALIDATION=1, with a
  post-step that fails the job if any test skipped itself, so it cannot go green having rendered
  nothing. It gates spec-cleanliness, not pixels — the filter is
  ^(VulkanValidation|VulkanCameraModel)_test$, and it runs unlit because lit shading segfaults
  inside lavapipe's JIT. Golden images remain a local pre-push check.

---

Known gaps in this release

Stated rather than smoothed over:

• A flock plays in the editor and is inert in threepp_player — FlockPlaySession is not
  registered in PlayerCore.cpp, unlike the other ten. A document with a flock will not behave
  the same in CI as in the editor.
• Granular authoring's phase-4 suites have not been run (a9f61d69).
• Splat transmission legs don't march the volume — a splat seen through glass is missing from
  reflections-through-transmission; four more call sites, deliberately deferred.
• ParticleField::TracedRepr is stored and consumed by nothing.
• The CUDA interop's POSIX/_OPAQUE_FD path is untested — no CI job has both Vulkan and CUDA.

---

This discussion was created from the release 2026-08-21.