← Learn · Build · 14 November 2026 · 6 min

Made of Things: My Name Where Every Letter Turns Into Something From My Life

Type motion where each letter of my name turns into a glossy 3D thing: my laptop, a rocket for the YC startups, my coffee and a 3D emoji of me, made with Codex. Six modes (lens, pop, shuffle, wave, sticker, burst), one spring per letter, no libraries.

The output, liveavivashishta.com/lab/things
Open the live page ↗

I saw a type experiment on Threads where you run the cursor over a headline and the letters under it turn into little 3D objects: a rocket, a nerd face, a pair of headphones. I wanted my own version, with my name, where every object is something from my life. Play with it at avivashishta.com/lab/things.

It opens with the things dealing into a spinning ring around a loading counter. At 100% each one flies out of the ring into a letter of my name and turns into that letter. Then move over "Avi Vashishta" and the letters under your cursor turn back into things, with a label saying what each one has to do with me. There are no buttons on the page: press 1 to 6 to change how the letters move.

The short version: Codex makes eighteen glossy 3D emoji, one of them me (from my illustrated avatar), and macOS Vision cuts them out. Every letter is a slot holding the glyph and an image. Each slot has one number, how far it has turned, from 0 (the letter) to 1 (the thing). Each mode only sets where that number wants to go; one spring per slot gets it there, so every mode overshoots and settles the same way.

Step 1: the things (Codex)

Eighteen things across my three worlds. Build: a laptop, a rocket (the two YC startups), a robot (my AI agents), a keycap, a lightning bolt. Brand: a camera, a ring light, a mic, a phone, a heart, a clapperboard. Learn: books, a pencil, a graduation cap, a light bulb, a mug of coffee, some sparkles. And me: a 3D emoji head made from my avatar, attached as a reference image.

Subject: a 3D emoji head of the young Indian man in the attached reference image: his big curly black hair, thin black rectangular glasses, warm brown skin, a friendly confident smile. Keep his likeness (hair, glasses, face shape) but make it a cute glossy 3D emoji head, head only, no body.

Style: a premium glossy 3D emoji icon: soft rounded chunky shapes, smooth glossy plastic and soft clay materials, bright saturated colours, soft studio lighting with gentle highlights, a slight three-quarter view, one single object only, centered with generous empty margin, on a pure seamless flat white background (#ffffff), no ground shadow, no text, no logos. Square 1:1, 1024x1024.

codex exec --skip-git-repo-check -C ./raw -i avatar.png -- - < avi-smile.txt
bun scripts/prepare-things.mjs ./raw

Two things to know: -i takes several files, so put -- before the - that reads the prompt from stdin, or Codex treats it as another image. And run the jobs one at a time; parallel ones fail silently. The prepare script cuts each one out with macOS Vision (scripts/cutout.swift), trims it, and pads it into a 360px square so every thing fills the same box as a letter.

Step 2: a slot per letter

Each letter is a span with the glyph and an image stacked on top of it. Layout never changes: the thing is absolutely positioned over its letter, so nothing reflows while letters turn.

<span className={styles.slot}>
  <span className={styles.glyph}>{ch}</span>
  <img className={styles.obj} alt="" />
</span>

One requestAnimationFrame loop owns every slot. It writes transforms directly (React only renders the text once), and only when the string changed:

const g = clamp(1 - s.a, 0, 1.3);  // the letter shrinks as the thing grows
const o = Math.max(0, s.a);
glyph.style.transform = `translate3d(0,${lift}px,0) scale(${g})`;
img.style.transform = `translate3d(-50%,-50%,0) rotate(${s.rot}deg) scale(${o})`;

The clamp lets the letter grow past full size, so when a thing springs back into its letter, the letter lands slightly too big and bounces.

Step 3: six modes, one spring

Every mode just picks a target for each slot:

  • Lens: distance from the pointer, through a smoothstep. The nearest letter becomes the biggest thing and leans away from the cursor.
  • Pop: touch a letter and it turns into the next thing for 0.9 seconds.
  • Shuffle: near the pointer the things flicker like a slot machine; in a ring around them the letters scramble.
  • Wave: a sine wave travels along the name, lifting letters into things as it passes. Your pointer's side of the screen steers it.
  • Sticker: click a letter to stick a thing on it, with a die-cut white edge (four 1px drop-shadows) and a random tilt.
  • Burst: click and every nearby thing is thrown out with gravity and spin, and the letters grow back with a bounce.

Then one spring moves each slot toward its target:

s.v += ((target - s.a) * 240 - s.v * 19) * dt;  // a little underdamped
s.a += s.v * dt;

With those numbers it overshoots by about 8%, which is the whole feel. One spring for all six modes means switching mode mid-motion never jumps.

The loader and the hand-off

While the images download, they deal into a ring one by one, in step with a counter in the middle. The ring spins slowly (each item spins the other way inside it, so the things stay upright) and opens out as the count climbs. The counter follows the real downloads but never runs faster than about 1.4 seconds, so the ring still has time to deal when everything is cached.

At 100% the counter lifts away and the letters take over. Each letter finds its thing in the ring, reads where it is on screen and how big it is, and starts its own image there:

const r = ringImg.getBoundingClientRect();
s.fx = r.left + r.width / 2 - s.cx;   // offset from the letter to the ring item
s.fy = r.top + r.height / 2 - s.cy;
s.s0 = r.width / (fs * 0.94);         // the ring item's size, as a fraction of the letter's
ringItem.style.visibility = "hidden"; // the letter's copy takes its place in the same frame

Then the offset eases to zero along a small arc while the thing grows, 45ms apart left to right. Once a thing arrives, its target goes back to 0 and the spring turns it into the letter, which lands a little too big and bounces. Things nobody took shrink away. Because the letter's copy starts exactly where the ring item was, you never see the swap. If nobody moves for a few seconds after that, a ghost pointer drifts over the name so the page is never still.

The small things

  • Captions: in lens and pop, the biggest thing gets a small label underneath: "Coffee first", "Two YC startups".
  • No controls on the page. Keys 1 to 6 switch between the modes, and typing a letter sets off every matching letter, so it works from the keyboard too.
  • The longest word fits the screen: the loop measures each word and shrinks the font if one is wider than the page.
  • Preloaded and decoded before the intro, so swapping a thing is just changing the image src.

Build your own

Build a type motion page (React, no animation libraries). A big serif headline, where every letter is a span holding the glyph plus an absolutely positioned cut-out 3D object image (about 1em square) on top of it. Each letter has a value a from 0 (letter) to 1 (object) driven by a spring: v += ((target - a) * 240 - v * 19) * dt; a += v * dt. Each frame, scale the glyph by clamp(1 - a, 0, 1.3) and the object by max(0, a). Write transforms directly in one requestAnimationFrame loop.

Modes only set the target: lens (smoothstep of distance to the pointer, radius about 1em), pop (hovered letter becomes the next object for 0.9 s), shuffle (objects cycle every 90 ms near the pointer and letters scramble in a ring around it), wave (a travelling sine wave), sticker (click to toggle, white die-cut edge from drop-shadows) and burst (click throws nearby objects out with gravity and spin while the letters grow back). While the images load, deal them into a slowly spinning ring around a percentage counter. At 100%, start each letter's object at its ring item's screen position and size, hide the ring item, fly it to the letter on an eased arc, then spring it back into the letter, left to right. Show a caption under the biggest object, and let a ghost pointer wander over the text when idle.