Graph Editor & Easing — Use the Graph Editor to adjust...

SECTION 1

Historical Context & Motivation

Long before digital tools existed, animators understood that movement in life is rarely uniform. A bouncing ball does not travel at the same speed at every point in its arc; it accelerates under gravity and decelerates at the peak. In traditional hand-drawn animation, artists at studios like Disney developed the principle of slow in and slow out — the practice of adding more drawings near the beginning and end of a motion to simulate natural acceleration and deceleration. This principle, codified by Frank Thomas and Ollie Johnston in their landmark text The Illusion of Life (1981), became one of the twelve principles of animation that still govern motion design today.

When computer animation emerged, engineers needed a mathematical method to replicate this expressive control over timing. The solution arrived through spline interpolation — using smooth mathematical curves to define how a property changes between keyframes. Blender's Graph Editor is the workspace where you directly manipulate these curves, giving you fine-grained control over the velocity, timing, and feel of every animated property.

1981

The Twelve Principles Published

Frank Thomas and Ollie Johnston codify decades of Disney animation craft, including slow in and slow out, establishing the artistic foundation for easing.

1987

Bézier Curves in Animation Software

Early 3D packages adopt Pierre Bézier's parametric curves as the standard representation for animation splines, enabling intuitive handle-based editing of motion timing.

1998

Blender's Initial Public Release

Blender emerges as a commercial tool (later open-sourced in 2002) with an IPO Curve Editor — the precursor to the modern Graph Editor — allowing artists to visualize and sculpt interpolation curves.

2011

Blender 2.5+ F-Curve Overhaul

Blender's animation system is redesigned around F-Curves (function curves), providing a modern Graph Editor with Bézier handles, interpolation modes, and channel-based organization.

2023

Modern Easing Presets & Procedural Workflows

Blender 3.x+ includes built-in easing presets (ease-in, ease-out, elastic, bounce), noise modifiers, and driver-based procedural curves — tools that reflect decades of animation research.

The central question the Graph Editor addresses is deceptively simple: how does a value change between two keyframes? Without it, you are limited to the default interpolation Blender assigns, which may produce robotic or lifeless motion. The Graph Editor transforms you from someone who merely sets keyframes into an animator who sculpts the soul of movement.

SECTION 2

Core Principles & Definitions

Before diving into the Graph Editor interface, you need a solid grasp of the vocabulary and concepts that underpin animation curves. Every animated property in Blender — position, rotation, scale, color, influence — is stored as an F-Curve (function curve). An F-Curve is a two-dimensional graph where the horizontal axis represents time (in frames) and the vertical axis represents the property value. The shape of this curve dictates exactly how the property transitions from one keyframe to the next.

Keyframe

A point on the F-Curve that locks a specific value at a specific frame. Keyframes are the anchors between which Blender interpolates (calculates in-between values).

Interpolation

The method Blender uses to compute values between keyframes. Bézier (smooth curves), Linear (straight lines), and Constant (stepped holds) are the three primary modes.

Easing

The rate at which a value accelerates or decelerates as it transitions between keyframes. Ease In starts slow and speeds up; Ease Out starts fast and slows down.

Bézier Handles

Control arms attached to each keyframe point on a Bézier F-Curve. By adjusting handle length (controls timing/speed) and angle (controls trajectory), you reshape the interpolation curve.

Handle Types

Blender provides several handle modes: Auto (smooth automatic), Aligned (co-linear pair), Free (fully independent), and Vector (point toward neighboring keys).

✦ KEY TAKEAWAY

Think of an F-Curve like a musical score for motion. Each keyframe is a note, but the curve between notes determines the phrasing — whether a gesture crescendos suddenly or glides gracefully. A pianist who only plays notes without dynamics sounds mechanical; an animator who only sets keyframes without shaping curves produces robotic movement. The Graph Editor is your dynamic marking system — it is where you add the crescendos, ritardandos, and staccatos to your animation.

SECTION 3

Visual Explanation — Anatomy of the Graph Editor

The following diagram illustrates the essential components of Blender's Graph Editor. The horizontal axis shows frames (time), and the vertical axis shows the animated property value. Two keyframes are connected by a Bézier F-Curve, with handles extending from each keyframe that control the shape and therefore the easing of the interpolation. Notice how the slope of the curve at any point represents the velocity of the change: a steep slope means rapid change, a flat slope means the value is barely moving.

Anatomy of an F-Curve in the Graph Editor. The purple keyframe (A) and cyan keyframe (B) are connected by a Bézier curve. The amber handle controls how the value departs keyframe A, while the green handle controls how it arrives at keyframe B. This particular curve shape produces an ease-in, ease-out motion.

In the diagram above, observe that the curve leaves Keyframe A with a nearly horizontal trajectory — the flat slope means the value changes slowly at first, producing an ease-in effect. As the curve steepens in the middle section, the value changes rapidly. Then as it approaches Keyframe B, the curve flattens again, creating an ease-out. This combined pattern — the classic S-curve — is the most common easing shape in animation because it mimics the way physical objects accelerate and decelerate under real forces. By dragging the handles longer or shorter, or tilting them, you reshape this curve and fundamentally alter how the motion feels.

SECTION 4

Mathematical Framework — Bézier Interpolation

Blender's default interpolation mode uses cubic Bézier curves to compute values between keyframes. Understanding the underlying mathematics is not strictly required to animate, but it provides a conceptual framework that helps you predict how handle adjustments will affect the curve — much the way understanding color theory deepens a painter's intuition even when mixing pigments intuitively.

CUBIC BÉZIER FORMULA

B(t) = (1 − t)³·P₀ + 3(1 − t)²·t·P₁ + 3(1 − t)·t²·P₂ + t³·P₃

Where t ∈ [0, 1] is the parameter along the curve; P₀ is the starting keyframe; P₃ is the ending keyframe; P₁ and P₂ are the control points (the tips of the Bézier handles extending from each keyframe).

The key insight is that P₁ and P₂ never lie on the curve itself — they act as gravitational attractors that pull the curve toward them. When you drag a handle in the Graph Editor, you are repositioning one of these control points. A longer handle pulls the curve more forcefully in that direction, which translates to a longer period of slow change (more easing). A short handle produces a sharper transition.

VELOCITY (FIRST DERIVATIVE)

B′(t) = 3(1 − t)²·(P₁ − P₀) + 6(1 − t)·t·(P₂ − P₁) + 3t²·(P₃ − P₂)

The first derivative gives the tangent at any point, which in animation terms represents the instantaneous rate of change (velocity) of the animated property. When B′(t) is near zero, the value changes slowly — this is where you see the easing effect visually as a flat segment of the curve.

LINEAR INTERPOLATION (LERP)

V(t) = (1 − t)·A + t·B

For comparison, linear interpolation produces a straight line between values A and B. The velocity B′(t) is constant — no easing occurs. This creates mechanical, uniform motion often useful for technical animations but unsuitable for organic movement.

📐 Why Handles Matter Geometrically

When both handles at a keyframe are horizontal (parallel to the time axis), the curve's slope is zero at that keyframe — meaning the value momentarily stops changing. This is the geometrical reason why horizontal handles produce easing. Tilting a handle upward steepens the departure, making the value accelerate immediately. Tilting it downward can even cause the value to briefly overshoot — useful for bounce or anticipation effects.

SECTION 5

Interpolation & Easing Types in Blender

Blender provides multiple interpolation modes and easing presets accessible through the Graph Editor. Each produces a distinct curve shape and, consequently, a different quality of motion. The following diagram compares the three fundamental interpolation modes side by side, while the table below catalogs the full range of options available to you.

Comparison of Blender's three primary interpolation modes. Bézier produces the smoothest motion with natural easing. Linear creates uniform, mechanical motion. Constant holds the first value until the next keyframe, useful for on/off switches or frame-by-frame style animation.

Blender's interpolation modes and easing presets with recommended use cases

Interpolation / Easing	Curve Shape	Best Used For
Bézier	Smooth S-curve with adjustable handles	Most character and organic animation; default choice for natural motion
Linear	Straight line, constant slope	Mechanical motion (conveyors, clocks), technical visualizations, procedural rigs
Constant	Flat hold, instantaneous jump	On/off toggles, visibility switches, frame-by-frame (pose-to-pose) blocking
Ease In (Quad / Cubic / Quart)	Slow start, fast finish; power-curve shape	Object falling under gravity, character starting to run, fade-in
Ease Out (Quad / Cubic / Quart)	Fast start, slow finish	Settling after impact, throwing an object, menu slide-in
Bounce	Oscillating curve with diminishing peaks	Ball bouncing, UI element landing with rebound
Elastic	Overshooting sinusoidal decay	Springy, rubbery motion; cartoon squash-and-stretch
Back	Slight overshoot past target, then settle	Anticipation before action, door swinging past rest position

SECTION 6

Worked Example — Creating a Bouncing Ball Ease

The following walkthrough demonstrates how to use the Graph Editor to transform a stiff, linear bouncing ball into one with convincing weight and energy loss. We will work with the Z-location channel (vertical position) of a sphere that has keyframes at the top of each bounce arc and at each ground contact.

Sculpting a Bounce Curve in the Graph Editor

Step 1 — Set Initial KeyframesPlace the ball at Z = 5 on frame 1 (top of drop), Z = 0 on frame 12 (ground contact), Z = 3 on frame 22 (first bounce peak), Z = 0 on frame 30 (second contact), and Z = 1.5 on frame 36 (second bounce peak). Press I → Location at each position. At this stage, the default Bézier interpolation creates a smooth, floaty curve that does not look like a real bounce.

5 keyframes set with default Bézier interpolation on the Z-location channel.

Step 2 — Open the Graph EditorSwitch an editor panel to the Graph Editor (via the editor type dropdown or by splitting a panel and choosing Graph Editor). In the left sidebar channel list, click on Z Location to isolate that curve. Press Home to fit the entire curve in view.

The Z-location F-Curve is visible, showing a wavy S-curve that floats unrealistically.

Step 3 — Sharpen Ground ContactsSelect the keyframe at frame 12 (first ground contact, Z = 0). Press V and choose Vector handles. This forces the handles to point directly at the neighboring keyframes, creating a sharp V-shape at the contact point — exactly what a rigid ball impact looks like. Repeat for the keyframe at frame 30.

Ground contacts now show sharp V-shaped cusps, indicating instantaneous direction change (impact).

Step 4 — Ease Out at PeaksSelect the keyframe at frame 1 (initial drop position). The handles should be Auto or Aligned, producing a smooth curve. Ensure the outgoing handle is nearly horizontal — this creates an ease-out at the peak, simulating the moment where the ball decelerates before falling. Adjust the peaks at frames 22 and 36 similarly: flatten the handles so the ball lingers briefly at the top of each arc.

Each bounce peak shows a rounded, flat-topped curve — the ball decelerates naturally at the apex.

Step 5 — Verify with PlaybackPress Space to play the animation in the 3D Viewport. The ball should accelerate downward (steep curve segment approaching ground), impact sharply (V-shaped cusp), and decelerate as it rises (flattening curve at peak). If the second bounce still feels too energetic, select its peak keyframe and drag it downward (reducing the Z value) or shorten the horizontal span (fewer frames) to convey energy loss. Each subsequent bounce should be shorter in both height and duration.

A physically convincing bounce with proper easing: ease-out at peaks, sharp impacts at ground, diminishing amplitude.

SECTION 7

Strengths, Limitations & Workflow Tips

The Graph Editor is an extraordinarily powerful tool, but like any instrument, it has contexts where it excels and situations where other approaches may be more appropriate. Understanding these trade-offs will help you develop an efficient animation workflow.

Evaluating the Graph Editor's role in an animation pipeline

Strengths	Limitations
Precise, frame-level control over every animated property's timing and velocity.	Can become overwhelming with complex rigs (hundreds of channels); requires careful channel management and filtering.
Visual feedback: the curve shape directly communicates the character of the motion before you even play the animation.	Handle adjustments can be non-intuitive for beginners — small changes to handles can produce unexpectedly large motion differences.
Easing presets and handle types accelerate common tasks (bounces, elastic, back) without manual curve sculpting.	Easing presets are per-keyframe; applying consistent easing across many keyframes requires batch operations or scripting.
Supports modifiers (Noise, Cycles, Stepped) that procedurally alter curves — powerful for secondary motion and loops.	Does not replace good keyframe planning; sculpting bad poses into smooth curves still yields unconvincing animation.
Non-destructive: you can always revert handle types, re-key, or add keyframes without losing existing work.	Quaternion rotations display as four separate channels (W, X, Y, Z), which can be confusing; Euler rotations are more Graph-Editor-friendly.

🔧 WORKFLOW INSIGHT

Professional animators often follow a two-pass workflow: first, block in poses using Constant interpolation in the Dope Sheet (so you can evaluate timing without distraction from interpolation artifacts), then switch to Bézier and refine curves in the Graph Editor. This separation — like sketching composition before rendering detail in painting — ensures that strong poses and timing are established before you invest effort in polish.

SECTION 8

Connections to Advanced Animation Theory

The Graph Editor's F-Curves serve as the bridge between fundamental keyframe animation and more advanced techniques. As you progress, you will encounter tools that build directly on the interpolation concepts covered here, extending them into procedural, physics-driven, and non-linear workflows.

How Graph Editor fundamentals connect to advanced Blender animation workflows

Graph Editor Concept	Advanced Extension	What It Adds
Bézier handles (manual easing)	Drivers	Automate one property based on another's value using expressions; the driven curve replaces manual keyframing entirely.
Easing presets (bounce, elastic)	Physics simulations	Rigid body, cloth, and fluid simulations generate F-Curves procedurally based on physical forces — true physics rather than approximated easing.
F-Curve Noise modifier	Procedural animation (Geometry Nodes)	Noise-driven motion becomes node-based, enabling complex emergent behaviors like crowd simulation and generative motion graphics.
Single action / timeline	Non-Linear Animation (NLA Editor)	F-Curve segments are packaged as reusable Action strips that can be blended, layered, and sequenced non-destructively.
Manual keyframe spacing	Motion capture retargeting	Imported mocap data appears as dense F-Curves; the Graph Editor is used to clean, smooth, and exaggerate captured motion.

One particularly useful advanced feature accessible directly within the Graph Editor is the Cycles modifier. By adding a Cycles modifier to an F-Curve (via the Modifiers panel in the sidebar), you can make a segment of animation repeat infinitely without duplicating keyframes. Combined with easing on the source keyframes, this creates seamless looping animations — walking cycles, pulsing glows, or oscillating pendulums — with minimal manual work. The Graph Editor thus functions not only as a polishing tool but as a generative design environment where curves, modifiers, and drivers interact to produce complex motion from simple inputs.

SECTION 9

Practice Problems

PROBLEM 1 — CONCEPTUAL

In the Graph Editor, you observe that the F-Curve for an object's X-location is a perfectly straight diagonal line between two keyframes. Describe the quality of the resulting motion and explain which interpolation mode is active. How would the motion change if you switched to Bézier interpolation with auto handles?

PROBLEM 2 — BASIC CALCULATION

A cube's Z-location has keyframes at frame 1 (value = 0) and frame 25 (value = 10) with Linear interpolation. What is the cube's Z-location at frame 13? Now suppose you add a third keyframe at frame 13 with value 10 and switch all segments to Linear — describe the resulting motion qualitatively.

PROBLEM 3 — INTERMEDIATE

You are animating a door swinging open from 0° to 90° rotation over 30 frames. The door should start slowly (as if pushed gently), reach maximum speed around frame 15, and overshoot to approximately 95° before settling back to 90° by frame 40. Describe which handle types and easing strategies you would apply to achieve this in the Graph Editor, and indicate whether you need additional keyframes.

PROBLEM 4 — APPLIED

You are creating a motion graphics title sequence where text flies in from the right side of the screen and settles at center. The creative brief specifies the motion should feel 'snappy and modern.' In the Graph Editor, the X-location curve currently shows a standard Bézier ease-in / ease-out S-curve. What specific handle adjustments would you make to achieve a snappy feel, and what easing preset might serve as a starting point? Explain your reasoning in terms of velocity profile.

PROBLEM 5 — CRITICAL THINKING

An animation of a character jumping shows smooth, well-eased curves in the Graph Editor, yet the motion still looks 'floaty' and unconvincing during playback. Propose at least three possible causes that are not related to interpolation mode or handle shape, and for each, explain how you might use the Graph Editor (or related tools) to diagnose and address the issue.

SUMMARY

Summary

Blender's Graph Editor is the workspace where you sculpt the timing and feel of animation by directly manipulating F-Curves — function curves that plot an animated property's value over time. Every animated channel uses one of three fundamental interpolation modes: Bézier (smooth curves with adjustable handles), Linear (constant velocity), and Constant (stepped holds). Easing — the controlled acceleration and deceleration at keyframes — is achieved by adjusting Bézier handles (length controls how much easing, angle controls trajectory) or by selecting built-in easing presets like Quad, Cubic, Bounce, Elastic, and Back.

The underlying mathematics of cubic Bézier curves shows that handle control points act as attractors that shape the curve without lying on it, and that the curve's slope at any point equals the instantaneous velocity of change — flat slopes mean slow change (easing), steep slopes mean rapid change. Mastering the Graph Editor transforms your animation from rigid, keyframe-to-keyframe motion into expressive, weighted, and emotionally resonant movement, connecting directly to the traditional animation principle of slow in and slow out and opening the door to advanced tools like Drivers, F-Curve modifiers, and the NLA Editor.