thehardwarestore.ai

NoPoSplat is a research application for novel view synthesis and camera pose estimation from unposed image pairs. It predicts 3D Gaussian parameters (means, covariances, harmonics, opacities) in canonical space using a vision transformer backbone (CroCo, ResNet, or DINO) with a DPT head, then renders images via differentiable Gaussian splatting. The system eliminates the need for known camera poses during training/inference by estimating poses implicitly through geometric consistency losses. Built on PyTorch Lightning with Hydra configuration, it supports multi-GPU training and evaluation on datasets like RealEstate10K, ACID, DTU, and ScanNet++. The codebase emphasizes modularity through component registries, composable loss functions, and chainable data preprocessing shims.

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.

E-RayZer is a self-supervised 3D reconstruction system that takes unordered multi-view images as input and outputs estimated camera poses, target-view renders, Gaussian point clouds, and turntable videos. The system uses a transformer-based architecture to estimate camera poses and scene representations, then renders novel views using differentiable Gaussian splatting. It includes a Gradio demo interface for easy inference, along with training and evaluation scripts for the DL3DV dataset. The model is trained without ground truth camera poses or depth information, learning to reconstruct 3D scenes purely from multi-view image consistency.

Brush is a 3D Gaussian Splatting engine for real-time rendering and training of 3D scenes from multi-view images. It features a modular Rust workspace architecture with applications for desktop GUI (eframe/egui), headless CLI, C FFI, and WebAssembly (web). The system loads datasets (COLMAP, Nerfstudio, RealityCapture), initializes and optimizes Gaussian splats via gradient descent using the Burn tensor library for autodiff, and renders via a wgpu-based rasterization pipeline. Key innovations include a GPU-accelerated radix sort for depth ordering, an actor model for async processing, and a virtual file system for cross-platform file access.

SPAG4D is a production-grade tool that converts 360° equirectangular panoramic photos into explorable 3D Gaussian Splat (3DGS) scenes. It integrates multiple depth estimation backends (DA360, DAP, PaGeR, SHARP, UniSHARP) to generate depth maps from a single panorama, then projects the points into standard 3DGS PLY format. The system provides a CLI, a FastAPI web server with a JavaScript frontend, and a Python API for programmatic use. Beyond the core conversion, it includes optional refinement pipelines to fill holes and improve scene quality: OmniRoam (WSL2-based video generation and distillation), ArtiFixer3D (Docker-based diffusion refinement), and a lighter geometric refinement pipeline using depth alignment and voxel aggregation. The architecture is modular with pluggable generators, comprehensive configuration dataclasses, and provenance tracking. While the tool is primarily an application, it leans heavily on research-grade depth models and refinement techniques, giving it a hybrid character. The codebase is well-structured with clear separation of concerns, reusable utilities (spherical projection, depth blending, scene filtering, geometric alignment), and extensive tests. It is actively maintained with recent commits, though it carries complexity from multiple backends and platform-specific dependencies (WSL2, Docker, CUDA).

Reall3dViewer is a high-performance 3D Gaussian Splatting (3DGS) web viewer built on Three.js. It streams and renders large-scale point cloud scenes (up to 150M points) at interactive frame rates across desktop and mobile devices. The viewer supports multiple input formats including PLY, SPLAT, SPX (proprietary high-compression format), SPZ, SOG, and GLB with the KHR_gaussian_splatting extension. Its architecture is event-driven and modular, with a central event system (Events.ts), dedicated loaders for each format, web workers for parallel data fetching and sorting, and a texture management pipeline that handles LOD tile streaming, frustum culling, and adaptive quality levels. Beyond basic viewing, the repository provides a full suite of interactive features: measurement and annotation tools (distance, area, point labels, 3D tags, circle plans), a map viewer (Reall3dMapViewer) with GIS basemap integration, a first-person/third-person player mode with physics (rapier3d), weather effects (rain, snow), audio-driven text overlays, and a fly-through camera path system. The code is published as an npm package (@reall3d/reall3dviewer) and includes comprehensive demo pages with scene configuration JSON files. While primarily an application library, the project also exhibits data/research characteristics through its custom SPX format specifications, advanced compression techniques (WebP, gzip, xz, zstd), and spherical harmonics support up to degree 3. The source code demonstrates high engineering craftsmanship in areas like GLSL shader modularization, WebAssembly integration for format parsing, and efficient web worker communication patterns. However, there are some maintenance risks including a large monolithic event constant file (200+ auto-incremented integers), hardcoded demo URLs, and a build script that embeds worker code as base64, which complicates debugging. No automated tests are present.

WorldGen is a Python library and demo application for generating 3D scenes from text prompts or single images in seconds. It orchestrates a pipeline of state-of-the-art models: a fine-tuned FLUX diffusion model to generate 360° panoramic images, DA-2 for monocular depth estimation on equirectangular images, and optionally OneFormer for semantic segmentation and LaMa for inpainting to handle background occlusions. The 3D scene is produced as a Gaussian splatting point cloud (via a custom RGBD-to-Gaussian conversion) or as a textured mesh. An experimental mode uses Apple's Sharp model for higher-quality Gaussian splats by processing cubemap faces. The codebase demonstrates strong engineering practices for a research project: modular pipeline design, use of submodules for dependencies, custom diffusers pipelines with VAE tiling modifications for seamless panorama generation, and a Viser-based interactive viewer. While the core value is the integrated pipeline, several utility modules (equirectangular projection utilities, splat file handling) are cleanly isolated and reusable in other 360° or 3D vision projects.

This repository is a curated 'awesome list' for 3D Gaussian Splatting (3DGS) research papers, complemented by a static site generator and a YAML editor. The core functional code reads a YAML database of ~500 papers and generates a single-page HTML site with search, filter by year/tag, and paper selection for sharing. It includes a PyQt6 GUI for managing the YAML file, an arXiv integration module to fetch metadata, a PDF thumbnail generator, and a link checker for CI. The frontend uses vanilla CSS and JS with no framework. The codebase is well-organized for its purpose but lacks deep abstraction; the template engine is a thin wrapper around string.Template, and the editor is tightly coupled to the application. The main value is the curated paper list itself rather than the software engineering.

This repository implements Mobile-GS, a real-time Gaussian splatting approach for novel view synthesis optimized for mobile devices. The system trains 3D Gaussian representations from multi-view images, applies compression techniques (vector quantization, Huffman coding, GPCC) to reduce model size, and renders novel views via differentiable EWA (Elliptical Weighted Average) splatting. It includes training pipelines (train.py, pretrain.py), rendering engine (gaussian_renderer/), scene management, custom CUDA kernels for efficient rasterization, and evaluation metrics. The architecture follows a modular design with separate components for training, rendering, scene handling, and compression, optimized for deployment on mobile platforms with limited computational resources.

This repository implements Pixie, a research framework for predicting dense physical material fields (density, Young's modulus, Poisson's ratio, material ID) from 2D image observations of 3D objects. Hydra configs drive a multi-stage pipeline: Objaverse object retrieval, Blender rendering, NeRF-based CLIP feature field training (F3RM), Gaussian Splatting training, voxel grid feature extraction, VLM-based or neural material segmentation, and MPM physics simulation via the vendored PhysGaussian codebase. The pipeline.py entry point orchestrates these stages with caching and reproducibility checks, while render.py produces Blender visualizations of segmented physics fields. Real-scene mode extends the same pipeline to captured datasets using COLMAP dataparsers. The repository also contains the full PixieVerse data curation workflow: class-based Objaverse selection using sentence-transformers, large-scale parallel Blender rendering, VLM-based filtering and critique (Gemini/Claude/GPT/Qwen via the vendored vlmx agent framework), and Streamlit tools for human-in-the-loop label correction and simulation validation. The discrete (semantic segmentation) and continuous (property regression) 3D UNet training lives in the vendored Wavelet-Generation submodule, with shared utilities in pixie/training_utils.py and normalization statistics already computed in normalization_stats/. Architecturally this is a hybrid research/application repository: primarily a configuration-driven pipeline framework with CLI entry points, but also a dataset-generation and model-training workflow. It depends heavily on vendored third-party code (nerfstudio, f3rm, PhysGaussian, Wavelet-Generation, vlmx) and shells out to Blender, CUDA rasterizers, and Hugging Face. Quality is research-grade: disciplined Hydra configs, contextual config snapshots, and skip-if-exists caching coexist with hardcoded user-specific paths, commented-out dead code, and a subprocess-heavy orchestration style. Download scripts for pre-trained models and the PixieVerse dataset are included and functional.