diff --git a/TODO b/TODO
deleted file mode 100644
index 03b002777..000000000
--- a/TODO
+++ /dev/null
@@ -1,42 +0,0 @@
-#### Important
-
-- Wrong world name in config should issue warning --> hazard protection doesn't do this on wither worlds
-
-#### IDEAS
-
-- [ ] portals need to be discovered before they can be used. (maybe overridable on a per-portal basis? for admins?)
-- [ ] tab shows ordered by world
-- [ ] angel shift scroll selects level or some percentage.
-- [ ] autostop at certain times. 12am 12pm
-- [ ] trampelpfad (a trail of path-block that is created automatically when players take a route often, could get fancy.)
-- [ ] add a mechanic to update in-game maps (e.g. with a custom item, or redstone)
-- [ ] player heads from /heads
-- [ ] lodestone portal scrolls teleport on top of the stone
-- [ ] world rebuild check for armor stands and item frames. don't let them be destroyed
-- [ ] minecart speed ++++++ only if player in minecart, or maybe with an extra type of minecart. is it time for the netherite minecart?
-- [ ] on first join message: e.g. for link to map and discord link
-
-- permission audit for all players with moderator level
-- sleep day -> get night
-- portal scrolls show total uses since creation
-- ultra infinity for all arrow types (put on arrow?)
-
-portal domes? projector like setup for full-dome or maybe even a sphere. good that this sentence makes no sense.
-limit range to prevent clutter and require multiple hops (either multiple hops in the menu o.
-
-- [ ] descr level bottle
-- [ ] bottle fill max
-
-- [ ] better pack icon
-- [ ] github readme banners
-- [ ] crafting recipes in readme
-- [ ] armor stand poser manipulation by perpendicular intersection between Line of sight and arm
-- [ ] item frame invisibilinator (visible if empty)
-- [ ] player list footer header configuration
-- [ ] transmutation tool copy pasta with direction awareness
-- [ ] sign editing (a tool ?)
-- [ ] add items to shulker box by right click with item in inventory on box?
-- [ ] Maybe "Advancements to guide you through most additions"
-- can we inherit spectator skins? maybe hook into data loading?
-- golden sickle -> golden mistletoe, mistel (viscum album)
-- used as enchantment binding agent/ catalyst?.
diff --git a/build.gradle.kts b/build.gradle.kts
index 2ce47f6a4..70026781e 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -10,6 +10,8 @@ dependencies {
 
 java {
 	toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+	sourceCompatibility = JavaVersion.VERSION_21
+	targetCompatibility = JavaVersion.VERSION_21
 }
 
 // We don't need to generate an empty `vane.jar`
@@ -40,9 +42,15 @@ subprojects {
 		maven("https://repo.bluecolored.de/releases")
 	}
 
+	java {
+		sourceCompatibility = JavaVersion.VERSION_21
+		targetCompatibility = JavaVersion.VERSION_21
+	}
+
 	tasks.withType<JavaCompile> {
 		options.compilerArgs.addAll(arrayOf("-Xlint:all", "-Xlint:-processing", "-Xdiags:verbose"))
 		options.encoding = "UTF-8"
+		options.release.set(21)
 	}
 
 	dependencies {
diff --git a/docs/index.html b/docs/index.html
index f2e3d92dd..13589f869 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -2159,6 +2159,15 @@ <h2>Portals &amp; Regions</h2>
 <ul>
 <li>Admins of the region can change the portal settings</li>
 <li>The visibility of the portal can be restricted to either players that have the portal permission or other portals that are in a region with the same region group.</li>
+</ul>
+<h2>Flight in Regions</h2>
+<p>Players with admin or friend roles in a region can fly within their claims using the <code>/fly</code> command.</p>
+<ul>
+<li>Upon entering a region where you have permissions, flight is automatically enabled—just double-jump to start flying.</li>
+<li>Use <code>/fly</code> to manually toggle flight on/off with visual feedback.</li>
+<li>Particle visualization shows region boundaries while flying, automatically updating when moving between regions.</li>
+<li>Fall damage protection is provided when exiting a region while airborne.</li>
+<li>Flight automatically disables when leaving the region or entering an area without permissions.</li>
 </ul></div>
 		<div class="clear-right"><!-- spacer --></div>
 	</div>
@@ -2440,7 +2449,7 @@ <h2 id="feature-vane-admin--graylist">
 </h2>
 <div id="body-feature-vane-admin--graylist" class="hidden">
 	<div class="p-5 border border-b-0 border-gray-200 dark:border-gray-700 dark:bg-gray-900">
-		<div class="prose prose-slate prose-img:rounded-xl prose-img:w-1/3 prose-img:sm:m-4 prose-img:w-full prose-img:sm:w-1/2 prose-img:lg:w-2/5 prose-img:min-w-32 prose-img:max-w-full prose-img:float-right prose-img:clear-right prose-h1:clear-right prose-h2:clear-right prose-img:float-right dark:prose-invert max-w-none"><h2>Graylist</h2>
+        <div class="prose prose-slate prose-img:rounded-xl prose-img:w-1/3 prose-img:sm:m-4 prose-img:w-full prose-img:sm:w-1/2 prose-img:lg:w-2/5 prose-img:min-w-32 prose-img:max-w-full prose-img:float-right prose-img:clear-right prose-h1:clear-right prose-h2:clear-right prose-img:float-right dark:prose-invert max-w-none"><h2>Graylist</h2>
 <p>Vane provides a feature similar to a graylist.
 This allows anyone to connect to your server but in a <em>no touch, only look!</em> kind of way.
 To modify anything about the world, a player must either be oped,
@@ -2451,6 +2460,12 @@ <h2 id="feature-vane-admin--graylist">
 <p>Why can't I build anything?</p>
 </blockquote>
 <p>This feature is <strong>disabled</strong> by default, as it often caused confusion.</p>
+<h3>Quick start</h3>
+<ul>
+<li>Enable in <code>vane-admin</code> config: set <code>world_protection.enabled: true</code>, then restart the server.</li>
+<li>Grant a newcomer build rights with <code>/perm add &lt;player&gt; user</code>.</li>
+<li>Or allow trusted members to vouch: give them <code>verified</code> via <code>/perm add &lt;player&gt; verified</code>, then they can <code>/vouch &lt;other_player&gt;</code>.</li>
+</ul>
 <h2>Vouching</h2>
 <p>When using <code>vane-permissions</code>, you can also allow trusted members of your community to vouch for other players.
 This allows them to lift a new user into the <code>users</code> group,
diff --git a/documentation/content/vane-admin/graylist.md b/documentation/content/vane-admin/graylist.md
index e217c5c2a..1d1906a84 100644
--- a/documentation/content/vane-admin/graylist.md
+++ b/documentation/content/vane-admin/graylist.md
@@ -18,6 +18,18 @@ you can assign a new player to the `user` group by executing `perm add player_na
 
 This feature is **disabled** by default, as it often caused confusion.
 
+### Quick start
+
+- Enable in `vane-admin` config: set `world_protection.enabled: true`, then restart the server.
+- Grant a newcomer build rights with `/perm add <player> user`.
+- Or allow trusted members to vouch: give them `verified` via `/perm add <player> verified`, then they can `/vouch <other_player>`.
+
+### Commands
+
+- `/perm add <player> user` — allow building (bypasses graylist).
+- `/perm add <player> verified` — let a player vouch others.
+- `/vouch <player>` — move a player to the `user` group.
+
 ## Vouching
 
 When using `vane-permissions`, you can also allow trusted members of your community to vouch for other players.
diff --git a/documentation/content/vane-regions/regions.md b/documentation/content/vane-regions/regions.md
index 441ee0ce6..2460c4cc6 100644
--- a/documentation/content/vane-regions/regions.md
+++ b/documentation/content/vane-regions/regions.md
@@ -38,3 +38,13 @@ If a portal is inside a region, some additional things apply:
 
 - Admins of the region can change the portal settings
 - The visibility of the portal can be restricted to either players that have the portal permission or other portals that are in a region with the same region group.
+
+## Flight in Regions
+
+Players with admin or friend roles in a region can fly within their claims using the `/fly` command.
+
+- Upon entering a region where you have permissions, flight is automatically enabled—just double-jump to start flying.
+- Use `/fly` to manually toggle flight on/off with visual feedback.
+- Particle visualization shows region boundaries while flying, automatically updating when moving between regions.
+- Fall damage protection is provided when exiting a region while airborne.
+- Flight automatically disables when leaving the region or entering an area without permissions.
diff --git a/vane-core/build.gradle.kts b/vane-core/build.gradle.kts
index 7c8397e35..b445c76fc 100644
--- a/vane-core/build.gradle.kts
+++ b/vane-core/build.gradle.kts
@@ -45,7 +45,7 @@ tasks {
             include(dependency("org.bstats:bstats-bukkit"))
             include(dependency("org.reflections:reflections"))
             include(dependency("org.json:json"))
-            include(dependency(":vane-annotations"))
+            include(project(":vane-annotations"))
             include(dependency("org.apache.commons:commons-lang3"))
             include(dependency("org.apache.commons:commons-text"))
         }
diff --git a/vane-portals/build.gradle.kts b/vane-portals/build.gradle.kts
index e604151b4..7ebcc2674 100644
--- a/vane-portals/build.gradle.kts
+++ b/vane-portals/build.gradle.kts
@@ -7,8 +7,7 @@ dependencies {
 }
 
 tasks {
-    shadowJar {
-        configurations = listOf()
-        relocate("org.json", "org.oddlama.vane.external.json")
-    }
+	shadowJar {
+		// No special configuration needed
+	}
 }
diff --git a/vane-regions/build.gradle.kts b/vane-regions/build.gradle.kts
index a664e3824..066ac20c7 100644
--- a/vane-regions/build.gradle.kts
+++ b/vane-regions/build.gradle.kts
@@ -10,7 +10,8 @@ dependencies {
 
 tasks {
     shadowJar {
-        configurations = listOf()
-        relocate("org.json", "org.oddlama.vane.external.json")
+        dependencies {
+            include(dependency(":vane-portals"))
+        }
     }
 }
diff --git a/vane-regions/src/main/java/org/oddlama/vane/regions/RegionFlyManager.java b/vane-regions/src/main/java/org/oddlama/vane/regions/RegionFlyManager.java
new file mode 100644
index 000000000..9fd69bd07
--- /dev/null
+++ b/vane-regions/src/main/java/org/oddlama/vane/regions/RegionFlyManager.java
@@ -0,0 +1,245 @@
+package org.oddlama.vane.regions;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.UUID;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerGameModeChangeEvent;
+import org.bukkit.event.player.PlayerToggleFlightEvent;
+import org.oddlama.vane.core.Listener;
+import org.oddlama.vane.core.module.Context;
+import org.oddlama.vane.regions.region.Region;
+import org.oddlama.vane.regions.region.RoleSetting;
+
+public class RegionFlyManager extends Listener<Regions> {
+    
+    // Track which players are flying via the region fly feature
+    // Maps player UUID -> region they were in when they enabled flying
+    private Map<UUID, UUID> flying_players = new HashMap<>();
+    
+    // Track players who have auto-fly enabled (allowFlight but not actively flying)
+    private Map<UUID, UUID> auto_fly_enabled = new HashMap<>();
+    
+    // Track players who are protected from fall damage after leaving a region
+    private Map<UUID, Long> fall_damage_protected = new HashMap<>();
+
+    // Track players who manually disabled flight via /fly (opt-out of auto-fly)
+    private HashSet<UUID> manual_fly_opt_out = new HashSet<>();
+    
+    public RegionFlyManager(Context<Regions> context) {
+        super(context);
+    }
+    
+    public void add_flying_player(final UUID player_id, final Region region) {
+        flying_players.put(player_id, region.id());
+        // Also add to auto-fly when manually enabling
+        auto_fly_enabled.put(player_id, region.id());
+        // Clear manual opt-out when explicitly enabling
+        manual_fly_opt_out.remove(player_id);
+    }
+    
+    public void remove_flying_player(final UUID player_id) {
+        flying_players.remove(player_id);
+        auto_fly_enabled.remove(player_id);
+    }
+
+    public void set_manual_opt_out(final UUID player_id, final boolean opt_out) {
+        if (opt_out) {
+            manual_fly_opt_out.add(player_id);
+        } else {
+            manual_fly_opt_out.remove(player_id);
+        }
+    }
+
+    public boolean is_manual_opt_out(final UUID player_id) {
+        return manual_fly_opt_out.contains(player_id);
+    }
+    
+    public boolean is_region_flying(final UUID player_id) {
+        return flying_players.containsKey(player_id) || auto_fly_enabled.containsKey(player_id);
+    }
+    
+    public boolean is_actively_flying(final UUID player_id) {
+        return flying_players.containsKey(player_id);
+    }
+    
+    private boolean can_fly_in_region(final Player player, final Region region) {
+        if (region == null) {
+            return false;
+        }
+        
+        final var group = region.region_group(get_module());
+        final var role = group.get_role(player.getUniqueId());
+        
+        // Check if player has BUILD permission (which friends and admins have)
+        // or ADMIN permission
+        return role.get_setting(RoleSetting.ADMIN) || role.get_setting(RoleSetting.BUILD);
+    }
+    
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on_player_move(final PlayerMoveEvent event) {
+        final var player = event.getPlayer();
+        final var player_id = player.getUniqueId();
+        
+        // Skip if player is in creative or spectator mode (they can fly anyway)
+        if (player.getGameMode() == GameMode.CREATIVE || player.getGameMode() == GameMode.SPECTATOR) {
+            return;
+        }
+        
+        // Only proceed when the player actually changed block coordinates
+        if (!event.hasChangedBlock()) {
+            return;
+        }
+        
+        // Check current region
+        final var current_region = get_module().region_at(event.getTo());
+        final var old_region_id = flying_players.get(player_id);
+        final var auto_fly_region_id = auto_fly_enabled.get(player_id);
+        
+        // Check if they can fly in the current region
+        final boolean can_fly = can_fly_in_region(player, current_region);
+        
+        if (is_region_flying(player_id)) {
+            // Player has fly enabled (either actively or auto)
+            if (!can_fly) {
+                // They left the region or don't have permission anymore
+                disable_flying(player);
+            } else if (current_region != null && 
+                       old_region_id != null && 
+                       !current_region.id().equals(old_region_id)) {
+                // They entered a different region where they have permissions (and are actively flying)
+                flying_players.put(player_id, current_region.id());
+                auto_fly_enabled.put(player_id, current_region.id());
+                // Update visualization to show new region boundaries
+                get_module().start_visualizing_region(player_id, current_region);
+            } else if (current_region != null && 
+                       auto_fly_region_id != null && 
+                       !current_region.id().equals(auto_fly_region_id)) {
+                // Update auto-fly region tracking
+                auto_fly_enabled.put(player_id, current_region.id());
+                // Update visualization if they're actively flying
+                if (player.isFlying()) {
+                    get_module().start_visualizing_region(player_id, current_region);
+                }
+            }
+        } else if (can_fly && !player.getAllowFlight()) {
+            // Player entered a region where they can fly - enable auto-fly
+            // only if they didn't manually opt-out via /fly and don't already
+            // have flight from another source (e.g. Essentials /fly)
+            if (!is_manual_opt_out(player_id)) {
+                player.setAllowFlight(true);
+                auto_fly_enabled.put(player_id, current_region.id());
+            }
+        }
+    }
+    
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void on_player_toggle_flight(final PlayerToggleFlightEvent event) {
+        final var player = event.getPlayer();
+        final var player_id = player.getUniqueId();
+        
+        // Skip if player is in creative or spectator mode
+        if (player.getGameMode() == GameMode.CREATIVE || player.getGameMode() == GameMode.SPECTATOR) {
+            return;
+        }
+        
+        // Check if player has auto-fly enabled and is starting to fly
+        if (event.isFlying() && auto_fly_enabled.containsKey(player_id)) {
+            final var region_id = auto_fly_enabled.get(player_id);
+            get_module().all_regions().stream()
+                .filter(r -> r.id().equals(region_id))
+                .findFirst()
+                .ifPresent(region -> {
+                    // Mark as actively flying
+                    flying_players.put(player_id, region_id);
+                    // Start visualizing the region
+                    get_module().start_visualizing_region(player_id, region);
+                });
+        }
+    }
+    
+    private void disable_flying(final Player player) {
+        final var player_id = player.getUniqueId();
+        
+        // Don't disable flight for creative/spectator players
+        if (player.getGameMode() == GameMode.CREATIVE || player.getGameMode() == GameMode.SPECTATOR) {
+            remove_flying_player(player_id);
+            return;
+        }
+        
+        // Disable flying
+        player.setAllowFlight(false);
+        player.setFlying(false);
+        
+        // Stop visualizing the region
+        get_module().stop_visualizing_region(player_id);
+        
+        // Stop all downward velocity immediately to prevent momentum damage
+        final var velocity = player.getVelocity();
+        if (velocity.getY() < 0) {
+            player.setVelocity(velocity.setY(0));
+        }
+        
+        // Reset fall distance to prevent accumulated fall damage
+        player.setFallDistance(0);
+        
+        // Enable fall damage protection
+        fall_damage_protected.put(player_id, System.currentTimeMillis());
+        
+        // No messages - silent auto-disable
+        remove_flying_player(player_id);
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void on_fall_damage(final EntityDamageEvent event) {
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        
+        if (event.getCause() != EntityDamageEvent.DamageCause.FALL) {
+            return;
+        }
+        
+        final var player_id = player.getUniqueId();
+        
+        // Check if player is protected from fall damage
+        final var protection_time = fall_damage_protected.remove(player_id);
+        if (protection_time != null) {
+            final long elapsed = System.currentTimeMillis() - protection_time;
+            if (elapsed < get_module().config_fall_damage_protection_ms) {
+                event.setCancelled(true);
+            }
+        }
+    }
+    
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void on_player_quit(final PlayerQuitEvent event) {
+        final var player_id = event.getPlayer().getUniqueId();
+        // Clean up when player quits
+        remove_flying_player(player_id);
+        fall_damage_protected.remove(player_id);
+        // Also stop visualizing
+        get_module().stop_visualizing_region(player_id);
+    }
+    
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void on_gamemode_change(final PlayerGameModeChangeEvent event) {
+        final var player = event.getPlayer();
+        final var new_mode = event.getNewGameMode();
+        
+        // If switching to creative or spectator, remove from tracking
+        // (they can fly anyway)
+        if (new_mode == GameMode.CREATIVE || new_mode == GameMode.SPECTATOR) {
+            remove_flying_player(player.getUniqueId());
+        }
+    }
+}
+
+
diff --git a/vane-regions/src/main/java/org/oddlama/vane/regions/Regions.java b/vane-regions/src/main/java/org/oddlama/vane/regions/Regions.java
index 286494b82..31bd3ab2e 100644
--- a/vane-regions/src/main/java/org/oddlama/vane/regions/Regions.java
+++ b/vane-regions/src/main/java/org/oddlama/vane/regions/Regions.java
@@ -16,7 +16,7 @@
 import java.util.logging.Level;
 import java.util.stream.Collectors;
 import net.minecraft.core.BlockPos;
-import org.oddlama.vane.external.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.bukkit.Chunk;
 import org.bukkit.Color;
 import org.bukkit.Location;
@@ -43,6 +43,7 @@
 import org.oddlama.vane.annotation.config.ConfigBoolean;
 import org.oddlama.vane.annotation.config.ConfigDouble;
 import org.oddlama.vane.annotation.config.ConfigInt;
+import org.oddlama.vane.annotation.config.ConfigLong;
 import org.oddlama.vane.annotation.config.ConfigMaterial;
 import org.oddlama.vane.annotation.lang.LangMessage;
 import org.oddlama.vane.annotation.persistent.Persistent;
@@ -64,7 +65,7 @@
 import org.oddlama.vane.regions.region.RoleSetting;
 import org.oddlama.vane.util.StorageUtil;
 
-@VaneModule(name = "regions", bstats = 8643, config_version = 4, lang_version = 3, storage_version = 1)
+@VaneModule(name = "regions", bstats = 8643, config_version = 4, lang_version = 4, storage_version = 1)
 public class Regions extends Module<Regions> {
     //
     //                                                  ┌───────────────────────┐
@@ -158,6 +159,13 @@ public class Regions extends Module<Regions> {
     )
     public double config_cost_y_multiplicator;
 
+    @ConfigLong(
+        def = 15000,
+        min = 0,
+        desc = "Duration in milliseconds to protect players from fall damage after flight is disabled when leaving a permitted region."
+    )
+    public long config_fall_damage_protection_ms;
+
     // Primary storage for all regions (region.id → region)
     @Persistent
     private Map<UUID, Region> storage_regions = new HashMap<>();
@@ -179,16 +187,38 @@ public class Regions extends Module<Regions> {
     // No key → Player not in selection mode
     // extent.min or extent.max null → Selection mode active, but no selection has been made yet
     private Map<UUID, RegionSelection> region_selections = new HashMap<>();
+    
+    // A map containing regions being visualized by players
+    private Map<UUID, Region> region_visualizations = new HashMap<>();
 
     @LangMessage
     public TranslatedMessage lang_start_region_selection;
 
+    @LangMessage
+    public TranslatedMessage lang_fly_enabled;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_disabled;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_not_in_region;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_no_permission;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_disabled_safe_landing;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_disabled_region_exit;
+
     // This permission allows players (usually admins) to always administrate
     // any region (rename, delete), regardless of whether other restrictions
     // would block access.
     public final Permission admin_permission;
 
     public RegionMenuGroup menus;
+    public RegionFlyManager fly_manager;
 
     public RegionDynmapLayer dynmap_layer;
     public RegionBlueMapLayer blue_map_layer;
@@ -205,11 +235,13 @@ public Regions() {
         environment_overrides = new RegionGlobalEnvironmentOverrides(this);
 
         new org.oddlama.vane.regions.commands.Region(this);
+        new org.oddlama.vane.regions.commands.Fly(this);
 
         new RegionEnvironmentSettingEnforcer(this);
         new RegionRoleSettingEnforcer(this);
 
         new RegionSelectionListener(this);
+        fly_manager = new RegionFlyManager(this);
         dynmap_layer = new RegionDynmapLayer(this);
         blue_map_layer = new RegionBlueMapLayer(this);
 
@@ -287,6 +319,18 @@ public boolean is_selecting_region(final Player player) {
     public RegionSelection get_region_selection(final Player player) {
         return region_selections.get(player.getUniqueId());
     }
+    
+    public void start_visualizing_region(final UUID player_id, final Region region) {
+        region_visualizations.put(player_id, region);
+    }
+    
+    public void stop_visualizing_region(final UUID player_id) {
+        region_visualizations.remove(player_id);
+    }
+    
+    public boolean is_visualizing_region(final UUID player_id) {
+        return region_visualizations.containsKey(player_id);
+    }
 
     private static final int visualize_max_particles = 20000;
     private static final int visualize_particles_per_block = 12;
@@ -294,7 +338,7 @@ public RegionSelection get_region_selection(final Player player) {
     private static final DustOptions visualize_dust_invalid = new DustOptions(Color.fromRGB(230, 60, 11), 1.0f);
     private static final DustOptions visualize_dust_valid = new DustOptions(Color.fromRGB(120, 220, 60), 1.0f);
 
-    private void visualize_edge(final World world, final BlockPos c1, final BlockPos c2, final boolean valid) {
+    private void visualize_edge(final World world, final BlockPos c1, final BlockPos c2, final boolean valid, final Player viewer) {
         // Unfortunately, particle spawns are normally distributed.
         // To still have a good visualization, we need to calculate a stddev that looks
         // good.
@@ -313,8 +357,8 @@ private void visualize_edge(final World world, final BlockPos c1, final BlockPos
         dy *= visualize_stddev_compensation;
         dz *= visualize_stddev_compensation;
 
-        // Spawn base particles
-        world.spawnParticle(
+        // Spawn base particles (local to viewer)
+        viewer.spawnParticle(
             Particle.END_ROD,
             mx,
             my,
@@ -323,13 +367,11 @@ private void visualize_edge(final World world, final BlockPos c1, final BlockPos
             dx,
             dy,
             dz,
-            0.0, // speed
-            null, // data
-            true
-        ); // force
+            0.0 // speed
+        );
 
-        // Spawn colored particles indicating validity
-        world.spawnParticle(
+        // Spawn colored particles indicating validity (local to viewer)
+        viewer.spawnParticle(
             Particle.DUST,
             mx,
             my,
@@ -339,12 +381,12 @@ private void visualize_edge(final World world, final BlockPos c1, final BlockPos
             dy,
             dz,
             0.0, // speed
-            valid ? visualize_dust_valid : visualize_dust_invalid, // data
-            true
-        ); // force
+            valid ? visualize_dust_valid : visualize_dust_invalid // data
+        );
     }
 
     private void visualize_selections() {
+        // Visualize region selections
         for (final var selection_owner : region_selections.keySet()) {
             final var selection = region_selections.get(selection_owner);
             if (selection == null) {
@@ -390,19 +432,68 @@ private void visualize_selections() {
             final var G = new BlockPos(hx, hy, hz);
             final var H = new BlockPos(lx, hy, hz);
 
-            // Visualize each edge
-            visualize_edge(world, A, B, valid);
-            visualize_edge(world, B, C, valid);
-            visualize_edge(world, C, D, valid);
-            visualize_edge(world, D, A, valid);
-            visualize_edge(world, E, F, valid);
-            visualize_edge(world, F, G, valid);
-            visualize_edge(world, G, H, valid);
-            visualize_edge(world, H, E, valid);
-            visualize_edge(world, A, E, valid);
-            visualize_edge(world, B, F, valid);
-            visualize_edge(world, C, G, valid);
-            visualize_edge(world, D, H, valid);
+            // Visualize each edge (local to player)
+            visualize_edge(world, A, B, valid, player);
+            visualize_edge(world, B, C, valid, player);
+            visualize_edge(world, C, D, valid, player);
+            visualize_edge(world, D, A, valid, player);
+            visualize_edge(world, E, F, valid, player);
+            visualize_edge(world, F, G, valid, player);
+            visualize_edge(world, G, H, valid, player);
+            visualize_edge(world, H, E, valid, player);
+            visualize_edge(world, A, E, valid, player);
+            visualize_edge(world, B, F, valid, player);
+            visualize_edge(world, C, G, valid, player);
+            visualize_edge(world, D, H, valid, player);
+        }
+        
+        // Visualize existing regions
+        for (final var visualize_owner : region_visualizations.keySet()) {
+            final var region = region_visualizations.get(visualize_owner);
+            if (region == null) {
+                continue;
+            }
+
+            // Get player for visualization
+            final var offline_player = getServer().getOfflinePlayer(visualize_owner);
+            if (!offline_player.isOnline()) {
+                continue;
+            }
+            final var player = offline_player.getPlayer();
+
+            // Get the region extent
+            final var extent = region.extent();
+            final var world = getServer().getWorld(extent.world());
+            if (world == null) {
+                continue;
+            }
+
+            final var min = extent.min();
+            final var max = extent.max();
+
+            // Corners
+            final var A = new BlockPos(min.getX(), min.getY(), min.getZ());
+            final var B = new BlockPos(max.getX(), min.getY(), min.getZ());
+            final var C = new BlockPos(max.getX(), max.getY(), min.getZ());
+            final var D = new BlockPos(min.getX(), max.getY(), min.getZ());
+            final var E = new BlockPos(min.getX(), min.getY(), max.getZ());
+            final var F = new BlockPos(max.getX(), min.getY(), max.getZ());
+            final var G = new BlockPos(max.getX(), max.getY(), max.getZ());
+            final var H = new BlockPos(min.getX(), max.getY(), max.getZ());
+
+            // Visualize each edge - always valid (green) and local to player
+            visualize_edge(world, A, B, true, player);
+            visualize_edge(world, B, C, true, player);
+            visualize_edge(world, C, D, true, player);
+            visualize_edge(world, D, A, true, player);
+            visualize_edge(world, E, F, true, player);
+            visualize_edge(world, F, G, true, player);
+            visualize_edge(world, G, H, true, player);
+            visualize_edge(world, H, E, true, player);
+            visualize_edge(world, A, E, true, player);
+            visualize_edge(world, B, F, true, player);
+            visualize_edge(world, C, G, true, player);
+            visualize_edge(world, D, H, true, player);
         }
     }
 
@@ -675,8 +766,11 @@ public RegionGroup get_or_create_default_region_group(final Player owner) {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void on_player_quit(final PlayerQuitEvent event) {
+        final var player_id = event.getPlayer().getUniqueId();
         // Remove pending selection
         cancel_region_selection(event.getPlayer());
+        // Remove region visualization
+        stop_visualizing_region(player_id);
     }
 
     @EventHandler
diff --git a/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Fly.java b/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Fly.java
new file mode 100644
index 000000000..46f388fe5
--- /dev/null
+++ b/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Fly.java
@@ -0,0 +1,95 @@
+package org.oddlama.vane.regions.commands;
+
+import static com.mojang.brigadier.Command.SINGLE_SUCCESS;
+
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import org.bukkit.entity.Player;
+import org.oddlama.vane.annotation.command.Aliases;
+import org.oddlama.vane.annotation.command.Name;
+import org.oddlama.vane.annotation.lang.LangMessage;
+import org.oddlama.vane.core.command.Command;
+import org.oddlama.vane.core.lang.TranslatedMessage;
+import org.oddlama.vane.core.module.Context;
+import org.oddlama.vane.regions.Regions;
+import org.oddlama.vane.regions.region.RoleSetting;
+
+@Name("fly")
+@Aliases({ "regionfly" })
+public class Fly extends Command<Regions> {
+
+    @LangMessage
+    public TranslatedMessage lang_fly_enabled;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_disabled;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_not_in_region;
+
+    @LangMessage
+    public TranslatedMessage lang_fly_no_permission;
+
+    public Fly(Context<Regions> context) {
+        super(context);
+    }
+
+    @Override
+    public LiteralArgumentBuilder<CommandSourceStack> get_command_base() {
+        return super.get_command_base()
+            .then(help())
+            .requires(ctx -> ctx.getSender() instanceof Player)
+            .executes(ctx -> {
+                toggle_fly((Player) ctx.getSource().getSender());
+                return SINGLE_SUCCESS;
+            });
+    }
+
+    private void toggle_fly(Player player) {
+        // Check if player is in a region
+        final var region = get_module().region_at(player.getLocation());
+        
+        if (region == null) {
+            lang_fly_not_in_region.send(player);
+            return;
+        }
+
+        // Get the region group and check permissions
+        final var group = region.region_group(get_module());
+        final var role = group.get_role(player.getUniqueId());
+        
+        // Check if player has BUILD permission (which friends and admins have)
+        // or ADMIN permission
+        final boolean hasPermission = role.get_setting(RoleSetting.ADMIN) || 
+                                     role.get_setting(RoleSetting.BUILD);
+        
+        if (!hasPermission) {
+            lang_fly_no_permission.send(player);
+            return;
+        }
+
+        // Toggle flying
+        if (player.getAllowFlight()) {
+            // Disable flying
+            player.setAllowFlight(false);
+            player.setFlying(false);
+            get_module().fly_manager.remove_flying_player(player.getUniqueId());
+            // Set manual opt-out so auto-fly won't re-enable until toggled again
+            get_module().fly_manager.set_manual_opt_out(player.getUniqueId(), true);
+            // Stop visualizing the region
+            get_module().stop_visualizing_region(player.getUniqueId());
+            lang_fly_disabled.send(player);
+        } else {
+            // Enable flying
+            player.setAllowFlight(true);
+            player.setFlying(true);
+            get_module().fly_manager.add_flying_player(player.getUniqueId(), region);
+            // Clear manual opt-out now that the player opted in again
+            get_module().fly_manager.set_manual_opt_out(player.getUniqueId(), false);
+            // Start visualizing the region
+            get_module().start_visualizing_region(player.getUniqueId(), region);
+            lang_fly_enabled.send(player);
+        }
+    }
+}
+
diff --git a/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Region.java b/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Region.java
index 5b8e17cf1..2ab0c1710 100644
--- a/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Region.java
+++ b/vane-regions/src/main/java/org/oddlama/vane/regions/commands/Region.java
@@ -8,6 +8,8 @@
 import org.oddlama.vane.annotation.command.Aliases;
 import org.oddlama.vane.annotation.command.Name;
 import org.oddlama.vane.core.command.Command;
+import org.oddlama.vane.annotation.lang.LangMessage;
+import org.oddlama.vane.core.lang.TranslatedMessage;
 import org.oddlama.vane.core.module.Context;
 import org.oddlama.vane.regions.Regions;
 
@@ -15,6 +17,15 @@
 @Aliases({ "regions", "rg" })
 public class Region extends Command<Regions> {
 
+    @LangMessage
+    public TranslatedMessage lang_visualize_disabled;
+
+    @LangMessage
+    public TranslatedMessage lang_visualize_not_in_region;
+
+    @LangMessage
+    public TranslatedMessage lang_visualize_enabled;
+
     public Region(Context<Regions> context) {
         super(context);
     }
@@ -23,6 +34,14 @@ public Region(Context<Regions> context) {
     public LiteralArgumentBuilder<CommandSourceStack> get_command_base() {
         return super.get_command_base()
             .then(help())
+            .then(
+                LiteralArgumentBuilder.<CommandSourceStack>literal("visualize")
+                    .requires(ctx -> ctx.getSender() instanceof Player)
+                    .executes(ctx -> {
+                        toggle_region_visualization((Player) ctx.getSource().getSender());
+                        return SINGLE_SUCCESS;
+                    })
+            )
             .requires(ctx -> ctx.getSender() instanceof Player)
             .executes(ctx -> {
                 open_menu((Player) ctx.getSource().getSender());
@@ -33,4 +52,22 @@ public LiteralArgumentBuilder<CommandSourceStack> get_command_base() {
     private void open_menu(Player player) {
         get_module().menus.main_menu.create(player).open(player);
     }
+    
+    private void toggle_region_visualization(Player player) {
+        final var player_id = player.getUniqueId();
+        
+        if (get_module().is_visualizing_region(player_id)) {
+            get_module().stop_visualizing_region(player_id);
+            lang_visualize_disabled.send(player);
+        } else {
+            final var region = get_module().region_at(player.getLocation());
+            if (region == null) {
+                lang_visualize_not_in_region.send(player);
+                return;
+            }
+            
+            get_module().start_visualizing_region(player_id, region);
+            lang_visualize_enabled.send(player);
+        }
+    }
 }
diff --git a/vane-regions/src/main/resources/lang-en.yml b/vane-regions/src/main/resources/lang-en.yml
index d24052f95..bc811a049 100644
--- a/vane-regions/src/main/resources/lang-en.yml
+++ b/vane-regions/src/main/resources/lang-en.yml
@@ -12,7 +12,7 @@
 
 # DO NOT CHANGE! The version of this language file. Used to determine
 # if the file needs to be updated.
-version: 3
+version: 4
 # The corresponding language code used in resource packs. Used for
 # resource pack generation. Typically, this is a combination of the
 # language code (ISO 639) and the country code (ISO 3166).
@@ -34,11 +34,34 @@ select_primary_block: "§aSelected (%1$s§a, %2$s§a, %3$s§a) as primary block.
 # %3$s: Block Z
 select_secondary_block: "§aSelected (%1$s§a, %2$s§a, %3$s§a) as secondary block."
 
+# This message is sent when flying is enabled in a region.
+fly_enabled: "§aFlight enabled! You can fly in regions where you have permission."
+# This message is sent when flying is manually disabled.
+fly_disabled: "§cFlight disabled."
+# This message is sent when the player tries to use /fly but is not in a region.
+fly_not_in_region: "§cYou must be inside a region to use this command."
+# This message is sent when the player tries to use /fly but doesn't have permission.
+fly_no_permission: "§cYou don't have permission to fly here. Ask the region owner for friend or admin role."
+# This message is sent when flying is disabled because the player left the region and they are protected from fall damage.
+fly_disabled_safe_landing: "§eYou left the area! Flight disabled but you're protected from fall damage."
+# This message is sent when flying is disabled because the player left the region but they were close to the ground.
+fly_disabled_region_exit: "§eYou left the area! Flight disabled."
+
 command_region:
   usage: "%1$s"
   description: "Open the region management menu."
   help: "Execute to open the region management menu."
 
+command_fly:
+  usage: "%1$s"
+  description: "Toggle flying in regions where you have permission."
+  help: "Execute to toggle flying. You must be in a region where you have friend or admin permissions."
+
+# Region visualization toggle messages
+visualize_disabled: "§cRegion visualization disabled."
+visualize_not_in_region: "§cYou must be inside a region to visualize it."
+visualize_enabled: "§aVisualizing region boundaries. Use §b/region visualize§a again to disable."
+
 dynmap:
   # The label for the dynmap layer
   layer_label: "Regions"