{
  "id": "rust",
  "title": "Redis leaderboard with Rust",
  "url": "https://redis.io/docs/latest/develop/use-cases/leaderboard/rust/",
  "summary": "Implement sync and async Redis leaderboards in Rust with redis-rs and sorted sets",
  "tags": [
    "docs",
    "develop",
    "stack",
    "oss",
    "rs",
    "rc"
  ],
  "last_updated": "2026-04-28T13:01:52-05:00",
  "children": [],
  "page_type": "content",
  "content_hash": "d63ec545004dacb409c50f270c69087c0ab7a57f40f4cc4527a3ba6a3b0923cf",
  "sections": [
    {
      "id": "overview",
      "title": "Overview",
      "role": "overview",
      "text": "This guide shows you how to implement Redis-backed leaderboards in Rust with the [`redis-rs`](https://redis.io/docs/latest/develop/clients/rust) client library. It includes both synchronous and asynchronous APIs, uses a sorted set to store rank order, stores per-user metadata in Redis hashes, and includes a small local web server so you can explore the leaderboard interactively in your browser."
    },
    {
      "id": "overview",
      "title": "Overview",
      "role": "overview",
      "text": "Leaderboards are a natural fit for Redis. A sorted set stores each member together with a numeric score, and Redis maintains the ranking order automatically.\n\nThat gives you:\n\n* Fast score updates for existing users\n* Simple top `n` leaderboard queries\n* Efficient queries for entries around a specific rank position\n* Straightforward trimming to a fixed leaderboard size\n* A clean separation between rank data and richer user metadata\n\nIn this example, the leaderboard score data is stored in a sorted set called `leaderboard:demo`, and each user's metadata is stored in a hash such as `leaderboard:demo:user:player-17`."
    },
    {
      "id": "how-it-works",
      "title": "How it works",
      "role": "content",
      "text": "The flow looks like this:\n\n1. Store each user ID in a sorted set with their score\n2. Store per-user metadata in a separate Redis hash keyed by user ID\n3. Fetch the highest-ranked users with a reverse range query\n4. Fetch users around a given rank by calculating a rank window\n5. Trim the leaderboard after updates so only the top configured entries remain\n\nSeparating rank data from metadata keeps leaderboard operations efficient while still letting the application render richer profile details."
    },
    {
      "id": "installation",
      "title": "Installation",
      "role": "setup",
      "text": "Add the `redis` crate to your `Cargo.toml`:\n\n[code example]"
    },
    {
      "id": "using-the-rust-module",
      "title": "Using the Rust module",
      "role": "content",
      "text": "The module provides both a synchronous `RedisLeaderboard` and an asynchronous `AsyncRedisLeaderboard`\n([source](leaderboard.rs))."
    },
    {
      "id": "synchronous-usage",
      "title": "Synchronous usage",
      "role": "content",
      "text": "[code example]"
    },
    {
      "id": "asynchronous-usage",
      "title": "Asynchronous usage",
      "role": "content",
      "text": "[code example]"
    },
    {
      "id": "data-model",
      "title": "Data model",
      "role": "content",
      "text": "The implementation uses two Redis structures:\n\n[code example]\n\nThe score data lives in the sorted set, while the user details live in hashes keyed by the same user ID.\n\nThe implementation uses:\n\n* [`ZADD`](https://redis.io/docs/latest/commands/zadd) to add or update leaderboard scores\n* [`ZRANGE`](https://redis.io/docs/latest/commands/zrange) with the `REV` option to fetch the highest-ranked members\n* [`ZREVRANK`](https://redis.io/docs/latest/commands/zrevrank) to find a user's rank from the top\n* [`ZREMRANGEBYRANK`](https://redis.io/docs/latest/commands/zremrangebyrank) to trim the lowest-ranked overflow entries\n* [`HSET`](https://redis.io/docs/latest/commands/hset) and [`HGETALL`](https://redis.io/docs/latest/commands/hgetall) to store and load user metadata\n* [`DEL`](https://redis.io/docs/latest/commands/del) to remove metadata for trimmed or deleted users"
    },
    {
      "id": "leaderboard-implementation",
      "title": "Leaderboard implementation",
      "role": "content",
      "text": "The synchronous `upsert_user()` method writes the score, updates metadata, and then trims the board if it exceeds the configured limit:\n\n[code example]\n\nTo fetch users around a rank, the implementation converts the requested rank and count into a reverse range window:\n\n[code example]"
    },
    {
      "id": "metadata-design",
      "title": "Metadata design",
      "role": "content",
      "text": "The leaderboard stores only user IDs and scores in the sorted set. Richer details stay in a separate per-user hash. That means the same user ID can be ranked efficiently while still exposing extra fields such as:\n\n* Display name\n* Short description\n* Team or country\n* Avatar URL\n* Other lightweight profile fields\n\nThis is a useful pattern when the ranking view and the profile view need different data shapes."
    },
    {
      "id": "running-the-demo",
      "title": "Running the demo",
      "role": "content",
      "text": "A local demo server is included to show the leaderboard in action\n([source](demo_server.rs)):\n\n[code example]\n\nThe demo uses the async leaderboard implementation for the HTTP handlers and provides an interactive web interface where you can:\n\n* Add or update a player score and metadata\n* Increase a player's score incrementally\n* View the top `n` players on the leaderboard\n* View the `n` players around a chosen rank\n* Change the maximum number of entries the leaderboard keeps\n* Reset the demo dataset to a known starting state\n\nThe demo assumes Redis is running on `localhost:6379` but you can specify a different host using the `REDIS_URL` environment variable. Visit `http://localhost:8080` in your browser to try it out."
    },
    {
      "id": "production-usage",
      "title": "Production usage",
      "role": "content",
      "text": "This guide uses a deliberately small local demo so you can focus on the Redis leaderboard pattern. In production, you will usually want to add more validation, tighter concurrency control, and application-specific lifecycle rules."
    },
    {
      "id": "decide-how-ties-should-behave",
      "title": "Decide how ties should behave",
      "role": "content",
      "text": "Redis sorted sets order primarily by score. When two members have the same score, Redis uses the member value as a secondary ordering rule. If your application needs a different tie-breaker, you may want to encode it in the score or store additional state."
    },
    {
      "id": "consider-how-you-expire-or-archive-old-data",
      "title": "Consider how you expire or archive old data",
      "role": "content",
      "text": "Some leaderboards are permanent, while others reset daily, weekly, or seasonally. Depending on your use case, you may want to:\n\n* Namespace keys by season or event\n* Snapshot historical results elsewhere\n* Rebuild the current leaderboard from upstream data"
    },
    {
      "id": "keep-metadata-lightweight",
      "title": "Keep metadata lightweight",
      "role": "content",
      "text": "Per-user hashes work best for small, frequently accessed profile details. Large profile documents or rarely used attributes are often better kept in another store, with Redis holding only the fields needed to render the leaderboard quickly."
    }
  ],
  "examples": [
    {
      "id": "installation-ex0",
      "language": "toml",
      "code": "[dependencies]\nredis = { version = \"0.24\", features = [\"script\", \"tokio-comp\"] }\ntokio = { version = \"1\", features = [\"full\"] }",
      "section_id": "installation"
    },
    {
      "id": "synchronous-usage-ex0",
      "language": "rust",
      "code": "use redis::Client;\n\nlet client = Client::open(\"redis://localhost:6379/\")?;\nlet mut con = client.get_connection()?;\n\nlet board = RedisLeaderboard::new(\"leaderboard:demo\", 100);\n\nboard.upsert_user(\n    &mut con,\n    \"player-1\",\n    1200.0,\n    Some(metadata_map(&[\n        (\"name\", \"Ada\"),\n        (\"description\", \"Solves production incidents before breakfast.\"),\n    ])),\n)?;\n\nlet top_players = board.get_top(&mut con, 5)?;",
      "section_id": "synchronous-usage"
    },
    {
      "id": "asynchronous-usage-ex0",
      "language": "rust",
      "code": "use redis::Client;\n\nlet client = Client::open(\"redis://localhost:6379/\")?;\nlet mut con = client.get_multiplexed_async_connection().await?;\n\nlet board = AsyncRedisLeaderboard::new(\"leaderboard:demo\", 100);\n\nboard.upsert_user(\n    &mut con,\n    \"player-1\",\n    1200.0,\n    Some(metadata_map(&[\n        (\"name\", \"Ada\"),\n        (\"description\", \"Solves production incidents before breakfast.\"),\n    ])),\n).await?;\n\nlet top_players = board.get_top(&mut con, 5).await?;",
      "section_id": "asynchronous-usage"
    },
    {
      "id": "data-model-ex0",
      "language": "text",
      "code": "leaderboard:demo\n  player-1 => 1225\n  player-2 => 1180\n  player-3 => 1105\n\nleaderboard:demo:user:player-1\n  name = Ada\n  description = Solves production incidents before breakfast.",
      "section_id": "data-model"
    },
    {
      "id": "leaderboard-implementation-ex0",
      "language": "rust",
      "code": "pub fn upsert_user(\n    &self,\n    con: &mut dyn redis::ConnectionLike,\n    user_id: &str,\n    score: f64,\n    metadata: Option<Metadata>,\n) -> RedisResult<LeaderboardEntry> {\n    let payload = metadata.unwrap_or_default();\n\n    let mut pipe = redis::pipe();\n    pipe.atomic().cmd(\"ZADD\").arg(&self.key).arg(score).arg(user_id);\n    if !payload.is_empty() {\n        pipe.cmd(\"HSET\")\n            .arg(self.metadata_key(user_id))\n            .arg(flatten_metadata(&payload));\n    }\n    pipe.query::<()>(con)?;\n\n    let trimmed_user_ids = self.trim_to_max_entries(con)?;\n    let entry = self.get_user_entry(con, user_id)?;\n    Ok(entry.unwrap_or_else(|| LeaderboardEntry::new(0, user_id, score, payload, trimmed_user_ids)))\n}",
      "section_id": "leaderboard-implementation"
    },
    {
      "id": "leaderboard-implementation-ex1",
      "language": "rust",
      "code": "pub fn get_around_rank(\n    &self,\n    con: &mut dyn redis::ConnectionLike,\n    rank: usize,\n    count: usize,\n) -> RedisResult<Vec<LeaderboardEntry>> {\n    let total_entries = self.get_size(con)? as usize;\n    if total_entries <= count {\n        return self.list_all(con);\n    }\n\n    let half_window = count / 2;\n    let mut start = rank.saturating_sub(1 + half_window);\n    let max_start = total_entries - count;\n    if start > max_start {\n        start = max_start;\n    }\n    let end = start + count - 1;\n\n    let entries: Vec<(String, f64)> = redis::cmd(\"ZRANGE\")\n        .arg(&self.key)\n        .arg(start)\n        .arg(end)\n        .arg(\"REV\")\n        .arg(\"WITHSCORES\")\n        .query(con)?;\n\n    self.hydrate_entries(con, entries, start + 1)\n}",
      "section_id": "leaderboard-implementation"
    },
    {
      "id": "running-the-demo-ex0",
      "language": "bash",
      "code": "cargo run --bin demo_server",
      "section_id": "running-the-demo"
    }
  ]
}