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
