OGRE (Object-Oriented Graphics Rendering Engine) is a mature, production-grade 3D rendering engine written in C++ with extensive cross-platform support. The codebase implements a modular plugin architecture with render system backends for Direct3D 9/11, OpenGL (legacy, 3+, ES2), Metal, Vulkan, and a software Tiny renderer. Core modules include scene management, material/shaders, resource handling, animation, particle systems, and compositor framework. Optional components provide real-time shader generation (RTShaderSystem), automatic mesh LOD generation, terrain rendering, volume rendering, world paging, and a 2D overlay system. The repository also includes Python bindings, sample applications, fuzz testing, and content pipeline tools (exporters for Maya, Milkshape, Wings3D). The architecture follows design patterns such as Singleton managers, Factory-based extensibility, and a work queue for background loading. Despite its age and size, the engine remains actively maintained with recent commits, CI/CD pipelines, and support for modern graphics APIs. Notable technical debt includes legacy render backends, deprecated APIs, and some tightly coupled subsystems.
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).
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.
TRELLIS.2 is a research codebase for state-of-the-art image-to-3D generation using a novel sparse voxel representation (O-Voxel) and flow matching with 4B parameters. It provides full training and inference pipelines for generating high-fidelity 3D meshes with PBR materials from single images. The repository includes custom CUDA extensions for voxel processing, a flexible sparse tensor library, and comprehensive dataset tooling for large-scale 3D asset curation (Objaverse-XL, Sketchfab). While primarily a research project with training code and data pipelines, it also offers Gradio web demos and Python APIs for inference. The codebase demonstrates strong engineering in its modular design (pipelines, mixins, config-driven training) but suffers from some research-typical issues like code duplication, hardcoded paths, and fragile dependency management.
Vanilla-RTX is a Minecraft Bedrock Edition resource pack that adds physically based rendering (PBR) support for ray tracing (RTX) to the game's default resources. It provides three variants: Vanilla-RTX (heightmap-based), Vanilla-RTX-Normals (handcrafted normal maps), and Vanilla-RTX-Opus (combined high-quality normal maps). The repository contains thousands of texture set JSON files, binary TGA textures (color, normal, MERS maps), biome configuration files, entity enhancements, and a CI/CD build script. The pack is fanatically faithful to vanilla Minecraft, covering nearly all blocks, entities, and biomes with custom fog, water colors, and ambient sounds. The build script (pack_builder.py) automates packaging into .mcpack and .mcaddon releases, merging __enhancements folders for fixes. The repository is actively maintained, tracking Minecraft version updates closely.
Razix is a multi-platform 3D game engine built in C++ with a focus on modern graphics APIs (Vulkan, DirectX 12, OpenGL). It features a custom rendering hardware interface (RHI), a frame graph system for efficient render pass scheduling, an entity-component system (ECS) for scene management, and a built-in editor with ImGui integration. The engine includes a Lua scripting system, physics integration via Jolt Physics, and a comprehensive memory management layer with custom allocators. Despite its ambitious scope and active development, the codebase exhibits a mix of well-engineered subsystems and areas of legacy code (e.g., LIMBO_STATE). The project provides testing frameworks for both engine core and graphics pipelines, and maintains a dedicated game project ('Tanu') as a showcase.
UniTEX is a research-focused repository implementing a two-stage framework for high-fidelity 3D texture generation from arbitrary 3D shapes. Stage 1 uses LoRA-adapted Diffusion Transformers for multi-view texture synthesis, while Stage 2 employs a transformer-based Large Texturing Model (LTM) to predict Texture Functions in unified 3D space, bypassing UV mapping limitations. The repository integrates super-resolution (TSD_SR) for detail enhancement and provides tools for mesh processing, rendering, and texture reprojection. It includes training scripts, model architectures, and utility libraries, indicating its primary purpose is to support experimentation and reproduction of the CVPR 2026 paper's methodology rather than serving as a standalone end-user application.