Building a Production-Grade 3DGS Training Library from Scratch: A Deep Dive into Full-GPU Residency and the Vulkan Stack

A Production-Ready 3DGS Open Source Project Takes Shape

3D Gaussian Splatting (3DGS) has emerged as one of the most closely watched technologies in computer graphics and 3D reconstruction over the past two years, rapidly making the leap from academic research into real-world engineering. Yet most mainstream 3DGS implementations today are born from research prototypes — codebases built to reproduce paper results, not to meet the performance and stability demands of production environments.

Recently, a seasoned software engineer with years of experience at major tech companies posted a call for contributors on Reddit, looking for like-minded developers to help build a brand-new 3DGS training library. This developer has deep roots in XR (extended reality), graphics and GPU programming, spatial algorithms and AI, and hands-on 3DGS engineering.

The core vision is unambiguous: build a focused 3DGS library from first principles, with a strong emphasis on performance and correctness — targeting genuine production use cases rather than relying on toolchains designed for academic research.

5 Million Splats at a Stable 60fps: A Key Performance Milestone

Though the project is only a few months old, it has already hit a significant milestone: rendering a scene with 5 million Gaussian splats at 60fps on an Ampere-architecture A6000 GPU.

Five million splats represents a fairly complex scene by 3DGS standards. Holding a stable 60fps at that scale signals that the rendering pipeline optimizations are already paying off. For a project this early in its life, that kind of performance is strong validation of the chosen technical approach.

Notably, the author was deliberate about one thing: although projects like VkSplat served as inspiration, he intentionally avoided looking at anyone else's code, choosing to implement everything independently from scratch. This approach added development difficulty but ensures architectural purity and clean IP ownership.

The 1.0 MVP Goal: A Fully GPU-Resident Rendering and Training Solution

The author has set a clear minimum viable product target for version 1.0: a fully GPU-resident solution delivering best-in-class speed for both rendering and training.

"Fully GPU resident" means keeping the entire pipeline — from data to computation — on the GPU as much as possible, minimizing costly CPU-GPU data transfers that are a major bottleneck in 3DGS training. Built around this goal, the planned core features include:

• Global image alignment: Ensuring consistency across multi-view inputs
• Fully fused forward and backward passes: Deeply merging compute kernels to reduce intermediate VRAM read/write overhead
• Adam optimizer: The core optimization algorithm for the training loop
• Aggressively optimized adaptive control and densification: Dynamically adjusting splat density — a critical factor for both quality and efficiency in 3DGS
• A stable, highly flexible C API: Providing a unified interface for higher-level tools and cross-language integration

This feature set targets the core engineering pain points of 3DGS directly. Fused kernels and densification optimization in particular are often the primary bottlenecks that cap training speed. Choosing a C API as the external interface rather than direct Python bindings also reflects a design philosophy aimed at diverse production integration scenarios.

Tech Stack Breakdown: High-Performance Architecture Driven by C++23 and Vulkan

The project's published tech stack makes clear that this is a systems engineering effort optimized for maximum performance.

Language and Build Toolchain

• Languages: C++23, CUDA, GLSL (with a planned migration to Slang)
• Build system: CMake and Ninja
• Compilers: GCC, Clang, MSVC (MSVC support may be temporarily dropped)

Adopting the latest C++23 standard signals a desire to leverage modern C++ language features that balance performance with memory safety. The planned migration from GLSL to Slang is also forward-looking — as NVIDIA's promoted shading language, Slang offers clear advantages in cross-platform support and modern GPU programming.

Platform Support and GPU Backend

• Target platform: Linux (Linux 7.X)
• Profiling tools: LLVM, perf, Nsight
• GPU backend: Vulkan with NVIDIA GPUs
• Dependencies: googletest, googlebenchmark, ngfx

Choosing Vulkan as the graphics backend rather than a CUDA-only approach leaves the door open for cross-hardware expansion in the future. Bringing in googletest and googlebenchmark from the very start shows the author takes structured testing and benchmarking seriously from day one — something notably absent from most research codebases.

Open Source Collaboration: Enthusiasm Is the Only Hard Requirement

While the project is still in early stages, the codebase has grown large enough to support multi-contributor collaboration. The author is actively seeking contributors and takes an open, welcoming stance:

"Prior knowledge is not a prerequisite — I've learned a lot myself throughout this process — but enthusiasm is a must."

The areas where help is most needed right now:

• CI/CD pipeline setup: Automating builds, packaging, and deployment
• Nsight and GPU performance tuning: Deep optimization of the rendering and training pipelines
• API design and implementation: Building a clean, ergonomic C interface
• Testing and benchmarking: Verifying correctness and measuring performance

The project will be released on GitHub under the MIT license. If it gains enough traction, the author plans to build additional tools and infrastructure on top of it.

Why This 3DGS Project Deserves Developer Attention

From an industry perspective, this project addresses a genuine gap in the 3DGS ecosystem. The vast majority of existing 3DGS implementations prioritize research flexibility, and often struggle to balance engineering stability, deployment convenience, and peak performance all at once. An open-source library designed from the ground up for production use — and built on a modern C++ and Vulkan stack — genuinely fills a hole.

Of course, the challenges facing a solo-led open source project are equally real: sustaining momentum, attracting enough contributors to form a real community, and building meaningful differentiation against more established projects are all factors that will determine its long-term trajectory.

For developers interested in graphics programming, GPU optimization, or 3DGS technology, this may be a rare opportunity for deep, high-impact involvement. In a project that hasn't yet solidified its shape, individual contributions carry far more weight than they would in a mature codebase. As the author himself puts it: enthusiasm matters more than experience.