# Utonia: one Point Transformer V3 encoder for point clouds across domains

> Pointcept's Utonia ships cross-domain pre-trained Point Transformer V3 weights with inference and visualization code. It is a frozen encoder to try before you train your own, and the split between this repo and the Pointcept codebase is where most of the friction lives.

**Pointcept/Utonia** — [ICML'26] Official repository of Utonia: Toward One Encoder for All Point Clouds

- Repository: https://github.com/Pointcept/Utonia
- Website: https://pointcept.github.io/Utonia/
- Stars: 767 · Forks: 55
- Language: Python
- License: Apache-2.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/pointcept-utonia

## A single PTv3 encoder aimed at indoor, outdoor, object and video point clouds

Utonia is the official repository for the paper "Utonia: Toward One Encoder for All Point Clouds", published under arXiv identifier 2603.03283 and built by Pointcept. The stated goal is narrow and concrete: provide a cross-domain pre-trained Point Transformer V3 that can be dropped into downstream 3D point cloud tasks, so that a model does not have to be re-trained per dataset domain. The code is described as modified from Sonata and Concerto, which means the encoder lineage and the demo structure are inherited rather than invented here.

The audience is engineers and researchers who already have point clouds and want features or segmentation quickly. The repository supplies three things and stops there: pre-trained models, inference code, and a visualization demo. The models themselves live on Hugging Face under the Pointcept organisation, and the project homepage sits at pointcept.github.io/Utonia.

Sizes matter here because the repository now ships more than one checkpoint. An October 2026 update uploaded Utonia Tiny and Utonia Small alongside the full model, which means an evaluation can start with the smaller encoders and move up. A February 2026 update added the inference and visualization demo path, and the README points first-time users at that entry point.

## This repo hands over weights, not a training recipe

The most important structural fact about Utonia is what it excludes. The repository is described as being used mainly for providing pre-trained models, inference code and a visualization demo. Anyone who wants to reproduce the pre-training process itself is directed to the separate Pointcept codebase repository. That means the learning rate schedule, the dataset mixture, the pretraining sample strategy and the augmentation stack are not recoverable from this repository alone.

The top-level layout confirms the narrow scope. The entries are .gitignore, LICENSE, README.md, a demo directory, environment.yml, setup.py and a utonia package directory. There is no training script, no config directory and no checkpoints directory. The demo directory holds numbered scripts from 0_pca_indoor.py through 8_pca_video.py plus a visual_util.py helper.

The packaging is thin. setup.py declares name="utonia", version="1.0", py_modules=["utonia"] and uses find_packages with demo packages excluded. The license header inside setup.py carries a Meta Platforms copyright notice alongside the Apache 2.0 text, while the repository license itself is Apache-2.0. There are no GitHub releases, so version history for the weights has to be read off Hugging Face rather than off a release feed.

## Standalone conda mode for a first inference run

The README describes two installation paths, and it recommends the standalone one for quick inference and visualization because the environment file handles CUDA and PyTorch together. The environment it builds is named utonia, and the comments in that block state cuda: 12.4 and pytorch: 2.5.0. If a local CUDA install is present, the README suggests unsetting CUDA_PATH first so the environment does not pick up conflicting paths.

Run these two commands in a shell that has conda available:

```bash
conda env create -f environment.yml --verbose
conda activate utonia
```

After the environment is active, the demo scripts expect the repository root to be importable, and the README sets that up with PYTHONPATH. A PCA visualization run looks like this:

```bash
export PYTHONPATH=./
python demo/0_pca_indoor.py
```

The --verbose flag on env create is what makes a slow CUDA wheel download debuggable instead of mysterious. One thing the environment file assumes rather than checks: FlashAttention is installed by default, and the README states this in bold as a requirement, so a machine without a working FlashAttention build is the most likely first failure.

## Package mode when the encoder has to live inside your own code

If the goal is to inject Utonia into an existing codebase rather than to run the demo, the README points to package mode and setup.py. The dependency list has to be assembled by hand, and the version placeholders are resolved from the local machine: CUDA_VERSION from nvcc --version and TORCH_VERSION from a torch version print. The install sequence is:

```bash
pip install spconv-cu${CUDA_VERSION}
pip install torch-scatter -f https://data.pyg.org/whl/torch-{TORCH_VERSION}+cu${CUDA_VERSION}.html
pip install git+https://github.com/Dao-AILab/flash-attention.git
python setup.py install
```

The demo code pulls in a separate, heavier set of packages, and the install line carries a version pin worth noting:

```bash
pip install open3d fast_pytorch_kmeans psutil addict scipy camtools natsort opencv-python trimesh gradio numpy==1.26.4  # currently, open3d does not support numpy 2.x
```

That pin is the kind of detail that decides whether an afternoon of setup ends well. The comment states that open3d does not support numpy 2.x, so numpy is held at 1.26.4 in an environment that may otherwise want the newer release. Two Docker images are also referenced, utonia-cuda128 and utonia-cuda128-flashattn, contributed by a community member and discussed in issue 28. Note that setup.py has no console entry points, so utonia is imported as a library rather than driven by a utonia command.

## The demo scripts, and the one that will not accept a smaller encoder

The demo folder is where the value of this repository is most visible. It reproduces the visualization demos of Sonata and Concerto: a segmentation result, a similarity heatmap, and PCA projections. The numbered scripts cover indoor scenes, a similarity view, semantic segmentation, batched forward passes, and PCA views for indoor, object, manipulation and outdoor content.

Every PCA, similarity, batch and video demo accepts a --model flag, and the default remains utonia. Switching encoder size is a flag, not a code change:

```bash
python demo/0_pca_indoor.py --model utonia_small
python demo/3_batch_forward.py --model utonia_tiny
```

There is one asymmetry that is easy to trip over. demo/2_sem_seg.py uses the ScanNet linear probing head trained for the full utonia model, and it does not support the small or tiny encoders. A semantic segmentation run with --model utonia_small will not work, even though the flag exists elsewhere in the demo folder.

Two flags control the input conditioning for the visualization without color and normal, and they can be combined:

```bash
python demo/0_pca_indoor.py --wo_color --wo_normal
```

Whether these encoders degrade gracefully without appearance features, or simply produce worse features, is not something the documentation answers, so treat the color-free path as something to verify on your own data.

## Feeding your own point clouds, and the transform pipeline that is only half shown

Inference on custom data is described with a dictionary convention. A single point cloud carries coord, color and normal arrays of shape (N, 3), with an optional segment array of shape (N,). A batched form adds a batch array of shape (N,), and the README points at the Pointcept documentation for the offset convention used to describe batched point clouds. A sample is loaded with:

```python
point = utonia.data.load("sample1")
```

The full dictionary shape looks like this:

```python
point = {
  "coord": numpy.array,  # (N, 3)
  "color": numpy.array,  # (N, 3)
  "normal": numpy.array,  # (N, 3)
  "segment": numpy.array,  # (N,) optional
}
```

The transform pipeline is where this documentation thins out. The README states that the pipeline differs from the earlier Sonata and Concerto pipelines, and the code sample it gives for constructing that pipeline is cut off mid-comment on the choice of scale. The consequence is practical: the scale rule that the earlier pipelines made explicit is not written down here, so it has to be recovered from the Pointcept codebase or determined by trial. A user treating that comment fragment as complete guidance is working from an incomplete specification.

The video demo is the one with an extra dependency. It needs VGGT to lift video into a point cloud, cloned and pip installed separately, and it exposes flags for the reconstruction itself, including conf_thres 0, a prediction mode named "Depthmap and Camera Branch", TSDF fusion, and PCA brightness controls.

## What the project does not promise, and what it costs to follow

Three limits are worth stating plainly. First, this is a release of artifacts rather than a supported product: there are no GitHub releases, the demo directory carries version 1.0 in setup.py with no release notes attached, and the documentation does not describe rollback for a downloaded checkpoint. Second, the pre-training process itself lives elsewhere, so anyone wanting to change the pre-training mixture cannot do it from this repository. Third, the dependency surface is wide, spanning spconv, torch-scatter, FlashAttention built from source, open3d and gradio, and the numpy pin means a fresh environment will not match a modern numpy setup by default.

On licence terms, the repository is Apache-2.0, which is the permissive choice most teams expect for commercial use of model weights and inference code. The setup.py header also carries a Meta Platforms copyright notice, reflecting the Sonata and Concerto code it derives from. This is a note about the licence text as written, not legal advice on how the weights may be used.

For maintenance facts, the repository is not archived and the last push was on 2026-10-16, five days before this writing, following the October 2026 upload of the Tiny and Small weights. Activity is therefore recent rather than historical, but it is activity on a demo and inference repository, not on a training pipeline.

## Conclusion

Utonia fits teams that want a frozen, general-purpose point cloud encoder for feature extraction or a quick baseline without training from scratch. It does not fit anyone who needs a documented fine-tuning loop, a released checkpoint history, or a pre-training recipe contained in one place, since the weights arrive without GitHub releases and pre-training reproduction is delegated to the separate Pointcept codebase. Before committing, verify that your data carries the coordinate, color and normal fields the demo dictionary expects, check that FlashAttention builds against your CUDA and torch versions, and confirm that the encoder size you pick is one the script you intend to run actually accepts.

## FAQ

### How do I install Utonia and run its visualization demo?

Create the bundled conda environment with `conda env create -f environment.yml --verbose` and activate it with `conda activate utonia`, which the README describes as providing cuda 12.4 and pytorch 2.5.0. Then export PYTHONPATH as ./ and run one of the numbered scripts in the demo folder, for example demo/0_pca_indoor.py. FlashAttention is installed by default in this environment.

### Which Utonia model size should I use, the default, Small or Tiny?

The PCA, similarity, batch and video demos accept a --model flag whose default remains utonia, and the October 2026 update added Utonia Tiny and Utonia Small alongside it. One exception: demo/2_sem_seg.py uses the ScanNet linear probing head trained for the full model and does not support the small or tiny encoders.

### Can I reproduce the Utonia pre-training process from this repository?

No. The repository is for pre-trained models, inference code and the visualization demo, and the README directs anyone who wants to reproduce the pre-training process to the Pointcept codebase. It also has no GitHub releases, so checkpoint history is not tracked through release notes here.

### What licence applies to the Utonia code and weights?

The repository license is Apache-2.0. The setup.py file additionally carries a Meta Platforms copyright notice with the Apache 2.0 header text, reflecting the Sonata and Concerto code it is derived from.

## Sources

- [Issues](https://github.com/Pointcept/Utonia/issues)
- [License: Apache-2.0](https://github.com/Pointcept/Utonia/blob/main/LICENSE)
- [Pointcept/Utonia on GitHub](https://github.com/Pointcept/Utonia)
- [Project website](https://pointcept.github.io/Utonia/)
- [README](https://github.com/Pointcept/Utonia/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/pointcept-utonia