# tlabel convert: One CLI to Bridge 9 Tactile Dataset Formats

> Source: <https://dev.to/liesliy/tlabel-convert-one-cli-to-bridge-9-tactile-dataset-formats-400k>
> Published: 2026-08-11 04:08:43+00:00

How a single command can unify GelSight, PaXini, Daimon, ToucHD, and 5 other tactile sensor formats into training-ready data.

If you work in tactile robotics research, you've been here before:

A collaborator sends you a dataset collected with a PaXini PXCap force array. Your pipeline expects GelSight .pkl files. Your colleague's LeRobot training code needs Zarr. Someone else is publishing results on a Daimon DM-TacClaw in .parquet format.

Three sensors. Three formats. Three days of writing ad-hoc parsing scripts that you'll delete next week.

Tactile sensing is having a moment — multiple billion-dollar funding rounds in embodied AI have poured attention (and capital) into the field in 2026. But while hardware is advancing fast, data interoperability is still a mess. Every sensor vendor ships data in a proprietary format, and there's no common lingua franca for tactile manipulation datasets.

TLabel is an open-source project that tackles exactly this problem. And with the maturation of its CLI and adapter architecture through v0.18.x, the workflow for converting between tactile dataset formats has gotten dramatically simpler.

**What TLabel Actually Does**

Before diving into commands, let's set expectations. TLabel is a data pipeline standardization layer. It does not:

Interface with hardware or collect data

Run inference or train models

Replace your training pipeline

It does:

Define a 14-dimension semantic annotation schema (covering contact, force, slip, texture, deformation, and more)

Provide adapter implementations that translate sensor-specific formats into that schema

Export annotated data into training-ready formats (LeRobot, FTP-1 Zarr, JSON, CSV)

Think of it as the Unicode for tactile data — one standard schema, every sensor.

**The Adapter Landscape**

TLabel currently ships with 12 built-in adapters covering 9 dataset formats and 3 real-time sensor interfaces:

**Dataset Adapters (Offline Data Loading)**

<> — GelSight Mini / DIGIT, visuo-tactile, .pkl, L3

<> — PaXini PXCap, force array, .h5, L2

<> — Daimon DM-TacClaw, multimodal, .parquet, L3

<> — ToucHD, visuo-tactile, .hdf5, L3

<> — UniVTAC, visuo-tactile, .hdf5, L3

<> — VTouch, visuo-tactile, .h5, L3

<> — YCB-Slide, visuo-tactile, .npy, L3

<> — TacQuad (AnyTouch), multi-sensor, directory, L3

<> — TLabel native, meta format, .json, L1–L4

**Real-Time Sensor Adapters**

<> — PaXini GEN3, force array, SDK connection, L2

<> — Daimon DM-Tac, visuo-tactile, USB / .avi, L3

<> — PaXini PX6D, 6-axis force, placeholder, L2

That covers the majority of tactile sensors used in manipulation research today.

**Getting Started**

Install is straightforward:

```
pip install tlabel

# Or with sensor-specific extras:
pip install tlabel[gelsight]     # GelSight / DIGIT (.pkl)
pip install tlabel[paxini]       # PaXini PXCap (.h5)
pip install tlabel[daimon]       # Daimon DM-TacClaw (.parquet)
pip install tlabel[ftp1]         # FTP-1 export (zarr)
pip install tlabel[all]          # Everything
```

**Exploring Adapters from the CLI**

Once installed, you can inspect what's available without writing any code:

```
# List all registered adapters
tlabel list
```

This prints all dataset and real-time adapters with their type, native format, and compliance level. It's the first command I run when working with a new dataset.

For details on a specific adapter:

```
tlabel info gelsight
```

This shows the adapter's capability declaration — which of the 14 semantic dimensions it can annotate, its compliance level, and any format-specific notes. For example, GelSight outputs force_vector (L3) but not temperature (L4), while a simple resistive sensor might only declare L1 fields like contact and slip_event.

This capability declaration system is one of TLabel's key design decisions. Rather than forcing every sensor to produce all 14 dimensions (which would mean fabricating data it can't actually measure), each adapter honestly declares what it can and cannot provide.

**Validating Your Data**

Before converting, it's worth checking that your data passes schema validation:

```
tlabel validate data.json
```

This runs a compliance check against the 14-dimension Schema V2 and reports any issues. Catching format problems early saves debugging time downstream.

**Converting Between Formats**

Here's where things get practical. TLabel provides two paths for format conversion: CLI for quick checks and the Python API for full control.

**Quick Conversion via CLI**

For simple cases — say you have a single GelSight .pkl file and want a JSON summary:

```
tlabel export --input grasp_data.pkl --format json --output annotations.json
```

This reads the GelSight data through its adapter, applies the Schema V2 annotation, and writes a clean JSON file with all 14 semantic dimensions (at the appropriate compliance level for the sensor).

**Full Conversion Pipeline via Python**

For the heavy lifting — converting entire datasets into training-ready formats — the Python API gives you the most control:

``` python
import tlabel
from tlabel.converters import tlabel_to_lerobot

# Load data from any supported sensor
data = tlabel.load("path/to/paxini_data.h5")

# Inspect what you got
print(data.describe())
# -> {'num_frames': 500, 'sensor': 'paxini', 'compliance_level': 'L2', ...}

# Export to JSON/CSV for analysis
data.export("output.json")

# Export to FTP-1 Zarr for foundation model training
data.export_ftp1("output.zarr")

# Convert to LeRobot episode format
tlabel_to_lerobot("annotations.json", "lerobot_episode/")
```

Here's a concrete example that walks through a realistic workflow — loading PaXini force array data, validating annotations, and exporting to both LeRobot and FTP-1 formats:

``` python
import tlabel
from tlabel.converters import tlabel_to_lerobot

# Step 1: Load PaXini PXCap data
data = tlabel.load("experiment_01.h5")

# Step 2: Validate schema compliance
data.validate_annotations()
# Reports any missing or malformed fields

# Step 3: Auto-annotate events from signal patterns
data.annotate_events_auto()
# Detects: contact_onset, contact_loss, slip events, force spikes

# Step 4: Export
data.export("experiment_01.json")           # Analysis
data.export_ftp1("experiment_01.zarr")      # Foundation model training
tlabel_to_lerobot("experiment_01.json",     # LeRobot pipeline
                   "lerobot_episode/")
```

**Batch Processing Multiple Files**

When you're dealing with an entire experiment directory (which is the typical case — real manipulation datasets have hundreds of episodes), you can batch-load and convert:

``` python
import glob
import tlabel

files = glob.glob("raw_data/*.h5")

for f in files:
    data = tlabel.load(f)
    data.validate_annotations()
    data.export(f"annotated/{data.sensor}_{data.num_frames}f.json")
    print(f"Converted {f} -> {data.sensor} (L{data.compliance_level})")
```

**Understanding the Architecture**

The adapter system sits in a three-layer architecture:

```
┌─────────────────────────────────────────────────┐
│ Layer 1: Schema                                 │
│ 14 semantic dimensions + Compliance Level L1-L4 │
├─────────────────────────────────────────────────┤
│ Layer 2: Adapters                               │
│ DataAdapterBase │ SensorAdapterBase             │
├─────────────────────────────────────────────────┤
│ Layer 3: Downstream                             │
│ Feature derivation · Export · Augmentation      │
│ FTP-1 · LeRobot · RLDS · ROS2                  │
└─────────────────────────────────────────────────┘
```

Layer 1 is the schema itself — 14 semantic dimensions covering spatial perception (contact, centroid, region), mechanics (force magnitude, force vector, torque), dynamics (slip event, slip velocity, manipulation phase), surface properties (texture class), and meta-perceptions (deformation, temperature, confidence, compliance level).

Layer 2 is where adapters live. There are two base classes:

DataAdapterBase — for offline dataset files (sublcass this to add support for a new sensor format, takes ~30 minutes)

SensorAdapterBase — for real-time hardware connections (streaming data from a live sensor)

Both produce output conforming to the same Schema V2, which means Layer 3 downstream tools work identically regardless of which sensor the data came from.

Layer 3 handles everything after annotation: feature derivation, data augmentation, and export into training frameworks. This is where the LeRobot converter, FTP-1 Zarr exporter, and RLDS bridge live.

**The Compliance Level System**

One concept worth explaining in more detail: Compliance Levels (L1–L4). This is TLabel's answer to the question "what if my sensor can't measure temperature or 6-axis force?"

L1 — Basic Tactile: contact, centroid, slip, confidence. Examples: Single-point resistive, proximity sensors

L2 — Force-Aware: L1 + force_magnitude. Examples: PaXini, YCB-Slide, GelSight

L3 — Full-Vector: L2 + force_vector. Examples: ToucHD, calibrated DM-TAC

L4 — Rich-Semantic: L3 + all optional fields. Examples: BioTac, next-gen multimodal sensors

The key insight: a PaXini at L2 and a ToucHD at L3 both produce valid TLabel output. They just populate different subsets of the 14 dimensions. Downstream code can check compliance_level to decide what it can and cannot use, rather than writing sensor-specific branches.

This is what makes cross-sensor comparison possible. You can train a model on GelSight data (L3) and evaluate it on PaXini data (L2), knowing exactly which fields are comparable and which aren't.

**What About My Sensor?**

TLabel is designed for extensibility. If your sensor isn't supported yet, adding an adapter takes about 30 minutes:

Fork the adapter template from contrib/adapter-template/

Subclass DataAdapterBase (for datasets) or SensorAdapterBase (for hardware)

Implement the required methods and declare your compliance level

Submit a PR or publish as a standalone package

The project also supports register_external_adapter() and entry_points auto-discovery, so third-party adapters can be published independently.

**How This Fits Into the Embodied AI Pipeline**

The broader context matters. Foundation models for robotics — like those being built on top of LeRobot, Open X-Embodiment, and similar frameworks — need diverse, standardized training data. But tactile data has been a bottleneck:

Collection is sensor-specific (hardware-dependent)

Annotation has been ad-hoc (no standard schema)

Training expects uniform input formats

TLabel deliberately addresses step 2 and 3 only. It's a standardization layer that sits between your raw sensor data and your training pipeline. By providing a common schema with honest capability declarations, it enables:

Cross-sensor training: Mix data from different sensors in the same training batch

Capability-aware models: Train models that know what information is available at each compliance level

Reproducible research: Compare results across labs using different hardware

The project is also actively contributing tactile data format support upstream to LeRobot via PR #4032, which signals growing recognition that tactile data standards are needed in the broader robotics ecosystem.

**Quick Reference**

See all supported adapters → tlabel list

Get adapter details → tlabel info gelsight

Validate a data file → tlabel validate data.json

Export to JSON → data.export("out.json")

Export to FTP-1 Zarr → data.export_ftp1("out.zarr")

Convert to LeRobot format → tlabel_to_lerobot(src, dst)

Load any sensor data → tlabel.load("file")

Try a demo (no files needed) → tlabel.demo("gelsight")

**Wrapping Up**

Tactile data interoperability isn't glamorous work — it's infrastructure. But it's the kind of infrastructure that determines whether the field can scale beyond lab-specific pipelines to shared, reproducible, cross-sensor research.

TLabel's adapter architecture and CLI tools won't solve every data problem in tactile robotics. But they provide a concrete, working answer to the question: "How do I get data from sensor X into format Y without writing a custom parser?"

That question used to take a weekend. Now it takes one line.

**Links:**

GitHub: [https://github.com/liesliy/tlabel](https://github.com/liesliy/tlabel)

PyPI: [https://pypi.org/project/tlabel/](https://pypi.org/project/tlabel/)

TLabel Paper: PDF on GitHub

Schema V2 Spec: docs/tlabel-format.md

Adapter Template: contrib/adapter-template

Contributing Guide: CONTRIBUTING.md

LeRobot PR #4032: huggingface/lerobot#4032

Previous Dev.to post: TLabel: Unifying Tactile Data Annotation for Robotics

Open X-Embodiment: robotics-transformer-x.github.io

OpenTouch: opentouch.ai

TL;DR — TLabel is the Unicode for tactile data: one standard schema, every sensor. Install with pip install tlabel, run tlabel list to see what's supported.