Visualization and compute, at GPU scale.

Move massive datasets through GPU-resident pipelines. Filter, aggregate, project, and render without unnecessary CPU round trips. luma.gl is a modular, TypeScript-first framework for data-intensive visualization, portable GPU programming, and high-quality interactive rendering.

Choose the level you need: typed columnar data, GPU-resident dataframes, graph and raster analytics, reusable compute operations, GPU command graphs, rendering primitives, composable visual effects, or retained three-dimensional scenes.

Massive data. GPU-native compute. Interactive visualization. WebGPU and WebGL2.

The framework, module by module

GPU-native computationCompute, tables, and ArrowConnect GPU-resident columns, reusable operations, command graphs, filtering, aggregation, and large-scale visualization.@luma.gl/gpgpu · @luma.gl/tables@luma.gl/arrow · experimental / privateExperimental GPU analyticsDataframes, graphs, and rastersQuery GPU-resident tables, discover graph communities, and analyze cached scientific or geospatial raster tiles without unnecessary readback.luDF · luGraph · LuRaster@luma.gl/experimental · privatePortable GPU foundationCore, WebGPU, and WebGLOne application-facing device API for buffers, textures, pipelines, commands, and explicit GPU resource ownership.@luma.gl/core · @luma.gl/webgpu · @luma.gl/webglRendering engineModels, geometry, and animationBuild with models, GPU geometry, picking, instancing, render loops, and reusable animation mixing.@luma.gl/engineShader programmingReusable shaders and modulesCompose WGSL and GLSL with typed shader modules, injection hooks, lighting, and high-precision visualization tools.@luma.gl/shadertoolsVisual effectsComposable image processingCombine bloom, ambient occlusion, reflections, indirect light, volumetrics, motion blur, and temporal antialiasing.@luma.gl/effectsExperimental retained scenesANARI / Scene APIDescribe cameras, geometry, lights, and renderers; explore glTF and experimental OpenUSD import in the ANARI Playground.@luma.gl/anari · experimental / privateANARI-inspired; not an ANARI-conformant implementation.Assets and materialsglTF and physically based shadingRender portable PBR assets, native glTF extensions, skeletal and morph animations, and independently animated GPU-instanced crowds.@luma.gl/gltfExperimental neural renderingStreaming Gaussian splatsRender progressively streamed captured scenes with view-dependent harmonics, semantic picking and filtering, and bounded tile residency.@luma.gl/splats · experimental / private

WebGPU logo by W3C, used under the Creative Commons Attribution 4.0 International license. Standards marks identify related technologies and do not imply endorsement, certification, or conformance.

How to read the feature matrices

Status	Meaning
Available	Implemented in a published framework module, subject to documented device and browser requirements.
Evolving	Implemented in a published module, but integration, feature coverage, or the v10 API remains incomplete.
Experimental	Implemented in a private package or work-in-progress source module that is not yet published independently.
Opportunity	A useful extension or known limitation; do not interpret it as existing functionality.

WebGPU + WebGL2 means an application-facing path exists for both backends; exact shader, texture, or device-feature requirements can still differ. WebGPU identifies capabilities that require compute shaders, storage resources, or another WebGPU-specific implementation.

GPU-native data, compute, and visualization

GPU-resident tables and columnar memory

Feature	Status	Backend	Package	Details
Owned or borrowed GPU chunks	Evolving	WebGPU + WebGL2	@luma.gl/tables	Each GPUData object owns or borrows exactly one GPU buffer.
Typed GPU vectors	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUVector preserves an ordered list of independent data chunks.
Strided and child views	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUDataView describes views and struct children without duplicating GPU storage.
GPU record batches	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPURecordBatch groups aligned named columns without erasing batch identity.
Chunk-preserving tables	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUTable keeps streamed record batches instead of implicitly repacking them.
Constant values	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUConstant represents scalar or row-level constant inputs.
Explicit vector formats	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUVectorFormat describes stored bytes independently of shader value types.
GPU schemas	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUSchema and input schemas describe column names, formats, and bindings.
Shader binding synthesis	Evolving	WebGPU + WebGL2	@luma.gl/tables	Table-aware helpers connect compatible columns to vertex attributes or storage.
Buffer budget planning	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUTableBufferPlanner bounds bindings and respects available device limits.
Explicit packing	Evolving	WebGPU + WebGL2	@luma.gl/tables	Packing is an explicit operation, never a hidden side effect of streaming.
Ownership-aware destruction	Evolving	WebGPU + WebGL2	@luma.gl/tables	Aggregate destruction does not release buffers borrowed from their original owners.
Table-backed rendering	Evolving	WebGPU + WebGL2	@luma.gl/tables	GPUTableModel and table geometry connect columnar data directly to drawing.
Table transform feedback	Evolving	WebGL2	@luma.gl/tables	Apply supported table transforms through WebGL transform feedback.
Table compute dispatch	Evolving	WebGPU	@luma.gl/tables	Compose typed GPU table inputs and outputs through WebGPU compute.

See GPU table structure and lifecycle.

Apache Arrow, geometry, and text

Feature	Status	Backend	Package	Details
Apache Arrow uploads	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Convert supported Arrow tables, batches, vectors, and numeric columns into GPU data.
Original batch boundaries	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Preserve source chunks and batch ownership instead of flattening streamed input.
Renderer-independent Arrow analytics	Experimental	WebGPU	@luma.gl/arrow	Use makeGPUAnalyticsTableFromArrowTable() to create storage-backed analytical tables without renderer-specific shader metadata.
Arrow analytics validity masks	Experimental	WebGPU	@luma.gl/arrow	Preserve compatible Arrow nullability as explicit GPU-resident validity data and independent source batches.
Dictionary-backed analytics categories	Experimental	WebGPU	@luma.gl/arrow	Preserve CPU-owned UTF-8 dictionary labels and ordering metadata with signed or unsigned 32-bit GPU category indices.
Fixed-size vector columns	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Adapt supported fixed-size lists into typed GPU vectors and shader bindings.
Variable-length geometry	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Preserve offsets for paths, polygons, and other row-oriented variable-length data.
Normalized and HDR colors	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Adapt normalized colors and supported floating-point color inputs without promising universal zero-copy uploads.
Temporal and matrix metadata	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Carry supported timestamps, time origins, and matrix-oriented source metadata.
Arrow path rendering	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Draw Arrow-backed paths with portable attributes or WebGPU storage strategies.
Arrow polygon rendering	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Render supported polygon rows and preserve source-row identity for interaction.
Arrow text rendering	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Render supported string and dictionary-encoded label columns.
Source-row picking	Experimental	WebGPU + WebGL2	@luma.gl/arrow	Map visible geometry and labels back to their original Arrow rows.
GeoArrow tessellation	Experimental	WebGPU + WebGL2	@math.gl/geoarrow	Handle supported mixed geometry, polygon holes, coordinate layouts, and worker-assisted tessellation.
deck.gl Arrow layers	Experimental	WebGPU + WebGL2	@deck.gl-community/arrow-layers	Connect Arrow-backed paths, polygons, and text to compatible visualization layers.
Text and glyph atlases	Experimental	WebGPU + WebGL2	@luma.gl/text	Render bitmap, SDF, or MSDF glyphs with supported Unicode layout, kerning, and clipping.
Dictionary-compressed labels	Experimental	WebGPU	@luma.gl/text	Reuse repeated label values through WebGPU storage-based text strategies.
Animated path visualization	Evolving	WebGPU	@luma.gl/tables	Render GPU-resident trips and variable-length paths through storage-backed models.

See supported Arrow types and representations.

Portable data operations

Feature	Status	Backend	Package	Details
Portable data evaluation	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Evaluate supported expressions against the most appropriate available execution backend.
Lazy vector evaluation	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Build deferred vector expressions and resolve them when values are needed.
Arithmetic operations	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Apply addition, subtraction, multiplication, division, powers, and other supported operations.
Elementary math	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Evaluate supported sine, cosine, tangent, exponential, logarithm, and square-root functions.
Extent and vector reductions	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Calculate supported extents, dot products, lengths, and equality checks.
Gather and selection	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Gather indexed values, select elements, and generate index sequences.
Segmented operations	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Apply supported segmented mappings without losing source-vector structure.
Swizzle and interleave	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Reorder vector components and combine compatible streams.
Result caching	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Reuse evaluated values and clean up evaluator-owned temporary resources.
Dynamic backend loading	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Select compatible implementations without requiring every execution adapter up front.
Custom operation handlers	Available	CPU + WebGPU + WebGL2	@luma.gl/gpgpu	Extend evaluator behavior through explicit backend-specific operation handlers.

See GPU operations and custom evaluation.

GPU command graphs and execution

Feature	Status	Backend	Package	Details
GPU command-graph compilation	Experimental	WebGPU	@luma.gl/experimental	Compile explicit compute, rendering, and copy workflows into reusable encodings.
Resource dependency tracking	Experimental	WebGPU	@luma.gl/experimental	Order graph nodes around their declared resources and access relationships.
Caller-owned resources	Experimental	WebGPU	@luma.gl/experimental	Import external buffers, textures, and data views without transferring ownership.
Transient buffer reuse	Experimental	WebGPU	@luma.gl/experimental	Alias compatible graph-owned scratch allocations across nonoverlapping lifetimes.
Transient texture reuse	Experimental	WebGPU	@luma.gl/experimental	Reuse compatible intermediate textures inside the compiled graph.
Typed table integration	Experimental	WebGPU	@luma.gl/experimental	Import GPU vectors and chunk-aware data views into command-graph workflows.
Compute-to-render composition	Experimental	WebGPU	@luma.gl/experimental	Connect compute passes to rendering without materializing a CPU-side dataset.
Indirect draw commands	Experimental	WebGPU	@luma.gl/experimental	Generate caller-visible draw and indexed-draw arguments on the GPU.
Indirect compute dispatch	Experimental	WebGPU	@luma.gl/experimental	Produce bounded dispatch arguments for supported graph-driven workloads.
Explicit submission	Experimental	WebGPU	@luma.gl/experimental	Return encoded GPU work without hidden eager submissions.
Render targets and resolve	Experimental	WebGPU	@luma.gl/experimental	Describe render attachments and supported multisample resolve targets.
Execution inspection	Experimental	WebGPU	@luma.gl/experimental	Inspect graph nodes, resource lifetimes, CPU counters, and available GPU timestamps.
Small-result readback	Experimental	WebGPU	@luma.gl/experimental	Return bounded interaction results or aggregates rather than copying every source row.

See GPU command graphs.

Parallel algorithms and GPU-native queries

Feature	Status	Backend	Package	Details
Prefix scan	Experimental	WebGPU	@luma.gl/experimental	Perform inclusive, exclusive, and supported segmented prefix operations.
Stable compaction	Experimental	WebGPU	@luma.gl/experimental	Preserve original row order while removing records outside the current selection.
Indexed range generation	Experimental	WebGPU	@luma.gl/experimental	Build bounded index ranges for compatible visibility and selection workflows.
Chunked indexed scatter	Experimental	WebGPU	@luma.gl/experimental	GPUChunkedIndexedScatter routes selected source identifiers into bounded destination chunks and publishes GPU-resident counts, offsets, and indirect dispatches.
Boolean masks	Experimental	WebGPU	@luma.gl/experimental	Combine selection masks using supported boolean and difference operations.
GPU depth and key sorting	Experimental	WebGPU	@luma.gl/experimental	Sort supported unsigned keys and values through bitonic or radix implementations.
Chunk-preserving batch sort	Experimental	WebGPU	@luma.gl/experimental	Sort source batches without silently merging independently owned buffers.
Minimum and maximum reduction	Experimental	WebGPU	@luma.gl/experimental	Compute supported sums, extents, minima, and maxima on the GPU.
Uniform histograms	Experimental	WebGPU	@luma.gl/experimental	Bin supported numeric inputs into configurable uniform histogram buckets.
Irregular-edge histograms	Experimental	WebGPU	@luma.gl/experimental	Evaluate custom bin edges with supported GPU or literal edge buffers.
Grouped aggregates	Experimental	WebGPU	@luma.gl/experimental	Calculate supported group count, sum, minimum, maximum, and mean values.
Spatial grid binning	Experimental	WebGPU	@luma.gl/experimental	Assign compatible rows to bounded two-dimensional grid cells.
Spatial grid indexes	Experimental	WebGPU	@luma.gl/experimental	Index supported two-dimensional or three-dimensional points for spatial queries.
Grid aggregates	Experimental	WebGPU	@luma.gl/experimental	Produce supported spatial cell sums, minima, maxima, and means.
Hash indexes	Experimental	WebGPU	@luma.gl/experimental	Build and query supported bounded unsigned-key hash indexes.
Hash joins	Experimental	WebGPU	@luma.gl/experimental	Execute capacity-bounded sparse inner joins for supported unsigned keys.
Batch-preserving joins	Experimental	WebGPU	@luma.gl/experimental	Preserve independent left-side batch capacities and expose bounded overflow.
Spatial bounds queries	Experimental	WebGPU	@luma.gl/experimental	Query compatible point, radius, and bounds relationships in GPU spatial indexes.
Bounding-volume hierarchies	Experimental	WebGPU	@luma.gl/experimental	Build or refit fixed-topology hierarchies for supported spatial queries and object-level ray traversal.
Graph traversal	Experimental	WebGPU	@luma.gl/experimental	Traverse supported incoming, outgoing, or bidirectional hierarchical relationships.
Hierarchy layout	Experimental	WebGPU	@luma.gl/experimental	Derive stable hierarchical layout and ancestor-projection data.
Frustum visibility	Experimental	WebGPU	@luma.gl/experimental	Cull compatible GPU-resident scene records against the current viewing volume.
GPU scene draw generation	Experimental	WebGPU	@luma.gl/experimental	Group visible scene resources and generate bounded indirect rendering commands.
Async picking readback	Experimental	WebGPU	@luma.gl/experimental	Resolve supported selection and picking results through an asynchronous readback ring.
Two-dimensional FFT	Experimental	WebGPU	@luma.gl/experimental	Transform bounded complex fields for spectral simulation and related data workflows.

See GPU primitive documentation.

GPU dataframe analytics

Feature	Status	Backend	Package	Details
GPU-resident dataframes	Experimental	WebGPU	@luma.gl/experimental/ludf	LuDataFrame wraps typed GPU tables without taking implicit ownership of borrowed source buffers.
Immutable query plans	Experimental	WebGPU	@luma.gl/experimental/ludf	Build reusable filter, projection, aggregation, histogram, and ordering plans without eagerly dispatching GPU work.
Chunk-preserving source tables	Experimental	WebGPU	@luma.gl/experimental/ludf	Retain source record-batch boundaries, row identities, ownership, and compatible dictionary metadata.
Typed column expressions	Experimental	WebGPU	@luma.gl/experimental/ludf	Compose supported numeric, comparison, boolean, literal, and parameter expressions over named columns.
Reusable query parameters	Experimental	WebGPU	@luma.gl/experimental/ludf	Re-encode compatible parameterized filters and derived computations without rebuilding the source dataframe.
Null-aware filtering	Experimental	WebGPU	@luma.gl/experimental/ludf	Apply filter() predicates with explicit validity masks and supported null checks.
Column projection	Experimental	WebGPU	@luma.gl/experimental/ludf	Use select() to project ordered source columns without silently copying or repacking their GPU buffers.
Nullable derived columns	Experimental	WebGPU	@luma.gl/experimental/ludf	Use withColumn() to evaluate compatible GPU-resident arithmetic while propagating source validity.
Dense grouped aggregation	Experimental	WebGPU	@luma.gl/experimental/ludf	Use groupBy() with dense unsigned categories and dictionary or explicit cardinality; aggregate compatible floating-point values.
Global dataframe reductions	Experimental	WebGPU	@luma.gl/experimental/ludf	Use aggregate() for non-nullable row counts and validity-aware sums, extrema, and means.
Null-aware dataframe histograms	Experimental	WebGPU	@luma.gl/experimental/ludf	Use histogram() with compatible numeric columns, explicit domains, irregular edges, and source validity.
Batch-preserving dataframe inner joins	Experimental	WebGPU	@luma.gl/experimental/ludf	Use innerJoin() with unique-right unsigned keys, stable source-row identifiers, preserved batches, and explicit bounded overflow.
Source-aligned dataframe lookups	Experimental	WebGPU	@luma.gl/experimental/ludf	Use lookup() to publish compatible right-row identifiers and match masks without compacting or repacking left rows.
Stable dataframe sorting	Experimental	WebGPU	@luma.gl/experimental/ludf	Use sortBy() independently within each source batch with explicit numeric ordering and null/NaN placement.
Per-batch top-K selection	Experimental	WebGPU	@luma.gl/experimental/ludf	Use topK() to retain a bounded number of stably ordered rows per source batch without flattening independent inputs.
Graph-compiled query execution	Experimental	WebGPU	@luma.gl/experimental/ludf	Compile compatible dataframe plans into reusable GPUCommandGraph work while preserving explicit command submission.

The @luma.gl/experimental/ludf entry point is private and experimental; its graph-native operations are implemented, but non-unique, outer, or multi-key joins, temporal windows, and cross-batch global ordering remain opportunities. See GPU command graphs and reusable primitives.

GPU graph analytics and layout

Feature	Status	Backend	Package	Details
GPU-resident relationship graphs	Experimental	WebGPU	@luma.gl/experimental/lugraph	LuGraph borrows typed source and target columns without materializing a JavaScript edge list.
Chunk-preserving graph inputs	Experimental	WebGPU	@luma.gl/experimental/lugraph	Preserve independently owned source batches and caller-controlled graph resource lifetimes.
Compressed graph adjacency	Experimental	WebGPU	@luma.gl/experimental/lugraph	Build reusable forward and optional reverse compressed sparse row (CSR) adjacency for supported graph operations.
Directional vertex degree	Experimental	WebGPU	@luma.gl/experimental/lugraph	Compute supported incoming or outgoing degree values directly into GPU result columns.
Structural graph core numbers	Experimental	WebGPU	@luma.gl/experimental/lugraph	Find bounded simple weak-graph k-core values, convergence, and maximum degeneracy without counting loops or duplicate neighbors.
Breadth-first graph search	Experimental	WebGPU	@luma.gl/experimental/lugraph	Traverse bounded unweighted neighborhoods and generate deterministic predecessor or selection results.
Weighted single-source shortest paths	Experimental	WebGPU	@luma.gl/experimental/lugraph	Find least-cost routes over nonnegative single-precision edge weights with bounded relaxation and deterministic predecessors.
Weakly connected components	Experimental	WebGPU	@luma.gl/experimental/lugraph	Label supported connected groups within an explicit iteration budget and expose convergence information.
Deterministic graph communities	Experimental	WebGPU	@luma.gl/experimental/lugraph	LuGraphLabelPropagation assigns communities through bounded unweighted majority votes and deterministic label tie-breaking.
Weighted community modularity	Experimental	WebGPU	@luma.gl/experimental/lugraph	Score existing directed or undirected community partitions, preserving original edge weights and multiplicity without claiming Louvain optimization.
Local clustering coefficients	Experimental	WebGPU	@luma.gl/experimental/lugraph	Measure exact weak-neighborhood closure with distinct directed links or optional undirected triangle counts.
GPU PageRank	Experimental	WebGPU	@luma.gl/experimental/lugraph	Rank vertices using iterative GPU execution with supported dangling-node redistribution.
Six Graphalytics workload families	Experimental	WebGPU	@luma.gl/experimental/lugraph	Implement the Graph Data Council's six LDBC Graphalytics algorithms without claiming official validation, certification, or published benchmark results.
Exact force-directed layout	Experimental	WebGPU	@luma.gl/experimental/lugraph	Generate directly renderable graph positions through supported pairwise attraction and repulsion.
Spatially accelerated layout	Experimental	WebGPU	@luma.gl/experimental/lugraph	Approximate supported distant forces through a flat GPU spatial grid; this is not hierarchical Barnes-Hut.
Interactive graph exploration	Experimental	WebGPU	@luma.gl/experimental/lugraph	Coordinate layout, neighborhood highlighting, GPU picking, dragging, and pinned graph vertices.
deck.gl-native graph analytics	Experimental	WebGPU	@deck.gl-community/arrow-layers	Share supported GPU graph analytics and layout with deck.gl layers while preserving source batches and deck.gl-owned command submission.
CPU and GPU graph benchmarks	Experimental	WebGPU	@luma.gl/experimental/lugraph	Compare nine bounded reference workloads while separately reporting encoding, completion, setup, and accuracy costs.

Read the GPU-resident graph analytics reference, the interactive luGraph explorer, or the deck.gl graph explorer.

The Graph Data Council (GDC), formerly the Linked Data Benchmark Council, maintains the LDBC Graphalytics benchmark. Its formal reference datasets, correctness outputs, driver, and competition rules are separate from luGraph's local demonstrations. Structural core numbers and modularity scoring go beyond its six standardized workload families.

GPU raster and satellite analysis

Feature	Status	Backend	Package	Details
GPU-resident raster bands	Experimental	WebGPU	@luma.gl/experimental/luraster	GPURaster describes compatible raster dimensions, bands, metadata, coordinate systems, and ownership.
Application-owned raster tile sources	Experimental	WebGPU	@luma.gl/experimental/luraster	Validate caller-owned raster source, transport, decoding, and submission contracts before optional framework-managed upload and caching.
Source-provided raster overviews	Experimental	WebGPU	@luma.gl/experimental/luraster	Select compatible source windows, source-provided overview levels, coordinate metadata, and cancellable tile requests.
Bounded raster tile residency	Experimental	WebGPU	@luma.gl/experimental/luraster	GPURasterTileCache controls independently bounded decoded CPU tiles, uploaded GPU buffers, and compatible compiled graphs.
Deterministic raster tile eviction	Experimental	WebGPU	@luma.gl/experimental/luraster	Reuse cache hits and evict eligible unpinned raster tiles and graphs within explicit byte and entry-count budgets.
Cancellation-safe raster tile requests	Experimental	WebGPU	@luma.gl/experimental/luraster	Deduplicate compatible in-flight source requests without canceling other waiting callers.
Fence-protected raster tile leases	Experimental	WebGPU	@luma.gl/experimental/luraster	Pin raster tiles and reusable graphs until an application-owned post-submission completion fence resolves.
Compiled raster graph reuse	Experimental	WebGPU	@luma.gl/experimental/luraster	Reuse shape-compatible compiled analysis graphs while rebinding the current tile's borrowed GPU buffers.
Seam-safe cross-tile raster halos	Experimental	WebGPU	@luma.gl/experimental/luraster	Assemble real neighboring samples on the GPU, preserve cumulative receptive fields, and publish each half-open tile core exactly once.
Nodata-aware analytical overviews	Experimental	WebGPU	@luma.gl/experimental/luraster	Generate calibrated, valid-sample-weighted floating means with explicit sums, counts, masks, and odd-edge coverage.
Exact categorical raster overviews	Experimental	WebGPU	@luma.gl/experimental/luraster	Preserve native signed and unsigned class identifiers with deterministic nearest or valid-label mode policies.
Dataset-wide tiled raster statistics	Experimental	WebGPU	@luma.gl/experimental/luraster	Merge valid tile counts, calibrated sums, and extrema into explicitly initialized GPU-resident global accumulators.
Stable-domain global histogram replay	Experimental	WebGPU	@luma.gl/experimental/luraster	Replay every owned tile core against the finalized dataset-wide value domain before merging compatible bins.
GPU global percentiles and thresholds	Experimental	WebGPU	@luma.gl/experimental/luraster	Derive histogram-estimated global percentiles and consistent Otsu thresholds without downloading raster samples.
Overflow-aware global raster reductions	Experimental	WebGPU	@luma.gl/experimental/luraster	Saturate global counts and bins, expose sticky overflow flags, and invalidate unsafe percentile results.
Buffer and texture conversion	Experimental	WebGPU	@luma.gl/experimental/luraster	Convert supported raster bands between GPU buffers and textures without downloading source pixels.
Calibrated raster band math	Experimental	WebGPU	@luma.gl/experimental/luraster	Combine supported numeric bands while applying explicit scale, offset, validity, and nodata contracts.
GPU vegetation index	Experimental	WebGPU	@luma.gl/experimental/luraster	Compute normalized-difference vegetation index (NDVI) from compatible red and near-infrared bands.
Nodata-aware raster statistics	Experimental	WebGPU	@luma.gl/experimental/luraster	Calculate supported valid-pixel counts, sums, means, extrema, and scalar summaries.
Raster histograms	Experimental	WebGPU	@luma.gl/experimental/luraster	Derive valid-pixel distributions with supported explicit or GPU-inferred histogram domains.
Automatic Otsu thresholds	Experimental	WebGPU	@luma.gl/experimental/luraster	Select supported image thresholds from GPU-resident histogram distributions.
Raster threshold classification	Experimental	WebGPU	@luma.gl/experimental/luraster	Classify compatible pixel values against explicit thresholds without CPU-side source traversal.
Raster contrast adjustment	Experimental	WebGPU	@luma.gl/experimental/luraster	Apply supported contrast remapping while preserving raster validity and domain semantics.
Neighborhood convolution	Experimental	WebGPU	@luma.gl/experimental/luraster	Evaluate bounded kernels with supported raster borders and nodata-aware neighborhood policies.
Gaussian and box smoothing	Experimental	WebGPU	@luma.gl/experimental/luraster	Smooth compatible raster bands without implicitly filling invalid neighboring pixels.
Sobel and Scharr gradients	Experimental	WebGPU	@luma.gl/experimental/luraster	Evaluate supported directional derivatives and edge responses from GPU-resident raster neighborhoods.
Gradient magnitude and Laplacian	Experimental	WebGPU	@luma.gl/experimental/luraster	Derive gradient magnitude and compatible second-order edge information from valid raster pixels.
Binary and grayscale morphology	Experimental	WebGPU	@luma.gl/experimental/luraster	Process supported binary masks or grayscale raster bands with explicit structuring elements, borders, and nodata policies.
Raster dilation and erosion	Experimental	WebGPU	@luma.gl/experimental/luraster	Expand or contract compatible raster features through bounded square or Manhattan-diamond neighborhoods.
Raster opening and closing	Experimental	WebGPU	@luma.gl/experimental/luraster	Compose supported erosion/dilation sequences to remove small features or close compatible raster gaps.
Deterministic raster connected components	Experimental	WebGPU	@luma.gl/experimental/luraster	Assign sparse minimum-root foreground labels with explicit four/eight-neighbor connectivity while preserving valid background and nodata barriers.
Convergence-gated raster component labels	Experimental	WebGPU	@luma.gl/experimental/luraster	Publish GPU convergence and optional actual iteration counts; clear all labels and validity when a bounded graph cannot prove convergence.
Dense raster component identifiers	Experimental	WebGPU	@luma.gl/experimental/luraster	Compact converged sparse representatives into deterministic contiguous row-major region IDs without losing valid background.
Bounded raster region counts and overflow	Experimental	WebGPU	@luma.gl/experimental/luraster	Publish exact required and capacity-clamped component populations, invalidate truncated foreground, and expose per-execution overflow.
Marching-squares contours	Experimental	WebGPU	@luma.gl/experimental/luraster	Classify bounded raster cells and generate supported vector contour segments directly on the GPU.
Indirect contour overlays	Experimental	WebGPU	@luma.gl/experimental/luraster	Draw GPU-generated contour geometry without downloading or rebuilding every segment on the CPU.
Device-aware raster dispatch	Experimental	WebGPU	@luma.gl/experimental/luraster	Plan bounded dispatch stripes against the selected device's actual compute limits.

Start with the LuRaster concepts and execution guide, read the LuRaster API reference, or experiment with the Satellite Raster Lab.

Applied visualization, geospatial, and interaction

Feature	Status	Backend	Package	Details
Linked crossfiltering	Experimental	WebGPU	@luma.gl/experimental/luxfilter	Maintain linked scalar ranges and two-dimensional brushes over GPU-resident data.
Self-excluding histograms	Experimental	WebGPU	@luma.gl/experimental/luxfilter	Recalculate brush histograms without counting the active dimension against itself.
Stable selected row IDs	Experimental	WebGPU	@luma.gl/experimental/luxfilter	Preserve row identity for linked charts and renderable selection masks.
High-precision projection	Experimental	WebGPU	@luma.gl/experimental/luproj	Build local error-bounded projection patches from compatible CPU projection providers.
Binary64 coordinate transport	Experimental	WebGPU	@luma.gl/experimental/luproj	Transport 64-bit source coordinates as integer words and subtract a local origin.
Web Mercator support	Experimental	WebGPU	@luma.gl/experimental/luproj	Project supported geospatial coordinates while retaining local precision.
Geographic distance	Experimental	WebGPU	@luma.gl/experimental/geospatial	Evaluate supported Haversine, point, segment, and linestring distances.
Polygon containment	Experimental	WebGPU	@luma.gl/experimental/geospatial	Test supported polygon boundary and containment relationships.
Hierarchical trace views	Experimental	WebGPU	@luma.gl/experimental/lutrace	Filter, project, and render supported process, thread, and dependency hierarchies.
GPU-driven timeline picking	Experimental	WebGPU	@luma.gl/experimental/lutrace	Link trace visibility, indirect timeline draws, and GPU-aware picking.
Chunk-aware trace dependencies	Experimental	WebGPU	@luma.gl/experimental/lutrace	Route visible dependency endpoints across supported independent source-span batches.
Bounded dataset residency	Experimental	WebGPU	Application-owned example	Stream large source corpora with an application-managed bounded GPU-resident working set.
Portable path and polygon models	Evolving	WebGPU + WebGL2	@luma.gl/tables	Render table-backed paths and polygons using compatible attribute-driven strategies.
Storage-backed path models	Evolving	WebGPU	@luma.gl/tables	Process compatible path, polygon, and trip columns directly through storage buffers.

Try Million-Row Crossfilter, Billion-Point Spatial Atlas, GPU data analysis, and GPU sorting. Billion-scale figures describe source corpora; the GPU-resident working set remains bounded.

Portable GPU foundation and rendering

Devices, resources, and presentation

Feature	Status	Backend	Package	Details
Unified GPU device API	Available	WebGPU + WebGL2	@luma.gl/core	Access adapters, devices, resources, commands, features, and limits through one model.
Backend adapters	Available	WebGPU + WebGL2	@luma.gl/webgpu and @luma.gl/webgl	Select the native WebGPU adapter or the WebGL2 compatibility adapter.
Feature and limit discovery	Available	WebGPU + WebGL2	@luma.gl/core	Inspect device capabilities before enabling optional functionality.
GPU buffers	Available	WebGPU + WebGL2	@luma.gl/core	Create vertex, index, uniform, and compatible readback buffers.
GPU storage buffers	Available	WebGPU	@luma.gl/webgpu	Bind supported read-only or writable storage buffers to WebGPU shaders.
Typed texture resources	Available	WebGPU + WebGL2	@luma.gl/core	Allocate compatible 2D, array, cubemap, and three-dimensional texture resources.
Texture views and samplers	Available	WebGPU + WebGL2	@luma.gl/core	Describe texture views, filtering, wrapping, and supported anisotropic sampling.
Compressed textures	Evolving	WebGPU + WebGL2	@luma.gl/core	Use BC, ETC2, or ASTC formats when supported by the selected device.
Native external textures	Available	WebGPU	@luma.gl/webgpu	Bind compatible browser-owned external image resources without a WebGL fallback.
Video texture uploads	Available	WebGPU + WebGL2	@luma.gl/engine	Update compatible GPU textures from supported browser video sources.
Framebuffers and attachments	Available	WebGPU + WebGL2	@luma.gl/core	Manage color, depth, stencil, and supported multiple-render-target attachments.
Render pipelines	Available	WebGPU + WebGL2	@luma.gl/core	Configure shader bindings, vertex layouts, depth, stencil, and blend state.
Compute shaders and passes	Available	WebGPU	@luma.gl/webgpu	Encode compute pipelines, dispatches, and WebGPU storage-resource workflows.
Indexed and indirect draws	Evolving	WebGPU + WebGL2	@luma.gl/core	Indexed drawing is portable; GPU-generated indirect drawing requires WebGPU.
Render bundles	Evolving	WebGPU	@luma.gl/webgpu	Reuse compatible recorded render commands.
Transform feedback	Available	WebGL2	@luma.gl/webgl	Support established WebGL transform-feedback workflows.
Occlusion and timing queries	Evolving	WebGPU + WebGL2	@luma.gl/core	Use supported query types only when the selected backend advertises them.
Multisample resolve	Available	WebGPU	@luma.gl/webgpu	Resolve supported multisampled render attachments.
Canvas sizing and pixel ratio	Available	WebGPU + WebGL2	@luma.gl/core	Manage browser canvas configuration, resize, and high-DPI presentation.
Extended color and HDR	Evolving	WebGPU	@luma.gl/webgpu	Present compatible floating-point or display-P3 output when browser and display support it.

Engine, geometry, and interaction

Feature	Status	Backend	Package	Details
Model and material lifecycle	Available	WebGPU + WebGL2	@luma.gl/engine	Compose shader inputs, geometry, materials, pipelines, and draw calls.
CPU and GPU geometry	Available	WebGPU + WebGL2	@luma.gl/engine	Connect source geometry to explicit GPU buffers and shader-facing layouts.
Built-in geometry primitives	Available	WebGPU + WebGL2	@luma.gl/engine	Generate supported cubes, planes, spheres, cylinders, cones, and related meshes.
Indexed and instanced rendering	Available	WebGPU + WebGL2	@luma.gl/engine	Reuse geometry across indexed meshes and compatible instance batches.
Scenegraph transforms	Available	WebGPU + WebGL2	@luma.gl/engine	Organize supported scene nodes, groups, transforms, and bounding information.
Dynamic buffers and textures	Available	WebGPU + WebGL2	@luma.gl/engine	Resize and update managed application resources as data changes.
Integer-index picking	Evolving	WebGPU + WebGL2	@luma.gl/engine	Use exact integer picking when the selected backend supports integer render targets.
Color picking fallback	Available	WebGPU + WebGL2	@luma.gl/engine	Encode supported object and batch identifiers into compatible color targets.
Orbit camera controls	Available	WebGPU + WebGL2	@luma.gl/engine	Orbit, zoom, constrain, and automatically rotate an interactive scene camera.
Animation loop and timeline	Available	WebGPU + WebGL2	@luma.gl/engine	Coordinate rendering, frame state, keyframes, and application updates.
Animation interpolation	Available	WebGPU + WebGL2	@luma.gl/engine	Evaluate step, linear, cubic-spline, and supported quaternion interpolation.
Animation clip mixing	Available	WebGPU + WebGL2	@luma.gl/engine	Play, pause, scrub, loop, weight, and crossfade compatible animation actions.
Fullscreen drawing	Available	WebGPU + WebGL2	@luma.gl/engine	Build visualization overlays and fullscreen passes from reusable clip-space geometry.

Shader assembly and numerical precision

Feature	Status	Backend	Package	Details
WGSL shader assembly	Available	WebGPU	@luma.gl/shadertools	Compose supported WebGPU shader source and typed application bindings.
GLSL shader assembly	Available	WebGL2	@luma.gl/shadertools	Compose supported WebGL vertex and fragment shaders.
Typed shader modules	Available	WebGPU + WebGL2	@luma.gl/shadertools	Reuse shader modules with explicit source, dependencies, and uniform types.
Shader hooks and injections	Available	WebGPU + WebGL2	@luma.gl/shadertools	Extend supported applications through composable shader hooks and source injections.
Shader plugins	Available	WebGPU + WebGL2	@luma.gl/shadertools	Order reusable shader plugins and validate supported varying relationships.
Uniform and binding reflection	Available	WebGPU + WebGL2	@luma.gl/shadertools	Coordinate application uniforms, supported bindings, and shader layouts.
Color and picking modules	Available	WebGPU + WebGL2	@luma.gl/shadertools	Reuse compatible color transforms, clipping, filtering, and picking logic.
Lighting and PBR shaders	Available	WebGPU + WebGL2	@luma.gl/shadertools	Compose supported Lambert, Phong, physically based shading, and image-based lighting.
Joint-driven skinning	Available	WebGPU + WebGL2	@luma.gl/shadertools	Skin compatible glTF and retained-scene geometry using shared WGSL and GLSL joint-palette modules.
Geometric specular antialiasing	Available	WebGPU + WebGL2	@luma.gl/shadertools	Stabilize supported base and clearcoat highlights through derivative-based geometric filtering.
Split-float high precision	Evolving	WebGPU + WebGL2	@luma.gl/shadertools	Emulate selected higher-precision arithmetic without claiming native WGSL 64-bit floats.
GLSL fp64 transcendentals	Available	WebGL2	@luma.gl/shadertools	Use the supported GLSL high-precision transcendental library.
64-bit cell identifiers	Evolving	WebGPU	@luma.gl/shadertools	Represent supported geospatial cell identifiers as paired unsigned words.

Lighting, visual effects, and transparency

Feature	Status	Backend	Package	Details
Ordered image-effect pipelines	Available	WebGPU + WebGL2	@luma.gl/effects	Chain compatible shader passes and explicitly named intermediate targets.
HDR bloom	Available	WebGPU + WebGL2	@luma.gl/effects	Apply supported floating-point highlight extraction and multiresolution blur.
Photographic lens effects	Available	WebGPU + WebGL2	@luma.gl/effects	Add optional chromatic ghosts, radial halos, aperture starbursts, and compatible lens-dirt masks.
Fused WebGPU bloom	Available	WebGPU	@luma.gl/effects	Fuse compatible bloom downsampling and filtering work while retaining a portable render-pass fallback.
Fourier aperture convolution	Experimental	WebGPU	@luma.gl/experimental	Convolve compatible highlight fields against a supplied aperture through independent RGB GPU Fourier transforms.
Color and image filters	Available	WebGPU + WebGL2	@luma.gl/effects	Adjust brightness, contrast, hue, saturation, noise, sepia, and vignette.
Depth-of-field passes	Available	WebGPU + WebGL2	@luma.gl/effects	Apply supported depth-aware focus and image-space blur.
Temporal antialiasing	Available	WebGPU	@luma.gl/effects	Reproject compatible camera, color, and depth history with jitter and neighborhood-clamped accumulation.
Motion blur	Available	WebGPU	@luma.gl/effects	Use compatible velocity and frame data for image-space motion blur.
Screen-space ambient occlusion	Available	WebGPU	@luma.gl/effects	Compute supported SSAO and GTAO visibility from scene attachments.
Screen-space reflections	Available	WebGPU	@luma.gl/effects	Trace and stabilize supported SSR reflections using depth and frame history.
Screen-space indirect lighting	Available	WebGPU	@luma.gl/effects	Approximate supported diffuse bounce lighting with temporally filtered SSGI.
Adaptive exposure	Available	WebGPU	@luma.gl/effects	Reduce scene luminance on the GPU and update compatible HDR exposure.
Volumetric lighting and fog	Available	WebGPU	@luma.gl/effects	Render supported fog, participating media, and clustered light scattering.
Depth-aware outlines	Available	WebGPU	@luma.gl/effects	Highlight compatible object boundaries using auxiliary scene attachments.
Deferred G-buffer rendering	Experimental	WebGPU	@luma.gl/experimental	Compose supported surface attachments and deferred lighting passes.
Compute-clustered lights	Experimental	WebGPU	@luma.gl/experimental	Partition dense point-light workloads into compatible screen-space clusters.
Cascaded directional shadows	Experimental	WebGPU	@luma.gl/experimental	Render supported cascaded shadow maps for directional lights.
Spot and point shadows	Experimental	WebGPU	@luma.gl/experimental	Render supported spot shadows and six-face omnidirectional point shadows.
Soft and contact shadows	Experimental	WebGPU	@luma.gl/experimental	Apply supported blocker search, filtering, and screen-space contact shadows.
Exact order-independent transparency	Experimental	WebGPU	@luma.gl/experimental	Use a bounded A-buffer on devices with sufficient fragment storage resources.
Weighted-blended transparency	Experimental	WebGPU + WebGL2	@luma.gl/experimental	Approximate order-independent transparency when required float attachments are blendable.
Spectral optical caustics	Experimental	WebGPU	@luma.gl/experimental	Compute supported wavelength-separated lighting through a bounded refractor.

Try Lightstorm Megacity, Illumination Lab, Prism Cathedral, and Effects: Image Processing.

glTF, PBR, and standards-driven animation

Feature	Status	Backend	Package	Details
glTF and GLB scene loading	Available	WebGPU + WebGL2	@luma.gl/gltf	Load supported scene hierarchies, indexed meshes, cameras, materials, and animation data.
Draco mesh compression	Available	WebGPU + WebGL2	@luma.gl/gltf	Decode supported Draco-compressed meshes through the shared asset loader.
Meshopt compression	Available	WebGPU + WebGL2	@luma.gl/gltf	Decode supported Meshopt-compressed primitives during asset loading.
Quantized geometry	Available	WebGPU + WebGL2	@luma.gl/gltf	Expand supported quantized accessors before GPU geometry creation.
Basis Universal and KTX2	Evolving	WebGPU + WebGL2	@luma.gl/gltf	Decode supported compressed textures when the runtime and selected device permit it.
Metallic-roughness materials	Available	WebGPU + WebGL2	@luma.gl/gltf	Apply supported PBR textures, material factors, normals, and emissive surfaces.
Authored PBR texture slots	Available	WebGPU + WebGL2	@luma.gl/gltf	Preserve 21 supported material texture slots, their color spaces, sampler semantics, and authored transforms.
Specular and index of refraction	Available	WebGPU + WebGL2	@luma.gl/gltf	Apply authored glTF specular factors, specular textures, and physical index-of-refraction parameters.
Clearcoat and sheen	Available	WebGPU + WebGL2	@luma.gl/gltf	Render authored secondary clearcoat and cloth-like sheen material lobes through shared PBR shaders.
Iridescence and anisotropy	Available	WebGPU + WebGL2	@luma.gl/gltf	Render thin-film interference and directional anisotropic highlights through the shared PBR shader.
Transmission and volume	Available	WebGPU + WebGL2	@luma.gl/gltf	Shared scene renderers refract captured scene color; the standalone glTF rendering fallback remains approximate.
Chromatic dispersion	Available	WebGPU + WebGL2	@luma.gl/gltf	Separate visible wavelengths when physical transmission uses authored KHR_materials_dispersion.
Authored bump maps	Available	WebGPU + WebGL2	@luma.gl/gltf	Apply supported EXT_materials_bump height textures through the canonical physically based shader.
Diffuse transmission	Available	WebGPU + WebGL2	@luma.gl/gltf	Evaluate supported KHR_materials_diffuse_transmission factors and independently authored color textures.
Approximate volume scattering	Evolving	WebGPU + WebGL2	@luma.gl/gltf	Approximate the unratified KHR_materials_volume_scatter draft per surface without claiming random-walk transport.
Authored UV transforms	Available	WebGPU + WebGL2	@luma.gl/gltf	Preserve supported texture offset, rotation, and scale semantics.
Authored normals and tangents	Evolving	WebGPU + WebGL2	@luma.gl/gltf	Preserve supported vertex attributes; complete renderer-to-renderer fidelity varies.
Punctual-light parsing	Available	WebGPU + WebGL2	@luma.gl/gltf	Parse supported authored directional, point, and spot light definitions.
Generated image-based lighting	Experimental	WebGPU + WebGL2	@luma.gl/experimental	Generate compatible GGX-prefiltered specular maps, diffuse irradiance, and a split-sum BRDF lookup texture.
Shared animation clips	Available	WebGPU + WebGL2	@luma.gl/engine	Play, blend, crossfade, loop, and interpolate compatible imported tracks.
Typed animation pointers	Available	WebGPU + WebGL2	@luma.gl/gltf	Animate supported KHR_animation_pointer transforms, morph weights, visibility, materials, UVs, cameras, and lights.
Existing joint-driven skinning	Available	WebGPU + WebGL2	@luma.gl/shadertools	Reuse established skin shaders and automatically bind mesh-local glTF joint palettes.
Morph-target animation	Available	WebGPU + WebGL2	@luma.gl/gltf	Animate POSITION, NORMAL, and TANGENT morph targets through shared glTF, engine, and retained-scene paths.
Independently animated GPU crowds	Available	WebGPU + WebGL2	@luma.gl/gltf	createGLTFAnimatedCrowd() batches independently animated actors into one instanced draw per compatible source primitive.
Actor-specific crowd playback	Available	WebGPU + WebGL2	@luma.gl/gltf	Give each actor an independent clip, phase, speed, crossfade, and root transform while reusing shared source geometry.
Backend-specific crowd joint palettes	Available	WebGPU + WebGL2	@luma.gl/gltf	Access actor-specific skin palettes through WebGPU storage buffers or WebGL2 floating-point palette textures.
Native material variants	Available	WebGPU + WebGL2	@luma.gl/gltf	Select compatible authored KHR_materials_variants without replacing retained scene nodes.
Imported GPU instancing	Available	WebGPU + WebGL2	@luma.gl/gltf	Render authored EXT_mesh_gpu_instancing transforms through one real instanced draw per source primitive.
Imported node visibility	Available	WebGPU + WebGL2	@luma.gl/gltf	Apply authored KHR_node_visibility recursively to compatible descendants and punctual lights.
Source-faithful glTF and GLB export	Available	WebGPU + WebGL2	@luma.gl/gltf	Preserve supported hierarchy, geometry, accessors, images, skins, morph targets, animation, and extensions.
Screen-space crowd level of detail	Available	WebGPU + WebGL2	@luma.gl/gltf	Classify independently animated actors into authored or automatically decimated mesh-detail buckets, cull offscreen/tiny actors, and submit one instanced draw per occupied source-primitive/detail group. GPU-driven indirect selection remains future work.
Global animated-crowd vertex budgets	Available	WebGPU + WebGL2	@luma.gl/gltf	Limit submitted index references across all visible actor primitives, deterministically demote farther characters first, and report unsatisfied limits without hiding actors.

The ownership boundaries are intentional: @luma.gl/gltf interprets assets, @luma.gl/shadertools owns shared shading, @luma.gl/engine owns generic animation, @luma.gl/experimental explores higher-level rendering, and @luma.gl/anari orchestrates retained scene objects. Reuse each capability at its existing layer rather than creating parallel implementations.

See the glTF extension support matrix, native glTF runtime behavior, materials and texture slots, and source-faithful asset interchange, or explore independently animated glTF crowds.

Declarative scenes and asset integration

Feature	Status	Backend	Package	Details
ANARI-inspired retained objects	Experimental	WebGPU + WebGL2	@luma.gl/anari	Manage retained cameras, geometry, materials, lights, surfaces, instances, and worlds.
Perspective and orthographic cameras	Experimental	WebGPU + WebGL2	@luma.gl/anari	Configure supported camera models through the retained scene API.
Shared geometry instances	Experimental	WebGPU + WebGL2	@luma.gl/anari	Reuse compatible surfaces, groups, and geometry across retained instances.
Physically based scene materials	Experimental	WebGPU + WebGL2	@luma.gl/anari	Describe supported matte and physically based material parameters.
Scene light types	Experimental	WebGPU + WebGL2	@luma.gl/anari	Configure supported ambient, directional, point, and spot lights.
Switchable scene renderers	Experimental	WebGPU + WebGL2	@luma.gl/anari	Select supported forward or debug views; deferred and ray-tracing renderers require WebGPU.
Retained animation playback	Experimental	WebGPU + WebGL2	@luma.gl/anari	Play supported transform, material, texture-coordinate, skeletal, and morph-target animations.
Editable JSON scenes	Experimental	WebGPU + WebGL2	@luma.gl/anari	Inspect and edit supported retained scene descriptions interactively.
Experimental OpenUSD import	Experimental	WebGPU + WebGL2	@luma.gl/anari	The ANARI Playground imports supported ASCII USD and ASCII-root USDZ examples.
Scene-level skeletal animation	Experimental	WebGPU + WebGL2	@luma.gl/anari	Automatically evaluate imported skeletal clips and bind independent mesh-local joint palettes.
Retained morph-target animation	Experimental	WebGPU + WebGL2	@luma.gl/anari	Update supported POSITION, NORMAL, and TANGENT morph targets through retained scene playback.
Camera-reprojected scene antialiasing	Experimental	WebGPU	@luma.gl/anari	Stabilize compatible forward and deferred raster views with persistent camera-reprojected history.

This is an ANARI-inspired proof of concept, not a claim of complete standards conformance. Explore the ANARI Playground, or read about retained animation and switchable scene renderers.

GPU ray tracing and progressive rendering

Feature	Status	Backend	Package	Details
WebGPU software ray tracing	Experimental	WebGPU	@luma.gl/experimental	Trace supported retained scene geometry through caller-owned GPU command graphs without hardware ray-tracing extensions.
Retained ANARI ray tracing	Experimental	WebGPU	@luma.gl/anari	Select the raytrace renderer for compatible retained cameras, analytic spheres, meshes, and direct lights.
Morton-sorted scene acceleration	Experimental	WebGPU	@luma.gl/experimental	Build GPU Morton-sorted top-level acceleration structures (TLAS) with bounding-volume hierarchies (BVH) over compatible objects and instances.
Transform-aware acceleration refits	Experimental	WebGPU	@luma.gl/experimental	Reuse retained leaf permutations and refit compatible scene hierarchies when only instance transforms change.
Triangle-level mesh acceleration	Experimental	WebGPU	@luma.gl/experimental	Build and reuse GPU Morton-sorted bottom-level acceleration structures (BLAS) over supported mesh triangles.
Nearest-hit and shadow traversal	Experimental	WebGPU	@luma.gl/experimental	Traverse the scene hierarchy for primary intersections and bounded early-exit direct-light shadow rays.
Progressive ray accumulation	Experimental	WebGPU	@luma.gl/anari	Accumulate compatible direct-light samples across unchanged frames; this does not imply multi-bounce transport.
Adaptive ray-tracing resolution	Experimental	WebGPU	@luma.gl/anari	Adjust internal resolution, sampled-pixel phases, and rotating shadow work toward an explicit frame budget.
Ray-traced temporal reprojection	Experimental	WebGPU	@luma.gl/anari	Reuse compatible retained history and reject invalid camera, depth, normal, or scene changes.
HDR ray-tracing presentation	Experimental	WebGPU	@luma.gl/anari	Resolve and upsample supported floating-point ray-traced output to compatible presentation targets.
Advanced acceleration topology	Opportunity	WebGPU	@luma.gl/experimental	Extend existing Morton-sorted TLAS/BLAS hierarchies with SAH/Karras topology and richer traversal diagnostics.
Multi-bounce path tracing	Opportunity	WebGPU	@luma.gl/experimental	Extend existing direct-light ray tracing with indirect transport, physically based bounces, and denoising.
Ray-traced animated materials	Opportunity	WebGPU	@luma.gl/anari	Extend supported ray tracing toward textured PBR, transmission, skeletal deformation, and animated morph targets.

Read the ANARI ray-tracing renderer and the retained rendering architecture.

Gaussian splats and captured-scene rendering

Feature	Status	Backend	Package	Details
Typed Gaussian splat columns	Experimental	WebGPU + WebGL2	@luma.gl/splats	Represent position, scale, orientation, opacity, supported colors, and row identity.
Anisotropic covariance	Experimental	WebGPU + WebGL2	@luma.gl/splats	Project compatible anisotropic splats rather than reducing them to fixed point sprites.
Portable splat rendering	Experimental	WebGPU + WebGL2	@luma.gl/splats	Select WebGPU storage or globally ordered WebGL2 attribute-backed rendering without mutating caller-owned source data.
Globally sorted WebGL splat runs	Experimental	WebGL2	@luma.gl/splats	Composite every visible row exactly once across interleaved source batches using independently owned reordered attributes.
Progressive batch streaming	Experimental	WebGPU + WebGL2	@luma.gl/splats	Preserve independently owned streamed source batches.
GPU projection and culling	Experimental	WebGPU	@luma.gl/splats	Project visible splats and apply supported frustum, opacity, and size thresholds.
GPU depth sorting	Experimental	WebGPU	@luma.gl/splats	Execute supported command-graph-native global depth ordering.
Indirect splat drawing	Experimental	WebGPU	@luma.gl/splats	Generate one bounded indirect draw from the visible GPU-resident set.
Segmented paged splat rendering	Experimental	WebGPU	@luma.gl/splats	Project sparse original source rows into bounded GPU segments and draw them in one globally sorted cross-page depth order.
Spark-calibrated RAD reconstruction	Experimental	WebGPU	@luma.gl/splats	Project analytic Gaussian covariance with area-preserving antialiasing and authored nonlinear coarse-level opacity.
HDR spherical-harmonic DC	Experimental	WebGPU	@luma.gl/splats	Preserve supported floating-point source radiance on compatible presentation targets.
Standard-dynamic-range fallback	Experimental	WebGPU + WebGL2	@luma.gl/splats	Apply supported display mapping when extended HDR output is unavailable.
View-dependent harmonics	Experimental	WebGPU + WebGL2	@luma.gl/splats	Evaluate degree-one through degree-three spherical harmonics in reusable WebGPU graphs and unclamped Float32 WebGL2 attributes.
Unclamped WebGL harmonic radiance	Experimental	WebGL2	@luma.gl/splats	Preserve directional highlights and negative radiance from byte-backed source colors in stable Float32 vertex attributes.
Dedicated splat picking	Experimental	WebGPU + WebGL2	@luma.gl/splats	Resolve stable batch, row, and semantic identities through graph-native integer picking or portable GPU passes.
Semantic splat filtering	Experimental	WebGPU + WebGL2	@luma.gl/splats	Apply GPU-native graph class selection or portable class/predicate filtering without repacking batches.
Dynamic splat updates	Experimental	WebGPU + WebGL2	@luma.gl/splats	Update prepared source rows in place while preserving GPU buffers and reusable command graphs.
Mixed mesh and splat rendering	Experimental	WebGPU + WebGL2	@luma.gl/splats	Composite depth-tested Gaussian splats between caller-owned opaque and transparent meshes.
Bounded splat residency	Experimental	WebGPU + WebGL2	@luma.gl/splats	Reserve upload capacity and evict prioritized, unpinned source tiles within byte, row, and chunk budgets.
Hierarchical splat refinement	Experimental	WebGPU + WebGL2	@luma.gl/splats	Select frustum-culled, foveated source-page frontiers with parent fallback and bounded asynchronous loading.
Row-accurate RAD hierarchy	Experimental	WebGPU + WebGL2	@luma.gl/splats	Prioritize authored child rows with best-first angular refinement, coarse-node coverage, parent fallback, and sparse source-row identity.
Khronos glTF splat attributes	Experimental	WebGPU + WebGL2	@luma.gl/splats	Render decoded KHR_gaussian_splatting attributes, feature IDs, and externally decoded SPZ v2 content.
Camera-driven RAD page sources	Experimental	WebGPU + WebGL2	@luma.gl/arrow and @luma.gl/splats	Demand, prioritize, cancel, and evict independently range-fetched source pages while preserving authored global row identities.
Background RAD page decoding	Experimental	WebGPU	Gaussian Splat Viewer	Decode transferable RAD ranges in bounded module workers; preserve Arrow ownership and automatically fall back when worker startup, CSP, or dynamic imports fail.

Higher-order harmonics, semantic filtering, dedicated picking, and mixed-scene composition are available through the portable SplatRenderer and the WebGPU-only GPUSplatGraphRenderer. The graph renderer preserves its high-throughput GPU depth sorting and indirect-drawing path.

View captured scenes in the Gaussian Splat Viewer and review completed and planned work in the Gaussian splat implementation roadmap.

Simulation and immersive presentation

Feature	Status	Backend	Package	Details
Three-dimensional fire and smoke	Experimental	WebGPU	@luma.gl/experimental	Evolve three-dimensional fire velocity, pressure, fuel, heat, smoke, and solid obstacles.
Spectral ocean simulation	Experimental	WebGPU	@luma.gl/experimental	Generate GPU Fourier-displaced waves, normals, and compression-derived whitecaps.
Two-dimensional MLS-MPM liquids	Experimental	WebGPU	@luma.gl/experimental	Simulate supported two-dimensional MLS-MPM particle and grid transfers.
Full three-dimensional particle liquids	Opportunity	WebGPU	@luma.gl/experimental	The existing liquid solver is two-dimensional rather than a general three-dimensional fluid system.
Cloth and soft-body simulation	Opportunity	WebGPU	@luma.gl/experimental	Deformable-body simulation is not part of the current framework.
WebXR frame integration	Experimental	WebGPU + WebGL2	@luma.gl/experimental	Drive compatible immersive frames from WebXR session scheduling.
Immersive AR and VR	Experimental	WebGPU + WebGL2	@luma.gl/experimental	Render supported per-eye immersive AR and VR views with explicit viewports.
Native WebGPU XR layers	Experimental	WebGPU	@luma.gl/experimental	Use projection layers only when the browser, XR session, and adapter support them.
Raw AR camera textures	Experimental	WebGL2	@luma.gl/experimental	Bind compatible raw-camera access through the WebGL immersive path.
Advanced XR spatial features	Opportunity	WebGPU + WebGL2	@luma.gl/experimental	Hit testing, anchors, hand tracking, depth sensing, and WebGPU camera textures remain absent.

Try Volumetric Fire Forge, Tempest Ocean, and Fluid Foundry.

Opportunities for data-intensive visualization and compute

These opportunities follow luma.gl's core focus: massive data, GPU-native computation, practical rendering infrastructure, and interactive visualization. They describe useful directions, not commitments to release dates.

Feature	Status	Backend	Package	Details
Unified out-of-core dataset streaming	Opportunity	WebGPU + WebGL2	@luma.gl/tables and @luma.gl/arrow	Extend existing splat and raster residency managers into shared Arrow/columnar streaming, coordinated priorities, and reusable backpressure.
Unified compute scheduling	Opportunity	WebGPU	@luma.gl/gpgpu and @luma.gl/experimental	Lower compatible lazy expressions into reusable command graphs while preserving portable fallbacks.
Kernel fusion	Opportunity	WebGPU	@luma.gl/gpgpu	Reduce intermediate allocations by fusing compatible columnar compute operations.
Advanced dataframe analytics	Opportunity	WebGPU	@luma.gl/experimental/ludf	Extend existing grouped analytics, joins, lookups, sorting, and top-K toward non-unique/outer joins, temporal windows, and incremental updates.
GPU vector similarity search	Opportunity	WebGPU	@luma.gl/experimental	Add embedding similarity, nearest-neighbor indexes, top-K distance queries, and compatible metadata filtering.
Cross-tile contour stitching and combined raster pipelines	Opportunity	WebGPU	@luma.gl/experimental/luraster	Extend implemented halos, generated overviews, and global replay toward stitched contour topology and combined cross-tile neighborhood/overview analysis.
Advanced GPU graph analytics	Opportunity	WebGPU	@luma.gl/experimental/lugraph	Build on existing core numbers, weighted shortest paths, local clustering, community modularity scoring, all six Graphalytics families, and layouts with Louvain/Leiden partition optimization and dynamic graph updates.
Hierarchical spatial indexes	Opportunity	WebGPU	@luma.gl/experimental/geospatial	Extend supported spatial queries toward tiled indexing, nearest neighbors, and spatial joins.
High-precision geospatial pipelines	Opportunity	WebGPU	@luma.gl/experimental/luproj	Broaden projection, local-origin precision, coordinate systems, and streamed map-scale workflows.
Cross-view GPU-native provenance	Opportunity	WebGPU	@luma.gl/experimental/luxfilter	Extend existing linked filters and histograms with shared picking, provenance, and selection across more charts, maps, and scene views.
Scalable GPU-native annotations	Opportunity	WebGPU + WebGL2	@luma.gl/text and @luma.gl/arrow	Advance streamed labels, dictionary reuse, collision-aware placement, and exact row selection.
Scientific volume rendering	Opportunity	WebGPU	@luma.gl/anari and @luma.gl/experimental	Visualize streamed three-dimensional fields with transfer functions, clipping, and isosurfaces.
Massive geometry visualization	Opportunity	WebGPU	@luma.gl/experimental	Extend procedural virtual geometry toward imported mesh clusters and occlusion-aware residency.
Motion-aware temporal reconstruction	Opportunity	WebGPU	@luma.gl/effects and @luma.gl/anari	Extend camera-reprojection antialiasing with animated-object motion vectors, compatible denoising, and temporal upscaling.
GPU-resident crowd animation	Opportunity	WebGPU	@luma.gl/gltf	Extend existing instanced skeletal crowds toward GPU clip sampling, independent actor morph deformation, and material variation.
Incremental GPU splat hierarchy scheduling	Opportunity	WebGPU	@luma.gl/splats	Move authored row traversal and camera-prioritized page scheduling into bounded incremental worker/GPU workflows.
Segmented splat picking and mesh composition	Opportunity	WebGPU	@luma.gl/splats	Add stable GPU picking across paged segments and compose segmented splats with caller-owned meshes in one depth-aware pass.
Partitioned splat sorting and scatter	Opportunity	WebGPU	@luma.gl/splats	Extend global ordering beyond 33,554,432 active rows on a 128 MiB binding limit and replace segment-pair scatter with near-linear routing.
Streamed 3D Tiles and glTF splat transport	Opportunity	WebGPU + WebGL2	@luma.gl/splats with existing loaders.gl packages	Reuse existing Tileset3D traversal, fetching, computed transforms, caching, and feature metadata; apply loader-computed transforms per tile/page in the renderer; connect selected tiles to prepared splats or the existing SplatLayer after loaders.gl adds Gaussian glTF extension handlers and SPZ v2 decoding (#1245).
Measured captured-scene visual and performance parity	Opportunity	WebGPU	@luma.gl/splats	Establish reproducible Coit imagery, frame-time, startup, bandwidth, and bounded-residency comparisons against Spark.
Production-ready module boundaries	Opportunity	WebGPU + WebGL2	@luma.gl/engine, @luma.gl/tables, and @luma.gl/gpgpu	Graduate reusable scheduling, data adapters, and algorithms into their natural published packages.

@luma.gl/experimental, @luma.gl/anari, @luma.gl/splats, @luma.gl/arrow, @luma.gl/text, @math.gl/geoarrow, and @deck.gl-community/arrow-layers are private packages in active development and are not yet published independently. Hardware capabilities, browser support, and API stability vary by feature.

Explore the live visualization examples, read the GPU programming guides, or inspect the GPU data and compute architecture.