TAMPanda

A lightweight, open-source MuJoCo wrapper for the Franka Emika Panda. Scene building, IK, RRT*, and pick-and-place out of the box — so neuro-symbolic and TAMP researchers can focus on the algorithm, not the infrastructure.

$git clone https://github.com/snoato/tampanda
$cd tampanda && pip install -e .
Step-by-step tutorial View on GitHub
MIT Python ≥3.10 MuJoCo 3.x

From symbolic plan to physical execution in minutes

Transitioning from standard planning benchmarks to physics simulation is expensive: you need scenes, collision detection, grasp pipelines, and control loops before testing a single idea.

TAMPanda wraps all of that. A symbolic instruction like pick(block) translates into a physically validated, collision-free trajectory — automatically.

Components are modular: use the high-level executor, or drop down to IK solvers, motion planners, and joint-space representations directly.

quickstart.py
from tampanda import ArmSceneBuilder, RRTStar
from tampanda import GraspPlanner, PickPlaceExecutor
from tampanda.scenes import (
    TABLE_SYMBOLIC_TEMPLATE,
    BLOCK_SMALL_TEMPLATE,
)
import numpy as np

# Build a scene from a Python config
builder = ArmSceneBuilder()
builder.add_resource("table", TABLE_SYMBOLIC_TEMPLATE)
builder.add_resource("block", BLOCK_SMALL_TEMPLATE)
builder.add_object("table", pos=[0.75, 0.80, 0.00])
builder.add_object("block", pos=[0.45, 0.40, 0.31],
                   name="block_0")

env      = builder.build_env(rate=200.0)
planner  = RRTStar(env)
executor = PickPlaceExecutor(
    env, planner, GraspPlanner(table_z=0.27))

# One call handles approach → grasp → lift → place
executor.pick(
    "block_0",
    env.get_object_position("block_0"),
    env.get_object_half_size("block_0"),
    env.get_object_orientation("block_0"))
executor.place("block_0",
    np.array([0.50, 0.25, 0.31]))
Framework

Modular components for the full pipeline

Each component can be used independently or in combination. Use the high-level API or drop down to any layer.

🏗️

Scene Builder

Assemble MuJoCo environments from Python — no manual MJCF/XML. Register object templates, place instances, set colours. Supports hot-reload and YCB / Google Scanned Objects (~1 000 objects) on demand.

ArmSceneBuilder
🦾

Inverse Kinematics

Differential IK via Mink. Solve for end-effector pose targets with configurable position and orientation thresholds. Exposed for custom planner integration.

MinkIK
🗺️

Motion Planning

RRT* with path smoothing in joint configuration space. Geometry-aware grasp candidate ranking. Parallelized RRT feasibility checks for reward shaping in learning pipelines.

RRTStar
🤏

Pick & Place

Translates a single high-level pick(obj) call into approach → grasp → lift → transport → place. Multi-candidate retry and kinematic object attachment included.

PickPlaceExecutor
🧩

PDDL Domain Adapter

Wire any PDDL domain to TAMPanda's continuous execution layer using Python decorators — define predicate truth rules, action executors, and pose samplers without modifying TAMPanda internals. Planning via unified-planning.

DomainBridge
🎮

Gymnasium Integration

Full Gymnasium-compatible environment suite: standard env, HER-compatible goal env, symbolic reward shaping, expert action wrapper, and spawn-safe parallel workers via make_vec_env.

TampandaGymEnv · HER
📷

Perception

RGB, depth, and segmentation rendering. Point cloud generation with object filtering. Ground-truth state access and predicate grounding for symbolic state estimation.

MujocoCamera

Built for the neuro-symbolic and TAMP communities

Neuro-Symbolic AI Researchers

Bridge symbolic representations and continuous robot execution — predicate grounding, spatial reasoning, plan-conditioned policies — without writing simulation infrastructure from scratch.

TAMP Researchers

Lightweight alternative to full TAMP systems for rapid prototyping. Symbolic actions are validated by IK + RRT* before commitment; planners and solvers are swappable.

Reinforcement Learning Researchers

Drop-in Gymnasium environment with configurable observation spaces, HER-compatible goal conditioning, symbolic reward shaping, and spawn-safe parallel workers. Symbolic predicates can be used as structured goal representations.

RoboCup Teams

Model assembly and manipulation tasks offline. Integrated YCB and Google Scanned Objects support makes it easy to instantiate standard object sets for league-specific domains.

Applications

In use for ongoing research

TAMPanda was built to support active research at the Chair of Machine Learning and Reasoning (i6), RWTH Aachen University.

Neuro-Symbolic Representation Learning

TAMPanda's BlocksDomain drives data generation pipelines for learning to predict continuous object configurations from symbolic state sequences. Predicate grounding provides validation oracles.

Geometric Feasibility in Planning

Parallelized RRT feasibility checking at simulation throughputs sufficient for online reward shaping, supporting research into learning implicit geometric pre-conditions in underspecified symbolic domains.

Goal-Conditioned Manipulation Policies

TAMPanda provides the physics environment and symbolic observation layer for training goal-conditioned policies over individual symbolic state transitions.

RoboCup Smart Manufacturing League

The SceneBuilder and PickPlaceExecutor serve as the simulation backbone for offline assembly sequence planning in the RoboCup SML assembly task.

Examples

Ready to run

All examples are in examples/. On macOS, use mjpython for scripts that open a viewer.

ScriptWhat it demonstrates
basic_ik.pyIK to a target pose, held in the interactive viewer
basic_rrt.pyRRT* path between two joint configurations
grasping_rrt_planner.pyGeometry-aware grasping with ranked candidates
blocks_world_rrt.pyPick two cubes onto a platform using PickPlaceExecutor
demo_pick_put.pyFull TAMP pipeline: GridDomain → symbolic plan → continuous execution
symbolic.pyGrid-based PDDL planning with live viewer
scene_builder.pyProgrammatic scene construction with hot-reload
object_browser.pyBrowse, download, and preview YCB / Google Scanned Objects

Ready to get started?

The tutorial takes about 20 minutes and ends with a full pick-and-place pipeline running in simulation.

Open the tutorial → GitHub repository