Manipulation

EvoVLA (ECCV 2026) guide: eliminating stage hallucination in VLA manipulation via Stage-Aligned Reward, Gemini hard negatives, and long-horizon memory to reach 69.2% on the Discoverse-L benchmark.

VLAC integrates a learned critic into the real-world RL loop, lifting success rate from 30% to 90% in just 200 episodes — no reward engineering required.

Technical guide to Qwen-VLA from Alibaba: Qwen3.5-4B + DiT decoder architecture, 4-stage training pipeline, 97.9% on LIBERO, beating pi0.5 on real-world ALOHA.

FM-VLA uses a Variational Autoencoder to compress force-sensor history into 8 memory tokens, enabling robots to press buttons the right number of times, wipe dishes, and find hidden objects — achieving 83.3% success with only 3.3ms overhead.

ICLR 2026: InstructVLA uses VLA-IT with MoE LoRA to train manipulation policies that understand complex instructions, achieving +96% over OpenVLA on the 80-task SimplerEnv-Instruct benchmark.

Step-by-step guide to LaST-R1 — a framework combining Latent Chain-of-Thought reasoning with LAPO (RL) to fine-tune VLA models to 99.8% success on LIBERO with just 1 demo/task.

UniTacVLA integrates tactile chain-of-thought reasoning and coarse-to-fine prediction into VLA for contact-rich manipulation — ECCV 2026 with open-source code.

A technical guide to TORL-VLA — a framework combining tactile sensors and Online RL to fine-tune VLA models for high-precision contact-rich manipulation: latch, egg, coffee cup tasks.

From 79.6% on LIBERO benchmark to physical robot deployment: calibrate camera-to-robot transforms, handle domain gap with real-world augmentation, and deploy the SAP pipeline on Franka/UR5 with latency under 100ms.

A deep dive into VIMA's object tokenizer: Mask R-CNN objects, ViT crop features, bbox MLP position signals, and T5 prompt assembly.

Deep dive into VIMA's 650K trajectory dataset: procedural generation in PyBullet, pkl file format, HuggingFace download, and why just 1% of the data beats all baselines.

Install VimaBench, run the 200M checkpoint demo, and analyze all 4 eval partitions — from placement to novel task generalization. Which level matters most for humanoid deployment?

Decode VIMA's cross-attention architecture: how T5 encodes multimodal prompts and XAttn GPT generates motor commands for 17 robot manipulation tasks.

Discover Dexora — the first open-source VLA built for 36-DoF dual-arm, dual-hand manipulation, combining an exoskeleton backpack with Apple Vision Pro to achieve 66.7% success on dexterous tasks.

ManiAgent hits 86.8% on SimplerEnv vs pi0 55.7% and CogACT 51.3% — with zero robot fine-tuning. A deep-dive into the 3-agent architecture and why decomposition beats end-to-end.

Deep dive into ManiAgent's Perception Agent: Florence-v2 for zero-shot open-vocabulary object detection and AnyGrasp for 6-DoF grasp pose generation from point clouds. Build a complete Python perception module.

Comparing ALRM's two execution modes: CaP generates Python to call robot APIs in one pass, TaP uses ReAct to loop per tool call. Benchmark across 56 tasks and 10 LLMs to help you pick the right mode.

Run ds.py (DeepSeek-V3 subgoal decomposition) and main.py (OpenVLA on LIBERO). Implement a Temporal Verifier sliding window — SAP protocol achieving 79.6% LIBERO avg.

The capstone: combine Robo3R, DP3, Omni-Manip, and WholeBodyVLA into a concrete deployment pipeline for the Unitree G1 — from sensor placement, policy choice, and data strategy to a sim2real checklist.

Build MoveJ from scratch: joint-space interpolation, synchronized arrival, velocity and acceleration limits, Python prototype, and C++ playback.

Implement MoveL from scratch: linear TCP waypoints, quaternion SLERP, IK at every pose, and straightness verification.

Capstone article: deploy your controller on a real UR robot via ros2_control, joint_trajectory_controller and ur_rtde C++ with full tracking-error logging.

Build a reusable C++/CMake/Eigen skeleton with GoogleTest and a Python robotics environment for the rest of the series.

Fill a UR5 DH table by hand, build a NumPy/C++ Eigen model, then cross-check with Robotics Toolbox and Pinocchio URDF.

Compute UR5 FK from DH by hand, implement NumPy/C++ Eigen from scratch, then verify with GoogleTest, RTB and Pinocchio.

Derive UR5 IK by hand, then build numerical IK in Python and C++ with Jacobian pseudo-inverse, DLS and joint-limit handling.

Derive the UR5 Jacobian, detect singularities with SVD, and build safe resolved-rate control in Python and C++.

A practical guide to base/tool/user/object frames, 6-DOF TCP offsets, and SE(3) pose composition in Python and C++.

A beginner roadmap to industrial arm controllers: MoveJ/MoveL, planners, trajectories, servo loops, C++/Python, and 2026 libraries.

Build MoveC through three points and MoveP through many via points with steady TCP speed, blend radius, Python, and C++ Eigen.

Time-scaling for robot arms: trapezoid, S-curve, velocity/acceleration/jerk limits, Python prototype and C++ classes.

Learn blend radius, path deviation, why hard stops are slow, and build Python/C++ prototypes for smooth multi-waypoint arm motion.

Complete guide to MoveIt Servo on ROS 2: joint jog, Cartesian twist jog, real-time pose tracking, singularity/collision/joint-limit safety, C++ API and Python keyboard teleop.

DP3 turns a point cloud into a direct input for a diffusion policy — 24.2% relative improvement across 72 tasks, 85% success on real robots. Hands-on: install, train, eval from the YanjieZe/3D-Diffusion-Policy repo.

Bringing the real world into cuRobo planning with cuboids first, depth later, timestamp discipline, filtering, TSDF/ESDF, and immutable scene snapshots.

Practical guide for deciding when to upgrade from GoPro UMI to RealSense D405: what D405 brings, what you must build yourself, and the right architecture to avoid losing data quality.

A beginner-friendly guide to building RUKA-v2, a tendon-driven open-source robot hand for dexterous manipulation and policy learning.

A beginner-friendly guide to AffordanceVLA: paper idea, Which2Act/Where2Act/How2Act architecture, GitHub setup, training, inference, and results.

Scale UMI to bimanual: build 2 units, record two-arm demos, use the official demo_real_bimanual_robots.py and eval_real_bimanual_umi.py, train with umi_bimanual config. Concrete, step-by-step, no guesswork.

A practical guide to installing, running, fine-tuning, and deploying OpenEAI-VLA, an open Qwen3-VL-4B VLA for low-cost robot arms.

A practical FineVLA guide covering the paper idea, architecture, installation, training, inference, and results.

Designing a ROS 2 wrapper around cuRobo with actions, lifecycle warmup, joint-state reordering, retiming, controller execution, and watchdogs.

A practical guide to open-source EXPO-FT: fine-tuning π0.5 VLA with online RL in 19.1 minutes of robot data.

Train Diffusion Policy from UMI's replay_buffer.zarr.zip, understand training metrics, and deploy the policy to a real robot arm using eval_real_umi.py — with verified official configs.

Running pose-to-pose planning, obstacle collision, warmup, grasp approach-lift, and planner tuning for robot arms on Jetson.

Step-by-step guide to recording UMI single-arm demos, running all 8 official SLAM pipeline scripts (00–07), checking data quality, and exporting replay_buffer.zarr.zip for policy training.

Step-by-step guide to 3D printing and assembling a UMI handheld unit with GoPro — the verified path from the Stanford repo. Full BOM, print settings, and how to test before collecting your first demo.

A practical validation guide for forward kinematics, inverse kinematics, wxyz quaternions, joint order, and frame mistakes before real robot planning.

Understand the core idea behind Universal Manipulation Interface: why decoupling data collection from the robot is the key breakthrough for scaling imitation learning in manipulation.

How to convert a robot arm URDF into a usable cuRobo config with mesh paths, sphere fitting, self-collision ignores, clipping, and pass/fail criteria.

A reproducible Jetson setup for cuRoboV2 with JetPack, uv, Python 3.11, CUDA 12.x, PyTorch, and deployment-focused checks.

Hands-on guide to LeRobot v0.5 Multitask DiT Policy: one model for many tasks, CLIP text-conditioning, open-source on HuggingFace, deployed on SO-100/SO-101.

The opening guide for using cuRoboV2 on robot arms and Unitree G1, from Jetson runtime architecture to whole-body deployment boundaries.

Step-by-step guide to train SO-101 robot arm in NVIDIA Isaac Lab, collect teleop data, fine-tune GR00T N1.5, and deploy the policy on real hardware.

A comprehensive guide to RoboTwin 2.0 — the scalable synthetic data framework for bimanual robots, featuring MLLM code generation and strong domain randomization.

Deploy task planning for robot manipulation on NVIDIA Jetson AGX Orin 64GB — from cuTAMP and cuMotion to VLM inference at the edge.

Solving long-horizon manipulation with RL — curriculum learning, hierarchical RL, skill chaining, and IKEA furniture assembly benchmarks.

Teach robots to use tools with RL — affordance learning, two-phase grasp-then-use, and screwdriver insertion in MuJoCo.

Solve contact-rich manipulation with RL — peg-in-hole, assembly, tactile sensing, and domain randomization for sim-to-real transfer.

Complete guide to MoveIt2 configuration for robot arms — from URDF, collision detection to trajectory planning in ROS 2.

Train robots to carry objects stably with RL — from carry-flat to pouring, multi-objective reward balancing speed vs stability.

Train precise pick-and-place with RL — HER for sparse rewards, 6-DOF placement, and orientation alignment with sub-cm accuracy.

ALOHA hardware, Mobile ALOHA, ACT for bimanual tasks, data collection tips and LeRobot SO-100 dual arm — complete guide to bimanual manipulation.

Train a robot to carry a cup of water without spilling using RL — reward design for force control, impedance baseline, and SAC training.

In-hand rotation, tool use, DexGraspNet and tactile sensing — complete guide to dexterous manipulation with multi-finger robot hands.

DDPM recap, Diffusion Policy architecture (CNN vs Transformer), implementation with LeRobot, and benchmark results — complete practical guide.

Train robots to grasp diverse objects with RL — from grasping reward design to curriculum learning with PPO and SAC.

Build the foundation of RL for manipulation — from MDP formulation and reward function design to setting up MuJoCo environments from scratch.

Connect ROS 2 to real hardware — write a C++ hardware interface for motor drivers and read encoders with the ros2_control framework (Jazzy, updated June 2026).

Vision-Language-Action models changing manipulation — from Google's RT-2 to pi0 by Physical Intelligence, with fine-tuning and real-world limitations.

Complete end-to-end tutorial: setup LeRobot, record demonstrations, train policy (ACT/Diffusion), evaluate and deploy to real robot arms.

Data collection via teleoperation, Behavioral Cloning pipeline, DAgger fixes distribution shift, and ACT -- comprehensive guide for teaching robots manipulation from demonstrations.

From traditional force closure to deep learning grasp detection -- overview of modern grasping methods and how to choose right approach for your project.

Solve IK for 6-DOF robot arm — from DH parameters, forward kinematics to numerical IK solver in Python with NumPy.

Compare top 5 cobot brands — payload, reach, price, and practical applications for Vietnamese factories.

Python is the most popular language in robotics thanks to rich library ecosystem. Learn how to control robots from GPIO to kinematics.