NVIDIA free 3D assets: how to download and 3D print them

By Ashish · Nov 15, 2026 · ~14 min · 3D printing

NVIDIA free 3D assets are easy to find, but they are hard to print. NVIDIA gives away a large amount of free 3D content, and you may want to print some of it. The catch is the file format. Slicers read STL and 3MF, but NVIDIA's assets come as USD files. This guide shows where to get them, how to convert USD to STL with a script I ran myself, and the license rules and credit you owe NVIDIA.

I will say exactly what I tested and what I did not. I ran the conversion on one NVIDIA asset with the Python code below. I did not test Blender, and I did not slice or print the result. Where something comes from documentation and not from my own test, the text says so.

Quick answer. NVIDIA free 3D assets are USD files, which are scenes that point to other files, so download the whole asset folder. Read its units and up axis, and visit instanced meshes, because a plain traversal finds none. Then write a millimeter STL and check size, wall thickness and separate bodies. The asset I tested is licensed CC BY 4.0, so credit NVIDIA and say you converted it.

NVIDIA free 3D assets: what they are, and what they are not

NVIDIA publishes its assets for robot and factory simulation, not for hobby printing. The format is OpenUSD, short for Universal Scene Description. It describes a whole scene, including shapes, materials, physics and links to other files.

NVIDIA's documentation lists 35 downloadable asset packs. They include warehouse parts, furniture, containers, data center equipment, materials and sample scenes. Sizes run from a few megabytes to more than 20 GB. The same page describes the assets as free to use in your own projects. It does not name a license, so do not rely on that sentence alone.

There is also SimReady Central, a library on Hugging Face where each asset owner publishes its own dataset. NVIDIA's own set is the SimReady Assets dataset. Its metadata lists the license as CC BY 4.0.

These are models of real objects, such as bottles, boxes, crates, machine parts and furniture. They are made to look right in a render and behave right in a physics engine. That is not the same as being made to print. Expect to check every model before you slice it.

The license: what you must do

SimReady Central does not use one license for all NVIDIA free 3D assets. Its documentation says each dataset owner chooses a license, including a non-commercial one, and that NVIDIA recommends CC BY 4.0. So the rule is simple: read the license of each asset you use.

Every asset package carries its own license. The package I downloaded has a .metadata/LICENSE.txt file with the full CC BY 4.0 text, and its com.nvidia.simready.packaging.json file lists "license": "CC-BY-4.0". Look for the same files in any asset you use.

From the license text in that package, CC BY 4.0 asks you to do four things when you share the model or an adapted version:

1. Name the creator, and keep any copyright notice the creator supplied.
2. Say that the work is licensed under CC BY 4.0, and link to the license.
3. Link to the original material where that is reasonable.
4. Say that you changed it. A conversion to STL is a change.

A credit line that covers this could read: "Beer bottle model (food_beverage_beerBottle_g01) from NVIDIA SimReady Assets, huggingface.co/datasets/nvidia/simready-assets, licensed CC BY 4.0. Converted from USD to STL by me." This is not legal advice. If you plan to sell prints, read the license yourself.

One more point matters. The same license text says patent and trademark rights are not licensed. The texture of the bottle I tested shows a real beer label. The STL has no textures, so the geometry carries no brand, but the artwork is a good reminder: a CC license does not give you the right to use someone's brand.

What is inside one asset

I looked at the file list of one asset, food_beverage_beerBottle_g01, through the Hugging Face API before I downloaded anything. It is a folder with about 48 files. These are the ones that matter:

The lesson is that the 20 KB main file is not the model. If you download only that file, you get an empty scene. NVIDIA's documentation says the same: keep the referenced materials and textures with the asset.

Download an NVIDIA free 3D asset

You can browse the SimReady Assets dataset on Hugging Face. Each asset is its own folder. I downloaded 20 files, 2.3 MB in total, and skipped the preview thumbnails and the source_assets folder. Any file can be fetched with a plain URL in this form:

https://huggingface.co/datasets/nvidia/simready-assets/resolve/main/FOLDER/PATH_TO_FILE

# example, with curl (keep the same folder layout on your disk)
curl -L -o simready_usd/payloads/geometries.usd \
  https://huggingface.co/datasets/nvidia/simready-assets/resolve/main/food_beverage_beerBottle_g01/simready_usd/payloads/geometries.usd

Repeat this for every file in the table above that you need, and keep the folder structure the same as on Hugging Face. The main USD file finds the others by relative path.

Convert USD to STL with Python

This is the method I tested to convert USD to STL. It uses usd-core, the free Python package of Pixar's OpenUSD, and trimesh. No NVIDIA software is needed. I ran it with Python 3.13, usd-core 26.11 and trimesh 5.2.1.

pip install usd-core trimesh numpy networkx

networkx is only needed for the "separate bodies" check on the last line. I removed it and re-ran the script, and the STL was written before that line failed. Save the code below as usd_to_stl.py. It is my own code, written for this guide.

# usd_to_stl.py: turn a USD asset into one STL in millimeters, sitting on the print bed
# Usage: python usd_to_stl.py asset.usd output.stl
import sys
import numpy as np
import trimesh
from pxr import Usd, UsdGeom

src, out_stl = sys.argv[1], sys.argv[2]
stage = Usd.Stage.Open(src)
meters_per_unit = UsdGeom.GetStageMetersPerUnit(stage)
up_axis = UsdGeom.GetStageUpAxis(stage)
print("up axis:", up_axis, "| metersPerUnit:", meters_per_unit)

xforms = UsdGeom.XformCache(Usd.TimeCode.Default())
parts = []
# TraverseInstanceProxies matters: SimReady geometry sits inside instanced prims,
# and a plain stage.Traverse() never visits it.
for prim in Usd.PrimRange.Stage(stage, Usd.TraverseInstanceProxies()):
    if not prim.IsA(UsdGeom.Mesh):
        continue
    img = UsdGeom.Imageable(prim)
    if img.ComputeVisibility() == "invisible" or img.ComputePurpose() in ("guide", "proxy"):
        print("skipping", prim.GetPath())
        continue
    mesh = UsdGeom.Mesh(prim)
    points = np.array(mesh.GetPointsAttr().Get(), dtype=np.float64)
    counts = mesh.GetFaceVertexCountsAttr().Get()
    indices = mesh.GetFaceVertexIndicesAttr().Get()

    triangles, offset = [], 0              # split every polygon into triangles
    for count in counts:
        for k in range(1, count - 1):
            triangles.append((indices[offset], indices[offset + k], indices[offset + k + 1]))
        offset += count
    triangles = np.array(triangles)

    matrix = np.array(xforms.GetLocalToWorldTransform(prim))   # 4x4, USD uses row vectors
    world = np.hstack([points, np.ones((len(points), 1))]) @ matrix
    if np.linalg.det(matrix[:3, :3]) < 0:  # a mirrored transform flips the face direction
        triangles = triangles[:, ::-1]
    part = trimesh.Trimesh(world[:, :3], triangles, process=False)
    print(f"part {prim.GetName()}: {len(part.faces)} triangles, watertight={part.is_watertight}")
    parts.append(part)

model = trimesh.util.concatenate(parts)
model.apply_scale(meters_per_unit * 1000.0)        # stage units to meters to millimeters
if up_axis == "Y":                                 # slicers are Z-up
    model.apply_transform(trimesh.transformations.rotation_matrix(np.pi / 2, [1, 0, 0]))
model.apply_translation([0, 0, -model.bounds[0][2]])   # lowest point on the bed
model.export(out_stl)

size = model.bounds[1] - model.bounds[0]
print("size in mm (X, Y, Z):", np.round(size, 2), "| triangles:", len(model.faces))
check = trimesh.load(out_stl)
print("watertight:", check.is_watertight, "| separate bodies:", len(check.split(only_watertight=False)))

Run it with the main USD file of the asset and a name for the STL:

python usd_to_stl.py simready_usd/sm_food_beverage_beerBottle_g01_01.usd beerbottle.stl

This is what it printed on my PC, and it wrote an STL of about 1.1 MB:

up axis: Z | metersPerUnit: 1.0
part sm_food_beverage_beerBottle_g01_cap_mesh_00: 11024 triangles, watertight=True
part sm_food_beverage_beerBottle_g01_body_mesh_00: 11746 triangles, watertight=True
size in mm (X, Y, Z): [ 50.39  49.93 229.3 ] | triangles: 22770
watertight: True | separate bodies: 5

Three traps the script avoids

The first one really bit me: my first attempt found no geometry at all. The other two are standard USD details that I handled from the start, so I only know them from the file and the documentation.

1. Instanced meshes are invisible to a plain traversal. My first check used stage.Traverse() and found 0 meshes. With TraverseInstanceProxies() it found 2, a cap and a body. SimReady assets use instancing, and the default walk skips instanced content.
2. Units. A USD stage stores a metersPerUnit value. This asset uses 1.0, so the numbers are meters. Without the factor of 1,000 you would get a model 0.2 mm tall. USD's documentation describes this value in its linear units reference. Other assets may use another value, so always read it.
3. Up axis. This asset is Z-up, like slicers. A Y-up file would lie on its back, so the script rotates it. I tested only the Z-up case, so check a Y-up file in your slicer.

The Blender route, from the manual (not tested by me)

You can also convert USD to STL in Blender, by importing the USD file and exporting STL. I did not test this, so treat these notes as pointers from Blender's USD manual, not as a recipe I proved.

• The importer has an option called Apply Unit Conversion Scale, which scales objects by the stage's metersPerUnit. It works together with a separate Scale option.
• For Y-up files, the manual says Blender rotates the root objects so they match its Z-up orientation.
• The manual lists limits. Among them, layers and references are not handled, and the conversion of USD Preview materials is lossy.

Because of that "references" note, I would test one asset first and compare the size with the numbers in the file. If the model comes in empty or the wrong size, use the Python route above.

Check the model before you slice it

My test showed why a converted model needs checking. The bottle converted without any error, but it is a poor candidate for printing as it stands. Here is what I measured on the STL:

• It is a hollow shell. I sliced the mesh at four heights. The glass wall was between 1.26 and 1.27 mm thick each time. A real bottle has thin walls, and this model copies that.
• Scaling down breaks it. At half size the wall would be about 0.64 mm. That is less than two lines of a 0.4 mm nozzle (0.8 mm), so it would not print as a solid wall. Keep the 1:1 size or larger.
• It is tall. At 229.3 mm (9 inches), it is taller than the build height of many desktop printers. Check your own machine.
• It has five separate bodies. Each one is watertight on its own. Three are thin extra shells close to the glass surface, at heights where the texture has label artwork. Your slicer will treat them as separate objects, so decide whether to keep or delete them.

The STL has no textures or colors. It stores only triangles. If you need color, a format such as 3MF can carry it, and the guide to 3MF vs STL explains the difference. For general settings once the model is clean, see the print settings guide.

If you want a printable object from a flat picture instead of a scene file, the image to STL guide shows another route. Free tools on this site help too. Text to STL makes names and keychains, and 3MF to Web shows a finished model on a web page.

Troubleshooting USD to STL

• Problem: the script finds 0 meshes. Why: the geometry is in instanced prims, or the other USD files are missing. Fix: use TraverseInstanceProxies() as in the script, and check that payloads/geometries.usd sits next to the main file in the same folder layout.
• Problem: the model is 1,000 times too small or too large. Why: the units do not match. Fix: read metersPerUnit and convert to millimeters, as the script does. Compare the printed size with the size you expect.
• Problem: the model lies on its side. Why: the file is Y-up and your slicer is Z-up. Fix: rotate 90 degrees around X, which the script does for Y-up files. I did not test a Y-up file, so confirm the result.
• Problem: the model looks inside out or has dark faces in the slicer. Why: some face directions are flipped, often by a mirrored transform. Fix: the script flips the winding when a transform mirrors the mesh. If a model still looks wrong, try your slicer's repair option.
• Problem: it prints as a thin empty shell. Why: many simulation assets are hollow shells made for rendering. Fix: measure the wall, as shown above. If it is under about 0.8 mm, scale up or choose another model.
• Problem: the slicer says there are multiple objects. Why: the asset has separate parts, such as a cap, a body and label shells. Fix: keep the parts you want, and delete the rest in the slicer.
• Problem: the colors and textures are gone. Why: STL cannot store them. Fix: use a format that can carry color if you need it.

Credits and sources

Everything below was used for this guide on NVIDIA free 3D assets. The asset and its data belong to their creators.

• 3D model tested: food_beverage_beerBottle_g01 from the NVIDIA SimReady Assets dataset, licensed Creative Commons Attribution 4.0. I converted it from USD to STL. I do not host the model or its textures on this site.
• Asset packs and licensing rules: NVIDIA's downloadable asset packs and SimReady Central documentation.
• USD software: usd-core, the Python package of Pixar's OpenUSD, and its linear units reference.
• Mesh software: trimesh by Michael Dawson-Haggerty and contributors.
• Blender notes: the Blender USD manual page.

Not affiliated with NVIDIA, Hugging Face, Pixar or Blender. Names belong to their owners.

Next steps

• Pick a solid object, such as a bolt, a nut or a bracket, and run the script on it. Solid parts are easier to print than hollow shells.
• Open the STL in your slicer and check the size against the numbers the script printed.
• Add the credit line wherever you share the model or a photo of the print.

Frequently asked questions

Where can I download NVIDIA free 3D assets?

From the SimReady Assets dataset on Hugging Face, and from the downloadable asset packs listed in NVIDIA's Omniverse documentation. Each Hugging Face asset is its own folder. Read the license file inside the folder before you use it.

Are NVIDIA's free 3D models free for commercial use?

The asset I checked is licensed CC BY 4.0, which allows commercial use if you give credit. But SimReady Central lets each asset owner pick its own license, including non-commercial ones, so read the LICENSE.txt inside every package. CC BY also does not license trademarks.

Can I 3D print a USD file directly?

No. Slicers expect meshes such as STL or 3MF. A USD file is a scene description that points to other files, so you convert it first.

Why does my Python script find no meshes in a USD file?

The geometry is probably inside instanced prims. A plain stage.Traverse() skips them. Walk the stage with Usd.PrimRange.Stage(stage, Usd.TraverseInstanceProxies()) instead.

Does an STL keep the textures and colors of the USD model?

No. STL stores only triangle geometry. The textures stay behind in the USD files. If you need color, look at a format that can carry it, such as 3MF.

Do I need NVIDIA Omniverse or Isaac Sim to convert these assets?

No. The test on this page used only the free usd-core Python package from Pixar's OpenUSD, plus trimesh, with no NVIDIA software installed.

Related guides

• 3MF file vs STL: open, convert and share 3MF files
• Image to STL: turn a drawing or logo into a 3D print
• Lithophane print settings for Bambu, Prusa and Ender
• 3D printed name keychain: sizes, two colors, print settings

Free tools: Lithophane Maker for flat, curved, heart, round and cylinder lamp lithophanes, the Shadow Box Lamp Generator for wall shadow lamps, Text to STL for names and keychains, and 3MF to Web to show your prints on a website. See all tools.