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.
This repository is a high-performance 2D graphics library for React Native, wrapping the Skia graphics engine. It provides both a declarative JSX component API (Canvas, Group, Circle, Path) and an imperative Skia API, rendering on iOS, Android, macOS, and Web via CanvasKit WASM. The core architecture uses a custom React reconciler to convert the component tree into a command list, which is then replayed onto a Skia canvas, supporting GPU acceleration through Skia's Graphite backend and WebGPU via Dawn. The library's primary data flow involves recording drawing commands from the declarative tree or imperative API, then replaying them on the target platform's rendering backend. It deeply integrates with react-native-reanimated for declarative animations and react-native-worklets for multi-threaded rendering. The codebase is a monorepo with a core package, an extensive example app, a Docusaurus documentation site, and a headless Node.js rendering mode. Notable engineering highlights include a well-implemented Command Pattern for the recording/replay system, a sophisticated singleton Shared WebGL Context for managing browser context limits, a pure worklet-safe 3D math library, and a robust C++ template system for JS-to-native type conversion. These components demonstrate high craftsmanship and are safely reusable in other projects. The project is actively maintained with frequent commits and responsive issue triage. However, it exhibits medium technical drift due to its heavy reliance on patched versions of Skia and Dawn, an incomplete web API surface, and the coexistence of two JSI object models. The complex multi-platform build system is a significant maintenance burden.
This repository is the @playcanvas/supersplat-viewer npm package, an embeddable 3D Gaussian splatting viewer built on the PlayCanvas engine. It bootstraps a full web application around a PlayCanvas AppBase: createViewer(options) mounts a canvas and UI, loads .gsplat/.ply content plus optional skybox and voxel/mesh collision assets, and returns a ViewerHandle for capture, seeking, camera control, XR, and teardown. The default rendering path is the engine's sorted gsplat renderer; an opt-in WebGPU stochastic renderer provides unsorted splat projection, temporal anti-aliasing, occlusion culling, and depth-based picking. The repo is an application, not a data/research pipeline, though it contains research-grade rendering experiments and a dedicated benchmark harness.
SuperSplat is a browser-based 3D Gaussian Splatting editor built with the PlayCanvas engine and PCUI framework. It provides a full-featured editing environment for loading, inspecting, selecting, transforming, color-grading, and exporting Gaussian splat data (PLY, SOG, SPZ, Splat formats). The application supports real-time GPU-accelerated data processing (histograms, bounding boxes, picking), camera animation with keyframe tracks and spline interpolation, video export via WebCodecs, and publishing to the PlayCanvas platform. Its architecture is event-driven with a centralized command queue for serializing async GPU work, an undo/redo system, and a modular tool system covering selection (rect, lasso, polygon, brush, flood, eyedropper, sphere, box) and transformation (move, rotate, scale, measure, orient). The UI is fully localized into 9 languages and includes a service worker for offline caching.
A monorepo providing `@pixiv/three-vrm`, a library for loading, controlling, and rendering VRM (Virtual Reality Model) avatars in three.js. It implements VRM 1.0 and partial VRM 0.0 specifications, handling humanoid bone mapping, facial expressions, eye gaze control (lookAt), first-person mesh culling, spring bone physics simulation, node constraints (aim, roll, rotation), and MToon toon material rendering. The library is structured as a collection of GLTFLoader plugins that parse VRM extensions from `.vrm` files. Core modules include `VRMLoaderPlugin` (orchestrating sub-plugins), `VRMCore` (humanoid, expressions, lookAt, firstPerson), `VRMSpringBoneManager` (verlet physics), `VRMNodeConstraintManager` (topological sort for constraints), and `MToonMaterial`/`MToonNodeMaterial` (custom shader/material for toon rendering). Both WebGL and experimental WebGPU renderers are supported. The codebase includes thorough examples, CI/CD, and compatibility shims for multiple three.js revisions (r123 through r180).
This is a comprehensive educational website and tutorial series for WebGPU, the next-generation graphics API. It provides over 100 interactive lessons covering fundamentals, 3D math, lighting, textures, compute shaders, post-processing, and more. The site is built as a static site with a custom build system, featuring live code editors, interactive diagrams, and multilingual support. The codebase includes reusable WebGPU utilities, a diagram framework, and helper libraries for timing, texture loading, and shader reflection. It serves as both a learning resource and a reference for WebGPU developers.
A comprehensive monorepo for the maptalks 2D/3D WebGL/WebGPU map rendering engine. It provides a full-stack geospatial visualization framework including core map controls, geometry types (Marker, LineString, Polygon), multiple layer types (Tile, Vector, GLTF, 3D Tiles, Video, Particle), advanced shading (PBR, Phong, Cloth, Subsurface), post-processing (bloom, SSR, TAA, fog, weather), spatial analysis (viewshed, cut, flood, heightmap), traffic simulation, and interactive editing tools. The architecture is modular with ~20 interdependent packages under a pnpm workspace, using a custom WebGL abstraction (fusion.gl) and a vector tile pipeline with worker-based processing. It supports both Canvas2D and WebGL renderers, with emerging WebGPU support via WGSL shaders. The codebase is well-structured with reusable patterns (mixin, painter plugin, worker communication, LRU cache, texture pooling) but shows medium technical drift due to experimental WebGPU code, duplicated utility functions across packages, and reliance on legacy tooling (regl, shelf-pack).
Koharu is a desktop application for manga/comic translation, built with Rust (Tauri) and a React/TypeScript frontend. It provides an end-to-end pipeline: page import, AI-based layout detection, speech bubble segmentation, OCR (multiple models including Manga OCR, PP-OCRv6, Baberu OCR), text translation (local LLMs via llama.cpp and 13+ remote providers), inpainting (LaMa, AOT, FLUX.2 Klein, RORem mixed), and typesetting with CJK/RTL support. The application features a WebGPU canvas editor, project management with undo/redo, PSD export, and an AI agent (Codex) for natural-language editing. The architecture is modular: a scene graph document model (koharu-scene), content-addressed blob storage (koharu-storage), a pipeline orchestrator (koharu-pipeline), and a hardware abstraction layer (koharu-runtime) for CUDA/ROCm/Vulkan/Metal. The frontend uses a custom UI component library (packages/ui) built on @base-ui/react. While the codebase is well-structured and actively maintained, it has technical drift risks from pinned git dependencies, multiple ML model ports that must stay synchronized with upstream, and platform-specific runtime packages.
Cocos Creator engine runtime is a cross-platform 2D/3D game engine framework written in TypeScript and C++. It provides a component-entity architecture with scene graph, rendering pipelines (forward/deferred/custom), physics (PhysX, Bullet, Box2D, builtin), animation (marionette state machine, pose graph, Spine, DragonBones), audio, UI, particle systems, and asset management. The engine is designed to be used with the Cocos Creator editor but can run standalone. It abstracts platform-specific APIs (graphics, input, audio, system) behind a common interface, supporting Web, iOS, Android, Windows, macOS, Linux, and various mini-game platforms. Key entry points include the Director, Scene, Node, Component, and the rendering pipeline. External dependencies include graphics APIs (Vulkan, Metal, GLES, WebGPU), physics libraries (PhysX, Bullet, Box2D), and scripting engines (V8, SpiderMonkey, JavaScriptCore).
This repository is a comprehensive, step-by-step tutorial series for learning wgpu, the Rust implementation of WebGPU. It contains over 30 example crates organized into beginner, intermediate, compute, and showcase categories, each demonstrating a specific GPU concept (window creation, pipelines, buffers, textures, uniforms, instancing, depth, lighting, normal mapping, HDR, compute shaders, etc.). The code is production-quality Rust with extensive use of wgpu, winit, cgmath, and bytemuck. A reusable framework crate (`code/showcase/framework`) provides a `Demo` trait, camera, model/texture loading, and pipeline builders, which many showcases implement. The repository also includes a VuePress documentation site with embedded WebAssembly demos, build scripts for WASM deployment, and a demo server. While the tutorials are well-structured and educational, there is significant code duplication across crates (e.g., identical `build.rs` files, repeated initialization boilerplate), and some showcases are stale or excluded from builds. The codebase tracks wgpu API changes closely (news files document migrations from 0.12 to 30.0), but some patterns use deprecated APIs (e.g., `wgpu::Backends::PRIMARY`, `immediate_size` in pipeline layouts). Overall, it is a valuable learning resource with solid engineering practices, though not a production library.
This repository is a Chinese-language translation and expansion of the Learn wgpu tutorial series, teaching the wgpu Rust implementation of the WebGPU graphics API through a Cargo workspace of ~25 runnable example crates. The curriculum progresses from window/surface setup (tutorial1-2), render pipelines and buffers (tutorial3-4), textures/uniforms/instancing/depth (tutorial5-8), through OBJ model loading, Blinn-Phong lighting, normal mapping, camera control, compute-shader terrain generation, HDR rendering, and particle systems. Each example is a small but complete winit application that runs natively and as WebAssembly via wasm-bindgen, sharing a common utils crate that provides the WgpuAppAction lifecycle trait, node-based render abstractions (ViewNode, ComputeNode, BufferlessFullscreenNode), and buffer/bind-group helpers. A VitePress documentation site embeds live WASM demos of the examples, and showcase crates demonstrate a Pong game, offscreen GIF encoding, multithreaded model loading, and compute-shader tangent generation. Although primarily a tutorial codebase, it is genuinely hybrid: it doubles as a deployable documentation site and a reference implementation of modern wgpu patterns.
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.
WebDNN is a browser-based neural network inference engine that executes ONNX models directly on the client side. It provides four backends—CPU, WebAssembly, WebGL (1/2), and WebGPU—allowing models to run on a wide range of hardware. The repository includes a Python graph transpiler for offline model optimization (shader generation, operator fusion, 8-bit quantization) and a TypeScript runtime with a modular operator registration system. While the runtime is application-oriented (library for web ML inference), the Python transpiler contains research-grade optimization passes and weight compression algorithms, giving the project a hybrid character. The codebase is well-structured with clean abstractions for backends and operators, but some backends (WebGPU, WebAssembly) are partially complete and require specific build toolchains.
This repository is not a software application, service, or data pipeline. It is an "awesome list": a manually curated Markdown directory of WebGPU resources. The only substantive content is readme.md, which organizes links into roughly a dozen categories: official specifications, browser support details, articles, tutorials, books, libraries, debuggers/profilers, gists, demos, videos, presentations, community channels, and bug-reporting trackers. It includes enablement instructions for Chrome, Firefox, Safari, and iOS/iPadOS, and points to both the W3C WebGPU/WGSL specifications and the MDN API reference. The repository is maintained as a community resource: it is CC0-licensed, has contribution guidelines and a code of conduct, and receives regular commits. Its value is informational rather than executable—there are no build scripts, package manifests, tests, entry points, or runtime dependencies. It is best used as a discovery reference for engineers evaluating WebGPU libraries, WGSL tooling, rendering engines, or GPU compute examples. The list also internally flags stale debugger projects, demonstrating careful curation. Because this repo contains no source code, there are no reusable software components, libraries, or data assets to extract. Its quality should be evaluated as documentation and curation, not as software engineering.
WebGPU.NET is a .NET binding library for the WebGPU API, specifically targeting WebAssembly via Blazor. It provides a low-level P/Invoke wrapper generated from Emscripten's WebGPU C header, enabling GPU compute and rendering in browser-based .NET applications. The repository includes a code generator (WebGPUGen) that parses the C header using CppAst and emits C# structs, enums, handles, delegates, and P/Invoke commands. The generated library is packaged as a NuGet package (Evergine.Bindings.WebGPU) with MSBuild integration for native WebGPU support. A Blazor WebAssembly sample (HelloTriangleWasm) demonstrates basic triangle rendering using the deprecated WGPUSwapChain API. The project is part of the Evergine ecosystem and follows the organization's binding conventions, with CI/CD pipelines and a binding manifest. While the core library is functional and the generator is effective, there are signs of technical drift: the sample uses a deprecated API, the generator has hardcoded paths and a typo, and the binding is tightly coupled to a specific Emscripten version. The repository is maintained but not actively evolving, with recent scope reduction (removal of non-browser support).