SHARP regresses 1.2 million metric-scale Gaussians from a single photograph in under a second. Here is how it works, the two training tricks that make it possible, how to run it — Mac included — and the licensing detail most coverage got wrong.
In December 2025, Apple released SHARP, a model that turns a single photograph into a 3D Gaussian scene in under a second. The release was widely covered in the tech press, but the articles stop at the headline. This post covers what a practitioner actually needs: how the model works, the two training ideas that make it possible, what it deliberately does not attempt, and the licensing detail most articles got wrong. SHARP was accepted at ICLR 2026, and it closes my feed-forward 3DGS timeline for a reason: it is the clearest demonstration of how far single-image reconstruction has come.
SHARP takes one photograph, at up to 1536×1536 resolution, and produces roughly 1.2 million 3D Gaussians in a single forward pass — about 0.9 seconds on an A100, with the resulting scene rendering above 100 frames per second. The scene is metric: distances are in real-world units, inherited from the metric depth model it is built on, so camera movements in it correspond to physical distances.
Just as important is what it does not attempt. The paper states the design target plainly: to "support natural posture shifts in AR/VR headsets, providing the experience of looking at a stable 3D scene from different perspectives," while it "need not support substantial travel ('walking around') within the photograph." SHARP is built for the view range of a person's head, not a walkthrough. That constraint is what buys the quality: the only content the model ever has to invent is the thin regions at object edges that appear when the viewpoint shifts slightly, and it fills those deterministically from learned priors — it is regression, not a generative model. If you want the full taxonomy of that distinction, I cover it in world models versus 3D reconstruction.
SHARP stands on Depth Pro, Apple's own monocular metric depth model, which is what makes the output metric-scale. The backbone's patch encoder stays frozen; the depth decoder and the low-resolution part of the encoder are unfrozen and fine-tuned for the new task. On top of this sit DPT-style decoders that output, for each cell of a 768×768 grid, two Gaussians — one for the visible surface, a second that can represent what that surface occludes or how its appearance shifts with viewing angle. Each Gaussian carries fourteen numbers: a 3D position, a 3D scale, a rotation quaternion, an RGB colour and an opacity. Notably, there are no spherical harmonics — plain RGB.
Two training-time ideas deserve more attention, because both address the same fundamental obstacle: a single photograph does not determine its own depth.
The first is a depth-adjustment module that exists only during training, and the problem it solves is the scale ambiguity of monocular depth. From a single photograph, scale cannot be determined: a large room far away and a small room close up can produce the same image, so many depth maps are consistent with what the network sees. Trained with an ordinary loss, a depth network handles this by predicting a compromise — in the paper's words, outputs "at the mean scale of possible outcomes" — a depth map that matches none of the valid answers and produces artifacts when a scene is built on it. SHARP's solution is to settle the scale question externally during training. A small side network — a U-Net of about two million parameters — receives both the predicted depth and the ground-truth depth, and outputs a per-pixel scale factor; multiplying the prediction by this factor brings it to the same scale as the ground truth. The scale map is regularized, so it cannot simply copy the ground truth into the prediction — it can align the scale, nothing more. With the scale aligned, the training loss no longer punishes the network for choosing a different but equally valid scale; it only punishes real errors. This is only possible during training, because the side network needs the ground truth as input. At inference it is simply removed, and the model predicts depth on its own. (The construction is adapted from conditional variational autoencoders, with the regularizer playing the role of the KL term.)
The second is view-swap self-supervision, which solves a data problem: real photographs come alone, with no second viewpoint to supervise novel views against. SHARP trains first on millions of synthetic multi-view renders, where perfect supervision exists. Then, on millions of real single photographs, it plays a swap: generate a pseudo-novel view from the photo, then treat that generated view as the input and the original photo as the novel view target. The real photograph — actual ground truth — ends up supervising novel-view synthesis, without a second camera ever existing.
The headline numbers from the paper: against the strongest prior method, Gen3C, SHARP reduces LPIPS by 25 to 34 percent and DISTS by 21 to 43 percent across six zero-shot benchmarks — none of which it was trained on. The speed comparison is the more striking one: Gen3C is a video-diffusion-based approach that takes on the order of minutes per scene, and ViewCrafter likewise; SHARP produces its scene roughly three orders of magnitude faster. Against Flash3D, the closest feed-forward relative, the quality gap is wide in SHARP's favour. Being regression rather than diffusion is precisely what makes the sub-second time possible: one pass, one answer, no sampling loop.
The code is on GitHub and the practical path is short: create a Python environment, install the requirements, and run sharp predict -i your_images -o gaussians --render. The weights download automatically on first run. Prediction runs on CUDA, on CPU, and — notably — on Apple Silicon via MPS, so a Mac can turn photos into splats; only the video rendering path requires CUDA. The output is a standard 3DGS .ply file that loads in any of the usual splat viewers.
Now the licensing detail the news coverage flattened. Most articles called SHARP "open source." The truth has two halves: the code ships under Apple's permissive sample-code license, but the weights ship under the Apple Machine Learning Research Model License — research use only, with commercial exploitation explicitly excluded. You can study it, benchmark it, build research on it, and write blog posts about it. You cannot ship it in a product. If your plans involve revenue, read the license file before you architect around this model.
The authors are specific about failure modes, and they are worth knowing before you feed it your photo library. Depth errors concentrate at object boundaries and in fine structures like foliage. Photographs with strong depth-of-field or macro shots mislead the depth backbone. A starry sky comes back as a curved surface. Water reflections are read as distant geometry — the classic non-Lambertian failure that, as the timeline article notes, no method in this field has solved. And by design, views far from the input camera are out of scope: that is the headbox constraint, not a bug.
SHARP follows the design that came to dominate feed-forward 3DGS in 2025: a largely frozen pretrained geometry backbone, a lightweight decoder on top, and the ingenuity invested in training rather than in architecture — the same pattern as Depth Anything 3's frozen-backbone Gaussian head. SHARP is that pattern applied to a single photograph, and executed with product-level polish. Compare it with Splatter Image, which opened the same single-image problem two years earlier on 64×64 synthetic renders, and you have the full distance the field travelled — which is exactly how the timeline article tells the story.
Yes, for prediction: SHARP supports Apple Silicon through MPS, alongside CUDA and CPU. Turning a photo into a Gaussian .ply works on a Mac. Only the built-in video rendering path requires a CUDA GPU — but the output file can still be viewed on a Mac, since community splat viewers, including browser-based ones, display standard .ply splats.
No. SHARP is a regression model: one forward pass, one deterministic answer, no sampling. It synthesizes small amounts of unseen content — the thin regions revealed at object edges when the viewpoint shifts — but it fills them from learned priors deterministically, and it never invents beyond the photograph's frame.
A standard 3D Gaussian Splatting .ply file of roughly 1.2 million Gaussians at metric scale, with plain RGB colours rather than spherical harmonics. It loads in ordinary splat viewers and renders above 100 frames per second.
SHARP's output renders through the same differentiable rasterizer as every method on this site. My 3D Gaussian Splatting Course builds that pipeline from first principles in PyTorch only — no CUDA, no C++ — covering initialization, rasterization, backward passes and training loops.
Explore the Course →I share practical posts on 3DGS, NeRF, PyTorch implementations, research breakdowns, and the engineering details that usually get skipped.
Subscribe →At Qubit Analytics, we help companies put 3D Gaussian Splatting to work — classic per-scene 3DGS, feed-forward 3DGS, and the 3D foundation models covered on this page. We integrate these techniques into products, build custom reconstruction pipelines, and turn recent research into working prototypes.
For consulting inquiries:
contact@qubitanalytics.be