---
title: Can One Photo Get You to a 3D Print? — Running TRELLIS on a Laptop GPU
url: https://oosioo.com/en/p/%EC%82%AC%EC%A7%84-%ED%95%9C-%EC%9E%A5%EC%9C%BC%EB%A1%9C-3d-%ED%94%84%EB%A6%B0%ED%8A%B8%EA%B9%8C%EC%A7%80-%ED%95%A0-%EC%88%98-%EC%9E%88%EC%9D%84%EA%B9%8C
date: 2026-11-02T14:25:58+00:00
author: SYSOP
summary: Upload a photo to services like Tripo or Meshy and a 3D model comes back in tens of seconds. I tried doing the same on a personal laptop with TRELLIS, released by Microsoft. The official requirement is 16 GB of GPU memory, but loading only the models each stage needs made it run on an 8 GB laptop (RTX 3070) in 12–22 s per object. Measured against ground truth, the public models landed within 1 mm on average when printed at 6 cm. Objects I built myself drifted to 1.5–3 mm, and a handle the photo did not show was never made. Getting to a 3D printer took more work: the generated meshes were hollow skins with only 4–56% of the volume they have once filled. I also compared it on the same laptop with TripoSR and TripoSG, released by Tripo: TripoSG matched or beat TRELLIS on shape and came out solid, but has no color and was more than three times slower. This post also lays out the lineage of 3D reconstruction methods and the principles behind Tripo and TRELLIS.
---
# Can One Photo Get You to a 3D Print? — Running TRELLIS on a Laptop GPU

![A single photo of a garden gnome lying on its side is on the left. Following the arrows to the right, the same gnome becomes a stack of tiny cubes (the 64³ skeleton), a smooth colored 3D mesh, and a white printable solid. The title reads "From one photo to a 3D print · TRELLIS · laptop RTX 3070 8 GB · 12–22 s each"](/uploads/3059717d108f2b3e.webp)

Upload one photo and, a few dozen seconds later, you get a 3D model you can spin around. That is what services such as Tripo, Meshy and Rodin do. Free credits buy about a dozen models a month; $20 a month buys about 200. Game props, figure mock-ups and product previews for online shops are made this way. MakerWorld, the model-sharing site of the 3D printer maker Bambu Lab, has added a photo-to-3D menu too.

So can you do it at home with an open model? In December 2024 Microsoft released a 3D generation model called TRELLIS under the MIT license. The official requirement is a GPU with at least 16 GB of memory. My laptop GPU has 8 GB. I tried whether it runs, how accurate it is, and whether it can take me all the way to a file a 3D printer will accept.

## What I set out to do

1. Lay out how 3D reconstruction methods developed, and look at the principles behind Tripo and TRELLIS.
2. Run TRELLIS on an 8 GB laptop GPU.
3. Measure accuracy on objects with a ground-truth model, comparing 1, 2 and 4 input photos, and against two of Tripo's open models.
4. Turn the results into 3D-printable files and put numbers on what goes wrong.
5. Build a web page that walks through each stage.

The research on principles and services went to an AI agent, which had to separate what it confirmed in primary sources (papers, official repositories, pricing pages) from what it saw only second-hand and what it could not confirm. Installation, experiments, print conversion and the web page were also built and run by AI agents.

## Five ways to get 3D

Turning objects into 3D is old. The methods fall into five broad families.

![A timeline from 2006 to 2026 with five rows. Active sensors: Kinect (2010, structured light), KinectFusion (2011), iPad LiDAR (2020). Solve many photos: Photo Tourism (2006), COLMAP (2016), NeRF (2020), 3D Gaussian Splatting (2023). Borrow 2D generators: DreamFusion (2022), Zero-1-to-3, MVDream, Zero123++ (2023). Predict in one pass: LRM (2023), TripoSR, InstantMesh (2024). Generate 3D natively: 3DShape2VecSet (2023), CLAY (2024), TRELLIS (late 2024), Hunyuan3D 2.0, TripoSG, Step1X-3D (2025), TRELLIS.2 (late 2025). The axis is widened after 2020 to spread out the crowded points](/uploads/6430868ec0b7e39e.webp)

### 1. Shine light and measure

Shine light on the object and measure what comes back. The first Kinect (2010) projected a dot pattern and computed distance from how the pattern bent (structured light). KinectFusion (2011) stitched those depth frames into a single 3D surface in real time. The LiDAR in the 2020 iPad Pro times the returning light to get distances up to 5 m. Most industrial 3D scanners belong here. Accurate, but you need the hardware, and shiny or transparent objects are hard.

### 2. Solve many photos

Photograph an object from many angles and you can find the same points in each photo and solve for camera positions and the 3D points together. This is photogrammetry (SfM and MVS). Photo Tourism showed it with tourist photos from the internet in 2006; today anyone can do it with free tools like COLMAP (2016).

NeRF (2020) represented a scene as "a neural network that returns color and density for a position and direction," and trained that network per scene until it looked exactly like the photos. 3D Gaussian Splatting (2023) did the same with millions of translucent ellipsoids (Gaussians) and made real-time rendering possible. Both need tens to hundreds of photos. In return, what was photographed comes out accurate.

### 3. Borrow 2D generators

With only one photo, you cannot know the back. DreamFusion (2022) handed the grading to an image generation model: render the 3D model from random angles and keep fixing it until the image model finds it plausible (Score Distillation Sampling). No 3D training data needed, but each object took over an hour. In 2023 image models were modified to draw other angles directly, "what this object looks like from the side" (Zero-1-to-3, MVDream, Zero123++). The drawn views are then solved with method 2.

### 4. Predict in one pass

LRM (Large Reconstruction Model), at the end of 2023, dropped optimization altogether. A transformer trained on about a million 3D objects looks at one photo and outputs a 3D representation (a triplane NeRF) in one go, in under five seconds. In March 2024 VAST, the company behind Tripo, and Stability AI released TripoSR, which refined this design and produced a mesh in under 0.5 s on an A100 GPU.

### 5. Generate 3D natively

Most services in use today belong here. Just as image generators create pictures in a "compressed number space" (latent space), these models learn a separate space that compresses 3D objects and generate inside it. 3DShape2VecSet (2023) compressed shapes into a set of vectors, and CLAY (the basis of Rodin, 2024), Hunyuan3D 2.0 (Tencent, 2025), TripoSG (2025) and Step1X-3D (2025) built on it. TRELLIS is in this family too, with a somewhat different way of compressing.

Families 1 and 2 **measure what is there.** Families 3 to 5 **invent the side you cannot see.** That difference explains almost all of the experimental results later in this post.

## How Tripo does it

Tripo has not published the architecture of its commercial models (labeled H3.1 and P2.0 on its developer page). The same company has, however, released three open models, all MIT-licensed.

- **TripoSR** (2024): family 4. A transformer reads one photo and predicts a triplane (three feature maps along width, height and depth) in one pass, from which a mesh is extracted. About 6 GB of GPU memory.
- **TripoSG** (2025): family 5. It first learns a compressor (VAE) that represents shape as "distance to the surface" (SDF), and then a 1.5-billion-parameter rectified flow model generates shapes in that space, conditioned on the photo. Trained on 2 million image–SDF pairs. 8 GB of GPU memory or more.
- **TripoSF** (2025): a compressor that attaches a surface extraction method called FlexiCubes to sparse voxels and represents shapes up to 1024³. What was released is the compressor and inference code.

Service prices (official pages on 2026-11-02, annual billing):

| Service | Free | Paid | Rights to what you make for free |
|---|---|---|---|
| Tripo | 200 credits/month (about 13 models) | Pro $20/month (about 200), Max $90/month (about 1,660) | Public models, non-commercial |
| Meshy | 100 credits/month | Pro from ₩28,869/month (shown in KRW from Korea) | CC BY 4.0 (commercial use allowed with attribution) |
| Rodin | 10 private assets | Creator $30/month (about 60) | Commercial terms of the free plan not confirmed |

Tencent's Hunyuan3D has open weights, but not for users in Korea. The 2.0 and 2.1 community licenses define their territory as "worldwide, excluding the European Union, the United Kingdom and South Korea." Downloading and using it from Korea falls outside the license.

## How TRELLIS does it

The core of TRELLIS is a 3D compression scheme called a Structured Latent (SLat).

- Put the object into a 64×64×64 grid and **switch on only the cells the surface passes through.** According to the paper, about 20,000 cells are on on average, around 8% of the 262,144.
- Attach **8 numbers** to each active cell. Those 8 numbers hold the shape and color of that cell in compressed form.
- During training, each object is rendered from 150 directions, and the features extracted by DINOv2, an image model that is good at reading photos, are averaged per cell to produce these numbers.

Generation has two stages. First it decides which cells to switch on (the skeleton), then it fills the 8 numbers for each active cell. Both stages are transformers using a generation method called rectified flow, and the input photo is read by DINOv2 and fed in as the condition. The finished latent can be decoded by one of three decoders. Decode each cell into 32 Gaussians and you get 3D Gaussian Splatting; decode into a 512³ volume and you get a NeRF-like radiance field; decode with FlexiCubes and you get a mesh at 256³ resolution. The official GLB files bake the Gaussians' colors onto the mesh.

The training data is about 500,000 objects drawn from Objaverse-XL, ABO, 3D-FUTURE and HSSD. The image model has 1.2 billion parameters. Counting the downloaded weights: 556 million in the skeleton generator, 600 million in the latent generator, 74 million in the skeleton decoder. On top of that come 300 million in DINOv2, which reads the photo, and 91 million in the mesh decoder.

The successor, TRELLIS.2, arrived in December 2025: 4 billion parameters, up to 1536³ resolution, and PBR materials such as metalness and roughness. It can represent open surfaces and interior structure. It needs 24 GB of GPU memory or more, so I did not try it on this laptop.

## Running it on an 8 GB laptop

The laptop has an RTX 3070 (8 GB), WSL Linux and 15 GB of memory. The official setup script uses conda and a C++ compiler to build several extension modules. This laptop had no compiler, so I installed only what is available prebuilt: sparse convolution (spconv), attention (xformers) and kaolin, which FlexiCubes uses.

Two pieces were left out: the rasterizer that draws Gaussians on screen, and nvdiffrast, which bakes textures onto meshes. Both are used to show results, not to generate them. I colored the mesh by copying the average color of the 8 nearest Gaussians onto each vertex. As a side effect this avoided a license problem: nvdiffrast is under an NVIDIA non-commercial license, and the Gaussian rasterizer under a research license. TRELLIS itself is MIT, but baking GLBs the official way pulls in parts you cannot use as-is in a commercial service.

At first I put every model on the GPU.

![The left bar chart shows peak GPU memory for five stages (read image, stage 1 skeleton, stage 2 latent, decode Gaussians, decode mesh). With all models on the GPU (gray) the first four stages take 5.4–5.7 GB and mesh decoding takes 10.4 GB, over the 8 GB line. With only what each stage needs (blue) they take 1.8–2.8 GB and mesh decoding 6.6 GB. The right chart is time: mesh decoding takes 24.7 s in gray and 2.4 s in blue; the rest are similar. Title: "Time: 35 s → 12 s"](/uploads/892e4c9af55ce40f.webp)

- **All models on the GPU:** 35 s per object. GPU memory reached 10.4 GB when decoding the mesh. The Windows driver covered the overflow by borrowing system memory, and that stage alone took 24.7 s.
- **Only what each stage needs on the GPU:** load only the models in use, in the order read photo → skeleton → latent → decoder, and move the rest to system memory. Peak 6.6 GB, 12 s per object.

The six examples took 13.6–21.7 s. More active cells mean a bigger mesh and a longer run. The mug, with over 30,000 active cells, peaked at 8.0 GB, right at the limit. In laptop electricity it costs less than one won (a tenth of a US cent) per object.

## How accurate is it? Objects with ground truth

Generated results usually look plausible to the eye, so I measured on objects with a ground-truth model.

- **Three public models:** Spot the cow, Bob the duck and Blub the fish, released into the public domain by Keenan Crane. They are well known and often used in graphics papers, so they may have been in TRELLIS's training data.
- **Two objects I built:** assembled from primitive shapes so that they cannot be in the training data. The mug's handle is hidden at the back so the front view does not show it. The little house has only a door in front; a round window and steps are on the back.

I rendered the ground-truth models to look like photos (768 px, from 15° above) and fed 1 photo (front, at an angle), 2 (front and back) or 4 (all sides). With several photos, TRELLIS cycles through them as the condition at each generation step. Three seeds each, 45 generations in all. Each result was scaled and rotated onto the ground truth, and I measured how far the two surfaces are from each other (symmetric chamfer distance). Numbers are in mm, as if the longest side were printed at 6 cm.

![The left bar chart shows mean error (mm) for five objects (Spot the cow, Bob the duck, Blub the fish, Mug, House) with 1, 2 and 4 photos. The three public models are low at 0.7–0.9 mm. The mug we built is 1.5, 1.2 and 1.2 mm; the house 3.0, 2.3 and 2.4 mm. The right chart compares, for one photo, how far the truth surface was missed on the side seen in the photo versus the unseen side: cow 0.7 and 0.7, duck 0.9 and 0.8, fish 0.7 and 0.9, mug 2.0 and 2.1, house 2.1 and 3.9 mm](/uploads/33d50bb13d2c76e3.webp)

| Object | 1 photo | 2 | 4 |
|---|---|---|---|
| Spot (cow) | 0.79 mm | 0.75 | 0.68 |
| Bob (duck) | 0.89 | 0.83 | 0.79 |
| Blub (fish) | 0.84 | 0.78 | 0.72 |
| Mug (built by us) | 1.52 | 1.22 | 1.17 |
| House (built by us) | 2.98 | 2.27 | 2.45 |

- **The public models were within 1 mm from a single photo.** On a 6 cm figure, 1 mm is barely visible. Errors on the unseen side were about the same as on the seen side. They are left-right symmetric, so mirroring the seen side usually fills in the unseen one, and the model may also have seen these shapes in training.
- **The objects I built drifted to 1.5–3 mm.** On the house, the unseen side was off by 3.9 mm, nearly double the seen side (2.1 mm).
- **More photos mostly helped, but not always.** The house with 4 photos (2.45 mm) was worse than with 2 (2.27 mm). Because the photos take turns as the condition, information from different photos gets mixed.

Where it goes wrong is quicker to see in pictures.

![A grid of renders. Three rows (mug from the side, house from the back, house from the side) and four columns (input photo, front; ground truth; made from 1 photo; made from 4 photos). Mug row: the truth has a round handle on the right, the 1-photo result is a plain cylinder without a handle, and the 4-photo result has the handle. House back row: the truth's back wall has a blue round window and gray steps; the 1-photo result put a brown door identical to the front door on the back wall, and the 4-photo result has a black smudge on the back wall. House side row: the truth's side wall is blank, but the 4-photo result grew a door on the side wall](/uploads/66f384e0e08ab9e5.webp)

- **It did not make a handle the photo did not show.** From a single front photo there is no way to know whether a handle exists. TRELLIS made a handleless cylinder for all three seeds. Adding a back photo, where the handle is seen head-on, gave a handle in two of three seeds; with 4 photos including the sides, all three had one.
- **It copied the front door onto the back of the house.** Instead of the round window and steps, it put on a door identical to the front one. Another seed put a door on all four walls. It fills the unseen side to "look like the side it saw."
- **Even 4 photos did not get everything right.** In the 4-photo result shown (seed 1), the back window became a black smudge and a door appeared on a side wall that has none. The steps appeared in no result at all.
- **From the front, depth is unknown.** One of the single-photo houses was deeper front-to-back and narrower than the truth. Aligning it to the truth gave almost the same error whether the roof matched the truth's direction or was turned 90°. The figure above uses seed 3, whose roof lines up correctly.

## Side by side with Tripo's open models

I could not test Tripo's commercial model, but the same company's open TripoSR (2024) and TripoSG (2025) run on the same laptop. I fed them exactly the same input images as the accuracy test (one photo) and measured them the same way. TRELLIS and TripoSG ran three seeds each; TripoSR always gives the same result for the same input, so it ran once.

![The left bar chart shows mean error (mm) for five objects (cow, duck, fish, mug, house) for TRELLIS (blue), TripoSR (orange) and TripoSG (green): cow 0.8, 1.1, 0.8; duck 0.9, 2.0, 0.6; fish 0.8, 1.6, 0.9; mug 1.5, 2.3, 1.3; house 3.0, 1.0, 2.5. The right bar chart shows the generated volume as a percentage of the filled volume: TRELLIS 25%, TripoSR 98%, TripoSG 96%. Inside the bars, the time per object: 16 s, 5 s, 53 s](/uploads/17a8f248591903cd.webp)

| Object | TRELLIS | TripoSR | TripoSG |
|---|---|---|---|
| Spot (cow) | 0.79 mm | 1.14 | 0.80 |
| Bob (duck) | 0.89 | 1.97 | 0.56 |
| Blub (fish) | 0.84 | 1.58 | 0.88 |
| Mug (built by us) | 1.52 | 2.35 | 1.30 |
| House (built by us) | 2.98 | 1.02 | 2.55 |
| Time per object | 12–22 s | 4–5 s | 47–62 s |
| Peak GPU memory | 6–8 GB | 2.5 GB | 5.4 GB |

- **On shape alone, TripoSG matched or beat TRELLIS.** Duck 0.56 mm, mug 1.30 mm. But it makes no color and took close to a minute per object (50 steps, the official setting).
- **TripoSR is fast, but the back gets mushy.** It needs only 5 s and 2.5 GB. On the public models it was the worst at 1.1–2.0 mm. As with the duck in the figure below, the unseen side looks melted and blurry. That is the limit of predicting in one pass (family 4).
- **Only on the house did TripoSR fit best, at 1.02 mm.** TripoSR reconstructs the shape relative to the camera that took the photo; even the 15° tilt of the input photo was left in the result. Copying the proportions visible in the photo literally got the house's depth right. TRELLIS and TripoSG built the house deeper than the truth, or shallower and taller. Generative models fill in with "houses like this are usually like that."
- **None of the three made the handle.** On the back wall of the house, TRELLIS and TripoSR copied the front door. TripoSG has no color, so you cannot even tell whether it added a door.

![A grid of renders. Three rows (duck from the back, mug from the side, house from the back) and four columns (ground truth, TRELLIS, TripoSR, TripoSG). Duck row: the truth is yellow with blue spots; TRELLIS gets the shape right but paints the back dark green; TripoSR is yellow but the back is mushy; TripoSG is gray but its shape is closest to the truth. Mug row: only the truth has a handle; all three models made a plain cylinder, and TripoSR's mug is shorter. House row: the truth's back wall has a round window and steps; TRELLIS and TripoSR put a door on the back wall, and TripoSG shows only a gray wall](/uploads/4b82cce5a131dd36.webp)

## Getting to a 3D printer

What happens if you put a generated mesh straight into a slicer? A 3D printer file has a few conditions. The surface must be closed with no gaps (watertight), there must be no loose debris, and walls must be thick enough for the nozzle. For the common 0.4 mm nozzle the rule is at least 0.8 mm, 1.2 mm to be safe. And the bottom must be flat to stick to the bed.

I checked six examples against these rules: two real photos (a public-domain garden gnome figurine and a CC BY toy car), one example image from the TRELLIS repository (a dwarf), and the mug, house and cow from the accuracy test.

**First, debris.** Straight out of the model, meshes came in 2 to 9 pieces: one big body plus small bits split off at beard tips, between fingers and so on. Pieces with less than 0.5% of all faces were removed.

**Second, they were hollow.** This was the biggest issue.

![Two rows; on the left the cross-section lines of the generated mesh, on the right the cross-section after filling. House row: on the left the roof is only a thin triangular outline, a wall shows up as a single thin plate on the right, and there is no floor. On the right the whole house shape is solid blue. Cow row: on the left the body outline is drawn twice, an outer and an inner line running in parallel, like an empty balloon. On the right the same outline is solid blue](/uploads/889fa89f3dddfcfb.webp)

TRELLIS's mesh decoder learns to make rendered views match. Only the visible outer surface has to be right; nobody looks inside. So the little house had walls as thin as a single sheet of paper and an open bottom. The garden gnome was a skin open on the underside, where it touches the bench. The cow was a hollow balloon with a separate inverted inner skin inside the outer one.

![The left bar chart shows the volume of the six examples, gray (as generated, holes closed) next to blue (after filling), with the generated volume as a percentage of the filled volume above each blue bar: gnome 10%, toy car 16%, dwarf 35%, mug 56%, house 4%, cow 21%. The right chart shows the share of surface thinner than 0.8 mm: as generated, gnome 87%, toy car 22%, dwarf 8%, mug 0%, house 96%, cow 29%; after filling it drops to 0–2.9%](/uploads/f0e78608a179c6fd.webp)

| Example | Size (mm) | Volume as generated → after filling | Thinner than 0.8 mm | Overhang over 45° |
|---|---|---|---|---|
| Garden gnome (real photo) | 67×39×59 | 2.2 → 21.8 cm³ | 87% → 2.9% | 19.7% |
| Toy car (real photo) | 89×51×39 | 13.2 → 82.1 cm³ | 22% → 0% | 22.3% |
| Dwarf (example image) | 51×30×59 | 8.8 → 25.2 cm³ | 8% → 0.5% | 8.5% |
| Mug | 53×53×59 | 18.1 → 32.5 cm³ | 0% → 0% | 0% |
| House | 47×40×49 | 2.3 → 53.7 cm³ | 96% → 1.9% | 3.1% |
| Cow | 26×50×49 | 3.9 → 19.0 cm³ | 29% → 0% | 10.4% |

The generated volume was 4–56% of the filled volume. Tripo's two open models were different. On the five accuracy-test objects, TripoSR came out at 97–99% and TripoSG at 94–98%: solid from the start. Both compute a value over the whole space that says inside or outside (density for TripoSR, distance to the surface for TripoSG) and then extract the boundary. TRELLIS was at 5–56% on the same five objects. TripoSG, on the other hand, left many loose fragments (94 pieces on the mug). The median skin thickness of the house and the gnome was 0.2–0.3 mm. Put that into a slicer as is and walls thinner than the nozzle simply vanish, or the gap between two overlapping skins gets filled in odd ways. Here is how I filled the inside.

1. Stamp the mesh surface into a grid of 0.2 mm cells.
2. From each cell, draw straight lines in five directions (up, front, back, left, right); if all five hit the skin, count the cell as inside. The downward direction may be open and still count, because the model often leaves the underside empty when the photo does not show it. Places open at the top, like the inside of a mug, stay empty.
3. Turn the filled cells back into a mesh (marching cubes) and reduce it to 120,000 faces.

**Third, thin spots.** Whatever stays thin after filling really is thin, like the gnome's pipe and beard tips (2.9%). Those need to be scaled up or thickened.

**Fourth, the base and overhangs.** I cut the bottom flat by 1.5% of the height so it sits on the bed. The reclining gnome touches the bed with only 64 mm², and 20% of its surface faces more than 45° downward. It will not print without supports. The toy car also had 22%, under the wheels.

**Fifth, the color disappears.** The color of a generated model is painted onto vertices or a texture. An FDM printer with a single filament has no use for it. Printing in several colors needs a separate step that splits color regions and maps them to filaments.

After these fixes, all six STLs were closed, single solids. At 15% infill they come to roughly 10–35 g of PLA. I did not actually print them this time, nor did I run them through a slicer for print times. "A file you can put into a printer" is the scope of this post.

## Try it

```map /embed/trellis-3d-2026-en.html 16:10
A page that walks from one photo to a printable file. Pick one of six examples at the top right (garden gnome, toy car, dwarf, mug, house, cow) and step through photo → 64³ skeleton → Gaussians → mesh → printable → vs. truth with the buttons at the bottom. Drag to rotate and zoom. The table on the right shows generation time and GPU memory, piece counts, volume before and after filling, and the share of thin and overhanging surface.
```

On a narrow screen, **[open it in a new window](/embed/trellis-3d-2026-en.html)**. The "skeleton" stage shows the 64³ cells TRELLIS switched on first. In the "printable" stage, red is thinner than 0.8 mm and orange thinner than 1.2 mm. "vs. truth" opens only for the mug, house and cow, which have a ground truth. "Missed truth" paints, on the ground-truth model, the places the generated mesh missed. On the mug the handle and the rim are red, and the body is off by around 1 mm. On the house (1 photo, seed 3) the back steps and the chimney are red.

![The mug in stage 6, vs. truth, with "Missed truth" on. The body of the ground-truth mug is a mix of blue-gray and yellow, and the handle on the left and the rim are deep red. The table on the right shows generated → truth mean 0.92 mm, truth → generated mean 1.89 mm, and 15% of the truth surface missed by more than 2 mm](/uploads/153ebc609cd33a6d.webp)

![The garden gnome in stage 5, printable. The figurine, now a white solid, lies on a grid floor, with red and orange only at the pipe tip and a few other spots. The table on the right shows volume (before → after filling) 2.2 → 21.8 cm³, 2.9% of the surface thinner than 0.8 mm, 19.7% overhang area over 45°, 64 mm² bed contact area and about 15 g of PLA](/uploads/76199cbb4641e139.webp)

## Where it went wrong

- **At first it went over 8 GB.** With every model on the GPU, mesh decoding needed 10.4 GB. It ran without errors, but borrowing the overflow from system memory made that stage ten times slower. I switched to loading only the models each stage uses.
- **The official setup script would not run.** The laptop has no C++ compiler. I confirmed that generation works with prebuilt packages alone and chose to copy colors onto vertices instead of baking textures. That is why mesh colors in this post are blurrier than the official GLBs.
- **The alignment to the truth came out rotated 90°.** The house's footprint is nearly square, so aligning by shape alone sometimes matched the roof at a right angle. I changed the selection of candidate angles to look at color too. Even so, seed 1, built deeper front-to-back, had the same error either way and the alignment could not tell them apart.
- **TripoSR's results were lying down.** TripoSR outputs results with the z axis up. Scoring without fixing the axis gave the cow an error of 3.5 mm. Trying all six directions found the right axis (1.1 mm). TripoSG, like TRELLIS, has y up.
- **The filling leaked twice.** At first I filled from the outside, like pouring water. The skins were open at the bottom, so the water leaked in and nothing got filled. I closed it off with a plate where the print bed goes; the gnome's open rim sat higher than the plate, so it leaked again. I switched to the five-direction line test. Then it filled the inside of the mug as well, so I changed the rule once more to leave spaces open at the top empty.
- **I mistook the mugs for bottomless.** Rendering a generated mug from above showed a white circle inside. I thought the bottom was open and the background showed through. Counting vertex positions showed that all six had a bottom; the white circle was a white floor.
- **The web page's average error differed from the experiment.** The mug's "truth → generated mean" came out as 5.2 mm. I had averaged the distance at each vertex, and the ground-truth model's vertices crowd around the handle, so the average leaned toward it. Switching to points sampled evenly over the surface, as in the experiment, gave 1.9 mm.

## Why this works in one click

Generation itself really is one click. Put in a photo and a mesh comes out of a laptop in about 15 seconds. No free credits to ration, no photos uploaded to someone else's server. A model trained on 500,000 objects already has a feel for "this kind of photo means this kind of shape."

There are two places where one click does not work. One is **the side the photo does not show.** The model fills it with the most common, most plausible shape. For symmetric or common objects that is nearly right; where the object has its own story, a handle or a back door, it is wrong. Worse, it is wrong without looking wrong. The other is **the inside you cannot see.** The model learned to look plausible on screen, so turning its output into something you can hold means a person has to decide to fill the inside and check thickness.

## If you want to try

- **With an 8 GB GPU, load and unload models per stage.** With 12 GB or more it will likely run as is. Mesh decoding uses the most.
- **Use photos with a simple background and the object large in the center.** Real photos go through background removal (rembg) first; a messy background is where things go wrong first.
- **If the back matters, photograph the sides.** The mug's handle came back in two of three seeds with front and back photos, and in all three with 4 photos including the sides. If you can take many photos, family 2 (photogrammetry, 3D Gaussian Splatting) is more accurate.
- **If printing is the goal, consider TripoSG too.** It comes out as a solid, so it barely needs filling. It has no color, and the fragments must be removed.
- **Fill the inside before printing.** Generated meshes had 4–56% of the filled volume. Then check 0.8 mm thickness, cut the base flat, and look at overhangs, in that order.
- **Check the licenses.** The TRELLIS model and code are MIT. nvdiffrast, which bakes the official GLBs, is non-commercial. pymeshfix, commonly used for mesh repair, is AGPL. Hunyuan3D's open weights exclude Korea from their territory. What you make on Tripo's free plan is non-commercial.

## What this cannot do

- **No official GLBs.** I skipped texture baking and used vertex colors only. Textures good enough for game assets do not come out of the method in this post.
- **No comparison with commercial services.** Only Tripo's open models (TripoSR, TripoSG) were run. Commercial Tripo (H3.1), Meshy and others need accounts and uploads and were not tested. Whether the quality is "similar" to commercial services cannot be said from the numbers here.
- **Only five objects with ground truth.** Three of them may have been in the training data. Accuracy on real photos could not be measured, since there is no ground truth.
- **The inputs are renders.** The photos in the accuracy test are renders with clean lighting and backgrounds. Real photos are harder.
- **Nothing was actually printed.** Slicer times, support volume and print success were not measured. The thickness and overhang checks are estimates.
- **TRELLIS.2 was not run.** It needs a 24 GB GPU.

Still, getting a 3D model from one photo now takes just a laptop. It comes out in 15 seconds and, for objects on the level of the public models, lands within 1 mm. But that model is a skin with nothing inside, and its back is imagined. For something you want to print, generation is only the starting point; filling the inside and measuring thickness remain. For the side that has to be right, taking one more photo is the cheapest fix.

### If you enjoyed this, please leave a comment.

## Sources

- TRELLIS: Xiang et al., "Structured 3D Latents for Scalable and Versatile 3D Generation" [arXiv 2412.01506](https://arxiv.org/abs/2412.01506) (CVPR 2025), [GitHub microsoft/TRELLIS](https://github.com/microsoft/TRELLIS), [project page](https://microsoft.github.io/TRELLIS/)
- TRELLIS.2: Xiang et al., "Native and Compact Structured Latents for 3D Generation" [arXiv 2512.14692](https://arxiv.org/abs/2512.14692), [GitHub microsoft/TRELLIS.2](https://github.com/microsoft/TRELLIS.2)
- Tripo open models: [TripoSR](https://github.com/VAST-AI-Research/TripoSR) ([arXiv 2403.02151](https://arxiv.org/abs/2403.02151)), [TripoSG](https://github.com/VAST-AI-Research/TripoSG) ([arXiv 2502.06608](https://arxiv.org/abs/2502.06608)), [TripoSF](https://github.com/VAST-AI-Research/TripoSF) ([arXiv 2503.21732](https://arxiv.org/abs/2503.21732)), [Tripo developer page](https://developers.tripo3d.ai/)
- Pricing: [Tripo](https://www.tripo3d.ai/pricing), [Meshy](https://www.meshy.ai/pricing), [Rodin](https://hyper3d.ai/pricing) (all checked 2026-11-02)
- Hunyuan3D licenses: [Hunyuan3D-2.1 LICENSE](https://github.com/Tencent-Hunyuan/Hunyuan3D-2.1/blob/main/LICENSE), [Hunyuan3D-2 LICENSE](https://github.com/Tencent-Hunyuan/Hunyuan3D-2/blob/main/LICENSE)
- Lineage: KinectFusion [Newcombe et al. 2011](https://www.microsoft.com/en-us/research/publication/kinectfusion-real-time-dense-surface-mapping-tracking/), [iPad Pro LiDAR announcement](https://www.apple.com/newsroom/2020/03/apple-unveils-new-ipad-pro-with-lidar-scanner-and-trackpad-support-in-ipados/), [COLMAP](https://colmap.github.io/), NeRF [arXiv 2003.08934](https://arxiv.org/abs/2003.08934), 3D Gaussian Splatting [arXiv 2308.04079](https://arxiv.org/abs/2308.04079), DreamFusion [arXiv 2209.14988](https://arxiv.org/abs/2209.14988), Zero-1-to-3 [arXiv 2303.11328](https://arxiv.org/abs/2303.11328), MVDream [arXiv 2308.16512](https://arxiv.org/abs/2308.16512), Zero123++ [arXiv 2310.15110](https://arxiv.org/abs/2310.15110), LRM [arXiv 2311.04400](https://arxiv.org/abs/2311.04400), InstantMesh [arXiv 2404.07191](https://arxiv.org/abs/2404.07191), 3DShape2VecSet [arXiv 2301.11445](https://arxiv.org/abs/2301.11445), CLAY [arXiv 2406.13897](https://arxiv.org/abs/2406.13897), Hunyuan3D 2.0 [arXiv 2501.12202](https://arxiv.org/abs/2501.12202), Step1X-3D [arXiv 2505.07747](https://arxiv.org/abs/2505.07747)
- Licenses: [nvdiffrast](https://github.com/NVlabs/nvdiffrast/blob/main/LICENSE.txt), [diff-gaussian-rasterization](https://github.com/graphdeco-inria/diff-gaussian-rasterization/blob/main/LICENSE.md), [pymeshfix](https://github.com/pyvista/pymeshfix)
- 3D printing: minimum wall thickness [Formlabs](https://formlabs.com/blog/minimum-wall-thickness-3d-printing/), MakerLab Image to 3D [Bambu Lab forum](https://forum.bambulab.com/t/new-makerlab-tool-image-to-3d-model/76805), [3D Printing Industry](https://3dprintingindustry.com/news/meshy-and-makerworld-team-up-to-put-ai-3d-model-generation-in-bambu-lab-users-hands-250281/)
- Ground-truth models: Keenan Crane, [3D Model Repository](https://www.cs.cmu.edu/~kmcrane/Projects/ModelRepository/) (Spot, Bob, Blub, public domain)
- Installation, experiments, print conversion, the web page and the charts were all made for this post

## Image credits

- Garden gnome photo: [German garden gnome.jpg](https://commons.wikimedia.org/wiki/File:German%5Fgarden%5Fgnome.jpg), Colibri1968, public domain (Wikimedia Commons)
- Toy car photo: [CreativeTools.se - PackshotCreator - Toy car](https://commons.wikimedia.org/wiki/File:CreativeTools.se%5F-%5FPackshotCreator%5F-%5FToy%5Fcar%5F%284294245549%29.jpg), Creative Tools, CC BY 2.0 (Wikimedia Commons)
- Dwarf image: [TRELLIS repository example](https://github.com/microsoft/TRELLIS/tree/main/assets/example%5Fimage) (MIT)
- All other images and screenshots were made for this post

