F3D is a fast, minimalist 3D viewer and rendering library (libf3d) built on VTK, providing both a desktop application and a reusable C++ library with bindings for C, Python, Java, and WebAssembly. It loads and interactively visualizes dozens of 3D file formats (glTF, USD, STEP, STL, OBJ, FBX, etc.) through a plugin architecture. The application offers a rich CLI, interactive console, configurable rendering options, animations, and scientific visualization features like volume rendering, scalar coloring, and point clouds. The library exposes a clean public API (engine, scene, window, camera, interactor, options) that can be embedded in other applications or used for offscreen rendering. The codebase demonstrates strong engineering: modular plugin system, extensive test suite (including pixel comparison and event recording), cross-platform support, and thorough documentation. Its architecture separates concerns cleanly between application layer, library, VTK extensions, and plugins, making individual components potentially reusable in other VTK-based projects.
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.
This is a monorepo centered on `@google/model-viewer`, a production web component that renders glTF/GLB 3D models in the browser using Three.js and Lit. The core package provides a `<model-viewer>` custom element with a rich feature surface: WebXR/Scene Viewer/Quick Look AR, animation controls, camera orbit/perspective controls, environment lighting, hotspots/annotations, a mutable scene-graph API, lazy loading, and post-processing via a companion `model-viewer-effects` package. In addition to the library itself, the repo contains `space-opera`, a Redux + Lit-based interactive editor for configuring model-viewer snippets and editing glTF materials, plus a full documentation/examples site and render-fidelity tooling that performs golden-image screenshot comparisons across renderers. Although the dominant character is an application/library monorepo, it also includes research-grade visual fidelity workflows and color science work around tone mapping.
cgltf is a single-file, stb-style C library for parsing and writing glTF 2.0 files. It provides a comprehensive set of data structures mirroring the glTF spec, along with functions to parse JSON/GLB, load buffers, validate data, and write back glTF/GLB. The library is self-contained, requires no external dependencies, and includes an embedded copy of the JSMN JSON parser. It supports core glTF 2.0 and many extensions (KHR_materials_*, KHR_lights_punctual, EXT_mesh_gpu_instancing, etc.). The code is well-structured, uses C99, and is designed for easy integration into any C or C++ project. It is used by major projects like bgfx, Filament, and raylib. The writer component (cgltf_write.h) is separate but similarly crafted. The repository includes a comprehensive test suite and fuzz testing setup.
Tetra3D is a pure-Go 3D game engine and rendering library built on top of Ebiten (a 2D game library). It provides a full scene graph with nodes, models, cameras, lights, materials, and animations, along with collision detection, particle systems, text rendering, and pathfinding grids. The architecture is a library with a rich set of examples demonstrating each feature. Key entry points include the tetra3d package root, Camera.RenderScene() for rendering, and gltf.LoadGLTF() for asset loading. Data flows involve loading GLTF/GLB files (with custom Blender exporter metadata), constructing a scene graph, and rendering per frame with support for lighting, shadows, and transparency. External dependencies are Ebiten for rendering/input, qmuntal/gltf for GLTF parsing, tanema/gween for tweening, and golang.org/x/image for font rendering. The codebase includes SIMD-optimized matrix math, a comprehensive vector library, and a Blender addon for exporting scenes with engine-specific properties.
The mviewer repository is a Rust-based application for viewing and exporting Marmoset .mview scene files. It features a dual-mode interface: launching a GUI (using tao/wry embedded webview) for interactive preview when no arguments are provided, or running in CLI mode for batch conversion when arguments are given. The GUI loads a local HTTP server to serve an embedded, forked Marmoset JavaScript viewer that renders scenes with visual parity to Marmoset Toolbag. The core Rust logic handles loading the proprietary .mview archive format, extracting scene data (meshes, materials, animations, cameras, lights, textures), and exporting to glTF/GLB/OBJ formats. The application demonstrates strong modularity with clear separation between archive parsing, data processing, export pipelines, and GUI integration. While the embedded JavaScript viewer introduces some maintenance considerations due to its forked nature, the Rust components exhibit high reusability and craftsmanship, particularly in handling complex binary formats and data transformations.
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).
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.
g3nd is the official demo/showcase application for the g3n Go 3D game engine. It is a single Go binary that presents a windowed GUI (built on the engine's own immediate-mode GUI system) with a categorized demo tree. Users select demos that exercise the engine's capabilities: glTF/glb loading, PBR materials, animations (skinning, morph targets), audio (OpenAL), particle systems, post-processing shaders, and GUI widgets (tables, trees, sliders, form boxes, dock layouts). The application registers demos via Go's `init()` side-effect pattern: each demo package imports itself and calls `app.DemoMap["category.name"] = &struct{}{}`. The core `App` struct manages the scene graph, camera, orbit controls, and per-frame `Update` dispatch. The repository also vendors a large set of test assets (glTF sample models, Blender files, audio, textures) under `data/`. The architecture is a classic Go application: `main.go` imports all demo packages for their registration side effects, then delegates to `app.Create().Run()`. The `app` package owns the window, GUI, and demo lifecycle. Each demo implements a minimal `IDemo` interface (`Start`, `Update`, `Cleanup`). The `util` package provides reusable GUI helpers (file selectors, light meshes). The demos are grouped by category: animation, audio, experimental physics, geometry, GUI, light, loader, material, other, shader, texture. The code is idiomatic Go with clean separation, but some demos are marked experimental and the engine dependency is a pseudo-version that may drift.