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.
React Three Fiber (R3F) is a React renderer for three.js, enabling declarative construction of 3D scenes using JSX. It provides a `<Canvas>` component that bootstraps a WebGL renderer, a custom React reconciler that bridges React's component lifecycle with three.js objects, and a rich set of hooks (`useFrame`, `useThree`, `useLoader`) for imperative control. The architecture follows a monorepo pattern with three packages: the core fiber library (web and React Native), a test renderer for unit testing 3D components, and an ESLint plugin enforcing performance rules. The core library abstracts WebGL details, handles pointer events with raycasting, manages the render loop, and supports advanced features like portals, Suspense for async assets, and context bridging. It is a foundational tool for building interactive 3D applications in the browser or on mobile via Expo. The codebase demonstrates high craftsmanship with clean abstractions, extensive test coverage, and a modular design that separates concerns across reconciler, event system, state management, and rendering utilities.
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.
libGDX is a mature, cross-platform Java game development framework supporting Windows, Linux, macOS, Android, iOS (via RoboVM), and web browsers (via GWT). The codebase is organized as a multi-project Gradle build with a core module (gdx) providing platform-agnostic APIs for graphics (2D/3D), audio, input, file handling, math, utilities, scene2d UI, asset management, and tile maps. Platform-specific backends implement these interfaces using LWJGL3 (desktop), Android SDK, RoboVM (iOS), GWT (web), and a headless backend for testing. Extensions provide Box2D (2D physics), Bullet (3D physics), FreeType (font rendering), and development tools (texture packer, particle editor, font generator). The architecture uses interface-based abstraction with platform-specific implementations, enabling write-once-run-anywhere game development. The codebase demonstrates strong engineering practices: clean separation of concerns, extensive test coverage (unit tests + integration tests across backends), native code integration via JNI/SWIG for physics engines, and a comprehensive asset pipeline. Recent commits (2026) show active maintenance with modern Gradle, Java 17+ compatibility, and ongoing MetalANGLE backend development for iOS.
The Open 3D Engine (O3DE) is a modular, open-source 3D game engine designed for developing AAA games, simulations, and interactive 3D content. It employs a component-based architecture with a core framework (AzCore, AzFramework, AzToolsFramework) and extensible gems for specialized functionality such as rendering (Atom), physics (PhysX), animation (EMotionFX), and UI (LyShine). The engine emphasizes data-driven design through reflection and serialization systems, and uses an event-driven communication pattern (EBus) for loose coupling between systems. Key architectural features include an entity-component-system (ECS) for game objects, a flexible asset processing pipeline that converts source assets into runtime-optimized formats, and a multi-platform rendering abstraction (RHI) supporting Vulkan, DirectX 12, and Metal. The engine provides extensive editor tools for content creation, including a scene editor, asset browser, and visual scripting system (ScriptCanvas). Cross-platform support is achieved through platform-specific trait files and abstraction layers, enabling deployment to Windows, Linux, macOS, Android, and iOS. The engine demonstrates strong engineering practices in its core systems: the EBus implementation offers a sophisticated, policy-based event bus; the reflection system enables serialization, behavior context binding, and editor integration; and the Interface pattern provides a flexible singleton mechanism. While the codebase shows signs of platform-specific duplication and some deprecated code, active maintenance and a clear modular structure help manage technical debt. O3DE is suitable for reuse in projects requiring a full-featured game engine or as a source of reusable patterns for engine development.
Manim is a comprehensive Python library for creating programmatic mathematical animations, primarily used for explanatory math videos. It provides a declarative scene API where users define objects (mobjects), animations, and camera movements in code, then renders them to video or image sequences via two backends: a CPU-based Cairo renderer and a GPU-accelerated OpenGL renderer. The library handles everything from Bézier curve rendering and LaTeX/Typst typesetting to 3D surface shading and vector field visualization. Its architecture is centered on the `Scene`, `Mobject`, and `Animation` classes, with extensive support for coordinate systems, graphs, text, and custom shaders. The dual renderer design introduces some code duplication, but the codebase is actively maintained with a rich test suite, CI/CD, and plugin system. While primarily an application library, it also incorporates elements of data research in its color science and mathematical utilities.
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.
OpenSCAD is a mature, script-based 3D CAD modeler. It provides a declarative language for defining solid geometry through Constructive Solid Geometry (CSG) operations, extrusions, and transformations. The application consists of a C++ core that parses the custom scripting language, builds an AST, and evaluates geometry using either the CGAL or Manifold library for boolean operations. Rendering is handled via OpenGL with both preview (OpenCSG) and final render modes. The GUI, built on Qt, includes a code editor with syntax highlighting, a 3D viewport, parameter customizer, and an integrated AI assistant for code generation. Exports to STL, OBJ, SVG, 3MF, PDF, and other formats. The codebase demonstrates strong engineering with clear module separation (core, geometry, glview, gui, io, utils), extensive regression tests, and reusable patterns such as visitors, builders, and self-contained geometry utilities.
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.
This repository is a large, modular C++ game engine with a fully integrated editor. The engine core provides a world/component architecture, reflection-driven serialization, resource management, a task system, and a render abstraction layer with DirectX 11 and Vulkan backends. Runtime features are delivered as plugins: Jolt physics, FMOD/MiniAudio audio, RmlUi UI, particle effects, animation graphs, AI navigation, procedural generation, terrain, and OpenXR support. The editor is a Qt-based multi-process application: a host editor process communicates with a separate engine process over IPC, mirroring document objects into a live world for preview and manipulation. Asset managers turn imported files such as meshes, textures, skeletons, animation clips, sound events, and UI documents into versioned engine resources. Sample game applications and extensive unit tests demonstrate the runtime API and provide a working baseline for engine consumers. The codebase is production-oriented rather than research-oriented: there are no notebooks, data pipelines, or ML artifacts. Instead, it is an application and framework monorepo with strong engineering discipline visible in its consistent component/manager patterns, plugin registration conventions, and resource lifecycle management. The custom RTTI/reflection system underpins serialization, editor property grids, undo/redo, and scripting, making the engine highly data-driven. However, the code is macro-heavy and some areas, especially editor plugins, repeat near-identical boilerplate patterns across many asset types. The project is actively maintained, with recent commits, CI workflows, and a large third-party dependency set that is mostly bundled in-tree; some bundled libraries and platform-specific paths show moderate drift but not abandonment.
MethaneKit is a cross-platform graphics rendering framework that provides abstractions over DirectX 12, Vulkan, and Metal APIs. It features a layered architecture with platform-independent interfaces (RHI), platform-specific implementations, an application framework, UI components, and mathematical utilities. The framework includes tutorial applications demonstrating various graphics techniques from basic triangle rendering to compute shaders and parallel rendering. Key systems include resource management, command submission, pipeline state handling, and synchronization primitives. The codebase demonstrates modern C++ practices with extensive use of templates, PIMPL idiom, and interface-based design.
ggez is a lightweight, cross-platform 2D game framework for Rust, inspired by LÖVE. It provides a comprehensive set of subsystems for graphics, audio, input, filesystem, and timer management, all accessible through a central `Context` object. The framework abstracts over `winit` for windowing and events, `wgpu` for GPU rendering, `rodio` for audio playback, and `gilrs` for gamepad support. The architecture is modular, using sub-contexts (e.g., `GraphicsContext`, `AudioContext`) that can be individually accessed via `Has`/`HasMut` traits, allowing for custom context composition. The graphics pipeline supports 2D and optional 3D rendering (behind a feature flag) with shaders, meshes, images, instanced drawing, and text rendering via `glyph_brush`. The filesystem uses a virtual filesystem (VFS) layer with physical directories and zip archives, and configuration is handled via TOML serialization. Key entry points include `ContextBuilder` for initialization, `EventHandler` trait for the game loop (with `update`, `draw`, and input callbacks), and the `event::run()` function to start the application. Data flows are event-driven: user input is collected by `winit` and forwarded to the event handler, while rendering commands are batched and submitted to the GPU each frame. The framework also includes built-in coroutines for asynchronous tasks without futures. The repository contains over 40 examples demonstrating all major features, from simple drawing to complex 3D scenes and shader effects. ggez is actively maintained with a stable API, though some parts (e.g., 3D support, coroutine implementation) are less mature. The codebase demonstrates good engineering practices: builder patterns, resource caching, buffer sub-allocation, and a clear separation of concerns. It is suitable for hobby game development, educational projects, and rapid prototyping. The heavy reliance on evolving crates like `wgpu` and `winit` introduces some technical drift, but the framework keeps pace with updates.
Yave is a C++20 Vulkan-based real-time graphics engine paired with a custom ImGui-driven editor and a self-contained core utility library named `y`. The repository is structured as three layers: `y` provides reusable containers, math, concurrency, IO, serialization, and a test framework; `yave` implements the engine itself (Vulkan device/window management, frame graph, render passes, ECS, asset pipeline, physics, animation, and scripting); and `editor` is a full 3D scene editor application with workspaces, widgets, gizmos, importers, thumbnails, and undo/redo. The renderer supports deferred PBR, cascaded shadow maps, TAA, bloom, SSAO/RTAO, RTGI, atmosphere scattering, and tone mapping, and it runs through a declarative frame graph with automatic resource pooling and barrier insertion. The editor is not a separate toy: it provides asset browsing, glTF/image import, material editing, scene outliner, inspector, file system views, performance metrics, GPU profiling, and RenderDoc integration. The engine uses a modern ECS with component groups, async asset pointers, and a serialization framework that supports schema evolution. The `y` library is particularly notable for its clean, high-performance primitives: SSO strings, flat hash maps with SIMD probing, sparse component sets, dependency-aware job system, and a forward/backward-compatible binary serialization layer. Externally, it depends on Vulkan, VMA, Volk, Dear ImGui, JoltPhysics, LuaJIT, tinygltf, stb, Tracy, and spirv_reflect, mostly vendored. While the project is described by its author as a learning/pet engine, the code is generally well-structured and professionally organized. However, it is a single-author codebase with many `Y_TODO` markers, some stubbed platform paths, global device singletons, and an explicit compiler-dependent serialization format. Tests exist mainly for the `y` core containers and math, not for the engine or editor. The repository is active and uses current C++/Vulkan practices, but should be treated as an evolving research-quality engine, not a stable library.
The ANARI SDK is a comprehensive implementation of the Khronos ANARI (ANother API for Rendering and Imaging) standard, designed for scientific visualization rendering. It provides a core C/C++ frontend library, multiple device backends including a CPU reference renderer (helide using Embree), an experimental GPU backend (helide_gpu using SDL3 GPU), a remote rendering device over TCP, a debugging/serialization device, and a no-op sink device. The SDK also includes a Conformance Test Suite (CTS) for validating device correctness via image-based comparisons (SSIM/PSNR), a reusable base framework (Helium) that abstracts common device implementation patterns (parameter management, deferred commits, object lifecycle), code generation tools that produce C++ code from JSON extension definitions, and an OpenUSD Hydra render delegate plugin for integration with Pixar's USD ecosystem. Additionally, it ships example applications (viewer, capability analysis tool, Blender add-on) and a rich set of test scenes for performance and correctness testing.
PyMeshLab is a Python library that provides bindings to the core functionality of MeshLab, a mature C++ application for processing and editing large 3D triangle meshes and point clouds. The library exposes a MeshSet class that wraps hundreds of geometry processing filters (e.g., simplification, smoothing, Boolean operations, surface reconstruction, parameterization) via a dynamic method registration pattern—each filter becomes an method on MeshSet at import time. The architecture relies on a pybind11-based C++ extension module that communicates with MeshLab's filter plugins, VCG library, Eigen, and Qt. Users can load meshes in many standard formats (OBJ, PLY, STL, etc.), apply filters with typed parameters (including custom types like PercentageValue and Color), and export results. The project includes comprehensive documentation, automated tests with sample meshes, and cross-platform build scripts for Linux, macOS, and Windows. While the library is tightly coupled to the MeshLab submodule, its design patterns—such as dynamic filter registration and reusable parameter wrappers—demonstrate solid engineering for bridging C++ and Python.
geometry3Sharp is a comprehensive C# library for 2D/3D geometric computing and triangle mesh processing. It provides a rich set of data structures (dynamic mesh, spatial indices, graphs) and algorithms (mesh editing, remeshing, simplification, boolean operations, distance queries, implicit surfaces, hole filling, smoothing, deformation). The library also includes I/O for common mesh formats (OBJ, STL, OFF), numerical solvers (sparse CG, SVD, eigen), and utilities like parallel loops and memory-efficient containers. It is designed for integration into real-time applications and Unity via conditional compilation. While the codebase shows signs of long development with some incomplete features and deprecated APIs, it remains a powerful and well-crafted tool for geometry processing tasks.
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.
This repository implements an automatic texture atlas generation library for 3D meshes. Its primary function is to take an arbitrary triangle mesh (typically loaded from an OBJ file) and produce a UV-mapped mesh with a compact, packed texture atlas. The algorithm segments the mesh into charts based on geometric and topological criteria, parameterizes each chart using least-squares conformal mapping (LSCM) or orthogonal projection, and packs the charts into a single bitmap using a brute-force or random bin-packing strategy. The library is designed to handle non-manifold meshes, supports colocal vertices, and provides quality metrics such as stretch and conformal distortion. The architecture is modular, with separate libraries for core utilities (nvcore), mathematics (nvmath), mesh data structures (nvmesh), and image handling (nvimage). The public API is a single C-linkage function `atlas_generate` with options for quality, texel density, and packing alignment. The codebase was originally developed for use in the video game 'The Witness' and is released under the MIT license. It includes a test harness that loads an OBJ file and prints atlas results. The repository is functionally complete but shows its age: it predates C++11, uses custom containers instead of STL, and relies on vendored dependencies (tinyobj, stb_image, poshlib) with known limitations. The packing algorithm can be slow for large meshes, and there are numerous TODO comments and dead code paths. Despite this, the underlying algorithms are sound and the half-edge mesh, sparse solver, and rasterization components are well-implemented and could be extracted for use in other 3D projects.