# SHARP demo: explore the results

See Apple’s single-image view synthesis examples, then generate a 3D Gaussian representation from your own photograph locally.

Canonical URL: https://aiidelist.com/blog/apple-sharp-image-to-3d

Language: en

Published: 2026-09-24

Updated: 2026-09-24

SHARP · IMAGE TO 3D

See Apple’s single-image view synthesis examples, then generate a 3D Gaussian representation from your own photograph locally.

## Explore the official comparison gallery

This gallery contains pre-rendered research examples with interactive scene and method comparisons. It does not upload your photo or run SHARP inference in your browser.

[Open gallery in a new tab ↗](https://apple-aiml-research.github.io/ml-sharp/#videos)

## Generate a scene from your own image

### Install SHARP

Python 3.13 · official SHARP CLI

```text
conda create -n sharp python=3.13 -y
conda activate sharp
git clone https://github.com/apple-aiml-research/ml-sharp.git
cd ml-sharp
python -m pip install -r requirements.txt
sharp --help
```

Put one or more photos in an input directory, then run prediction. The checkpoint downloads automatically on the first run.

Predict

```text
sharp predict -i ./input -o ./output
```

Successful prediction writes 3D Gaussian .ply files to the output directory. Open them in a compatible Gaussian-splat viewer. The result supports nearby viewpoints; it is not a complete reconstruction of unseen parts of a scene.

## Choose the right device

**Gaussian prediction**

CPU, CUDA or Apple MPS

**Render a camera-path video**

CUDA GPU required by the official renderer

### Optional: render a video on CUDA

CUDA

```text
sharp predict -i ./input -o ./output --render
# Or render previously generated Gaussians:
sharp render -i ./output -o ./renderings
```

## If something goes wrong

- First run appears slow: allow time for checkpoint download and initialization; inspect the terminal output.
- Video rendering fails on Mac: prediction supports MPS, but the official --render path requires CUDA.
- Scene orientation looks wrong in another viewer: SHARP uses OpenCV coordinates; check scale and rotation in that viewer.

Official code and examples · checked September 12, 2026

[Apple GitHub ↗](https://github.com/apple-aiml-research/ml-sharp) · [Official examples ↗](https://apple-aiml-research.github.io/ml-sharp/) · [Paper ↗](https://arxiv.org/abs/2512.10685)

## Image to 3D: one photo, a 3D Gaussian splat

IMAGE TO 3D · GAUSSIAN SPLATS

Apple SHARP predicts a 3D Gaussian representation from a single photograph in under a second on a GPU and renders nearby viewpoints in real time. This page is the task-first guide: what you get, how to run it locally on Mac or CUDA, and how to view the result.

[See official SHARP examples](/blog/apple-sharp-image-to-3d) · [GitHub](https://github.com/apple-aiml-research/ml-sharp)

## What you get

- A .ply file of 3D Gaussians with metric scale, ready for splat viewers.
- Real-time parallax around the original viewpoint—think 3D photos, not a full model.
- Optional rendered camera-path videos on CUDA GPUs.

## Run SHARP locally

1. Create a Python 3.13 environment and install the official repository.
2. Put one or more photos in an input folder.
3. Run sharp predict; the checkpoint downloads on first use.
4. Open the output .ply in a Gaussian-splat viewer.

Python 3.13 · official SHARP CLI

```text
conda create -n sharp python=3.13 -y
conda activate sharp
git clone https://github.com/apple-aiml-research/ml-sharp.git
cd ml-sharp
python -m pip install -r requirements.txt
sharp predict -i ./input -o ./output        # CPU, CUDA or MPS
sharp predict -i ./input -o ./output --render   # video rendering needs CUDA
```

## Viewing the result

SHARP writes standard 3D Gaussian .ply files. Web-based splat viewers open them directly; SHARP uses OpenCV camera conventions, so check scale and orientation if a viewer shows the scene flipped.

## Need a relightable asset instead?

Luce (Apple, August 2026) targets objects rather than scenes and predicts PBR materials—albedo, metallic-roughness and normals—so the asset can be relit and exported as a mesh. Code was not confirmed as public at the time of checking.

[Luce →](/blog/luce) · [Luce vs SHARP →](/blog/luce-vs-sharp)

## Questions

**Is this the same as photogrammetry?**

No. Photogrammetry needs many photos and reconstructs the full object. SHARP infers a plausible 3D scene from one photo and is designed for nearby views only.

**Can it run in the browser?**

Generation runs locally with the official CLI; there is no in-browser inference. Viewing the .ply output in a web splat viewer works fine.

**Does it work on iPhone?**

Not as shipped; the reference implementation is a Python package for Mac and Linux. Render the result on a computer, then share the video or splat file.

## Hardware

- Prediction: CPU, CUDA or Apple Silicon (MPS).
- Video rendering (--render): CUDA GPU required by the official renderer.
- A recent Mac produces a scene in seconds; unseen regions stay unreconstructed.

- [SHARP model page](/blog/apple-sharp-image-to-3d)
- [Depth Pro](/blog/depth-pro)
- [More tools](/blog/apple-ai-browser-tools)