Bake It Till You Make It

Abstract

Recent extensions of 3D Gaussian Splatting capture fine color detail using hash-grid based appearance parameterization, but pay a high per-fragment cost from neural field queries during rendering. We introduce a decoupled radiance representation that models low-frequency geometry and view-dependent appearance with 2D surfels, while representing high-frequency texture as a view-independent residual. Because the residual is view independent, we bake it into a compact texture, so inference reduces to pure hardware texture sampling with no neural queries. Combined with sparsity-enhancing optimization, our method renders significantly faster and sparser than prior work while preserving perceptual fidelity, reaching real-time 4K rates on consumer hardware and real-time rendering on mobile devices.

Key Ideas

• View-independent texture residual. Restricting the residual to be view independent is what makes it bakeable, removing per-fragment neural queries at inference.
• Hardware-native rendering. Inference is nothing but GPU texture lookups. Storing the residual as block-compressed BC7 means the texture unit decompresses and filters it in fixed-function hardware, at the same per-fragment cost as an uncompressed fetch but a fraction of the bandwidth — and the same path runs on mobile GPUs, which ship the equivalent hardware (BC7 on desktop and iOS, ASTC on Android). The rasterization itself is hardware too: a Vulkan port using the GPU's fixed-function rasterizer and ROP blending draws the same bakes 1.7× faster than our CUDA renderer at measured parity.
• Sparse geometry. Decoupling appearance from geometry lets the surfels stay sparse instead of splitting to fit texture, lowering primitive count. Flattened beta-surfels sharpen the opacity falloff to a compact support, so each surfel covers fewer fragments and far fewer of them survive the alpha cutoff — cutting overdraw, the dominant per-pixel cost once primitive count is low.

Method

Interactive Demo

Garden

79 MB · Mip-NeRF 360 · baked texture atlas

Garden

104 MB · experimental — learned probes

Brain

123 MB · micro-CT · experimental — proxy-mesh occlusion culling

Results

Rendering throughput and quality on three standard benchmarks, measured on a single RTX 5090. All timings use per-frame cuda.Event pairs (50 warmup + 400 timed frames, sort and preprocess included), cycling through each scene's full held-out test set so all methods are timed on identical images. We first highlight the two most relevant baselines: FastGS, the fastest untextured method, which optimises the per-primitive cost of a conventional splat, and Nexels (100K), the strongest textured baseline near our primitive budget. We instead change what a primitive stores — moving high-frequency appearance into a baked texture, so far fewer and cheaper primitives are needed. The full comparison follows below.

Full comparison: one GPU, one eval script

Every baseline below is retrained and re-benchmarked by us on the same RTX 5090, with quality recomputed from the saved renders by one shared evaluation script — no numbers are copied from other papers. We are the fastest method on all three benchmarks; among methods above 1000 FPS we have the best LPIPS on every benchmark mean and on 12 of 13 scenes. Red, orange and yellow tints mark the best, second and third value in each quality and speed column (Primitives and Size are context, not ranked; see the note below).

Show every method in the plot

Show our per-scene results

Our method carries ~3× fewer primitives than FastGS on every benchmark (over 10× fewer than 3DGS) and is 7–9× faster than 3DGS on the benchmark means, up to 13× on garden. FastGS holds a small PSNR edge on Mip-NeRF 360 (−0.21 dB) and Deep Blending (−0.15 dB) and we lead on Tanks & Temples (+0.10 dB), while LPIPS favours us on all 13 scenes — the explicit texture holds high-frequency detail that a per-primitive colour model cannot. Nexels (400K), the strongest textured baseline, edges our LPIPS on Mip-NeRF 360 and Deep Blending but renders 16–36× slower and trails us on Tanks & Temples. FastGS's own high-quality recipe, FastGS (Big), closes much of the LPIPS gap and still trails us on every benchmark mean, at 1.6–2.3× our primitive count and 0.6–0.8× our frame rate.

Texture finetune. The baked atlas is initialised from the trained neural residual and then finetuned against the training images for a short schedule, with geometry and view-dependent colour frozen so only the texels move. Baking alone can only lose information relative to its teacher; optimising the texels directly recovers it and then exceeds it, worth +0.49 dB and −0.037 LPIPS on average over the raw bake at identical primitive count, storage and frame rate.

Protocol. FastGS checkpoints were trained with its own released script (train_base.sh), which loads images at the 3DGS default (long edge capped at 1600 px). On Mip-NeRF 360 we render them at the standard evaluation resolution (images_4 outdoors, images_2 indoors) so both methods are measured on identical images; retraining FastGS at that resolution changes its primitive count by −8 % and its throughput by <3 %. On Tanks & Temples and Deep Blending both methods already use the same native resolution. FastGS runs at its own released default (mult = 0.5); at mult = 1.0 it gains ~0.2 dB PSNR and loses ~11 % throughput, with LPIPS essentially unchanged.

BibTeX

@article{kelkar2026bake,
  title   = {Bake It Till You Make It: Ultrafast Spatial Texture-Surfel Splatting},
  author  = {Kelkar, Neel and Niedermayr, Simon and Petkov, Kaloian and
             Engel, Klaus and Westermann, R{\"u}diger},
  journal = {arXiv preprint arXiv:2607.13808},
  year    = {2026}
}