It isn't about accuracy. It's about whether the solver ever has to invert a stiffness matrix at all — and that single choice decides your time step, your run time, and which problems you can even attempt.
A frequent assumption is that implicit solvers are "more accurate" and explicit solvers are a lower-fidelity shortcut for when you need speed. That's backwards for the problems each one is actually built for. A car crash simulation run implicitly will grind through failed equilibrium iterations as contact status flips dozens of times per millisecond; a static bracket deflection run explicitly will technically produce an answer, eventually, after simulating far more time steps than the problem needs. The real dividing line is how each method advances the solution from one time step to the next: does it solve a system of equations that includes the next step's unknowns, or does it compute the next step directly from what is already known?
An implicit scheme (backward Euler, Newmark-beta, or a full Newton-Raphson equilibrium iteration) writes the equations of motion in terms of the unknown future state and solves that system directly — which is what makes it unconditionally stable: the time step size can be chosen for accuracy alone, not to avoid the solution blowing up. The cost is that every step requires assembling and factorizing a stiffness matrix, and for nonlinear problems, iterating that solve until it converges — and convergence itself can fail outright when contact status is changing rapidly. An explicit scheme (central difference time integration) instead computes the acceleration at the current step directly from known forces and a diagonal (lumped) mass matrix — no system of equations, no iteration, no convergence to fail. That speed per step comes at a price: the scheme is only conditionally stable, meaning the time step must stay below the Courant-Friedrichs-Lewy limit, roughly the time for a stress wave to cross the smallest element in the mesh. A model with a tiny, stiff element anywhere can force every single step in the entire simulation down to microseconds, even if nothing interesting is happening in that one small region.
Both methods can be made arbitrarily accurate by refining mesh and time step — accuracy is not the axis that separates them. The real trade is stability behavior versus per-step cost. Highly nonlinear, short-duration, high-rate events — crash, drop test, ballistic impact, explosive forming, sheet-metal stamping with severe contact and large deformation — are dominated by rapidly changing contact and extreme deformation, exactly the conditions that make implicit Newton-Raphson iterations struggle or fail to converge at all. Explicit solvers sidestep that problem entirely because they never iterate to convergence in the first place; they just march forward. Conversely, a slow, quasi-static structural problem — a bolted joint being torqued down, a bracket settling under a slowly applied load — has no meaningful wave-propagation physics to resolve, so paying the Courant-limited microsecond time step of an explicit solver for a problem that takes seconds to occur in real life would mean millions of unnecessary steps. Each method is well matched to a different regime of the same underlying physics, not to a different level of rigor.
Explains the real distinguishing feature between explicit and implicit finite element time-integration schemes — not accuracy, but whether the solver inverts a stiffness matrix at each step or marches forward from known values — and why each is matched to a different regime of structural dynamics problems.
Because implicit solvers are the default for everyday linear-static and low-rate structural analysis, and explicit solvers show up almost exclusively in crash and impact simulation marketing, engineers often absorb "implicit = precise, explicit = approximate" as a shortcut. Both are exact numerical integration schemes for the same underlying equations of motion; neither one sacrifices accuracy by design. What differs is the stability condition each scheme must satisfy and the resulting cost profile, which is what actually makes one or the other practical for a given class of problem.
Implicit integration (e.g., Newmark-beta, backward Euler, or a full nonlinear Newton-Raphson equilibrium iteration) writes the discretized equilibrium equations at the future time step and solves for the unknown displacement, velocity, and acceleration simultaneously — which requires assembling and factorizing a global stiffness matrix, and for nonlinear problems, repeating that solve iteratively until residual forces converge. This makes implicit schemes unconditionally stable for linear problems: the time step can be chosen purely to resolve the response accurately, unconstrained by a stability limit.
Explicit integration (central difference method) computes the acceleration at the current, already-known step directly from Newton's second law using a lumped (diagonal) mass matrix — a trivial, non-iterative division, not a matrix solve — then integrates forward to get the next step's velocity and displacement. No system of equations is solved and no iteration to convergence is needed, which makes each step extremely cheap. But the scheme is only conditionally stable: the time step must satisfy the Courant-Friedrichs-Lewy (CFL) condition, roughly Δt ≤ Lₑ / c, where Lₑ is the smallest element characteristic length in the mesh and c is the material's dilatational wave speed. Exceed that limit and the solution diverges numerically, regardless of the true physics.
Implicit solvers dominate linear statics, modal analysis, low-to-moderate-rate nonlinear structural problems, and most everyday FEA in tools like ANSYS Mechanical, Abaqus/Standard, and NX Nastran, because those problems have no wave-propagation time scale to resolve and benefit from large, accuracy-driven time steps. Explicit solvers (Abaqus/Explicit, LS-DYNA, ANSYS LS-DYNA, RADIOSS) dominate crash, drop test, ballistic impact, blast, and metal-forming simulation, where contact status changes constantly and deformation is extreme — conditions under which implicit Newton-Raphson iterations frequently fail to converge, while explicit marching never needs to converge in the first place. Some workflows deliberately mix the two: an implicit solve establishes a pre-stressed or pre-loaded state (like a press-fit or bolt preload), which is then handed off as the initial condition to an explicit solve for the dynamic event.
Yes, via "dynamic relaxation" or quasi-static explicit analysis — artificially speeding up the loading (or adding mass scaling/damping) so the event completes in far fewer of the tiny Courant-limited steps than the real-time event would need, while keeping inertial effects small enough not to distort the result. This is a common workaround when a problem has severe contact nonlinearity that would stall an implicit solver, even though the actual physical event is quasi-static.
Mass scaling artificially increases element mass (often only for the smallest, most restrictive elements) to raise the stable time step, since Δt scales with the square root of mass over stiffness. It trades a small, deliberately bounded increase in inertial effects for a large reduction in run time, and is a standard technique in explicit metal-forming and quasi-static simulations — but it must be checked (via kinetic-energy-to-internal-energy ratio, typically kept under a few percent) to confirm it hasn't distorted the physical result.
No — both schemes handle linear and nonlinear problems; the labels describe time integration, not nonlinearity. Implicit solvers run the vast majority of linear-static analysis by far, but also handle nonlinear statics and moderate-rate dynamics. Explicit solvers are not limited to crash — they are also the standard choice for sheet-metal stamping, forging, blast/impact, and other severe, short-duration events outside literal vehicle crash testing.
Refining a mesh (making elements smaller) reduces Lₑ in the Courant condition, which directly forces a smaller stable time step across the entire model, not just the refined region — so a locally refined mesh can inflate total run time dramatically. An implicit solve's time step is chosen for accuracy, not tied to element size, so mesh refinement there mainly adds cost through a larger, more expensive matrix to factorize each step, not through a shrinking time step.
Try our Engineering Software Studio
More calculators, simulators, and guides for this discipline.
Engineering Software Handbook (Full Access)
✨ Premium ContentA zoomable interactive reader — free preview, then unlock the full set.