Two opposite robot-arm problems. One always has exactly one answer. The other usually has several — or none at all.
Every articulated robot arm has to solve two questions that sound almost identical but are computationally opposite. Given the angle of every joint, where does the gripper end up? That's forward kinematics — direct, mechanical, and always solvable. Given where you want the gripper to be, what joint angles get it there? That's inverse kinematics— and it's a fundamentally harder problem, because for most arms there isn't just one answer.
Picture a simple 2-link planar arm: a shoulder joint rotates the first link by angle θ1, and an elbow joint rotates the second link by angle θ2 relative to the first. Where the tip of that arm — the end-effector — ends up depends entirely on θ1, θ2, and the fixed lengths of the two links. Real industrial arms usually have 6 joints and move in 3D, and the transforms are chained using something like Denavit-Hartenberg (DH) parameters instead of simple trigonometry, but the two questions below stay exactly the same shape.
Forward kinematics only ever moves in one direction: take the known angle at joint 1, apply it to find where joint 2 sits, take the known angle at joint 2, apply it to find where the tip sits, and so on out to the end-effector. Each step is a simple, deterministic transform — plug in a number, get a number out. There is nothing to search for and nothing to guess.
Inverse kinematics runs the other direction: you know where the tip has to go, and you have to work backward to the angles that produce it. Because trigonometric functions like sine and cosine aren't one-to-one — the same reach can be achieved with the elbow bent up or bent down — the equations frequently have more than one valid root. For simple arms (2 or 3 joints) that inverse can sometimes still be written as a closed-form formula, using the law of cosines the way the elbow-up/elbow-down solutions above were derived. For arms with more joints, or joints whose axes don't line up conveniently, no closed-form formula exists at all, and the controller instead solves it iteratively — nudging a guess at the joint angles closer and closer to the target using the arm's Jacobian (a matrix of how small joint movements affect end-effector position) until the error is small enough to call it solved.
It feels like it should be — just "run the math backward" — but inverse kinematics is a fundamentally harder computational problem than forward kinematics, for three separate reasons. First, it usually doesn't have a single answer: a typical 6-DOF arm can have up to eight distinct joint-angle combinations that all place the gripper at the exact same point and orientation (elbow-up vs. elbow-down is only the simplest version of this). Second, it might have no answer at all — if the target point lies outside the arm's reachable workspace, no set of joint angles gets there, and the solver has to report failure rather than force a result. Third, beyond a few joints there is often no simple closed-form equation to solve in the first place; real controllers fall back on iterative numerical methods — commonly Jacobian inverse or pseudo-inverse techniques — that converge toward a solution step by step rather than computing it directly in one pass. Forward kinematics is a formula. Inverse kinematics is a search.
Explains why forward kinematics (joint angles → end-effector position) is a simple, always-solvable chain of transforms, while inverse kinematics (end-effector position → joint angles) is a fundamentally harder problem that frequently has multiple valid solutions, sometimes has none, and often requires iterative numerical methods rather than a direct formula.
Forward kinematics starts at the robot's fixed base and works outward, joint by joint, to the end-effector. Given the angle of every joint and the fixed geometry of every link (commonly described with Denavit-Hartenberg parameters), each joint's position and orientation is computed from the one before it using a simple transform. Because every step is a direct, deterministic calculation with no branching and no searching, forward kinematics always produces exactly one result for a given set of joint angles, and it is always solvable — there is no such thing as an "unreachable" forward-kinematics problem.
Inverse kinematics starts from a desired end-effector position and orientation and asks what joint angles produce it. Because trigonometric relationships aren't one-to-one, the same target point can often be reached by more than one combination of joint angles — the classic example being "elbow up" vs. "elbow down" on a simple arm. A typical 6-degree-of-freedom industrial arm can have as many as eight distinct valid solutions for a single reachable target. Some targets have no solution at all, because they fall outside the arm's reachable workspace (too far away, too close, or at an unreachable orientation). And for arms with more than a few joints, or non-trivial joint-axis geometry, there may be no closed-form equation at all — the controller instead solves the problem numerically, iterating on a guess using the arm's Jacobian (inverse or pseudo-inverse methods) until it converges on angles that place the tip close enough to the target.
Every motion-planning stack for an articulated robot runs forward kinematics constantly (to know where the arm currently is) and inverse kinematics whenever a new target pose is commanded (to know how to get there). Simple 2- and 3-joint arms — like SCARA robots — often use closed-form inverse kinematics because the geometry is simple enough to solve directly. Six-axis articulated arms typically rely on a mix of closed-form solutions for common wrist geometries and numerical Jacobian-based solvers for the general case, which is also why some commanded poses fail with a "no IK solution found" or "target unreachable" error rather than silently picking an answer.
Given every joint angle of a robot arm, forward kinematics computes exactly where the end-effector (gripper or tool tip) ends up in space. It's a direct calculation — chain each link's transform together, starting from the fixed base, and there is always exactly one resulting position.
Given a desired position (and often orientation) for the end-effector, inverse kinematics computes what joint angles would put it there. Unlike forward kinematics, this problem frequently has more than one valid answer, sometimes has none, and often can't be solved with a simple direct formula.
Because the trigonometric relationships that map joint angles to position aren't one-to-one. For a simple 2-link arm, the same target point can be reached with the elbow bent one way ("elbow up") or the other ("elbow down") — both place the tip at the identical (x, y). A 6-degree-of-freedom industrial arm can have as many as eight distinct joint-angle solutions for a single reachable target pose.
If the requested position and orientation lie outside the arm's reachable workspace — too far away, too close to the base, or at an angle the wrist geometry can't achieve — there is no set of joint angles that satisfies it. A well-behaved controller detects this and reports the target as unreachable rather than returning an invalid or approximate result.
It depends on the arm. Simple geometries (SCARA arms, spherical wrists on 6-axis arms) often have closed-form solutions that can be solved directly and quickly. More general or redundant arm geometries frequently have no closed-form solution, so the controller uses a numerical method instead — commonly a Jacobian inverse or damped-least-squares (pseudo-inverse) approach that iteratively refines a guess until it converges on the target.
The Jacobian is a matrix that relates small changes in joint angles to the resulting small changes in end-effector position and orientation. Numerical inverse-kinematics solvers use its inverse (or pseudo-inverse, for redundant or singular arm configurations) to repeatedly adjust a candidate set of joint angles so the end-effector moves closer to the target with each iteration, rather than solving for the angles directly in one step.
Try our Robotics & Automation Studio
More calculators, simulators, and guides for this discipline.