projects

Deployment case studies

1. Apollo humanoid release integration

Context: Apollo is Apptronik’s general-purpose humanoid robot platform. My work sits in the legged controls stack, where controller behavior has to survive the transition from simulation and subsystem tests to an integrated robot operating under release pressure.

My role: I worked on whole-body MPC controller integration, state estimation, whole-body motion planning, teleoperation-related validation, and on-robot hardware debugging across the integrated stack.

Deployment constraints: Release work required fast iteration across software, hardware, application engineering, and systems teams. The main challenge was not only whether the controller worked in isolation, but whether the robot behavior remained valid when perception, teleop, hardware, and demo workflows were exercised together.

Outcome: Supported public-release integration and live demo readiness by validating controller behavior on hardware, debugging integration issues in real time, and helping de-risk customer-facing robot demonstrations.

Stack: Whole-body MPC, state estimation, C++, CasADi/codegen, robot hardware validation, Git.


2. Moonwalkers product deployment at Shift Robotics

Context: Moonwalkers are robotic mobility devices shipped to end users by Shift Robotics. The control software has to feel intuitive to first-time users while remaining reliable on deployed hardware.

Shubham at a Moonwalkers deployment demo
Moonwalkers deployment demo at CES 2024.


My role: I owned gait control and sensing software in Shift OS, including calibration/training workflows and gait sensing improvements driven by user feedback.

Deployment constraints: The product had to work across different users, walking styles, environments, demo conditions, and hardware units. Field feedback mattered because small sensing or calibration issues directly affected user trust.

Outcome: Shipped user-facing control improvements documented in the Shift OS 2.0 release notes, improved gait sensing intuitiveness through field testing, supported live demos at CES 2024 and university campuses, and helped troubleshoot deployed hardware/software issues in real time.

Stack: Classical control, estimation, sensor fusion, biomechanics, embedded systems, C/C++, Python, hardware troubleshooting.


3. Contact-aware MPC hardware validation at Flexiv Robotics

Context: During my internship at Flexiv Robotics, I worked on validating a contact-aware MPC force controller for a 7-DoF manipulator.

My role: I bridged simulation and hardware validation, connecting PyBullet-based development to a real robot control workflow through LCM communication.

Deployment constraints: Contact-rich manipulation required validating controller behavior beyond simulation, with attention to timing, force response, and consistency between the model and hardware behavior.

Outcome: Validated the controller across simulation and hardware, helping close the gap between algorithm development and robot execution.

Stack: MPC, trajectory optimization, PyBullet, LCM, C++, Python.


Research and technical projects

1. Analytical Second-Order Derivatives vs. CasADi for Whole-Body MPC (2026)

Per-call derivative cost (B2+Z1, nv=25), same quantity: analytical is 1.9× / 1.2× faster than compiled CasADi


Dynamics derivatives are ≈80% of a whole-body MPC tick (Molnar et al.'s B2+Z1, ≈59 ms). I benchmarked analytical RBD derivatives against CasADi (auto-diff + codegen) on the same code, same quantity, at the Python-binding level (no ca.Callback): analytical is faster per call and eliminates the codegen/memory wall (8.83 MB C + 1.40 GB build RAM → 0). Wiring it into the live solver is the next step.

Skills used: C++, Python, Pinocchio, CasADi, Whole-Body MPC, Rigid-Body Dynamics, Spatial Vector Algebra
Offline build cost (second-order): analytical 0, vs CasADi 8.83 MB C / 1.40 GB RAM (OOM at 32 GB heavier)
2-page technical note (PDF).

MPC (Molnar et al., RA-L): paper · code — Analytical derivatives (Singh et al.): paper · pinocchio fork — Technical note (PDF)



2. Second-Order DDP via the modRNEA contraction (2026)

SO-DDP solving a reach on the 7-DoF Franka Panda (rendered in PyBullet)
Local convergence: SO-DDP is super-linear / quadratic, while first-order FDDP is linear (a straight line on the semilog axis)


The problem. Trajectory optimization is posed as a discrete optimal control problem (OCP): over a horizon of T steps, pick the joint torques that minimize a sum of running costs plus a terminal cost, subject to the robot's nonlinear forward dynamics. For a reaching task the running cost regularizes the state and the controls, while the terminal cost drives the end-effector to a target. Differential Dynamic Programming (DDP) solves this by alternating a backward Riccati-like sweep, which builds a local feedback policy, with a forward rollout.

First vs. second order. The backward sweep needs the value-function Hessian, which contains the second derivative of the dynamics, Fxx, contracted with the value gradient. The standard solvers (iLQR / FDDP) drop this term — the Gauss–Newton approximation — so they are first-order and converge linearly. Keeping it gives full second-order DDP, which converges quadratically near the optimum; but forming Fxx is an O(n³) third-order tensor at every knot, long considered too expensive.

The modRNEA contraction. DDP only needs the Hessian contracted with the value gradient (a costate), not the full tensor. The modified-RNEA second-order algorithm computes this costate-contracted directional derivative in O(n²), with no 3D tensor. I ported it onto Pinocchio 3.2 (finite-difference verified to ~1e-6) and built a second-order solver (SolverSODDP) in Crocoddyl that injects the contracted Hessian blocks directly into the backward pass.

Quasi-Newton amortization. Even at O(n²), recomputing the second-order term every iteration costs roughly twice a first-order iteration. The quasi-Newton scheme (Singh et al., Humanoids 2023) recomputes it only every p iterations (here p = 5) and reuses the cached blocks in between, cutting the per-iteration overhead to about +25% while preserving the convergence benefit.

Results. Benchmarked on a 7-DoF iiwa reach (the same solver runs on the Franka Panda shown above). SO-DDP reaches the same optimum as FDDP but converges quadratically: to a 1e-12 stopping tolerance, FDDP needs 57 iterations while SO-DDP needs 22 (full) or 25 (quasi-Newton), running 1.6–1.85× faster in wall-clock — with the advantage widening as the problem is solved more tightly. The second-order benefit is largest on ill-conditioned problems, where the Gauss–Newton model is poorest.

Skills used: C++, Pinocchio, Crocoddyl, Differential Dynamic Programming, Spatial Vector Algebra
Iterations and wall-clock vs. stopping tolerance (7-DoF iiwa): SO-DDP and its quasi-Newton variant both beat first-order FDDP, and the gap widens at tighter tolerances

Code



3. Operational Space Control for a 7-DOF Franka Panda Arm (2026)

OSC task-space tracking with null-space posture control


A from-scratch implementation of Khatib's Operational Space Control (OSC) formulation for a 7-DOF Franka Panda arm in PyBullet. The controller features task-space PD control with feedforward acceleration, a damped pseudo-inverse for singularity robustness, and null-space posture control to prevent elbow drift. A minimum-jerk trajectory generator provides smooth reference tracking. The system mirrors a real robot control stack with a multi-rate loop: 1 kHz for OSC torque computation and physics, 200 Hz for trajectory updates, and 5 Hz for goal input. Dynamics (mass matrix, Coriolis, Jacobians) are computed via Pinocchio.

Skills used: Python, PyBullet, Pinocchio, Operational Space Control, Trajectory Optimization

Code



4. Multi-Shooting DDP optimization for a for a 7-DoF Quadruped using Quasi-Newton (2020-2023)

9-phase Double-Gait trajectory for a 7-DoF planar quadruped
Torque history for the 9-phase trajectory


Differential Dynamic Programming (DDP) is a popular technique used to generate motion for dynamic-legged robots in the recent past. However, in most cases, only the first-order partial derivatives of the underlying dynamics are used, resulting in the iLQR approach. Neglecting the second-order terms often slows down the convergence rate compared to full DDP. Multi-Shooting is another popular technique to improve robustness, especially if the dynamics are highly non-linear. In this work, we consider Multi-Shooting DDP for trajectory optimization of a bounding gait for a simplified quadruped model. As the main contribution, we develop Second-Order analytical partial derivatives of the rigid-body contact dynamics, extending our previous results for fixed/floating base models with multi-DoF joints. Finally, we show the benefits of a novel Quasi-Newton method for approximating second-order derivatives of the dynamics, leading to order-of-magnitude speedups in the convergence compared to the full DDP method.

Skills used: C++, Fortran, Optimization, Spatial Vector Algebra

Code , Paper



5. Analytical Partial Derivatives of Rigid Body Systems (2020-2023)

CPU Runtime for Floating Base Robots
CPU Runtime for serial/branched chains


An essential need for many model-based robot control algorithms is the ability to quickly and accurately compute partial derivatives of the equations of motion. State of the art approaches to this problem often use analytical methods based on the chain rule applied to existing dynamics algorithms. Although these methods are an improvement over finite differences in terms of accuracy, they are not always the most efficient. In this paper, we contribute new closed-form expressions for the first-order partial derivatives of inverse dynamics, leading to a recursive algorithm. The algorithm is benchmarked against chain-rule approaches in Fortran and against an existing algorithm from the Pinocchio library in C++. Tests consider computing the partial derivatives of inverse and forward dynamics for robots ranging from kinematic chains to humanoids and quadrupeds. Compared to the previous open-source Pinocchio implementation, our new analytical results uncover a key computational restructuring that enables efficiency gains. Speedups of up to 1.4x are reported for calculating the partial derivatives of inverse dynamics for the 50-dof Talos humanoid.

Skills used: C++, Fortran, Optimization, Spatial Vector Algebra

Code , Paper



6. Differential Dynamic Programming for Rigid Body Systems (2018-2023)

Cart-Pole System
Pendu-bot control (with only τ 1) using DDP
Pendu-bot control (with only τ 2) using DDP


Multi Shooting Differential Dynamic Programming [MDDP] algorithm is benchmarked for legged robotic models like the underactuated pendubot and the cart-pole system. Experiments are done to adjust the MDDP tuning parameters and safeguard settings for the feedback matrices B, C, and D. It is found that the safeguarding multipliers are sensitive to the problem type, and can range from 0.1 to 100,000.

Skills used: Fortran, Optimization



7. TOWR for Urban Environments (Jan-May 2021)

Modified Terrain for Right Turn


This project is aimed at simulating the behavior of quadrupeds to move in urban environments (hallways, buildings, turns, etc.) The popular TOWR (Trajectory Optimizer for Walking Robots) library is used to implement obstacle avoidance constrained motion for quadrupeds. A number of constraints are implemented on the COM and legs of the quadruped to avoid cylindrical obstacles, make sharp turns, and reach a target. Depending on the target and obstacle positions, the quadruped chooses an optimal trajectory to reach in a given time. The entire coding framework is based on the IPOPT framework written in C++.

Skills used: C++, ROS, Optimization, IPOPT

Code , Slides

8. Trust Region Method Based on Cholesky Decomposition (Aug-Dec 2019)

Second-order optimization methods often use the Levenberg-Marquardt method to decide the step length. To improve the step length selection criteria, in this project, a trust region method based on Cholesky Decomposition used for second-order optimization algorithms is implemented. In the end, suggestions on the method are mentioned to use it for high degree-of-freedom systems like legged robots. This method is key in accelerating the use of the full second-order method for optimization-based robotics.

Skills used: MATLAB, Optimization
Slides



9. Methods of Orbit Determination (Jan-May 2018)

The problem of determining the future state of a satellite based on a set of observations is formulated and analyzed. Under the effect of various forces, the orbit of the satellite is estimated for 6 days using an Extended Kalman Filter formulation and is propagated for another day to report the state information in the ECI coordinate frame at the ∆V1 epoch. A high fidelity gravity model (20x20 non-spherical model) along with lunar, solar perturbations, solar radiation pressure, etc. are included for propagating the orbit and develop the analytical expressions required in the estimation process.

Skills used: MATLAB, Estimation, Navigation, Astrodynamics
Slides

10. Collaborative Air Autonomy- System of Systems (Aug-Dec 2015)

ABM Simulation Space


The implementation of a collaborative air autonomy system of systems (SoS) on the Hoosier National Forest in Southern Indiana provides an effective means to combat fire threats. This study explores how to utilize air autonomy systems (UAVs) and ground-based systems (lookout towers and ground support vehicles) to detect forest fires more efficiently than isolated constituent systems. In order to support this analysis, an SoS was created through definition, abstraction, and implementation phases, including a research question motivated by the operational context, status quo, and barriers. The agent-based modeling (ABM) method was chosen to simulate the start and spreading of a forest fire and how the proposed systems take action against the fires. Before building the ABM of the targeted SoS, a paper model was developed to represent the real-world situation. The model was used to translate real-world behaviors into a MATLAB program. From the simulation, the two hypotheses formed were tested and a trade-space analysis was completed contrasting the response time. Performance Index) to the cost of implementation for the suggested architecture. This trade study revealed that the best balance between cost and performance was a system based on multiple watchtowers with medium ranges with UAV speed improvements as a primary investment.

Skills used: MATLAB, Agent Based Modeling, Systems-of-systems

Slides