Low FPS (~2-3) When Running MuJoCo Simulation in LivelyBot Pi RL Baseline – Possible Causes?

[hxyair]

Intro

Hi everyone,

I'm currently trying to reproduce the HighTorque-Robotics/livelybot_pi_rl_baseline project, which involves Sim2Sim reinforcement learning for a bipedal robot using both Isaac Gym and MuJoCo.

While Isaac Gym simulations run smoothly, I’m encountering a very low frame rate (~2-3 FPS) in MuJoCo, and I’m hoping someone here can help identify the root cause.

My setup

🧪 Project Details:

• Goal: Sim2Sim RL for LivelyBot using Isaac Gym + MuJoCo
• Hardware: Laptop with NVIDIA RTX 4080 GPU
• OS: Ubuntu 20.04 (NVIDIA drivers properly installed and active)
• MuJoCo Version: 2.3.6
• Python Version: 3.8.20

💻 Simulation Observations:

• Isaac Gym: High GPU utilization, smooth performance.
• MuJoCo: ~2–3 FPS, extremely slow.
• GPU usage is negligible
• CPU usage is also low

🧪 Troubleshooting Attempts:

• Disabled matplotlib_thread → No improvement in FPS.
• Confirmed Isaac Gym works well → No hardware or PyTorch issues.
• Reduced resolution (e.g., 1280x720) → No noticeable improvement.
• MuJoCo performs well on other models
  • Running MuJoCo’s humanoid.xml reaches 1000+ FPS.
• Tested LivelyBot model (pi_12dof_release_v1.xml) independently
  • Using mj_step() manually for 5000 steps gives ~102 FPS.
  • Viewer launched with mujoco.viewer.launch_passive()

My question

❓ Questions:

1. Why does MuJoCo perform so poorly (~3 FPS) in this project compared to Isaac Gym?
2. Is there a known performance bottleneck when running MuJoCo with more complex robot models?
3. Could it be related to physics parameters, viewer settings, or model configuration?
4. Any recommended profiling tools or configuration tweaks to improve FPS in MuJoCo?

Minimal model and/or code that explain my question

import math
import numpy as np
import mujoco, mujoco_viewer
from tqdm import tqdm
from collections import deque
from scipy.spatial.transform import Rotation as R
from humanoid import LEGGED_GYM_ROOT_DIR
from humanoid.envs import PaiCfg
import torch
import threading
import glfw
import matplotlib.pyplot as plt
import time # Newly added time module
import torch
torch.backends.cudnn.benchmark = True

class cmd:
vx = 0.
vy = 0.
dyaw = 0.

class mujoco_visual:
def init(self) -> None:
self.count_lowlevel = 0
self.stop_event = threading.Event()
self.vel = [0,0,0]
self.w = [0,0,0]
# Key mapping (avoiding C/J/G/M/T/V/E in the image)
self.key_states = {
# Direction control
glfw.KEY_UP: False,
glfw.KEY_DOWN: False,
glfw.KEY_LEFT: False,
glfw.KEY_RIGHT: False,
glfw.KEY_W: False, # Added
glfw.KEY_S: False, # Added
glfw.KEY_A: False, # Added
glfw.KEY_D: False, # Added
# Image function keys (keep original)
glfw.KEY_C: False,
glfw.KEY_J: False,
glfw.KEY_G: False,
glfw.KEY_M: False,
glfw.KEY_T: False,
glfw.KEY_V: False,
glfw.KEY_E: False
}

def quaternion_to_euler_array(self, quat):
    x, y, z, w = quat
    t0 = +2.0 * (w * x + y * z)
    t1 = +1.0 - 2.0 * (x * x + y * y)
    roll_x = np.arctan2(t0, t1)
    
    t2 = +2.0 * (w * y - z * x)
    t2 = np.clip(t2, -1.0, 1.0)
    pitch_y = np.arcsin(t2)
    
    t3 = +2.0 * (w * z + x * y)
    t4 = +1.0 - 2.0 * (y * y + z * z)
    yaw_z = np.arctan2(t3, t4)
    
    return np.array([roll_x, pitch_y, yaw_z])

def get_obs(self, data):
    q = data.qpos.astype(np.double)
    dq = data.qvel.astype(np.double)
    quat = data.sensor('orientation').data[[1, 2, 3, 0]].astype(np.double)
    r = R.from_quat(quat)
    v = r.apply(data.qvel[:3], inverse=True).astype(np.double)
    self.vel = [v[0], v[1], v[2]]
    omega = data.sensor('angular-velocity').data.astype(np.double)
    self.w = omega
    gvec = r.apply(np.array([0., 0., -1.]), inverse=True).astype(np.double)
    return (q, dq, quat, v, omega, gvec)

def pd_control(self, target_q, q, kp, target_dq, dq, kd):
    return (target_q - q) * kp + (target_dq - dq) * kd

def plot_thread(self):
    plt.ion()
    fig, ax = plt.subplots()
    t, cmd_x, true_x = [], [], []
    line_cmd_x, = ax.plot(t, cmd_x, 'r-')
    line_true_x, = ax.plot(t, true_x, 'b-')

    while not self.stop_event.is_set():
        t.append(self.count_lowlevel * 0.001)
        cmd_x.append(cmd.vx)
        true_x.append(self.vel[0])
        line_cmd_x.set_xdata(t)
        line_cmd_x.set_ydata(cmd_x)
        line_true_x.set_xdata(t)
        line_true_x.set_ydata(true_x)
        ax.relim()
        ax.autoscale_view()
        plt.draw()
        plt.pause(0.001)
    plt.savefig('sine_wave.png')
    plt.ioff()
    plt.close('all')

def run_mujoco(self, policy, cfg):
    model = mujoco.MjModel.from_xml_path(cfg.sim_config.mujoco_model_path)
    model.opt.timestep = cfg.sim_config.dt
    data = mujoco.MjData(model)
    mujoco.mj_step(model, data)
    # viewer = mujoco_viewer.MujocoViewer(model, data) # Original code
    viewer = mujoco_viewer.MujocoViewer(model, data, width=1360, height=720) # Modified

    # Disable shadows and other visual effects
    # viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_SHADOW] = False
    # viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_SKYBOX] = False
    # viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_HAZE] = False
    viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_TRANSPARENT] = False

    def key_callback(window, key, scancode, action, mods):
        # Handle motion control keys
        if key in self.key_states:
            self.key_states[key] = action == glfw.PRESS
        
        # Implement visualization functions in the image (keep original)
        if key == glfw.KEY_C and action == glfw.PRESS:
            viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_CONTACTPOINT] ^= 1
        if key == glfw.KEY_J and action == glfw.PRESS:
            viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_JOINT] ^= 1
        if key == glfw.KEY_G and action == glfw.PRESS:
            viewer._graph._visible ^= 1
        if key == glfw.KEY_M and action == glfw.PRESS:
            viewer.vopt.flags[mujoco.mjtVisFlag.mjVIS_COM] ^= 1

    glfw.set_key_callback(viewer.window, key_callback)
    self.window = viewer.window

    target_q = np.zeros((cfg.env.num_actions), dtype=np.double)
    action = np.zeros((cfg.env.num_actions), dtype=np.double)

    hist_obs = deque()
    for _ in range(cfg.env.frame_stack):
        hist_obs.append(np.zeros([1, cfg.env.num_single_obs], dtype=np.double))

    for _ in tqdm(range(int(cfg.sim_config.sim_duration / cfg.sim_config.dt)), desc="Simulating..."):
        if glfw.window_should_close(self.window):
            break

        # Motion control processing (added WSAD)
        cmd.vx = 0.5 * (self.key_states[glfw.KEY_UP] or self.key_states[glfw.KEY_W])
        cmd.vx -= 0.5 * (self.key_states[glfw.KEY_DOWN] or self.key_states[glfw.KEY_S])
        cmd.vy = 0.5 * (self.key_states[glfw.KEY_A] - self.key_states[glfw.KEY_D])
        cmd.dyaw = 1.0 * (self.key_states[glfw.KEY_LEFT] - self.key_states[glfw.KEY_RIGHT])

        q, dq, quat, v, omega, gvec = self.get_obs(data)
        q = q[-cfg.env.num_actions:]
        dq = dq[-cfg.env.num_actions:]
        for i in range(6):
            q[i], q[i+6] = q[i+6], q[i]
            dq[i], dq[i+6] = dq[i+6], dq[i]

        if self.count_lowlevel % cfg.sim_config.decimation == 0:
            obs = np.zeros([1, cfg.env.num_single_obs], dtype=np.float32)
            eu_ang = self.quaternion_to_euler_array(quat)
            eu_ang[eu_ang > math.pi] -= 2 * math.pi

            obs[0, 0] = math.sin(2 * math.pi * self.count_lowlevel * cfg.sim_config.dt / 0.5)
            obs[0, 1] = math.cos(2 * math.pi * self.count_lowlevel * cfg.sim_config.dt / 0.5)
            obs[0, 2] = cmd.vx * cfg.normalization.obs_scales.lin_vel
            obs[0, 3] = cmd.vy * cfg.normalization.obs_scales.lin_vel
            obs[0, 4] = cmd.dyaw * cfg.normalization.obs_scales.ang_vel
            obs[0, 5:17] = q * cfg.normalization.obs_scales.dof_pos
            obs[0, 17:29] = dq * cfg.normalization.obs_scales.dof_vel
            obs[0, 29:41] = action
            obs[0, 41:44] = omega
            obs[0, 44:47] = eu_ang

            obs = np.clip(obs, -cfg.normalization.clip_observations, cfg.normalization.clip_observations)
            hist_obs.append(obs)
            hist_obs.popleft()

            policy_input = np.zeros([1, cfg.env.num_observations], dtype=np.float32)
            for i in range(cfg.env.frame_stack):
                policy_input[0, i * cfg.env.num_single_obs : (i + 1) * cfg.env.num_single_obs] = hist_obs[i][0, :]
            #action[:] = policy(torch.tensor(policy_input))[0].detach().numpy()

            device = next(policy.parameters()).device  # Get the device where the model is located
            policy_input_tensor = torch.tensor(policy_input).to(device)  # Move input to the same device
            print(f"policy_input_tensor device: {policy_input_tensor.device}")
            policy_output = policy(policy_input_tensor)
            # print(f"policy output device: {policy_output.device}") # Remove after debugging
            action_tensor = policy_output[0]
            action[:] = action_tensor.detach().cpu().numpy()

            action = np.clip(action, -cfg.normalization.clip_actions, cfg.normalization.clip_actions)
            target_q = action * cfg.control.action_scale

        target_dq = np.zeros((cfg.env.num_actions), dtype=np.double)
        tau = self.pd_control(target_q, q, cfg.robot_config.kps,
                        target_dq, dq, cfg.robot_config.kds)
        tau = np.clip(tau, -cfg.robot_config.tau_limit, cfg.robot_config.tau_limit)
        for i in range(6):
            tau[i], tau[i+6] = tau[i+6], tau[i]
        data.ctrl = tau
        
        mujoco.mj_step(model, data)

        # time.sleep(0.001) # For faster stepping frequency, set to 0.001; to slow down, use 0.01
        if self.count_lowlevel % cfg.sim_config.decimation == 0:
            viewer.sync()

        self.count_lowlevel += 1
        viewer.render()

    self.stop_event.set()
    viewer.close()

Confirmations

• I searched the latest documentation thoroughly before posting.
• I searched previous Issues and Discussions, I am certain this has not been raised before.