Three.js is a mature, production-grade JavaScript 3D library providing WebGL and WebGPU renderers, a comprehensive scene graph, and extensive tooling for 3D web applications. The codebase demonstrates exceptional architecture with a clean separation between core rendering (src/), the new node-based shader system TSL (Three.js Shading Language), and a vast ecosystem of addons in examples/jsm/. The library supports multiple renderers (WebGLRenderer, WebGPURenderer, CSS2DRenderer, CSS3DRenderer, SVGRenderer), a full animation system, physics integrations (Ammo, Rapier, Jolt), WebXR for AR/VR, and loaders for 30+ formats (GLTF, FBX, USD, OBJ, etc.). The TSL node system is a standout achievement - a compiler-like architecture that transpiles shader graphs to GLSL/WGSL with automatic differentiation, lighting models, and post-processing. The WebGPU backend shows deep GPU API expertise with pipeline management, bind groups, and descriptor reuse. Code quality is consistently high with strong typing patterns, comprehensive unit tests (200+ test files), and modern ES module architecture. The project is actively maintained with recent commits, semantic versioning, and CI/CD pipelines.
PixiJS is a mature 2D rendering library for the web (npm package pixi.js). Its production purpose is to let developers build interactive scenes, games, visualizations, and creative applications using an object-oriented scene graph and render them through WebGL, WebGPU, or Canvas backends. The core runtime is a modular TypeScript library, not a monolith: users construct Containers, Sprites, Graphics, Text, Meshes, and ParticleContainers, then a renderer collects renderables into instruction sets, batches draw calls through backend-specific adaptors and pipes, and manages GPU resources such as textures, buffers, uniform groups, and render targets via pooling and garbage-collected caches. The repository also includes an asset subsystem with loader parsers, a resolver, a cache, and format detection, plus an extension registry that allows custom systems, loaders, pipes, filters, and backend adaptors to be registered cleanly. Primary entry points are src/index.ts, the Application class with initialization and plugins (ResizePlugin, TickerPlugin, CullerPlugin), autoDetectRenderer, and the Assets API. The library depends on browser platform capabilities (Canvas 2D, WebGL/WebGPU, OffscreenCanvas, Web Workers, fetch) and small npm packages; compressed-texture support shells out to Basis/KTX transcoders. Data flows are asset ingestion (fetch/parse/cache) and GPU command generation; there is no server-side pipeline or ETL component. The codebase shows strong engineering practice: typed extension points, backend abstraction layers, performance-conscious allocation management, dual GLSL/WGSL shader support, and an extensive test suite including snapshot-based visual regression tests across WebGL1, WebGL2, WebGPU, and Canvas. Some deprecation shims and experimental features exist, but the project is actively maintained with recent commits, release automation, and active issue triage.
glTF-Transform is a comprehensive SDK and CLI tool for processing, optimizing, and inspecting glTF/GLB 3D assets. It provides a rich property graph model (Document) for reading, editing, and writing glTF files, with full support for the glTF 2.0 specification and dozens of official extensions (KHR_materials_*, EXT_meshopt_compression, etc.). The library includes a broad set of transforms (compression, quantization, deduplication, welding, palette optimization, texture compression, etc.) that can be composed into custom pipelines. A command-line interface wraps all transforms for batch processing, and a viewer package provides real-time Three.js integration. Built as a monorepo with packages for core, extensions, functions, CLI, view, and docs, it demonstrates strong software engineering practices: property-graph architecture, extension system, observer patterns, and comprehensive unit/integration tests. Designed for both scripting in Node.js/Deno/Web and direct use from the command line.
Fyrox is a large, mature Rust game engine delivered as a multi-crate workspace, plus a full visual scene editor (fyroxed) and a project manager. The codebase implements a complete runtime stack: 3D/2D rendering through OpenGL or wgpu backends, a scene graph with dynamic node types, physics integration via Rapier, an animation system with ABSM state machines, a sound engine with HRTF and DSP effects, a custom UI toolkit, and an async resource loading framework. The editor is built on the engine's own UI and uses plugin architecture, command-based undo/redo, inspector property editors, gizmos, tilemap tools, and asset browsers. Entry points include the public `fyrox` facade crate, `editor-standalone/src/main.rs` for the editor binary, `project-manager/src/main.rs` for project management, and example applications in `examples/` and `fyrox-sound/examples/`. Architecturally, the engine is a library plus a desktop application rather than a service. It relies heavily on a custom reflection and serialization stack (`Reflect`, `Visit`, type UUIDs, builder patterns) that powers scene persistence, asset hot-reloading, and editor inspectors. The primary data flow is asset-to-scene: resource loaders read files (FBX, glTF, RGS, RON, audio, textures), construct typed resources through UUID-driven constructor containers, and insert them into the scene graph; the renderer then converts scene nodes into GPU data via deferred rendering, caches, and visibility/occlusion systems. Plugin/script hot-reload is supported for dynamic loading of game code. External dependencies include winit for windowing, Rapier for physics, nalgebra for math, wgpu/OpenGL for graphics, and OS audio backends. The codebase is generally well-engineered, with clear subsystem boundaries, reusable builder APIs, and an unusually deep custom infrastructure for an open-source engine. However, it carries notable maintenance risk: two graphics backends must stay in sync, parts of the editor are tightly coupled to engine internals, several modules contain unsafe transmutes or deliberate leaks, and the custom derive macros and serialization format require careful versioning. Dependency drift exists, including old `syn`/`darling` versions in `fyrox-core-derive` and unresolved backend feature gaps such as missing wgpu occlusion queries. Overall this is a strong, active codebase with several genuinely reusable components, but not an exceptionally polished one.
morphic.js is a dependency-free JavaScript library implementing the Squeak/Self-inspired Morphic UI framework on HTML5 Canvas. It provides a tree-structured scene graph of 'Morph' objects, a damage-based incremental rendering loop that repaints only dirty rectangles, a unified event dispatch system (mouse, touch, keyboard, drag-and-drop, external file drop), and a full widget toolkit including menus, sliders, dials, scroll frames, editable text fields, inspectors, color pickers, speech bubbles, and dialog prompts. It also includes a LOGO-style turtle (PenMorph) with a warp optimization for deep recursion. In production it serves as the GUI kernel for Snap!, the block-based programming environment — the heavy multi-touch editing, shape caching, template-dragging, and file-import behaviors in this file exist to support that use case. Architecturally it is a single-file monolith (~11k lines of code plus extensive embedded documentation) using classical prototypal inheritance mixed with modern ES2020+ syntax (const, arrow functions, optional chaining, async/await, Map). There are no imports, no build step, no package manifest, and zero external runtime dependencies — only browser Canvas/DOM APIs. The primary entry point is `new WorldMorph(canvasElement)`, driven by a requestAnimationFrame loop calling `world.doOneCycle()` (see minimal.html, morphic.html, multiple.html, sample.html for working demos). Data flows from browser events into WorldMorph's event listeners, get dispatched through HandMorph to target Morphs, and state changes push damaged rectangles into a 'broken' list that `doOneCycle()` condenses and redraws incrementally. The most reusable assets are the Point/Rectangle/Color value classes (full 2D vector math, rectangle algebra, HSV/HSL conversion), the self-contained retina display patcher for hi-DPI canvases, the generic Animation/easing engine, the PNG metadata embedding utility (iTXt chunk injection with CRC32), and the dirty-rectangle damage-merging renderer. Each of these can be extracted into a standalone project with minimal modification and demonstrates non-obvious craftsmanship. The codebase is remarkably well-commented with a full programming guide, inheritance hierarchy, and migration notes embedded in the source itself. Caveats: there are no automated tests, no CI, no npm packaging, heavy pollution of the global namespace, and an intentional `eval`-based inspector for developer mode. The AGPL-3.0 license and single-file distribution model reflect its Smalltalk 'kernel image' philosophy rather than modern modular library conventions. It is maintained but commit cadence is sparse (version string 2026-May-11, last push 2026-Sep-01), and 32 open issues show no obvious triage activity.
threeify is a TypeScript monorepo providing a WebGL2-based 3D rendering library with a focus on physically-based rendering (PBR), glTF support, and modular architecture. It is loosely derived from three.js but aims for a more modern, tree-shakeable design with native WebGL2 abstractions. The library includes a comprehensive math package (vectors, matrices, quaternions, colors, bounding volumes), a scene graph with cameras, lights, and materials (including clearcoat, sheen, transmission, and anisotropic extensions), a renderer with post-processing effects (tone mapping, Gaussian blur, bloom, cubemap background), a 2D layer compositor with blend modes and panorama support, and a custom GLSL-to-TypeScript transpiler for shader management. The codebase is organized into packages (core, math, scene, layer-compositor) and tools, with over 50 interactive examples demonstrating various rendering techniques. External dependencies include WebGL2 and browser APIs; the library is still in development and not yet recommended for production use.
GraphDreamer is a PyTorch-based system for generating compositional 3D scenes from scene graphs. It implements a coarse-to-fine approach where objects are represented as implicit signed distance functions (SDFs) and optimized using gradient signals from 2D diffusion models (DeepFloyd IF for coarse stage, Stable Diffusion for refinement). The system takes text prompts describing objects and their relationships, constructs a scene graph, and generates 3D meshes representing the composed scene. Architecture follows the threestudio framework with modular components for data handling, geometry, materials, guidance, rendering, and system orchestration. Key entry points are in launch.py which supports training, validation, testing, and export modes via command-line interface.
This repository is a C# port of the Three.js 3D library, providing a comprehensive 3D graphics framework for .NET applications. It implements a scene graph architecture with Object3D hierarchy, supporting geometries, materials, cameras, lights, and various loading mechanisms for 3D models and textures. The library offers multiple rendering backends (OpenTK/OpenGL and Silk.NET) and includes extensive example applications demonstrating features like physically-based rendering, post-processing effects, animation systems, and camera controls. The codebase shows good separation of concerns in core mathematical utilities and event systems, though suffers from some duplication between rendering backends and inconsistent patterns in examples.