# Pattern library Section-by-section landing page patterns - navigation, hero, features, social proof, CTA, footer, and scroll motion - with the recommended default of each in full. Proven structures for each landing page section. Pick sections within the [composition budget](/design/overview#the-composition-budget), choose **after** committing to a [Direction](/design/direction), then adapt each pattern's content and visual tokens to serve it. The pattern is the structure; your Direction is the soul. Labels such as `N1`, `H1`, and `F1` are stable identifiers — use them when discussing or reviewing a composition. Snippets assume placement in `src/pages/index.tsx`; adjust relative imports if you extract components. ## How patterns integrate with the scaffold * **Clean primitives** you can import from `src/components/landing/primitives.tsx`: `Typewriter`, `ScrollReveal`, `StaggerContainer`, `staggerChild`, `AnimatedStat`, `cn`, `motion`, `AnimatePresence`, `useInView`, `ChevronDown`. * `GlassCard`, `PlaceholderImage`, `BrowserMockup`, and `SectionHeading` contain known [gate](/design/anti-ai-gate) violations. Prefer inline semantic surfaces, or repair `primitives.tsx`. * **CTA routing:** CTAs navigate to `/home`, which is public in the scaffold. Target a route under `(app)/(protected)/` when sign-in should be required. No "landing seen" storage flag exists. ## Universal rules * Use semantic tokens; replace every `TODO`; use icons or inline SVG rather than pictograph emoji. * Wrap the tree in ``; manually gate scroll transforms, timer loops, and CSS keyframes ([rule 13](/design/overview#hard-rules-non-negotiable)). * Run the [anti-AI gate](/design/anti-ai-gate) after composition. * After you compose, eyeball-check that the page serves its Direction. If it does not, revise the Direction or the composition rather than adding more patterns. ## Navigation — 6 patterns, pick one (or none) If your landing lives under `(app)/`, apply the [nav-hiding patch](/design/overview#hide-the-global-navigation-on-the-landing-route) **before** dropping in any pattern below — otherwise the app's global `` stacks on top of the landing chrome, the clearest telltale of a bolted-on landing. A static top-level `src/pages/index.tsx` sits outside that layout and inherits no app chrome. ### N1 — Dual-state floating pill (recommended default) When to use: most modern SaaS, productivity tools, consumer products. The default workhorse — pick this unless your direction calls for something specific. Three coordinated pieces: a static top nav at page top, a floating pill that materializes on scroll, and an animated mobile dropdown. Active section highlighting works in both desktop states. **Direction → choice:** the "pill materializes on scroll" pattern reads as polish-conscious and modern. If your direction is editorial/zine (no polish theater) or brutalism (rejects smooth transitions), pick N5 or N3 instead. Full source - N1 dual-state floating pill ```tsx import { useEffect, useState } from 'react' import { useNavigate } from 'react-router-dom' import { Menu, X } from 'lucide-react' import { AnimatePresence, motion, cn, } from '../components/landing/primitives' const NAV_SECTIONS = [ { id: 'features', label: 'Features' }, { id: 'pricing', label: 'Pricing' }, { id: 'faq', label: 'FAQ' }, ] as const const APP_NAME = 'TODO: Brand' // Small inline useActiveSection — the scaffolded LandingPage.tsx defines // one but doesn't export it. Reads from the document scroll, not a custom // scroll root, so element rects use viewport coords directly. function useActiveSection(ids: readonly string[]) { const [active, setActive] = useState(null) useEffect(() => { const calc = () => { const triggerY = window.innerHeight * 0.3 let cur: string | null = null for (const id of ids) { const el = document.getElementById(id) if (el && el.getBoundingClientRect().top <= triggerY) cur = id } setActive(cur) } calc() window.addEventListener('scroll', calc, { passive: true }) return () => window.removeEventListener('scroll', calc) }, [ids]) return active } export function LandingNav() { const [isScrolled, setIsScrolled] = useState(false) const [mobileOpen, setMobileOpen] = useState(false) const navigate = useNavigate() const ids = NAV_SECTIONS.map(s => s.id) const active = useActiveSection(ids) useEffect(() => { const onScroll = () => setIsScrolled(window.scrollY > 80) onScroll() window.addEventListener('scroll', onScroll, { passive: true }) return () => window.removeEventListener('scroll', onScroll) }, []) const scrollTo = (id: string) => { setMobileOpen(false) document.getElementById(id)?.scrollIntoView({ behavior: 'smooth', block: 'start' }) } // /home is public by default in the scaffold. To force sign-in on click, // either swap to an `(app)/(protected)/` route or open here. const enterApp = () => navigate('/home') const mobileDropdown = ( {mobileOpen && (
{NAV_SECTIONS.map(link => ( ))}
)} ) return ( <> {/* Static top nav (page top; fades out on scroll) */}
{APP_NAME}
{NAV_SECTIONS.map(link => ( ))}
{mobileDropdown}
{/* Floating pill (slides down on scroll) */} {isScrolled && (
{APP_NAME}
{NAV_SECTIONS.map(link => ( ))}
)} ) } ``` ### The other five nav patterns * **N2 — Sticky docs-style top bar.** Dev tools, doc-heavy products, anything where the nav needs to persist and feel functional rather than decorative. No transformation on scroll — a solid `sticky top-0` bar with backdrop blur, a mono wordmark, a few text links, and a "Launch app →" text button. * **N3 — Corner brand, no nav at all.** Manifesto sites, single-screen kinetic-typography landings, retro directions. When the page is so committed to a single idea that a nav would diminish it: just two `fixed` corner elements — the brand top-left, an "Enter →" button top-right — each fading in on a delay. * **N4 — Hamburger-only.** Consumer products with strong identity where the nav is a secondary concern. Fixed brand top-left, a round bordered hamburger button top-right on every device; opening it covers the page with a `backdrop-blur` overlay of oversized centered links that stagger in. * **N5 — Inline anchor list (editorial).** Magazine, zine, or single-page long-scroll pages where the nav is prose-adjacent. No fixed bar, no pill — a masthead row (italic serif brand, issue label, heavy bottom border) with a small mono-uppercase anchor index beneath it that scrolls with the page. * **N6 — Hover-panel mega menu.** Product suites with enough surface area that a flat nav wouldn't fit. Each top-level item opens a categorized panel on hover (label + one-line description per entry). **Direction → choice:** only pick N6 if the product actually has 2+ top-level categories. A two-page product using a mega menu looks bigger than it is and reads as try-hard. ## Hero — 5 patterns, pick one * **H1 — Split-screen with animated product mockup.** Product-led SaaS where a UI preview is the easiest way to explain the thing. Text on one side, a live-rendered React mockup on the other — the mockup is a React component (staggered tiles, styled divs), never an AI-generated image. * **H2 — Full-bleed atmospheric.** Consumer brands, lifestyle and editorial products, products whose value is mood more than feature. Full source below. * **H3 — Bento hero.** Multi-feature SaaS where the first viewport should already communicate 3–5 things. A headline tile (spanning 4 columns and 2 rows) anchors the grid; the rest fills with a stat tile, an inline-visual tile, a pull-quote tile, and an inverted info tile — each small and distinct, not three identical cards. * **H4 — Typographic poster.** Manifesto sites, writing products, agencies. The headline IS the hero: `text-[12vw]` serif type on a near-empty canvas with one accent-colored italic word, closed by a bordered baseline row holding one short supporting sentence and a mono CTA. * **H5 — Live terminal / CLI demo.** Dev tools, APIs, technical infrastructure. A fake terminal types commands with realistic variable timing — slower keystrokes on input lines with random jitter, near-instant output lines — so it reads as convincing, not scripted. **The H5 reduced-motion lesson:** the terminal's typing loop is driven by `setTimeout`, which is not framer-motion — `` does not cover it. The pattern must call `useReducedMotion()` itself and short-circuit, jumping straight to the terminal's end state. The same applies to any timer or `requestAnimationFrame` loop ([rule 13](/design/overview#hard-rules-non-negotiable)). ### H2 — Full-bleed atmospheric (full source) A generated atmospheric image fills the viewport; the headline floats over a gradient scrim. **Image-generation workflow:** generate the image with `integration.post('gemini/generate-image', ...)` (or `openai/generate-image`). **Your prompt must include `no text, no words, no letters, no writing, no logos`** — AI models hallucinate gibberish text otherwise. Persist the URL with `useR2Files` if you want it stable across renders. Generated images are for atmosphere only — product mockups stay React components. Full source - H2 full-bleed atmospheric ```tsx import { useNavigate } from 'react-router-dom' import { motion } from '../components/landing/primitives' const HERO_BG = 'TODO: paste integration-generated image URL here' export function AtmosphericHero() { const navigate = useNavigate() return (
TODO: 3–8 word headline. TODO: one sentence. navigate('/home')} className="mt-10 inline-flex items-center px-7 py-3.5 rounded-full bg-foreground text-background text-sm font-medium hover:opacity-90" > Enter →
) } ``` ## Features — 5 patterns, pick one (sometimes two) Three identical cards with icon + title + description is the most-common AI-generated layout tell. Every pattern here is designed to break that shape — if your features section renders three of the same thing with the same structure, redesign it. ### F1 — Tabbed interactive showcase (full source) When to use: 3–5 features, each of which needs a visual. One tab list, one preview area. Clicking a tab swaps the preview. Full source - F1 tabbed interactive showcase ```tsx import { useState } from 'react' import { motion, AnimatePresence, cn } from '../components/landing/primitives' const FEATURES = [ { id: 'speed', label: 'Speed', title: 'TODO headline.', body: 'TODO one sentence.' }, { id: 'sync', label: 'Sync', title: 'TODO headline.', body: 'TODO one sentence.' }, { id: 'share', label: 'Share', title: 'TODO headline.', body: 'TODO one sentence.' }, ] export function TabbedFeatures() { const [active, setActive] = useState(FEATURES[0].id) const feature = FEATURES.find(f => f.id === active)! return (

TODO: section headline.

    {FEATURES.map(f => (
  • ))}
{feature.label}

{feature.title}

{feature.body}

{/* Add a feature-specific inline visual here — styled divs, SVG, not AI images. */}
) } ``` ### The other four feature patterns * **F2 — Alternating visual rows.** 2–4 features where each deserves space. Rows alternate left/right (`md:flex-row-reverse` on odd rows) so the page has rhythm; each row pairs a `ScrollReveal`-wrapped inline visual with a label + headline + one-paragraph body sliding in from opposite directions. * **F3 — Bento feature grid.** 4–7 features, several of which fit in smaller tiles. A 6-column grid of `col-span` tiles where **size = hierarchy** — the largest tile is the primary feature. * **F4 — Single scrolling showcase.** One feature is so much more important than the rest that it deserves the whole section: mono label, one-sentence claim as the headline, a 16:9 inline visual, then three short supporting beats in a row. **Direction → choice:** F4 suits editorial, minimalist, and premium directions where restraint is the aesthetic. Avoid it if your Direction calls for "show the whole product at a glance" — use F3 instead. * **F5 — Code-block feature list.** Dev tools where each feature is a code snippet. Title + description on one side, a `
` code sample on the other — the code IS the demo.

## Social proof — 4 patterns, pick at most one

**Real proof only.** Use a social-proof section only if you actually have real social proof. Fake logos and fake testimonials are worse than no social proof at all.

* **S1 — Logo row + single big stat.** You have a few real customer/user logos AND one memorable metric. Keep it spare — five logos max, one oversized number with a one-line explanation.
* **S2 — Single pull quote.** You have one great quote from a real person. Weight a single quote with serif typography instead of padding out a 3-quote row.
* **S3 — Metric trio.** Three meaningful numbers that tell a story together, using the scaffolded `AnimatedStat` primitive in a `StaggerContainer`. **Reduced-motion note:** `useCountUp` inside `AnimatedStat` uses `requestAnimationFrame`, and the scaffolded primitive doesn't gate it — if your users include people with vestibular sensitivity, either inline a gated version or accept that numbers count once on entry (usually acceptable).
* **S4 — Marquee carousel.** You have a lot of real logos or testimonials and want to show breadth. **Use only if your direction tolerates continuous motion.** A horizontal infinite scroll (the array doubled so the loop appears continuous) is the most-common offender for reduced-motion regressions — the pattern must gate on `useReducedMotion` and freeze (`x: 0`, no `repeat: Infinity` transition) for those users.

## CTA — 3 patterns, pick one

### C1 — Contrast band (full source)

When to use: the default closer. A full-width band that breaks the page's rhythm and makes the action feel decisive.

Full source - C1 contrast band

```tsx
import { useNavigate } from 'react-router-dom'
import { ArrowRight } from 'lucide-react'
import { ScrollReveal } from '../components/landing/primitives'

export function ContrastBand() {
  const navigate = useNavigate()
  return (
    

TODO: one-line close.

TODO: one-line support.

) } ``` ### The other two CTA patterns * **C2 — Centered glow.** Subtle close for editorial, minimalist, or premium directions. The page keeps the same background; a soft radial glow (`bg-primary/15 blur-3xl` circle behind the content) gives the CTA weight without a hard color break. Serif italic headline, single button. * **C3 — Asymmetric full-bleed.** Brutalist, editorial, or agency directions. Breaks the max-width container between heavy `border-y-2` rules: left-anchored giant serif type (`text-[10vw]`), right-anchored mono uppercase button, negative space between. ## Footer — 3 patterns, pick one ### FT2 — Column grid (full source) When to use: the default SaaS footer. Brand column + 2–4 link columns + a small attribution row. Full source - FT2 column grid ```tsx import { Github, Twitter, Mail } from 'lucide-react' const LINKS = { Product: ['Overview', 'Changelog', 'Pricing'], Company: ['About', 'Blog', 'Careers'], Resources: ['Docs', 'Community', 'Support'], } const SOCIALS = [ { icon: Github, href: 'TODO', label: 'GitHub' }, { icon: Twitter, href: 'TODO', label: 'Twitter' }, { icon: Mail, href: 'TODO', label: 'Email' }, ] export function ColumnFooter() { return (
TODO: brand

TODO: one-line product description.

{SOCIALS.map(({ icon: Icon, href, label }) => ( ))}
{Object.entries(LINKS).map(([heading, items]) => (

{heading}

    {items.map(i => (
  • {i}
  • ))}
))}
© {new Date().getFullYear()} TODO: brand Built with DeepSpace
) } ``` ### The other two footer patterns * **FT1 — Minimal mono.** Editorial, zine, or manifesto pages where the footer should disappear into the page. One line of mono-uppercase meta-info (brand, typefaces, year — a colophon) and one link, above a heavy top border. * **FT3 — Editorial masthead.** Magazine/editorial/zine pages. A footer masthead echoing the nav masthead — italic serif brand, issue number and date, "Edited by" credit — closing the "it's a printed issue" metaphor. ## Scroll & motion — 4 patterns, pick zero to N **Skip this section entirely unless your Design Direction calls for scroll choreography.** A quiet or still direction ships without any of these. Every pattern here uses `useTransform` from `useScroll` or a continuous animation loop. **Both bypass ``** — manual `useReducedMotion()` gates are required. * **SM1 — Parallax background layer.** Editorial or atmospheric directions where a slow layer shift behind content adds depth. Maps `scrollYProgress` to a `-12%` → `12%` background translate; when `useReducedMotion()` is true the range collapses to `0%`/`0%`. * **SM2 — Pinned section with stage progression.** Product walkthroughs — 3–5 stages advance as the user scrolls through a pinned section (`sticky top-0` inside a container `STAGES.length * 80vh` tall); each stage swaps opacity on the visual. Reduced-motion users see the final stage immediately. * **SM3 — Scroll progress indicator.** Long-form editorial pages where the user wants to know how far in they are. A thin fixed bar at the top of the viewport, `scaleX` driven by `scrollYProgress` with `origin-left`. * **SM4 — Word-by-word reveal heading.** Manifesto sites, writing products, kinetic-typography directions. The headline splits into words; each fades in as it enters the viewport (`useInView`, once). Gated: reduced-motion users get `duration: 0` and see the whole heading at once. ## Next steps * [Anti-AI gate](/design/anti-ai-gate) — run the full gate after composing. * [Worked examples](/design/worked-examples) — see the patterns adapted to five committed directions.