diff --git a/examples/large_scenes/bevy_city/Cargo.toml b/examples/large_scenes/bevy_city/Cargo.toml
index deb64ecaa04ea..046596ea4bfde 100644
--- a/examples/large_scenes/bevy_city/Cargo.toml
+++ b/examples/large_scenes/bevy_city/Cargo.toml
@@ -5,6 +5,9 @@ edition = "2024"
 publish = false
 license = "MIT OR Apache-2.0"
 
+[features]
+traffic = []
+
 [dependencies]
 bevy = { path = "../../../", features = [
   "https",
diff --git a/examples/large_scenes/bevy_city/src/assets.rs b/examples/large_scenes/bevy_city/src/assets.rs
index f1baa9e13f417..dc2703acc272f 100644
--- a/examples/large_scenes/bevy_city/src/assets.rs
+++ b/examples/large_scenes/bevy_city/src/assets.rs
@@ -27,6 +27,7 @@ pub struct CityAssets {
     pub tree_large: Handle<Scene>,
     pub path_stones_long: Handle<Scene>,
     pub fence: Handle<Scene>,
+    pub traffic_light: Handle<Scene>,
 }
 
 impl CityAssets {
@@ -219,6 +220,9 @@ pub fn load_assets(
         GltfAssetLabel::Scene(0).from_asset(format!("{base_url}/city-kit-suburban/fence.glb"))
     );
 
+    let traffic_light: Handle<Scene> =
+        load_asset!(GltfAssetLabel::Scene(0).from_asset("traffic_assets/traffic_light.glb"));
+
     commands.insert_resource(CityAssets {
         untyped_assets,
         cars,
@@ -232,5 +236,6 @@ pub fn load_assets(
         tree_large,
         path_stones_long,
         fence,
+        traffic_light,
     });
 }
diff --git a/examples/large_scenes/bevy_city/src/generate_city.rs b/examples/large_scenes/bevy_city/src/generate_city.rs
index 46aa5594e4cc8..73c9df09d5b79 100644
--- a/examples/large_scenes/bevy_city/src/generate_city.rs
+++ b/examples/large_scenes/bevy_city/src/generate_city.rs
@@ -2,8 +2,7 @@ use bevy::prelude::*;
 use noise::{NoiseFn, OpenSimplex};
 use rand::{rngs::SmallRng, RngExt, SeedableRng};
 
-use crate::{assets::CityAssets, Car, Road};
-
+use crate::{assets::CityAssets, traffic, Car, CarAtStopState, CarState, Road};
 #[derive(Component)]
 pub struct CityRoot;
 
@@ -87,10 +86,26 @@ fn spawn_roads_and_cars<R: RngExt>(
     let x = offset.x;
     let z = offset.z;
 
-    commands.spawn((
-        SceneRoot(assets.crossroad.clone()),
-        Transform::from_xyz(x, 0.0, z),
-    ));
+    let crossroad = commands
+        .spawn((
+            SceneRoot(assets.crossroad.clone()),
+            Transform::from_xyz(x, 0.0, z),
+            traffic::TrafficLight::new((x * 7.3 + z * 3.7).rem_euclid(traffic::CYCLE_DURATION)),
+        ))
+        .id();
+
+    // 2 traffic lights at diagonal corners
+    for (dx, dz, y_rot) in [
+        (-0.5_f32, -0.5_f32, 0.0_f32),
+        (0.5_f32, -0.5_f32, std::f32::consts::FRAC_PI_2),
+    ] {
+        commands.spawn((
+            SceneRoot(assets.traffic_light.clone()),
+            Transform::from_translation(Vec3::new(x + dx, 0.0, z + dz))
+                .with_rotation(Quat::from_rotation_y(y_rot))
+                .with_scale(Vec3::splat(0.3)),
+        ));
+    }
 
     let max_car_density = 0.4;
 
@@ -108,6 +123,7 @@ fn spawn_roads_and_cars<R: RngExt>(
             Road {
                 start: Vec3::new(0.75, 0.0, 0.0),
                 end: Vec3::new(0.75 + (0.5 * car_count as f32), 0.0, 0.0),
+                intersection: crossroad,
             },
         ))
         .with_children(|commands| {
@@ -133,6 +149,9 @@ fn spawn_roads_and_cars<R: RngExt>(
                             distance_traveled: i as f32 * 0.5,
                             dir: -1.0,
                             offset: Vec3::new(4.25, 0.0, -0.15),
+                            car_state: CarState::Driving,
+                            at_stop_state: CarAtStopState::Default,
+                            next_lane: None,
                         },
                     ));
                 }
@@ -150,6 +169,9 @@ fn spawn_roads_and_cars<R: RngExt>(
                             distance_traveled: i as f32 * 0.5,
                             dir: 1.0,
                             offset: Vec3::new(-0.25, 0.0, 0.15),
+                            car_state: CarState::Driving,
+                            at_stop_state: CarAtStopState::Default,
+                            next_lane: None,
                         },
                     ));
                 }
@@ -165,6 +187,7 @@ fn spawn_roads_and_cars<R: RngExt>(
             Road {
                 start: Vec3::new(0.0, 0.0, 0.75),
                 end: Vec3::new(0.0, 0.0, 0.75 + (0.5 * car_count as f32)),
+                intersection: crossroad,
             },
         ))
         .with_children(|commands| {
@@ -187,6 +210,9 @@ fn spawn_roads_and_cars<R: RngExt>(
                             distance_traveled: i as f32 * 0.5,
                             dir: 1.0,
                             offset: Vec3::new(-0.15, 0.0, -0.25),
+                            car_state: CarState::Driving,
+                            at_stop_state: CarAtStopState::Default,
+                            next_lane: None,
                         },
                     ));
                 }
@@ -201,6 +227,9 @@ fn spawn_roads_and_cars<R: RngExt>(
                             distance_traveled: i as f32 * 0.5,
                             dir: -1.0,
                             offset: Vec3::new(0.15, 0.0, 2.75),
+                            car_state: CarState::Driving,
+                            at_stop_state: CarAtStopState::Default,
+                            next_lane: None,
                         },
                     ));
                 }
diff --git a/examples/large_scenes/bevy_city/src/main.rs b/examples/large_scenes/bevy_city/src/main.rs
index 24d53893ecc31..de86e98e326ed 100644
--- a/examples/large_scenes/bevy_city/src/main.rs
+++ b/examples/large_scenes/bevy_city/src/main.rs
@@ -27,6 +27,8 @@ mod assets;
 mod generate_city;
 mod settings;
 
+mod traffic;
+
 #[derive(FromArgs, Resource, Clone)]
 /// Config
 pub struct Args {
@@ -41,14 +43,23 @@ pub struct Args {
     /// adds NoCpuCulling to all meshes
     #[argh(switch)]
     no_cpu_culling: bool,
+    // forces Vulkan backend and clears instance flags for RenderDoc capture
+    //#[argh(switch)]
+    //renderdoc: bool,
 }
 
 fn main() {
     let args: Args = argh::from_env();
 
-    App::new()
-        .add_plugins((
-            DefaultPlugins.set(WindowPlugin {
+    let mut app = App::new();
+
+    app.add_plugins((
+        DefaultPlugins
+            .set(AssetPlugin {
+                file_path: "./".to_string(),
+                ..default()
+            })
+            .set(WindowPlugin {
                 primary_window: Some(Window {
                     title: "bevy_city".into(),
                     resolution: WindowResolution::new(1920, 1080).with_scale_factor_override(1.0),
@@ -58,30 +69,34 @@ fn main() {
                 }),
                 ..default()
             }),
-            FreeCameraPlugin,
-            FeathersPlugins,
-            WireframePlugin::default(),
-        ))
-        .insert_resource(args.clone())
-        .insert_resource(ClearColor(Color::BLACK))
-        .insert_resource(WinitSettings::continuous())
-        .init_resource::<Settings>()
-        .insert_resource(UiTheme(create_dark_theme()))
-        .insert_resource(WireframeConfig {
-            global: false,
-            default_color: WHITE.into(),
-            ..default()
-        })
-        // Like in many realistic large scenes, many of the objects don't move
-        // We can accelerate transform propagation by optimizing for this case
-        .insert_resource(StaticTransformOptimizations::Enabled)
-        .add_systems(Startup, (setup, load_assets))
-        .add_systems(Update, (simulate_cars, loading_screen))
-        .add_observer(add_no_cpu_culling)
-        .add_observer(add_no_cpu_culling_on_scene_ready)
-        .add_observer(on_city_assets_ready)
-        .add_observer(setup_settings_ui)
-        .run();
+        traffic::TrafficPlugin,
+        FreeCameraPlugin,
+        FeathersPlugins,
+        WireframePlugin::default(),
+    ))
+    .insert_resource(args.clone())
+    .insert_resource(ClearColor(Color::BLACK))
+    .insert_resource(WinitSettings::continuous())
+    .init_resource::<Settings>()
+    .insert_resource(UiTheme(create_dark_theme()))
+    .insert_resource(WireframeConfig {
+        global: false,
+        default_color: WHITE.into(),
+        ..default()
+    })
+    // Like in many realistic large scenes, many of the objects don't move
+    // We can accelerate transform propagation by optimizing for this case
+    .insert_resource(StaticTransformOptimizations::Enabled)
+    .add_systems(Startup, (setup, load_assets))
+    .add_systems(Update, (simulate_cars, loading_screen))
+    .add_observer(add_no_cpu_culling)
+    .add_observer(add_no_cpu_culling_on_scene_ready)
+    .add_observer(on_city_assets_ready)
+    .add_observer(setup_settings_ui);
+
+    app.add_systems(Update, apply_traffic_rules.before(simulate_cars));
+
+    app.run();
 }
 
 fn setup(mut commands: Commands, mut scattering_mediums: ResMut<Assets<ScatteringMedium>>) {
@@ -225,6 +240,7 @@ fn on_city_assets_ready(
 struct Road {
     start: Vec3,
     end: Vec3,
+    intersection: Entity,
 }
 
 #[derive(Component)]
@@ -232,11 +248,34 @@ struct Car {
     offset: Vec3,
     distance_traveled: f32,
     dir: f32,
+    car_state: CarState,
+    at_stop_state: CarAtStopState,
+    next_lane: Option<Entity>,
+}
+
+#[derive(PartialEq, Eq, Default)]
+pub enum CarState {
+    Accelerating,
+    #[default]
+    Driving,
+    Breaking,
+    Stopped,
+}
+
+#[derive(PartialEq, Eq, Default)]
+pub enum CarAtStopState {
+    #[default]
+    Default,
+    WaitForIntersection,
+    MoveOnIntersection,
+    WaitProtectedIntersection,
+    MoveOnProtectedIntersection,
 }
 
 fn simulate_cars(
     settings: Res<Settings>,
-    roads: Query<(&Road, &Transform, &Children), Without<Car>>,
+    roads: Query<(&Road, &Children), Without<Car>>,
+    car_positions: Query<&Car, Without<Road>>,
     mut cars: Query<(&mut Car, &mut Transform), Without<Road>>,
     time: Res<Time>,
 ) {
@@ -244,22 +283,95 @@ fn simulate_cars(
         return;
     }
     let speed = 1.5;
+    let minimum_gap = 0.5;
+
+    for (road, children) in &roads {
+        let road_len = (road.end - road.start).length();
+        let direction = (road.end - road.start).normalize();
+
+        // Snapshot distances from a read-only query before mutating anything
+        let distances: Vec<(Entity, f32, f32)> = children
+            .iter()
+            .filter_map(|e| {
+                car_positions
+                    .get(e)
+                    .ok()
+                    .map(|car| (e, car.distance_traveled, car.dir))
+            })
+            .collect();
 
-    for (road, _, children) in &roads {
-        for child in children {
-            let Ok((mut car, mut car_transform)) = cars.get_mut(*child) else {
+        for child in children.iter() {
+            let Ok((mut car, mut car_transform)) = cars.get_mut(child) else {
                 continue;
             };
 
-            car.distance_traveled += speed * time.delta_secs();
-            let road_len = (road.end - road.start).length();
-            if car.distance_traveled > road_len {
-                car.distance_traveled = 0.0;
+            if matches!(car.car_state, CarState::Stopped) {
+                continue;
+            }
+
+            let blocked = distances.iter().any(|&(e, other_d, other_dir)| {
+                e != child && other_dir == car.dir && {
+                    let gap = (other_d - car.distance_traveled) * car.dir;
+                    gap > 0.0 && gap < minimum_gap
+                }
+            });
+
+            if matches!(car.car_state, CarState::Breaking | CarState::Stopped)
+                && car.at_stop_state == CarAtStopState::Default
+            {
+                car.at_stop_state = CarAtStopState::WaitForIntersection;
+            }
+            let protected_turn =
+                car.next_lane.is_some() && car.next_lane != Some(road.intersection);
+            if matches!(car.at_stop_state, CarAtStopState::WaitForIntersection)
+                && !protected_turn
+                && !blocked
+            {
+                car.at_stop_state = CarAtStopState::MoveOnIntersection;
+            }
+
+            if !blocked {
+                car.distance_traveled += speed * time.delta_secs();
+                if car.distance_traveled > road_len {
+                    car.distance_traveled = 0.0;
+                }
             }
-            let direction = (road.end - road.start).normalize() * car.dir;
 
             let progress = car.distance_traveled / road_len;
-            car_transform.translation = (road.start + car.offset) + direction * road_len * progress;
+            car_transform.translation =
+                (road.start + car.offset) + direction * car.dir * road_len * progress;
+        }
+    }
+}
+
+fn apply_traffic_rules(
+    settings: Res<Settings>,
+    roads: Query<(&Road, &Children), Without<Car>>,
+    mut cars: Query<&mut Car>,
+    traffic_lights: Query<&traffic::TrafficLight>,
+    time: Res<Time>,
+) {
+    let elapsed = time.elapsed_secs();
+    let stop_distance = 0.4;
+    for (road, children) in &roads {
+        let Ok(light) = traffic_lights.get(road.intersection) else {
+            continue;
+        };
+        let phase = light.phase(elapsed);
+        for child in children.iter() {
+            let Ok(mut car) = cars.get_mut(child) else {
+                continue;
+            };
+            let road_len = (road.end - road.start).length();
+            let remaining = road_len - car.distance_traveled;
+            car.car_state = if settings.traffic_enabled
+                && remaining < stop_distance
+                && phase == traffic::TrafficLightPhase::Red
+            {
+                CarState::Stopped
+            } else {
+                CarState::Driving
+            };
         }
     }
 }
diff --git a/examples/large_scenes/bevy_city/src/settings.rs b/examples/large_scenes/bevy_city/src/settings.rs
index 858cf4898a961..ea1b65d62e1cf 100644
--- a/examples/large_scenes/bevy_city/src/settings.rs
+++ b/examples/large_scenes/bevy_city/src/settings.rs
@@ -19,6 +19,7 @@ use crate::{assets::CityAssets, CitySpawned};
 #[derive(Resource)]
 pub struct Settings {
     pub simulate_cars: bool,
+    pub traffic_enabled: bool,
     pub shadow_maps_enabled: bool,
     pub contact_shadows_enabled: bool,
     pub wireframe_enabled: bool,
@@ -29,6 +30,7 @@ impl Default for Settings {
     fn default() -> Self {
         Self {
             simulate_cars: true,
+            traffic_enabled: true,
             shadow_maps_enabled: true,
             contact_shadows_enabled: true,
             wireframe_enabled: false,
@@ -77,6 +79,15 @@ pub fn setup_settings_ui(_: On<CitySpawned>, mut commands: Commands) {
                         }
                     )
                 ),
+                (
+                    checkbox(Checked, Spawn((Text::new("Simulate traffic"), ThemedText))),
+                    observe(checkbox_self_update),
+                    observe(
+                        |change: On<ValueChange<bool>>, mut settings: ResMut<Settings>| {
+                            settings.traffic_enabled = change.value;
+                        }
+                    )
+                ),
                 (
                     checkbox(
                         Checked,
diff --git a/examples/large_scenes/bevy_city/src/traffic.rs b/examples/large_scenes/bevy_city/src/traffic.rs
new file mode 100644
index 0000000000000..e30d3b68bc57d
--- /dev/null
+++ b/examples/large_scenes/bevy_city/src/traffic.rs
@@ -0,0 +1,171 @@
+use crate::settings::Settings;
+use bevy::{prelude::*, scene::SceneInstanceReady};
+
+pub const RED_DURATION: f32 = 5.0;
+pub const YELLOW_DURATION: f32 = 2.0;
+pub const GREEN_DURATION: f32 = 5.0;
+pub const CYCLE_DURATION: f32 = RED_DURATION + YELLOW_DURATION + GREEN_DURATION;
+
+// Timing phase logic for traffic light
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TrafficLightPhase {
+    Red,
+    Yellow,
+    Green,
+}
+
+#[derive(Component)]
+pub struct TrafficLight {
+    pub time_offset: f32,
+    last_phase: Option<TrafficLightPhase>,
+    bulbs: Vec<(Entity, TrafficLightColor)>,
+}
+
+impl TrafficLight {
+    pub fn new(time_offset: f32) -> Self {
+        Self {
+            time_offset,
+            last_phase: None,
+            bulbs: Vec::new(),
+        }
+    }
+
+    pub fn phase(&self, time: f32) -> TrafficLightPhase {
+        let time_in_cycle = (time + self.time_offset).rem_euclid(CYCLE_DURATION);
+
+        if time_in_cycle < RED_DURATION {
+            TrafficLightPhase::Red
+        } else if time_in_cycle < RED_DURATION + YELLOW_DURATION {
+            TrafficLightPhase::Yellow
+        } else {
+            TrafficLightPhase::Green
+        }
+    }
+}
+
+// Component for each bulb on a traffic light, which is updated based on light's current phase
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TrafficLightColor {
+    Red,
+    Yellow,
+    Green,
+}
+
+#[derive(Resource)]
+pub struct TrafficLightMaterials {
+    pub red_on: Handle<StandardMaterial>,
+    pub red_off: Handle<StandardMaterial>,
+    pub yellow_on: Handle<StandardMaterial>,
+    pub yellow_off: Handle<StandardMaterial>,
+    pub green_on: Handle<StandardMaterial>,
+    pub green_off: Handle<StandardMaterial>,
+}
+
+pub struct TrafficPlugin;
+
+impl Plugin for TrafficPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Startup, setup_traffic_light_materials)
+            .add_systems(Update, update_bulb_materials)
+            .add_observer(on_traffic_light_scene_ready);
+    }
+}
+
+fn setup_traffic_light_materials(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.insert_resource(TrafficLightMaterials {
+        red_on: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.4, 0.0, 0.0),
+            emissive: LinearRgba::new(12.0, 0.0, 0.0, 1.0),
+            ..default()
+        }),
+        red_off: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.15, 0.02, 0.02),
+            ..default()
+        }),
+        yellow_on: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.4, 0.3, 0.0),
+            emissive: LinearRgba::new(10.0, 6.0, 0.0, 1.0),
+            ..default()
+        }),
+        yellow_off: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.15, 0.12, 0.02),
+            ..default()
+        }),
+        green_on: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.0, 0.4, 0.0),
+            emissive: LinearRgba::new(0.0, 12.0, 0.0, 1.0),
+            ..default()
+        }),
+        green_off: materials.add(StandardMaterial {
+            base_color: Color::srgb(0.02, 0.15, 0.02),
+            ..default()
+        }),
+    });
+}
+
+fn on_traffic_light_scene_ready(
+    trigger: On<SceneInstanceReady>,
+    mut traffic_lights: Query<&mut TrafficLight>,
+    children: Query<&Children>,
+    names: Query<&Name>,
+    mut mesh_materials: Query<&mut MeshMaterial3d<StandardMaterial>>,
+    light_materials: Res<TrafficLightMaterials>,
+) {
+    let root = trigger.entity;
+    let Ok(mut light) = traffic_lights.get_mut(root) else {
+        return;
+    };
+    for descendant in children.iter_descendants(root) {
+        let Ok(name) = names.get(descendant) else {
+            continue;
+        };
+        let color = match name.as_str() {
+            "RED_LIGHT" => TrafficLightColor::Red,
+            "YELLOW_LIGHT" => TrafficLightColor::Yellow,
+            "GREEN_LIGHT" => TrafficLightColor::Green,
+            _ => continue,
+        };
+        light.bulbs.push((descendant, color));
+        if let Ok(mut material) = mesh_materials.get_mut(descendant) {
+            material.0 = light_materials.red_off.clone();
+        }
+    }
+}
+
+fn update_bulb_materials(
+    settings: Res<Settings>,
+    mut traffic_lights: Query<&mut TrafficLight>,
+    mut mesh_materials: Query<&mut MeshMaterial3d<StandardMaterial>>,
+    time: Res<Time>,
+    materials: Res<TrafficLightMaterials>,
+) {
+    if !settings.traffic_enabled {
+        return;
+    }
+    let elapsed = time.elapsed_secs();
+    for mut light in traffic_lights.iter_mut() {
+        let phase = light.phase(elapsed);
+        if light.last_phase == Some(phase) {
+            continue;
+        }
+        light.last_phase = Some(phase);
+        for (entity, color) in &light.bulbs {
+            let Ok(mut material) = mesh_materials.get_mut(*entity) else {
+                continue;
+            };
+            material.0 = match (color, phase) {
+                (TrafficLightColor::Red, TrafficLightPhase::Red) => materials.red_on.clone(),
+                (TrafficLightColor::Red, _) => materials.red_off.clone(),
+                (TrafficLightColor::Yellow, TrafficLightPhase::Yellow) => {
+                    materials.yellow_on.clone()
+                }
+                (TrafficLightColor::Yellow, _) => materials.yellow_off.clone(),
+                (TrafficLightColor::Green, TrafficLightPhase::Green) => materials.green_on.clone(),
+                (TrafficLightColor::Green, _) => materials.green_off.clone(),
+            };
+        }
+    }
+}
diff --git a/examples/large_scenes/bevy_city/traffic_assets/street_light.glb b/examples/large_scenes/bevy_city/traffic_assets/street_light.glb
new file mode 100644
index 0000000000000..8fa03aad8cf36
Binary files /dev/null and b/examples/large_scenes/bevy_city/traffic_assets/street_light.glb differ