@@ -253,7 +253,6 @@ constructor(private val proxy: ProxyServer, private val logger: Logger) {
                 roleQuery = { ProxyServiceRegistry.get(PlayerRoleQuery::class.java) },
                 serverQuery = { ProxyServiceRegistry.get(ServerDisplayQuery::class.java) },
                 isBedrock = roster::isBedrock,
-                onlineCount = { networkPlayerCount },
             )
         tabList = tab
         proxy.commandManager.register("proxydebug", ProxyDebugCommand(messages))
@@ -271,8 +270,7 @@ constructor(private val proxy: ProxyServer, private val logger: Logger) {
         proxy.eventManager.register(this, hops)
         proxy.commandManager.register("proxy", ProxyCommand(proxyId, service, hops, messages))
 
-        // On a timer as well as on join: the ping and the roster both change with no event to hang
-        // off, and a footer that shows the ping from the moment you logged in is worse than none.
+        // Roster entries and remote rank snapshots can change between join events.
         proxy.scheduler
             .buildTask(
                 this,
 
@@ -9,35 +9,13 @@ import gg.grounds.proxy.api.ServerDisplayQuery
 import net.kyori.adventure.text.Component
 import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer
 
-/**
- * The header and footer above and below the player list, and the chips and colour of the names in
- * it.
- *
- * The tab list is the only screen a player can open from anywhere, which makes it the right place
- * for the two facts that are true everywhere: which network this is, and which backend you are on.
- * It belongs to the proxy because both answers do — a backend server knows its own name and nothing
- * about how the network should label it.
- *
- * ```
- *              [GROUNDS wordmark]
- *
- *  [ADMIN]  Steve
- *  [USER]   Alex
- *
- *          Lobby 2 • 42 players online • 24 ms
- * ```
- *
- * The ping is coloured by how bad it is, using the state colours rather than a number nobody reads:
- * green under 100 ms, amber under 200, salmon above. A player who has not been measured yet gets a
- * dash instead of a fabricated zero.
- */
+/** Network branding, rank-coloured names, and rank/name ordering for each viewer's roster. */
 class TabList(
     private val proxy: ProxyServer,
     private val messages: Translations,
     private val roleQuery: () -> PlayerRoleQuery?,
     private val serverQuery: () -> ServerDisplayQuery?,
     private val isBedrock: (java.util.UUID) -> Boolean = { false },
-    private val onlineCount: () -> Int? = { null },
 ) {
     private val rankWarmup = RankWarmup()
 
@@ -47,27 +25,15 @@ class TabList(
         colourNames(viewer)
     }
 
-    /**
-     * Redraws for everyone.
-     *
-     * Called on a timer, because the ping and the roster change without an event to hang off. It
-     * renders per player rather than once for all of them: the footer is in the player's own
-     * language and carries their own ping, so there is nothing to share.
-     */
+    /** Refreshes each viewer in their language as the roster and rank snapshots change. */
     fun refreshAll() {
         proxy.allPlayers.forEach(::refresh)
     }
 
     private fun header(viewer: Player): Component = messages.render(ProxyMessage.TAB_HEADER, viewer)
 
     private fun footer(viewer: Player): Component =
-        messages.render(
-            ProxyMessage.TAB_FOOTER,
-            viewer,
-            "server" to serverLabel(viewer),
-            "ping" to ping(viewer.ping),
-            "online" to (onlineCount()?.toString() ?: "—"),
-        )
+        messages.render(ProxyMessage.TAB_FOOTER, viewer, "server" to serverLabel(viewer))
 
     private fun serverLabel(viewer: Player): Component {
         val raw =
@@ -78,12 +44,7 @@ class TabList(
         val label =
             kindLabel(kind, viewer)
                 ?: plain(messages.render(ProxyMessage.TAB_SERVER_UNKNOWN, viewer))
-        val peers =
-            proxy.allServers
-                .map { it.serverInfo.name }
-                .filter { query?.displayOf(it)?.kind == kind }
-        val number = ServerDisplayIds.numberOf(raw, peers)
-        return Component.text("$label $number", Palette.TEXT)
+        return Component.text(label, Palette.TEXT)
     }
 
     private fun kindLabel(kind: String?, viewer: Player): String? {
@@ -107,8 +68,25 @@ class TabList(
      */
     private fun colourNames(viewer: Player) {
         val query = roleQuery()
-        viewer.tabList.entries.forEach { entry ->
-            val role = query?.highestRoleOf(entry.profile.id)
+        val entries = viewer.tabList.entries.toList()
+        val roles = entries.associate { it.profile.id to query?.highestRoleOf(it.profile.id) }
+        val orders =
+            TabOrder.orders(
+                entries.map { entry ->
+                    TabOrder.Entry(
+                        entry.profile.id,
+                        gg.grounds.proxy.api.PlayerDisplayNames.displayName(
+                            entry.profile.name,
+                            isBedrock(entry.profile.id),
+                        ),
+                        roles[entry.profile.id]?.sortOrder,
+                    )
+                }
+            )
+        entries.forEach { entry ->
+            val order = orders.getValue(entry.profile.id)
+            if (entry.listOrder != order) entry.setListOrder(order)
+            val role = roles[entry.profile.id]
             val supplied = entry.displayNameComponent.orElse(null)
             if (
                 role == null &&
 
@@ -0,0 +1,19 @@
+package gg.grounds.proxy.velocity.tab
+
+import java.util.Locale
+import java.util.UUID
+
+/** A viewer's existing roster, ordered independently of local proxy membership. */
+internal object TabOrder {
+    data class Entry(val id: UUID, val name: String, val sortOrder: Int?)
+
+    fun orders(entries: List<Entry>): Map<UUID, Int> =
+        entries
+            .sortedWith(
+                compareBy<Entry> { it.sortOrder?.toLong() ?: Long.MAX_VALUE }
+                    .thenBy { it.name.lowercase(Locale.ROOT) }
+                    .thenBy { it.id }
+            )
+            .mapIndexed { index, entry -> entry.id to entries.size - index }
+            .toMap()
+}
@@ -1,7 +1,7 @@
 # Three leading lines balance the 26px wordmark's ascent against the two trailing lines.
 # U+E018 is TabSpaces.of(16) on each side.
 tab.header=\n\n\n<font:grounds:tab><white>\uE018\uE000\uE018</white></font>\n\n
-tab.footer=\n<text><bold><server></bold></text><muted> • </muted><text><online> players online</text><muted> • </muted><ping>
+tab.footer=\n<text><bold><server></bold></text>\n<muted>grounds.gg</muted>
 tab.server.lobby=Lobby
 tab.server.game=Game
 tab.server.match=Match
 
@@ -1,5 +1,5 @@
 tab.header=\n\n\n<font:grounds:tab><white>\uE018\uE000\uE018</white></font>\n\n
-tab.footer=\n<text><bold><server></bold></text><muted> • </muted><text><online> Spieler online</text><muted> • </muted><ping>
+tab.footer=\n<text><bold><server></bold></text>\n<muted>grounds.gg</muted>
 tab.server.lobby=Lobby
 tab.server.game=Spiel
 tab.server.match=Match
 
@@ -1,5 +1,5 @@
 tab.header=\n\n\n<font:grounds:tab><white>\uE018\uE000\uE018</white></font>\n\n
-tab.footer=\n<text><bold><server></bold></text><muted> • </muted><text><online> jugadores conectados</text><muted> • </muted><ping>
+tab.footer=\n<text><bold><server></bold></text>\n<muted>grounds.gg</muted>
 tab.server.lobby=Lobby
 tab.server.game=Juego
 tab.server.match=Partida
 
@@ -1,5 +1,5 @@
 tab.header=\n\n\n<font:grounds:tab><white>\uE018\uE000\uE018</white></font>\n\n
-tab.footer=\n<text><bold><server></bold></text><muted> • </muted><text><online> joueurs en ligne</text><muted> • </muted><ping>
+tab.footer=\n<text><bold><server></bold></text>\n<muted>grounds.gg</muted>
 tab.server.lobby=Lobby
 tab.server.game=Jeu
 tab.server.match=Match
 
@@ -66,21 +66,13 @@ class TabListTest {
     }
 
     @Test
-    fun `the footer carries the friendly server network count and ping`() {
-        val rendered = footer("Lobby 2", 17)
-        assertTrue(rendered.contains("Lobby 2"), rendered)
-        assertTrue(rendered.contains("17 ms"), rendered)
-        assertTrue(rendered.contains("42 players online"), rendered)
-        assertFalse(rendered.contains("grounds.gg"), rendered)
-        assertFalse(rendered.contains("nl-ams1"), rendered)
-    }
-
-    @Test
-    fun `the footer is one status line separated by dots`() {
-        val rendered = footer("Lobby 2", 17)
-        val body = rendered.trim().lines()
-        assertEquals(1, body.size, rendered)
-        assertEquals("Lobby 2 • 42 players online • 17 ms", body.single())
+    fun `the footer contains only the server type and domain in every locale`() {
+        for (locale in
+            listOf(Locale.ENGLISH, Locale.GERMAN, Locale.FRENCH, Locale.forLanguageTag("es"))) {
+            val rendered =
+                plain(messages.render(ProxyMessage.TAB_FOOTER, locale, "server" to "Lobby"))
+            assertEquals(listOf("Lobby", "grounds.gg"), rendered.trim().lines())
+        }
     }
 
     /** Hard-coding the year is how a footer ends up saying 2026 in 2029. */
 
@@ -0,0 +1,30 @@
+package gg.grounds.proxy.velocity.tab
+
+import java.util.UUID
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class TabOrderTest {
+    @Test
+    fun `rank wins over name then equal priorities use case insensitive alphabet`() {
+        val names = listOf("Aaron", "zoe", "alice", "Bob", "ALICE", "Unknown")
+        val priorities = listOf<Int?>(20, 0, 0, 0, 0, null)
+        val entries =
+            names.mapIndexed { i, name -> TabOrder.Entry(UUID(0, i.toLong()), name, priorities[i]) }
+        val order = TabOrder.orders(entries)
+        assertEquals(
+            listOf("alice", "ALICE", "Bob", "zoe", "Aaron", "Unknown"),
+            entries.sortedByDescending { order[it.id] }.map { it.name },
+        )
+    }
+
+    @Test
+    fun `extreme priorities do not overflow and an unknown rank sorts last`() {
+        val entries =
+            listOf(Int.MAX_VALUE, null, Int.MIN_VALUE).mapIndexed { i, priority ->
+                TabOrder.Entry(UUID(0, i.toLong()), "Player$i", priority)
+            }
+        val order = TabOrder.orders(entries)
+        assertEquals(listOf(entries[2].id, entries[0].id, entries[1].id), order.keys.toList())
+    }
+}