Skip to content
VibeFather
Sign up free

2 cases built from this template

Same prompt, different [VARIABLES]. Click one to preview it above.

About this template

Neon Hovercar City Runner is a one-screen arcade drive. The page opens on a night canyon: a low wedge hovercar sits on wet asphalt between glowing towers. Hover height stays fixed. The car glides, bends across the lane, can push a faster pace, and can spend a surge meter to kick through an arch. Drones cut the frame on contact. Crystals add haul. The course is a fixed 1.5 km and ends at a berth. An empty frame ends the run early. Results list haul, crystals, arches, peak pace, frame left, and time, then offer the same lane again.

Amber curbs and violet windows are the only neon pair. A dark metal road plus a streak layer reads as wet asphalt. Desktop uses a restrained bloom that phones turn off, and fog tightens on small screens. Pace and frame sit low on the left, surge along the bottom, haul and berth distance up on the right, and a vertical ribbon shows the lane ahead. Keys cover desktop. Phones get large buttons that can be held together. Reduced motion drops bloom, bob, and camera kick, and keeps steering and hazards.

Default copy is a night courier shift: Lumenlane, desk 4 on the lower quay of Amberwharf, a hovercar called the Kite Skiff, relay crystals, and a Roof Berth. Mara Quill is the dispatcher. Names live in one content file. A second set of values makes the same lane a salvage shift and leaves the mesh, colors, placements, and hit numbers unchanged. It suits developers and indie hackers who want a static Three.js game they can reskin by editing words. There is no server or downloaded model. Fonts are self-hosted, the favicon is code-drawn, and the build is minified static files with source maps off.

The template prompt

The live demo was built from exactly this text — nothing added. The other cases only change the values of the [VARIABLES].

# Neon Hovercar City Runner

Build this website exactly as described below. Replace the [VARIABLES] with your own values; keep everything else.

## Brief
Build [BRAND], a single-page night-canyon arcade game in the invented city [CITY]. The player pilots [VEHICLE], a code-built wedge hovercar locked to one hover height, up a wet reflective lane. Pocket [CARGO], pass surge arches, dodge drones, and reach the [DESTINATION] before the frame meter hits zero. [DISPATCHER] is the dispatcher named on the start card. The first screen is the live canyon with the hovercar already in it.

- Audience: Indie hackers and developers who want a finished static Three.js game, with keyboard and touch controls, a readable corner HUD, and words that can change without redrawing the course.
- Goal: Ship one replayable run of about a minute: launch from the canyon, bend the lane, push pace, spend surge, pocket cargo, survive drones and wall scrapes, then land on a results card for a reached berth or an empty frame. The course, meshes, palette, and hit numbers stay fixed when the variables change.
- Tone: Night-shift, concrete, and dry. Short US English. The failure is a machine losing its frame, not an injury. No gore, no real brands, and no slogans taken from other games.

## Stack
- Framework: Vite 6 + TypeScript 5
- Styling: Vanilla CSS
- Libraries: three (MIT), lucide (ISC), @fontsource/rajdhani (OFL-1.1), @fontsource-variable/outfit (OFL-1.1)
- Build: `npm run build` → static files in `dist/`. No backend, no server code, no external APIs.
- Setup:
  - Scaffold Vite's vanilla TypeScript template. Scripts: dev=vite, build=tsc && vite build, preview=vite preview. Do not add React, a physics engine, a game engine, or a postprocessing npm package.
  - In vite.config set base to './', build.outDir to dist, build.emptyOutDir to true, and build.sourcemap to false. In tsconfig set strict true, target ES2022, and noEmit true so tsc only typechecks.
  - Install only three, lucide, @fontsource/rajdhani, and @fontsource-variable/outfit as dependencies, plus vite and typescript as devDependencies. Import WebGLRenderer, FogExp2, and PMREMGenerator from three. Import EffectComposer, RenderPass, and UnrealBloomPass from three/examples/jsm/postprocessing/EffectComposer.js, RenderPass.js, and UnrealBloomPass.js. Those example modules ship with three under the MIT license.
  - Import Rajdhani 500, 600, and 700 from @fontsource/rajdhani, and Outfit Variable from @fontsource-variable/outfit/wght.css. Use the family names Rajdhani and Outfit Variable. Do not load any font from a CDN.
  - Copy only the SVG path data for pause, play, rotate-ccw, volume-2, volume-x, chevron-left, chevron-right, circle-help, and x from the installed lucide package into src/icons.ts. Render them as inline SVG at stroke 1.75. Do not add lucide-react.
  - Use one index.html with a full-viewport canvas and semantic HTML overlays. No router and no second page. Set the document title from content.ts to BRAND followed by an em dash and CITY.
  - Split the code into src/content.ts, src/track.ts, src/canyon.ts, src/skiff.ts, src/sim.ts, src/hud.ts, src/minimap.ts, src/audio.ts, src/icons.ts, src/main.ts, and src/styles.css. Every visible string lives in content.ts. Every course number lives in track.ts. Other modules import those files and do not hard-code names or placements.
  - When BRAND, CITY, VEHICLE, CARGO, DESTINATION, or DISPATCHER change, rewrite the start card, pilot notes, signs, results sentences, and flank decal so none of the default names remain. Keep the sentence count, the control mapping, the mesh, the palette, and the course.
  - Derive the localStorage key from a slug of BRAND: lowercase, spaces become hyphens, drop other punctuation, then prefix lane-best-haul:. Store only the best haul integer. Do not hard-code Lumenlane into the key.
  - Cap device pixel ratio at 1.75 on the desktop tier and 1.25 on the phone tier. Pause the simulation when the document is hidden and show the pause card. Do not auto-resume when it becomes visible again.
  - Before finishing, play the default run at 1440 by 900 and at 390 by 844: launch, bend, push pace, spend surge, pocket a crystal, pass an arch, scrape a wall, take a drone hit, reach the berth, empty the frame on a second run, pause, and toggle reduced motion. The console must stay empty.

## Variables
- [BRAND] — Game name (default: "Lumenlane"). One invented word shown as the large start-card title. Never a real company or an existing game.
- [CITY] — Canyon city (default: "Amberwharf"). One invented place name used on the eyebrow, the first sign, and the title.
- [VEHICLE] — Hovercar name (default: "Kite Skiff"). Two or three invented words, under 18 characters, painted on the flank and used in sentences. The mesh does not change.
- [CARGO] — Pickup name (default: "relay crystals"). A lowercase plural noun phrase of two words, used in the headline and the start-card body.
- [DESTINATION] — Finish name (default: "Roof Berth"). Two invented words for the pad at the end of the lane.
- [DISPATCHER] — Dispatcher (default: "Mara Quill"). An invented first and last name. Not a real person or a public figure.
- [CREDIT] — keep a small "Template by VibeFather" link to https://vibefather.ai/t/neon-hovercar-city-runner in the footer (default: yes; delete this line to remove it)

The copy under Pages & Sections is written for the default values. If your values differ, rewrite every headline, paragraph, label and image for them — same length, tone and structure. Layout, colors, type and motion stay as described.
Keep all copy, image paths and links in one content file (for example `src/content.ts`), keyed by section, so the content can be swapped later without touching components.

Pro template. The design, sections, motion and assets parts of this prompt are for Pro members. The live demo and DESIGN.md stay free.

DESIGN.md

The design system on its own — colors, type, spacing and motion. Apply this look to a project you already have.

---
name: "Neon Hovercar City Runner"
colors:
  canyon_night: "#07060C"
  asphalt: "#121018"
  shoulder: "#0C0B10"
  tower_body: "#14121C"
  fog_violet: "#1C1428"
  amber: "#F0A202"
  iris: "#6E5BFF"
  chartreuse: "#D6F25C"
  bone: "#F6F1E8"
  muted_lilac: "#A39BB4"
  panel: "#100E18"
  line: "#2A2636"
  coral: "#FF5C3A"
typography:
  game_title_hud_numerals_meter_labels_and_results_titles: { family: "Rajdhani", weights: [500, 600, 700] }
  body_copy_buttons_pilot_notes_and_the_small_pace_caption: { family: "Outfit Variable", weights: [400, 500, 600] }
spacing: "Use a 4 px base. Desktop HUD gutters are 20 px. Mobile gutters are 10 px plus the safe-area inset. Cards use 22 px padding. Buttons are at least 48 px tall. Coarse-pointer controls are at least 68 px. Keep the chase view clear of the cards: the desktop start card occupies the left 400 px and leaves the right half of the canyon open."
radius: "Cards and the lane ribbon use 16 px. Buttons use 12 px. The surge key is a circle. Meter tracks use 999 px. World geometry stays hard-edged except the two lamp rings, which are toruses."
---

# Neon Hovercar City Runner — Design System

Apply this design system to an existing project. It describes the look and feel only; for the full site, use prompt.md.

## Colors
- **Canyon night** `#07060C` — Page background, renderer clear color, and favicon ground
- **Asphalt** `#121018` — Wet road surface
- **Shoulder** `#0C0B10` — Ground between the curbs and the towers
- **Tower body** `#14121C` — Canyon tower faces
- **Fog violet** `#1C1428` — Exponential fog only. Not the curb color
- **Amber** `#F0A202` — Curbs, outrigger ring lamps, surge fill, primary button, and arch posts
- **Iris** `#6E5BFF` — Window grids and the hover slit under the car. The second neon, never a curb
- **Chartreuse** `#D6F25C` — Arch crossbars and cleared-arch ticks on the ribbon
- **Bone** `#F6F1E8` — Primary text, pace numerals, and the berth pad edge
- **Muted lilac** `#A39BB4` — Secondary labels and pilot-note body text
- **Panel** `#100E18` — Start, pause, notes, and results cards
- **Line** `#2A2636` — Card borders, empty meter tracks, and ribbon border
- **Coral** `#FF5C3A` — Drone rims, low-frame segments, and hit feedback. Never a full-screen flash

## Typography
- **Game title, HUD numerals, meter labels, and results titles** — Rajdhani (OFL), weights 500/600/700. Self-host the font files.
- **Body copy, buttons, pilot notes, and the small pace caption** — Outfit Variable (OFL), weights 400/500/600. Self-host the font files.

## Spacing & shape
- Spacing: Use a 4 px base. Desktop HUD gutters are 20 px. Mobile gutters are 10 px plus the safe-area inset. Cards use 22 px padding. Buttons are at least 48 px tall. Coarse-pointer controls are at least 68 px. Keep the chase view clear of the cards: the desktop start card occupies the left 400 px and leaves the right half of the canyon open.
- Radius: Cards and the lane ribbon use 16 px. Buttons use 12 px. The surge key is a circle. Meter tracks use 999 px. World geometry stays hard-edged except the two lamp rings, which are toruses.

## Motion
- Simulate at a fixed 1/60 second step, accumulate time, and run at most three steps per frame. Cap the incoming delta at 0.05 seconds.
- The hovercar glides at 26 m/s, rises toward 46 m/s while pace is held, and adds a 1.35 second surge kick. Steering eases across the lane. The chase camera lags behind the road tangent.
- Desktop bloom is static, not pulsing. Phone tier removes bloom and tightens fog. Reduced motion also removes bloom, hover bob, streak scroll, arch pulse, crystal spin, and the hit kick.
- Cards fade in over 160 ms and move no more than 8 px. Reduced motion makes those changes instant. Button presses scale to 0.96 while held.
- A drone hit or a wall scrape flashes only the frame segments for 120 ms. Do not flash the whole viewport.

## Imagery
Build the canyon, the hovercar, the arches, the drones, the crystals, the berth, the wet-road streak, and the favicon from original Three.js geometry and canvas textures. No photographs, no generated images, no downloaded models, no HDRI files, and no sky texture. The live canyon is the first-screen anchor. People are not shown. The only text inside the 3D view is the vehicle name on the flank and three short signs.

## Tone
Night-shift, concrete, and dry. Short US English. The failure is a machine losing its frame, not an injury. No gore, no real brands, and no slogans taken from other games.

---
Inspired by neoncity one-shot hovercar game by @JulianGoldieSEO — https://agentos.guide/grok-4-7-agent-os
— Prompt by VibeFather · https://vibefather.ai/t/neon-hovercar-city-runner · CC BY-NC 4.0 (non-commercial; commercial use needs a VibeFather Pro license) · Request removal: https://vibefather.ai/takedown

Make it yours

  • A studio launching an indie arcade title: set BRAND to your game name, CITY to your fictional district, and VEHICLE to your craft, then rewrite the start card and pilot notes.
  • A developer portfolio piece: keep the neon canyon but set CARGO to your project names and DESTINATION to your contact page, so each crystal collected reads as a shipped build.
  • A brand activation or event page: set DISPATCHER to the host name and DESTINATION to the venue, then rewrite the results sentences to invite players to the booth.
  • A tabletop or lore site: set CITY and VEHICLE to your setting's names and rewrite the pilot notes as in-world briefing text, leaving the course and hazards untouched.

Neon Hovercar City Runner: questions and answers

What do I actually change to reskin the Neon Hovercar City Runner game for my own brand?

The Neon Hovercar City Runner template keeps every visible word in one content file, driven by six variables: BRAND, CITY, VEHICLE, CARGO, DESTINATION and DISPATCHER. Change those and rewrite the start card, pilot notes, signs, results sentences and flank decal so no default names remain. The mesh, palette, placements and hit numbers stay the same, so the lane plays identically.

How do the controls work on the Neon Hovercar City Runner, and can phones play it?

The Neon Hovercar City Runner uses keys on desktop and large on-screen buttons on phones, which can be held together for steering plus surge. Pace and frame sit low on the left, surge along the bottom, haul and berth distance up on the right, and a vertical ribbon shows the lane ahead. Reduced motion drops bloom, bob and camera kick while keeping steering and hazards.

Can I run the Neon Hovercar City Runner game without a server or downloaded models?

The Neon Hovercar City Runner template builds to minified static files with no backend, no external APIs and no downloaded 3D models. The hovercar, canyon and arches are drawn in code with Three.js. Fonts are self-hosted and the favicon is code-drawn, so you can host the output on any static host. Source maps are off in the build.

How does a run end in the Neon Hovercar City Runner, and what does the results card show?

A run in the Neon Hovercar City Runner ends at the berth after a fixed 1.5 km course, or early if the frame meter empties. The results card lists haul, crystals, arches, peak pace, frame left and time, then offers the same lane again. Drones cut the frame on contact, wall scrapes cost you, and surge is spent to kick through arches.

Can I use the Neon Hovercar City Runner template for a client project or a commercial game?

Commercial and client use of the Neon Hovercar City Runner requires Pro. The brief, stack and variables are public, the full prompt is available to Pro members, and the demo source code comes with Pro. Free templates' prompts and every DESIGN.md are licensed for personal, non-commercial use under CC BY-NC 4.0.

How do I build a neon hovercar city runner with AI?

Copy the full prompt (Pro) from this page or run npx vibefather add neon-hovercar-city-runner, replace [CITY], [BRAND], [CARGO] and [VEHICLE] with your own content, and paste it into Claude Code, Codex, Cursor or another AI coding agent. The live demos were built from exactly that text.

Which AI model built the Neon Hovercar City Runner demo?

The Amberwharf courier run case was built by Grok 4.7 in Grok Build; the Saltarcade salvage run case was built by Grok 4.7 in Grok Build. Each build used the published prompt with nothing added.

What tech stack and pages does the Neon Hovercar City Runner template use?

Neon Hovercar City Runner is a single-page site built with Three.js, with 3d / webgl and micro-interactions. The prompt fixes the stack so every AI tool builds the same kind of project, and the result runs as a static site you can host anywhere.

Is the Neon Hovercar City Runner template free to use?

Neon Hovercar City Runner is a Pro template: the brief, stack and variables are public, and the full prompt, the source code of the live demo and a commercial license come with VibeFather Pro. Its DESIGN.md is free for personal projects.

Does the Neon Hovercar City Runner template work on mobile?

Yes. Every Neon Hovercar City Runner build was tested on a phone-sized screen as well as desktop before it went live, checking layout, text size and touch targets. Open the live demo on your phone, or switch the preview on this page to mobile view, to check it yourself.