How to add motion trails and afterimages in Godot 4

Motion trails — those fading ghost copies left behind a dashing character — are one

of the quickest wins for game feel. They make speed readable without any physics

changes. Here's how to build one from scratch in Godot 4, then tips for turning it

into a reusable component.

How it works

The idea is simple: every N milliseconds, take a snapshot of the character's current

sprite frame and position, then fade that snapshot out. Stack several snapshots and

you get a trail. No physics, no shaders required to start.

Step 1: the ghost scene

Create a new scene with a Sprite2D root. Name it TrailGhost. Give it this script:

class_name TrailGhost extends Sprite2D



func play(tex: Texture2D, region: Rect2, use_region: bool,

          at: Vector2, flipped_h: bool, alpha_start := 0.7,

          duration := 0.25) -> void:

    texture = tex

    region_rect = region

    region_enabled = use_region

    global_position = at

    flip_h = flipped_h

    modulate.a = alpha_start

    var t := create_tween()

    t.tween_property(self, "modulate:a", 0.0, duration) \

        .set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)

    t.tween_callback(queue_free)

This ghost reads the source sprite's current frame data, drops itself at the right

world position, and auto-destroys after fading. The region_rect copy is what makes

the snapshot land on the correct animation frame rather than the whole spritesheet.

Step 2: the trail emitter

In your character scene, add a child Node2D called Trail. Give it this script,

and export a reference to the character's AnimatedSprite2D (or Sprite2D):

extends Node2D



@export var ghost_scene: PackedScene

@export var source: AnimatedSprite2D

@export var interval := 0.04          # seconds between ghosts

@export var ghost_duration := 0.25

@export var alpha_start := 0.65



var _timer := 0.0

var _active := false



func activate() -> void:  _active = true

func deactivate() -> void: _active = false



func _process(delta: float) -> void:

    if not _active:

        return

    _timer += delta

    if _timer < interval:

        return

    _timer = 0.0

    _spawn_ghost()



func _spawn_ghost() -> void:

    if not source or not ghost_scene:

        return

    var g: TrailGhost = ghost_scene.instantiate()

    get_tree().current_scene.add_child(g)   # world-space, not parented to character

    var frames := source.sprite_frames

    var anim := source.animation

    var frame_idx := source.frame

    var tex := frames.get_frame_texture(anim, frame_idx)

    g.play(tex, Rect2(), false,

           source.global_position, source.flip_h,

           alpha_start, ghost_duration)

Adding the ghost to the scene root instead of the character means it stays at the

right world position even when the character moves. If you parent it to the character,

it follows along and the trail collapses.

Step 3: wire it to a dash

Call activate() and deactivate() around any movement where you want a trail.

A typical dash looks like this in the character script:

func _dash() -> void:

    $Trail.activate()

    var t := create_tween()

    t.tween_property(self, "velocity", dash_dir * dash_speed, 0.0)

    await get_tree().create_timer(dash_duration).timeout

    $Trail.deactivate()

For continuous speed-based trails (racing games, bullet hell), you can skip the

manual toggle and drive it from speed instead:

func _process(delta: float) -> void:

    var spd := velocity.length()

    if spd > trail_threshold:

        $Trail.activate()

    else:

        $Trail.deactivate()

Step 4: make it look good

A few small tweaks make a big difference:

Interval vs duration ratio — if interval is close to ghost_duration, ghosts

are sparse and the trail feels dotted. For a solid streak, keep interval at roughly

one-sixth of ghost_duration (e.g. 0.04s / 0.25s).

Tint the ghosts — multiply modulate by a color before calling play(). Cyan

works well for ice dashes; orange for fire. Set it on the Trail node as an export:

@export var tint := Color.WHITE



# inside _spawn_ghost(), after g.play():

g.modulate *= tint

Z-index — give TrailGhost a lower z_index than the character (e.g. -1) so

the trail sits behind the sprite, not on top of it.

Layer trails on AnimatedSprite2D frames — if your character uses a packed

spritesheet with region_enabled = true, read texture_region_rect instead of

region_rect and set region_enabled = true on the ghost. The script above leaves

a Rect2() placeholder — swap it for source.get_rect() if your frames are

packed that way.

When to pool

queue_free is fine for short dashes where you spawn 5–10 ghosts per dash. Once

you're emitting dozens per second — flying enemies, bullet patterns — the alloc

pressure adds up. A small pool (pre-spawn 20 ghosts, hide/show rather than

instantiate/free) keeps the frame time flat. The same pooling pattern from the

damage-numbers post applies directly here.

The finished trail

That's the core: a self-destructing ghost scene, a timer-driven emitter, and an

on/off signal tied to your movement logic. Tweak interval, duration, and tint per

ability and you get a different personality for every dash in the game. If you'd

rather drop in a single addon with pooling, color modes, and a one-call API already

wired up, that's exactly what Saltmire Trail handles.

If you'd rather drop this in than build it, Saltmire Trail does it as a ready-made tool: https://saltmire.itch.io/saltmire-trail

Originally published at https://saltmire.github.io/godot-4-motion-trail-afterimage.html