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 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 and 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 without discarding raw binary64 source precision.
  • 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

  • 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.
  • MSDF text fonts - @luma.gl/text can build or load prebuilt BMFont JSON MSDF atlases, including kerning and multi-page atlas metadata, through the same FontAtlas format used by generated bitmap and SDF atlases.
  • 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[].