3D Reconstruction · Radiance Fields

Self-hosting Gaussian Splatting: how much VRAM you actually need, and which card to rent

From the INRIA original to gsplat, 3DGRUT and hierarchical 3DGS — real memory footprints, real wall-clock times, real licence terms, and the cheapest NexGPU card that clears each bar.

Gaussian Splatting · self-hosted

Gaussian Splatting is not a model, it is an optimisation procedure. In the SIGGRAPH 2023 paper, Kerbl, Kopanas, Leimkühler and Drettakis fit a cloud of anisotropic 3D Gaussians to a set of posed photographs and splat them back through a differentiable rasteriser, reaching real-time novel-view synthesis at 1080p with ≥100 fps while beating Mip-NeRF360 on quality. So there is no "7B or 70B" here — only "how many Gaussians did this scene converge to", and VRAM follows almost entirely from that number.

Which leads to the most counter-intuitive fact about self-hosting it: 3DGS memory use is not fixed at launch, it climbs with densification. The official README lists "24 GB VRAM (to train to paper evaluation quality)" and then honestly adds that "by our calculations it should be possible with way less memory (~8GB)". Both statements are true; the gap is entirely about whether you let the Gaussian count run free. Once you understand that, picking a card stops being guesswork.

The other thing to settle first is licensing. graphdeco-inria/gaussian-splatting ships a custom Inria/MPII research licence whose body states, in capitals, that "THE USER CANNOT USE, EXPLOIT OR DISTRIBUTE THE SOFTWARE FOR COMMERCIAL PURPOSES WITHOUT PRIOR AND EXPLICIT CONSENT OF LICENSORS" — commercial use means emailing Inria's tech transfer office. If the output is going into a product, move to an Apache-2.0 implementation: nerfstudio's gsplat, NVIDIA's 3DGRUT, or Brush, which needs no CUDA at all. Every route below is labelled accordingly.

01 —

Six mainstream implementations, six different memory profiles

Same mathematics, different engineering trade-offs — find your row first, then pick the card

Version	Parameters	VRAM	Context	Notes
graphdeco-inria/gaussian-splatting (original + Oct 2024 accelerated branch)	Typically 1M–6M Gaussians per scene	24GB for paper-quality 30K iterations / ~8GB claimed as the theoretical floor	Input images 1–1.6K px wide; anything above 1.6K is auto-downscaled	The academic baseline — use it when you need numbers that line up with published tables. It absorbed the Taming-3DGS rasteriser for a ×1.6 speedup by default and ×2.7 with --optimizer_type sparse_adam, plus depth regularisation, exposure compensation and --antialiasing. Non-commercial research licence.
nerfstudio-project/gsplat v1.6 (Apache-2.0)	~3.24M Gaussians at default settings; hard-capped via --cap-max	5.7GB at 30K on one GPU (9.0GB for the original); MCMC at 1M Gaussians 1.98GB, at 3M 4.99GB	Multi-GPU DDP supported — 4 GPUs on one scene drops to 2.0GB each	The engineering default. On the official Mip-NeRF360 benchmark it matches the original's average PSNR exactly (28.95) while using roughly 40% less memory, and four GPUs cut 37m13s down to 11m28s. Requires PyTorch 2.7+, supports CUDA 12.8 and 13.2.
Splatfacto / Splatfacto-big (nerfstudio)	Gaussian count set by nerfstudio's densification strategy	~6GB / ~12GB	Trains on full images rather than ray bundles; wants COLMAP SfM points for init	gsplat underneath, but with the whole ns-process-data → ns-train → ns-viewer pipeline around it. The lowest-friction path from a phone orbit video to an interactive scene.
NVIDIA 3DGRUT: 3DGRT + 3DGUT (Apache-2.0)	Same order of magnitude, plus secondary-ray payloads	Needs an RT-core GPU; the official benchmarks were run on an RTX 5090	Distorted and fisheye cameras, rolling shutter, reflections, refraction and shadows	3DGRT ray-traces the particles instead of splatting them; 3DGUT uses an unscented transform so rasterisation can handle distorted cameras. On NeRF Synthetic, 3DGUT trains in 214.6s at 846 FPS and 3DGRT in 479.3s at 347 FPS; 3DGUT+MCMC on Mip-NeRF360 gives 27.78 PSNR at 308 FPS. Effectively mandatory for autonomous-driving and XR capture.
Hierarchical 3D Gaussians (SIGGRAPH 2024)	Chunked into 100 m cubes, 100–2000 cameras per chunk	Renderer schedules against a 16GB budget by default, plus ~1.5GB of framebuffer	Official example is 1500 images in 2 chunks; 48GB-class cards recommended for training	The only official route that swallows block-scale and kilometre-scale captures: train chunks independently, merge into a hierarchy, then page nodes in by view distance and VRAM budget. Official RTX A6000 timings are 47 min COLMAP, 95 min chunk preprocessing, 171 min training.
Brush (Apache-2.0, WebGPU + Burn)	Scales with scene size	No CUDA dependency — AMD, Intel, Apple and browsers all work	Reads COLMAP and nerfstudio datasets, visualises training live	Compiles to dependency-free binaries that run on macOS, Windows, Linux, Android and in the browser. The easiest thing to hand a client who will not install CUDA — at the cost of a less mature kernel and tooling ecosystem than gsplat.

02 —

Four NexGPU cards cover 95% of real 3DGS work

Pick by the route you are actually running, not by paying double "to be safe"

gsplat + MCMC for benchmark reproduction and ablation sweeps, memory pinned under 5GB
RTX 3090 24GB$0.193/GPU-hour
Once MCMC caps the Gaussian count, memory becomes fully predictable (1.98GB at 1M, 4.99GB at 3M), so a 24GB card is enormous headroom — and this is the cheapest 24GB card on the list.
Original 3DGS at a full 30K iterations with densification unrestricted, targeting paper-grade quality
RTX 4090 24GB$0.540/GPU-hour
24GB is literally the stated hardware requirement, and Ada extracts the full ×2.7 sparse_adam speedup with fused-ssim, so you never have to trade throughput for memory via --data_device cpu.
3DGRT / 3DGUT with reflections, refraction, fisheye or rolling-shutter cameras
RTX 5090 32GB$0.723/GPU-hour
3DGRT performance depends directly on RT cores, and NVIDIA's published figures (3DGUT at 846 FPS) were measured on an RTX 5090, so your environment and their numbers actually correspond.
Hierarchical 3DGS on block- or campus-scale captures, thousands of images chunked and merged
RTX A6000 48GB$0.817/GPU-hour
The 47/95/171-minute timings in the official repo were produced on an RTX A6000, and 48GB holds both the merge-stage hierarchy and the 16GB render budget at once.

03 —

Four steps from an orbit video to a walkable scene

Copy these straight onto a NexGPU instance — PyTorch and CUDA images are prebuilt

01
Launch the instance and clone everything, submodules included
Start from a prebuilt PyTorch image and SSH in. The original repo's three submodules — diff-gaussian-rasterization, simple-knn and fused-ssim — must come with it; miss any one and the build fails. Use g++ or MSVC, since the README explicitly rules out Clang, and check that the GPU is compute capability 7.0 or higher.
```
git clone https://github.com/graphdeco-inria/gaussian-splatting --recursive && pip install -e submodules/diff-gaussian-rasterization submodules/simple-knn submodules/fused-ssim
```
02
Run COLMAP for camera poses — this is the real bottleneck
convert.py drives COLMAP through feature extraction, matching and sparse reconstruction to produce poses and an initial point cloud. Bad poses make everything downstream worthless — the Gaussians converge into cotton wool. In the official hierarchical 3DGS example, 1500 images took 47 minutes here, so do not budget it as a rounding error. Images wider than 1.6K are downscaled automatically, so control your input resolution deliberately.
```
python convert.py -s data/my_scene
```
03
Train — the original for metrics, gsplat for memory discipline
The original defaults to 30,000 iterations with checkpoints at 7,000 and 30,000. If memory gets tight, reach for --data_device cpu, raise --densify_grad_threshold, or set --test_iterations -1 to dodge evaluation-time spikes. If what you want is bounded memory and a permissive licence, switch to gsplat's MCMC strategy, where whatever you write in --strategy.cap-max is what the footprint becomes.
```
python train.py -s data/my_scene -m output/my_scene --optimizer_type sparse_adam --antialiasing
```
04
Export, compress, ship
The output lands at point_cloud/iteration_30000/point_cloud.ply, and raw PLY is heavy enough to wreck a web first paint. Converting to PlayCanvas SOG (meta.json plus WebP textures, optionally bundled into a single .sog) cuts it to roughly a fifteenth to a twentieth of PLY; the same tool also emits .spz and compressed.ply. Stop the instance and compute billing stops; only the PLY on disk keeps accruing storage.
```
npx splat-transform output/my_scene/point_cloud/iteration_30000/point_cloud.ply scene.sog
```

The arithmetic, in full

Start with the big one. The official Hierarchical 3DGS repo publishes its own timings for the example dataset (1500 images, 2 chunks) on an RTX A6000: 47 minutes of COLMAP, 95 minutes of chunk preprocessing, 171 minutes of training — 313 minutes total, or 5.22 hours. NexGPU's RTX A6000 48GB is $0.817/GPU-hour, so 5.22 × 0.817 ≈ $4.26. A block-scale scene, from raw photographs to a walkable hierarchical splat, for just over four dollars. Now the small one. Running all seven Mip-NeRF360 scenes to a full 30K iterations with gsplat takes 35m49s per scene on the official benchmark, so about 4.18 hours for the set, with a 5.7GB peak that a 24GB RTX 3090 barely notices: 4.18 × 0.193 ≈ $0.81. Under a dollar to reproduce an entire results table. Switch to MCMC capped at 1M Gaussians and a single scene takes 15m42s at 1.98GB — roughly $0.05 a run on the same 3090. Fan out ten concurrent instances for a hyperparameter sweep and an hour still costs $1.93. Billing is per second with no minimum and no setup fee, so you stop when the run stops. The PLY you keep is charged at the $0.414/GB-month median, and converting it to SOG knocks that down another order of magnitude.

04 —

FAQ

How much VRAM does Gaussian Splatting training actually need — is 24GB enough?

It depends on the route. The original repo puts "24 GB VRAM (to train to paper evaluation quality)" in its hardware requirements while also saying that by their calculations ~8GB should work — the gap is whether densification runs unchecked. With gsplat, the same 30K iterations on Mip-NeRF360 peak at 5.7GB; cap MCMC at 1M Gaussians and 1.98GB does it. So 24GB is comfortably enough for almost any single scene, and NexGPU's RTX 3090 24GB at $0.193/GPU-hour and RTX 4090 24GB at $0.540/GPU-hour cover both ends of that range.

Can I use 3D Gaussian Splatting commercially, or is there a licence problem?

Not with the INRIA original. Its LICENSE.md states in capitals that the software cannot be used, exploited or distributed for commercial purposes without prior explicit consent, and directs commercial users to Inria's tech transfer office. For products, move to an Apache-2.0 implementation: gsplat, NVIDIA's 3DGRUT, or Brush. All three install cleanly on NexGPU's prebuilt PyTorch images, with no quota request required.

Why does my 3DGS run start fine and then OOM halfway through?

Densification. The Gaussian count grows throughout training, so peak memory arrives in the middle-to-late phase rather than at launch — which is exactly why the original repo offers --densify_grad_threshold, --densify_until_iter, --data_device cpu and --test_iterations -1 as escape hatches. To remove the uncertainty entirely, use gsplat's MCMC strategy and pin cap-max so the footprint becomes a constant you can budget. On NexGPU you can also prototype on a $0.193/GPU-hour 3090 and move to a 48GB A6000 only if you hit the wall — per-second billing means the failed attempt costs pennies.

Can older cards like the Tesla P40 or V100 run Gaussian Splatting?

V100 yes, P40 no. The original requires CUDA compute capability 7.0 or higher: the Tesla V100 is 7.0 and the Tesla T4 is 7.5, both above the bar, while the Tesla P40 is Pascal at 6.1 and will not even get through building diff-gaussian-rasterization. NexGPU's Tesla V100 32GB is $0.188/GPU-hour — the cheapest 32GB of VRAM on the list and fine for gsplat-style training that does not need RT cores. For 3DGRT ray tracing you want the RTX 5090 32GB at $0.723/GPU-hour instead.

Does the COLMAP step use the GPU, and how long does it take?

Yes. Feature extraction and matching use the GPU, while sparse reconstruction leans on single-core CPU performance, making it the hardest stage to parallelise. For reference, the official hierarchical 3DGS example took 47 minutes for 1500 images on an RTX A6000 machine. Since it shares a machine with training, NexGPU's per-second billing matters here: preprocessing and training are one continuous instance clock, compute billing stops the moment the instance stops, and a 47-minute job is never rounded up to a full hour.

My trained PLY is too big for the browser to load. What do I do?

Convert it. PlayCanvas SOG is a WebP-based super-compressed format that the project describes as 15–20× smaller than PLY, and splat-transform converts in one command between PLY, .sog, .spz, .ksplat and compressed.ply. The conversion is CPU work, so on NexGPU you can do it on the same instance right after training finishes and then shut down. What stays on disk is billed at the $0.414/GB-month median with egress at a $0.0081/GB median, which makes delivery cost effectively a rounding error.

Start building on NexGPU

Enterprise R&D team or solo developer — either way, your first job can be running in minutes.