---

name: horizontal-scroll-scenes description: Build scene-by-scene chapters that advance left to right on one fixed stage while the user scrolls vertically, with native scroll as the only input. One pure function turns scrollY into scene, dwell and move, so forward, reverse, scrollbar drags, fast skips and reload at depth all land on the right frame. Covers dwell versus transition budgets, a burn-wipe or pan between scenes, chapter index and progress UI, glide-to-scene links that skip intermediate scenes, keyboard and reduced-motion behaviour. Use for horizontal scrollytelling, multi-scene product tours, "scroll down to travel sideways", chapter carousels driven by the wheel, or any piece where a wheel-jacked slider keeps breaking on touch, keys, refresh or back.

Horizontal Scroll Scenes

The mechanism: scroll position is the only state. One pure function turns scrollY / (scrollHeight - innerHeight) into {scene, dwell 0→1, move 0→1} every frame, and everything on screen (camera, wipe line, craft clock, text, index) is written from that triple. Nothing remembers where you were, so every beat is a place on the page.

This is what Kibori does, and it is not a translateX slider. Verified by running it: the page is a 1742vh native-scroll track (15,678 px at 1440×900); a fixed stage holds one WebGL world whose camera travels 0 → 49.7 world units left to right through eight stations; between stations a ragged burn line wipes from a frozen frame of the scene being left to the live scene already framed on the next. There is no wheel handler, no snap, no stored "current chapter". Reload at depth, scrollbar drag and anchor jumps work because state is derived, not accumulated.

Reach for scroll-world-storytelling or build-threejs-scroll-worlds for the story and 3D-world side, gsap-scrolltrigger-storytelling for pinned sticky sections, scroll-progress-timeline for a progress line. Reach for this when the deliverable is discrete chapters with a resting beat each, laid along an X axis, and the hard part is making that state machine survive reverse, skip and refresh. The demo is Vanilla JavaScript + DOM/CSS + inline SVG; the source is three.js. The state machine is identical.

The pace: two weights and a track height

Every number lives in DWELL, MOVE and the track height. One unit is one screen of scrolling.

constant	value	meaning
DWELL	1.15	scroll spent inside a scene while its craft advances (about 1,030 px at 900 tall)
MOVE	0.85	scroll spent crossing to the next scene (about 760 px); the last scene has none
CYC	2.00	one scene per two screens
SPAN	N*DWELL + (N-1)*MOVE	8 scenes: 15.15 plus a 1.35 footer = 16.5; demo, 5 scenes: 9.15
track	(SPAN + 1) * 100vh	so 1 unit ≈ 1 screen; Kibori is 1742vh for 16.5

function travel(sp){                              // sp = scrollY / (scrollHeight - innerHeight)
  const u  = Math.min(SPAN - 1e-5, sp*SPAN);
  const i  = Math.min(N - 1, Math.floor(u/CYC));
  const local = u - i*CYC;
  const dw = Math.min(1, local/DWELL);                        // the scene's own clock
  const f  = i >= N-1 ? 0 : clamp01((local - DWELL)/MOVE);    // the move
  const rc = clamp01((f - 0.01)/0.97);                        // the line's own clock
  return {i, u, dw, f, fe: sstep(0,1,f), L: -0.08 + 1.24*rc,  // L: line, off-frame at both ends
          live: Math.min(N-1, f < 0.39 ? i : i+1)};           // what the index shows
}

Normalise by scrollHeight - innerHeight, never a hard-coded pixel height: a phone's collapsing URL bar changes innerHeight mid-scroll and a px map drifts.

Rules, each with the failure it prevents

1. Derive, do not accumulate. Never keep currentScene or add wheel deltas. Stored state desyncs on scrollbar drag, Home/End, anchor jumps, back-forward and refresh. Prove it: record a signature of every visible style at 20 u values going forward, then again in reverse, then by jumping straight to each, then after reload() at three depths. All must be equal (the demo run: 0 mismatches of 21, 0 skip, 0 reload).
2. No wheel hijack, no scroll-snap. Hijacking breaks touch, trackpad momentum, Space/PageDown and find-in-page. Snap fights the dwell, which is already the resting plateau (1.15 screens where nothing moves but the craft). Native scrolling stays 1:1: 2,000 px of wheel gave exactly u = 2000/(scrollHeight - vh)*SPAN.
3. Pin the craft clock outside its dwell. Scene k's progress is 1 if k < i, dw if k == i, 0 after. Then nothing snaps back behind you and reverse retraces exactly. Write it as --p{k} and eased --e{k} custom properties on the stage; both world copies read them, so it is one write per frame.
4. A move with nothing moving is dead scroll. Start the line at the frame's edge almost at once (rc = (f-0.01)/0.97); starting it further off made the first eighth of every move do nothing.
5. The wipe hides the camera. Freeze the outgoing frame ahead of the line and have the live world already standing on the destination behind it. A camera still travelling under the line reads as a double exposure. Demo: layer A at camera i clipped to the far side of the line, layer B at i+1 clipped to the near side. Pan mode (translateX(-(i+fe)/N*100%)) is the alternative when no wipe is wanted.
6. The line writes the next chapter in. Alternate sweep direction from the side the incoming words sit on. Mask outgoing text linear-gradient(a, transparent (L-.01)%, #000 (L+.016)%) and incoming #000 (L-.062)%, transparent (L-.048)%, with a = 90deg or 270deg. Two chapters never share a patch of frame. On a phone both sit in one slot: hide the incoming until the line has cleared, sstep(1.00, 1.14, L).
7. The index flips at f < 0.39, not 0.5. At the midpoint the incoming title is already half written; flipping late labels the wrong scene. Fade the inactive rows to 0.55, not 0.
8. Chapter clocks overlap on purpose. Arrival starts MOVE*0.80 before the scene's home and finishes DWELL*0.62 into it; departure starts at DWELL + MOVE*0.28 and takes MOVE*0.34. Each part (eyebrow, title, lede, numbers) takes its own slice of arrive (0, .12, .40, .60 plus a 0.30 ramp).
9. Fast-skip plays only the last move. More than one scene away: roll smoke in over 380 ms, scrollTo the station before the target ((tgt-1)*CYC + DWELL*0.96 going forward, (tgt+1)*CYC + 0.02 going back), then play the final move for 2,600 ms with 1-(1-x)^2.4 as the veil lifts over the first 24%. Hide the scene it passes through, or its words flash. Land at tgt*CYC + DWELL*0.80 so the target is assembled. One scene away or fewer: plain leg of clamp(700 + |dy|/vh*150, 900, 2400) ms with cubic in-out. Without this a jump from 1 to 8 strobes six fires.
10. Any wheel, touch or nav key cancels the glide. Otherwise the page fights the hand.
11. html{scroll-behavior:smooth} breaks both the glide and every capture. Per-frame scrollTo chases itself; playwright screenshots land mid-scroll and look like overlap bugs. Set auto.
12. Hidden chapters are visibility:hidden plus inert. Opacity 0 alone leaves invisible links focusable and readable to screen readers.
13. Render on scroll, resize, pageshow, load and fonts.ready. Reload restores scroll after first paint; a bfcache restore fires no scroll event. Guard a zero-size stage and size from a ResizeObserver.
14. Duplicate worlds need unique SVG ids. Two copies sharing a clipPath id resolve url(#id) to the first one only.
15. Announce committed changes only. A polite live region says "Scene 4 of 5: Yakisugi" once when a glide lands, not on every threshold crossed on the way.

Accessibility and lifecycle

• Index rows are real links with aria-current="step" and a visible 1 px outline at 5 px offset; brand link returns to scene 1. The stage is position:fixed above a plain-height track so Space, arrows, PageDown, Home and End scroll natively.
• prefers-reduced-motion: reduce: no line, no travel. Scene B cross-fades over f 0.30 → 0.70, the incoming chapter waits until f = 0.64, glides are an instant scrollTo, and the craft still advances with scroll (that is the user's own input). Controls stay live.
• document.hidden: settle any glide at its target so a resumed tab does not integrate the pause.
• Mobile: keep the index to the current row (03 / 05 Kigumi), stack the chapter at the foot and the work above it.

Cost, measured

The state machine is free: render() sits at the 0.1 ms timer floor (p50 0, p90 0.1) over a 400-step sweep, and 8.3 ms p50 (120 Hz cap) with 9.2 ms max during a 2.6 s glide in the demo. The cost is whatever the scenes draw. In Kibori a dwell frame was slower than a transition until a 4096² shadow map stopped redrawing every frame, and a scissored live scene did the rest; see the kibori-60fps notes. Never spend effort optimising travel().

Failure signatures

you see	cause
reload lands on scene 1	state kept in JS; derive from scrollY and render on load/pageshow
scene "sticks" between two beats	snap or wheel capture; delete it
two rooms overlap under the line	camera still travelling under the wipe
index shows the old scene as the title lands	flip threshold at 0.5 instead of 0.39
jump link strobes several scenes	glide plays every move instead of the last
jump link overshoots or stutters	scroll-behavior:smooth on html
second scene's clip does nothing	duplicated SVG id
screen reader reads chapters that are not on screen	opacity 0 without inert
phone shows two titles spliced at the line	incoming chapter not held back until the line clears

Provenance

Extracted from KIBORI 木彫, an eight-craft Kyoto woodshop page in one three.js file (kibori.html, travel() and the glide block near the end of its module script). Demo staged in that page's dark-and-ember look with five hand-drawn SVG crafts.