mrdoob/three.js

This system is the Three.js 3D graphics library, providing a comprehensive WebGL and WebGPU rendering engine for creating and displaying 3D content in web browsers. It features a modern, node-based material system (TSL) that supports advanced lighting, post-processing effects, and physically based rendering. The codebase includes a robust set of utilities for geometry manipulation, animation, physics integration, and asset loading, alongside a detailed editor and documentation suite for development and inspection.

42 changes.

This period focused on a comprehensive architectural overhaul, migrating the codebase to ES6 classes and modular ES modules across core systems like materials, lights, and animations. It simultaneously introduced WebGPU support, modernized the editor with advanced scripting tools, and established foundational infrastructure for color management and texture handling.

50 changes.

This period focused on migrating the codebase to ES6 classes and modules, standardizing APIs across geometries, helpers, and controls while deprecating legacy CommonJS builds. It also expanded the library with extensive new addons for physics, advanced rendering, and WebXR support, alongside significant improvements to documentation infrastructure and test coverage.

44 changes.

This period focused on introducing the WebGPU renderer with a WebGL fallback and overhauling the rendering pipeline to use a new node-based architecture and Three.js Shading Language (TSL). The work involved migrating core materials to the node system, implementing advanced PBR features, and adding comprehensive post-processing and utility tools for the new rendering infrastructure.

28 changes.

This period focused on expanding the WebGPU renderer with advanced lighting systems, including clustered, dynamic, and probe-based illumination, alongside significant enhancements to the TSL ecosystem. Concurrently, the project introduced a comprehensive WebGPU Inspector and Chrome DevTools extension to improve debugging and development workflows. The work also included refactoring various loaders and adding new procedural generators and documentation tools.

The examples/models/3mf directory now includes a README.md file that documents the licensing (BSD 2-Clause) and sources for the included 3MF sample files, such as cube\_gears, facecolors, and volumetric models. This change provides necessary legal attribution for the assets used in the 3D loader examples.

examples/models/3mf · high confidence

Added the \basis\_transcoder.js\ and \basis\_transcoder.wasm\ files to the examples library, providing the JavaScript wrapper and WebAssembly module required for the KTX2Loader to transcode Basis Universal texture formats.

examples/jsm/libs/basis · high confidence

The examples/models/gcode directory now includes three new G-code files: benchy.gcode, test\_m82.gcode, and test\_m83.gcode. The benchy.gcode file provides a standard 3D model example generated with absolute extrusion mode (M82), while test\_m82.gcode and test\_m83.gcode serve as minimal test cases specifically demonstrating absolute (M82) and relative (M83) extrusion behaviors respectively.

examples/models/gcode · high confidence

The examples/models/vrml directory now includes several new VRML 2.0 model files to demonstrate various features. camera.wrl provides a scene with PerspectiveCamera and OrthographicCamera nodes alongside basic geometry. crystal.wrl, creaseAngle.wrl, and house.wrl showcase complex IndexedFaceSet geometries, material properties, and lighting. Additionally, elevationGrid1.wrl, elevationGrid2.wrl, extrusion1.wrl, extrusion2.wrl, and extrusion3.wrl introduce examples using ElevationGrid for terrain and Extrusion for 3D shapes like rooms, pyramids, and twisted bars.

examples/models/vrml · high confidence

Introduced a new Voxel Cone Tracing (VXGI) system for WebGPU that provides indirect diffuse lighting and ambient occlusion. The change adds \VXGINode\ as a post-processing node that voxelizes the scene into a \VXGIVolume\ and gathers indirect light per pixel using approximate cone tracing. Supporting files include \VXGIConeTracer.js\ for the ray-marching and radiance sampling logic, \VXGISceneCollector.js\ for CPU-side triangle collection and texture sampling, and \VXGIVolume.js\ for managing the 3D storage textures and voxelization state. This feature offers a middle ground between screen-space GI and light probe grids, providing consistent lighting that includes off-screen surfaces while requiring static geometry for efficient voxelization.

examples/jsm/lighting/vxgi · high confidence

Two new spotlight classes, IESSpotLight and ProjectorLight, are now available for use with the WebGPU renderer. IESSpotLight extends the standard SpotLight to support IES (Illuminating Engineering Society) profiles via an iesMap texture, allowing for realistic light distribution based on photometric data. ProjectorLight extends SpotLight to support projected textures with a configurable aspect ratio, enabling effects like gobo lighting. Both classes are exclusive to the WebGPU rendering pipeline.

src/lights/webgpu · high confidence

New example modules for the WebGPU renderer have been added: \Line2\ (a wide polyline extending \LineSegments2\), \LineSegments2\ (the underlying segment renderer with screen-space and world-space raycasting), and \Wireframe\ (a mesh-based wireframe class supporting dashed lines via \computeLineDistances\). These files import from \three/webgpu\ and are intended for use with \WebGPURenderer\ only, providing WebGPU equivalents to the existing WebGL line examples.

examples/jsm/lines/webgpu · high confidence

New TSL (Three Shading Language) data nodes have been introduced for Ambient, Directional, Hemisphere, Point, and Spot lights to enable dynamic lighting in the WebGPU renderer. These nodes batch light properties (such as color, position, direction, and intensity) into uniform arrays, allowing the renderer to process multiple lights of each type in a single pass rather than iterating per-light in the shader. This change provides the underlying data infrastructure for the new dynamic lighting system, with each node handling specific light attributes and contributing to the global irradiance or reflected light calculations.

examples/jsm/tsl/lighting/data · high confidence

The examples/models/fbx directory now includes new sample files: ball\_anims\_asc\_2018.fbx (a model with animation data), nurbs.fbx (containing various NURBS curve geometries), and stanford-bunny.fbx (a textured mesh). Additionally, a README.md file has been added to explicitly state that nurbs.fbx is licensed under CC0 (Public Domain).

examples/models/fbx · high confidence

The offscreen example directory now includes three new JavaScript modules: \scene.js\ which initializes a Three.js scene with rotating icosahedrons on an offscreen canvas, \offscreen.js\ which handles the message passing between the main thread and the worker, and \jank.js\ which provides a utility to simulate rendering jank for performance testing.

examples/jsm/offscreen · high confidence

The examples/luts directory now includes several new Color Lookup Table (LUT) files, specifically Bourbon 64.CUBE, Chemical 168.CUBE, Clayton 33.CUBE, Cubicle 99.CUBE, Presetpro-Cinematic.3dl, and Remy 24.CUBE. These files provide sample 3D LUT data (in both .CUBE and .3dl formats) for testing and demonstration purposes within the examples suite.

examples/luts · high confidence

A new ASCII-format Point Cloud Data (PCD) file has been added to the examples/models/pcd directory, providing a concrete sample dataset for testing and demonstrating PCD loader functionality.

examples/models/pcd · high confidence

A new Collada (.dae) model file for the Cobra s350 has been added to the examples/models/collada directory, providing a new asset for users to test 3D model loading and rendering capabilities.

examples/models/collada · high confidence

The script editor now includes three new CodeMirror addons: a dialog utility for opening input prompts and confirmation boxes, a show-hint addon for code completion suggestions, and a Tern integration addon that provides advanced JavaScript features like type inference, documentation tooltips, and go-to-definition. These additions enhance the coding experience by enabling interactive dialogs, auto-completion, and smarter code assistance within the editor.

editor/js/libs/codemirror/addon · high confidence

The editor now includes the CodeMirror JavaScript library (codemirror.js) and its default styling (codemirror.css) to power the scripting UI. Additionally, the Monokai color theme (monokai.css) has been added, providing a dark syntax-highlighting style for code editing within the editor.

editor/js/libs/codemirror · high confidence

A new FlakesTexture class is now available in the examples to generate flakes texture images, which can be used as normal maps to produce car paint-like effects. The class creates a canvas with random flakes and returns it for use with CanvasTexture.

examples/jsm/textures · high confidence

The editor now supports syntax highlighting for GLSL and JavaScript code within the scripting UI. This change introduces new CodeMirror mode definitions for these languages, enabling features like keyword recognition, string/comment handling, and indentation logic for GLSL shaders and JavaScript scripts directly in the editor.

editor/js/libs/codemirror/mode · high confidence

New GLSL-specific parser classes (GLSLNodeFunction and GLSLNodeParser) have been added to the nodes/parsers directory, enabling the system to parse GLSL source code into structured node functions with support for precision qualifiers, input/output qualifiers, and header code extraction.

src/nodes/parsers · high confidence

The manual examples now include a new dataset for the Gridded Population of the World (GPW) v4, specifically the basic demographic characteristics revision 10. This addition provides a readme file with source documentation and a corresponding ASCII grid file containing population density data, enabling users to test or demonstrate features that rely on this specific geographic dataset.

manual/examples/resources · high confidence

This location introduces a new glTF sample model demonstrating the KHR\_materials\_variants extension. The example features a single shoe model that shares geometry and most textures across three distinct color variants (Beach, Midnight, and Street), reducing file size compared to storing separate models for each variant. The entry includes the glTF JSON definition, the associated binary buffer, and a README explaining the variant structure and licensing.

examples/models/gltf/MaterialsVariantsShoe · high confidence

A new text file (Ogro.txt) has been added to the examples/models/md2/ogro directory, providing detailed documentation for the Ogro MD2 model. This file includes author credits, skin descriptions, technical specifications (polygon/vertex counts), and usage instructions for the Quake II model.

examples/models/md2 · high confidence

The examples/textures/matcaps directory now includes attribution text files (040full.txt and matcap-porcelain-white.txt) for the corresponding matcap assets, crediting the original artists and providing source links.

examples/textures/matcaps · high confidence

This change introduces the foundational assets and styles for the documentation interface. It adds a collection of SVG icons (including menu, close, search, code, copy, and tick icons) to the files directory, alongside a new main icon.svg. Additionally, it establishes the main.css stylesheet, which defines the layout structure (header, panel), typography (Roboto Mono), and CSS variables for theming, including support for dark mode via prefers-color-scheme.

files · high confidence

New tools have been added to the manual's resources to help generate data for aligning HTML elements to 3D and using indexed textures for picking. This includes \make-geo-picking-texture.html\ and its JavaScript counterpart for processing world border shapefiles, as well as \make-geo-picking-texture-ogc.html\ and its Node.js/JS variants for parsing OGC geometry data. Supporting parsers for shapefiles (\shapefile.js\) and OGC formats (\ogc-parser.js\) are also included to enable users to create or extract similar maps from other geographic data sources.

manual/resources/tools · high confidence

The LDraw examples now include pre-packed versions of official library models (such as the Imperial AT-ST and Lighthouse) to optimize loading performance, alongside the necessary license files (OpenContent and Creative Commons Attribution 2.0) to clarify usage rights for the included assets.

examples/models/ldraw · high confidence

A new Collada model file (pump.dae) has been added to the examples/models/collada/pump directory. This file contains a 3D model of a pump, including camera definitions, materials, and effects, exported from Maya using OpenCOLLADA. The model includes various textures and lighting setups, providing a reference for users working with Collada files in the examples.

examples/models/collada/pump · high confidence

Added two new ASCII PLY model files to the examples directory: a standard dolphin mesh and a colored variant that includes vertex color properties (red, green, blue, alpha). These files provide additional test assets for the PLY loader examples.

examples/models/ply · high confidence

The editor's runtime player now supports the WebGPU renderer, allowing projects to be previewed using the new rendering backend alongside the existing WebGL renderer. Additionally, the texture loading system has been expanded to support EXR, KTX2, and TGA file formats, with KTX2 support detected dynamically and TGA/KTX2 textures automatically assigned the sRGB color space. The underlying scripting engine has also been updated, replacing the older esprima version with v3.1.3 to improve code parsing and validation capabilities.

editor/js/libs · high confidence

The editor now includes new SVG assets for rotate, scale, and translate actions, enabling users to visually identify and perform these transformation operations within the interface.

editor/images · high confidence

The examples/materialx directory has been significantly expanded with a large set of new MaterialX 1.39 (.mtlx) files. These additions include new surface shader definitions for complex materials such as dispersion glass, honey, pearl, and velvet, alongside a comprehensive suite of test cases for the standard\_surface shader. These test files cover specific features including transmission, opacity, sheen, thin-film interference, roughness, and various image coordinate transformations (rotate2d, rotate3d, place2d), providing users with more reference materials and validation examples for MaterialX workflows.

examples/materialx · high confidence

The exporter files in examples/jsm/exporters have been converted to ES modules, introducing new exporters for EXR and KTX2 formats and adding WebGPURenderer support to GLTF, KTX2, and EXR exporters. The GLTFExporter now supports a plugin system for extensions like clearcoat and transmission, while the USDZExporter has been refactored to support scene hierarchies and animations. Additionally, the DRACOExporter now properly supports point clouds and the PLYExporter honors buffer attribute data types for better compatibility.

examples/jsm/exporters · high confidence

Established the project's foundational configuration and documentation by adding an .editorconfig for consistent coding styles (LF line endings, UTF-8, tabs), a .gitattributes file for text handling, and a comprehensive .gitignore covering build artifacts, IDE files, and test outputs. Included a standard MIT LICENSE, a SECURITY.md policy for private vulnerability reporting, and an ESLint flat configuration (eslint.config.js) that enforces ECMAScript 2022 standards, restricts test imports to source files, and integrates plugins for HTML, compatibility, and JSDoc checking. Additionally, added a README.md with usage examples and badges, and llms.txt to provide LLM-friendly documentation links.

(repo-wide) · high confidence

The Inspector's tabbed interface has been reorganized into dedicated modules (Console, Memory, Parameters, Performance, Settings, Timeline, Viewer). The new Memory tab displays renderer memory usage (textures, geometries, buffers) with a live graph. The Performance tab provides FPS, CPU, and GPU timing graphs alongside detailed frame stats. The Timeline tab introduces a command recorder with hierarchical and count-based views, recording controls, and data export. The Console tab now supports filtering, type-based toggles, and a 'Copy All' button. The Settings tab allows forcing WebGL backend, capturing stack traces, managing extensions, and configuring storage scope.

examples/jsm/inspector/tabs · high confidence

The Inspector now includes a new Color Grading extension that allows users to apply and preview real-time color adjustments on the rendered scene. This extension provides a modular pipeline with controls for exposure, brightness, contrast, hue, saturation, vibrance, and lift/gamma/gain wheels, as well as RGB curves. It supports 3D LUT (Look-Up Table) import and export, enabling users to apply professional-grade color grading presets or create their own. The extension integrates with the Inspector's UI, offering a dedicated panel for these adjustments.

examples/jsm/inspector/extensions · high confidence

The script editor now includes the Tern.js library (editor/js/libs/ternjs), enabling advanced code intelligence features such as type inference, JSDoc comment parsing, and code completion. This integration adds core analysis modules including the inference engine (infer.js), type definition parser (def.js), and comment handling (comment.js, doc\_comment.js), along with necessary polyfills (polyfill.js) and signaling utilities (signal.js) to support static analysis within the editor environment.

editor/js/libs/ternjs · high confidence

Adds a new Cascade Shadow Maps (CSM) implementation to the examples, providing separate modules for WebGL (CSM) and WebGPU (CSMShadowNode) to improve shadow quality across varying distances. The WebGL version injects GLSL shader logic to handle cascade splitting and optional fading, while the WebGPU version utilizes the TSL node system for shadow calculations. A CSMHelper utility is also included to visualize the cascade frustums, planes, and shadow bounds for debugging.

examples/jsm/csm · high confidence

The WebGL fallback renderer now includes built-in GLSL polyfills for \textureGather\, \textureGatherCompare\, and their array variants, as well as 4x8 signed/unsigned normalized float packing and unpacking functions. This allows node materials to use these advanced texture sampling and data conversion operations on WebGL contexts that may not support the corresponding native extensions or built-in functions, ensuring broader compatibility for complex shader effects.

src/renderers/webgl-fallback/nodes · high confidence

The \examples/jsm/transpiler\ directory now provides a new toolchain to automatically convert GLSL shader code into Three.js TSL (node-based) syntax and WGSL. This includes a \GLSLDecoder\ to parse GLSL into an AST, a \Linker\ to resolve variable references, a \TSLEncoder\ to emit TSL code (importing functions like \add\, \uniform\, \texture\ from \three/tsl\), and a \WGSLEncoder\ to emit WGSL code with appropriate type mappings and polyfills. A \ShaderToyDecoder\ is also included to handle ShaderToy-specific globals like \iTime\ and \fragColor\. This allows developers to migrate custom materials from legacy GLSL to the new node-based system or WebGPU-compatible WGSL.

examples/jsm/transpiler · high confidence

The new NodeMaterialObserver class is added to the WebGPU renderer to manage and optimize the refresh state of node materials. It tracks render objects, materials, geometries, and textures using internal caches to detect changes in uniforms, geometry versions, and texture states. This allows the renderer to determine precisely when a full or partial refresh is needed before rendering, avoiding unnecessary recalculations and improving performance for animated or dynamic scenes.

src/materials/nodes/manager · high confidence

The TSL (Three.js Shading Language) documentation is now available as an interactive web application. This update adds a new guide interface featuring a split-pane layout with a Markdown content area on the left and a live Monaco code editor on the right. Users can now experiment with TSL code directly in the browser, with immediate visual feedback rendered via a WebGPU-based preview pane. The guide includes a comprehensive introduction to TSL's node-based architecture, examples of shader creation, and a built-in Playground for testing snippets. The interface supports syntax highlighting for TSL imports, search functionality, and responsive design for mobile devices.

tsl · high confidence

The \src/nodes/code\ directory now contains the core node classes (\CodeNode\, \ExpressionNode\, \FunctionCallNode\, \FunctionNode\) and their corresponding TSL helper functions (\code\, \js\, \wgsl\, \glsl\, \expression\, \call\, \glslFn\, \wgslFn\). This adds the capability to define, include, and call native shader code (GLSL/WGSL/JS) directly within the node material system, allowing developers to implement custom shader logic and functions using the TSL syntax.

src/nodes/code · high confidence

A new Chrome DevTools extension for inspecting three.js applications has been added to the devtools directory. The extension provides a dedicated panel that displays a collapsible tree of scenes and objects, including geometry and material types, object and light counts, and renderer properties with render stats and memory usage. Users can inspect individual objects to see their position, rotation, and scale, view rendered previews of meshes and lines, and highlight objects in the page with a bounding box overlay. The toolbar icon indicates the detected three.js revision and allows scrolling to the first canvas.

devtools · high confidence

The WebGPU renderer now includes a set of internal utility modules in the \src/renderers/webgl-fallback/utils\ directory to support its WebGL fallback path. These new files—\WebGLAttributeUtils\, \WebGLCapabilities\, \WebGLConstants\, \WebGLExtensions\, \WebGLState\, \WebGLTextureUtils\, \WebGLTimestampQueryPool\, \WebGLUtils\, and \WebGLVertexArrayUtils\—manage core WebGL 2 operations such as attribute buffer creation, state caching, texture format conversion, extension handling, and timestamp query pooling, ensuring the WebGL backend functions correctly when the native WebGPU API is unavailable.

src/renderers/webgl-fallback/utils · high confidence

The examples/jsm/inspector directory now contains the core implementation of the WebGPU Inspector, including the main Inspector class, RendererInspector for frame/timestamp tracking, and an Extension base class for modular UI tabs. This change adds support for persisting inspector state via localStorage (with version and URL awareness), enables CSP compliance via nonce injection, and provides a lifecycle API for extensions to serialize/deserialize settings and handle layout changes.

examples/jsm/inspector · high confidence

This change adds the foundational node-based rendering infrastructure for the WebGPU renderer. It introduces BasicNodeLibrary and StandardNodeLibrary to map lights, tone-mapping techniques, and materials (such as MeshStandardMaterial and MeshPhysicalMaterial) to their node implementations. Additionally, it provides the WGSLNodeBuilder, WGSLNodeParser, and WGSLNodeFunction classes, which handle the generation, parsing, and compilation of WebGPU Shading Language (WGSL) code, including support for various texture types, uniform buffers, and polyfills for missing WGSL functions.

src/renderers/webgpu/nodes · high confidence

The WebGPU renderer is now available as an alternative to the WebGL renderer, allowing applications to leverage the WebGPU API for improved performance and modern graphics capabilities. If WebGPU is not supported by the browser, the renderer automatically falls back to a WebGL 2 backend, ensuring compatibility across a wider range of devices. This change introduces new renderer classes (WebGPURenderer and WebGPURenderer.Nodes) and a dedicated WebGPU backend implementation, along with associated node libraries for material handling.

src/renderers/webgpu · high confidence

This change adds a new set of modules for rendering wide lines with arbitrary width and world-unit scaling: Line2, LineGeometry, LineSegments2, LineSegmentsGeometry, LineMaterial, Wireframe, and WireframeGeometry2. Line2 and LineSegments2 provide the mesh objects, while LineGeometry and LineSegmentsGeometry handle the underlying vertex data and support methods like setFromPoints and fromWireframeGeometry. LineMaterial includes shader logic for dashed lines, world-unit width, and proper clipping/trimming near the camera. Wireframe and WireframeGeometry2 enable wide-line wireframe rendering for meshes. These classes are WebGL-only; WebGPU users must import the corresponding webgpu variants.

examples/jsm/lines · high confidence

The \src/objects\ directory now includes \BatchedMesh\, a new mesh variant designed for multi-draw batch rendering to optimize performance when rendering many objects with the same material but different geometries or transforms. Additionally, \ClippingGroup\ is introduced as a specialized \Group\ that allows clipping planes to be encoded directly into the scene graph, a feature currently supported only by the \WebGPURenderer\. These additions expand the available 3D object types for advanced rendering and scene organization.

src/objects · high confidence

The rendering pipeline now uses dedicated Node-based lighting models (Basic, Phong, Physical, Toon, Shadow, and Volumetric) within the NodeMaterial system. This change replaces the previous shader-based approach with a composable, node-graph-driven architecture, enabling more flexible material definitions and better integration with the Three.js Shader Language (TSL). Users will see these models powering the corresponding NodeMaterials (e.g., MeshBasicNodeMaterial, MeshPhysicalNodeMaterial), allowing for more precise control over lighting calculations like ambient occlusion, transmission, and volumetric scattering through the node graph.

src/nodes/functions · high confidence

The rendering pipeline for core materials (MeshBasic, MeshStandard, MeshPhysical, MeshPhong, MeshLambert, MeshToon, MeshMatcap, MeshNormal, LineBasic, LineDashed, Line2, Points, Sprite, and Shadow) has been migrated to the new NodeMaterial system. This change replaces the previous shader generation approach with a node-based architecture, allowing material properties like color, metalness, roughness, and lighting to be defined and manipulated via nodes. Users can now leverage the node system for advanced customizations, such as using nodes for emissive, metalness, or roughness values, and benefit from improved consistency and extensibility in how materials interact with the scene's lighting and environment.

src/materials/nodes · high confidence

A new TSL module has been introduced, providing a declarative syntax for building shader code. This change adds a centralized entry point (TSLBase.js) that re-exports core node types and functions, and implements method chaining on the Node prototype via TSLCore.js. Users can now use fluent APIs (e.g., \node.assign()\, \node.toVar()\) and access swizzle properties directly on nodes. The implementation includes error handling for operations outside of defined stacks and replaces previous proxy-based approaches with prototype extensions for better performance and tree-shaking support.

src/nodes/tsl · high confidence

The \src/nodes/utils\ directory now contains a comprehensive suite of new TSL (Three Shading Language) nodes and procedural functions. This includes procedural pattern generators like \checker\ and \matcapUV\, coordinate system helpers such as \equirectUV\ and \equirectDirection\, and post-processing utilities including \getNormalFromDepth\, \interleavedGradientNoise\, and \vogelDiskSample\. Core node infrastructure has been expanded with \ArrayElementNode\, \ConvertNode\, \DebugNode\, \EventNode\ (supporting frame and object lifecycle events), \LoopNode\, and \FunctionOverloadingNode\. Additionally, new capabilities for render targets (\RTTNode\), environment map conversion (\CubeMapNode\), and reflection (\ReflectorNode\) are provided, alongside standard shader operations like \Discard\, \FlipNode\, and \Packing\ functions.

src/nodes/utils · high confidence

A new WebGL 2 backend implementation has been added to serve as a fallback for the WebGPU renderer. This change introduces the \WebGLBackend\ class and supporting utilities (such as \WebGLBufferRenderer\, \WebGLState\, and \WebGLExtensions\) within the \src/renderers/webgl-fallback\ directory. This allows applications to continue rendering using WebGL 2 when the primary WebGPU backend is unavailable or unsupported, ensuring broader compatibility without requiring a separate WebGL renderer instance.

src/renderers/webgl-fallback · high confidence

A new WebGLNodesHandler module has been added to bridge the gap between the NodeMaterial system and the WebGL renderer. This component introduces a WebGLNodeBuilder and SceneContext to adapt TSL nodes for WebGL resources, enabling features like fog, environment mapping, and lighting within the NodeMaterial framework. It also includes a RendererProxy to manage renderer-specific data and handles PMREM generation for environment maps, effectively allowing NodeMaterials to be compiled and rendered in WebGL contexts.

examples/jsm/tsl · high confidence

The core module now includes the foundational classes for modern geometry handling and event management. BufferAttribute and BufferGeometry provide the new standard for storing and managing vertex data, indices, and attributes for efficient GPU communication, replacing legacy geometry structures. EventDispatcher enables custom objects to emit and listen for events, supporting the scene graph's object lifecycle. Additionally, the Clock utility is introduced for time tracking, though it is immediately marked as deprecated in favor of the Timer module.

src/core · high confidence

The math module now includes new classes for 2D and 3D bounding boxes (Box2, Box3), cylindrical coordinates (Cylindrical), and a comprehensive color management system (ColorManagement). The Color class has been rewritten as an ES6 class with support for explicit color space handling, while ColorManagement introduces a configurable pipeline for converting between color spaces like sRGB and linear light. These changes provide more robust geometric calculations and accurate color rendering out of the box.

src/math · high confidence

A new DevTools panel has been added to inspect Three.js scenes and renderers. The panel provides a collapsible hierarchy of scenes and objects, displays detailed properties for selected items, and includes a preview tile for object visualization. It supports both light and dark themes and automatically updates as the inspected page's state changes.

devtools/panel · high confidence

The manual's resource directory now includes a new \canvas-wrapper.js\ utility that patches the Canvas 2D context to support a \currentTransform\ property and a save/restore stack, enabling accurate orbit trail drawing in the moon-orbit example. Additionally, the manual now ships with dedicated \lesson.js\ and \lesson.css\ files to handle link navigation within iframes, code syntax highlighting via \prettify.js\, and dark mode styling, replacing the previous inline or external dependencies for these manual-specific behaviors.

manual/resources · high confidence

Added new ES6 module versions of the 3DM (Rhino3dmLoader), 3MF (ThreeMFLoader), AMF (AMFLoader), and BVH (BVHLoader) loaders to examples/jsm/loaders. These modules provide modern, tree-shakeable entry points for loading Rhinoceros 3D files, 3D Manufacturing Format archives, additive manufacturing files, and skeleton animation data, respectively, replacing or supplementing legacy loader implementations.

examples/jsm/loaders · high confidence

The examples directory now includes ES6 module versions (in examples/jsm/renderers) for the legacy CSS2DRenderer, CSS3DRenderer, SVGRenderer, and Projector. These modules provide modern, importable implementations of the renderers, including updated features such as render order support in CSS2DRenderer, DOM element reuse, and depth sorting in SVGRenderer, allowing users to integrate these specific rendering capabilities into modern module-based projects.

examples/jsm/renderers · high confidence

Added ES6 module versions of the Anaglyph, Ascii, Outline, ParallaxBarrier, and Stereo effects to the JSM directory. These modules provide the same visual capabilities as the legacy examples but are structured for modern import usage, with the Anaglyph effect updated to use physically-correct stereo projection via frameCorners.

examples/jsm/effects · high confidence

This change introduces a suite of new nodes in the \src/nodes/gpgpu\ directory to enable advanced GPU compute capabilities. \AtomicFunctionNode\ provides atomic operations (load, store, add, sub, max, min, and, or) for thread-safe variable modifications. \BarrierNode\ adds synchronization controls via \workgroupBarrier\, \storageBarrier\, and \textureBarrier\. \ComputeBuiltinNode\ exposes compute shader built-ins like \numWorkgroups\ and \workgroupId\. \SubgroupFunctionNode\ implements subgroup/wave intrinsics such as \subgroupElect\, \subgroupBallot\, and shuffle operations. \WorkgroupInfoNode\ allows the creation of fast, workgroup-scoped buffers, and \ComputeNode\ serves as the entry point for dispatching these compute shaders.

src/nodes/gpgpu · high confidence

Added BitonicSort and CountingSort classes to the GPGPU addons, enabling efficient data sorting directly on the GPU using TSL compute shaders. BitonicSort provides a deterministic comparison-based sort suitable for smaller datasets, while CountingSort offers a high-performance, approximate sort for large datasets by quantizing keys into bins. Both implementations support WebGPU and include CPU fallbacks for WebGL compatibility, allowing users to reorder instance data or other buffers efficiently without transferring data back to the main thread.

examples/jsm/gpgpu · high confidence

Added \LDrawConditionalLineMaterial\ and \LDrawConditionalLineNodeMaterial\ to provide WebGL and WebGPU-specific line rendering for LDraw models, respectively, ensuring correct conditional line drawing based on control points. Additionally, introduced \WoodNodeMaterial\, a new procedural material built with TSL that generates realistic wood textures using noise, rings, and cell structures, available for use in the examples.

examples/jsm/materials · high confidence

The \examples/jsm/lights\ directory now includes two new utility modules: \LightProbeGenerator\, which provides static methods to create \LightProbe\ instances from cube textures or cube render targets (supporting Float and Half Float types), and \RectAreaLightTexturesLib\, which initializes the LTC BRDF approximation data textures required for \RectAreaLight\ shading.

examples/jsm/lights · high confidence

The examples/jsm/curves directory now includes new ES module files for advanced curve types: NURBSCurve, NURBSSurface, NURBSVolume, and CurveExtras. NURBSCurve adds support for NURBS curves with serialization via toJSON/fromJSON and tangent calculation. NURBSSurface and NURBSVolume extend this to 2D and 3D NURBS primitives respectively. CurveExtras provides several parametric curves (GrannyKnot, HeartCurve, VivianiCurve, KnotCurve, HelixCurve) for visual examples. These are utility classes for the examples directory, not core Three.js library features.

examples/jsm/curves · high confidence

The library now exposes two new top-level entry points, \src/nodes/Nodes.js\ and \src/nodes/TSL.js\, which aggregate and re-export the entire node system. \Nodes.js\ provides class-based exports for core infrastructure (e.g., \Node\, \NodeBuilder\, \UniformNode\), accessors (e.g., \TextureNode\, \BufferAttributeNode\), display passes (e.g., \PassNode\, \RenderOutputNode\), lighting models, and GPGPU compute nodes. \TSL.js\ offers a functional shading-language API, exporting utility functions (e.g., \equirectUV\, \matcapUV\, \triplanarTextures\), accessors, display helpers (including blend modes and color/tone-mapping functions), lighting primitives, and BSDF functions (e.g., \BRDF\_EON\, \D\_GGX\, \LTC\_Evaluate\). This centralizes access to the node system and TSL capabilities for users.

src/nodes · high confidence

This change introduces a comprehensive set of new node classes in \src/nodes/lighting\ to power the scene's lighting and shadowing system. It adds base classes like \LightingNode\ and \AnalyticLightNode\, alongside specific implementations for all light types (\AmbientLightNode\, \DirectionalLightNode\, \PointLightNode\, \SpotLightNode\, \HemisphereLightNode\, \RectAreaLightNode\, \IESSpotLightNode\, \ProjectorLightNode\, and \LightProbeNode\). It also introduces a new shadow system with \ShadowNode\, \ShadowBaseNode\, \PointShadowNode\, and various filter nodes (\BasicShadowFilter\, \PCFShadowFilter\, \VSMShadowFilter\), as well as environment lighting nodes (\EnvironmentNode\, \BasicEnvironmentNode\) and utility nodes for ambient occlusion and irradiance.

src/nodes/lighting · high confidence

This change introduces the PMREMNode class, which manages the generation and caching of Pre-filtered Environment Maps (PMREMs) from input textures, handling renderer-specific caches and disposal. It also adds PMREMUtils, providing TSL functions for GGX VNDF importance sampling and spiral-based Gaussian blurring to improve the quality and performance of environment map prefiltering in PBR materials.

src/nodes/pmrem · high confidence

A new \RangeNode\ has been introduced in the geometry nodes module to generate random data within a specified range for instanced attributes. This allows users to create effects such as random per-instance colors by defining minimum and maximum bounds, which are then interpolated using linear interpolation. The node handles buffer management by checking uniform buffer limits, falling back to instanced buffer attributes if necessary, and supports various data types including colors and vectors.

src/nodes/geometry · high confidence

Added five new TSL (Three.js Shading Language) functions in \src/nodes/functions/material\ to enhance material shading capabilities. \getAlphaHashThreshold\ implements hashed alpha testing for transparent materials, \getParallaxCorrectNormal\ provides parallax-corrected normals for box-projected environment mapping, and \getShIrradianceAt\ enables spherical harmonics irradiance calculation. Additionally, \getRoughness\ and \getGeometryRoughness\ introduce geometry-aware roughness adjustments, ensuring minimum perceptual roughness and accounting for surface detail.

src/nodes/functions/material · high confidence

Added new TSL (Three Shading Language) modules in the math directory to support advanced procedural effects. The \Bayer\ module provides \bayer16\ for sampling a Bayer matrix texture (useful for dithering and reducing banding in ray marching) and \bayerDither\ for applying structured noise to color inputs. The \curlNoise\ module introduces 3D curl noise generation based on Simplex noise, enabling divergence-free vector fields for fluid-like animations. The \voronoiNoise\ module adds animated 2D and 3D Voronoi noise functions, allowing for morphing cellular patterns in shaders.

examples/jsm/tsl/math · high confidence

Added several new TSL utility modules to the examples: \GroundedSkybox\ provides a function to project world positions onto a ground-clipped sphere for environment sampling; \RNoise\ offers a texture-free analytic R² noise generator; \Raymarching\ introduces a \RaymarchingBox\ helper for box-area raymarching with a configurable step count and callback; \SoftParticles\ implements a symmetric contrast curve for fading particles against scene depth; \SpecularHelpers\ supplies GGX/VNDF microfacet BRDF components (distribution, geometry, Fresnel, and importance sampling) for specular rendering; and \TAAUtils\ provides shared functions for temporal anti-aliasing, including AABB color clipping, flicker reduction, depth reprojection, and Halton jitter generation.

examples/jsm/tsl/utils · high confidence

The fog module now exposes dedicated TSL (Three.js Shading Language) functions for calculating fog factors, including \rangeFogFactor\, \densityFogFactor\, and \exponentialHeightFogFactor\. These functions allow developers to programmatically define how fog density increases with distance or height, replacing previous implicit or manual implementations with a standardized node-based approach. The \fog\ function remains available to combine these factors with a color to produce the final fog effect.

src/nodes/fog · high confidence

This location introduces a comprehensive suite of new post-processing and display effects implemented using the Three.js TSL (Three Shader Language) for the WebGPU renderer. The changes add new node classes and utility functions for visual effects including Bloom, Depth of Field, Chromatic Aberration, FXAA, FSR1, Bilateral Blur, Denoise, AfterImage, Anaglyph stereo rendering, Dot Screen, Bleach Bypass, and CRT simulation (barrel distortion, scanlines, vignette). These nodes provide a modern, composable API for applying screen-space effects, replacing or supplementing older implementation patterns with TSL-native code.

examples/jsm/tsl/display · high confidence

Added TileShadowNode and TileShadowNodeHelper to the TSL shadows module, enabling tiled shadow mapping for large scenes. TileShadowNode splits the shadow map into configurable X/Y tiles, each with its own light and camera, to improve quality and performance, while TileShadowNodeHelper provides debug visuals for the tile layout and shadow cameras.

examples/jsm/tsl/shadows · high confidence

Added new \WebGL.js\ and \WebGPU.js\ modules in the capabilities directory to help applications detect hardware support. The \WebGL\ module provides \isWebGL2Available()\ to check for WebGL 2 support, \isColorSpaceAvailable()\ to verify specific color space support (such as Display P3), and \getWebGL2ErrorMessage()\ to generate a user-friendly error message if WebGL 2 is missing. The \WebGPU\ module offers \isAvailable()\ to confirm WebGPU support by attempting to request an adapter, and \getErrorMessage()\ to display a fallback message when WebGPU is not supported.

examples/jsm/capabilities · high confidence

Three new lighting node implementations are added for the WebGPU renderer to improve performance and flexibility. ClusteredLightsNode introduces Forward+ clustered shading, subdividing the view frustum into a 3D grid to efficiently cull and process point lights based on depth. DynamicLightsNode batches supported analytic lights (directional, point, spot, hemisphere) into uniform arrays for faster rendering, while keeping unsupported or shadow-casting lights on the default per-light path. LightProbeGridNode enables the use of baked spherical-harmonic light probe grids by sampling a 3D texture atlas to evaluate irradiance, allowing static environment lighting to be applied automatically to standard materials.

examples/jsm/tsl/lighting · high confidence

This change introduces three new core modules for the WebXR renderer: WebXRController, WebXRDepthSensing, and WebXRManager. WebXRController manages XR input sources by exposing distinct coordinate spaces (target ray, grip, and hand) and dispatching connection events. WebXRDepthSensing provides access to the WebXR Depth Sensing API, allowing applications to retrieve and visualize environment depth data via an ExternalTexture. WebXRManager acts as the central abstraction for the WebXR Device API, handling session lifecycle, camera updates, controller management, and integration with the new depth sensing and controller modules.

src/renderers/webxr · high confidence

This update introduces the EdgeSplitModifier for splitting faces at sharp angles to improve normal computation, and the CurveModifierGPU for bending meshes along curves using the WebGPU TSL shader API. The existing CurveModifier has been updated to use HalfFloatType textures for smoother path following, while SimplifyModifier and TessellateModifier have been refactored to work with BufferGeometry, with TessellateModifier now supporting uv1 attributes and SimplifyModifier preserving normal and UV attributes during simplification.

examples/jsm/modifiers · high confidence

This update introduces several new helper classes to the examples library, including AnimationPathHelper for visualizing animation motion paths, OctreeHelper for debugging octree structures, PositionalAudioHelper for showing directional audio cones, RapierHelper for physics collider outlines, and TextureHelper for inspecting 2D, 3D, and array textures. Existing helpers have been updated to support both WebGL and WebGPU renderers, with specific WebGPU versions provided for LightProbeHelper, LightProbeGridHelper, and TextureHelper. Additionally, VertexNormalsHelper and VertexTangentsHelper have been refined to remove the deprecated linewidth parameter, and ViewHelper now includes configurable positioning via a location property.

examples/jsm/helpers · high confidence

The editor now includes a dedicated Animation panel that provides playback controls (play, pause, stop), a time display, and a timeline area with track rows. Users can scrub through animations by dragging the playhead, adjust the mixer time scale, and resize the panel. This panel is integrated into the editor's signal system and respects the user's preferred language for labels.

editor/js · high confidence

The \examples/jsm/animation\ directory now includes two new modules: \AnimationClipCreator\, a utility class providing factory methods to easily generate basic animation clips (such as rotation, scaling, shaking, pulsation, visibility toggling, and material color changes), and \CCDIKSolver\, which implements the CCD algorithm for solving inverse kinematics problems on \SkinnedMesh\ instances, including support for blend factors and helper creation.

examples/jsm/animation · high confidence

This update introduces three new lighting components to the examples/jsm/lighting directory. ClusteredLighting provides a Forward+ clustered shading implementation for the WebGPURenderer, partitioning the view frustum into a 3D grid to efficiently handle scenes with many point lights. DynamicLighting offers a WebGPU-specific lighting system that batches analytic lights into uniform arrays, allowing light count changes without recompiling materials. Additionally, LightProbeGrid (for WebGPU) and LightProbeGridWebGL (for WebGL) provide position-dependent diffuse global illumination using 3D grids of spherical harmonic irradiance probes, with the WebGL version featuring GPU-resident baking and indirect bounce support.

examples/jsm/lighting · high confidence

This change introduces a new set of build and documentation utilities under the \utils\ directory. It adds \utils/build/dev.js\ and \utils/build/preview.js\ to streamline local development by generating lightweight dev builds and running a watch-mode Rollup server with a custom preview server. A new \utils/build/rollup.config.js\ defines the build pipeline for core, TSL, and WebGPU entry points. Additionally, the documentation system is overhauled with a new JSDoc configuration (\utils/docs/jsdoc.config.json\), a custom JSDoc template (\utils/docs/template/\), and static assets for the docs site, including interactive browser examples for geometry, materials, and bones.

utils · high confidence

The \src/nodes/display\ directory now contains a comprehensive set of new node modules that bring advanced display and post-processing capabilities to the node material system. This includes \BlendModes\ for compositing (Burn, Dodge, Screen, Overlay, and standard alpha blending), \ColorAdjustment\ for image grading (grayscale, saturation, vibrance, hue rotation, CDL, and posterization), and \ColorSpaceNode\ for explicit working-to-output color space conversions. Tone mapping is now fully node-driven via \ToneMappingNode\ and \ToneMappingFunctions\ (Linear, Reinhard, Cineon, ACES Filmic, AgX), while \RenderOutputNode\ allows manual control over the final tone mapping and color space steps in post-processing chains. Additional new nodes include \BumpMapNode\ and \NormalMapNode\ for GPU-based height and normal mapping, \FrontFacingNode\ for face culling logic, \PassNode\ for render pass management, \ScreenNode\ for screen-space metrics, and \ToonOutlinePassNode\ for toon-shading outlines.

src/nodes/display · high confidence

Three new environment scene classes are now available to simplify setting up Image Based Lighting (IBL) via PMREMGenerator: ColorEnvironment provides a uniform colored sphere for ambient lighting, DebugEnvironment offers a simple room with colored emissive panels for development, and RoomEnvironment delivers a more realistic room setup with multiple lights and boxes for production-quality IBL. All three classes extend Scene, include a dispose() method for resource management, and are designed to be passed to PMREMGenerator.fromScene() to generate environment maps.

examples/jsm/environments · high confidence

The Scene class now exposes dedicated properties for visual effects: \fog\ (accepting \Fog\ or \FogExp2\ instances) to apply distance-based depth effects, \background\ to set a uniform color, texture, or skybox, and \environment\ to provide environment maps for physical materials. Additionally, users can control the appearance of these elements via \backgroundBlurriness\, \backgroundIntensity\, \backgroundRotation\, \environmentIntensity\, and \environmentRotation\. These properties are fully supported in serialization (\toJSON\) and cloning (\copy\), allowing scenes with these effects to be saved, loaded, and duplicated correctly.

src/scenes · high confidence

The examples/jsm/geometries directory now includes a suite of new geometry generators. BoxLineGeometry creates wireframe-style boxes for LineSegments. ConvexGeometry generates convex hulls from point arrays. DecalGeometry projects meshes onto surfaces, now supporting geometries without normals. LoftGeometry skins surfaces through a series of cross-sections. ParametricGeometry and its accompanying ParametricFunctions module allow generating surfaces from mathematical functions (including Klein bottle, Mobius strip, and plane). RoundedBoxGeometry extends BoxGeometry to produce boxes with rounded corners and edges. TeapotGeometry tessellates the classic Utah teapot model. TextGeometry generates 3D text meshes from loaded fonts, supporting text direction (left-to-right, right-to-left, top-to-bottom).

examples/jsm/geometries · high confidence

This change introduces four new modules in the interactive examples directory to enhance 3D scene interaction and DOM integration. HTMLMesh allows rendering DOM elements (such as lil-gui interfaces) as textures on 3D planes, supporting VR compatibility and automatic updates via DOM mutation observers. InteractiveGroup provides a unified way to handle pointer, mouse, and XR controller events for selecting descendant 3D objects using raycasting. SelectionBox and SelectionHelper offer a new mechanism for selecting multiple 3D objects via a visual selection box, with SelectionHelper managing the UI overlay and event listeners for the selection rectangle.

examples/jsm/interactive · high confidence

The loader subsystem introduces dedicated classes for loading specific asset types, including AnimationLoader, AudioLoader, BufferGeometryLoader, CompressedTextureLoader, CubeTextureLoader, DataTextureLoader, FileLoader, ImageBitmapLoader, ImageLoader, MaterialLoader, ObjectLoader, and TextureLoader. These loaders now inherit from a unified Loader base class and utilize a new global caching mechanism (Cache) to deduplicate requests and improve performance, with caching disabled by default. The FileLoader has been rewritten to use the Fetch API instead of XMLHttpRequest, supporting features like abort controllers and progress tracking via ReadableStream. Additionally, the ObjectLoader now supports loading extended PerspectiveCamera instances, and the MaterialLoader handles serialization/deserialization of material properties such as roughness, metalness, and blending factors.

src/loaders · high confidence

Added NodeLoader, NodeMaterialLoader, and NodeObjectLoader to enable loading 3D scenes and materials that utilize the new Node-based shader system. NodeLoader handles the deserialization of node definitions from JSON, NodeMaterialLoader extends the standard MaterialLoader to resolve node inputs within materials, and NodeObjectLoader extends ObjectLoader to manage the loading of Object3D hierarchies containing node materials, ensuring that node dependencies and textures are correctly resolved during the import process.

src/loaders/nodes · high confidence

Added a suite of new manual examples demonstrating how to render 3D scenes with various background types (CSS, cubemaps, equirectangular maps, and separate scenes) and how to align HTML labels to 3D objects (with sorting, hiding, and handling many labels). These examples also include a tool for generating 3D LUT base cubes and updated imports using the \three/addons/\ alias.

manual/examples · high confidence

The \src/math/interpolants\ directory now contains dedicated ES module classes for animation interpolation, including \BezierInterpolant\ (supporting cubic Bezier curves with explicit in/out tangents), \CubicInterpolant\ (a fast cubic spline with configurable ending conditions), \DiscreteInterpolant\, \LinearInterpolant\, and \QuaternionLinearInterpolant\. These classes extend the base \Interpolant\ and provide the specific interpolation logic used by animation tracks, replacing previous implementations or structures that were consolidated into this location.

src/math/interpolants · high confidence

The math node library now includes new capabilities for low-level data manipulation: BitcastNode allows reinterpreting bit representations between float and integer types (with helpers like floatBitsToInt and intBitsToFloat), BitcountNode provides operations to count leading zeros, trailing zeros, and set bits, and PackFloatNode/UnpackFloatNode enable packing and unpacking float vectors into 32-bit integers using snorm, unorm, and float16 encodings in both 2x16 and 4x8 layouts.

src/nodes/math · high confidence

The examples/jsm/math directory now includes a comprehensive suite of new utility classes for 3D math and geometry operations. Users can now use Capsule for swept-sphere bounding volumes, OBB for oriented bounding box collision detection, and Octree for hierarchical spatial partitioning and collision queries. Geometry processing is enhanced with ConvexHull for computing convex hulls from points or objects, and MeshSurfaceSampler for weighted random point sampling on mesh surfaces. Color handling is expanded with ColorConverter for HSV conversions, ColorSpaces for Display-P3 and Rec.2020 color space definitions, and Lut for lookup table-based colormap visualization. Procedural generation is supported by ImprovedNoise and SimplexNoise classes.

examples/jsm/math · high confidence

Added a suite of new modules to the misc directory, providing tools for physics-based object breaking (ConvexObjectBreaker), hierarchical rotation handling (Gyroscope), legacy MD2 character animation (MD2Character, MD2CharacterComplex), morph target animation (MorphAnimMesh, MorphBlendMesh), progressive lightmap accumulation for WebGL and WebGPU (ProgressiveLightMap, ProgressiveLightMapGPU), procedural roller coaster geometry generation (RollerCoaster), and interactive 3D mesh sculpting (Sculptor, SculptorMesh).

examples/jsm/misc · high confidence

The USD loading system has been refactored into three distinct components: USDAParser, USDCParser, and USDComposer. USDAParser now handles the parsing of ASCII USD (USDA) files, while USDCParser manages binary USD (USDC) files, including LZ4 decompression and type handling. USDComposer is responsible for building the Three.js scene graph from the parsed data, supporting features like variant selection, animation, and transform composition. This modular approach replaces the previous monolithic loader, improving maintainability and allowing for more robust handling of different USD formats.

examples/jsm/loaders/usd · high confidence

Three.js now provides distinct entry points to improve tree-shaking and clarify capabilities: \Three.Core.js\ exports the core library (objects, textures, materials, loaders, math, etc.) without a renderer; \Three.js\ adds the WebGL renderer; \Three.WebGPU.js\ adds the WebGPU renderer and its node-based material system; and \Three.TSL.js\ exports the Shader Node Library. Additionally, MaterialX support is introduced in the node system via new files (\MaterialXCore.js\, \MaterialXColor.js\, \MaterialXColorTransform.js\) that provide functions for color space conversions (e.g., sRGB linearization) and transformations, enabling MaterialX-style material definitions within the node-based rendering pipeline.

src · high confidence

Added new ES6 module examples for several 3D objects: GaussianSplat (WebGPU-only, with raycasting support), GroundedSkybox (a ground-projected skybox), Lensflare and LensflareMesh (WebGL and WebGPU variants), MarchingCubes (migrated to Mesh), Reflector, Refractor, ReflectorForSSRPass, ShadowMesh, Sky and SkyMesh (WebGL and WebGPU variants), and Water and WaterMesh. These modules provide ready-to-use implementations for common visual effects, with clear renderer-specific pairings (e.g., Lensflare for WebGL, LensflareMesh for WebGPU) and updated APIs such as bounding volume computation and encoding handling.

examples/jsm/objects · high confidence

The \src/nodes/accessors\ directory has been restructured into dedicated modules, introducing new TSL (Three.js Shading Language) capabilities for advanced rendering features. Users can now access parallax mapping via \parallaxUV\ and \bentNormalView\, and handle instanced geometry with \instancedArray\ and the \instance()\ setup function. Additionally, a new \Batch\ module provides \batch()\ and \batchIndirectIndex\ to support \BatchedMesh\ transformations and motion vectors. These changes also include updated accessors for bitangents, camera matrices (supporting \ArrayCamera\), and material properties, all implemented as new files replacing the previous monolithic structure.

src/nodes/accessors · high confidence

Three new physics engine wrappers are now available in the examples directory: AmmoPhysics, JoltPhysics, and RapierPhysics. These modules allow developers to integrate Ammo.js, Jolt, and Rapier physics engines into their Three.js applications by automatically loading the respective libraries from a CDN. Each wrapper provides a consistent API for adding scenes and meshes, supporting features like dynamic/static body creation, restitution, and instanced meshes, with specific geometry support varying by engine (e.g., Rapier supports RoundedBoxGeometry and trimeshes, while Jolt and Ammo focus on boxes and spheres).

examples/jsm/physics · high confidence

Added new procedural generators for creating complex scenes: CityGenerator lays out city blocks with skyscrapers, sidewalks, and street furniture; ForestGenerator carpets terrain with instanced trees; TerrainGenerator bakes procedural mountain ranges; and TreeGenerator grows detailed tree skeletons. These generators provide new capabilities for building diverse, large-scale environments programmatically.

examples/jsm/generators · high confidence

A new \shapeCircle\ function has been added to the shapes module, allowing users to generate circle shapes based on UV coordinates. The function supports anti-aliasing through alpha-to-coverage when the renderer provides samples, otherwise falling back to a standard step function, providing a flexible way to create circular masks or shapes in node-based materials.

src/nodes/shapes · high confidence

The extras module now includes several new utility classes: Controls serves as an abstract base class for managing user input and DOM event listeners; DataUtils provides functions for converting between single and half-precision floating-point values; Earcut wraps the mapbox/earcut library for polygon triangulation; ImageUtils offers helpers for generating data URIs and converting sRGB images to linear color space; PMREMGenerator creates Prefiltered, Mipmapped Radiance Environment Maps for image-based lighting; ShapeUtils provides functions for calculating polygon area, winding order, and triangulation; and TextureUtils adds methods to scale textures (contain, cover, fill) and calculate byte lengths for various compressed texture formats.

src/extras · high confidence

This update introduces several new utility modules in the examples/jsm/utils directory. GaussianSplatUtils provides functions to create and manage Gaussian splat geometry, including support for packed spherical harmonics. ColorUtils adds a setKelvin function to convert color temperatures to sRGB colors for physically-based lighting. CameraUtils introduces a frameCorners function to set a perspective camera's projection and orientation to frame an arbitrary rectangle. Additionally, GeometryUtils now includes generators for Hilbert and Gosper curves, and SceneUtils adds functions to create meshes from instanced or multi-material meshes.

examples/jsm/utils · high confidence

The node system has been significantly restructured with the introduction of new core node classes including ArrayNode, AssignNode, AttributeNode, BypassNode, ConstNode, ContextNode, IndexNode, InputNode, InspectorNode, IsolateNode, LightingModel, MRTNode, Node, NodeAttribute, NodeBuilder, NodeCache, NodeCode, NodeError, and NodeFrame. These classes form the foundation of the new TSL (Three.js Shader Language) system, enabling more flexible shader code generation, context management, multi-render target (MRT) support, and improved caching mechanisms. The NodeBuilder has been completely rewritten to support the new node architecture, while ContextNode allows for context modification during node building, and InspectorNode enables runtime inspection of node values for debugging purposes.

src/nodes/core · high confidence

The texture system has been reorganized into a modular structure under src/textures, introducing dedicated classes for specific use cases. This includes CanvasTexture for HTML canvas elements, HTMLTexture for live HTML elements, VideoTexture and VideoFrameTexture for video data, and ExternalTexture for raw GPU textures. Compressed textures are now handled by CompressedTexture, CompressedCubeTexture, and CompressedArrayTexture, while DataTexture, DataArrayTexture, and Data3DTexture provide direct access to raw buffer data. Cube textures are split into CubeTexture and CubeDepthTexture, and FramebufferTexture enables capturing framebuffer contents. A new TextureSource class decouples texture data from texture definitions, allowing shared data sources across multiple textures. These changes provide a more organized API with specialized classes for different texture types and data sources.

src/textures · high confidence

The WebGPU backend now uses a set of dedicated utility modules in \src/renderers/webgpu/utils\ to manage core rendering operations. \WebGPUAttributeUtils\ handles vertex and storage buffer creation, including padding for WGSL alignment and patching for 16-bit integer attributes. \WebGPUBindingUtils\ manages GPU bind group layouts and groups with caching to optimize resource binding. \WebGPUPipelineUtils\ constructs render and compute pipelines, handling material blending, stencil operations, and depth states. \WebGPUTextureUtils\ and \WebGPUTexturePassUtils\ manage texture creation, sampling, and internal copy passes for mipmaps. \WebGPUConstants\ provides a centralized mapping of WebGPU enums, while \WebGPUCapabilities\ exposes device limits. \WebGPUTimestampQueryPool\ enables performance measurement via GPU timestamps, and \WebGPUUtils\ offers common helpers like canvas format detection.

src/renderers/webgpu/utils · high confidence

The rendering engine has been refactored to use a new common, backend-agnostic architecture located in \src/renderers/common\. This change introduces a suite of new management components—including \Animation\, \Attributes\, \Backend\, \Background\, \BindGroup\, \Bindings\, \BlendMode\, \Buffer\, \BundleGroup\, \CanvasTarget\, \ChainMap\, and \ClippingContext\—which replace the previous implementation. This new structure centralizes core rendering logic, allowing the \WebGPURenderer\ and \WebGLRenderer\ to share a unified foundation while handling backend-specific operations through the abstract \Backend\ interface.

src/renderers/common · high confidence

The LWO loader implementation has been restructured from a single monolithic file into three distinct ES6 classes: IFFParser, LWO2Parser, and LWO3Parser. This change improves code organization and maintainability by separating the IFF container parsing logic from the specific LWO2 and LWO3 block handling, while preserving the existing functionality for loading LightWave 3D models.

examples/jsm/loaders/lwo · high confidence

The shader architecture has been refactored to replace the monolithic ShaderLib and UniformsUtils with a modular system. Shader code is now organized into individual GLSL files managed by ShaderChunk, while material definitions in ShaderLib and uniform definitions in UniformsLib are rebuilt by importing these chunks. This change improves code maintainability and enables better tree-shaking by allowing only the necessary shader parts to be included. Additionally, a new DFGLUTData module provides a precomputed lookup table for physically based specular lighting calculations.

src/renderers/shaders · high confidence

The shader logic in src/renderers/shaders/ShaderChunk has been reorganized from monolithic or inline definitions into a set of granular, reusable GLSL.js chunks (e.g., alphatest, clearcoat, envmap, lighting). This modularization allows specific rendering features—such as alpha hashing, ambient occlusion, and physical environment mapping—to be included or excluded independently, improving maintainability and reducing the size of compiled shader programs by only pulling in the code required for the active material features.

src/renderers/shaders/ShaderChunk · high confidence

A change to existing behaviour in examples/models/tilt — 1 commit, 1 file.

examples/models/tilt · low confidence · unverified

A change to existing behaviour in examples/textures/equirectangular — 15 commits (1 fix), 17 files.

(repo-wide) · medium confidence · unverified

A change to existing behaviour in examples/models/vox — 3 commits, 3 files.

examples/models/amf, examples/models/vox · medium confidence · unverified

The examples/jsm/Addons.js entry point has been updated to reflect significant changes in the available addons. New capabilities are now exposed, including the UltraHDRLoader, GaussianSplat object, Sculptor utility, TileCreasedNormalsPlugin, and LoftGeometry. Several legacy or deprecated modules have been removed from the public export surface, specifically LogLuvLoader, RGBMLoader, CinematicCamera, MMD modules, GPUStatsPanel, PeppersGhostEffect, and TiltLoader. Additionally, the barrel no longer exposes LWO parsers, and the SkyGPU and WaterGPU modules have been renamed to Sky and Water respectively.

examples/jsm · high confidence

The audio modules (Audio, AudioListener, PositionalAudio, AudioAnalyser, AudioContext) have been converted to ES6 classes and restructured. PositionalAudio now uses HRTF panning model by default for improved 3D audio results. A new AudioAnalyser class allows frequency data analysis of audio sources. AudioListener now uses a Timer for delta time calculations instead of Clock, and master volume changes use setTargetAtTime for smoother transitions. The Audio class includes fixes for playback control flags, loop handling, and source connection management.

src/audio · high confidence

Added a README file to the NRRD models directory that documents the origin and licensing of the included 3D volume data. Specifically, it identifies stent.nrrd as a public domain conversion from the imageio project and notes the source of l.nrrd as unknown, ensuring users are aware of the data provenance.

examples/models/nrrd · high confidence

The ColladaLoader has been split into separate modular files (ColladaComposer, ColladaParser, etc.) to improve maintainability. This update enhances animation support by introducing deferred pivot animation handling and improved track building. It also adds support for \instance\_joint\ elements, allowing for better skeletal hierarchy representation, and enables loading of \polygons\ primitives in geometry data. Additionally, spot lights now correctly apply falloff angles, improving lighting accuracy in loaded scenes.

examples/jsm/loaders/collada · high confidence

All controls in the examples (Orbit, Trackball, Arcball, Transform, Drag, Fly, FirstPerson, PointerLock, and Map) have been rewritten as ES6 classes extending the new base Controls class. The interaction model has been updated to use Pointer Events instead of legacy mouse/touch events, and the domElement is now a mandatory constructor argument. This change introduces new capabilities such as ArcballControls for virtual trackball navigation, MapControls for map-like panning, and DragControls with rotate mode, while ensuring consistent behavior across mouse, touch, and pen inputs.

examples/jsm/controls · high confidence

The curve classes in \src/extras/curves\ (including \ArcCurve\, \CatmullRomCurve3\, \CubicBezierCurve\, \EllipseCurve\, \LineCurve\, \QuadraticBezierCurve\, and \SplineCurve\) have been rewritten as ES6 classes. This change introduces standard \copy()\, \toJSON()\, and \fromJSON()\ methods to all curve types, enabling reliable cloning and serialization. Additionally, \CatmullRomCurve3\ now supports closed curves and multiple parameterizations (centripetal, chordal, and catmullrom) to prevent cusps and self-intersections, while \EllipseCurve\ gains an optional rotation parameter.

src/extras/curves · high confidence

The CommonJS build (build/three.cjs) is now deprecated and will be removed in a future release. It currently re-exports the ES module via require(esm) and emits a DeprecationWarning when used. Users should replace \require('three')\ with \import \* as THREE from 'three'\ to adopt the ESM-only approach.

build · high confidence

The editor's main stylesheet has been replaced to introduce comprehensive styling for new UI elements including TabbedPanel, Listbox, and CodeMirror integration, while also adding native dark mode support via the CSS color-scheme property and refining the outliner's visual behavior.

editor/css · high confidence

The published editor application template (index.html) has been updated to use ES modules via an import map instead of global script tags. This change modernizes the runtime environment for exported projects, allowing for cleaner module resolution and better compatibility with modern browser standards. The template also includes a placeholder for the project title and generator metadata.

editor/js/libs/app · high confidence

The editor's command system has been restructured into individual ES6 modules within the \editor/js/commands\ directory, replacing the previous flat structure. This change introduces several behavioral updates: \MoveObjectCommand\ now dispatches an 'added' event on the moved object during execute and undo operations, and \SetValueCommand\ no longer dispatches \sceneGraphChanged\ signals, reducing unnecessary UI updates. Additionally, \SetGeometryCommand\ now disposes of old geometries before assignment, and material-related commands (\SetMaterialColorCommand\, \SetMaterialMapCommand\, etc.) now support a \materialSlot\ parameter to handle multi-material objects correctly.

editor/js/commands · high confidence

The editor's \index.html\ has been updated to use an import map for module resolution, defining aliases for \three\, \three/webgpu\, and \three/addons/\ pointing to the local build and examples directories, while also importing external libraries like \three-gpu-pathtracer\ and \three-mesh-bvh\ from jsdelivr. Additionally, the editor instance and the \THREE\ namespace are now explicitly exposed on the \window\ object, allowing scripts and the browser console to access them directly.

editor · high confidence

The spline editor example has been refactored to improve the organization and usage of its control components, likely enhancing usability and code maintainability within the interactive demo.

examples · medium confidence

All geometry classes in src/geometries have been converted to ES6 classes extending BufferGeometry, replacing legacy implementations. This introduces a standardized API where every geometry exposes a parameters object storing constructor arguments, supports cloning via the copy() method, and enables serialization/deserialization through static fromJSON() factory methods. The refactoring also includes structural improvements such as making constructor parameters optional with sensible defaults, adding missing vertex normals, and ensuring consistent multi-material support via geometry groups.

src/geometries · high confidence

The Inspector's user interface has been refactored to improve performance and visual consistency. Graph metrics (such as FPS and memory) are now rendered using HTML5 Canvas instead of the previous DOM-based approach, providing smoother real-time updates. The UI styling has been migrated to use CSS @scope to encapsulate styles within the inspector, preventing leakage into the host application and ensuring a consistent dark theme. Additionally, the UI now supports CSP compliance via nonce injection and includes new components for collapsible list items and parameter values with drag-to-adjust functionality.

examples/jsm/inspector/ui · high confidence

The animation system now provides distinct, type-specific keyframe track classes (Boolean, Color, Number, Quaternion, String, and Vector) that extend the base KeyframeTrack. This change allows users to create tracks with explicit type semantics, such as discrete interpolation for Boolean and String tracks, and specialized quaternion linear interpolation for Quaternion tracks, improving clarity and correctness when animating different data types.

src/animation/tracks · high confidence

The animation module has been replaced with a new clip-based architecture, introducing core classes such as AnimationClip, AnimationAction, AnimationMixer, and KeyframeTrack. This change brings support for multiple interpolation modes (linear, discrete, smooth, and Bezier), additive animation blending, and the ability to group objects for shared animation states via AnimationObjectGroup. Users will now define animations as reusable clips containing keyframe tracks, which are scheduled and blended by actions within a mixer, replacing the previous legacy animation API.

src/animation · high confidence

The light system in \src/lights\ has been rewritten as a set of ES6 classes (Light, AmbientLight, DirectionalLight, HemisphereLight, LightProbe, PointLight, RectAreaLight, SpotLight) inheriting from Object3D, replacing the previous prototype-based structure. This change introduces a consistent API across all light types, including standardized \color\ and \intensity\ constructor parameters, unified \copy()\ and \toJSON()\ serialization methods, and \dispose()\ lifecycle management. Directional, Point, and Spot lights now support shadow casting via dedicated shadow classes (DirectionalLightShadow, PointLightShadow, SpotLightShadow) that manage their own view cameras and configuration properties like bias, radius, and map size. Point and Spot lights also expose a \power\ getter/setter for physically-based intensity control, while SpotLight gains \penumbra\ and \map\ (cookie) support. HemisphereLight and AmbientLight remain non-shadow-casting but follow the same structural pattern.

src/lights · high confidence

The manual pages in manual/pages have been completely rewritten to use modern Three.js patterns and improved documentation structure. Key changes include: replacing legacy Mesh-based billboards with Sprite/SpriteMaterial for labels that always face the camera; adding HTML element alignment to 3D objects using CSS positioning and world-to-screen coordinate conversion; updating background examples to support both CSS-based backgrounds and scene-based backgrounds with proper aspect ratio handling for textures and cubemaps; introducing a new Cameras article with interactive GUI controls for adjusting near/far planes and field of view, including a split-view demonstration using scissor testing; adding a new Animation System overview covering clips, keyframe tracks, mixers, and actions; and implementing a ResourceTracker class in the Cleanup article to help manage memory by tracking and disposing of geometries, textures, and materials. The pages also use import maps for module imports and include updated code examples throughout.

manual/pages · high confidence

The manual site has been restructured to improve navigation and content organization. A new \list.json\ file defines the updated manual structure, which now includes a dedicated 'Physics' page under the 'Fundamentals' section and a 'WebGPU' section containing guides for the WebGPURenderer and its post-processing capabilities. The site's frontend (\index.html\) has been updated to support this new navigation hierarchy, and a new \split.min.js\ library (v1.3.5) has been added to the \3rdparty\ folder to handle the resizable navigation panel layout.

manual · high confidence

The MaterialX loader implementation has been significantly restructured to improve reliability and expand shader capabilities. A new MaterialXArchive module now handles .mtlx.zip packages, ensuring that loading promises only resolve once all sub-resources are fully loaded, which prevents race conditions. The loader also introduces support for hextile textures via new coordinate and blend weight computation functions, and includes a comprehensive interface validation system with a detailed node registry to better map MaterialX node definitions to Three.js materials.

examples/jsm/loaders/materialx · high confidence

The material system has been refactored to use ES module syntax, with all material classes (such as MeshStandardMaterial, MeshPhysicalMaterial, and LineBasicMaterial) inheriting from a single, unified Material base class. This change introduces a consistent API across all materials, including standardized properties like opacity, blending, and fog, and ensures that serialization, cloning, and copying methods are uniformly implemented. Users will benefit from a more predictable and maintainable material system, with improved support for advanced features like custom blending, alpha hashing, and environment map rotation.

src/materials · high confidence

The camera system has been restructured with a new abstract \Camera\ base class that inherits from \Object3D\ and manages \matrixWorldInverse\ and \projectionMatrixInverse\. \PerspectiveCamera\ and \OrthographicCamera\ now extend this base, introducing a \zoom\ property and \view\ offset support for multi-window setups. A new \ArrayCamera\ is available for efficiently rendering scenes with multiple sub-cameras, which is particularly useful for VR multiview rendering. \StereoCamera\ has been updated to use layers for rendering per-eye content and includes caching for performance. \CubeCamera\ now supports multiple coordinate systems (WebGL and WebGPU) and manages its own render target.

src/cameras · high confidence

The BSDF node functions have been reorganized into a modular library of individual components (BRDF\_EON, BRDF\_GGX, BRDF\_Lambert, BRDF\_Sheen, D\_GGX, V\_GGX\_SmithCorrelated, F\_Schlick, etc.) to support more flexible material construction. This change introduces the EON rough diffuse BRDF for energy-preserving diffuse shading, adds anisotropic support to the GGX microfacet model, and provides dedicated functions for sheen, environment mapping, and Linearly Transformed Cosines (LTC) area lighting, enabling more accurate and customizable physically based rendering.

src/nodes/functions/BSDF · high confidence

The node system has been restructured to improve performance and maintainability. The central management component has been renamed from \Nodes\ to \NodeManager\, which now handles node builder states, caching, and async compilation. A new \NodeLibrary\ class manages mappings for materials, tone mapping, and lights (with deprecated \addLight\/\getLightNodeClass\ methods warning users to use \Light.registerNode()\). The binding system now uses node-based wrappers (\NodeUniform\, \NodeSampler\, \NodeSampledTexture\, \NodeStorageBuffer\, etc.) that derive values from node objects, ensuring bindings stay in sync with node updates. \NodeBuilderState\ now tracks \updateBefore\ and \updateAfter\ nodes for compute stages, and \NodeUniformBuffer\ correctly exposes \byteLength\ via a getter that follows the overridden \buffer\ property.

src/renderers/common/nodes · high confidence

The PMREMGenerator has been rewritten to use the new NodeMaterial system, replacing the previous CubeUV atlas approach with cube render targets and implementing GGX VNDF importance sampling for improved accuracy. The synchronous \fromScene()\ method is now the primary interface, accepting optional \size\, \position\, and \renderTarget\ parameters, while the asynchronous \fromSceneAsync()\ method has been deprecated in favor of awaiting \renderer.init()\ first. This change also introduces a spiral blur algorithm to replace the previous separable blur and fixes issues with back-side materials and black HDRIs when processing textures of different sizes.

src/renderers/common/extras · high confidence

The post-processing examples have been converted from the legacy /examples/js directory structure to modern ES6 modules located in /examples/jsm/postprocessing. This change introduces TypeScript definitions for all passes (including Afterimage, Bloom, Bokeh, Clear, CubeTexture, DotScreen, EffectComposer, FXAA, Film, GTAO, Glitch, Halftone, LUT, Mask, and Outline) and standardizes the API by adding explicit dispose() methods to manage GPU resources, ensuring proper cleanup when passes are removed from the EffectComposer.

examples/jsm/postprocessing · high confidence

The post-processing shader library has been converted from legacy script files to ES6 modules. This change updates the import paths and export structure for all included shaders (such as ACESFilmicToneMapping, Bokeh, FXAA, and SSAO), requiring users to update their import statements to use the new module format.

examples/jsm/shaders · high confidence

The core 2D geometry classes (Curve, CurvePath, Path, Shape, ShapePath) have been rewritten as ES6 classes with a cleaner inheritance hierarchy and improved API consistency. CurvePath now returns \this\ from \closePath()\ to support method chaining, and \getPoint()\ accepts an optional target vector for performance. ShapePath has been decoupled from Path to better handle font and SVG loading workflows, and Shape now includes UUID generation and robust serialization (toJSON/fromJSON) for holes. These changes provide a more stable foundation for 2D shape manipulation and extrusion.

src/extras/core · high confidence

All helper classes in src/helpers (ArrowHelper, AxesHelper, Box3Helper, BoxHelper, CameraHelper, DirectionalLightHelper, GridHelper, HemisphereLightHelper, PlaneHelper, PointLightHelper, PolarGridHelper, SkeletonHelper, and SpotLightHelper) have been converted to ES6 classes. To ensure helpers remain visible regardless of scene lighting, their materials now use toneMapped: false. Each helper now implements a dispose() method to properly free GPU resources (geometries and materials). Additionally, specific behaviors were refined: BoxHelper.setFromObject() now returns the instance for chaining, and SkeletonHelper exposes a setColors() method for customizing bone visualization colors.

src/helpers · high confidence

The shader library has been consolidated into a single, unified structure, introducing new shader modules for background rendering (including intensity control for 2D and cube maps), depth buffering with high-precision support for reversed depth buffers, and distance-based shading. Material shaders have been modernized to support advanced physical properties such as iridescence, thin-film effects, dispersion, sheen, anisotropy, and retroreflectivity, while also adding support for morph targets in instanced meshes and environment map-based image-based lighting (IBL) for legacy materials like MeshLambert and MeshPhong.

src/renderers/shaders/ShaderLib · high confidence

The Earcut polygon triangulation library used in the extras module has been updated to version 3.0.2. This change replaces the previous implementation with the latest upstream code from mapbox/earcut, which may include performance improvements and bug fixes related to triangulation accuracy and handling of complex polygon shapes with holes.

src/extras/lib · high confidence

The WebGL renderer no longer supports WebGL 1.0; all WebGL 1-specific code paths and legacy capabilities have been removed, requiring a WebGL 2-compatible browser or environment to render scenes.

src/renderers/webgl · high confidence

The WebGPU renderer now uses dedicated, reusable descriptor classes (such as GPURenderPassDescriptor, GPUTextureDescriptor, and GPUSamplerDescriptor) with built-in reset methods. This change supports descriptor caching and reuse, reducing object allocation overhead during rendering operations.

src/renderers/webgpu/descriptors · high confidence

The WebXR helper classes in examples/jsm/webxr (ARButton, VRButton, XRButton, XRHandModelFactory, XRControllerModelFactory, and others) have been converted from function-based exports to ES6 classes. This change introduces support for the WebXR offerSession API, allowing users to start sessions from any page rather than only the initial entry point. Hand models now support custom GLTFLoader injection, optional onLoad callbacks, and asset caching for better performance. The XRButton class provides a unified entry point that automatically selects between AR and VR modes. Additionally, a new WebGLXRFallback utility enables graceful fallback to WebGL when WebGPU XR is unavailable, and XRPlanes now dispatches planeschanged events for easier integration with physics engines.

examples/jsm/webxr · high confidence

A fix in examples/models/fbx/archer — 3 commits (2 fixs), 3 files.

examples/models/fbx/archer · medium confidence · unverified

The renderers now correctly respect the renderOrder property of objects even when the reversed depth buffer is enabled. Previously, the depth sorting logic did not account for the reversed depth buffer, which could cause objects to be rendered in the wrong order and appear incorrectly. This fix ensures that explicit render ordering is maintained regardless of the depth buffer configuration.

src/renderers · high confidence

Added documentation for ClearcoatTest model; Added test assets for Collada polygons primitives; Added unit tests for the animation, audio, and camera subsystems; New E2E and unit test infrastructure with treeshake verification.

The Draco 3D data compression library files in examples/jsm/libs/draco have been updated to version 1.5.6. This includes new builds of the JavaScript decoder (draco\_decoder.js), the WebAssembly decoder (draco\_decoder.wasm), and the WASM wrapper (draco\_wasm\_wrapper.js). A README.md file has also been added to this directory to document the available utilities and their usage with DRACOLoader.

examples/jsm/libs/draco · high confidence

The bundled chevrotain module in examples/jsm/libs has been updated to version 9.0.1. This upgrade replaces the previous version (0.5.0) and includes internal changes to the regexp-to-ast parser and lexer optimization logic, which may affect how custom token patterns and regular expressions are processed in grammar-based examples.

examples/jsm/libs · high confidence

The development environment has been upgraded to use ESLint 10 (with flat config support) and Rollup 4, alongside updates to key build plugins like @rollup/plugin-node-resolve and @rollup/plugin-terser. This shift modernizes the linting and bundling infrastructure, ensuring compatibility with the latest JavaScript standards and improving build performance for the library's source code and examples.

(dependencies) · high confidence

Added RobotExpressive model documentation; Added audio asset attribution documentation; Added documentation for KMZ model assets; Added license files for SPZ example models; Added metadata files for example video assets.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 46 → 40 (-5.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 41 → 36 (-5.6)
• Architecture 98 → 99 (+0.3)
• Maturity 56 → 65 (+9.7)
• Readiness 47 → 49 (+2.1)
• Security 80 → 72 (-7.7)
• Accessibility 39 → 30 (-9.0)

• (anonymous) (cognitive 19) (editor/js/Sidebar.Settings.Shortcuts.js)
• (anonymous) (cognitive 19) (utils/server.js)
• (anonymous) (cognitive 22) (devtools/background.js)
• (anonymous) (cognitive 27) (editor/js/Script.js)
• (anonymous) (cyclomatic 17) (editor/js/Script.js)
• (anonymous) (cyclomatic 18) (editor/js/Sidebar.Settings.Shortcuts.js)
• Boundary-crossing change coupling: MeshStandardMaterial.js ↔ ShaderLib.js (src/materials/MeshStandardMaterial.js)
• Boundary-crossing change coupling: MeshStandardMaterial.js ↔ WebGLMaterials.js (src/materials/MeshStandardMaterial.js)
• Boundary-crossing change coupling: MeshStandardMaterial.js ↔ WebGLProgram.js (src/materials/MeshStandardMaterial.js)
• Boundary-crossing change coupling: MeshStandardMaterial.js ↔ lights_physical_fragment.glsl.js (src/materials/MeshStandardMaterial.js)
• Boundary-crossing change coupling: MeshStandardMaterial.js ↔ meshphysical.glsl.js (src/materials/MeshStandardMaterial.js)
• Change coupling: lights_physical_fragment.glsl.js ↔ meshphysical.glsl.js (src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl.js)
• Change coupling: lights_physical_pars_fragment.glsl.js ↔ meshphysical.glsl.js (src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• FileTooLong: extras/PMREMGenerator.js (src/extras/PMREMGenerator.js)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Orphaned knowledge (manual/resources/prettify.js)
• …and 107 more

• (anonymous) (cognitive 18) (src/materials/nodes/Line2NodeMaterial.js)
• (anonymous) (cognitive 40) (editor/js/libs/codemirror/codemirror.js)
• (anonymous) (cognitive 74) (devtools/bridge.js)
• (anonymous) (cyclomatic 41) (editor/js/libs/codemirror/codemirror.js)
• (anonymous) (cyclomatic 69) (devtools/bridge.js)
• (anonymous) (cyclomatic 92) (manual/resources/tools/geo-picking/shapefile.js)
• (anonymous)::$prettyPrint::doWork (cognitive 92) (manual/resources/prettify.js)
• (anonymous)::$prettyPrint::doWork (cyclomatic 39) (manual/resources/prettify.js)
• (anonymous)::(anonymous)::next (cognitive 24) (editor/js/libs/jsonlint.js)
• (anonymous)::(anonymous)::next (cyclomatic 16) (editor/js/libs/jsonlint.js)
• (anonymous)::CodeMirror (cognitive 20) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::CodeMirror (cyclomatic 20) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::Server (cognitive 31) (editor/js/libs/ternjs/tern.js)
• (anonymous)::addChangeToHistory (cognitive 21) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addChangeToHistory (cyclomatic 16) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addEditorMethods::addWidget (cognitive 16) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addEditorMethods::findWordAt (cognitive 16) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addEditorMethods::getHelpers (cognitive 17) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addEditorMethods::getTokenTypeAt (cognitive 16) (editor/js/libs/codemirror/codemirror.js)
• (anonymous)::addType (cognitive 17) (editor/js/libs/ternjs/infer.js)
• …and 1071 more

• 300 commits — 250 feature/other, 50 fixes

• examples/jsm — 67 commits
• src/renderers — 59 commits
• src/nodes — 40 commits
• test/unit — 24 commits
• (root) — 14 commits
• examples/screenshots — 14 commits
• build/three.core.js — 13 commits
• .github/workflows — 6 commits
• editor/js — 5 commits
• tsl/js — 5 commits
• examples/models — 4 commits
• examples/tags.json — 4 commits
• src/materials — 4 commits
• src/math — 4 commits
• build/three.module.js — 3 commits
• examples/files.json — 3 commits
• test/e2e — 3 commits
• devtools/panel — 2 commits
• examples/webgpu_loader_materialx.html — 2 commits
• examples/webgpu_materialx_noise.html — 2 commits

• fix: Bindings: Fix stale storage buffer attributes. (#34388)
• fix: E2E: Try to fix the webgpu async timeouts (#34225)
• fix: Editor: Fix animation selection. (#34322)
• fix: Examples: Fix MaterialX shader precompilation.
• fix: FBXLoader: Fix missing userData copy. (#34302)
• fix: Fix GLSL Bitcount + add test coverage for BRDF/BSDF, depth, color space, type constructors, and bit operations (#34350)
• fix: Fix editor lint warnings (#34515)
• fix: Fix resize flickering in Playground (#34511)
• fix: Fix: Correct the color space setting in USDComposer to be linear sRGB. (#34644)
• fix: FramebufferTexture: Fix source copy. (#34636)
• fix: GaussianSplatMesh: Fix sort invalidation for transforms (#34233)
• fix: LightProbeGridWebGL: Fix SunLight integration. (#34370)
• fix: Line3: Fix at() return description. (#34545)
• fix: LineMaterial: Fix world-unit extrusion with orthographic cameras. (#34540)
• fix: MRTNode: Fix blend modes bug in merge(). (#34248)
• fix: MaterialNode: Fix clearcoat roughness texture channel. (#34564)
• fix: MathUtils: Fix large isPowerOfTwo values (#34459)
• fix: NURBSCurve: Fix clone(). (#34542)
• fix: ObjectLoader: Fix loading of BatchedMesh available ids. (#34652)
• fix: PLYLoader: Fix colors, tex coords and indices for quads. (#34649)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

mrdoob/three.js was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.