diff --git a/Engine/Game/Multiplayer/session_model.h b/Engine/Game/Multiplayer/session_model.h
index a2f7ef5..be3aeda 100644
--- a/Engine/Game/Multiplayer/session_model.h
+++ b/Engine/Game/Multiplayer/session_model.h
@@ -11,6 +11,7 @@
 #include <vector>
 
 namespace dingosdk {
+constexpr unsigned max_map_rotation = 1440; // minutes a server's rotation keeps one map, at most
 struct MultiplayerLobby {
     std::uint64_t id{}, owner{};
     std::string name, map, code;
@@ -140,6 +141,9 @@ struct MultiplayerModel {
     unsigned server_ban_total{};
     // For its admins: the levels (assets) the dedicated server can switch to.
     std::vector<std::string> server_maps;
+    std::vector<std::string> server_map_pool; // in rotation order; empty: every map
+    unsigned server_map_rotation{};           // minutes per map (0: off)
+    bool server_map_votes{};                  // players may vote for a map
     MultiplayerHostPreferences saved_host;
     bool force_world_layers{};
     std::uint64_t host_id{};
diff --git a/Extension/Multiplayer/Net/protocol.cpp b/Extension/Multiplayer/Net/protocol.cpp
index 559ab56..4a55395 100644
--- a/Extension/Multiplayer/Net/protocol.cpp
+++ b/Extension/Multiplayer/Net/protocol.cpp
@@ -356,7 +356,8 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
          })))
         throw std::invalid_argument("Invalid ban list");
     if (p.kind == PacketKind::maps &&
-        (!p.source || p.maps.size() > max_server_maps ||
+        (!p.source || p.maps.size() > max_server_maps || !valid_map_pool(p.map_pool, p.maps.size()) ||
+         p.map_rotation > max_map_rotation ||
          std::any_of(p.maps.begin(), p.maps.end(), [](const auto &asset) { return !valid_map_asset(asset); })))
         throw std::invalid_argument("Invalid server map list");
     if (p.kind == PacketKind::hello && !p.text.empty() && !valid_member_name(p.text))
@@ -366,6 +367,8 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
     if (p.kind == PacketKind::map_offer &&
         (!valid_map_destination(p.destination) || p.map != map_hash(p.destination)))
         throw std::invalid_argument("Invalid host map destination");
+    if ((p.kind == PacketKind::map_offer || p.kind == PacketKind::world_state) && !valid_map_label(p.map_label))
+        throw std::invalid_argument("Invalid map name");
     if (p.kind == PacketKind::world_state &&
         (p.destination.empty() ? (p.map != 0 || p.world_ready)
                                : (!valid_map_destination(p.destination) || p.map != map_hash(p.destination))))
@@ -408,6 +411,8 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
             w.integer(p.map_authorized ? 1 : 0, 1);
             w.integer(p.destination.size(), 2);
             w.bytes.insert(w.bytes.end(), p.destination.begin(), p.destination.end());
+            w.integer(p.map_label.size(), 1);
+            w.bytes.insert(w.bytes.end(), p.map_label.begin(), p.map_label.end());
         }
         if (p.kind == PacketKind::hello) {
             w.integer(p.text.size(), 1);
@@ -418,6 +423,8 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
         w.integer(p.world_ready ? 1 : 0, 1);
         w.integer(p.destination.size(), 2);
         w.bytes.insert(w.bytes.end(), p.destination.begin(), p.destination.end());
+        w.integer(p.map_label.size(), 1);
+        w.bytes.insert(w.bytes.end(), p.map_label.begin(), p.map_label.end());
     } else if (p.kind == PacketKind::world_ready) {
         w.integer(p.world_ready ? 1 : 0, 1);
     } else if (p.kind == PacketKind::pose) {
@@ -515,6 +522,9 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
             w.integer(asset.size(), 1);
             w.bytes.insert(w.bytes.end(), asset.begin(), asset.end());
         }
+        w.integer(p.map_pool.size(), 2);
+        for (const auto index : p.map_pool) w.integer(index, 2);
+        w.integer(p.map_rotation, 2);
     }
     if (p.kind == PacketKind::bans) {
         w.integer(p.ban_total, 4);
@@ -592,6 +602,13 @@ std::vector<std::uint8_t> encode(const Packet &p, bool compact_pose, std::uint32
         w.bytes[8 + i] = static_cast<std::uint8_t>(actual_payload >> (8 * i));
     return std::move(w.bytes);
 }
+static bool read_map_label(Reader &r, std::span<const std::uint8_t> bytes, Packet &p) {
+    const auto length = r.integer(1);
+    if (length > max_member_name || length > bytes.size() - r.at) return false;
+    p.map_label.assign(reinterpret_cast<const char *>(bytes.data() + r.at), static_cast<std::size_t>(length));
+    r.at += static_cast<std::size_t>(length);
+    return valid_map_label(p.map_label);
+}
 std::optional<Packet> decode(std::span<const std::uint8_t> bytes) noexcept {
     try {
         if (bytes.size() < header_size || bytes.size() > max_packet)
@@ -630,7 +647,7 @@ std::optional<Packet> decode(std::span<const std::uint8_t> bytes) noexcept {
                 p.destination.assign(reinterpret_cast<const char *>(bytes.data() + r.at),
                                      static_cast<std::size_t>(length));
                 r.at += static_cast<std::size_t>(length);
-                if (!valid_map_destination(p.destination) || p.map != map_hash(p.destination))
+                if (!valid_map_destination(p.destination) || p.map != map_hash(p.destination) || !read_map_label(r, bytes, p))
                     return {};
             }
             if (p.kind == PacketKind::hello) {
@@ -655,6 +672,7 @@ std::optional<Packet> decode(std::span<const std::uint8_t> bytes) noexcept {
                 if (p.destination.empty() ? (p.map != 0 || p.world_ready)
                                           : (!valid_map_destination(p.destination) || p.map != map_hash(p.destination)))
                     return {};
+                if (!read_map_label(r, bytes, p)) return {};
             }
         } else if (p.kind == PacketKind::pose) {
             const auto skater = r.integer(2), board = r.integer(2);
@@ -789,6 +807,11 @@ std::optional<Packet> decode(std::span<const std::uint8_t> bytes) noexcept {
                 if (!valid_map_asset(asset)) return {};
                 p.maps.push_back(std::move(asset));
             }
+            const auto pooled = r.integer(2);
+            if (pooled > p.maps.size()) return {};
+            for (std::uint64_t i = 0; i < pooled; ++i) p.map_pool.push_back(static_cast<std::uint16_t>(r.integer(2)));
+            p.map_rotation = static_cast<std::uint16_t>(r.integer(2));
+            if (!valid_map_pool(p.map_pool, p.maps.size()) || p.map_rotation > max_map_rotation) return {};
         } else if (p.kind == PacketKind::bans) {
             p.ban_total = static_cast<std::uint32_t>(r.integer(4));
             const auto count = r.integer(2);
@@ -958,6 +981,15 @@ bool valid_map_asset(std::string_view asset) noexcept {
     return !asset.empty() && asset.size() <= max_map_asset &&
            std::all_of(asset.begin(), asset.end(), [](char c) { return c > 32 && c < 127 && c != '|'; });
 }
+bool valid_map_label(std::string_view label) noexcept {
+    return label.empty() || (label.size() <= max_member_name && valid_member_name(label));
+}
+bool valid_map_pool(std::span<const std::uint16_t> pool, std::size_t maps) noexcept {
+    if (pool.size() > maps) return false;
+    for (std::size_t i = 0; i < pool.size(); ++i)
+        if (pool[i] >= maps || std::find(pool.begin(), pool.begin() + i, pool[i]) != pool.begin() + i) return false;
+    return true;
+}
 bool valid_admin_text(std::string_view text) noexcept {
     if (text.empty() || text.size() > max_admin_text) return false;
     for (std::size_t at = 0; at < text.size();) {
diff --git a/Extension/Multiplayer/Net/protocol.h b/Extension/Multiplayer/Net/protocol.h
index a86d70f..521f348 100644
--- a/Extension/Multiplayer/Net/protocol.h
+++ b/Extension/Multiplayer/Net/protocol.h
@@ -25,7 +25,7 @@ namespace dingosdk::multiplayer {
 constexpr std::size_t max_skater_bones = 512, max_board_bones = 64;
 constexpr std::size_t max_packet = 24576;
 constexpr std::size_t packet_header_size = 64;
-constexpr std::uint16_t protocol_version = 41;
+constexpr std::uint16_t protocol_version = 42;
 constexpr std::size_t max_throwdown_message = 4096;
 // Packet::tuning: the host's SkatePhysicsTuning differences (Extension/Skater/physics_tuning.h).
 constexpr std::size_t max_physics_tuning = 16384;
@@ -110,6 +110,8 @@ constexpr std::size_t max_ban_rows = 256;
 constexpr std::size_t max_server_maps = 128, max_map_asset = 128;
 // A level asset as a server's map list carries it: printable ASCII, no '|'.
 bool valid_map_asset(std::string_view asset) noexcept;
+bool valid_map_pool(std::span<const std::uint16_t> pool, std::size_t maps) noexcept; // distinct indices below `maps`
+bool valid_map_label(std::string_view label) noexcept; // empty, or a name like a member's
 struct Transform {
     std::array<float, 3> position{};
     std::array<float, 4> rotation{0, 0, 0, 1};
@@ -187,6 +189,9 @@ struct Packet {
     std::vector<MultiplayerBan> bans;         // bans: newest first
     std::uint32_t ban_total{};                // bans: how many the server has in all
     std::vector<std::string> maps;            // maps: level assets
+    std::vector<std::uint16_t> map_pool;      // maps: the pool as indices into `maps`, rotation order (empty: every map)
+    std::uint16_t map_rotation{};             // maps: minutes per map (0: off)
+    std::string map_label;                    // map_offer, world_state: the map's name for people (may be empty)
     std::vector<std::uint8_t> throwdown;      // throwdown: one encoded message (1..max_throwdown_message bytes)
     std::array<float, 3> teleport{};          // teleport: where the receiver goes (world position)
     std::vector<std::uint8_t> tuning;         // physics_tuning: 0..max_physics_tuning bytes
diff --git a/Extension/Multiplayer/Session/session.cpp b/Extension/Multiplayer/Session/session.cpp
index 2500dff..8a1c712 100644
--- a/Extension/Multiplayer/Session/session.cpp
+++ b/Extension/Multiplayer/Session/session.cpp
@@ -3,6 +3,7 @@
 #include "Extension/Multiplayer/Hud/native_indicators.h"
 #include "Extension/Multiplayer/Hud/native_party.h"
 #include "party_book.h"
+#include "Engine/Game/World/world_names.h"
 #include "Extension/Multiplayer/Remote/native_skater.h"
 #include "Extension/Multiplayer/Hud/custom_nametags.h"
 #include "Extension/Multiplayer/Hud/follow_camera.h"
@@ -75,6 +76,8 @@ void stop(Session &s, std::string reason) {
     s.server_bans.clear();
     s.server_ban_total = 0;
     s.server_maps.clear();
+    s.server_map_pool.clear();
+    s.server_map_rotation = 0;
     set_lobby_object_placement_allowed(true);
     s.guest_noclip = s.guest_no_bail = s.guest_boosts = true;
     s.enforce_tuning = true;
@@ -127,6 +130,7 @@ void stop(Session &s, std::string reason) {
     s.awaiting_map = s.join_map_authorized = s.map_load_submitted = false;
     s.join_started = s.last_map_request = s.last_map_load_check = 0;
     s.join_destination.clear();
+    s.map_label.clear();
     s.world = 1;
     s.travelling = false;
     s.host_world_ready = true;
@@ -545,6 +549,7 @@ MultiplayerModel model() {
     std::lock_guard lock(s.mutex);
     return s.view;
 }
+std::string take_leave_notice() { return std::exchange(session().leave_notice, {}); }
 MultiplayerChat chat() {
     auto &s = session();
     std::lock_guard lock(s.mutex);
@@ -637,6 +642,14 @@ bool prepare_join_map(Session &s, bool ready, std::string_view current, MapLoade
         s.last_map_load_check = now;
         std::string detail;
         const auto result = loader(s.join_destination, s.map_load_submitted, detail);
+        if (result == MapLoadResult::missing) {
+            const auto name = s.map_label.empty() ? world_level_name(world_destination_asset(s.join_destination)) : s.map_label;
+            const char *who = dedicated_host(s) ? "server" : "host";
+            s.leave_notice = (s.travelling ? std::string("The ") + who + " moved to " : std::string("The ") + who + " is on ") +
+                             name + ", which is not installed on this PC. Install its map mod and join again.";
+            stop(s, s.leave_notice);
+            return false;
+        }
         if (result == MapLoadResult::failed) {
             stop(s, detail.empty() ? "The host's map could not be loaded." : std::move(detail));
             return false;
diff --git a/Extension/Multiplayer/Session/session.h b/Extension/Multiplayer/Session/session.h
index 06ec342..0b7bc7b 100644
--- a/Extension/Multiplayer/Session/session.h
+++ b/Extension/Multiplayer/Session/session.h
@@ -10,12 +10,13 @@ std::string command(std::string_view action, std::string_view argument = {}, std
 bool queue_command(std::string_view action, std::string_view argument, std::string_view password);
 // Called just before the host's validated native load is submitted, on the client thread.
 void host_map_change(std::string_view destination);
-enum class MapLoadResult { waiting, queued, failed };
+enum class MapLoadResult { waiting, queued, failed, missing }; // missing: the map is not installed
 // Runs on the client thread; only catalog-registered destinations may be queued.
 using MapLoader = MapLoadResult (*)(std::string_view map, bool submitted, std::string &detail);
 void tick(std::uintptr_t base, std::uintptr_t client, bool gameplay_ready, std::string_view map,
           MapLoader loader = nullptr);
 MultiplayerModel model();
+std::string take_leave_notice(); // why the session just ended over a missing map, once; client thread
 // The session's chat lines for the overlay. Thread-safe and cheap: callable every frame.
 MultiplayerChat chat();
 } // namespace dingosdk::multiplayer
diff --git a/Extension/Multiplayer/Session/session_internal.h b/Extension/Multiplayer/Session/session_internal.h
index b46a57e..3c2c4a3 100644
--- a/Extension/Multiplayer/Session/session_internal.h
+++ b/Extension/Multiplayer/Session/session_internal.h
@@ -208,6 +208,10 @@ struct Session {
     std::vector<MultiplayerBan> server_bans;
     std::uint32_t server_ban_total{};
     std::vector<std::string> server_maps; // level assets the dedicated server allows
+    std::vector<std::string> server_map_pool; // admins: the pool's assets in rotation order (empty: every map)
+    unsigned server_map_rotation{};           // minutes per map (0: off)
+    std::string map_label;                    // the host's name for join_destination (may be empty)
+    std::string leave_notice;                 // take_leave_notice()
     std::uint64_t joined_public_lobby{};
     std::array<Peer, max_remote_players> peers;
     // Players take the lowest free slots, so every one sits below this mark
diff --git a/Extension/Multiplayer/Session/session_receive.cpp b/Extension/Multiplayer/Session/session_receive.cpp
index 9492558..b2b28d5 100644
--- a/Extension/Multiplayer/Session/session_receive.cpp
+++ b/Extension/Multiplayer/Session/session_receive.cpp
@@ -458,6 +458,7 @@ void networking(Session &s, const NativeFrame &local, std::uint64_t now) {
                 s.travel_started = s.join_started = now;
                 s.join_destination.clear();
                 s.map_name.clear();
+                s.map_label.clear();
                 s.map = 0;
                 s.map_load_submitted = false;
                 s.last_map_load_check = 0;
@@ -469,6 +470,7 @@ void networking(Session &s, const NativeFrame &local, std::uint64_t now) {
             s.world_state_sequence = p.sequence;
             if (!p.destination.empty()) {
                 s.join_destination = s.map_name = p.destination;
+                s.map_label = p.map_label;
                 s.map = p.map;
             }
             s.host_world_ready = p.world_ready;
@@ -567,6 +569,7 @@ void networking(Session &s, const NativeFrame &local, std::uint64_t now) {
             link->password_challenge = p.challenge;
             link->map_authorized |= p.map_authorized;
             s.join_destination = p.destination;
+            s.map_label = p.map_label;
             s.world = p.world;
             s.join_map_authorized |= p.map_authorized;
             if (new_challenge)
@@ -749,6 +752,9 @@ void networking(Session &s, const NativeFrame &local, std::uint64_t now) {
         if (p.kind == PacketKind::maps) {
             if (dedicated_host(s) && message.peer == s.host_id && p.source == s.host_id) {
                 s.server_maps = p.maps;
+                s.server_map_pool.clear();
+                for (const auto entry : p.map_pool) s.server_map_pool.push_back(p.maps[entry]);
+                s.server_map_rotation = p.map_rotation;
                 publish(s);
                 publish_chat(s);
             }
diff --git a/Extension/Multiplayer/Session/session_view.cpp b/Extension/Multiplayer/Session/session_view.cpp
index 1ab9925..d6d2e41 100644
--- a/Extension/Multiplayer/Session/session_view.cpp
+++ b/Extension/Multiplayer/Session/session_view.cpp
@@ -214,6 +214,9 @@ void publish(Session &s, const NativeFrame *local) {
         view.server_bans = true;
         view.server_ban_total = s.server_ban_total;
         view.server_maps = s.server_maps;
+        view.server_map_pool = s.server_map_pool;
+        view.server_map_rotation = s.server_map_rotation;
+        view.server_map_votes = (s.server_votes & server_vote_map) != 0;
     }
     view.chat_visible = s.chat_visible;
     view.chat_filter = s.chat_filter;
@@ -447,6 +450,8 @@ std::vector<MultiplayerChatCommand> chat_commands(const Session &s) {
             list.push_back({"/tod", "/tod <time>", "Admin: set the time of day", "time"});
             list.push_back({"/votes", "/votes [map|kick|tod on|off|<percent>]", "Admin: the server's vote settings"});
             list.push_back({"/vote-cancel", "/vote-cancel", "Admin: stop the running vote"});
+            list.push_back({"/map-pool", "/map-pool [add|remove <map>|clear]", "Admin: the maps players vote between and the rotation uses"});
+            list.push_back({"/rotation", "/rotation [<minutes>|off]", "Admin: change the map on a timer, through the map pool"});
         }
     }
     return list;
diff --git a/Extension/Multiplayer/Test/mesh_tests.cpp b/Extension/Multiplayer/Test/mesh_tests.cpp
index ffa7ca1..1e5dc9c 100644
--- a/Extension/Multiplayer/Test/mesh_tests.cpp
+++ b/Extension/Multiplayer/Test/mesh_tests.cpp
@@ -1254,7 +1254,7 @@ struct MapPair {
     static MapLoadResult loader(std::string_view, bool submitted, std::string &detail) {
         if (missing) {
             detail = "Map not installed.";
-            return MapLoadResult::failed;
+            return MapLoadResult::missing;
         }
         if (!submitted) ++loads;
         return submitted ? MapLoadResult::waiting : MapLoadResult::queued;
@@ -1365,8 +1365,9 @@ void map_checks() {
         MapPair pair;
         MapPair::missing = true;
         pair.run(20);
-        check(pair.guest.mode == Mode::off && pair.guest.status == "Map not installed.",
-              "Missing map did not end the pending join with its error");
+        const auto said = "The host is on Beach, which is not installed on this PC. Install its map mod and join again.";
+        check(pair.guest.mode == Mode::off && pair.guest.status == said && pair.guest.leave_notice == said,
+              "Missing map did not end the pending join naming the map");
     }
     {
         MapPair pair;
diff --git a/Extension/Multiplayer/Test/protocol_tests.cpp b/Extension/Multiplayer/Test/protocol_tests.cpp
index 223296d..029e0dc 100644
--- a/Extension/Multiplayer/Test/protocol_tests.cpp
+++ b/Extension/Multiplayer/Test/protocol_tests.cpp
@@ -874,6 +874,31 @@ void dedicated_server_codec() {
     maps.maps = {"Levels/Game/BAM_LevelRoot/BAM_LevelRoot", "Levels/Custom/bbcity/bbcity"};
     const auto map_list = decode_wire(encode_wire(maps));
     check(map_list && map_list->kind == PacketKind::maps && map_list->maps == maps.maps, "Server map list lost");
+    auto pooled = maps;
+    pooled.map_pool = {1, 0};
+    pooled.map_rotation = 20;
+    const auto pool_list = decode_wire(encode_wire(pooled));
+    check(pool_list && pool_list->map_pool == pooled.map_pool && pool_list->map_rotation == 20, "Server map pool or rotation lost");
+    Packet changed_map;
+    changed_map.kind = PacketKind::world_state; changed_map.session = 9; changed_map.epoch = 10; changed_map.source = server; changed_map.world = 2;
+    changed_map.destination = "Levels/Game/DingoLevel_Root/DingoLevel_Root|Levels/Game/dingolevel_reskate_momentumpark/x";
+    changed_map.map = map_hash(changed_map.destination);
+    changed_map.map_label = "Momentum Park";
+    const auto arrived = decode_wire(encode_wire(changed_map));
+    check(arrived && arrived->map_label == "Momentum Park" && arrived->destination == changed_map.destination,
+          "The map's name lost from a map change");
+    auto unnamed = changed_map;
+    unnamed.map_label.assign(max_member_name + 1, 'a');
+    check(reject(unnamed), "An overlong map name encoded");
+    auto stray = maps;
+    stray.map_pool = {2};
+    check(reject(stray), "A map pool entry past the map list encoded");
+    auto twice = maps;
+    twice.map_pool = {0, 0};
+    check(reject(twice), "A map listed twice in the pool encoded");
+    auto endless = maps;
+    endless.map_rotation = dingosdk::max_map_rotation + 1;
+    check(reject(endless), "An overlong map rotation encoded");
     auto piped = maps;
     piped.maps[0] = "Levels/Game/DingoLevel_Root/DingoLevel_Root|Levels/Game/BAM_LevelRoot/BAM_LevelRoot";
     check(reject(piped), "A destination encoded as a server map");
diff --git a/Extension/UI/Overlay/multiplayer_session.cpp b/Extension/UI/Overlay/multiplayer_session.cpp
index 36a7df2..14e06b6 100644
--- a/Extension/UI/Overlay/multiplayer_session.cpp
+++ b/Extension/UI/Overlay/multiplayer_session.cpp
@@ -77,6 +77,73 @@ void distance_settings(SkateMenu &menu, const MultiplayerModel &mp) {
     note(rates.c_str());
     end_card();
 }
+void map_pool_settings(SkateMenu &menu, const Model &model) { // the server's own maps, not this PC's
+    const auto &mp = model.multiplayer;
+    if (!mp.server_admin || mp.server_maps.empty()) return;
+    std::array<char, 65> unused{};
+    const auto server = [&](const std::string &command) { return send_private(menu, "server", command, unused, false); };
+    const auto &pool = mp.server_map_pool;
+    const auto pooled = pool.empty() ? mp.server_maps.size() : pool.size();
+    const auto count = std::to_string(pooled) + " of " + std::to_string(mp.server_maps.size()) + " maps";
+    begin_card(menu, "map-pool", "MAP POOL", count.c_str());
+    note("The maps players can vote for, in the order the rotation goes through them. These are the server's own "
+         "maps: its retail maps and the custom maps in its Mods folder.");
+    bool votes = mp.server_map_votes;
+    if (toggle_row(menu, "Player map votes", "Players start a vote with /vote map <map>.", votes))
+        server(votes ? "votes map on" : "votes map off");
+    ImGui::Dummy(ImVec2(0, px(2)));
+
+    const auto now = ImGui::GetTime();
+    std::erase_if(menu.map_pool_pending, [&](const auto &item) {
+        const bool listed = pool.empty() || std::find(pool.begin(), pool.end(), item.first) != pool.end();
+        return listed == item.second.first || now >= item.second.second;
+    });
+    const auto folded = [](std::string_view text) {
+        std::string result(text);
+        for (auto &c : result) c = c == '\\' ? '/' : c >= 'A' && c <= 'Z' ? static_cast<char>(c + 32) : c;
+        return result;
+    };
+    for (const auto &asset : mp.server_maps) {
+        const auto at = std::find(pool.begin(), pool.end(), asset);
+        bool listed = pool.empty() || at != pool.end();
+        if (const auto pending = menu.map_pool_pending.find(asset); pending != menu.map_pool_pending.end())
+            listed = pending->second.first;
+        auto label = map_label(model, asset);
+        if (at != pool.end()) label = std::to_string(at - pool.begin() + 1) + ".  " + label;
+        const bool installed = std::any_of(model.levels.begin(), model.levels.end(),
+                                           [&](const auto &level) { return folded(level.asset) == folded(asset); });
+        const auto hint = std::string(installed ? "" : "Not installed on this PC: you need its map mod to load it. ") +
+                          (listed ? "Untick to take it out of votes and the rotation." : "Tick to add it to the end of the rotation.");
+        const bool last = listed && pooled == 1; // the pool keeps at least one map
+        ImGui::PushID(asset.c_str());
+        if (toggle_row(menu, label.c_str(), last ? "The pool needs at least one map." : hint.c_str(), listed, !last, "ONLY") &&
+            server(std::string(listed ? "map-pool add " : "map-pool remove ") + asset))
+            menu.map_pool_pending[asset] = {listed, now + 2};
+        ImGui::PopID();
+    }
+    if (!pool.empty() && ImGui::Button("Use every map", ImVec2(-FLT_MIN, 0))) server("map-pool clear");
+    note(pool.empty() ? "Every map is in the pool. Untick maps to leave them out."
+                      : "Ticked maps join the end of the rotation; the numbers are its order.");
+    ImGui::Dummy(ImVec2(0, px(2)));
+
+    field(menu, "Rotation", "Minutes on each map before the server moves to the next map in the pool. 0 turns it off.");
+    int minutes = menu.map_rotation_pending.value_or(static_cast<int>(mp.server_map_rotation));
+    ImGui::DragInt("##map-rotation", &minutes, .25f, 0, static_cast<int>(max_map_rotation), minutes ? "Every %d min" : "Off",
+                   ImGuiSliderFlags_AlwaysClamp);
+    if (ImGui::IsItemActive()) menu.map_rotation_pending = minutes;
+    if (ImGui::IsItemDeactivatedAfterEdit()) {
+        server(minutes ? "rotation " + std::to_string(minutes) : std::string("rotation off"));
+        menu.map_rotation_until = now + 2;
+    }
+    if (!ImGui::IsItemActive() && menu.map_rotation_pending &&
+        (*menu.map_rotation_pending == static_cast<int>(mp.server_map_rotation) || now >= menu.map_rotation_until))
+        menu.map_rotation_pending.reset();
+    note(mp.server_map_rotation ? "Set to 0 to turn the auto rotation off. Players get a minute's warning; the clock "
+                                  "waits while nobody is on, and starts over whenever the map changes."
+                                : "Auto rotation is off (0). Drag above 0 to change the map on a timer; until then it "
+                                  "changes only by a vote or an admin.");
+    end_card();
+}
 } // namespace
 
 void voice_controls(SkateMenu &menu, const MultiplayerModel &mp) {
@@ -523,6 +590,7 @@ void session_page(SkateMenu &menu, const Model &model) {
         }
         end_card();
     }
+    map_pool_settings(menu, model);
 
     begin_card(menu, "host-options", mp.dedicated ? "SERVER OPTIONS" : "HOST OPTIONS", set_by(mp));
     std::array<char, 65> unused{};
diff --git a/Extension/UI/Overlay/skate_menu.h b/Extension/UI/Overlay/skate_menu.h
index 051f26c..c993bce 100644
--- a/Extension/UI/Overlay/skate_menu.h
+++ b/Extension/UI/Overlay/skate_menu.h
@@ -27,6 +27,9 @@ struct SkateMenu {
     bool multiplayer_same_map_only = false;
     bool multiplayer_dedicated_only = false;
     std::array<char, 321> server_command{}; // an admin's command for the dedicated server
+    std::map<std::string, std::pair<bool, double>> map_pool_pending; // asset -> {ticked, until}, until the server agrees
+    std::optional<int> map_rotation_pending;                         // the rotation slider, likewise
+    double map_rotation_until{};
     bool ban_confirm_on_server{};           // the Ban popup bans from a dedicated server
     int multiplayer_lobby_sort = 0;
     float multiplayer_code_height = 0;  // what the join-by-code card took last frame
diff --git a/Runtime/client_tick.cpp b/Runtime/client_tick.cpp
index 8ee41e0..7d3f17a 100644
--- a/Runtime/client_tick.cpp
+++ b/Runtime/client_tick.cpp
@@ -991,6 +991,8 @@ void tick(std::uintptr_t client, std::uintptr_t update) {
         {
             DINGO_PROFILE_ZONE("tick/multiplayer");
             dingosdk::multiplayer::tick(r.base,client,multiplayer_ready,r.multiplayer_map,load_multiplayer_map);
+            if (auto notice = dingosdk::multiplayer::take_leave_notice(); !notice.empty())
+                dingosdk::overlay::notify(dingosdk::overlay::NoticeLevel::warning, "Map not installed", std::move(notice));
         }
         dingosdk::multiplayer::refresh_identity_lists();
         dingosdk::tick_local_developer_hoodie(r.base, client, multiplayer_ready);
diff --git a/Runtime/level_requests.cpp b/Runtime/level_requests.cpp
index 73fc2fb..c464d48 100644
--- a/Runtime/level_requests.cpp
+++ b/Runtime/level_requests.cpp
@@ -77,7 +77,7 @@ dingosdk::multiplayer::MapLoadResult load_multiplayer_map(std::string_view desti
     }
     if (!root || !root->native_registered || (!sub_asset.empty() && !sub)) {
         detail = "The host's map is not installed or registered on this PC. Install the same map and join again.";
-        return Result::failed;
+        return Result::missing;
     }
     if (submitted) {
         detail = "The host's map did not finish loading. " + r.load_result;
diff --git a/Server/README.txt b/Server/README.txt
index 924f7c4..ab01244 100644
--- a/Server/README.txt
+++ b/Server/README.txt
@@ -42,6 +42,14 @@ name               Shown in the browser (1-64 characters).
 map                The map everyone skates, named like the game's load command:
                    "San Vansterdam", "Isle of Grom", "Super Ultra Mega Resort",
                    "Stadium 1", or a custom map such as "bbcity" (see Custom maps).
+map_pool           The maps players may vote for and the rotation goes through,
+                   in order, e.g. ["San Vansterdam", "Isle of Grom", "bbcity"].
+                   Empty (the default) allows every map the server knows.
+                   Admins can still change to any map.
+map_rotation_minutes  Minutes on each map before the server moves to the next
+                   one in map_pool (default 0: off). Players get a minute's
+                   warning; the clock waits while nobody is on, and starts
+                   over whenever the map changes (by a vote or an admin too).
 max_players        1-249.
 password           Empty for anyone; otherwise players type it to join.
 welcome            A chat line sent to each player as they join.
@@ -53,6 +61,7 @@ global_bans        Turn away players the ReSkate team has banned from multiplaye
                    "bans" apply either way.
 votes              Player votes, each off until turned on:
                      "map": {"enabled": true, "percent": 60}   /vote map <map>
+                                                   (a map in map_pool)
                      "kick": {"enabled": true, "percent": 60}  /vote kick <player>
                      "time_of_day": {"enabled": true, "percent": 50}  /vote tod <time>
                                                    (needs world_layer_sync)
@@ -133,6 +142,9 @@ and change voice, distances, placement and kicks from the Multiplayer menu.
   ban <player or id> [name]     For good.   unban <id>   bans
   map <name>                    e.g. map San Vansterdam, map grom, map bbcity
   maps                          The maps this server knows.
+  map-pool [add|remove <map>|clear]   The maps players vote between and the
+                                rotation uses (see map_pool).
+  rotation [<minutes>|off]      Change the map on a timer (see map_rotation_minutes).
   name <text>   password <text|off>   welcome <text|off>   listed on|off
   tps 20|30|60|120   voice on|off   voice-range <m>
   distances <full> <half> <half-return> <low>
diff --git a/Server/Test/server_config_tests.cpp b/Server/Test/server_config_tests.cpp
index c8f1627..80e525f 100644
--- a/Server/Test/server_config_tests.cpp
+++ b/Server/Test/server_config_tests.cpp
@@ -35,7 +35,7 @@ int run() {
     const auto config = load_config(file, &added);
     const auto has = [&](std::string_view name) { return std::ranges::find(added, name) != added.end(); };
     check(has("enforce_tuning") && has("votes.seconds") && has("votes.kick") && has("score_check") && has("score_allow") &&
-              has("global_bans"),
+              has("global_bans") && has("map_pool") && has("map_rotation_minutes"),
           "New settings not reported");
     check(!has("name") && !has("tps") && !has("votes.map"), "Settings the file had reported as new");
     const auto written = text(file);
@@ -85,6 +85,38 @@ int run() {
     const auto edges = load_config(file);
     check(edges.port == 65535 && edges.query_port == 1, "Ports at the ends of the range refused");
 
+    static_cast<void>(load_levels(folder / "Mods")); // no Mods folder: the retail maps only
+    ServerConfig pool;
+    check(pool_levels(pool).size() == levels().size() && in_map_pool(pool, "Stadium 2"),
+          "An empty pool does not allow every map");
+    pool.map_pool = {"Isle", "Isle of Grom", "San Vansterdam", "Stadium 1"};
+    check(pool_levels(pool).size() == 3, "Pool maps not resolved once each");
+    check(in_map_pool(pool, "San Vansterdam") && in_map_pool(pool, "Levels/Game/DingoLevel_SDM/DingoLevel_SDM_Int_001/DingoLevel_SDM_Int_001") &&
+              !in_map_pool(pool, "Super Ultra Mega Resort") && !in_map_pool(pool, "Nowhere"),
+          "Pool membership wrong");
+    const auto next = [&](std::string_view map) {
+        const auto *level = next_pool_map(pool, map);
+        return level ? level->name : std::string{};
+    };
+    check(next("Isle of Grom") == "San Vansterdam" && next("Stadium 1") == "Isle of Grom" &&
+              next("Super Ultra Mega Resort") == "Isle of Grom",
+          "Rotation does not follow the pool's order");
+    pool.map_pool = {"Isle of Grom"};
+    check(next("Isle of Grom").empty() && next("San Vansterdam") == "Isle of Grom", "A one-map pool rotated to itself");
+    check(config_error(pool).empty(), "A valid pool refused");
+    pool.map_pool = {"Isle of Grom", "Nowhere"};
+    check(!config_error(pool).empty(), "An unknown pool map accepted");
+    pool.map_pool = {"Isle of Grom", "Stadium 1"};
+    pool.map_rotation = 15;
+    pool.file = file;
+    save_config(pool);
+    const auto rotating = load_config(file);
+    check(rotating.map_pool == pool.map_pool && rotating.map_rotation == 15, "Map pool or rotation lost on save");
+    std::ofstream(file, std::ios::binary) << R"({"map_pool": ["Isle of Grom", 7, ""], "map_rotation_minutes": 5000})";
+    const auto odd_pool = load_config(file);
+    check(odd_pool.map_pool == std::vector<std::string>{"Isle of Grom"} && odd_pool.map_rotation == 1440,
+          "Bad pool entries kept, or rotation not capped");
+
     std::filesystem::remove_all(folder);
     if (failures) return 1;
     std::cout << "server config: ok\n";
diff --git a/Server/main.cpp b/Server/main.cpp
index f38bac1..f77ddf6 100644
--- a/Server/main.cpp
+++ b/Server/main.cpp
@@ -312,10 +312,17 @@ int run(int argc, char **argv, bool skip_update) {
     for (const auto &problem : load_levels(here / "Mods")) write_log("Mods: skipped " + problem);
     if (levels().size() > 6) write_log("Mods: " + std::to_string(levels().size() - 6) + " custom map(s).");
     // Older configs name the map by its full destination; keep the plain name instead.
+    bool renamed{};
     if (const auto setting = map_setting(config.map); setting != config.map && !setting.empty()) {
         config.map = setting;
-        try { save_config(config); } catch (...) {}
+        renamed = true;
     }
+    for (auto &map : config.map_pool) // short pool names ("isle") are saved in full
+        if (const auto *level = find_level(map); level && level->name != map) {
+            map = level->name;
+            renamed = true;
+        }
+    if (renamed) try { save_config(config); } catch (...) {}
     if (const auto error = config_error(config); !error.empty()) {
         write_log("Config problem: " + error);
         return 1;
diff --git a/Server/server_config.cpp b/Server/server_config.cpp
index 7681615..ab2f184 100644
--- a/Server/server_config.cpp
+++ b/Server/server_config.cpp
@@ -16,6 +16,10 @@ Json to_json(const ServerConfig &c) {
     auto root = Json::object();
     root["name"] = c.name;
     root["map"] = c.map;
+    auto pool = Json::array();
+    for (const auto &map : c.map_pool) pool.push_back(map);
+    root["map_pool"] = std::move(pool);
+    root["map_rotation_minutes"] = c.map_rotation;
     root["max_players"] = c.max_players;
     root["password"] = c.password;
     root["welcome"] = c.welcome;
@@ -111,6 +115,10 @@ ServerConfig load_config(const std::filesystem::path &file, std::vector<std::str
     if (!root.is_object()) throw std::runtime_error("The server config must be a JSON object.");
     c.name = root.value("name", c.name);
     c.map = root.value("map", c.map);
+    if (root.contains("map_pool") && root.at("map_pool").is_array())
+        for (const auto &map : root.at("map_pool"))
+            if (map.is_string() && !map.string().empty()) c.map_pool.push_back(map.string());
+    c.map_rotation = std::min(root.value("map_rotation_minutes", c.map_rotation), max_map_rotation);
     c.max_players = root.value("max_players", c.max_players);
     c.password = root.value("password", c.password);
     c.welcome = root.value("welcome", c.welcome);
@@ -226,6 +234,10 @@ std::string config_error(const ServerConfig &c) {
     if (c.map.empty() || !valid_map_destination(map_destination(c.map)))
         return "map \"" + c.map + "\" is not a known map. Use a name like \"San Vansterdam\", or put the map's mod "
                "folder in Mods next to the server.";
+    for (const auto &map : c.map_pool)
+        if (!find_level(map) || !valid_map_destination(map_destination(map)))
+            return "map_pool: \"" + map + "\" is not a single known map. Use names like \"Isle of Grom\", or put the "
+                   "map's mod folder in Mods next to the server.";
     if (c.max_players < 1 || c.max_players + 1 > max_players)
         return "max_players must be 1 to " + std::to_string(max_players - 1) + ".";
     if (c.password.size() > 64) return "password must be at most 64 characters.";
@@ -333,4 +345,32 @@ std::string map_label(std::string_view map) {
     if (const auto *level = find_level(map)) return level->name;
     return world_level_name(world_destination_asset(map_destination(map)));
 }
+std::vector<const ServerLevel *> pool_levels(const ServerConfig &config) {
+    std::vector<const ServerLevel *> pool;
+    const auto add = [&](const ServerLevel *level) {
+        if (level && multiplayer::valid_map_destination(map_destination(level->asset)) &&
+            std::find(pool.begin(), pool.end(), level) == pool.end())
+            pool.push_back(level);
+    };
+    if (config.map_pool.empty())
+        for (const auto &level : level_list()) add(&level);
+    for (const auto &map : config.map_pool) add(find_level(map));
+    return pool;
+}
+bool in_map_pool(const ServerConfig &config, std::string_view map) {
+    if (config.map_pool.empty()) return true;
+    const auto pool = pool_levels(config);
+    const auto *level = find_level(map);
+    return level && std::find(pool.begin(), pool.end(), level) != pool.end();
+}
+const ServerLevel *next_pool_map(const ServerConfig &config, std::string_view map) {
+    const auto pool = pool_levels(config);
+    const auto *current = find_level(map);
+    const auto at = static_cast<std::size_t>(std::find(pool.begin(), pool.end(), current) - pool.begin());
+    for (std::size_t step = 1; step <= pool.size(); ++step) {
+        const auto *next = at == pool.size() ? pool[step - 1] : pool[(at + step) % pool.size()];
+        if (next != current) return next;
+    }
+    return nullptr;
+}
 } // namespace dingosdk::server
diff --git a/Server/server_config.h b/Server/server_config.h
index 8a5ffa6..bfcb0e2 100644
--- a/Server/server_config.h
+++ b/Server/server_config.h
@@ -33,6 +33,8 @@ struct ServerConfig {
     // The map everyone skates, named like the game's `load` command: "San Vansterdam",
     // "Isle of Grom", or a custom map in Mods\ such as "bbcity".
     std::string map = "San Vansterdam";
+    std::vector<std::string> map_pool; // maps for votes and the rotation, in order; empty: every map
+    unsigned map_rotation = 0;         // minutes per map before the next pool map (0: off)
     unsigned max_players = 16; // players; the server itself is not one
     std::string password;      // empty: anyone may join
     std::string welcome;       // sent to each player as they join
@@ -107,4 +109,7 @@ std::string map_destination(std::string_view map);
 std::string map_setting(std::string_view map);
 // A map's name for people: "San Vansterdam".
 std::string map_label(std::string_view map);
+std::vector<const ServerLevel *> pool_levels(const ServerConfig &config); // known pool maps once each; all when empty
+bool in_map_pool(const ServerConfig &config, std::string_view map);
+const ServerLevel *next_pool_map(const ServerConfig &config, std::string_view map); // after `map`; null if no other
 } // namespace dingosdk::server
diff --git a/Server/server_host.cpp b/Server/server_host.cpp
index 957acfb..40d2b33 100644
--- a/Server/server_host.cpp
+++ b/Server/server_host.cpp
@@ -47,6 +47,7 @@ constexpr std::string_view help_text =
     "tps 20|30|60|120 | voice on|off | voice-range <50-1000> | distances <full> <half> <half-return> <low>\n"
     "placement everyone|admins|nobody | clear-objects | noclip on|off | nobail on|off | boosts on|off | tuning on|off\n"
     "tpall [player] | tphere <player> | votes [map|kick|tod on|off|<percent>] | vote-cancel\n"
+    "map-pool [add|remove <map>|clear] | rotation [<minutes>|off]\n"
     "park <lot> <layout> | layer-sync on|off | layer <key> default|on|off | tod <time|default>\n"
     "activity-log on|off | announce-throwdowns on|off | parties [on|off] | party-size <2-8> | speed-check off|warn|kick\n"
     "score-check [off|warn|kick] | score-allow [<fingerprint>|remove <fingerprint>]\n"
@@ -126,6 +127,11 @@ void Host::save() {
 }
 std::string Host::invite() const { return format_invite({id_, secret_}); }
 std::string Host::map_name() const { return map_label(config_.map); }
+std::string Host::wire_map_label() const { // players without the map's mod still see its name
+    auto label = map_name();
+    cut_text(label, max_member_name);
+    return valid_map_label(label) ? label : std::string{};
+}
 unsigned Host::players() const {
     return static_cast<unsigned>(std::count_if(guests_.begin(), guests_.end(), [](const auto &g) { return g.second->handshaken; }));
 }
@@ -296,6 +302,7 @@ void Host::send_roster() {
 void Host::send_world_state() {
     auto state = packet(PacketKind::world_state, now_);
     state.destination = map_destination(config_.map);
+    state.map_label = wire_map_label();
     state.world_ready = true; // the server has nothing to load
     const auto bytes = encode_wire(state);
     for (auto &[id, guest] : guests_)
@@ -322,12 +329,23 @@ void Host::send_bans(Guest &admin) {
     }
     if (send_packet(admin, list, true, false)) admin.bans_sent = bans_revision_;
 }
-// The maps an admin may switch to: the retail ones and the server's custom maps.
-void Host::send_maps(Guest &admin) {
+void Host::send_maps(Guest &guest) { // admins: every map and the pool; players: the pool
     auto list = packet(PacketKind::maps, now_);
-    for (const auto &level : levels())
+    const auto add = [&](const ServerLevel &level) {
         if (valid_map_asset(level.asset) && list.maps.size() < max_server_maps) list.maps.push_back(level.asset);
-    if (send_packet(admin, list, true, false)) admin.maps_sent = true;
+    };
+    if (is_admin(guest.member.id)) {
+        for (const auto &level : levels()) add(level);
+        if (!config_.map_pool.empty())
+            for (const auto *level : pool_levels(config_)) {
+                const auto at = std::find(list.maps.begin(), list.maps.end(), level->asset);
+                if (at != list.maps.end()) list.map_pool.push_back(static_cast<std::uint16_t>(at - list.maps.begin()));
+            }
+    } else {
+        for (const auto *level : pool_levels(config_)) add(*level);
+    }
+    list.map_rotation = static_cast<std::uint16_t>(std::min(config_.map_rotation, max_map_rotation));
+    if (send_packet(guest, list, true, false)) guest.maps_sent = true;
 }
 void Host::change_map(std::string_view map) {
     if (!valid_map_destination(map_destination(map_setting(map))))
@@ -361,6 +379,8 @@ void Host::change_map(std::string_view map) {
     activity_.clear(); // throwdowns end with the world
     config_.map = map_setting(map);
     map_ = map_hash(map_destination(config_.map));
+    map_since_ = now_;
+    rotation_warned_ = false;
     travel_started_ = now_;
     last_world_state_ = 0;
     send_world_state();
@@ -478,6 +498,7 @@ void Host::receive(std::uint64_t peer, std::span<const std::uint8_t> bytes, std:
         if (newly_authorized || !link->last_map_offer || now_ - link->last_map_offer >= 1000000) {
             auto offer = packet(PacketKind::map_offer, now_);
             offer.destination = map_destination(config_.map);
+            offer.map_label = wire_map_label();
             offer.challenge = link->password_challenge;
             offer.map_authorized = authorized;
             send_required(*link, encode_wire(offer));
@@ -807,6 +828,7 @@ void Host::tick(std::uint64_t now) {
     activity_.tick(now_);
     if (std::exchange(vote_recount_, false)) check_vote(false);
     if (vote_ && now_ >= vote_->ends) check_vote(true);
+    tick_rotation();
     std::erase_if(vote_cooldowns_, [&](const auto &entry) { return now_ >= entry.second; });
     join_backoff_.prune(now_);
 }
@@ -949,9 +971,51 @@ std::string Host::command(std::string_view line, std::uint64_t admin) {
     }
     if (name == "maps") {
         std::string text = std::to_string(levels().size()) + " maps (custom maps come from Mods next to the server)";
-        for (const auto &level : levels()) text += "\n  " + level.name + (same_map(level.asset) ? "  (now)" : "");
+        for (const auto &level : levels())
+            text += "\n  " + level.name + (same_map(level.asset) ? "  (now)" : "") +
+                    (!config_.map_pool.empty() && in_map_pool(config_, level.asset) ? "  (pool)" : "");
         return text;
     }
+    if (name == "map-pool") { // map-pool [add|remove <map>|clear]
+        const auto [what_text, map] = split(argument);
+        const auto what = lower(what_text);
+        if (what.empty()) return pool_text();
+        if (what == "clear") {
+            config_.map_pool.clear();
+            resend_maps();
+            return changed("The map pool is cleared: players vote between every map, and the rotation goes through them all.");
+        }
+        if (what != "add" && what != "remove") return "map-pool [add|remove <map>|clear]";
+        const auto *level = find_level(map);
+        if (!level || !valid_map_destination(map_destination(level->asset)))
+            return "No single map is called \"" + std::string(map) + "\". Type maps for the list.";
+        const auto pooled = [&](const std::string &entry) { return find_level(entry) == level; };
+        const bool listed = std::any_of(config_.map_pool.begin(), config_.map_pool.end(), pooled);
+        if (what == "add") {
+            if (listed || config_.map_pool.empty()) return level->name + " is already in the map pool.";
+            config_.map_pool.push_back(level->name);
+        } else {
+            if (config_.map_pool.empty()) // every map: keep all the others
+                for (const auto *other : pool_levels(config_)) config_.map_pool.push_back(other->name);
+            else if (!listed) return level->name + " is not in the map pool.";
+            if (std::all_of(config_.map_pool.begin(), config_.map_pool.end(), pooled))
+                return "The map pool needs at least one map. map-pool clear allows every map again.";
+            std::erase_if(config_.map_pool, pooled);
+        }
+        resend_maps();
+        return changed(level->name + (what == "add" ? " added to" : " removed from") + " the map pool.");
+    }
+    if (name == "rotation") { // rotation [<minutes>|off]
+        if (argument.empty()) return rotation_text();
+        const auto value = lower(argument);
+        const auto minutes = value == "off" ? std::optional<std::uint64_t>(0) : number(value);
+        if (!minutes || *minutes > max_map_rotation) return "rotation <1-1440 minutes>|off";
+        config_.map_rotation = static_cast<unsigned>(*minutes);
+        map_since_ = now_;
+        rotation_warned_ = false;
+        resend_maps();
+        return changed(rotation_text());
+    }
     if (name == "name") {
         if (argument.empty() || argument.size() > 64 || !valid_member_name(argument)) return "Server names are 1 to 64 characters.";
         config_.name = argument;
@@ -1327,10 +1391,12 @@ std::string Host::command(std::string_view line, std::uint64_t admin) {
         if (!individual_steam_id(id)) return "admin add|remove <player or SteamID64>";
         if (sub == "add") {
             if (!is_admin(id)) config_.admins.push_back(id);
+            resend_maps();
             return changed(std::to_string(id) + " is an admin.");
         }
         if (sub == "remove") {
             std::erase(config_.admins, id);
+            resend_maps();
             return changed(std::to_string(id) + " is no longer an admin.");
         }
         return "admin add|remove <player or SteamID64>";
diff --git a/Server/server_host.h b/Server/server_host.h
index 8ca26a4..1a60b1b 100644
--- a/Server/server_host.h
+++ b/Server/server_host.h
@@ -91,7 +91,7 @@ class Host {
         bool scoring_flagged{};     // out of linked activities (config score_check)
         ChatBudget scoring_budget;
         std::uint64_t bans_sent{}; // the ban list revision this admin has
-        bool maps_sent{};          // this admin has the server's map list
+        bool maps_sent{};          // this player has the server's map list (send_maps)
         // The owner's own upload, and what the server shares of it.
         ObjectState objects, shared;
         std::uint64_t shared_from{};
@@ -120,6 +120,8 @@ class Host {
     std::optional<Vote> vote_;
     bool vote_recount_{}; // a player left: recount in tick(), never while guests_ is being walked
     std::map<std::uint64_t, std::uint64_t> vote_cooldowns_;
+    std::uint64_t map_since_{}; // rotation clock start: the last map change, or while nobody is on
+    bool rotation_warned_{};    // players were told the next map is a minute away
     // Parties (server_party.cpp): the server owns them; each roster carries them to everyone.
     PartyBook parties_;
     std::uint64_t party_revision_{};
@@ -156,6 +158,7 @@ class Host {
     void send_bans(Guest &admin);
     void send_maps(Guest &admin);
     void change_map(std::string_view map); // a level name, level path or destination
+    std::string wire_map_label() const;
     bool same_map(std::string_view asset) const { return map_hash(map_destination(asset)) == map_; }
     bool accept_data(Guest &source, const Packet &);
     // `received_at`: the transport's arrival time for the message (TransportMessage::arrived).
@@ -173,6 +176,10 @@ class Host {
     std::uint8_t enabled_votes() const;
     void reply(Guest &, std::string_view text);
     Guest *match_player(std::string_view text);
+    void tick_rotation();
+    std::string pool_text() const;     // the map pool, one map a line
+    std::string rotation_text() const; // the rotation's interval and next map
+    void resend_maps();                // after the pool or the admins change
     // Parties (server_party.cpp).
     void party_request(Guest &, PartyAction, std::uint64_t player);
     void party_command(Guest &, std::string_view line); // "/party ..."
diff --git a/Server/server_votes.cpp b/Server/server_votes.cpp
index 34ed16a..e018ae7 100644
--- a/Server/server_votes.cpp
+++ b/Server/server_votes.cpp
@@ -5,7 +5,7 @@
 #include <cmath>
 
 // Player votes (map, kick, time of day) and the chat commands that run them. Each vote is
-// switched on and given its pass percentage in ReSkateServer.json ("votes").
+// switched on and given its pass percentage in ReSkateServer.json ("votes"); also the map pool and rotation.
 namespace dingosdk::server {
 namespace {
 constexpr std::array<std::string_view, 8> times{"default", "morning", "noon",       "afternoon",
@@ -67,6 +67,7 @@ void Host::chat_command(Guest &guest, std::string_view line) {
         if (votes & server_vote_kick) text += "/vote kick <player>: start a vote to kick a player\n";
         if (votes & server_vote_time) text += "/vote tod <time>: vote for a time of day (morning, noon, night...)\n";
         if (votes) text += "/yes or /no: vote in the running vote\n";
+        if (config_.map_rotation) text += "The map changes every " + std::to_string(config_.map_rotation) + " min.\n";
         if (config_.parties) text += "/party: your party (invite, accept, leave...; /party help); /p <message>: party chat\n";
         if (is_admin(guest.member.id)) text += "Admins: any server command as /<command>, e.g. /kick, /map, /tpall, /votes, /msg, /msg-party, /msg-admins\n";
         const std::string whisper = "/w <player> <message>: send a private message";
@@ -128,8 +129,10 @@ void Host::start_vote(Guest &guest, VoteKind kind, std::string_view argument) {
     case VoteKind::map: {
         if (argument.empty()) return reply(guest, "/vote map <map>, e.g. /vote map grom");
         // Players vote between the server's own maps (/maps); a raw level path is admins only.
-        if (!find_level(argument) || !valid_map_destination(map_destination(argument)))
+        const auto *level = find_level(argument);
+        if (!level || !valid_map_destination(map_destination(argument)))
             return reply(guest, "No single map is called \"" + std::string(argument) + "\".");
+        if (!in_map_pool(config_, level->asset)) return reply(guest, level->name + " is not one of this server's maps.\n" + pool_text());
         if (map_hash(map_destination(argument)) == map_) return reply(guest, "The server is already on that map.");
         vote.value = std::string(argument);
         vote.label = "change the map to " + map_label(argument);
@@ -230,4 +233,47 @@ void Host::check_vote(bool expired) {
         break;
     }
 }
+
+std::string Host::pool_text() const {
+    std::string text = config_.map_pool.empty() ? "Map pool: every map" : "Map pool:";
+    if (!config_.map_pool.empty())
+        for (const auto *level : pool_levels(config_)) text += "\n  " + level->name + (same_map(level->asset) ? "  (now)" : "");
+    return text;
+}
+std::string Host::rotation_text() const {
+    if (!config_.map_rotation) return "Map rotation is off.";
+    const auto every = "The map changes every " + std::to_string(config_.map_rotation) + " min";
+    const auto *next = next_pool_map(config_, config_.map);
+    if (!next) return every + ", but the map pool has no other map.";
+    if (!players()) return every + " while players are on. Next: " + next->name + ".";
+    const auto due = map_since_ + std::uint64_t{config_.map_rotation} * 60000000;
+    const auto left = due > now_ ? (due - now_ + 59999999) / 60000000 : 0;
+    return every + ". Next: " + next->name + " in about " + std::to_string(std::max<std::uint64_t>(left, 1)) + " min.";
+}
+void Host::resend_maps() {
+    for (auto &[id, guest] : guests_) guest->maps_sent = false;
+}
+void Host::tick_rotation() { // waits while nobody is on, and for a running map vote
+    if (!config_.map_rotation || !players()) {
+        map_since_ = now_;
+        rotation_warned_ = false;
+        return;
+    }
+    const auto due = map_since_ + std::uint64_t{config_.map_rotation} * 60000000;
+    if (now_ + 60000000 < due) return;
+    const auto *next = next_pool_map(config_, config_.map);
+    if (!next) {
+        map_since_ = now_;
+        return;
+    }
+    if (!rotation_warned_ && config_.map_rotation > 1) {
+        rotation_warned_ = true;
+        send_chat("Next map in 1 minute: " + next->name + ".");
+    }
+    if (now_ < due || (vote_ && vote_->kind == VoteKind::map)) return;
+    send_chat("Changing the map to " + next->name + ".");
+    log_("[rotation] Changing the map to " + next->name + ".");
+    change_map(next->name);
+    save();
+}
 } // namespace dingosdk::server