The Linear Inverted Pendulum Model (LIPM) excels at providing a mathematically tractable and computationally efficient template for bipedal walking. By constraining the Center of Mass (CoM) to a horizontal plane and assuming a constant height, it linearizes the complex dynamics of a humanoid. This simplification allows for closed-form solutions and highly stable, real-time walking controllers, as famously demonstrated by Honda's ASIMO. For a CTO, this translates to deterministic, low-latency control loops on embedded hardware, where a 1 kHz update rate is easily achievable.
Difference
Linear Inverted Pendulum Model vs Spring-Loaded Inverted Pendulum Model

Introduction
A data-driven comparison of two foundational reduced-order models for humanoid gait generation, helping CTOs choose the right template for walking versus running.
The Spring-Loaded Inverted Pendulum (SLIP) model takes a fundamentally different approach by introducing a compliant leg spring, capturing the energy storage and return critical for dynamic running. Instead of constraining the CoM, it embraces the vertical oscillation and ground reaction forces observed in human and animal locomotion. This results in a model that naturally generates flight phases and passive dynamic stability. However, this fidelity comes at the cost of computational complexity, often requiring numerical integration to solve the non-linear equations of motion, which can challenge hard real-time constraints on current edge compute platforms.
The key trade-off: If your priority is achieving robust, energy-efficient walking with deterministic, low-latency control on proven hardware, choose the LIPM. If you are pushing the frontier toward highly dynamic running, jumping, and navigating rough terrain where energy recovery is paramount, you must invest in the SLIP model's complexity. Consider the LIPM for factory-floor humanoids performing pick-and-place tasks, and choose the SLIP template when your roadmap targets agile locomotion in unstructured environments.
Head-to-Head Feature Comparison
Direct comparison of key metrics and features for reduced-order gait templates.
| Metric | Linear Inverted Pendulum (LIPM) | Spring-Loaded Inverted Pendulum (SLIP) |
|---|---|---|
Primary Gait Suitability | Walking (Flat-footed, Quasi-static) | Running (Dynamic, Aperiodic) |
Center of Mass Height | Constant (Constrained to plane) | Variable (Oscillates vertically) |
Energy Storage Modeling | ||
Mathematical Complexity | Linear ODEs (Analytically solvable) | Nonlinear/Hybrid Dynamics (Numerical integration required) |
Ground Reaction Force Profile | Single continuous force vector | Impulsive stance phase + flight phase |
Stability Metric | Zero Moment Point (ZMP) / Capture Point | Apex return map / Poincaré section |
Typical Control Horizon | 1-2 steps (MPC-friendly) | 1 stride (Step-to-step feedback) |
TL;DR Summary
A quick-reference card grid comparing the core strengths and ideal use cases for the Linear Inverted Pendulum Model (LIPM) and the Spring-Loaded Inverted Pendulum (SLIP) model in humanoid gait generation.
LIPM: Computational Simplicity
Linear dynamics enable closed-form solutions: The LIPM constrains the Center of Mass (CoM) to a horizontal plane, making the equations of motion linear. This allows for direct integration and analytical solutions for the CoM trajectory.
- Real-time performance: Solving the LIPM requires minimal CPU resources, often running at >1 kHz on standard embedded hardware.
- Matters for: Quasi-static walking on flat terrain where computational overhead must be minimized for whole-body control loops.
LIPM: Mature ZMP Integration
Direct compatibility with Zero Moment Point (ZMP) stability criteria: The LIPM's simplified dynamics map cleanly to ZMP-based balance control, the most widely deployed stability framework in humanoid robotics.
- Predictable foot placement: The linear relationship between CoM state and ZMP makes generating stable footstep plans straightforward.
- Matters for: Factory-floor humanoids performing repetitive, flat-footed tasks where proven stability guarantees are prioritized over dynamic agility.
SLIP: Captures Running Dynamics
Models the spring-mass mechanics of legged locomotion: The SLIP model incorporates a compliant leg spring, accurately representing the center of mass dynamics observed in biological running and hopping.
- Passive stability in running: The SLIP model exhibits self-stabilizing behavior during the stance phase, reducing the need for active control intervention.
- Matters for: Humanoids designed for dynamic running, jumping, or traversing highly uneven terrain where ground reaction forces are dominated by spring-like leg behavior.
SLIP: Energy Efficiency for Dynamic Gaits
Exploits natural system resonance: By matching leg stiffness to the gait frequency, the SLIP model enables energy-efficient locomotion through elastic energy storage and return.
- Cost of Transport (CoT) reduction: SLIP-based controllers can achieve a lower CoT for running gaits compared to stiff-legged LIPM approaches, which dissipate more energy at heel strike.
- Matters for: Battery-powered humanoids where extending operational runtime during dynamic locomotion is a critical design requirement.
Computational and Dynamic Performance
Direct comparison of key computational and dynamic metrics for reduced-order gait templates.
| Metric | Linear Inverted Pendulum (LIPM) | Spring-Loaded Inverted Pendulum (SLIP) |
|---|---|---|
Suitable Gait Type | Walking (Quasi-static) | Running (Dynamic) |
Center of Mass Height | Constant | Oscillates |
State Variables | 2 (CoM Position, Velocity) | 4 (CoM Pos/Vel, Spring Length/Velocity) |
Solve Time (QP per step) | < 1 ms | N/A (Numerical Integration) |
Energy Efficiency Modeling | ||
Aerial Phase Support | ||
Real-Time MPC Feasibility |
When to Choose LIPM vs SLIP
Linear Inverted Pendulum Model (LIPM) for Walking
Verdict: The industry standard for flat-footed, quasi-static walking.
LIPM assumes a constant center of mass (CoM) height and massless legs, simplifying the Zero Moment Point (ZMP) calculation to a linear equation. This makes it exceptionally well-suited for Model Predictive Control (MPC) and Quadratic Programming (QP) solvers running in real-time on embedded hardware.
- Strengths: Guarantees stability for flat-ground walking; computationally cheap (solves in microseconds); directly compatible with ZMP-based balance criteria.
- Weaknesses: Cannot generate flight phases; fails on highly dynamic or uneven terrain where CoM height varies significantly.
- Use Case: Humanoid robots performing factory-floor navigation, warehouse picking, or any scenario requiring stable, energy-efficient walking on rigid surfaces.
Spring-Loaded Inverted Pendulum (SLIP) for Walking
Verdict: Overkill for standard walking; adds unnecessary complexity.
SLIP models the leg as a spring, capturing the ground reaction forces and energy storage of a compliant gait. For walking, where double-support phases dominate and vertical oscillation is minimal, the spring dynamics add computational overhead without improving stability margins.
- Strengths: Models compliance and energy return.
- Weaknesses: Non-linear dynamics require iterative solvers; harder to integrate with real-time ZMP constraints.
- Use Case: Only relevant for walking if the robot uses highly compliant, series-elastic actuators and you need to model energy storage explicitly.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Technical Deep Dive: Model Formulation and Control Integration
A technical comparison of the Linear Inverted Pendulum Model (LIPM) and the Spring-Loaded Inverted Pendulum (SLIP) model for humanoid gait template generation. We analyze which simplified model better captures center of mass dynamics for walking versus running gaits, focusing on computational tractability, dynamic fidelity, and control integration.
The Linear Inverted Pendulum Model (LIPM) is significantly more computationally efficient. LIPM constrains the center of mass (CoM) to a horizontal plane, reducing dynamics to a linear second-order differential equation solvable in microseconds. This allows Model Predictive Control (MPC) loops to run at 1kHz on embedded hardware. SLIP introduces a non-linear spring force and flight phases, requiring numerical integration of hybrid dynamics. While SLIP captures energy storage in tendons, its computational cost is 5-10x higher, making LIPM the default for real-time walking controllers on torque-limited humanoid platforms.
Verdict
A data-driven breakdown of which reduced-order model better serves dynamic locomotion versus quasi-static walking for humanoid robotics.
The Linear Inverted Pendulum Model (LIPM) excels at generating stable, real-time walking gaits on flat terrain because its constant center of mass (CoM) height constraint simplifies the Zero Moment Point (ZMP) calculation into a linear control problem. For example, the Honda ASIMO and early HRP series robots relied on LIPM-based preview control to achieve reliable, quasi-static walking with a ZMP stability margin, typically achieving control loop rates exceeding 1 kHz on embedded hardware due to the model's low computational cost.
The Spring-Loaded Inverted Pendulum (SLIP) Model takes a fundamentally different approach by storing and releasing energy through a virtual leg spring. This captures the center of mass dynamics of running, hopping, and highly dynamic maneuvers that LIPM cannot represent. The SLIP model naturally predicts the ground reaction force profiles observed in human running, but its non-linear, hybrid dynamics require more complex event-based controllers and state estimation, often resulting in a 2-3x increase in computational load per step compared to LIPM.
The key trade-off: If your priority is deterministic, real-time walking with strict safety guarantees in structured environments like factories, choose the LIPM. Its linearity enables formal stability proofs and fast Model Predictive Control (MPC) solvers. If you prioritize dynamic agility, energy-efficient running, or rough-terrain locomotion, choose the SLIP model. It provides the essential template for compliant leg behavior and energy recycling, though it demands a more sophisticated whole-body controller to manage the resulting underactuated dynamics.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us