3D Gaussian Splatting: Photorealistic Scenes from Photos in Minutes

Imagine taking 50 photos of a room with your smartphone – and 20 minutes later you have a photorealistic, freely navigable 3D scene you can explore with your mouse. Three years ago, that required specialist cameras, studio equipment, and a computer graphics professional. Today, an open-source tool and a consumer GPU are enough. The technique behind it is called 3D Gaussian Splatting (3DGS) – and it ranks among the most exciting developments in computer graphics since the introduction of NeRF.

What is Gaussian Splatting?

The core idea is deceptively simple: instead of building a 3D scene from triangles (classical meshes) or voxels (3D pixels), it's composed of thousands of tiny, blurred 3D points – called Gaussian splats. Each splat has:

• A position (x, y, z) in space
• A shape (a 3D Gaussian bell curve – hence the name)
• A color and transparency
• An orientation (rotation in space)

When a scene is captured from many photos, an optimization procedure computes millions of these splats so that together they reproduce the original images as exactly as possible. The result doesn't just look like a photo – mathematically speaking, it is a photo, just stored as a 3D reconstruction.

3DGS vs. NeRF: What's the Difference?

Anyone exploring this topic quickly encounters NeRF (Neural Radiance Fields). Both techniques turn photos into 3D scenes, but they differ fundamentally:

• NeRF uses a neural network that predicts a color and density for every point in space. Brilliant quality, but slow (minutes per image) and difficult to edit.
• 3DGS uses explicit 3D Gaussian functions. Splatting (the "spraying" of points onto the screen) is real-time capable – 30+ FPS on a standard GPU is the norm.

For most use cases – product visualization, real-time demos, architecture, pre-visualization for games – 3DGS has become the first choice. NeRF remains relevant when highest geometric accuracy is required (medicine, scientific reconstruction).

The Most Important GitHub Repos

The open-source landscape around 3D Gaussian Splatting is remarkably active. Here are the repos you should know:

• graphdeco-inria/gaussian-splatting – The original repo from the INRIA research group around Bernhard Kerbl that triggered the revolution in 2023 with the SIGGRAPH paper "3D Gaussian Splatting for Real-Time Radiance Field Rendering". CUDA-based, reference implementation. ~20k stars, ~3k forks.
• nerfstudio-project/gsplat – A modern, modularized PyTorch reimplementation with better documentation and multi-GPU support. Ideal when you want to experiment with your own data. ~2.5k stars.
• playcanvas/splat-renderer – WebGL-based renderer for finished splat scenes. Lets you display 3DGS scenes directly in the browser without your own engine. Perfect for web demos.
• MrNeRF/awesome-3D-Gaussian-Splatting – The central curated list with papers, datasets, tools, and follow-up projects. Must-bookmark.
• city-super/Scaffold-GS – Further development with "scaffold" structures for huge scenes (city districts, entire forests). Solves the original's scaling problem.
• hustvl/4DGS – 4D extension: splats that change over time. First steps toward dynamic 3D reconstruction (e.g., dancing people from videos).
• autonomousvision/gaussian-splatting-lightning – Highly optimized variant with blazing fast convergence (~5 minutes instead of 30–60).

How the Workflow Works in Practice

The typical end-to-end process from photos to a finished 3D scene consists of four steps:

• 1. Capture: Take 50–200 photos of the object or room from as many angles as possible. A smartphone suffices for initial tests; better results with a system camera and known focal length.
• 2. Structure-from-Motion (SfM): Tools like COLMAP compute camera positions and an initial sparse point cloud from the photos. This forms the basis for the 3DGS optimization.
• 3. Training: The 3DGS tool iteratively optimizes millions of Gaussian splats. On an RTX 4090, this takes about 30–60 minutes for a typical indoor scene.
• 4. Rendering: The final scene is stored in a compressed file (.ply, .splat, or .ksplat) and can be displayed in real-time with open-source viewers (PlayCanvas, supersplat, luma-web-viewer).

Use Cases That Already Work

3DGS is no longer just research – the first productive applications are live:

• E-Commerce: Product visualization without a photo studio. Shopify plugins like 3DGS-Snap let merchants photograph a product and offer embedded 3D views.
• Architecture & Real Estate: Matterport competitors like KIRI Engine and Polycam offer 3DGS pipelines as cloud services.
• Robotics & Autonomous Systems: Sim-to-real training data from 3DGS scenes. NeurIPS 2025 showed that policies trained this way work surprisingly robustly in real rooms.
• Culture & Heritage Preservation: Research teams at ETH Zurich and TU Munich reconstructed historical sites in 3DGS in 2025 – including real-time annotation for restorers.
• AI-Generated 3D Content: The next wave is models that generate 3DGS scenes directly from text prompts (e.g., GaussianDreamer, GSGen). Still shaky, but the pace of publications is breathtaking.

Limitations You Should Know

3DGS isn't perfect – the key constraints today:

• Static: Standard 3DGS can only handle motionless scenes. For dynamic content you need 4DGS or other extensions.
• Storage Requirements: A medium-sized scene takes between 200 MB and 2 GB. Compression is an active research topic.
• Editability: Unlike meshes, splats are hard to edit. Removing or modifying individual objects from the scene is possible but cumbersome.
• Reflections and Transparency: Works, but with visible artifacts. Specular surfaces and glass are a discipline of their own.

Conclusion

• In 2026, 3D Gaussian Splatting is the most practical method to turn photos into navigable 3D scenes – in minutes to hours, not days.
• The original INRIA repo is the starting point, gsplat the best modular variant, playcanvas/splat-renderer the easiest web viewer.
• The most exciting open research question: dynamic 4D scenes and text-to-3DGS generation.
• For productive applications, commercial providers now exist (Polycam, KIRI Engine, Luma AI) – the market is consolidating right now.