A proposal-free space-curve transformer for fast, open-vocabulary 3D instance segmentation — 0.12–0.30 seconds per scene, no proposals, no GT 3D supervision.
Open-vocabulary 3D instance segmentation is a core capability for robotics and AR/VR, but prior methods trade one bottleneck for another: multi-stage 2D+3D pipelines aggregate foundation-model outputs at hundreds of seconds per scene, while pseudo-labeled end-to-end approaches rely on fragmented masks and external region proposals. We present SpaCeFormer (Space-Curve Transformer), a proposal-free space-curve transformer that runs at 0.12–0.30 seconds per scene across standard benchmarks, 2–3 orders of magnitude faster than multi-stage 2D+3D pipelines.
We pair it with SpaCeFormer-3M, the largest open-vocabulary 3D instance segmentation dataset (3.0M multi-view-consistent captions over 604K instances from 7.4K scenes) built through multi-view mask clustering and multi-view VLM captioning; it reaches 21× higher mask recall than prior single-view pipelines (54.3% vs. 2.5% at IoU>0.5). SpaCeFormer combines spatial window attention with Morton curve serialization for spatially coherent features, and uses a RoPE-enhanced decoder to predict instance masks directly from learned queries without external proposals. On ScanNet200 we achieve 11.1 zero-shot mAP, a 2.8× improvement over the prior best proposal-free method; on ScanNet++ we reach 22.9 mAP, surpassing all prior methods including those using multi-view 2D inputs.
We construct SpaCeFormer-3M, the largest open-vocabulary 3D instance segmentation training corpus. Using training-free multi-view mask clustering and structured VLM prompting, we generate 604K instance masks with 3M diverse captions across 7,361 indoor scenes — without any human annotation.
| Source Dataset | Scenes | Instance Masks | Captions | Avg Masks / Scene |
|---|---|---|---|---|
| ScanNet | 1,201 | 79,320 | 396,600 | 66.0 |
| ScanNet++ | 223 | 27,296 | 136,480 | 122.4 |
| ARKitScenes | 4,497 | 446,409 | 2,232,045 | 99.3 |
| Matterport3D | 1,440 | 51,102 | 255,510 | 35.5 |
| Total | 7,361 | 604,127 | 3,020,635 | 82.1 |
Auto-generated training masks benchmarked against GT instance annotations at IoU > 0.5. Compared to Mosaic3D's SAM2-based 2D-to-3D lifting, SpaCeFormer-3M achieves 21× higher recall (54.3% vs. 2.5%) — multi-view aggregation produces substantially more complete, geometry-consistent instances.
| Source | Masks/Scene | Mean best-IoU | Precision @0.5 | Recall @0.5 | IoU > 0.50 |
|---|---|---|---|---|---|
| Mosaic3D (SAM2 lifting) | 16.1 | 0.247 | 4.8% | 2.5% | 3.8% |
| SpaCeFormer-3M (Ours) | 65.2 | 0.251 | 33.6% | 54.3% | 25.9% |
Each 3D instance mask is paired with 5 diverse captions generated from multiple viewpoints, capturing shape, material, texture, and spatial context.
Explore SpaCeFormer's instance segmentation predictions on real 3D scenes. Click and drag to orbit, scroll to zoom, right-click to pan. Click masks in the legend to toggle.
Most 3D transformers serialize point clouds along Morton (Z-order) curves — space-filling curves that map 3D coordinates to 1D indices while preserving locality on average. The advantage: every attention block sees a fixed number of tokens, so compute is predictable.
For dense prediction tasks like instance segmentation, where you need sharp boundaries, this fragmentation is a real problem. SpaCeFormer interleaves curve attention with spatial window attention — fixed geometric extent (H×W×D voxels) with variable token count — to keep geometrically adjacent points in the same attention group. Shifted partitions across layers (à la Swin) restore connectivity beyond window boundaries.
SpaCeFormer is a hierarchical sparse-voxel U-Net interleaving Space attention (3D windows, fixed metric extent) at shallow high-resolution stages with Curve attention (Morton/Hilbert serialized patches, length 1024) at deeper low-resolution stages. Both flavors share fused QKV + 3D RoPE CUDA kernels on top of sparse convolution shortcuts.
ViT
CvT
Point Transformer
SpaCeFormer · Ours
Groups voxels into 3D windows of fixed metric extent (window_size),
guaranteeing spatial proximity with variable per-window populations. Achieves
~28.6% smaller mean pairwise distance between attending voxels than
curve-based grouping — deployed at shallow, high-resolution levels where local geometry
dominates.
Serializes voxels along space-filling curves and partitions into fixed-length patches
(patch_size=1024). Fixed compute per patch enables efficient long-range mixing;
deployed at deeper, low-resolution stages where receptive field matters more than locality.
Reduces complexity from O(N²) to O(N·L).
VoxelRotaryPositionalEmbeddings extends RoPE to 3D with block-diagonal
rotations parameterized by relative displacements (Δx, Δy, Δz), fused into the QKV CUDA
kernel. Window-aware base (~4·L) auto-selected via suggest_voxel_rope_base.
+1.1 mAP (7.60 vs 6.46) over the best alternative PE.
Learned query embeddings (Q=200) iteratively refined through cross-attention with point features and self-attention between queries. Directly predicts instance masks, CLIP features, and foreground scores — no proposal generation, no class-agnostic pre-filtering.
604K instance masks from 7,361 scenes with 3M multi-view captions. Training-free multi-view mask clustering from 2D foundation models, plus structured VLM prompting for diverse, view-consistent descriptions of shape, texture, material, and spatial context.
Released as warpconvnet.models.space_former. Configurable per-level attention
via enc_attn_types string codes (e.g. "ssccc"), three block layouts
(pre_norm / post_norm / stream_norm), pluggable MaskFormer
head wrapped in PointToVoxel.
From 3D input alone, SpaCeFormer reaches 22.9 mAP and surpasses the prior state of the art — OpenTrack3D (20.6 mAP), which fuses multi-view 2D streams with YOLO-World + SAM2 proposals — while running over 2,000× faster at 0.30 s per scene.
Under the matched setting (proposal-free, 3D-only, no GT 3D annotations), SpaCeFormer is 2.8× over the next-best method at 11.1 mAP, running in 0.12 s per scene. Higher-scoring methods rely on GT-trained Mask3D proposals or multi-view 2D streams with YOLO/SAM proposals.
Every prediction runs at interactive rates — 0.12–0.30 s per scene, orders of magnitude faster than proposal-based pipelines. Ablations confirm each component contributes: space-curve attention, 3D RoPE, and learned queries each improve open-vocabulary mAP, and the final model reaches strong class-agnostic mask quality (22.5 AP, 45.7 AP50, 64.4 AP25) alongside 11.1 mAP over 200 categories.
SpaCeFormer predictions on ScanNet200 validation scenes. Each color represents a distinct predicted instance with its open-vocabulary label.






Pretrained checkpoints and runnable examples live on the Hugging Face model page. The demo folder ships a viser viewer, a headless CLI, and a Gradio app. Inference requires WarpConvNet's compiled CUDA extension.
import numpy as np
import torch
from plyfile import PlyData
from huggingface_hub import hf_hub_download
from warpconvnet.geometry.types.points import Points
from warpconvnet.models.spaceformer import build_spaceformer, load_spaceformer_checkpoint
device = torch.device("cuda")
# 1 — Load a colored point cloud from a .ply file
ply = PlyData.read("my_scene.ply")["vertex"]
coord = np.column_stack([ply["x"], ply["y"], ply["z"]]).astype(np.float32) # [N, 3] meters
color = np.column_stack([ply["red"], ply["green"], ply["blue"]]).astype(np.float32) # [N, 3] in [0, 255]
# 2 — Convert RGB color to input features, normalized to [-1, 1]
feat = color / 127.5 - 1.0 # [N, 3]
# 3 — Move to GPU and wrap in a WarpConvNet Points object
coord_t = torch.from_numpy(coord).to(device)
feat_t = torch.from_numpy(feat).to(device)
offset = torch.tensor([0, coord_t.shape[0]], dtype=torch.int32, device=device) # single scene
pc = Points(batched_coordinates=coord_t, batched_features=feat_t, offsets=offset)
# 4 — Build the released model, load weights, and run
ckpt = hf_hub_download("chrischoy/SpaCeFormer", "spaceformer_512_siglip2_ssccc.ckpt")
net = build_spaceformer(device=device)
load_spaceformer_checkpoint(net, ckpt)
out = net({"pc": pc}) # {"logit": [B,Q,2], "mask": List[[N,Q]], "clip_feat": [B,Q,1152]}
pip install -r demo/requirements.txt
# Interactive viser viewer (open http://localhost:8080)
python demo/demo_viser.py --port 8080
# Run on your own scene with custom class names
python demo/demo_viser.py --ply my_scene.ply \
--class-names "chair" "table" "lamp" "other"
# Alternatives: headless CLI (demo/inference.py) or Gradio app (demo/app.py)
@inproceedings{choy2026spaceformer,
title = {SpaCeFormer: Fast Proposal-Free Open-Vocabulary
3D Instance Segmentation},
author = {Choy, Chris and Lee, Junha and Park, Chunghyun
and Cho, Minsu and Kautz, Jan},
booktitle = {Proceedings of the International Conference on
Machine Learning (ICML)},
year = {2026},
eprint = {2604.20395},
archivePrefix = {arXiv}
}