Products › BaseNode Packs › Motion Design 2D › Tutorial: A title sequence

A title sequence

Four seconds of broadcast title: the letters of a name fall into place in a random order and throw sparks, a line draws out under them, a tagline is typed on, a comet sweeps past with its echoes and its trail, and everything leaves again. The kind of thing you would make in After Effects with text animators, Particular and Echo, made here in Geometry Nodes, in one .bn file that grows a few lines at each step.

On a dark violet card, the words NEON NIGHTS fall into place letter by letter, turning and shrinking, sparks rising off them; a thin cyan line draws out under them and LIVE FROM GEOMETRY NODES is typed on; a white comet with a pink trail and cyan echoes sweeps past; then the words leave and the card is empty again
Where we are going: the whole sequence, which loops. Seven steps, each one a few lines more.

You will learn

This page goes faster on the basics than Lunar ground, which explains a graph, a pipe (|>), a material and the way a step file is read. Read it first if those are new to you.

Before you start

You need three things:

ModuleAfterWhat it gives
text_animateAfter Effects' text animators and range selectorsA text as one instance per letter (text_characters), a selector that reveals it by letter, word or line, forward, backward or at random (text_reveal), animate_characters about each letter's centre, typewriter, text_on_path.
particles2dFusion's particles, After Effects' ParticularEmitters (a point, a line, a circle, any shape or the outline of a text), particles_2d with speed, spread, gravity, drag and turbulence, sprites and dots that fade and grow over their life.
echoesAfter Effects' Echo, Fusion's Trailsechoes: copies of a moving element as it was a few frames before, fading and tinted; motion_trail: a curve through where it went, thinning to its tail.

Every block below is a complete .bn file, its code beside the nodes it builds. It opens on the graph the step adds or changes; the others are in the menu at the top of the block. Two ways to try a step:

Look at it from above (Numpad 7), in Material Preview, and play it from the first frame (Shift+Left, then Space): from step 5 on, the sparks and the comet are simulations, and a simulation only knows a frame it has played its way to. The animations are rendered from these exact files by render.py, which adds a dark gradient card behind the title, an orthographic camera straight above it, and a bloom in the compositor. They are rendered with EEVEE, the 96 frames of the sequence one after the other.

A letter is an instance

Everything in this tutorial rests on one choice of text_animate: a text is not one mesh but one instance per letter, each knowing its index, its word, its line and its centre. An instance can be moved, turned and scaled on its own, cheaply, before any letter is filled. So the work of a step is always the same: compute, for each letter, a number from 0 to 1 that says how far along it is, then let an animator turn that number into a move. Only at the end does text_mesh fill the letters into a mesh for the render.

1. A title, one instance per letter

text_characters writes the title with Blender's String to Curves, a curve instance for each letter, from the origin on its baseline. centred moves it so that its middle is at the origin, and text_mesh fills it.

step1_title.bn: title_sequence, centred, Title

NEON NIGHTS in warm white capitals, glowing softly, in the middle of a dark violet card
Step 1. The title at rest. Nothing moves yet.

2. Revealed letter by letter

Time comes in. SceneTime().frame is the frame being played; Clamp((frame - 6) / 36) makes it a progress that stays at 0 until frame 6, runs to 1 by frame 42 and stays there. Every animated part of this tutorial is driven this way, by a progress of its own.

step2_reveal.bn: title_sequence, Title

  1. The selector. text_reveal is After Effects' range selector: a number on each letter, 0 while it is not shown yet, 1 once it is. As progress goes from 0 to 1, it goes over the letters one after the other, by: Character, order: Forward.
  2. The softness. softness: 3.0 makes each letter take the time of three letters to come in, so that three are always on their way: a soft wave across the word instead of letters that blink on.
  3. The animator. animate_characters applies its changes by amount: 1 gives a letter all of them, 0 none. A letter not shown yet must have all of them, so amount: 1.0 - shown. Here the only change is opacity: 0.0, and no offset.
  4. The material. The animator stores opacity on each letter, and text_mesh passes it to the points of the mesh. Title now reads it with an Attribute node and mixes the light with a TransparentBSDF.
NEON NIGHTS fades in from left to right, a few letters at a time
Step 2. A wave of light from left to right, three letters wide.

3. Letters that fall into place

The same selector and the same animator, with more in it: each letter now comes from 90 cm above, turned by 40°, three times its size and transparent, and lands at rest. And the letters come in a random order.

step3_animators.bn: title_sequence

Large, turned, transparent letters drop into place one by one in a random order until NEON NIGHTS is complete
Step 3. Random order, softness 4: the letters overlap in time, as if dealt onto the card.

4. A tagline, typed on

A second line, small, widely spaced, in cyan, typed on under the title once it has landed, with a cursor that blinks after the last letter. The file now splits its work into small graphs, each with its own progress: title and tagline.

step4_typed.bn: tagline, title_sequence, title

NEON NIGHTS falls into place, then LIVE FROM GEOMETRY NODES is typed under it in small cyan capitals, a cursor blinking at its end
Step 4. The tagline is typed letter by letter, the cursor ahead of it.

5. Sparks off the letters

Particles, born on the outline of the letters as they land. title now returns the letters still as instances, so that two things can read them: text_mesh for the render, and sparks for the particles.

step5_sparks.bn: sparks, title_sequence, title, Spark

  1. The emitter. landed keeps the letters more than half shown, read from the opacity the animator stored; shape_emitter makes their outline a curve to be born on. So a letter starts to spark when it lands, not before, and the sparks follow the reveal with no time of their own.
  2. The simulation. particles_2d gives each spark a speed (speed, up to 70 % less at random), toward direction, up by default, in a fan spread wide, 90° here. Every frame, gravity pulls it (up here: a light spark rises like an ember), drag slows it, turbulence stirs it with a noise that flows. It dies after life.
  3. The sprites. particle_sprites_2d puts a small disc on each spark, stretched along its speed (stretch) so that the fast ones streak, shrinking to size_end of its size and fading over the last 60 % of its life. It stores opacity and life_factor on each one.
  4. The colour. Spark reads them from the instancer: gold at its birth, magenta at its death. A spark that changes colour as it dies reads as hot.

The simulation zone is inside particles_2d: it starts at the first frame of the scene, which is why you play the sequence from there.

As each letter of NEON NIGHTS lands, gold sparks rise from its outline, drift, turn pink and die
Step 5. 300 sparks a second off the letters that have landed, rising, stirred, gold to magenta.

6. A comet, its echoes and its trail

A moving element to cross the frame: a bright disc that sweeps in from the left under the title and out at the top right. Alone, a small disc moving fast is hard to follow; its past makes it read as motion.

step6_comet.bn: comet, title_sequence, Comet, Trail

Under the sparking title and its tagline, a white comet sweeps in from the left trailing a pink line and cyan dots, curves up past the end of the title and leaves at the top right
Step 6. The trail is continuous, the echoes are beads along it: two readings of the same past.

7. The whole sequence, in and out

The last step is timing. A line draws out under the title, the sequence holds, then everything leaves in turn and the card is empty again at frame 96, where it started: the sequence loops.

step7_final.bn: title_sequence, title, rule, ease

The full sequence: the title lands and sparks, a cyan line draws out, the tagline is typed on, the comet sweeps past, then NEON and NIGHTS grow and fade one after the other, the tagline is erased and the line draws back in
Step 7. Four seconds, from an empty card back to an empty card.

The knobs

Every module group has its inputs, on its node in the Geometry Node editor. A few to start with:

WhereInputWhat it does
text_revealby, order, seedLetter, word or line; forward, backward or at random, shuffled by the seed.
text_revealsoftnessHow many letters are on their way at once; 0 for letters that switch on.
animate_charactersoffset, rotation, scale, opacityWhere a letter comes from, how turned, how big, how transparent, about its centre.
particles_2drate, speed, spread, lifeHow many sparks a second, how fast, how wide a fan, how long they live.
particles_2dgravity, drag, turbulenceThe pull (a vector: up, down or sideways), the slowing down, the stirring.
particle_sprites_2dsize, size_end, stretchThe size at birth, the size at death as a factor of it, the streak along the speed.
echoescount, every, decay, tintHow many echoes, how many frames apart, how fast they fade, toward what colour.
motion_trailframes, radiusHow long the trail is, in frames, and how thick at its head.

Try: on step 7, set the title's order to Backward and by to Word. Set the sparks' gravity to (0.0, -2.0, 0.0): they fall like molten metal. Set every of echoes to 1 and count to 12: the beads become a smear.

To use your own title, change the two texts: centred keeps them in the middle, whatever their length. For a longer title, give text_characters a width: it wraps by words into lines, and by: Line brings them in one line at a time.

Take it to Blender

The whole sequence, in one file. Drag the card onto empty space in Blender's 3D Viewport and keep Instantiate the Example: a new object carries title_sequence. Then play it from the first frame. A click on the card downloads the file.

The steps before it, to start again from any of them:

The files, with the script that renders this page's animations, are in examples/tutorials/title_sequence/.