CoreSource checked

Semi-Implicit Euler

Updates velocity before position for a more stable Euler-style physics step.

Explore relationships Open constellationBrowse atlas

Quick Facts

Compact metadata for implementation and discovery.

Category: Simulation
Difficulty: Beginner
Family: Numerical Integration
Tier: Core
Status: Verified
Review: Source Checked
Sources: 1
Formulas: 1
Relationships: 3
Code example: Not ready
Visualization: Ready
Aliases: Symplectic Euler

Overview

Semi-Implicit Euler first changes velocity from acceleration, then advances position using the updated velocity.

Core Concepts

simulated statephysical stateintegral approximationnumerical integrationstate updatetime stepnumerical stability

Quick facts

Complexity

Runtime and memory behavior at a glance.

Best

O(t)

Average

O(t)

Worst

O(t)

Space

O(1)

When to Use

Use Semi-Implicit Euler when you need to update velocity from forces.
Use it for game physics with inputs like position.
Use it when approximate behavior over time is more useful than a closed-form answer.
Use it when the Numerical Integration tradeoff is acceptable for the problem size.

When Not to Use

Avoid it when the time step, grid size, or sample count cannot support stable results.
Avoid it when the required output is not next position and velocity.

What It Does

Updates velocity from forces
Uses updated velocity to move positions

Use Cases

Game physics
Simple rigid-body simulation
Real-time motion updates

Inputs

Position
Velocity
Acceleration
Time step

Outputs

Next position and velocity

Key Formulas (1)

Semi-implicit update

velocity_next = velocity + dt · acceleration; position_next = position + dt · velocity_next

velocity_next = velocity + dt * acceleration; position_next = position + dt * velocity_next

Updates velocity before position for better stability in simple physics.

Pseudocode

1.Compute acceleration from forces
2.Add acceleration times time step to velocity
3.Add updated velocity times time step to position
4.Repeat for each step

Canonical Example

Input: position = 0, velocity = 2, time step = 0.5
Output: next simulated state
Explanation: Semi-Implicit Euler: The algorithm advances the system by applying its update rule over a small step.

Implementation Notes

Keep the input contract explicit: Position; Velocity; Acceleration; Time step.
Use this step as the implementation spine: Compute acceleration from forces.
Then preserve the next state change: Add acceleration times time step to velocity.
Track units and invariants such as mass, energy, or count where they matter.

Common Pitfalls

Semi-Implicit Euler is still simple but often more stable than Forward Euler.
Using a time step that is convenient for rendering but unstable for the simulated system.
Returning next position and velocity without handling empty, invalid, or boundary inputs.

Interactive Mechanism Walkthrough

Iterative Convergence & State Trajectory

Show velocity updating before the object moves.

Step 1 of 4: Compute acceleration from forces

velocity-position-step

Notes

Semi-Implicit Euler operates in O(t) time and O(1) space within the Numerical Integration family. Key governing relation: velocity_next = velocity + dt * acceleration; position_next = position + dt * velocity_next. Often compared with Euler Integration and Verlet Integration.