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..545ae59 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))
@@ -515,6 +516,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);
@@ -789,6 +793,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 +967,12 @@ 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_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..aa1e2e7 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,7 @@ 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`
 struct Transform {
     std::array<float, 3> position{};
     std::array<float, 4> rotation{0, 0, 0, 1};
@@ -187,6 +188,8 @@ 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::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..7661906 100644
--- a/Extension/Multiplayer/Session/session.cpp
+++ b/Extension/Multiplayer/Session/session.cpp
@@ -75,6 +75,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;
diff --git a/Extension/Multiplayer/Session/session_internal.h b/Extension/Multiplayer/Session/session_internal.h
index 46ca45a..3ac17dc 100644
--- a/Extension/Multiplayer/Session/session_internal.h
+++ b/Extension/Multiplayer/Session/session_internal.h
@@ -200,6 +200,8 @@ 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::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 a9d69f3..092b3fb 100644
--- a/Extension/Multiplayer/Session/session_receive.cpp
+++ b/Extension/Multiplayer/Session/session_receive.cpp
@@ -682,6 +682,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 21c9ac7..44dd90a 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/protocol_tests.cpp b/Extension/Multiplayer/Test/protocol_tests.cpp
index 223296d..c322f30 100644
--- a/Extension/Multiplayer/Test/protocol_tests.cpp
+++ b/Extension/Multiplayer/Test/protocol_tests.cpp
@@ -874,6 +874,20 @@ 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");
+    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/Server/server_config.cpp b/Server/server_config.cpp
index f8dce2c..ab2f184 100644
--- a/Server/server_config.cpp
+++ b/Server/server_config.cpp
@@ -118,7 +118,7 @@ ServerConfig load_config(const std::filesystem::path &file, std::vector<std::str
     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), 1440U);
+    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);
diff --git a/Server/server_host.cpp b/Server/server_host.cpp
index 3b58fe8..0025f1d 100644
--- a/Server/server_host.cpp
+++ b/Server/server_host.cpp
@@ -323,15 +323,22 @@ void Host::send_bans(Guest &admin) {
     }
     if (send_packet(admin, list, true, false)) admin.bans_sent = bans_revision_;
 }
-void Host::send_maps(Guest &guest) { // admins: every map; players: the pool
+void Host::send_maps(Guest &guest) { // admins: every map and the pool; players: the pool
     auto list = packet(PacketKind::maps, now_);
     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 (is_admin(guest.member.id))
+    if (is_admin(guest.member.id)) {
         for (const auto &level : levels()) add(level);
-    else
+        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) {
@@ -960,7 +967,7 @@ std::string Host::command(std::string_view line, std::uint64_t admin) {
         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 > 1440) return "rotation <1-1440 minutes>|off";
+        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;