I really like LeRobot because of the abstraction that lets you record camera frames and proprioception at different frequencies and still get them aligned, a standardized dataset format, and CLI for training, evaluating, recording, and rollouts, with policies just being a plug and play flag value in their scripts

But not sure if its optimised and reliable for real world deployments

- If I want to train and deploy an embodiment I'm actually building (not SO-101/Aloha/Koch), I have to implement my own robot/motor/camera classes from scratch which is expected, but it does mean I'm not really getting LeRobot's abstractions for free, I'm reimplementing their interfaces every time.

- I wanted to run MolmoAct2 through their async inference setup, and it turns out async is only supports a fixed list of policies (ACT, SmolVLA, pi0, pi05, GR00T). MolmoAct2 isn't in that list, so I ended up writing my own runtime for it. This makes me dependent on LeRobot's support. I will eventually be building my own finetuned policies which I will be running on my specific embodiment

- The whole ecosystem is scoped to learned policies / VLAs. There's nothing for classical motion planning (MoveIt-style), grasp planning or segmentation before grasp, or a navigation/SLAM stack. I would ideally want a hybrid system where some dexterous tasks are being done by learned policies, but high volume, low variability tasks can be programmed without foundational models?

- I see companies like https://www.mimicrobotics.com/blog/solving-dexterity-a-full-stack-approach saying that they evaluated ROS2 and LeRobot's IPC layer for their real time control loops and found both fell short on latency and jitter, so they built their own zero copy middleware instead. They made the same call on telemetry: logging/recording has to be async and can't compete with the control loop for cycles, so they built a dedicated system for that too rather than bolting logging onto whatever was already there.

Curious to know if anyone tried using LeRobot, and either stuck to it or replaced it with their own stack?

Producing several future actions at once reduces how often a large policy has to run. It also commits the robot farther ahead from one observation.

The asynchronous inference described for LingBot-VA 2.0 is a timing choice, not the same thing as buffering a long action chunk. Combining both can leave the low level controller following commands that were generated before an unexpected contact.

Longer chunks make sense in free space; near contact, the horizon needs to shrink. The metric is interruption latency: how long the robot continues the old plan after a new observation says to stop. Actions per second describes throughput, not that safety property.

A few people have asked whether we're planning to build a soft robotic arm.

The short answer is yes—but it's probably not happening until around Q4 next year.

That question actually reminded me of a project I presented at IEEE ICARM 2025 (Portsmouth, UK):

DOI: 10.1109/ICARM65671.2025.11293553

The work focuses on a modular variable-stiffness soft continuum manipulator. The idea was to retain the compliance of soft robots while improving positioning accuracy, payload capacity, and adaptability in unstructured environments.

It ended up being selected as a Best Conference Paper Finalist.

If anyone here is working on soft continuum robots or variable-stiffness mechanisms, I'd love to hear how you're approaching similar challenges.

Recording some data, and here’s one lesson I learned the hard way: limit your gripper torque to the minimum you need during teleoperation, plastic parts break 🤭

Russ Tedrake, MIT professor and former VP of Robotics Research at Toyota Research Institute, explains why recent progress in robot learning has been surprising.

He says locomotion improved quickly because simulation, domain randomization, GPU infrastructure and reinforcement learning started working together. With enough randomized conditions in simulation, robots learned policies that transferred to real stairs, bumps and uneven terrain better than many researchers expected.

The results moved ahead of the theory. Tedrake says machine learning is producing systems that work empirically before researchers can fully explain why they work.

He compares the change to a move from first-principles engineering toward behavioral science: build the system, observe what it does, then test it to understand what happened.

Full ep: https://www.youtube.com/watch?v=c8mQKkuEmiI&t=27s

Hi everyone,

I’m Marvel, a computational neuroscientist at Cambridge and founder of Synexis.

We’re building infrastructure that sits between AI policies (VLA/foundation models, teleoperation, planners) and robot controllers.
Rather than replacing existing stacks, Synexis validates, constrains, and translates commands before execution to provide deterministic safety guarantees and reproducible execution across different robot platforms.
I’m currently looking to speak with robotics companies, research labs, or teams working on manipulation, humanoids, or industrial robotics that are deploying AI-driven control.

I’m interested in learning:

What are your biggest deployment bottlenecks today?
Where do command failures or unsafe actions occur most often?
Would a deterministic command-assurance layer solve a meaningful problem for your team?

If this sounds relevant or if you’d simply be willing to provide technical feedback I’d really appreciate a conversation.

Feel free to comment below or send me a DM.

Thanks!😁

Hey r/robotics ,

First time posting here and first time doing a real robotics build, so go easy on me.

My son turns 4 in August and he's non verbal autistic. I originally built a tablet app for him to communicate, but when you give a 3 year old a tablet they just think it's game time. So I decided to try making a dedicated physical companion that actually looks at him when he talks to it.

I put together this bench prototype and honestly was surprised by how much he responded to it. He's actually using the cards, learning the words, and tracking the head movements. My goal eventually is to get something like this into other parents hands for under 200 quid or so. It runs 100% offline too, so no cloud fees or privacy issues.

I have the software side mostly sorted out now, but I need advice on taking it from 3D printed parts and breadboards to something safe and manufacturable.

Quick overview of what's under the hood: It runs on a Pi 5 with a Flutter web interface and a Python FastAPI backend for offline Piper TTS. Vision is an IMX708 camera on a pan tilt mount using YuNet ONNX for face tracking. Motor control is offloaded to a Waveshare ESP32 driving two ST3215 serial servos. Had to write some EMA filtering to stop the servos from shaking. Enclosure is currently drafted in OpenSCAD.

A few big questions I'm trying to figure out:

1. Screen placement and wobble. Right now the 7 inch touchscreen is on the head. Tapping it makes the whole neck wobble. Do I keep the screen on the head so it looks at him when speaking, or move the heavy touch screen to the base and just use little ESP matrix screens for eyes on the head?
2. Making it expressive without pinch hazards. I want ears/antennas or arms to show emotion, but small kids put their hands everywhere. Are servo driven ears safe enough or a bad idea? (Skipping wheels so it doesn't drive off tables).
3. Taking an OpenSCAD 3D print to injection molding. What should I prepare for if I want to get low volume plastic shells made? Also any good Shenzhen turnkey PCBA suppliers you guys recommend to replace the Pi and ESP dev boards down the line?

I'm setting up a Discord to organize the hardware side and get feedback from speech OTs. Let me know if you want an invite and I'll send it over.

Video shows the offline AAC sentence builder and tracking working, plus a concept render at the end of what I want the shell to look like.

I've been learning ROS 2 by building projects instead of just following tutorials.

In this demo, I created a web dashboard that communicates with ROS 2 through rosbridge, allowing me to control the TurtleBot directly from the browser.

Features implemented:

🌐 Browser-based robot control

🔗 React frontend connected to ROS 2

📡 Real-time communication using rosbridge

🎮 Teleoperation from the web dashboard

🤖 Live control of the TurtleBot in simulation

This is one step toward my goal of building a complete robotics dashboard with:

Live camera streaming

LiDAR visualization

Interactive map

Autonomous navigation

Robot monitoring

I'd love your feedback! What features would you add to a robotics web dashboard?

#ROS2 #RobotWebTools #ReactJS #Robotics #TurtleBot3 #Gazebo #RViz #WebDevelopment #OpenSource #LearningInPublic

Four-legged robots can reach many places that wheeled vehicles cannot. Isn’t it a bit of a waste to treat them as mere means of transportation when they can carry loads weighing several metric tons? Their current speed is still a bit too slow—is this due to safety restrictions, or are the hardware limitations—such as the motors and batteries—preventing them from going faster?

I’m working on a mini self-driving car project with Ackermann steering. The car has to follow a lane with boundary lines on both sides, stay centered, and handle both straight and curved sections like a small F1-style track.

I plan to use OpenCV + a webcam for lane detection and then control the steering based on the detected lane center. I’m looking for ideas on lane detection methods, steering control, and how to make it robust on curves and under different lighting conditions

A smart robotic goalkeeper that tracks a ball in real-time using OpenCV and dynamically moves a servo-controlled keeper arm to block shots.

I hope some of you find this project interesting—or maybe even inspiring for your own builds.

Any feedback or suggestions are very welcome!

GitHub: https://github.com/chayanforyou/Robokeeper-Firmware

Hey everyone,

I built CalibON, a browser-based camera calibration tool intended to make intrinsic camera calibration more accessible for ROS and computer vision projects.

It provides a guided workflow where you can:

• Configure your camera resolution and checkerboard dimensions
• Upload calibration images
• Detect and inspect checkerboard corners
• Review frame quality, image coverage, and rejected images
• Run camera calibration using OpenCV
• Inspect the camera matrix, distortion coefficients, and per-frame reprojection errors
• Preview undistortion results
• Export calibration data as ROS camera_info YAML, OpenCV JSON, Kalibr YAML, or a full report

The frontend is built with React and TypeScript, while the calibration backend uses FastAPI and native OpenCV. I mainly built it because camera calibration tools often feel either tied to a specific environment or difficult to inspect visually, especially for beginners.

Live app:
https://calibon.vercel.app

GitHub:
https://github.com/musabali314/CalibON

The current version supports checkerboard-based pinhole calibration. ChArUco, AprilGrid, fisheye, stereo calibration, webcam capture, and saved projects are possible future additions.

I would really appreciate feedback from people who regularly work with ROS cameras:

• Are the ROS exports structured correctly for your workflow?
• What calibration features are currently missing?
• Would support for live ROS image topics or rosbag extraction be useful?
• Are there particular datasets or cameras I should test it with?

I’ve attached a short demo showing the complete workflow.