Guide

Game weather systems explained

In The Legend of Zelda: Breath of the Wild, a thunderstorm turns metal weapons into lightning rods. In Red Dead Redemption 2, mud slows horses and footprints vanish in rain. In Forza Horizon, wet asphalt changes grip and spray. Weather is one of the fastest ways to make an open world feel alive — yet many teams ship a particle emitter toggled by a boolean and wonder why storms feel cosmetic. A real weather system is a coordination layer: it drives sky color, fog density, surface wetness, wind on foliage, NPC behavior, audio mix, and sometimes combat math. Done well, players plan around forecasts; done poorly, rain is invisible indoors, lightning flashes tank the GPU, and multiplayer clients disagree on whether it is snowing. This guide covers weather state models, visual and audio pipelines, gameplay hooks, integration with the day-night cycle and lighting, performance budgets, multiplayer authority, and the checklist that keeps storms shippable on console and mobile.

What a weather system does — beyond particles

Weather is not a single effect. It is a set of correlated parameters that change together over time:

Atmosphere: cloud coverage, fog density, ambient color, sun visibility, volumetric god-rays.
Precipitation: rain, snow, hail, sand — rate, drop size, splash decals, accumulation on surfaces.
Wind: global direction and gust strength affecting trees, cloth, projectiles, and smoke.
Surface state: wetness, puddles, ice friction, mud depth.
Gameplay: visibility radius, fire suppression, elemental damage modifiers, spawn tables, travel speed.
Audio: layered loops, occlusion, thunder distance cues.

Treat weather as a broadcast channel. Lighting, VFX, audio, AI, and UI subscribe to one authoritative weather state rather than each subsystem polling its own random number. That is how you avoid rain audio playing under a clear sky because the particle system desynced from the sky shader.

Weather state models: presets, blends, and procedural rolls

Discrete weather presets

The simplest model: Clear, Cloudy, Rain, Storm, Snow, Fog. Each preset is a bundle of tuned parameters (particle counts, fog start distance, wetness target, audio stems). Designers swap presets at triggers — entering a mountain biome, starting a story beat, or crossing a region boundary. Presets are easy to author and debug; the cost is visible pops if transitions are instant.

Blended transitions

Production systems interpolate between presets over 30–120 real seconds. Store target values for cloud opacity, precipitation intensity, wind vector, and fog density; lerp each frame with easing curves so storms build rather than snap. Expose blend duration per transition type — drizzle to downpour can be fast; clear to blizzard should be slower so players notice the shift.

Procedural weather schedules

Open worlds often roll the next state from a Markov chain or weighted table conditioned on season, biome, and time of day. Example: if current state is Cloudy and biome is Coast, 40% chance of Rain in the next hour of world time, 10% chance of Storm. Tie rolls to the same world clock as your day-night cycle so "afternoon showers" are reproducible from a seed — critical for multiplayer and QA reproduction.

Scripted and quest-driven weather

Story missions override procedural weather: a boss arena forces Storm for drama; a stealth section demands Fog. Script overrides should stack priority over regional weather and restore previous state on quest completion, or players will complain that the eternal thunderstorm never ends.

Sky, clouds, and atmosphere

Precipitation particles look wrong if the sky still reads as cloudless noon. Weather and sky are one pipeline:

Cloud layers: stratified quads or volumetric noise textures scrolling with wind. Increase coverage and darken albedo as weather worsens.
Sky gradient: desaturate and cool horizon colors in rain; warm amber before storms; flat gray overcast for snow.
Fog: exponential height fog thickens with humidity. Pair fog color with sky — blue-gray for rain, white for blizzard. Fog is often cheaper than dense particles for obscuring distant geometry.
Lightning: brief directional light spikes plus screen flash on a random timer during Storm. Cap frequency and provide accessibility toggles for photosensitive players.

Reuse the sky evaluation path from your day-night system: weather modulates sun and moon contribution rather than replacing it. At night, rain should still read as night — darker blues, wet specular highlights from moonlight, not a daytime gray filter pasted on top.

Precipitation: particles, meshes, and surface wetness

Particle rain and snow

GPU particle systems emit streaks or flakes in a camera-centered volume so precipitation surrounds the player without simulating every drop in the world. Key tuning knobs: emission rate, velocity aligned to wind, size distribution, alpha fade by distance, and collision splashes on ground raycasts. For mobile, cap alive particles aggressively — a light drizzle with 2,000 drops often reads better than a stuttering 20,000-drop monsoon.

Occlusion and indoor rules

Rain should not render under roofs. Common approaches: disable precipitation when interior volume flag is set; stencil or depth-based ceiling tests; or separate indoor/outdoor particle emitters parented to the camera. Audio needs the same rule — muffled rain when indoors is a huge immersion win for one low-pass filter.

Surface wetness and puddles

A global wetness scalar (0–1) drives material shader roughness, puddle normal maps, and ripples. Decals at footfall positions sell impact. Accumulation can lag behind precipitation intensity — surfaces stay dry for the first minute of rain, then saturate. Snow adds height displacement on terrain and slower movement curves.

Screen-space effects

Raindrops on the camera lens (first-person), heat distortion in sandstorms, and snowflake streaks on visors are cheap fullscreen overlays. Use sparingly — they fatigue in third-person games and can obscure UI.

Wind: making the world respond

Wind ties weather to motion across the scene:

Foliage: vertex shader sway driven by wind direction, gust noise texture, and precipitation state (heavy rain = stronger sway).
Cloth and hair: physics or baked simulation scaled by wind magnitude.
Particles: smoke, leaves, and embers inherit wind vector.
Projectiles: optional drift for arrows and grenades in storms — communicate clearly in UI or players will blame netcode.

Publish wind as a vec3 or direction + magnitude each frame so VFX, audio (wind howl intensity), and gameplay systems read the same values.

Gameplay hooks: when weather changes the rules

Cosmetic weather is fine for scenic games; systemic weather creates memorable mechanics:

Visibility: fog and blizzard reduce AI sight cones and minimap range — pairs naturally with AI perception and stealth loops.
Movement: mud, ice, and deep snow modify acceleration and turn rate; stamina drains faster in heatwaves.
Combat: fire spells weaken in rain; lightning strikes conductive armor; wind pushes archery shots.
Survival meters: hypothermia in snow, heat in deserts — tie to clothing and shelter crafting.
Spawns and economy: rare fish during rain, crops needing water, merchants closing in storms.
Player tools: umbrellas, weather forecasts on in-game maps, consumables that grant temporary immunity.

If weather affects mechanics, surface it in UI — a small icon and forecast timer prevent "unfair" deaths. Players forgive storms they saw coming.

Audio: layers, occlusion, and thunder distance

Weather audio is almost always layered loops crossfaded by intensity: light drizzle stem, heavy rain stem, wind gust one-shots, distant thunder rumbles. Route through your audio bus so combat SFX stay readable — duck music slightly, never bury footstep feedback. Thunder delay should match lightning flash distance: delay = distance / speedOfSound sells the illusion. Indoors, apply low-pass and volume reduction on precipitation loops. Stereo pan wind toward the prevailing direction for headphone players.

Performance: the mobile and console budget

Weather is a classic frame-time spike source:

Particles: pool emitters; distance-cull splashes; reduce rate when FPS drops (dynamic weather quality setting).
Overdraw: fullscreen rain alpha kills fill rate — use stochastic sparse drops or limit to a frustum shell.
Lightning: avoid shadow-casting flashes every few seconds; use emissive sky and brief screen grade instead.
Wet materials: batch surfaces sharing wetness params; avoid per-object unique dynamic materials.
CPU: weather state machine runs once per tick; do not raycast per raindrop — cap ground collision samples.

Ship a weather quality preset: Off (clear only), Low (audio + fog, no particles), Medium, High. Competitive multiplayer titles often lock weather to presets per map for readability and fairness.

Multiplayer: one sky, authoritative state

Desynced weather breaks immersion and mechanics. Patterns:

Server-authoritative state: host or dedicated server rolls and broadcasts weather enum + blend progress + seed. Clients interpolate visuals locally but do not roll independently.
Deterministic from world seed: all clients derive weather from hash(worldSeed, dayIndex, regionId) — no network message needed except time sync.
Gameplay replication: if lightning damages players, server validates strikes; clients show cosmetic bolts only.

Match your netcode tick rate — weather blends are slow enough that 1 Hz state updates often suffice for open worlds.

Biomes, seasons, and terrain integration

Regional climate tables prevent snow in deserts and sandstorms in tundra unless scripted. Layer base biome climate with season modifiers (winter increases snow weight) and altitude (mountain peaks always cold). When generating terrain, stamp biome IDs so weather rolls query the correct table at each coordinate. Transitions at biome borders should blend over distance — a sharp rain/snow line at the tree line looks like a rendering bug.

Common anti-patterns

Rain indoors — breaks immersion instantly; fix occlusion before adding more particles.
Instant weather snaps — players notice pop; always blend unless comedic intent.
Weather ignores time of day — night rain must darken the scene, not just add gray streaks.
Gameplay without telegraph — lightning one-shots with no forecast feel cheap.
Unbounded particle counts — storms that run at 15 FPS on target hardware.
Per-client random weather — multiplayer friends see different skies.
Silent weather — audio carries 80% of storm feel; do not ship particles alone.

Production checklist

Define weather presets as data bundles (VFX, lighting, fog, audio, gameplay).
Implement blended transitions with tunable duration per edge.
Broadcast one authoritative weather state to lighting, VFX, audio, and AI.
Integrate with day-night sky evaluation — weather modulates, not replaces.
Add indoor/outdoor occlusion for particles and audio.
Drive surface wetness and friction from a global scalar.
Expose wind direction and magnitude for foliage and VFX shaders.
Document gameplay modifiers and show forecast UI when mechanics are affected.
Ship weather quality presets; profile fill rate and particle counts on min-spec.
Sync weather in multiplayer via server state or deterministic seed.
Provide accessibility options for lightning flashes and motion-heavy storms.

Key takeaways

Weather is a system, not an emitter — sky, fog, surfaces, wind, audio, and rules move together.
Blended state machines and seeded schedules make storms feel natural and reproducible.
Gameplay hooks turn weather from wallpaper into something players plan around.
Performance and occlusion matter as much as art — especially on mobile.
Multiplayer authority prevents five friends from seeing five different skies.