Skip to main content

What's New

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

  • 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/gpgpu workflows.
  • Table-driven planning - Experimental dataframes can plan queries from loaders.gl SQL expressions and feed batch-preserving GPU evaluation and rendering.

New Modules

  • @luma.gl/arrow (currently private) - Arrow adapters and renderers are being prepared for publication as a standalone module.

@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.

@luma.gl/gpgpu

  • 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/gpgpu/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/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/gpgpu/gpu-graph 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

  • 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/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/shadertools

  • 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.

@luma.gl/arrow (Private)

  • 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/gpgpu/gpu-data and @luma.gl/experimental/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/gpgpu/gpu-data and private tables from @luma.gl/experimental/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/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/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.

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.
  • Four new experimental modules - @luma.gl/text, @luma.gl/splats, @luma.gl/scene, and @luma.gl/experimental 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/gpgpu/gpu-data, independent of source adapters and rendering models.
  • Tables and models stay focused - Batch-preserving tables live in @luma.gl/experimental/gpu-tables; path and polygon models live in @luma.gl/experimental/models.
  • Renderers preserve what matters - @luma.gl/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/gpgpu - New module for lazy GPUDataEvaluator operations and chunk-preserving GPUVectorEvaluator transforms with CPU/WebGL/WebGPU backends.
  • @luma.gl/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/scene - Experimental forward, deferred, glTF, ray-marching, and ray-tracing scene rendering.
  • @luma.gl/experimental - GPU analytics, simulations, rendering techniques, and WebXR helpers, now published for direct use.

@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 - Format-owned .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/scene (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.
  • 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/scene/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/experimental/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/experimental/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/experimental/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/experimental/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.
  • 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.
  • 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/experimental/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.
  • 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/experimental/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/experimental/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/gpgpu 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/gpgpu/gpu-data, while GPURecordBatch and GPUTable provide reusable non-Arrow-specific GPU table ownership and batching from @luma.gl/experimental/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 - TableTransform, 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/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/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/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/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/experimental.
  • 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

@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/shadertools/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​

ModuleImpactDescription
@luma.gl/coreNew APIThe new portable luma.gl GPU API. Applications can run on both WebGPU and WebGL2 devices.
@luma.gl/engineLight API updatesClassic luma.gl engine classes ()Model, AnimationLoop etc), which work portably on both WebGPU and WebGL 2.
@luma.gl/gltfRenamed moduleNew module that exports the glTF classes (moved from @luma.gl/experimental).
@luma.gl/shadertoolsLight API updatesThe shader assembler API and the shader module library.
@luma.gl/webglWebGL backendOptional "GPU backend module". Importing this module enables the application to create WebGL 2 Devices.
@luma.gl/webgpuWebGPU backendExperimental "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[].