Skip to content
animorio
IT
Journal

Nick Ho, by BORING, Dion Ploeg

Nick Ho, how it’s made: the screen inside the number

The site of a Dutch Porsche Carrera Cup driver: a loader where the white screen is the inside of his number, a fluid that brings the colour back to the black and white photo, a car driving through the race calendar. We take it apart with three demos rebuilt from scratch.

2 October 202611 min readThe original site

The home page of Nick Ho
The home page of nickho-motorsports.nl, captured on 2 October 2026.Open the site

The palette

  • #000000the black of the dark sections
  • #FFFFFFthe white of the loader and of the 98
  • #FED60Athe yellow of the lights, the menu and the races
  • #333333the dark grey of some text

Tap a colour to copy its code.

nickho-motorsports.nl is the site of Nick Ho, a driver from Rotterdam who at 21 races in the Porsche Carrera Cup Deutschland with car number 98. It was made by the studio BORING, whose address, weareboring.nl, can also be read on the windscreen of the Porsche in the calendar, and by Dion Ploeg. It is black, white and yellow, #FED60A: black and white photos, headings in Anton, narrow and capitalised, text in Helvetica, and thin vertical lines over the background.

Underneath there is Webflow, with GSAP 3.15 (ScrollTrigger, SplitText and CustomEase), Lenis for the smooth scrolling, Three.js r128 for the opening photo, Swiper for the carousels and hls.js for a video served by Bunny Stream. The hand-written code comes from Slater: a small file that loads twenty-five others, one per effect. Without scrolling, the first load weighs 17.4 MB in 271 requests.

The site has an Awwwards Honorable Mention from 3 September 2026, but the award page shows only community votes and none from the jury: no score to report. We take it apart in three moments, with a demo rebuilt from scratch for each, for three invented brands: drawings, copy and code are ours. From the site we took the ideas and, where we say so, the numbers.

The number that was the screen

It opens on a white screen. In the middle the car’s number rolls up from 00 to 98 like an odometer, and at the bottom five small black squares turn yellow one after the other, like starting lights. Then the white shrinks and you see what it was: the inside of a giant 98, which gets smaller until it settles next to the driver, with a yellow copy chasing it.

Demo rebuilt from scratchFull-screen numberGo to the page

The 98 is an SVG 11.625 rem wide that starts scaled a hundred times and moved by 95 rem, so the whole screen falls inside a stroke of the figure. The count takes 2 seconds with expo.out. Each light comes on in 0.35 seconds, spread so that the last one is on 0.3 seconds before the count stops. After a 0.05 second pause the 98 goes back to scale 1 in 1.2 seconds with expo.inOut, the yellow copy 0.025 seconds later; meanwhile the count shrinks away in a second and the lights go out in a row, 0.2 seconds each, 0.08 apart, squeezed into half the takeover.

Underneath, the photo comes back from 1.2 to 1 in 1.6 seconds and the background lines come down from the top, in a scattered order. 0.4 seconds before the number lands, in groups 0.15 seconds apart, come the stats, which roll in 1.2 seconds, and the words, which rise from under the line in 0.8. The white 98 stays there: it is the page’s big number. Until it has landed, scrolling is held still.

In our demo the team is invented, Halcyon Motorsport, with number 27, the lights are orange and behind there is a real photo of a circuit’s straight, shot at ground level on the kerb, which as on the site zooms back and takes its colour. The giant number is not scaled with CSS: it is made of the outlines of the typeface’s digits, and the script works out its viewBox on every frame, so it stays sharp at any magnification. It finds the point to start from by itself, looking for the thickest point of the number, so the screen fits inside whatever number you choose. A button runs the start again.

Colour that clings

The opening photo is black and white: the driver in his helmet, his car, the background. Moving the mouse brings the colour back behind the pointer, like a fluid that spreads and curls, and it lasts longer on the driver than on the background.

Demo rebuilt from scratchColour that clingsGo to the page

It is a real fluid, solved in Three.js on a grid 0.4 cells per pixel wide: the pointer pushes (3 for every pixel of movement) and pours dye (0.65 per frame), vorticity (4) makes it curl, 12 pressure steps keep it from compressing, and every frame 0.906 of the velocity and 0.947 of the dye are left. The photo is in three layers, driver, car and background, each with its own depth map. Where things are near the dye fades much less, towards 0.998, the threshold to see it drops (0.66 times one minus 0.9 times the depth) and the pressure pushes the fluid aside: that is why the colour seems to cling to the driver. Meanwhile the layers shift with the pointer, by 0.015, each according to its depth.

The fluid only starts with a mouse: on phones it is the loader that takes the grey off the photos, in 1.6 seconds, and with reduced motion the photos are in colour at once. After the last move the fluid runs until even the colour on the nearest things is gone, about 14 seconds, then it stops and resets.

In our demo the opening belongs to an invented balloon festival, Highfield Balloon Week, and the picture is a real, copyright-free photograph of a striped balloon over the downs in the morning, with its depth painted over it in greys: the sky far away, the land nearer, the balloon closest of all. The fluid’s numbers are the site’s, but the fluid is written in WebGL2 without libraries, the brush fills fast strokes with several touches and on phones you paint with a finger.

The car in the calendar

Further down there is the race calendar, one race per row. When the list reaches the middle of the screen, a Porsche seen from above drives in from the top and stops in the middle, over the list; the races slide under it and the one passing under the car turns yellow.

Demo rebuilt from scratchThe car in the calendarGo to the page

The car sits in a sticky frame as tall as the screen. When the top of the section crosses the middle of the screen it drives in in 0.8 seconds with expo.out; when the end of the list crosses it, it drives off downwards in 0.8 seconds with expo.in, and only once it is gone does it turn 180 degrees. So if you scroll back up it comes in from below nose first, and leaves at the top turning round again: the car always drives the way you are reading. Every race has its own ScrollTrigger, which turns it yellow in 0.2 seconds and back to white in 0.6, and the frame drifts slowly, from -12 to 12 percentage points, while the section crosses the screen.

In our demo the calendar belongs to an invented team, Brightwater Racing, with nine invented circuits and a car drawn in SVG, white with two lime green stripes. The rules are the site’s; ours are the section cut with overflow: clip, so the car appears from the edge of the calendar and not from the section before it, and with reduced motion the car does not drive but fades out and back in.

The other details

Among the sponsors’ logos the driver’s helmet spins: it is 180 AVIF frames drawn on a canvas. On its own it turns at 24 frames per second, one turn every 7.5 seconds; scrolling speeds it up, up to 270 frames per second, and it keeps turning the way you last scrolled. The frames arrive in layers, first one in 12, then one in 6, one in 3 and all of them, and meanwhile the nearest one that has arrived is shown. The helmet grows in with a little bounce, floats 12 pixels up and down and turns towards the mouse, up to 11 degrees.

At the end of the calendar there is a chequered flag that breathes: its squares dim and come back at random, up to 16 at once, a new one every 80 to 140 milliseconds. In the driver’s story, in five chapters, the picture of the chapter crossing the middle of the screen takes its colour while the others stay grey and faint, and the 1/5 counter rolls. The track video grows while you scroll from 70% of the screen to the whole screen, the gallery is a wheel of 14 photos with a needle swinging over a scale of marks, like a rev counter, and at the opening the countdown leads to the next race in the calendar.

Where it stumbles

The weight, first of all: 17.4 MB in 271 requests without scrolling. On computers the helmet’s 180 frames, 8 MB, arrive right after the page, even though the helmet is several screens further down; on phones the site waits until you are near and takes one frame in two. The track video, much further down, loads at 1080p from the start: 7.5 MB of segments and a 0.8 MB cover image. Scrolling to the bottom you get to about 20 MB and 320 requests.

Then Three.js r128, a 2021 release, is downloaded on every device for a fluid that only runs with a mouse, and the custom code arrives in 26 separate files, each with its own request.

On the other hand reduced motion is respected almost everywhere, which is rare: no loader, no fluid, the helmet still on one frame, the flag still. And on our visits the console stayed clean.

What we take away

A loader can be a single gesture, if the white of the screen is already the number about to appear. A loud effect becomes measured when it knows what is in the photo: colour that clings to near things tells the depth without any 3D. And a car that always drives the way you read is enough to make a calendar race.

Journal