Gaussian splatting,
explained.

Neural radiance fields (NeRF) represent a scene implicitly: a small neural network that, given a 3D point and a viewing direction, returns a color and density. To render one pixel you cast a ray into the scene and march along it, querying that network at many sample points and integrating the results. Gorgeous quality — but that's dozens or hundreds of network evaluations per pixel, per frame. Rendering is seconds per image, nowhere near interactive.

Gaussian Splatting asks: what if the scene were explicit — a concrete geometric thing you could draw directly, the way GPUs love to draw triangles — instead of a function you have to probe? Then rendering becomes rasterization, which hardware does astonishingly fast. The trick is choosing a primitive that's explicit and drawable, yet soft enough to represent fuzzy real-world appearance and be optimized smoothly. That primitive is the 3D Gaussian.

The scene is a collection of 3D Gaussians, each a soft ellipsoidal blob defined by four things: a position (its center), a covariance (its shape and orientation — how stretched, in which directions), a color (view-dependent, via spherical harmonics), and an opacity. A single Gaussian is a smooth lump of colored, semi-transparent fog; a million of them, arranged in space, can reconstruct a whole scene in fine detail.

The softness matters. Because each Gaussian falls off smoothly from its center — its footprint is densest in the middle and fades outward — the representation has no hard edges to alias, and every parameter is differentiable. That means the whole scene can be optimized by gradient descent (section 04), which a mesh of hard triangles can't be nearly as gracefully. Explicit enough to rasterize, soft enough to optimize: that combination is the whole design.

To render a view: project every 3D Gaussian onto the image plane (a "splat" — a 2D Gaussian footprint), sort them by depth, and blend them front-to-back with alpha compositing. A pixel's color accumulates each Gaussian's contribution, weighted by how much light is still unblocked by everything in front of it — the transmittance:

Transmittance T_i is the running product of "what got past" all the nearer, more opaque splats, so a fully opaque Gaussian in front (α = 1) drives T to zero and occludes everything behind it — exactly as physical over-painting should. It's the same volume-rendering equation NeRF integrates, but applied to a sorted, discrete set of Gaussians you can rasterize in one fast pass, not sampled along rays through a network. The runnable version below computes this compositing and shows why depth order matters.

How do you get the millions of Gaussians in the first place? You optimize them to reproduce your input photos. The pipeline is fully differentiable, so gradient descent can tune every Gaussian's position, shape, color, and opacity to minimize the difference between rendered views and the real photos:

That last step — adaptive density control — is what lets the scene allocate detail where it's needed: splitting Gaussians in under-reconstructed regions, removing ones that contribute nothing. After a few minutes of optimization you have a scene that renders novel viewpoints in real time. Training is fast, rendering is faster.

The headline is the combination of quality and speed that had never coexisted:

That last point is quietly important: because the scene is explicit geometry, it plays well with existing graphics pipelines and can be edited, animated, and combined in ways an implicit network resists. Real-time speed plus an explicit, malleable representation is why it moved so fast from paper to product.

Gaussian Splatting spread through graphics and vision almost overnight, spawning a huge wave of follow-ups: dynamic and animatable scenes, avatars, SLAM, compression, generative 3D. The reason is the same one that made it fast — an explicit, differentiable, GPU-friendly primitive sits at a sweet spot the field had been circling, and once someone showed it worked at real-time speed with NeRF-level quality, everyone could build on it.

Its deeper lesson is about representation choice. NeRF's implicit network was a beautiful idea whose cost was baked into the representation itself — you couldn't make querying-a-network-per-sample cheap. Switching to an explicit set of soft primitives didn't just optimize the old approach; it changed the computational character of the problem from "evaluate a function millions of times" to "rasterize millions of things," which is exactly what graphics hardware was built for. Sometimes the biggest speedup comes from picking a representation the hardware already loves.