jungle-trail logo

jungle-trail

A fully procedural first-person jungle in Three.js. Zero external art assets - every texture, mesh and sound generated in code.

Website GitHub

What is it?

What it is

A procedural first-person game in a jungle environment built with Three.js, generating all assets (textures, meshes, sounds) in code without external files.

Why it exists

To demonstrate procedural generation capabilities in Three.js, creating a fully asset-free experience with dynamic content computed at runtime.

Who should use it

Graphics programmersWebGL/Three.js developersProcedural generation enthusiastsShader engineersTechnical artists

Who should avoid it

Beginners looking for simple game templatesDevelopers seeking ready-made 3D models or texturesUsers looking for high-level game engines with visual editors

How it works

A quick walkthrough in plain English

How jungle-trail works

Step 1 of 3

You interact with it

Open jungle-trail, send a request, or connect it to your stack.

Features

Procedural generation of all textures, meshes, and audio at runtime
Zero external art assets (no images, models, or audio files)
First-person exploration of a jungle trail with ruins and waterfall
GPU texture baking using GLSL surf() functions
Advanced post-processing pipeline (volumetrics, bloom, defocus, motion blur, etc.)
Procedural character with 22 bones and 512-square body atlas
16 species of vegetation built from swept tube and bent leaf card primitives
536 eroded stone blocks in procedurally generated ruins
Synthesized audio with 17 voices and 60 buffers generated in a worker
Planar water reflection that reuses shadow maps and renders at reduced resolution
Atmospheric scattering baked to cube map for sky and image-based lighting
Canopy shadowing via analytic transmittance term instead of depth buffer
Teleport system (keys 1-5) to key locations along the trail
Debug overlay toggleable with F3 key
No build step or runtime npm dependencies (uses Three.js from CDN via importmap)
Offline audio rendering capability via pure DSP functions
Incommensurate ambient audio loops to prevent audible repetition
Performance capped at 60 fps with detailed frame timing breakdowns

Advantages

  • Truly zero-asset approach demonstrates advanced procedural techniques
  • High frame rates (108+ fps) on mid-tier hardware (RTX 4060)
  • Sophisticated graphics techniques normally requiring asset pipelines
  • Audio synthesis avoids Web Audio API in DSP path enabling offline rendering
  • Thoughtful post-processing design with tone mapping last and HDR linear processing
  • Critically reviewed subsystems with documented improvement paths
  • Efficient resource use: planar reflection runs at 36% resolution and skips when off-screen
  • No build step required - runs as plain ES modules with static server
  • MIT license permits free use and modification
  • Detailed performance analysis shows understanding of GPU timing quirks
  • Techniques like normal map derivation from albedo ensure consistency
  • Sky and IBL share same function preventing drift between lighting and background
  • Motion blur reconstructs velocity from depth buffer without velocity attachments
  • Audio loop lengths are mutually incommensurate preventing repetition
  • Open development process with critic feedback documented in status section

Disadvantages

  • Middle distance (>8m) appears as flat khaki wall due to insufficient haze and channel separation
  • Lack of backlit leaf translucency reduces depth perception in vegetation
  • Waterfall representation limited to swept quad sheet (no droplet-level detail)
  • Planar reflection has soft quality and masonry band misalignment issues
  • Brook banks remain straight despite other water improvements
  • Project status indicates significant unfinished work (middle distance)
  • Vegetation and lighting systems signed off at only 5/10 and 6/10 by critics
  • Relies on Three.js from CDN (though this is runtime-only and documented)
  • No mention of mobile device testing or touch controls
  • Complex shader-based systems may have high development maintenance cost
  • Procedural generation at load time may cause initial stutter despite worker audio baking
  • Techniques like analytic canopy transmittance may not generalize to other scenes
  • Post-processing chain complexity could be barrier to entry for contributors
  • Performance numbers vary between runs (spread of ~0.03ms on 9ms frame)
  • No built-in level editor or procedural content modification tools exposed to users

Installation

cloud

not mentioned

docker

not mentioned

native

git clone https://github.com/StarKnightt/jungle-trail.git
cd jungle-trail
npm run serve

compose

not mentioned

FAQ

How do I run the project locally?

Clone the repository and run `npm run serve`. You must use a static file server because ES modules and web workers require a real origin; opening `index.html` directly from the filesystem will not work.

Does the game use any external art or audio assets?

No. The project is entirely procedural. Every texture, mesh, and sound is generated in code at load time using GLSL shaders and mathematical functions, with zero external image, model, or audio files.

What are the movement and view controls?

Use W, A, S, D to move and Shift to sprint. Use the Mouse to look around and Space to jump. You can also use keys 1 through 5 to teleport to specific locations along the trail.

How do I view the debug overlay?

Press the F3 key to show or hide the debug overlay. Once visible, you can collapse the header to a summary bar using the same key.

Does the project have any runtime npm dependencies?

The game has zero runtime npm dependencies. It fetches Three.js from a jsDelivr CDN via an importmap in `index.html`, but no other external libraries are loaded at runtime.

Loading documentation…
View on GitHub

Featured in Videos

YouTube tutorials and walkthroughs for jungle-trail

Alternatives

Similar projects ranked by category, topics, and text overlap.

Compare
jungle-trail | MushyBook