ShapeNet

ShapeNet is a repository of 3D CAD models of everyday objects, collected from online model repositories and organized under the noun synsets of WordNet, the same hierarchy as ImageNet. It was built by researchers at Stanford University, Princeton University and the Toyota Technological Institute at Chicago and described in a technical report by Angel X. Chang and colleagues in December 2015 (Chang et al., 2015); the first ShapeNetCore release is dated May 2015. Its subset ShapeNetCore, 55 categories with about 51,300 models, and the part labels that Yi et al. (2016) added to 16 of its categories became the default data for learning on 3D shapes: classification, part segmentation, single-view 3D reconstruction and shape generation all have standard benchmarks built from it.

Purpose

Chang et al. (2015) cite the Penn Treebank, WordNet and ImageNet as the dataset efforts they wanted to match for 3D models. Existing shape collections were small and lightly annotated: the Princeton Shape Benchmark, which they call probably the most well-known and frequently used, had about 1,800 models in 90 categories with category labels only, and the “large” SHREC 2014 dataset about 9,000 models in 171 categories. Online repositories such as the Trimble 3D Warehouse held millions of models but were unorganized or grouped only into broad categories. The report states four goals: collect and centralize 3D model datasets, support data-driven methods, enable evaluation of algorithms for segmentation, alignment and correspondence, and serve as a knowledge base of real-world objects and their semantics. It cites the Protein Data Bank as a model for a shared repository with linked annotations.

Dataset Size

ShapeNet as a whole. The models came from the Trimble 3D Warehouse (2.4 million user-designed models and scenes) and Yobi3D (350,000 models gathered from other repositories). The report gives two sets of counts: its abstract and §5 say roughly 3,000,000 models indexed, of which 220,000 are classified into 3,135 WordNet synsets, while §3 says about 3 million collected and 300 thousand categorized. Only the subsets below were released.

ShapeNetCore contains single, clean models with manually verified category and alignment annotations: 55 categories with “about 51,300 unique 3D models” (Chang et al., 2015, §5.1; the same figure appears on the archived 2017 about page and, for v2, on the Hugging Face dataset card, as of October 2026). The report’s per-synset table (Table 2) prints a total of 57,386, although its 55 rows sum to 55,722 (our arithmetic); since a model’s metadata lists every synset it belongs to (v1 README), the excess over 51,300 is presumably models counted under more than one synset, though no source states this, and no source explains the printed total. All 12 categories of PASCAL 3D+ are covered.

ShapeNetSem is a smaller, more densely annotated subset of 12,000 models in a broader set of 270 categories, with real-world dimensions, category-level material composition, and estimated volume and weight.

Versions and formats. The ShapeNetCore v1 README (July 2015) lists a v0 release in May 2015 and v1 in July 2015, which fixed missing material files in the car synset and geometry errors from incomplete or incorrect triangulation. v1 ships one archive per synset, named by its eight-digit WordNet 3.0 offset (02828884 for bench), with OBJ meshes, MTL materials and textures, and a CSV of metadata per synset: the WordNet synsets and lemmas, the up and front vectors in the original model coordinates, and the uncurated name and tags from the source repository. The OBJ files are pre-aligned with up along +Y and front along +X, normalized to fit a unit cube centered at the origin, and for most categories the X–Y plane is the bilateral symmetry plane. As of October 2026 the Hugging Face organization distributes ShapeNetCore v1 and v2 archives, a ShapeNetCore v2 repository, repositories named shapenetcore-gltf and shapenetcore-glb, and the ShapeNetSem v0 archive. The v1 and v2 README links there now redirect to the organization page; the v1 README survives in archived copies, but we found no public description of the changes from v1 to v2 (the v2 dataset card points to a DATA.md that only approved users can read). The ShapeNetSem v0 README (June 2015) lists OBJ and COLLADA meshes, surface and solid binvox voxelizations, and screenshots from 12 viewpoints, with a metadata file of units, aligned dimensions, volumes, support-surface area, weight and static friction force.

Classes

Every model is assigned to one or more WordNet noun synsets, and the synset offsets match ImageNet’s identifiers, so a ShapeNetCore category links directly to an ImageNet class (Table 2; v1 README). The 55 ShapeNetCore categories are very unequal in size: table (8,443 models), car (7,497), chair (6,778), airplane (4,045) and sofa (3,173) are the largest, while keyboard (65), bicycle (59) and cap (56) are the smallest (Table 2).

ShapeNetSem uses its own manual categories, each linked to a WordNet synset; its largest are Chair (696), Lamp (663) and ChestOfDrawers (511) (Table 3). The report notes that ShapeNet is strongly biased towards rigid man-made artifacts, unlike image datasets, and attributes this to the source repositories: natural objects are harder to model in CAD software, and consumers of 3D models are more interested in man-made objects.

Annotation Types

Chang et al. (2015) combine algorithmic predictions with human verification and plan to record the source and a confidence for every annotation.

• Category. Models were retrieved from the repositories by text query, sorted by the repository’s popularity score, and shown to people for verification; verification stopped once fewer than 2% of the models were correct. Models were then sorted into single objects, scenes (detected by counting connected components in a voxelization), billboards (textured planes, detected when one plane fits all vertices) and objects on a large ground plane; only single objects went into ShapeNetCore (§4.1).
• Rigid alignment. A person picks the upright direction from six candidates, the principal axes of a point sample and their reverses. Shapes are then aligned jointly within each leaf synset by MAP inference in a Markov random field over discretized rotations, after splitting synsets with more than 100 shapes into clusters, and the alignment is propagated up the taxonomy using one representative shape per synset, with human checks at every level (§4.2, Appendix A.1).
• Symmetry. A bilateral symmetry plane is detected for every ShapeNetCore model by Hough voting over pairs of vertices, and the winning plane is verified to give every vertex a symmetric counterpart (§4.4).
• Physical properties. Absolute size is estimated with an earlier size-estimation method and verified by hand; volume comes from a filled-in voxelization, or a surface voxelization for container-like categories such as bottles; weight follows from category-level material priors and a table of densities (§4.5). These annotations are released with ShapeNetSem.
• Parts and keypoints. The 2015 report describes these as planned, with propagation of curated annotations by active learning (§4.3).

Part labels. Yi et al. (2016) built that annotation framework. Given a category and a label of interest (“back” for chairs), their system cycles between people annotating regions, a conditional random field that propagates the labels to other shapes, and crowd workers who verify the propagated labels, choosing which shapes to annotate and verify to minimize the human time. Labels are per point on 3,000 points sampled uniformly from each shape and projected to the mesh faces afterwards. Annotating 16 ShapeNetCore categories with 31,963 models and 1 to 5 labels each (42 labels in total), they obtained 93,625 verified annotations, 9,564 of them confirmations that a part does not exist on the object, in an estimated 110 hours of work against an estimated 780 hours for annotating one by one (Table 1). The labels need not partition the surface: they mark salient regions and may overlap. An expert re-check found a false-positive rate below 4% for crowd verifications, and 2–7% of the shapes per category had ambiguous geometry that no annotation passed.

Splits

ShapeNet itself defines a training, validation and test split of ShapeNetCore, the “official splits” that Yi et al. (2017) follow. The benchmarks built on it each carry their own subset and split:

Benchmark	Data	Split
Part segmentation (ShapeNetPart), Qi et al. (2017)	16,881 shapes, 16 categories, 50 parts	test list in the PointNet repository (2,874 shapes)
Part segmentation, ShapeNet challenge (Yi et al., 2017)	16,880 models, 16 categories, 2–6 parts each, 50 in total	12,136 / 1,870 / 2,874; deduplicated test set of 1,381
Single-view reconstruction, 3D-R2N2 (Choy et al., 2016)	13 categories, “50,000 models”	4/5 training, 1/5 test (8,725 test models)
Single-view reconstruction, ShapeNet challenge	48,600 pre-aligned ShapeNetCore models	33,673 / 4,917 / 10,010; deduplicated test set of 6,785
Single-view reconstruction, Tatarchenko et al. (2019)	all 55 categories	70% / 10% / 20% per category, random
Point-cloud generation, Achlioptas et al. (2018)	one category at a time	85% / 5% / 10%

Part segmentation. The project page of Yi et al. offers the full pre-release of the part annotations and a re-organized benchmark version that contains only expert-verified segmentations together with “the official training/test split from ShapeNet”. The name ShapeNetPart is used for both. Qi et al. (2017) describe their data as 16,881 shapes from 16 categories annotated with 50 parts, most categories with two to five; the ShapeNet challenge paper gives 16,880 models with 2 to 6 parts per category. The challenge’s deduplicated test set removes test models with nearly the same geometry as a training or validation model and approximate duplicates within the test set. The two official code bases start from different copies. PointNet’s download_data.sh fetches the pre-release (1.08 GB according to the README), which it calls the original ShapeNetPart dataset, together with HDF5 files prepared by the authors, and test.py reads its test shapes from testing_ply_file_list.txt in the PointNet repository: 2,874 shapes, each pointing to an expert-verified label file of the pre-release. PointNet++ uses a preprocessed copy with point normals (shapenetcore_partanno_segmentation_benchmark_v0_normal, 674 MB, linked from its README) and reads train_test_split/shuffled_test_file_list.json from it, under a comment that calls it the official split.

Reconstruction. Choy et al. (2016) rendered the training models from random viewpoints over random crops of PASCAL VOC images, used 127 × 127 input images and 32³ voxel grids, and for testing rendered five random views of each test model on a uniform background. Mescheder et al. (2019) reused “the same voxelization, image renderings and train/test split” and carved a validation set out of the training models, which made this subset, often called the 3D-R2N2 or Choy et al. split, the usual one for single-view reconstruction. Tatarchenko et al. (2019) argued that restricting evaluation to 13 of 55 classes has no justification, since they found no correlation between a class’s number of training samples and its mean IoU.

Generation. Achlioptas et al. (2018) trained one model per category on 2,048 points sampled uniformly from each mesh, with shapes axis-aligned and centered in the unit sphere. PointFlow (Yang et al., 2019) kept 2,048 points per shape and evaluated on airplane, chair and car, normalizing all points of a category to zero mean per axis and unit variance overall.

Tasks

• Shape classification and retrieval. Category labels make ShapeNetCore a classification and retrieval dataset, although point cloud and volumetric classifiers are more often compared on ModelNet40 (Related Datasets).
• Part segmentation: label each point of a shape with a part of its known category, a 3D counterpart of semantic segmentation.
• Single- and multi-view reconstruction: predict a voxel grid, mesh, point set or implicit function from rendered images.
• Shape generation and representation learning: learn a distribution over shapes of a category, as point clouds or neural implicit representations.
• Shape completion, correspondence and synthetic rendering: the consistent alignment and per-category organization make the models a source of training data for many other tasks.

Evaluation

Part segmentation

Qi et al. (2017) define the metric in text: for each shape, compute the IoU between ground truth and prediction for each part type of its category, counting a part as IoU 1 when the union is empty; average over the category’s parts to get the shape’s mIoU; and average the shapes of a category to get the category’s mIoU. The official code of PointNet (part_seg/test.py, commit 2618f72) and PointNet++ (part_seg/evaluate.py, commit 4292663), read line by line, compute it as follows:

• The category is given. PointNet feeds the ground-truth category to the network as a one-hot vector, and both scripts restrict the prediction to that category’s parts before the arg max: PointNet sets the scores of all other categories’ parts below the minimum, PointNet++ takes the arg max over the category’s part columns only. A point can never be labelled with a part of another category.
• Per-part IoU is counted over points: intersection and union of the predicted and true point sets of each part (intersection over union). A part absent from both ground truth and prediction scores 1; a part absent from the ground truth but predicted on even one point scores 0.
• Shape mIoU is the unweighted mean over the category’s parts, whatever their sizes.
• Two averages over shapes. PointNet’s script prints “IoU”, the mean of shape mIoUs over all test shapes (instance mIoU), and the per-category means. PointNet++ prints both “eval mean mIoU”, the mean of the 16 category means (class mIoU), and “eval mean mIoU (all shapes)”, the instance mIoU.
• Which points are scored. PointNet scores every original annotated point: the cloud is padded to 3,000 points by repetition for the network, and only the first ori_point_num predictions are kept. PointNet++ scores 2,048 points (the default) drawn from each shape with replacement by np.random.choice, without a seed, so a point can count more than once and the score varies slightly from run to run; it also sums the outputs of 12 forward passes on the same batch.

The ShapeNet challenge (Yi et al., 2017) words it differently: a category’s IoU averages the per-part IoUs over all parts of all its shapes, and the overall score is the average of category IoUs weighted by the number of shapes in each category. Because every shape of a category has the same number of parts, this equals the category mean of shape mIoUs, and the shape-weighted average equals the instance mIoU (our derivation).

The two averages differ because the categories are unbalanced. In PointNet’s Table 2 the column “mean” is 83.7, while the mean of its 16 category values is 80.4; weighting the category values by the number of shapes of each category in PointNet’s test list gives 83.70, so the reported mean is the instance average (our arithmetic; the shape counts printed in Table 2 are for the whole dataset and give 83.6). The challenge’s Table 1 likewise ranks SSCN at 86.00, against 83.32 for the unweighted mean of its category scores (our arithmetic). Papers that report “mIoU” on ShapeNetPart without saying which average is meant cannot be compared directly.

The example below builds three synthetic categories from simple parts, with unequal sizes as in ShapeNetPart: tables (top, legs) are common and easy, lamps (base, pole, shade, and a finial that half of them lack) are rarer and harder, and mugs (body, handle) are rare. A noisy “segmenter” labels each jittered point by the nearest point of the category’s mean shape, so it errs near part boundaries and where a shape departs from the template. The function shape_miou follows the official rule; the script checks the two averages, the absent-part rule, and PointNet++’s resampling.

import numpy as np
from scipy.spatial import cKDTree

def cylinder(rng, n, r, z0, z1, x=0.0, y=0.0):
    t = rng.uniform(0, 2 * np.pi, n)
    return np.c_[x + r * np.cos(t), y + r * np.sin(t), rng.uniform(z0, z1, n)]

def disk(rng, n, r, z):
    rr, t = r * np.sqrt(rng.uniform(0, 1, n)), rng.uniform(0, 2 * np.pi, n)
    return np.c_[rr * np.cos(t), rr * np.sin(t), np.full(n, z)]

def cone(rng, n, r0, r1, z0, z1):
    s = rng.uniform(0, 1, n)
    t = rng.uniform(0, 2 * np.pi, n)
    r = r0 + (r1 - r0) * s
    return np.c_[r * np.cos(t), r * np.sin(t), z0 + (z1 - z0) * s]

# Each category has a fixed list of parts, as in ShapeNetPart; a part may be absent.
def make_shape(cat, rng, mean=False):
    j = (lambda v, s: v) if mean else (lambda v, s: v * rng.uniform(1 - s, 1 + s))
    pts = []
    if cat == "mug":                                   # parts: 0 body, 1 handle
        r, h = j(0.5, 0.15), j(1.0, 0.2)
        pts.append(cylinder(rng, 700, r, 0, h))
        t = rng.uniform(-np.pi / 2, np.pi / 2, 300)    # half-torus handle
        R = j(0.3, 0.2)
        pts.append(np.c_[r + R * np.cos(t), np.zeros(300), h / 2 + R * np.sin(t)])
    elif cat == "table":                               # parts: 0 top, 1 legs
        w, h = j(1.0, 0.2), j(0.8, 0.2)
        top = np.c_[rng.uniform(-w, w, 600), rng.uniform(-w / 2, w / 2, 600), np.full(600, h)]
        legs = np.vstack([cylinder(rng, 100, 0.05, 0, h, sx * 0.9 * w, sy * 0.4 * w)
                          for sx in (-1, 1) for sy in (-1, 1)])
        pts += [top, legs]
    elif cat == "lamp":                                # parts: 0 base, 1 pole, 2 shade, 3 finial
        h = j(1.2, 0.25)
        pts.append(disk(rng, 250, j(0.3, 0.2), 0.0))
        pts.append(cylinder(rng, 150, 0.03, 0, h))
        pts.append(cone(rng, 500, j(0.45, 0.2), j(0.2, 0.2), h, h + j(0.4, 0.2)))
        has_finial = mean or rng.uniform() < 0.5      # the optional part
        pts.append(cylinder(rng, 100, 0.02, h + 0.4, h + 0.55) if has_finial else np.zeros((0, 3)))
    X = np.vstack(pts)
    y = np.concatenate([np.full(len(p), k) for k, p in enumerate(pts)])
    return X, y

N_PARTS = {"mug": 2, "table": 2, "lamp": 4}

def predict(X, cat, rng, sigma=0.06):
    """A noisy 'segmenter': label each point by the nearest point of the category's
    mean-shape template, after jittering it. It errs near part boundaries and on
    shapes that differ from the template."""
    T, ty = make_shape(cat, np.random.default_rng(0), mean=True)
    _, idx = cKDTree(T).query(X + rng.normal(0, sigma, X.shape))
    return ty[idx]

def shape_miou(gt, pred, n_parts, absent="one"):
    """Mean of per-part IoU over the category's parts (PointNet / PointNet++ rule:
    a part absent from both ground truth and prediction scores 1)."""
    ious = []
    for p in range(n_parts):
        inter = np.sum((gt == p) & (pred == p))
        union = np.sum((gt == p) | (pred == p))
        if union == 0:
            if absent == "skip":
                continue
            ious.append(1.0)
        else:
            ious.append(inter / union)
    return np.mean(ious)

def make_test_set(seed, counts={"table": 120, "lamp": 25, "mug": 15}):
    rng = np.random.default_rng(seed)
    data = []
    for cat, n in counts.items():
        for _ in range(n):
            X, y = make_shape(cat, rng)
            data.append((cat, X, y, predict(X, cat, rng)))
    return data

def summarize(data, absent="one"):
    per_shape = {}
    for cat, X, y, p in data:
        per_shape.setdefault(cat, []).append(shape_miou(y, p, N_PARTS[cat], absent))
    cat_miou = {c: np.mean(v) for c, v in per_shape.items()}
    instance = np.mean([s for v in per_shape.values() for s in v])
    return cat_miou, np.mean(list(cat_miou.values())), instance

data = make_test_set(seed=1)
cats, class_m, inst_m = summarize(data)
for c, v in cats.items():
    print(f"{c:6s} shapes={sum(d[0] == c for d in data):3d}  category mIoU={v:.3f}")
print(f"class mIoU (mean of categories) = {class_m:.3f}")
print(f"instance mIoU (mean of shapes)  = {inst_m:.3f}")

_, class_s, inst_s = summarize(data, absent="skip")
lamp_skip = summarize([d for d in data if d[0] == "lamp"], absent="skip")[2]
print(f"absent part skipped instead of scored 1: lamp {lamp_skip:.3f}, "
      f"class {class_s:.3f}, instance {inst_s:.3f}")

# lamps without the optional finial (part 3): any stray finial prediction scores 0
no_fin = [(y, p) for c, X, y, p in data if c == "lamp" and not np.any(y == 3)]
stray = [shape_miou(y, p, 4) for y, p in no_fin if np.any(p == 3)]
clean = [shape_miou(y, p, 4) for y, p in no_fin if not np.any(p == 3)]
print(f"lamps without finial: {len(clean)} with no finial predicted, mean {np.mean(clean):.3f}; "
      f"{len(stray)} with stray finial points ({[int(np.sum(p == 3)) for y, p in no_fin if np.any(p == 3)]}), mean {np.mean(stray):.3f}")

# PointNet++ evaluates on 2,048 points resampled with replacement, unseeded
vals = []
for s in range(5):
    r = np.random.default_rng(100 + s)
    res = []
    for cat, X, y, p in data:
        i = r.choice(len(y), 2048, replace=True)
        res.append((cat, X[i], y[i], p[i]))
    vals.append(summarize(res)[2])
print("instance mIoU on 2,048 resampled points, 5 draws:", np.round(vals, 4))

gaps = []
for seed in range(1, 11):
    _, c, i = summarize(make_test_set(seed))
    gaps.append(i - c)
print(f"instance - class over 10 test sets: min {min(gaps):.3f}, max {max(gaps):.3f}")

table  shapes=120  category mIoU=0.869
lamp   shapes= 25  category mIoU=0.798
mug    shapes= 15  category mIoU=0.829
class mIoU (mean of categories) = 0.832
instance mIoU (mean of shapes)  = 0.854
absent part skipped instead of scored 1: lamp 0.790, class 0.829, instance 0.853
lamps without finial: 5 with no finial predicted, mean 0.892; 8 with stray finial points ([3, 54, 35, 24, 9, 3, 10, 7]), mean 0.697
instance mIoU on 2,048 resampled points, 5 draws: [0.8546 0.8527 0.8531 0.8527 0.855 ]
instance - class over 10 test sets: min 0.013, max 0.035

The easy category is also the largest, so the instance average sits above the class average, by 0.013 to 0.035 over ten generated test sets; the sign depends on whether the large categories are also the easy ones, as in ShapeNetPart, where small categories such as rocket and motorbike also score lowest (Qi et al., 2017, Table 2). The absent-part rule matters less to the averages than to individual shapes. A lamp without a finial scores a free 1 for that part if the segmenter predicts no finial points, and 0 if it predicts any: three stray points cost as much as 54, a quarter of the shape’s mIoU, so the lamps with stray predictions average about 0.2 lower. Scoring on 2,048 resampled points moves the instance mIoU only in the third decimal, which is still enough to change the order of methods that differ by a few tenths of a point. Run on these arrays, the metric lines of PointNet++’s evaluate.py and PointNet’s test.py (read from the files at the pinned commits; the TensorFlow model code cannot run without the data) gave the same class and instance mIoU to 12 decimal places.

Reconstruction

The protocols differ in output representation, ground truth and averaging, and their numbers are not interchangeable.

• 3D-R2N2 (Choy et al., 2016) reports voxel IoU between the predicted 32³ occupancy probabilities thresholded at $t$ and the ground-truth voxelization, with $t = 0.4$ in its multi-view ShapeNet evaluation, together with the cross-entropy loss, as means over the test set and per category.
• Occupancy Networks (Mescheder et al., 2019) evaluate against watertight versions of the meshes: volumetric IoU estimated from 100,000 points sampled in the bounding volume, the Chamfer-$L_1$ distance, and normal consistency, per category and as the mean over categories (their Table 1). The Chamfer Distance article gives these definitions and units. Re-evaluated this way, 3D-R2N2’s mean IoU is 0.493, while the 13 single-view category IoUs that Choy et al. report against 32³ voxels (Fig. 5(c) of arXiv v1, which the text calls Table 5) average 0.560 (our arithmetic).
• The ShapeNet challenge (Yi et al., 2017) asks for 256³ voxels, computes IoU per shape and averages over test shapes, and computes the Chamfer distance on 4,096 points chosen by farthest-point sampling from the centers of occupied voxels.
• Tatarchenko et al. (2019) evaluate on 128³ voxel grids, report class-aggregated mean IoU, and recommend the F-score at distance thresholds of 1% of the side length of the reconstructed volume and below, because at 2% the F-score values fell in the same range as mean IoU, which they had argued is uninformative at those levels.

Generation

Achlioptas et al. (2018) introduced three measures between a generated set of point clouds $A$ and a held-out set $B$. JSD is the Jensen–Shannon divergence between the marginal distributions of points over a 28³ voxel grid, which presumes aligned shapes. Coverage (COV) is the fraction of shapes in $B$ that are the nearest neighbor of some shape in $A$. Minimum matching distance (MMD) matches every shape of $B$ to its nearest shape in $A$ and averages those distances. COV and MMD use the Chamfer distance or the Earth Mover’s Distance between point sets, giving COV-CD, COV-EMD, MMD-CD and MMD-EMD. They observed that Chamfer-based scores barely penalized a generator that piled points where most chairs have mass. Yang et al. (2019) noted that an “average shape” can obtain a perfect JSD and that MMD is insensitive to poor samples, and added 1-NNA, the leave-one-out accuracy of a 1-nearest-neighbor classifier that tells generated from reference shapes, ideally 50%. In their Table 1, point clouds sampled from the training set scored worse than some generators on JSD, MMD or COV, but best on 1-NNA in all three categories.

Classification

Classification is scored by accuracy, overall or averaged over classes. PointNet’s ModelNet40 table, for example, prints both: 89.2% overall and 86.2% average class accuracy (Qi et al., 2017, Table 1).

License

ShapeNet has no open license. As of October 2026 the ShapeNet organization page states that ShapeNet data is distributed through Hugging Face, where each dataset repository is gated: a request asks for the full name, the advisor or principal investigator, the affiliation, the purpose and the country, with a box to agree to non-commercial use only, and access is approved manually. The ShapeNet Terms of Use (checked October 2026) grant permission to use “the ShapeNet database” at Princeton University and Stanford University in exchange for these conditions:

• use only for non-commercial research and educational purposes;
• no warranties from the universities, including of non-infringement;
• the researcher accepts full responsibility and indemnifies the universities against claims, including claims arising from copies of copyrighted 3D models made from the database;
• access may be shared with research associates and colleagues only if they first agree to the same terms;
• the universities may terminate access at any time;
• a researcher employed by a commercial entity binds the employer too;
• New Jersey law applies.

The dataset cards repeat that the data may be redistributed only to research associates and colleagues bound by the terms. The same terms appeared on shapenet.org before the move (archived 2020).

The 3D models themselves belong to their creators. The FAQ on the archived 2017 about page answers the question whether ShapeNet owns the model data with “No, the original creators of the 3D models own the copyright”; the terms cover access to the database, not those copyrights. The project page of Yi et al. (2016), from which the part annotations and the ShapeNetPart benchmark are linked, states no license for the annotations, so their terms are unclear; as of October 2026 its download host did not respond to our requests. The PointNet and PointNet++ code is released under the MIT license.

Limitations and Bias

• Man-made objects. The report itself notes the strong bias towards rigid man-made artifacts inherited from the CAD repositories; animals, plants and people are rare.
• Unbalanced categories. Five categories hold over half of the models in ShapeNetCore’s per-synset counts, and in ShapeNetPart, tables and chairs hold more than half of the shapes while caps and earphones have under 100 each (Qi et al., 2017, Table 2). Averages over shapes are dominated by the large categories (Evaluation).
• Synthetic geometry and appearance. Models are designed, not scanned: no sensor noise, no clutter, and renderings on plain or random backgrounds. Volumetric IoU needs closed surfaces: Mescheder et al. first made the meshes watertight with code by Stutz et al. and evaluated against those.
• Near-duplicates. Yi et al. (2017) found many nearly identical models in ShapeNetCore. On their deduplicated part segmentation test set every method except DeepPool, which scored about 43 on both, lost 3.1 to 8.1 points of mean IoU (Tables 1 and 2), a form of benchmark overfitting to near-copies of the training data.
• Recognition instead of reconstruction. On ShapeNet, Tatarchenko et al. (2019) found that a retrieval baseline outperformed the single-view reconstruction networks they tested in mean and median IoU and was best in 30 of 55 classes, which suggests that the networks largely recognized the category (3D reconstruction). The consistent canonical alignment makes this easier in an object-centered frame; they also evaluated a viewer-centered setup.
• Label quality. Part labels have a crowd-verification false-positive rate below 4%, and 2–7% of shapes per category had geometry that annotators could not resolve (Yi et al., 2016).
• Uncurated metadata. Names and tags come unedited from the source repositories (v1 README).

Common Uses

ShapeNet supplies the training shapes for most learned 3D object models: point-cloud networks such as PointNet, voxel and octree decoders, mesh deformation networks, and the occupancy and signed-distance networks of neural implicit representations, which are trained and compared on its categories. Its renderings serve as synthetic training data for single-view reconstruction, and its consistent alignment makes it a test bed for comparing 3D representations such as voxels, point sets and polygon meshes on the same shapes.

Historical Milestones

• 2015, ModelNet. Wu et al. built ModelNet from 3D Warehouse and Yobi3D, the sources ShapeNet later used, and trained 3D ShapeNets, a convolutional deep belief network on voxel grids, reporting 77.32% average category accuracy on a 40-category subset (Table 1).
• 2015, ShapeNet releases. ShapeNetCore v0 (May) and v1 (July), and ShapeNetSem v0 (June); the technical report followed in December (Chang et al., 2015).
• 2016, part annotations. Yi et al. annotated 31,963 models in 16 categories with an estimated 110 hours of human work.
• 2016, 3D-R2N2. Choy et al.’s recurrent network reconstructed 32³ voxels from one or more views; its residual GRU variant reached a voxel IoU of 0.634 with five views on their ShapeNet test set (arXiv v1, Table 1). Their 13-category split became the usual single-view benchmark.
• 2017, PointNet. Qi et al. reported 83.7 mIoU on ShapeNetPart (an instance average; Table 2) and 89.2% overall accuracy on ModelNet40 (Table 1) with a network that consumes raw points.
• 2017, ShapeNet challenge. In the part segmentation track, SSCN, a submanifold sparse convolutional network, scored 86.00 on the original and 82.89 on the deduplicated test set; in single-view reconstruction at 256³, HSP had the best IoU (38.25%) and α-GAN the best Chamfer distance (Yi et al., 2017, Tables 1–3).
• 2018, point-cloud generation. Achlioptas et al. introduced the COV, MMD and JSD measures and latent GANs on ShapeNet point clouds.
• 2019, critiques and new measures. Tatarchenko et al. showed that recognition baselines match single-view reconstruction networks and proposed the F-score at 1%; Mescheder et al. evaluated against watertight meshes; Yang et al. introduced 1-NNA for generation.

Related Datasets

• ModelNet (Wu et al., 2015) is the related classification benchmark: 151,128 CAD models in 660 categories, gathered from 3D Warehouse, Yobi3D and the Princeton Shape Benchmark by querying common object categories of the SUN database, with mis-categorized models removed on Amazon Mechanical Turk. Its 40-category subset ModelNet40, in the split PointNet used, has 12,311 models, 9,843 for training and 2,468 for testing (Qi et al., 2017); a 10-category subset is also used.
• PASCAL 3D+ aligns CAD models to objects in PASCAL VOC images; its 12 categories are all in ShapeNetCore, and Choy et al. fine-tuned 3D-R2N2 on it.
• The Princeton Shape Benchmark and SHREC datasets were the earlier shape retrieval collections ShapeNet set out to replace.
• PartNet is also distributed by the ShapeNet organization on Hugging Face (as of October 2026).

Resources

• ShapeNet on Hugging Face: the official distribution (access by request), with the terms of use and links to the ShapeNetCore and ShapeNetSem archives. The old shapenet.org address redirects there.
• Part annotation project page of Yi et al. (2016), linking the annotations and the segmentation benchmark.
• PointNet and PointNet++ repositories: the part segmentation evaluation scripts described above.
• ShapeNet challenge report (Yi et al., 2017): the segmentation and reconstruction protocols and the deduplicated test sets.