DM me for more

What You'll Do

• Design and implement high-fidelity robot models (URDF/MJCF) with accurate kinematics, dynamics, and contact properties
• Build and maintain simulation environments using MuJoCo, NVIDIA Isaac Sim, and/or Gazebo
• Develop end-to-end simulation pipelines for robot training, testing, and validation
• Tune physics parameters — friction, damping, inertia, actuator models — to maximize sim-to-real transfer
• Integrate simulations with ROS2 for perception, planning, and control workflows
• Write clean, performant code in Python and/or C++ to support simulation infrastructure
• Collaborate asynchronously with robotics researchers and engineers on model accuracy and environment design
• Profile and optimize simulation performance for large-scale or parallelized runs
• Document simulation configurations, model parameters, and pipeline architecture

Requirements

• Strong hands-on experience with at least one major robotics simulator: MuJoCo, NVIDIA Isaac Sim, or Gazebo
• Proficient in Python and/or C++ in a robotics or scientific computing context
• Solid understanding of rigid-body dynamics, contact mechanics, and control theory
• Experience creating and validating robot models (URDF, MJCF, or SDF formats)
• Familiarity with ROS2 and its integration with simulation environments

Hey everyone,

I’ve been working on a custom small humanoid/bipedal robot project and I recently got my URDF successfully imported into simulation. The robot is roughly a 2-foot-tall humanoid with multiple DOF in the legs, and my long-term goal is to get it balancing and eventually walking using reinforcement learning / locomotion policies.

Right now I’m trying to understand what the actual pipeline looks like after the URDF stage. I see a lot of people showing robots walking in Isaac Sim / Isaac Lab, MuJoCo, etc., but I’m struggling to understand the practical next steps between:

Importing the URDF

Setting up joints/actuators properly

Adding sensors (IMU, contact sensors, cameras?)

Creating observations/actions

Training a locomotion policy

Transferring sim-to-real onto actual hardware

Some specific questions I have:

What should I focus on immediately after the URDF import?

How important is accurate mass/inertia tuning early on?

Do most people start with standing/balancing before attempting walking?

What controllers are typically used before RL (PID, PD, inverse kinematics, etc.)?

How do you structure observations/actions for bipeds?

What are common mistakes beginners make at this stage?

Any recommended tutorials/repos specifically for humanoid locomotion?

For context, I’m using serial bus servos and building the physical hardware alongside the simulation. I’m trying to learn the full process instead of just copying a demo.

I’d really appreciate any advice, roadmaps, or resources from people who’ve actually gone through this process. Thanks!

What You'll Do

• Design and implement high-fidelity robot models (URDF/MJCF) with accurate kinematics, dynamics, and contact properties
• Build and maintain simulation environments using MuJoCo, NVIDIA Isaac Sim, and/or Gazebo
• Develop end-to-end simulation pipelines for robot training, testing, and validation
• Tune physics parameters — friction, damping, inertia, actuator models — to maximize sim-to-real transfer
• Integrate simulations with ROS2 for perception, planning, and control workflows
• Write clean, performant code in Python and/or C++ to support simulation infrastructure
• Collaborate asynchronously with robotics researchers and engineers on model accuracy and environment design
• Profile and optimize simulation performance for large-scale or parallelized runs
• Document simulation configurations, model parameters, and pipeline architecture

Hi everyone,

I recently worked on a small project where I designed a custom robot in Fusion 360 and trained it in IsaacLab using reinforcement learning.

USDZ File

CAD File

The robot is a wheeled biped-style platform. After creating the CAD model, I converted it into a simulation-ready asset, set up the joints, and used it for stabilization and jump-recovery tasks in IsaacLab.

What I found most interesting was how much the physical design affects the learning process. Things like joint placement, link length, wheel contact, collision shapes, inertia, and actuator settings all had a noticeable impact on whether the robot could learn stable behavior.

The first task was basic stabilization, where the robot learns to maintain its posture. I also tested a jump-and-stabilize task, where the robot needs to recover after a more dynamic motion.

This made me realize that building a robot for RL is not just about making a nice-looking CAD model. The morphology, physics properties, and simulation setup are all part of the learning problem.

The workflow was roughly:

Fusion 360 → asset preparation → joint setup → IsaacLab training → policy evaluation

I’m planning to extend this robot to more tasks, including wheeled balance control, push recovery, locomotion, turning, navigation, and object interaction.

I wrote a longer post with more details about the design process and what I learned from training it in IsaacLab.

Stabilize Task

Jump & Stabilize Task

Hey everyone! I wanted to share the second demo from my IsaacLab project series.

For Project Demo 2, I trained a humanoid agent to approach a ball and shoot it toward a goal. Compared to my previous Ackermann-steering soccer agent, this task focuses more on full-body coordination, balance, and contact-rich control.

The main challenge is that the agent has to approach the ball, maintain balance, time the kick properly, and generate contact force in the goal direction without falling too early.

### What’s next?

I’m planning to extend this task to more complex soccer-style behaviors, such as:

1. dribbling before shooting,
2. shooting from different angles,
3. balance recovery after kicking,
4. staged skills like approach → stabilize → kick.

I’d love to hear any feedback or suggestions, especially on reward shaping for humanoid sports tasks.

Thanks for reading!

https://reddit.com/link/1tc4t6f/video/cadj16njlx0h1/player

Hey everyone! Just wanted to share a demo of my latest agent. I've been training an Ackermann robot in IsaacLab to track a ball and kick it into a goal.
Ackermann kinematics make this much trickier than using a simple differential drive, as the turning radius limits how the robot can approach the ball for a shot.
The Setup:
I’m using a 17-dimensional observation space to give the agent a clear "spatial awareness." Here is the breakdown of what the robot sees:

• Positional Data: rel_robot_ball and rel_ball_goal (all in robot body frame).
• Heading: I used sin/cos of the heading errors to the ball and the goal to ensure the gradients stay smooth.
• Velocities: Robot linear/angular velocities + the ball's velocity in the body frame.
• History: Including the _prev_action to encourage smoother control and prevent jitter.

What’s next for Real-world Deployment?
The goal is to get this running on a 1/10th scale RC car. To get there, I’m working on:

1. System ID: Better matching the steering lag of real servos.
2. Noise Injection: Adding sensor noise to the observations during training.
3. Visual RL: Moving away from ground truth data to using a camera-based input (likely via a Kalman Filter or a small CNN).

Would love to hear your thoughts on Reward Shaping for sports-based tasks or any tips for Sim-to-Real with Ackermann steering!

https://reddit.com/link/1t99lf0/video/sf3bww4ftb0h1/player