What's New

Scoped model draw parameters

GPUVectorModel.draw(renderPass, {parameters}) and inherited Model.draw() accept temporary viewport, scissor, blend constant, and stencil reference overrides. Values are restored after all internal batch draws, including on errors. See Model and RenderPass.

Cancellable Arrow batch conversion

Arrow streaming conversion accepts an AbortSignal, validates consistent GPU formats across batches, and releases unyielded results on cancellation or validation failure. Yielded batches remain caller-owned. See Arrow conversion.

Dual-language shader injection targets

Shader injection target descriptors define one stage and name with separate GLSL and WGSL parameter syntax, return types, and header/footer source. Register the same descriptor with both assemblers; each selects its language implementation. Vertex and fragment injection targets may also share a name in WGSL: assembly resolves stage-specific functions and shared helpers. See ShaderAssembler.

Reusable graph texture bindings

GPUGraph and WebGPU SimpleGraph accept named texture inputs and operation-produced texture copy results, including selected mip/layer views and borrowed output targets. GPUGraph custom lowerings can also produce textures with execution-sized or scaled extents. See texture values and execution bindings. Evaluator APIs remain unchanged.

Retained scenegraph physics rendering

SceneRenderer accepts SceneMeshNode trees and generic engine GPU transform sources. PhysicsController publishes through that contract, with automatic borrowed-buffer refresh after reset/rebuild. Shared spot-shadow, depth and picking passes follow the evaluated poses. Newton's Cradle and Wrecking Ball use retained PBR geometry instead of example-owned pose shaders. Start with the expanded physics walkthrough.

Path-based scenegraph physics

PhysicsController attaches bodies and shared joint declarations using node references, IDs or paths. It infers CPU collision geometry, prepares GPU sessions and submits bounded fixed-step updates without pose readback. See the controller API.

Graph transfers and GPU-sized selection

Reusable GPUGraph and GPUSimpleGraph share upload and copy operations. WebGPU graphs also expose stable compaction with input-sized capacity and a separate GPU logical count, without implicit readback or allocation based on CPU-visible counts. Evaluator APIs remain unchanged.

Scenegraph node paths

GroupNode.findNode() and findNodes() resolve node references by exact ID, anchored hierarchy path or a partial path. Lookup includes hidden nodes and reports ambiguous single-node references. See Finding nodes by ID or path.

Graph intermediate storage reuse

Straight-line WebGPU graphs now route unselected operation-defined vector results through the command-graph transient planner. Non-overlapping results can share storage without changing chunk boundaries, output ownership, or evaluator behavior. Start with the new graph tutorial and storage rules.

Prepared graph execution

CompiledGPUGraph.prepare() binds one invocation and exposes its outputs before encoding. Append graph commands with execution.encode(encoder) alongside other compute or rendering, then submit once and release scratch with execution.destroy(). run() uses the same path. See Caller-owned encoding.

Consolidated inferred vector layouts

GPUVectorModel consolidates inferred constant attributes and compatible views of existing interleaved buffers. Arrow and other column adapters can omit hand-built layouts for these inputs. Explicit layouts and source buffer ownership are preserved. See vector model inputs.

Operation-defined graph results

GPUGraph.addInput() and addState() describe the external interface, while operation contracts define internal results. Expressions infer output types without manual intermediate declarations. Reusable runs accept grouped inputs, borrowed state, and selected output targets. SimpleGraph shares input declarations and inferred expression results; evaluator APIs are unchanged. See Graph inputs, results, and state.

Graph operation contracts

Logical Operations can declare reads, writes, output shapes, and required device features. Reusable graph planning discovers custom outputs through these contracts; extension lowerings augment the built-ins. See GPUOperation contracts.

Reusable graph expressions

Graph expressions now also support packed rows of widths 1–4: component-wise float32 arithmetic and math, scalar-component broadcasting, and width-preserving numeric casts. Row count remains execution-sized, and float32x3 stays packed at 12 bytes per row. Static .xyzw component access and swizzles compose with vec2/vec3/vec4 row constructors, including scalar replication and exact integer row construction.

GPUExpressionOperation accepts math.gl expression strings or parsed ASTs. GPUGraph and GPUSimpleGraph share scalar/vector declarations and execution-time input bindings for the float32 arithmetic and math-function subset, with explicit float32, sint32, and uint32 casts. Float-to-integer casts offer per-operation integerRounding: truncation by default, or nearest with ties away from zero. Vector dimensions can change between executions; existing evaluator APIs remain unchanged. See the expression reference.

GPU expressions now support row-local dot, length, equalAll, and select(condition, whenTrue, whenFalse) on WebGL SimpleGraph and both WebGPU graph paths. See the expression syntax reference.

Shader plugin primary modules

ShaderPlugin now contributes one optional module, with supporting modules expressed through its dependencies. Material, filter, and clip plugins use this simpler shape; injection-only plugins remain supported. See the plugin reference and migration guide.

Streamlined shader plugins

ShaderPlugin declares one portable interface. Each injection carries its own glsl and wgsl source alongside a shared target and order, removing nested plugin variants. See the plugin reference and migration guide.

Standalone shader tools

Shaders no longer depends on core. Resource-free layouts, type decoders, uniform block layouts and sampler options live in @luma.gl/shaders/types; WGSL scanners live in @luma.gl/shaders/wgsl. Core retains its existing exports through these implementations. Area-light LTC texture allocation lives in engine. Assemblers use explicit instance ownership.

Shader package

Shader composition and modules are now published as @luma.gl/shaders. Update imports to the new package name; the standalone shadertools package is removed. See the shader API reference and upgrade guide.

Explicit shader assembler ownership

Models and computations own their default GLSL/WGSL assembler state. Applications can share hooks, modules, and transpilers by passing a configured assembler explicitly. Gpgpu and graph execution no longer consult the legacy global defaults. See the assembler reference and upgrade guide.

Effects engine subpath

Reusable post-processing and screen-space effects are available from the optional @luma.gl/engine/effects entry. The standalone effects package is removed; engine root imports do not load effects. Shader-pass definitions and execution behavior are unchanged, and graph remains independent of engine. See the effects reference.

Text engine subpaths

Text rendering, font atlas builders, and 3D text geometry now live in the optional flat @luma.gl/engine/text, @luma.gl/engine/text-fonts, @luma.gl/engine/text-3d, and @luma.gl/engine/text-experimental subpaths. The standalone text package is removed. See the text API reference.

glTF engine subpaths

Import the glTF runtime from @luma.gl/engine/gltf and physics integration from the flat @luma.gl/engine/gltf-physics entry. The standalone glTF package is removed; engine root imports do not load these optional subpaths. See the upgrade guide.

Gaussian splats in engine

Gaussian splat data, rendering, picking, residency, and hierarchy helpers now live in @luma.gl/engine/splats. The standalone splats package is removed. This first migration preserves existing execution behavior; reusable graph operation extraction is a separate step.

Experimental API ownership and graph-based fluids

The standalone @luma.gl/experimental package is removed. Scene renderers and their PBR, shadow, transparency, and composition helpers now belong to @luma.gl/anari. Independent utilities are exposed through @luma.gl/engine/experimental/{controls,materials,textures,webxr}. Graph owns path/polygon models under /experimental/models and flow/fluid simulations under /experimental/simulation.

MLSMPMFluidSimulation now records its four ordered stages through a compiled GPU command graph per substep. Particle-buffer ping-pong, CFL splitting, and the WGSL kernels are preserved; the compiled graph and latest encodings expose execution for inspection.

Adaptive advection graph inspection

RK45 now executes a compiled counter-reset and integration graph. Each bounded advance or continuation returns its submitted encoding for resource inspection and CPU/GPU tracing, with stable timestamp snapshots across dispatches. Vector Observatory exposes the adaptive graph in its Graph and Trace tabs and reports dispatch numbers, continuation state and target horizons in Diagnostics.

Active-work GPU physics ensembles

GPUPhysicsEnsemble now retains awake-instance state, prepares per-instance contact lists, clears touched spatial buckets, and journals changed body/contact/allocator state for shared rollback. readWorkStatistics() exposes active work and snapshot payload sizes without adding readback to simulation encoding. Physics Batch Lab adds sleeping and wake-storm workloads and a separate CPU/GPU stage profile. See ensemble scheduling and limits.

Adaptive scientific particle tracing

ScientificFlowTracer adds GPU RKF45 integration with physical-unit local error tolerances, bounded continuation, explicit seeds and persistent termination states. Vector Observatory adds tolerance controls, step-size/status coloring and GPU timing when supported. Analytic trajectory tests and an opt-in accuracy/cost benchmark qualify the implementation. See the tracer API for numerical limits and continuation semantics.

Time-dependent scientific advection

ScientificFlowGraph now accepts timestamped field pairs, samples each Runge–Kutta stage in space and time, and rotates snapshots without resetting particles. advance() uses bounded GPU substeps and exposes simulation time. Vector Observatory adds an evolving double gyre and a wall-time-driven simulation clock. Analytic trajectory and convergence tests qualify the new temporal path.

Scientific vector-field advection

ScientificFlowGraph now compiles WebGPU particle advection into a GPU command graph, with RK2/RK4 integration, missing-data-aware bilinear sampling and GPU-resident ping-pong state buffers. The Vector Observatory example explores three analytic fields with up to a million particles, speed coloring and HDR trail persistence. The input contract accepts normalized regular scientific grids without adding a loaders.gl runtime dependency.

Authored GPU physics qualification

The pinned physics qualification profile now covers joint attachment frames, filtered ray segments, analytic impulse response, seven trigger shape kinds and authored trigger-event delivery. A 10,000-object hardware broad-phase baseline records correctness and performance separately from full-step simulation.

Analytic collider dimensions can change between GPU steps through shared scenegraph property bindings, including glTF implicit-shape pointers. The glTF Physics gallery adds an animated collider-scale scene. Scene instances support transactional live capture/restore and tracked asynchronous queries while preserving authored Reset behavior. Mesh deformation and full-profile qualification remain separate work.

ShaderPlugin portability

ShaderPlugins accept concretely typed ShaderModules and numeric preprocessor defines. WGSL plugin varyings now support fragment entry points with individual parameters or no parameters, as well as named input structs. Existing direct input locations are reserved when allocating plugin varyings. GLSL plugin inputs and varyings are declared before module helpers, allowing helpers to access them directly.

SimpleGraph value authoring

@luma.gl/graph/gpu-simple-graph now offers GPUSimpleGraphValue, simpleGraphOperations, and addValue() for expression authoring without constructing evaluators. Compilation owns the existing GPGPU execution machinery and its resources; legacy evaluator adapters remain supported. The SimpleGraph example uses the new path.

SimpleGraph uploads, copies, and scoped execution

SimpleGraph now supports declarative uploads and copies, borrowed per-chunk output targets, and WebGPU run({scope}) with explicit submission and cancellation. Dependency inspection reuses the evaluator snapshots. Existing GPGPU operations and ordinary execution are unchanged.

SimpleGraph and evaluator inspection

@luma.gl/graph/gpu-simple-graph provides an evaluator-backed subset of graph operation composition, with a dedicated SimpleGraph example. GPGPU data and vector evaluators now expose read-only getInspection() snapshots. WebGPU evaluation scopes also accept chunk-preserving vector evaluators, with one explicit submission and cancellation rollback. Ordinary evaluator execution remains unchanged; the evaluator implementation remains separate from the full graph compiler.

This page contains news for recent luma.gl releases. For older releases (through v8.5) refer to the Legacy What's New page.

Version 10.0

Target Release Date: Q3, 2026

General

• Graph resource inspection - The graph inspector adds a Graph Resources tab with selectable buffer/texture views, a persistent content viewer, and on-demand hover previews. See resource inspection.

• Program texture resources - GPUGraph now describes texture storage and subresource views, with caller-owned imports and graph-owned transients. See buffer and texture management.

• Shared math and loader APIs - Dependencies use math.gl 5.0.0-beta.4 grouped packages and loaders.gl 5.0.0-beta.4 grouped packages. Arrow adapters expose iterateGeoArrowBatchesFromArrowVector and getGeoArrowRowViewFromArrowVector for native GeoArrow chunks and rows without copying coordinate buffers. Views borrow source storage; keep it alive and do not mutate or detach it while in use.

• Engine scene controllers - Skinning, material variants, billboards, area lights, spatial audio, and interactivity use reusable engine APIs; glTF parsers map source data into those APIs. See scene controllers.

• Draft glTF area lights - Opt-in animated rectangle/disk light extraction and numerical PBR surface lighting, with a source-loaded Living Room preset in the shared glTF viewer.

• Draft glTF lightmaps - Linear irradiance bindings, node atlas overrides and portable instance atlas draws, demonstrated by the source-hosted Cornell Box through the shared glTF viewer.

• Draft glTF billboards - BillboardController provides opt-in full-axis camera-facing transforms, depth-relative scale and ordered overlay draw metadata without changing authored transforms.

• glTF spatial audio - Opt-in AudioController plays draft KHR_audio_emitter assets through Web Audio, with camera-relative positional sound and a Boom Box example.

• WGSL fp64 projection math - The fp64 shader module now provides double-single transcendental functions and returned-array vector/matrix helpers for geographic projection on WebGPU. See the supported functions and precision limits.

• Shared glyph loading - @luma.gl/engine/text-fonts decodes glyph PBF ranges, deduplicates and caches font-stack requests, and builds renderer-independent SDF atlases from server glyph metrics.

• Published entry point - @luma.gl/engine/text is included in engine npm releases, including its CPU font atlas builders under @luma.gl/engine/text-fonts.

• Opaque reflective ray transport - Opt-in bounded GGX metallic/roughness secondary paths add colored and glossy reflections. Chart Materials demonstrates a retained roughness sweep with transport and bounce controls. The default diffuse mode is unchanged.

• Ray-tracing diagnostics - Implementation capability reports, primary-hit debug views, and reference-image error metrics make ray-traced scene captures easier to inspect and compare.

• Ray-tracing quality controls - Opt-in guided spatial denoising, configurable history sample limits, and logical owned GPU allocation statistics are available in the renderer and scene playground.

• GPU-native columnar parsing and indexing - Composable Parquet parsing, chunk-preserving nested column layouts, and H3 and A5 cell projection add new optional @luma.gl/graph/gpu-simple-graph workflows.

• Table-driven planning - Experimental dataframes can plan queries from loaders.gl SQL expressions and feed batch-preserving GPU evaluation and rendering.

• Projection engine alignment - GPU Project can explicitly prepare math.gl engine factories, retain their CPU transforms, and honor spatial-reference axes and units. Public normalization expands adaptive conic coverage; CPU/GPU benchmarks include reusable, flat and bulk CPU APIs.

• Projection domains and routing - GPU Project adds explicit disconnected-domain and conservative disk partitions, seam-preserving segment clipping, opt-in indexed patch routing, fixed-arithmetic routing benchmarks and measurement-gated inline/materialized selection.

Experimental Three.js integration

• Shared depth in Three apps - @luma.gl/three/interleaved adds native deck layers to an existing Three WebGL2 canvas and depth buffer. Opaque geometry correctly occludes across both libraries while Three retains its renderer, controls and frame loop. The example compares shared depth with a separate transparent overlay.

• Deck overlays for Three apps - Add native deck layers to an existing Three renderer through @luma.gl/three/overlay. Three retains its camera, controls and frame loop; the separate transparent canvas follows perspective/orthographic cameras and pixel ratio.

• Shared prepared scenes - Multiple ThreeSceneLayer instances can share one adapter while retaining independent picking and highlighting. Readiness tracking does not retain borrowed scenes; failed preparation requires disposing and recreating the adapter.

• Scene placement in deck.gl - ThreeSceneLayer.modelMatrix supports affine placement in Cartesian coordinates and local Mercator meters without changing source transforms. Visible rendering, highlights, object IDs and surface depth picking share that placement.

New Modules

• Optional Arrow adapters - @luma.gl/graph/arrow, @luma.gl/graph/arrow, and @luma.gl/engine/arrow provide conversions and rendering adapters from the published packages. Apache Arrow remains an optional peer; generic roots remain Arrow-free.

@luma.gl/core

• Targeted WebGPU limits - DeviceProps.requiredLimits requests specific WebGPU device limits, such as maxStorageBuffersPerShaderStage, without taking every adapter limit and feature through featureLevel: 'max'. A development GPU then enforces the limits the application targets.
• Vertex buffer byte offsets - VertexArray.setBuffer() accepts an optional byteOffset, so vertex data can start inside a shared buffer without changing the buffer layout or render pipeline.

@luma.gl/graph/gpu-simple-graph

• Additive GPU point-cloud octrees - GPUPointCloudOctree builds sparse tile metadata and source-ID ranges without reordering positions. The new point-cloud octree example shows tile bounds, additive detail levels and command-graph diagnostics.

• Experimental GPU sphere physics - @luma.gl/graph/gpu-physics adds grid-based bounded contacts, inverse-mass Jacobi solving, solid-sphere angular dynamics, friction, sleeping and live finite-plane/gravity settings. The standalone sphere-world sandbox renders quaternion-driven cue-ball bands and benchmarks up to 10,000 GPU-resident bodies with explicit capacity diagnostics.

• Oriented GPU rigid bodies - A bounded sphere/box world adds rotated inertia, clipped contact manifolds, friction and island sleeping, with stack and large-count sphere examples.

• glTF physics draft import - Optional @luma.gl/engine/gltf-physics parses a pinned rigid-body/implicit-shape subset with capability reports, compound sphere/box ownership, authored mass/inertia, kinematic targets, collision filters and material policies. GPU scene synchronization and behavior bindings remain separate follow-ups.

• Persistent physics contacts and calibration - Opt-in cached sphere/surface impulses, accumulated friction constraints, discarded simulation-time reporting and provenance-aware SI calibration fitting add reproducible numerical evidence.

• Bounded continuous sphere physics - Optional small-world sphere/rectangle sweeps, persistent contact and pocket-trigger events, explicit impact/candidate budgets, static box surfaces and analytic material fixtures extend the physics module. Pool uses GPU pocket capture and event-driven clacks/trails, adds beveled jaws, hold-to-charge shooting with Escape cancellation, and automatic re-racking.

• Space Salvage and rigid-body collision APIs - A top-down WebGPU salvage game exercises an opt-in GPU contact-event ring, exact sphere/box raycasts and sphere-overlap queries. Events retain begin/end and thresholded impact samples across steps with explicit loss reporting; asynchronous queries expose selection, nearest hits and overlap truncation.

• GPU pool prototype - Sphere physics now supports linear/angular impulses, body teleport/wake/enable controls, multiple finite surfaces with individual materials, and explicit interaction snapshots. The standalone pool example adds aiming, power, cushions, six pockets, scratch recovery, and shot completion. Spin practice adds follow/draw setups, separate sliding/rolling/spinning resistance, and raised cushion contacts with speed-dependent restitution.

• Incremental GPU execution - GPUIncrementalExecution caches explicitly versioned batch partials, preserves borrowed source storage, and submits only changed batch work plus the live merge. The GPU Data Analysis example shows streaming sums, histograms, grouped counts, and unsigned Top-K with reuse instrumentation.

• Batch-preserving GPU rendering - GPUVectorModel renders chunked vectors without concatenating their source batches.

• Fixed-size-list GPU columns - First-class fixed-size-list<float32,768> formats describe arbitrary fixed-width storage rows without inventing unsupported vertex formats; vectors retain logical table-row counts, flattened element counts, preserved batches, and caller-owned storage.

• GPU vector similarity and clustering - The optional @luma.gl/graph/gpu-vector-search backend searches ordinary fixed-size-list GPU table columns with exact squared-Euclidean, cosine, and inner-product rankings; GPU-resident linked-selection masks; deterministic bounded top-K output; GPU k-means; and explicitly approximate IVF-flat search. Existing @luma.gl/graph/arrow table adapters upload Arrow embedding columns, while source IDs, validity, batch boundaries, ownership, and rendering remain caller-controlled.

• GPU command graphs - Experimental WebGPU command graphs compile explicit buffer hazards, fixed capacities, node resources, and transient-buffer reuse while leaving encoding and submission under application control.

• Parallel command-graph preparation - await GPUCommandGraph.compileAsync() starts independent compute and render pipeline compilations together, resolves only when graph-owned pipelines are ready, and leaves command submission and warm-up execution to the application.

• Reusable GPU Parquet streams - Fixed-capacity page-batch streams reuse exact-layout compiled decode graphs and pooled upload/output storage, with explicit FIFO backpressure and application-owned submission completion.

• Batched compressed Parquet pages - Compatible Snappy and LZ4_RAW BYTE_STREAM_SPLIT pages share one runtime-described LZ dispatch and one byte-restoration dispatch, replacing per-page pipelines and commands while retaining sequential decompression locality.

• Reusable command-graph inspection - GPUCommandGraphInspector collects bounded whole-graph and per-node CPU/GPU timing summaries, compile-time allocation statistics, and device capabilities for application-owned diagnostic UIs.

• Flat GPU scene records - GPUScene owns or borrows a fixed-capacity, table-independent draw database with stable IDs, bounds, transforms, grouping, geometry references, command slots, and typed command-graph views. Validated mutation transactions add bounded insert, patch, removal, stable compaction, overflow, move reporting, and exact queue-write costs without introducing a CPU scene hierarchy.

• Explicit GPU scene adapters - makeGPUSceneFromCPUScene() maps application-owned hierarchies into ordinary mutable scene records through stable preorder callbacks, while makeGPUScenePartitionsFromGPUTable() borrows canonical interleaved records from every preserved table batch without readback, concatenation, or hidden packing. Empty batches retain partition identity, and per-buffer ownership keeps table records borrowed while adapter state is released normally.

• GPU scene draw generation - GPUSceneDrawGeneration deterministically maps active, visible scene rows into explicit fixed-capacity indirect-command slots. Static geometry arguments remain renderer-owned, while GPU-resident required and published counts plus overflow expose out-of-range requests and collisions without CPU draw selection or hidden allocation.

• GPU scene resource groups - GPUSceneResourceGroups classifies generated indirect commands into stable renderer-owned pipeline/resource windows, preserves empty group slots and explicit binding order, and exposes per-group counts plus geometry, slot, and unknown-group overflow without claiming bindless WebGPU behavior.

• Reusable command-graph contributors - GPUCommandGraphContributor gives small algorithm libraries a structural addToGraph() contract, while public aligned-view binding and typed transient-view helpers let those libraries extend command graphs without a runtime registry or hidden submission.

• GPU scan, compaction, and indirect drawing - Typed graph views compose hierarchical uint32 scan, stable ID compaction, and GPU-written DrawCommandBuffer instance counts. Scan and compaction accept fixed-width GPUVector imports as one logical sequence while preserving chunk topology. The GPU Trace Viewer demonstrates the path over up to four million spans, while GPU Frustum Culling applies it to indexed indirect rendering of a 3D instance field.

• GPU virtual-geometry selection - GPUVirtualGeometrySelection traverses breadth-level cluster forests with conservative sphere-frustum tests and pixel-scale geometric error, then reuses stable visibility compaction to publish a deterministic cluster frontier and capacity-safe indirect instance count without CPU readback.

• Virtual Geometry Canyon - The WebGPU showcase drives a 4×4, six-refinement terrain forest through GPU-only LOD selection and one indexed indirect draw. A shared grid, exact parent-triangle geomorphing, and skirts visualize more than 41 million potential leaf triangles without a per-frame traversal or readback on the CPU.

• GPU trace manipulation primitives - GPUMask composes chunk-preserving selection predicates; GPUHierarchyLayout computes scan-based process and thread expansion; GPUGraphTraversal expands bounded, cycle-safe CSR dependency frontiers; and GPUAncestorProjection reconnects hidden spans to their nearest visible canonical parent. The GPU Hierarchical Trace Viewer applies all four to live hierarchy controls, topology filters, dependency focusing, GPU picking, projected indirect edges, and collapsed-process activity.

• Graph-native GPU sort - GPUSort stably orders one paired packed uint32 domain, while GPUBatchSort independently orders aligned GPU vector chunks without hidden packing or lost batch boundaries. Bitonic or binary LSD radix selection occurs per work unit. The GPU Sort example contrasts packed global order with preserved input batches and exposes graph compilation and transient reuse.

• Reusable 2D GPU FFT - GPUFFT2D records bounded power-of-two complex transforms into caller-owned WebGPU command encoders. Forward and normalized inverse passes share one explicit scratch field without hidden submission or readback, providing a reusable spectral-simulation and signal-processing foundation.

• Reusable GPU signal processing - GPUFFT1D, GPUFFT2D, GPUTranspose, and GPUConvolution compose one- and two-dimensional transforms, batched workloads, and graph-native convolution through caller-owned WebGPU command encoders.

• Graph-native GPU data analysis - GPUReduction, GPUHistogram, GPUGridBinning, GPUGridAggregation, and GPUGroupAggregation add deterministic scalar aggregates, equal-width or irregular-edge histogram counts, filtered categorical counts and floating-point statistics, row-major spatial counts, and weighted floating-point sum/min/max/mean cell statistics. GPU-resident histogram edges and group-selection masks can change between encodings without CPU readback or graph recompilation. Analysis operations initialize once and accumulate fixed-width vector chunks without packing. The GPU Data Analysis example composes the operations without hidden submission or readback.

• GPU graph analytics - The optional @luma.gl/graph/gpu-graph-algorithms subpath provides GPU-resident topology construction, degree, breadth-first search, shortest paths, connected components, PageRank, community metrics, and force-directed layouts.

• Bounded GPU hash lookup - GPUHashIndex builds fixed-capacity sparse uint32 key/value tables with deterministic duplicate values, bounded linear probing, explicit overflow, and collision-work statistics. GPUHashIndexQuery resolves changing key batches without hidden submission, resizing, or readback.

• Stable sparse GPU joins - GPUHashJoin composes exact hash lookup, scan, and bounded pair publication into stable many-to-one inner joins. Aligned left-join masks, required counts, overflow, and probe statistics remain GPU-resident and explicit.

• Batch-preserving sparse GPU joins - GPUBatchHashJoin independently joins ordered GraphVectorView chunks against one shared right index. Per-batch capacities, required counts, source-or-output overflow, and probe statistics preserve streaming source partitions without implicit packing.

@luma.gl/engine

• Attribute byte offsets - Model.setAttributes(buffers, {byteOffsets}) binds each named buffer at the byte offset where its vertex data starts.
• Awaitable pipeline creation - Computation.createAsync() and Model.createAsync() expose native asynchronous WebGPU pipeline creation for application loading phases, backed by cache-aware asynchronous Device and PipelineFactory methods.
• Pinch-roll orbit controls - Two-pointer gestures can roll the camera while preserving the existing pan, orbit, and zoom interactions.

@luma.gl/engine/gltf

• Larger and richer animated meshes - Skinning supports larger joint palettes and up to eight influences per vertex, while ordinary morph-weight animation uploads position, normal, and tangent deformation to the GPU.
• Meshopt decoding - glTF loading adopts the loaders.gl v5 KHR_meshopt_compression decoder.

@luma.gl/shaders

• Language-specific shader assembly - @luma.gl/shaders/glsl and @luma.gl/shaders/wgsl expose concrete assemblers and assembly helpers, sharing the abstract ShaderAssembler contract. The root exports remain available; explicit language entries avoid loading the other assembly backend.

• Atmospheric scattering - The shared GLSL/WGSL atmosphere module provides a Rayleigh/Mie sky and metre-space aerial perspective. AtmosphereLayer connects the same shader to deck.gl perspective views in Riverfront soft shadows.

• Cloud sunlight extinction - clouds_getTransmittance samples the existing animated cloud density to attenuate direct sunlight on buildings and ground, without separate cloud shadow resources.

• Surface weather - The portable surfaceWeather material helpers and frame-rate-independent integrateSurfaceWeather function provide wetness, puddle highlights and slope-aware snow cover in Riverfront weather.

• Hybrid fp64 arithmetic - Double-single WGSL arithmetic can select direct floating-point or integer-controlled operations to balance portability and throughput.

• CompositeShaderPass - The structured multi-pass postprocessing API and effect factories use composite-pass naming in place of ShaderPassPipeline.

Optional Arrow conversion subpaths

• High-dimensional Arrow storage columns - Existing Arrow table/vector adapters map wide FixedSizeList values directly into row-aligned fixed-size-list GPU columns, with optional named validity siblings and preserved parent/child nulls, record batches, and source identity.
• Arrow polygon and GeoArrow rendering - ArrowPolygonRenderer converts nested Arrow polygon columns for attribute- or storage-backed rendering, and the GeoArrow example routes mixed DenseUnion geometry through Arrow point, line, and polygon renderers.
• Restored deck.gl integrations - Private Arrow path, polygon, and text layers demonstrate downstream rendering, while the GPU-Culled deck Trace shares one GPU selection result between blocks, Arrow labels, and picking.
• Arrow shader layouts - getArrowBufferLayout() maps Arrow scalar and FixedSizeList columns to shader attribute formats from a shader-first layout, including direct arrow.Vector sources and Arrow table path mappings.
• Arrow GPU adapters - Arrow factories, append helpers, and readback helpers bridge Apache Arrow inputs into @luma.gl/graph/gpu-data and @luma.gl/graph/gpu-tables objects and preserve chunked UTF-8 GPU vector input for text workflows.
• Variable-length Arrow attribute lists - GPUVector can retain chunked nested list columns whose elements contain one to four numeric components, covering scalar streams plus tuple-style data such as XY, XYZ, and XYZM coordinates for path-rendering workflows.
• Closed Arrow path normalization - closeArrowPaths() appends explicit closing vertices only for closed Float32 absolute or origin-relative delta path rows whose endpoints differ beyond an epsilon, using WebGPU compute when available with equivalent CPU fallback semantics.
• ArrowPathRenderer attribute mode - The Arrow path facade converts prepared Float32 XY, XYZ, and XYZM paths into packed per-segment inputs for PathAttributeModel, and supports Float64 source paths through CPU-prepared Float32 deltas plus CPU-updated view origins.
• ArrowPathRenderer storage modes - WebGPU storage conversion expands nested prepared Float32 XY, XYZ, and XYZM rows into compact indexed segment records, keeps per-path color, width, and optional view-origin rows as storage bindings, can convert Float64 source paths into Float32 deltas with one fp64arithmetic compute pass, and feeds PathStorageModel or PathTripsStorageModel.
• Mesh Arrow geometry - ArrowTableGeometry and makeGPUGeometryFromArrow() support loaders.gl-compatible Mesh Arrow tables, including default interleaved vertex buffers and optional index buffers.
• Arrow table adapters - Arrow table/vector upload, append, and readback utilities layer over reusable primitives from @luma.gl/graph/gpu-data and tables from @luma.gl/graph/gpu-tables.
• Supported Arrow Types and GPU Table Lifecycle - Matrix Arrow vectors, storage-selected table bindings, Arrow adapters, and the generic tables execution layer.
• Apache Arrow GPU examples - Examples cover points, nested lines and temporal paths, text and dictionary text, dates and durations, matrices, particles, and global grid identifiers.
• Points Example - A ScatterplotLayer-style renderer consumes Arrow point vectors or DenseUnion point rows, supports M-coordinate or timestamp animation, and reports hover identity as full-table row index, batch, and batch-local row.
• Time Columns Example - This showcase prepares aligned scalar DateDay, TimeMillisecond, TimestampMillisecond, and DurationMillisecond rows into relative Float32 GPU vectors, then renders the same schedule through instanced attributes or WebGPU storage bindings.
• Blinking Stars Example - This showcase prepares aligned scalar TimestampMillisecond and DurationMillisecond rows into relative Float32 GPU vectors, then uses them as per-instance visibility windows and pulse periods through instanced attributes or WebGPU storage bindings.
• Lines Example - This showcase expands nested Arrow XYZM line rows and DenseUnion LineString rows into styled GPU segment instances with attribute-backed and storage-backed models, and uses PathTripsStorageModel with aligned List<Timestamp> rows for storage-backed trail filtering.

Arrow-backed text integration

• Incremental text streaming - Arrow chunks produce independent GPUTextData objects that append to a stable TextRenderer model without rebuilding earlier batches; GPUTextResources lets batches and renderers share one uploaded atlas texture.
• Arrow text conversion helpers - @luma.gl/engine/arrow exports makeGPUTextDataFromArrow() for automatic strategy selection, plus ArrowTextRenderer, source mapping, and low-level conversion helpers for specialized workflows.
• View-aware Arrow text clipping - Arrow 2D text accepts optional FixedSizeList<Float32>[4] clip rectangles. ArrowTextLayer interprets them as world-space anchor offsets, projects them through the active deck viewport, and supports visible-region alignment and pixel cutoffs; omitting clipRects retains a constant no-clipping fallback instead of allocating per-row data.
• GPU-selected text - GPUTextSelection filters row-indexed compact glyph records from GPU row flags, preserves original row identity, and writes the selected glyph count directly into an indirect draw command.

@luma.gl/engine/splats

• Stable RAD camera retargeting - SplatRADHierarchyManager preserves resolved visible rows while reprioritizing retained branches for a changed camera, traverses offscreen ancestors needed for visible descendants, and keeps bounded traversal, page demand, and active-row capacity coherent across rapid camera updates.
• Progressive RAD selection - selectView() selects a fresh complete cut; refineView() publishes coherent intermediate replacements while reprioritizing retained detail. Generic CPU-only residency and hierarchy data support worker selection with bounded page demand.
• Shared-pass splat rendering - GPUPagedSplatRenderer.prepare() encodes compute work before a host pass, and draw() presents inside it without clearing, ending, or submitting the borrowed pass.

@luma.gl/core/webgpu

• Attach to application-created GPUDevices - luma.attachDevice(gpuDevice, {adapters: [webgpuAdapter]}) and webgpuAdapter.attach(gpuDevice) wrap an existing WebGPU device, so an application and deck.gl can share one device with the application's requested limits and features. device.destroy() leaves the GPUDevice usable; the application destroys it.

Experimental Slang package

@luma.gl/slang is a public experimental package from v10. It is optional and has no runtime dependencies. The Slang documentation includes a live sculpture and links to a WebGPU particle simulation; applications own compiler registration and resource bindings.

Slang everyday language

The experimental Slang module adds switch with grouped labels and fallthrough, do/while, inferred mutable var and immutable let locals, numeric scalar/vector promotion, vector comparisons, integer shifts, floating-point remainder and component-wise matrix arithmetic. Matrix constructors support scalar broadcast, row vectors and matching matrices. GPU tests compare these features with upstream-generated WGSL and exercise GLSL ES 300. The optional compiler still has no runtime dependencies.

Slang compute and textures

The experimental Slang authoring module now supports integer atomics, byte-address buffers, synchronization diagnostics, texture arrays, multisampled loads, explicit gradients, gathers, dimension queries and more storage dimensions. The particle vortex example simulates and renders one shared Slang source. The compiler remains optional and dependency-free; WebGL uses GLSL ES 300, with diagnostics for operations that require explicit GLSL 450.

Version 9.4

Release Date: September 5, 2026

Version 9.4 expands luma.gl with portable GPU data processing and a broad experimental stack for analysis, text, splats, physical scenes, simulation, and immersive rendering.

Highlights

• Data that goes straight to pixels - Typed, chunked GPU columns can move through analysis, text, paths, and rendering without a CPU-side object layer.
• Analysis that stays on the GPU - Dataframes, sorting, aggregation, raster, geospatial, and trace APIs keep intermediate results resident and reusable.
• Captured and animated worlds - Stream large Gaussian splat scenes, mix splats with meshes, and animate crowds with shared geometry, GPU sampling, culling, and LOD.
• Three new experimental libraries - @luma.gl/engine/text, @luma.gl/splats, and @luma.gl/anari are now published for direct use. These APIs may evolve outside the 9.4 semver contract.

A clearer GPU data stack

• Primitive GPU data has a dedicated home - GPUData, GPUVector, views, formats, and layout helpers live in @luma.gl/graph/gpu-data, independent of source adapters and rendering models.
• Tables and models stay focused - Batch-preserving tables live in @luma.gl/graph/gpu-tables; path and polygon models live in @luma.gl/engine/models.
• Renderers preserve what matters - @luma.gl/engine/text supports streamed text and shared font resources. @luma.gl/splats retains source batches and stable row identities.

More room to build

• A faster rendering loop - RenderPass owns draw state and supports render bundles, direct draws, and indirect draws. Feature levels, stage-specific limits, DynamicBuffer, and VideoTexture make resource choices explicit.
• Richer physical scenes - Forward and deferred pipelines add bloom, ambient occlusion, reflections, fog, and adaptive exposure. glTF animation covers skins, morph targets, materials, texture transforms, and crowds.
• A cleaner shader and development workflow - Reusable WGSL/GLSL plugins, lightweight WGSL scanning, TypeScript 6.0, llms.txt, and opt-in WebGL debugging make projects easier to ship and maintain.

General

• TypeScript 6.0 - luma.gl package builds, website tooling, and supported example typechecks now use TypeScript 6.0.
• Precise raw binary64 coordinate deltas - The WGSL fp64arithmetic module can split a binary64-rounded subtraction into normalized double-single limbs, normalize and compare those limbs with integer-controlled behavior in either arithmetic mode, and explicitly classify non-finite values. The existing direct-to-f32 helper retains its single-round exact-delta contract.

AI-Assisted Development

• Official lumagl Agent Skill - luma.gl now ships an installable skill that teaches coding agents the framework architecture, WebGPU/WebGL portability boundaries, GPU debugging order, and contribution workflow.
• Agent-ready documentation - llms.txt and page-level Markdown give agents fresh, linkable access to tutorials, API guides, API references, and developer guides instead of relying on stale training data.
• Evidence-driven agent workflows - Browser-backed verification helps agents prove that generated GPU code actually renders instead of merely typechecking, while a checked-in evaluation corpus supports repeatable comparisons with and without the skill. See Working with AI Coding Agents.

New Modules

• @luma.gl/graph/gpu-simple-graph - New module for lazy GPUDataEvaluator operations and chunk-preserving GPUVectorEvaluator transforms with CPU/WebGL/WebGPU backends.
• @luma.gl/engine/text - GPU-oriented 2D and 3D text rendering and atlas construction.
• @luma.gl/splats - Experimental Gaussian splat rendering with caller-owned GPU data and preserved streaming batches.
• @luma.gl/anari - Experimental forward, deferred, glTF, ray-marching, and ray-tracing scene rendering.
• @luma.gl/graph/experimental - Path/polygon models and flow/fluid simulations through explicit experimental subpaths.

@luma.gl/engine

• Shared keyframe animation - AnimationMixer, AnimationClip, AnimationTrack, and AnimationAction provide reusable bindings, weighted clip blending, crossfades, playback speed, seeking, and once, repeat, or ping-pong looping.
• glTF-compatible interpolation - Shared samplers evaluate STEP, LINEAR, and CUBICSPLINE tracks, including normalized quaternion interpolation, without depending on glTF-specific scene classes.
• Portable morph-target deformation - applyMorphTargets() and updateMorphTargetBuffers() blend position, normal, and tangent targets into existing interleaved GPU buffers while preserving immutable source geometry and tangent handedness.

@luma.gl/gltf

• Source-faithful physical materials - One canonical texture-slot registry preserves all 17 supported PBR map slots, extension factors, UV sets, KHR_texture_transform, source color spaces, alpha masking, and double-sided materials.
• Authored samplers and mipmaps - glTF and postprocessed loaders.gl sampler representations retain their wrapping, filtering, and mipmap settings; shared texture creation generates requested mip chains on both WebGL and WebGPU.
• Skeletal and morph animation - Existing joint skinning now supports multiple skins, optional bind data, and normalized joint weights. Morph samplers correctly group multi-target weight channels, including cubic-spline data, and animate position, normal, and tangent deformation.
• Animated glTF properties - KHR_animation_pointer channels drive supported node transforms, physical-material factors, and texture transforms through the shared engine animation mixer.
• Lossless animated asset interchange - The shared application helper for .gltf and .glb export preserves hierarchy, animation clips, material pointers, skins, inverse bind matrices, morph targets, RGBA colors, joint attributes, material variants, GPU instancing, cameras, and punctual lights.
• Punctual lights and source-faithful materials - Source directional, point, and spot lights retain authored colors, intensity, and cones; generic export round-trips supported materials, all map slots, UV sets, texture transforms, and sampler settings.

@luma.gl/anari (Experimental)

• Retained physically based rendering - The ANARI-inspired scene API maps committed handles, staged parameters, instances, cameras, lights, and 17 material texture slots onto shared forward and WebGPU deferred scene renderers, including automatic opaque-scene capture for transmissive materials.
• Ray lighting quality controls - Opt-in power-weighted emissive selection preserves exact conditional sampling PDFs and CORE storage limits. The scene playground exposes explicit ray resolution, renderer switching and emitter-distribution comparisons with retained ray settings.
• Pluggable interactive GPU-compute ray tracing - ANARIDevice.registerRenderer() registers lazy custom runtimes, while the WebGPU-only raytrace subtype adapts committed scenes to the shared experimental RayTracingSceneRenderer for GPU-built object/instance BVHs, adaptive half-resolution rendering, interleaved pixel phases, stable-instance temporal reprojection, bounded rotating shadows, progressive sampling, and upsampled HDR presentation within default WebGPU CORE limits.
• Optional glTF animation integration - The isolated @luma.gl/anari/gltf entry point binds imported node hierarchies, material and sampler pointers, and morph-weight tracks to retained objects while committing each changed object at most once per frame.
• Source-faithful retained assets - JSON scenes preserve indexed geometry, both UV sets, tangents, RGBA vertex colors, joint attributes, morph targets, authored samplers, punctual lights, and OPAQUE/MASK/BLEND modes; programmatic renderer parameters can additionally supply caller-owned image-based-lighting textures.

Experimental rendering and GPU workflows

• Shared physical scene rendering - SceneRenderer renders format-independent physically based surfaces on WebGL and WebGPU with reusable instanced geometry, staged material updates, explicit joint palettes, morph deformation, punctual lights, and caller-provided image-based-lighting textures.
• Deferred physical scene rendering - DeferredSceneRenderer reuses the same scene descriptors through a four-target HDR G-buffer and lighting resolve that fits the default 32-byte WebGPU CORE limit, automatically falling back to the shared forward renderer for unsupported scenes.
• Shared interactive GPU-accelerated ray tracing - RayTracingSceneRenderer composes world-space instance bounds, dirty-only GPU bounding-volume hierarchy construction/refitting, nearest-hit traversal, bounded direct-light shadows, adaptive internal resolution, interleaved frame-budget coverage, stable-identity temporal reprojection, progressive accumulation, and upsampled HDR presentation through WebGPU compute/command graphs. Frame pacing uses ordinary animation intervals, the tracing pass uses five storage buffers, the BVH builder uses eight, mesh triangles remain linearly refined, and command submission stays application-owned.
• Generated physical lighting environments - PBREnvironmentGenerator and preparePBREnvironment() integrate equirectangular source textures into GGX-prefiltered specular cubemap mip chains, diffuse irradiance cubemaps, and split-sum BRDF lookup textures on both WebGL and WebGPU.
• Scene-color transmission and volume attenuation - The shared forward renderer captures opaque scene color automatically for transmissive surfaces, then applies screen-space refraction, roughness, Fresnel response, index of refraction, thickness, and Beer-Lambert attenuation while preserving physically opaque output.
• HTMLTexture - Experimental copied texture binding source copies HTML-in-Canvas DOM subtrees into GPU textures while the browser API is still experimental.
• OIT resolve pipelines - A-buffer and weighted-blended order-independent transparency now resolve captured fragments through exported ShaderPassPipeline factories, allowing WBOIT to compose directly with the advanced effects stack.
• GPU-resident trace scenes - GPUTraceScene, from @luma.gl/graph/gpu-trace, preserves canonical span identity, timing, process/thread ownership, hierarchy parents, explicit source batches, dependency links, and bidirectional adjacency while projecting shared GPU scene records for visibility, indirect drawing, and renderer-owned resource groups.
• GPU-native trace interactions - GPUTraceInteraction and reusable timeline picking live in the optional @luma.gl/graph/gpu-trace submodule, composing process/thread collapse, scanned row layout, time and classification filters, linked-span focus, nearest-visible ancestor projection, stable compaction, and scene indirect draws without CPU draw selection.
• Optional GPU geospatial kernels - The side-effect-free @luma.gl/graph/geospatial subpath contributes cuSpatial-compatible sinusoidal projection, haversine distance, pairwise planar distances, four-state point-in-polygon classification, nearest-linestring results, grid indexing, and point spatial queries to caller-owned command graphs, including raw binary64 coordinate inputs.
• GPU projection patches - The optional @luma.gl/graph/gpu-project subpath compiles arbitrary CPU projection providers into adaptive local polynomial patches and projects chunk-preserving coordinate vectors through WebGPU command graphs. Its fp64-backed double-single mode preserves more than Float32 precision through absolute float32x4 results, while an optional validity column distinguishes rejected rows from legitimate zero coordinates.
• Composable projection programs - Typed axis, unit, affine, and adaptive operations compile into a shared inline WGSL function and GPU Graph contributor. Programs preserve double-single intermediates, accept double-single output from upstream programs, propagate validity, and support compatible parameter updates without rebuilding the graph.
• Broader adaptive PROJJSON coverage - Lambert Conic Conformal 1SP/2SP and Albers Equal Area definitions use verified EPSG method/parameter mappings and the existing double-single adaptive backend. Custom CRS labels need no registry entry; identifier-only and localized definitions retain explicit units and error budgets. Both planners offer optional ProjectionPlanningError throwing without changing their default structured failure results.
• Batch-preserving CPU/GPU projection - ProjectionTableTransform uses one prepared CRS transform for batch-atomic CPU execution or explicit GPU table materialization. It preserves batch boundaries and source identity, borrows GPU inputs, exposes validity and output encodings, and keeps upload, submission and readback application-owned.
• Explicit projection seams and comparative benchmarks - Double-single longitude normalization has declared intervals, invalid seam guards, and no automatic many-to-one inverse. The optional program benchmark compares native/adaptive arithmetic and inline/materialized execution against an independent validity-aware oracle, reporting accuracy, buffer memory, planning/compilation, and synchronized execution costs.
• Equal-budget projection performance sweeps - Optional multi-patch UTM/Albers benchmarks compare quadratic/cubic adaptive plans, row counts, and shared-result consumer reuse at a fixed double-single accuracy budget. Reports distinguish timestamp-instrumented runs from normal pass-coalesced execution and include actual patch counts and buffer costs.
• Matched CPU projection baselines - The program benchmark also measures repeated and shared-result CPU consumers, with explicit provider labels and binary64 outputs. GPU-resident speedup includes encoding and synchronized execution but explicitly excludes transfers and setup.
• Production table projection measurements - An optional table-consumer benchmark compares retained CPU execution with GPU-resident, upload/project and CPU round-trip paths, preserving physical batches. Reports separate resident-data speedups from transfer-inclusive round trips and include accuracy, memory, setup and an optional 4K–4M row sweep.
• Opt-in native conic projections - Bounded Lambert Conformal Conic 1SP/2SP and Albers forward/inverse formulas lower from explicit PROJJSON or pipelines with Float32 arithmetic opt-in, guarded inverse footprints and shared inline/graph execution. Default high-precision adaptive coverage is unchanged; equal-budget conic benchmarks qualify optimization trade-offs.
• Visualization projection qualification - Spherical gnomonic/orthographic fixtures qualify prepared double-single plans, public-engine horizon/inverse-domain rejection, inline consumers and CPU/GPU table paths. Horizon-crossing geometry still requires explicit clipping; no new native visualization kernel is implied.
• Native Transverse Mercator and UTM - Explicit Float32 forward/inverse programs support all 60 WGS84 UTM zones, EPSG 9807 PROJJSON conversions, and utm/tmerc pipelines. Domain and inverse-footprint checks reject unsupported branches. Default higher-precision execution continues to use double-single adaptive patches, now fitted from the normalized binary64 series reference for supported explicit CRS pairs.
• Projection metadata and CRS planning - Projection programs expose immutable precision, domain, validity, inversion, and sampled-error metadata. The optional @luma.gl/graph/gpu-project/crs adapter lowers explicit axis/unit/affine PROJ pipelines and fits bounded CRS transformations through math.gl 5, with structured fallback reasons and independently bounded inverse plans.
• Caller-prepared projection planning - planProjection() accepts application-owned synchronous transforms, including preloaded math.gl providers, without resolving their CRS again or importing a projection catalogue. It shares the existing double-single compiler and structured failures while leaving lazy loading with the caller.
• Native Web Mercator programs - Explicitly opt into forward/inverse Float32 formulas through PROJJSON or webmerc pipelines, with checked domains, honest arithmetic metadata, and shared inline/graph execution. Default high-precision Web Mercator planning retains double-single adaptive fitting against the validated binary64 formula and declines lossy provider routes.
• Native CRS frame changes - Explicit PROJJSON geographic frames and equivalent Transverse Mercator/Pseudo Mercator conversions now lower to double-single axis/unit/affine programs without sampling. The planner normalizes ellipsoids, prime meridians, conversion parameters, and false origins; preserves datum boundaries; and requires fitting bounds only on adaptive routes.
• GPU spectral ocean simulation - SpectralOceanSimulation evolves a deterministic seeded Phillips spectrum, reconstructs three spatial fields on the GPU, and emits render-ready displacement and normal/foam buffers. Surface normals come from the displaced field, whitecaps come from horizontal-displacement compression with bounded temporal history, and command submission remains application-owned. Tempest Ocean binds those buffers directly to an independently tessellated HDR stormfront surface.
• GPU dataframe analytics - GPUDataFrame builds reusable WebGPU plans for null-aware filters, projections, derived columns, aggregations, histograms, batch-preserving joins and lookups, stable sorting, and top-K selection while retaining source batch and row identity.
• GPU raster analysis - The optional @luma.gl/graph/gpu-raster subpath supports bounded tile residency and halos, nodata-aware overviews and statistics, filtering and morphology, connected components, region measurements, and GPU-generated contours.
• Linked GPU crossfiltering - GPUCrossfilter composes reusable scalar ranges and two-dimensional brushes, self-excluding histograms, and stable selected-row IDs over GPU-resident columns.
• GPU volume analysis - The optional @luma.gl/graph/lucim subpath provides typed volume data, thresholding, binary and grayscale morphology, connected components, and per-region measurements for WebGPU workflows.
• Semantic G-buffer targets - GBuffer owns WebGPU MRT scene color, normal-roughness, velocity, and depth targets plus named extra channels, then exposes the standard depth, normal, and velocity bindings consumed by screen-space effect pipelines. Velocity remains enabled by default and can be omitted with velocity: false when a non-temporal renderer needs a smaller attachment budget.
• Composable deferred lighting - deferredLighting resolves Cook-Torrance opaque lighting from G-buffer material channels, reconstructed depth, one directional light, and a fixed-capacity WebGPU point-light storage buffer. The Deferred Illumination Lab exposes the material channels and animated lights live.
• Hybrid shadows - ShadowMapRenderer, the group-2 shadow WGSL module, and the contact-shadow shader-pass pipeline add WebGPU cascaded directional, spot, and point-light shadows with PCSS filtering. Visualization City demonstrates the complete ordered stack.
• Visualization City - The Advanced Effects example combines the experimental G-buffer, deferred-lighting, and shadow stack with public screen-space effects in one v9.4 showcase.
• Spectral caustics - SpectralCausticsRenderer captures a closed convex refractor, traces six wavelength bands with WebGPU compute, additively accumulates an HDR XYZ map, and exposes reusable planar-receiver shading without taking command-submission ownership.
• Clustered deferred lighting - ClusteredLightGrid bins point lights into a configurable 3D screen-space grid and feeds the clustered deferred resolve pipeline.
• MLS-MPM fluid simulation - MLSMPMFluidSimulation adds a WebGPU-only two-dimensional weakly compressible fluid solver with deterministic fixed-point grid scatter, double-buffered particle state, caller-owned command encoding, and storage buffers that applications can render without hidden submission or readback.
• Volumetric fire simulation - VolumetricFireSimulation records WebGPU-only dense 3D velocity, pressure, obstacle, and combustion work through a GPU command graph, then exposes the live velocity and combustion textures for HDR volume rendering without hidden submission or CPU readback. Volumetric Fire Forge demonstrates the live fields with obstacle-matched geometry, depth-aware emission and extinction, fixed exposure, HDR bloom, deterministic automatic and click-triggered burner flares, and synthesized spatial combustion audio.
• Orbit controls - OrbitControls provides reusable pointer-driven orbiting, wheel zoom, camera limits, and automatic rotation from @luma.gl/engine.
• Accessible comparison splitters - ComparisonSplitter adds reusable draggable, keyboard-accessible before-and-after views to experimental examples.
• WebXR - Experimental animation-frame, camera-texture, and session helpers integrate immersive WebXR rendering with luma.gl.

@luma.gl/graph/gpu-simple-graph NEW MODULE

• GPUDataEvaluator lazy GPUData operations and GPUVectorEvaluator chunk-preserving GPUVector transforms with CPU/WebGL/WebGPU backends.
• Interleaved GPGPU inputs - Borrowed GPUDataView values expose fixed-width strided attributes over shared buffers, allowing existing lazy operations to read interleaved data while continuing to produce packed outputs.

Experimental GPU data and tables

• Normalized Arrow color conversion - convertArrowColors() and convertColors() lower chunked Uint8, Float16, and Float32 RGB/RGBA rows into canonical unorm8x4 GPU vectors with opaque RGB expansion, preserved nullable-row metadata, caller-owned input lifetime, and WebGPU compute plus WebGL fallback. Arrow path, polygon, and text layers consume the same conversion boundary.
• Universal Arrow-to-GPU planner - planArrowGPUConversion() and convertArrowToGPUVector() select and explain zero-copy borrowing, direct or reinterpreted upload, numeric repacking, and semantic color, temporal, or matrix lowering. Table-schema counterparts preserve record batches, source row identity, field/null metadata, and explicit ownership while reporting byte/pass cost and precision warnings before allocation.
• Arrow shader layouts - getArrowBufferLayout() maps Arrow scalar and FixedSizeList columns to shader attribute formats from a shader-first layout, including direct arrow.Vector sources and Arrow table path mappings.
• Arrow GPU adapters - Arrow factories, append helpers, and readback helpers bridge Apache Arrow inputs into @luma.gl/tables objects and preserve chunked UTF-8 GPU vector input for text workflows.
• High-dimensional Arrow storage columns - Existing Arrow table/vector adapters map wide FixedSizeList values directly into row-aligned fixed-size-list GPU columns, with optional named validity siblings and preserved parent/child nulls, record batches, and source identity.
• Variable-length Arrow attribute lists - GPUVector can retain chunked nested list columns whose elements contain one to four numeric components, covering scalar streams plus tuple-style data such as XY, XYZ, and XYZM coordinates for future path-rendering workflows.
• Closed Arrow path normalization - closeArrowPaths() appends explicit closing vertices only for closed Float32 absolute or origin-relative delta path rows whose endpoints differ beyond an epsilon, using WebGPU compute when available with equivalent CPU fallback semantics.
• ArrowPathModel - New attribute-backed path renderer consumes prepared Float32 XY, XYZ, and XYZM path props, expands path rows into packed per-segment render records, and supports Float64 source paths through CPU-prepared Float32 deltas plus CPU-updated view origins.
• ArrowPathStorageModel - New WebGPU-only storage-backed path renderer expands nested prepared Float32 XY, XYZ, and XYZM rows through compute into compact 12-byte indexed segment records using GPU path values plus persistent per-row path ranges, keeps per-path color, width, and optional view-origin rows as storage bindings, can convert Float64 source paths into Float32 deltas with one fp64arithmetic compute pass, and can consume reusable ArrowPathStorageState objects built by createArrowPathStorageState.
• Mesh Arrow geometry - New ArrowTableGeometry and makeGPUGeometryFromArrow() support loaders.gl-compatible Mesh Arrow tables, including default interleaved vertex buffers and optional index buffers.
• Arrow table adapters - Arrow table/vector upload, append, and readback utilities now layer over reusable generic GPU table objects from @luma.gl/tables.
• Supported Arrow Types and GPU Table Lifecycle - Matrix Arrow vectors, storage-selected table bindings, Arrow adapters, and the generic tables execution layer.
• Apache Arrow GPU Tables examples - Points: FixedSizeList<Float32, 2 | 3 | 4> and DenseUnion point rows, Lines: List<FixedSizeList<Float32, 4>>, DenseUnion LineStrings, and List<Timestamp>, GeoArrow: mixed DenseUnion geometry routing, Text: Utf8/Dictionary<Utf8>, Time: Date/Time/Timestamp/Duration, Starfield: Timestamp/Duration, Matrices: FixedSizeList<Float32, 16>, Particles: FixedSizeList<Float32, 3>, and Global Grids: Uint64, Utf8 for geohash, quadkey, S2, A5, and H3 now live in the Apache Arrow section.
• Points Example - New ScatterplotLayer-style renderer consumes Arrow point vectors or DenseUnion point rows, supports M-coordinate or timestamp animation, and reports hover identity as full-table row index, batch, and batch-local row.
• Time Columns Example - New showcase prepares aligned scalar DateDay, TimeMillisecond, TimestampMillisecond, and DurationMillisecond rows into relative Float32 GPU vectors, then renders the same schedule through instanced attributes or WebGPU storage bindings.
• Blinking Stars Example - New showcase prepares aligned scalar TimestampMillisecond and DurationMillisecond rows into relative Float32 GPU vectors, then uses them as per-instance visibility windows and pulse periods through instanced attributes or WebGPU storage bindings.
• Lines Example - New showcase expands nested Arrow XYZM line rows and DenseUnion LineString rows into styled GPU segment instances with attribute-backed and storage-backed models, then adds an ArrowPathTripsStorageModel mode that prepares aligned List<Timestamp> rows into relative Float32 milliseconds for storage-backed trail filtering.
• GeoArrow Example - New mixed-geometry showcase routes one GeoArrow-style DenseUnion column through Arrow point, line, and polygon renderers.
• Composite GPU inputs - GPUInputSchema.attributeNames maps one logical table column to several shader attributes, allowing a shared matrix buffer to feed portable vertex attributes or a WebGPU storage binding without repacking. Ordinary inputs retain the singular attributeName.
• GPU data primitives and experimental tables - Canonical GPUData and GPUVector runtime classes live in @luma.gl/graph/gpu-data, while GPURecordBatch and GPUTable provide reusable non-Arrow-specific GPU table ownership and batching from @luma.gl/graph/gpu-tables.
• Table-backed rendering - GPUTableModel draws preserved table batches, and GPUTableGeometry exposes packed static GPU tables as renderable geometry.
• Vertex storage planning - GPUTableBufferPlanner checks vertex-stage storage buffer limits before choosing storage-backed table attributes, allowing core WebGPU devices to fall back to vertex attributes when needed.
• Execution helpers - GPUTableComputation, generated-buffer batch planning, and GPUTableBufferPlanner live with the experimental table runtime instead of a source-adapter module.
• Physical GPU data structs - Inline GPUData format records describe interleaved rows with wgsl-storage or minimally padded WebGPU vertex layouts, while GPUData.getChild() and getChildAt() expose typed zero-copy field views.

@luma.gl/engine/text

• GPU-only 2D text facade - TextRenderer renders caller-owned GPUTextData while selecting attribute, WebGPU storage, or dictionary strategies automatically.
• Experimental text strategies - Specialized model classes and low-level shader/compute contracts remain available from @luma.gl/engine/text-experimental for benchmarking.
• Packed generated glyph vertex data - Attribute text uses expandedGlyphVertexData, while storage text uses compactGlyphVertexData, reducing generated glyph buffer fan-out without folding caller-owned row/style vectors into generated records.
• Dependency-isolated font preparation - @luma.gl/engine/text-fonts builds bitmap and SDF browser fonts, builds or loads prebuilt BMFont JSON MSDF atlases, measures atlas-backed text, and exposes bundled Helvetiker data without importing luma.gl, loaders.gl, or GPU modules. Existing @luma.gl/engine/text font imports remain supported.
• GPU UTF-8 shader mapping - Reusable text-module WGSL helpers compose sparse UTF-8 byte traversal, code point decode, and storage lookup into one-pass text compute kernels.

@luma.gl/splats NEW MODULE

• Gaussian splat rendering - SplatRenderer draws caller-owned prepared GPU splat batches through reusable luma.gl rendering models on WebGPU and WebGL2.
• HDR Gaussian colors - Float32 color columns preserve spherical-harmonic DC radiance above the display range without premature clamping or quantization.
• GPU interaction and higher-order shading - WebGPU command graphs evaluate camera-dependent spherical-harmonic color, semantic filters, global depth ordering, and integer picking while preserving source batch, row, and semantic identity.
• Bounded hierarchical streaming - Frustum- and error-driven RAD traversal pages source data into explicit GPU residency budgets with parent fallback, cancellation, and stable authored row identities.
• Incremental splat streaming - New prepared batches append without concatenating source data, rebuilding previous batches, or transferring ownership to the renderer.
• Layered adapters - File parsing stays in loaders.gl, columnar source conversion stays outside the published splats package, and deck.gl integration stays in downstream applications.

@luma.gl/core

• WebGPU render bundles - Record reusable draw commands with RenderBundleEncoder and replay them from a RenderPass, reducing CPU command-recording time for repeated scenes.
• Render-pass draw commands - RenderPass now owns pipeline, binding, vertex-array, direct-draw, indirect-draw, and render-bundle commands. The former RenderPipeline draw and binding APIs remain as deprecated compatibility paths.
• WebGPU feature levels - DeviceProps.featureLevel can now request 'core', the portable WebGPU default; 'max', which requests every adapter feature and supported limit; 'compatibility'; or 'best-available', which upgrades compatibility to core when available. The effective level is reported as device.info.featureLevel.
• Stage-specific storage limits - device.limits now reports storage buffer and storage texture availability separately for vertex and fragment stages, so applications can choose storage-backed rendering only where the requested device supports it.
• HTML-in-Canvas feature detection - device.features.has('html-in-canvas') and isHTMLInCanvasSupported() report whether the active browser and backend expose the experimental DOM-to-texture rasterization path. The high-level HTMLTexture wrapper is available from @luma.gl/engine/experimental/textures.
• GPU data and buffer-layout utilities - New exported helpers decode GPU data types, select native or emulated Float16 arrays, and resolve logical attributes over shared or composite buffer layouts.

@luma.gl/webgl

• Optional WebGL debugging - WebGLDeveloperTools and Spector integration are registered through @luma.gl/webgl/debug, keeping debug-only code out of normal adapter application bundles.

@luma.gl/engine

• DynamicBuffer - New engine-level wrapper for resizable buffers. Model supports dynamic buffers for attributes, index buffers, and shader bindings, and Material supports dynamic buffer bindings with cache invalidation when the backing buffer changes.
• VideoTexture - Stable live video binding source for caller-owned HTMLVideoElement and VideoFrame inputs. Portable shaders use copied textures on WebGL and WebGPU, while WGSL texture_external can opt into native WebGPU external-video sampling.
• Animator - New generic Animator and AnimationClipController classes manage timeline-driven animation updates. GLTFAnimator now builds on the shared controller.
• Custom animation-frame providers - AnimationLoop can consume a caller-provided animation-frame source and forward its frame payload, enabling integrations such as WebXR without changing the normal browser loop.
• Shader pass pipelines - ShaderPassRenderer supports structured multi-pass effects such as bloom and depth of field.
• Temporal shader-pass targets - ShaderPassRenderer supports persistent ping-pong history targets, explicit reset, safe same-target temporal reads and writes, and caller-selected output formats.
• Geometry buffer layouts - Geometry now always has a populated bufferLayout. CPU attribute keys remain exactly as supplied; synthesized shader-facing layouts map supported glTF semantics such as POSITION, NORMAL, TEXCOORD_0, and COLOR_0.
• Interleaved geometry uploads - makeInterleavedGeometry() packs CPU attributes into one buffer, and makeGPUGeometry() uses the packed representation by default for one vertex buffer plus an optional index buffer.
• Index-based color picking - indexColorPicking encodes integer object indexes without application-provided picking colors. Picking also supports vertex indexes, redraw invalidation, and optional tooltips.
• Model layout updates - Model.setBufferLayout() is idempotent, and explicit WGSL attribute layouts are merged with inferred bindings to support shader metadata without manually declaring uniform bindings.
• ShaderInputs.addModules() - ShaderInputs can register shader modules and dependencies after construction, and it can carry deferred texture and buffer bindings until draw time.

@luma.gl/webgpu

• Lightweight WGSL interface scanning - getShaderLayoutFromWGSL() recognizes vertex inputs, buffer bindings, comparison and named depth samplers, storage textures, and external textures without shipping the full wgsl_reflect parser in the default WebGPU bundle.
• WGSL external textures - Scanned texture_external declarations produce external-texture bindings for native video sampling.
• Texture default views - WebGPU texture default views now preserve explicit TextureProps.view mip and array-layer ranges.
• Mapped buffer initialization - WebGPU buffers can be initialized through mapped ranges without losing byte offsets or debug data.

@luma.gl/effects

• bloom - New bloom postprocessing effect and shader-pass pipeline.
• dof - New depth-of-field postprocessing effect and shader-pass pipeline.
• gaussianBlur - New gaussian blur postprocessing effect.
• persistenceEffect - Moved into @luma.gl/effects as a first-class postprocessing effect.
• Advanced screen-space effects - New WebGPU-first composable pipelines provide depth-aware blur, SSAO, temporally stabilized GTAO, colored screen-space diffuse global illumination, outlines, temporal AA, motion blur, roughness-aware temporally stabilized screen-space reflections, compact height fog, bounded clustered participating-media lighting with camera-aware history, GPU-driven adaptive exposure, and HDR-safe successively filtered multiscale bloom. The pipelines can consume application-provided depth, normal, velocity, and material textures without requiring the experimental GBuffer.
• FFT convolution bloom - GPUConvolutionBloom performs energy-conserving, spectrally sampled aperture convolution on HDR WebGPU textures with reusable FFT resources and optional temporal stabilization.

@luma.gl/shadertools

• colors, floatColors, and storageColors - Semantic color normalization now has a colors helper namespace, the legacy floatColors alias remains available, and WebGPU shaders can read packed RGBA storage rows through storageColors.
• dggs - New WGSL helpers decode compact Uint64 DGGS cell keys for storage-buffer and boundary-extraction workflows.
• Apple/Metal-safe fp64 arithmetic - WGSL double-single arithmetic automatically uses integer-controlled twoSum, twoProd, and renormalization on Apple WebGPU adapters, avoiding Metal compiler reassociation while retaining the existing vec2f API. The LUMA_FP64_INTEGER_ARITHMETIC shader define can force or disable the mode.
• WGSL double-precision arithmetic - The fp64arithmetic shader module can subtract packed IEEE 754 double-precision values directly in WGSL and convert the result to f32.
• Portable tangent approximation - The shared fp32 shader module now provides tan_fp32() in GLSL and WGSL.
• ShaderPlugin - Reusable shader assembly plugins group modules, defines, named injections, caller-owned vertex inputs, and generated cross-stage varyings.
• WGSL hooks and injections - ShaderAssembler now applies registered hook functions and standard named injections such as vs:#main-start and fs:#main-end while assembling unified WGSL shaders.
• WGSL shader conditionals - Shadertools preprocessing accepts simple boolean and numeric #if expressions, and assembled WGSL exposes LUMA_SUPPORTS_VERTEX_STORAGE_BUFFERS so inactive resource branches are removed before @binding(auto) assignment.
• ShaderPassPipeline - New shader-pass pipeline type for structured multi-pass postprocessing.
• waterMaterial - New water material shader module with GLSL and WGSL shaders.

@luma.gl/gltf

• Animation controllers - GLTFAnimator uses the shared engine Animator while retaining its existing animations, animate(), setTime(), and getAnimations() compatibility surface.
• Attribute identification - PBR material setup recognizes both source glTF semantics and their shader-facing aliases.

@luma.gl/test-utils

• Feature-level WebGPU devices - getWebGPUTestDevice() accepts a WebGPU feature level, while getWebGPUTestDevices() returns the available requested profiles.

Version 9.3

Release Date: March 31, 2026

General

• Typescript 5.9 - luma.gl code base is now TypeScript 5.9 clean.

New Examples

• Texture Tester Example - New example showing support for compressed textures on WebGL and WebGPU. Also implements multi-canvas rendering.
• Multi-Canvas Example - New example showing rendering into multiple HTML canvas elements.
• External Context Example - New example showing integration with external WebGL contexts.
• React Strict Mode Example - Improved resource cleanup for better compatibility when using luma.gl in React <StrictMode> apps

@luma.gl/core

• Multi-canvas rendering is now supported on both WebGL and WebGPU via device.createPresentationContext(). See the Multiple Canvases developer guide details.
• Composite shader block layouts now support nested structs and fixed-size arrays in ShaderBlockLayout and UniformStore, while preserving nested JavaScript values at the API boundary.
• Grouped bindings now support ShaderLayout.bindings[].group, flat bindings, and grouped bindGroups, including sparse logical bind-group usage on both WebGPU and WebGL.

@luma.gl/engine

• New Material and MaterialFactory classes provide reusable material-owned group-3 bindings for Scenegraph models.
• WebGPU mipmap generation now supported by DynamicTexture.
• Explicit mip chains can now be passed to DynamicTexture for 2D, array, cube, and 3D uploads.
• Compressed mip uploads are now validated and uploaded through DynamicTexture, including block-size-aware mip truncation.
• Mip-level format metadata now accepts both textureFormat and format on texture data objects during the transition to loaders.gl TextureLevel naming.

@luma.gl/webgpu

• compressed texture support (but note that WebGPU is stricter than WebGL and requires block-aligned textures).
• texture readback improvements

@luma.gl/webgl

• RenderPipeline optimization - Compatible WebGL render pipelines now share linked WebGLPrograms, reducing pipeline creation overhead while preserving per-pipeline defaults.

@luma.gl/gltf

• WebGPU support - glTF models can now be rendered in WebGPU.
• Joint/Skin Animations - Support for glTF animations now include joint and skin animations.
• Lighting - luma.gl Light definitions are now extracted if the KHR_lights_punctual glTF extension is present in the glTF file.
• Scenegraph materials - glTF scenegraph creation now returns materials aligned with the source glTF materials array.
• linear texture filtering - default texture filtering is now linear instead of nearest for improved texture rendering.
• PBR material extensions - the stock pbrMaterial shader now implements KHR_materials_specular, KHR_materials_ior, KHR_materials_transmission, KHR_materials_volume, KHR_materials_clearcoat, KHR_materials_sheen, KHR_materials_iridescence, and KHR_materials_anisotropy, using the parsed glTF extension uniforms and textures.
• Emissive materials - the stock PBR shader now applies KHR_materials_emissive_strength, and core emissiveFactor values are preserved even when no emissive texture is present.
• KHR_animation_pointer - createScenegraphsFromGLTF() and GLTFAnimator now animate supported node TRS targets, selected material factors, and animated KHR_texture_transform offset/rotation/scale targets on stock PBR material texture slots. Structural targets such as animated texCoord, morph weights, cameras, and material mode switches remain unsupported.
• Extension support docs - the glTF Extension Support table now documents the current built-in vs parsed-only extension coverage for @luma.gl/gltf.
• Extension support metadata - createScenegraphsFromGLTF() now exposes an extensionSupport map so applications can inspect which extensions a model uses and whether @luma.gl/gltf supports them.

@luma.gl/shadertools

• floatColors - New shader module with shared semantic color normalization and premultiplied alpha helpers.
• Opt-in float semantic colors - Byte-based semantic color APIs in lighting, shared floatColors, legacy picking, and glTF light parsing accept useByteColors: false for float and HDR-style color values while preserving current defaults.
• lighting shader module supports a new light type SpotLight.
• lambertMaterial A new shader module adds a diffuse-only matte material model, completing the material catalog
• Unlit Materials All material shader modules now support unlit prop, allowing applications to disable lighting for materials that are already lit (e.g. photogrammetry).
• Composite uniformTypes uniformTypes now support nested structs and fixed-size arrays. See ShaderModule.
• WebGPU Shader modules - ShaderModules now have WGSL variants.
• Shader module auto bindings WGSL shader module now support @binding(auto) which eliminates binding conflicts. See WGSL Support.

@luma.gl/effects

• WebGPU/WGSL effects - Effects now have WGSL shader implementations and work under WebGPU.
• persistenceEffect - New temporal accumulation effect for fading trails and other history-based postprocessing workflows.

Version 9.2

Release Date: Sep 24, 2025

Production quality WebGPU backend

General

• All luma.gl examples now run under both WebGPU and WebGL
• API updates to cover new Chrome WebGPU features
• TypeScript v5.7, and all "strict" TypeScript options are now enabled.
• Documentation improvements

@luma.gl/core

• [Buffer]

  • [Buffer.mapAndReadAsync()] New method that reads directly from buffer memory without performing a copy.
  • [Buffer.mapAndWriteAsync()] New method that writes directly to buffer memory.

• [Texture]

  • Texture class refactors complete, see upgrade guide.

• Shader type APIs have been improved.

• CommandEncoder/CommandBuffer API improvements

• Fence - New synchronization primitive created with device.createFence()

• CanvasContext API simplifications (see upgrade guide).

• Texture Formats. Adds support for the new texture formats added in Chrome 132 (currently require setting chrome://flags/#enable-unsafe-webgpu)

  • 'r16unorm', 'rg16unorm', 'rgba16unorm' (feature 'chromium-experimental-unorm16-texture-formats')
  • 'r16snorm', 'rg16snorm', 'rgba16snorm' (feature 'chromium-experimental-snorm16-texture-formats')

• Vertex Formats (added in Chrome v133 and v119)

  • Single component 8 and 16 bit formats are now supported by WebGPU: 'uint8', 'sint8', 'unorm8', 'snorm8', 'uint16', 'sint16', 'unorm16', 'snorm16', and 'float16'.
  • Note: 3 component formats are still missing in WebGPU.
  • 'unorm8x4-bgra' - WebGPU only. Simplifies working with BGRA data.
  • 'unorm10-10-10-2 - Exposed since available in all WebGPU backends. Also supported by WebGL2.

@luma.gl/engine

• DynamicTexture
  • now supports mipmap generation for WebGPU textures
  • owns WebGPU mipmap generation for 2d, 2d-array, cube, cube-array, and 3d textures
  • throws explicit runtime errors when a WebGPU texture format does not support the required mipmap-generation capabilities

@luma.gl/effects

• More postprocessing effects ported to WGSL

@luma.gl/shadertools

• More shader modules ported to WGSL

Version 9.1

Target Date: Dec, 2024

Enhanced WebGPU support.

Highlights

• GPU backend management is streamlined via the new Adapter API.
• GPU connection to HTML DOM (via canvas elements) improved via CanvasContext API changes.
• Textures are now immutable, however a new DynamicTexture class offers a higher-level, mutable texture API.
• ShaderModule type safety improvements (shader uniforms can now be strictly typed in JavaScript)

@luma.gl/core

• Adapter
  • New class for singleton objects representing pluggable GPU backends.
  • Singleton Adapter objects are exported by the @luma.gl/webgpu and @luma.gl/webgl modules.
• luma
  • Now relies on Adapter instances to define which GPU backends are available.
  • Adapter can be supplied during device creation, avoiding the need for global registration of GPU backends.
  • CreateDeviceProps.adapters prop to supply list of GPU backend adapters to luma.createDevice().
  • luma.registerAdapters() New method for global registration of adapters (in case it still desired).
• Device
  • DeviceProps.createCanvasContext - New prop for creating a default CanvasContext.
  • DeviceProps.onResize - New callback tracking size changes to CanvasContexts.
  • DeviceProps.onVisibilityChange - New callback tracking visibility to CanvasContexts.
  • DeviceProps.onDevicePixelRatioChange - New callback tracking device pixel resolution (DPR) changes to CanvasContexts.
  • DeviceProps.debug* - New debug options, please refer to DeviceProps documentation.
• CanvasContext
  • Now calculates exact "device pixel content box" size enabling pixel perfect sized drawing buffers (no moire etc).
  • Now tracks size, visibility and DPR changes (see the new DeviceProps callbacks).
• Texture
  • Textures are now immutable and synchronous. See upgrade guide, and the new DynamicTexture class in @luma.gl/engine.
  • Texture.copyExternalImage() New function that works on both WebGPU and WebGL.
  • Texture.copyImageData() New function that works on both WebGPU and WebGL.
• Sampler
  • SamplerProps.mipmapFilter New value 'none' providing more explicit control over mipmap filtering.
• RenderPipeline
  • Parameters.blend - New parameter that provides more explicit control over color blending activation.
• RenderPass
  • RenderPassProps.clearColors - New prop enables specification of clear colors for multiple color attachments.

@luma.gl/engine

• makeAnimationLoopTemplate
  • Accepts a new .adapters prop. (Avoids need for global registration of adapters).
• DynamicTexture
  • New class allows that applications to work withcreate textures from a Promise.
• ShaderPassRenderer
  • New class that helps applications apply a ShaderPass list to a texture.

@luma.gl/shadertools

• [ShaderModule](/docs/api-reference/shaders/shader-module)
  • New improvements to type safety, in particular for uniforms and bindings.
  • New simplified API, no longer required to instantiate modules into ShaderModuleInstances.
• getShaderModuleUniforms(module: ShaderModule, ...) New function
• getShaderModuleDependencies(module: ShaderModule) New function

@luma.gl/webgl

• webglAdapter
  • New object representing the WebGL backend
  • New: adds mock WEBGL1 extensions to WebGL2 contexts for better compatibility with old WebGL libraries
  • Big texture refactor to align WebGL implementation with WebGPU APIs
• RenderPipeline
  • WebGL render pipelines now support frame buffers with multiple color attachments.
• RenderPass
  • Now supports framebuffers with multiple color attachments.

@luma.gl/webgpu

• webgpuAdapter New object representing the WebGPU backend
• Numerous under-the-hood improvements and bug fixes

Version 9.0

Target Date: Feb 2024

caution

luma.gl v9 contains significant API changes and requires existing luma.gl v8 applications to be upgraded.

luma.gl v9 is a major release that adds experimental WebGPU support to the luma.gl API.

WebGPU Support

The biggest change is that the core API is now portable (no longer WebGL-specific), and plug-in backends are provided for WebGL 2 and WebGPU:

• Portable GPU API: @luma.gl/core now provides a portable GPU resource management API.
• WebGL bindings: @luma.gl/webgl now provides a WebGL backend for the core API.
• WebGPU bindings: @luma.gl/webgpu provides a new experimental WebGPU backend for the core API.

WebGL Support

luma.gl v9 drops support for WebGL 1 functionality.

• WebGL1 WebGL 1 support is dropped.
• GLSL 1.00 is no longer supported. GLSL shaders need to be ported to GLSL 3.00.
• headless-gl The Node.js WebGL 1 integration is no longer supported

On the upside this means that all features requiring WebGL 2 are now available and luma.gl also brings support for a range of new WebGL 2 extensions, see more below.

New module structure

Module	Impact	Description
@luma.gl/core	New API	The new portable luma.gl GPU API. Applications can run on both WebGPU and WebGL2 devices.
@luma.gl/engine	Light API updates	Classic luma.gl engine classes ()Model, AnimationLoop etc), which work portably on both WebGPU and WebGL 2.
@luma.gl/gltf	Renamed module	New module that exports the glTF classes (moved from @luma.gl/experimental).
@luma.gl/shadertools	Light API updates	The shader assembler API and the shader module library.
@luma.gl/webgl	WebGL backend	Optional "GPU backend module". Importing this module enables the application to create WebGL 2 Devices.
@luma.gl/webgpu	WebGPU backend	Experimental "GPU backend module". Importing this module enables the application to create WebGPU Devices.

General improvements

• TypeScript: All APIs now rigorously typed.
• ES modules - Modern ES module and CommonJS entry points for maximum interoperability.
• Website - New Docusaurus website with more embedded live examples and improved documentation.
• Debugging - SpectorJS integration. Shader debugger UI.

New features

@luma.gl/core

• Exports the new Device class is the entry point to the luma.gl API, used to create other GPU resources.

@luma.gl/engine

• NEW: Scenegraph classes: ModelNode, GroupNode, ScenegraphNode, moved from @luma.gl/experimental.
• NEW: ShaderInputs - Class that manages uniform buffers for a Model
• NEW: ShaderFactory - Creates and caches reusable Shader resources
• NEW: AnimationLoopTemplate - Helper class for writing cleaner demos and applications in TypeScript.
• New Computation - Class that manages a ComputePipeline similar to Model and Transform.

@luma.gl/gltf

• New module that exports the glTF classes (moved from @luma.gl/experimental).

@luma.gl/shadertools

• All shader modules now use uniform buffers.
• New ShaderAssembler class that provides a clean entry point to the shader module system.
• New CompilerMessage type and formatCompilerLog function for portable shader log handling.
• Shader assembly now supports WGSL and single shader source (compute or single vertex+fragment WGSL shaders)

@luma.gl/webgl

• The new bindings API now supports WebGL 2 Uniform Buffers.

WebGL 2 Extension support: WebGL is not dead yet! Browsers (Chrome in particular) are actively developing "extensions" for WebGL 2, and luma.gl is exposing support for many of the new WebGL extensions through the DeviceFeatures API.

New Device.features that improve application performance in WebGL:

• compilation-status-async-webgl: Asynchronous shader compilation and linking is used automatically by luma.gl and significantly speeds up applications that create many RenderPipelines.

New Device.features that enable additional color format support in WebGL:

• rgb9e5ufloat-renderable-webgl: rgb9e5ufloat is renderable.
• snorm8-renderable-webgl: r,rg,rgba8snorm are renderable.
• norm16-renderable-webgl: r,rg,rgba16norm are renderable.
• snorm16-renderable-webgl: r,rg,rgba16snorm are renderable.

New Device.features that expose new GPU parameters in WebGL:

• depth-clip-control: parameters.unclippedDepth - depth clipping can now be disabled.
• provoking-vertex-webgl: parameters.provokingVertex - controls which primitive vertex is used for flat shading.
• polygon-mode-webgl: parameters.polygonMode - enables wire frame rendering of polygons.
• polygon-mode-webgl: parameters.polygonOffsetLine - enables depth bias (polygon offset) for lines.
• shader-clip-cull-distance-webgl: parameters.clipCullDistance0-7, also see GLSL effects below.

New Device.features that enable new GLSL syntax

• shader-noperspective-interpolation-webgl: GLSL vertex outputs and fragment inputs may be declared with a noperspective interpolation qualifier.
• shader-conservative-depth-webgl: GLSL gl_FragDepth qualifiers depth_any depth_greater depth_less depth_unchanged can enable early depth test optimizations.
• shader-clip-cull-distance-webgl: Enables gl_ClipDistance[] / gl_CullDistance[].

Shared scene lighting examples

The experimental deck.gl GPU layers add optional camera/object motion capture and SceneShaderPassEffect, which connects shared HDR color, depth, normals and velocity to existing luma.gl shader-pass graphs. Riverfront fireflies, HDR night lighting, global illumination and light shafts demonstrate this shared infrastructure on WebGPU. FireflyLayer and the reusable firefly shader module also support WebGL2. Fireflies adds calm-water emitter reflections and adjustable bloom; Fireflies and HDR night lighting request extended-range, floating-point canvas output on HDR-capable displays, with an SDR presentation fallback.

Retained chart shapes

ANARI scenes support capped hexPrism marks and full or open partial torus meshes. The engine exports TorusGeometry over shared math.gl tessellation. The Chart Shapes playground preset and --shapes capture option use the same geometry and datum identities across raster and ray rendering.

Bounded ray image export

@luma.gl/anari adds exportRayTracingImage and iterateRayTracingImageTiles for streamed RGBA8 output. Full-image coordinates and explicit sampling-frame indices keep seeded ray paths stable across tiles. Clipped filter/history halos preserve progressive and denoised image seams; per-tile readback and cancellation keep export-owned allocations bounded.

Emissive chart lighting, masks and ring segments

Ray renderers add opt-in emitterSampling for explicit connections to emissive triangles and transformed analytic spheres. Scalar alpha masks now control ray color, shadows, picking and channels. RingGeometry and ANARI ring geometry add closed annular prisms and capped segments using shared math.gl tessellation. The Chart Lighting preset combines these features with retained selection identities and an emissive-lighting preview toggle.

GPU physics reliability and gameplay queries

Experimental rigid-body worlds add opt-in GPU rollback for incomplete or nonfinite steps, explicit capacity-growth reconstruction, a bounded sphere/static CCD envelope, parallel geometry queries and sphere casts, and persistent compound spherical sensors. Space Salvage uses simulation-step docking events; Rigid Body Lab includes a thin-wall CCD scenario. See the rigid-body reference for supported envelopes and remaining qualification work.

GPU physics mechanisms and debugging

The experimental rigid-body world adds bounded ordered distance, fixed, hinge and slider joints, capped velocity motors and limits, plus full GPU state capture/restore for debugging. The Rigid Body Lab includes three Mechanisms scenarios. An executable finite-shape pair matrix records response coverage separately from numerical qualification.

Dedicated GPU Graph package

@luma.gl/graph exposes GPUGraph at its root and graph-based processing through focused subpaths. GPU tables, dataframe/SQL, raster, spatial processing, trace analytics, volume operations, simulations, and graph algorithms now share one package. GPU data primitives live in @luma.gl/graph/gpu-data; immediate operations live in @luma.gl/graph/gpu-simple-graph.

Authored GPU physics sessions

The experimental physics module adds ScenegraphPhysicsSession for shared engine/glTF animation ownership, transactional recooking, captures and revision-safe GPU render publication. Component property pointers and shared joint edits use the same runtime. glTF adds live deformation cooking snapshots and explicit native state export. The Authored Scene Stress Lab exercises shared assets and repeated lifecycle operations. See scenegraph physics for the supported contracts and remaining qualification limits.

• Compute execution - Gpgpu WebGPU operations and graph compute passes now execute through Kernel, with bindings supplied per dispatch. Module-based operations assemble their WGSL before kernel creation, and geospatial FP64 passes own their uniform buffers explicitly.

• Table transform ownership - Import TableTransform from @luma.gl/engine/tables; graph retains the underlying table data APIs. WebGL extent now executes its existing reduction through RenderKernel instead of GPUVectorModel.

• WebGL operation execution - Gpgpu row transforms, gather, sequence, segmented-map, and extent use RenderKernel while preserving their existing shaders and operation semantics. BufferTransform and TextureTransform are owned by engine.

• Vector rendering ownership - GPUVectorModel, GPUVectorGeometry, and their binding and batching helpers live in engine. Gpgpu and graph no longer depend on these rendering APIs.

Graph expression functions and numeric casts

GPUExpressionOperation accepts abs, sqrt, pow, sin, cos, tan, exp, and log calls, plus explicit float32, sint32, and uint32 value conversions. Both graph implementations accept typed 32-bit numeric inputs and outputs. Existing evaluator APIs and physical-format conversion behavior are unchanged.

Plugin-owned shader hooks

ShaderPlugins can provide render hooks with GLSL/WGSL parameter signatures as well as inject behavior into them. Object forms separate stage and target; string shorthand supports language prefixes. See the ShaderPlugin guide and Shaders overview.

Aligned per-batch shader uniforms

GPUVectorModel.drawBatches() and Model.drawBatches() use separate aligned regions of one engine-owned WebGPU uniform buffer for each batch. Set picking offsets or other uniforms in onBatch without managing the batch buffer yourself. The model reuses its allocation across submitted calls and grows it when needed. Matching chunk boundaries are still required. See Per-batch uniforms for the submission and lifetime contract.