Consistent hashing and rendezvous hashing

Python 3.14 · main.py

from bisect import bisect_left

NODES = "ABCDE"


def h32(text: str) -> int:
    # FNV-1a, then MurmurHash3's final mix.
    h = 0x811C9DC5
    for byte in text.encode():
        h = ((h ^ byte) * 0x01000193) & 0xFFFFFFFF
    h = ((h ^ (h >> 16)) * 0x85EBCA6B) & 0xFFFFFFFF
    h = ((h ^ (h >> 13)) * 0xC2B2AE35) & 0xFFFFFFFF
    return h ^ (h >> 16)


# 100 points a node, packed as position * 8 + node number.
RINGS = {
    n: sorted(h32(f"{NODES[i]}#{p}") * 8 + i for i in range(n) for p in range(100))
    for n in (4, 5)
}


def by_ring(n: int, key: str) -> str:
    # The first point at or after the key, wrapping round.
    ring = RINGS[n]
    return NODES[ring[bisect_left(ring, h32(key) * 8) % len(ring)] % 8]


def by_rendezvous(n: int, key: str) -> str:
    return max(NODES[:n], key=lambda node: h32(f"{node}|{key}"))


keys = [f"user:{i}" for i in range(2_000)]
schemes = {
    "hash mod N": lambda n, key: NODES[h32(key) % n],
    "ring": by_ring,
    "rendezvous": by_rendezvous,
}
for name, place in schemes.items():
    moved = [key for key in keys if place(4, key) != place(5, key)]
    to_e = "yes" if all(place(5, key) == "E" for key in moved) else "no"
    print(f"{name}: {len(moved)} keys move, all to E: {to_e}")

In Python: bisect_left finds the first point at or after the key, and max keeps the first node with the highest score, which settles a tie.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

const NODES = "ABCDE";

function h32(text) {
  // FNV-1a, then MurmurHash3's final mix.
  let h = 0x811c9dc5;
  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 0x01000193);
  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
  return (h ^ (h >>> 16)) >>> 0;
}

// 100 points a node, packed as position * 8 + node number.
const ring = (n) =>
  Array.from({ length: n * 100 }, (_, k) => {
    const node = Math.floor(k / 100);
    return h32(`${NODES[node]}#${k % 100}`) * 8 + node;
  }).sort((a, b) => a - b);
const RINGS = { 4: ring(4), 5: ring(5) };

function byRing(n, key) {
  // The first point at or after the key, wrapping round.
  const ring = RINGS[n];
  const target = h32(key) * 8;
  let lo = 0;
  let hi = ring.length;
  while (lo < hi) {
    const mid = (lo + hi) >>> 1;
    if (ring[mid] < target) lo = mid + 1;
    else hi = mid;
  }
  return NODES[ring[lo % ring.length] % 8];
}

function byRendezvous(n, key) {
  const score = (node) => h32(`${node}|${key}`);
  return [...NODES.slice(0, n)].reduce((best, node) => (score(node) > score(best) ? node : best));
}

const keys = Array.from({ length: 2000 }, (_, i) => `user:${i}`);
const schemes = {
  "hash mod N": (n, key) => NODES[h32(key) % n],
  ring: byRing,
  rendezvous: byRendezvous,
};
for (const [name, place] of Object.entries(schemes)) {
  const moved = keys.filter((key) => place(4, key) !== place(5, key));
  const toE = moved.every((key) => place(5, key) === "E") ? "yes" : "no";
  console.log(`${name}: ${moved.length} keys move, all to E: ${toE}`);
}

In JavaScript: Math.imul multiplies as 32-bit integers, and >>> 0 reads the result as unsigned. JavaScript has no binary search of its own, so byRing writes the search that bisect_left does in Python; reduce keeps the first of equal top scores.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class Main {
  static final String NODES = "ABCDE";
  static final List<String> KEYS = IntStream.range(0, 2_000).mapToObj(i -> "user:" + i).toList();
  static final long[][] RINGS = {ring(4), ring(5)};

  interface Place {
    char at(int n, String key);
  }

  static long h32(String text) {
    // FNV-1a, then MurmurHash3's final mix.
    int h = 0x811C9DC5;
    for (byte b : text.getBytes(StandardCharsets.UTF_8)) {
      h = (h ^ (b & 0xFF)) * 0x01000193;
    }
    h = (h ^ (h >>> 16)) * 0x85EBCA6B;
    h = (h ^ (h >>> 13)) * 0xC2B2AE35;
    return Integer.toUnsignedLong(h ^ (h >>> 16));
  }

  // 100 points a node, packed as position * 8 + node number.
  static long[] ring(int n) {
    long[] ring = new long[n * 100];
    for (int k = 0; k < ring.length; k++) {
      ring[k] = h32(NODES.charAt(k / 100) + "#" + k % 100) * 8 + k / 100;
    }
    Arrays.sort(ring);
    return ring;
  }

  static char byRing(int n, String key) {
    // The first point at or after the key, wrapping round.
    long[] ring = RINGS[n - 4];
    int i = Arrays.binarySearch(ring, h32(key) * 8);
    return NODES.charAt((int) (ring[(i >= 0 ? i : -i - 1) % ring.length] % 8));
  }

  static char byRendezvous(int n, String key) {
    char best = NODES.charAt(0);
    for (char node : NODES.substring(1, n).toCharArray()) {
      if (h32(node + "|" + key) > h32(best + "|" + key)) {
        best = node;
      }
    }
    return best;
  }

  static void report(String name, Place place) {
    List<String> moved = KEYS.stream().filter(k -> place.at(4, k) != place.at(5, k)).toList();
    String toE = moved.stream().allMatch(k -> place.at(5, k) == 'E') ? "yes" : "no";
    System.out.println(name + ": " + moved.size() + " keys move, all to E: " + toE);
  }

  public static void main(String[] args) {
    report("hash mod N", (n, key) -> NODES.charAt((int) (h32(key) % n)));
    report("ring", Main::byRing);
    report("rendezvous", Main::byRendezvous);
  }
}

In Java: An int multiplies with 32-bit wraparound, so h32 needs no mask; Integer.toUnsignedLong reads the result as unsigned. Arrays.binarySearch returns minus the insertion point minus one when the value is absent, and the strict > keeps the first of equal scores.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <algorithm>
#include <cstdint>
#include <format>
#include <print>
#include <string>
#include <string_view>
#include <vector>

const std::string kNodes = "ABCDE";

std::uint32_t h32(const std::string &text) {
  // FNV-1a, then MurmurHash3's final mix.
  std::uint32_t h = 0x811C9DC5u;
  for (const unsigned char byte : text) {
    h = (h ^ byte) * 0x01000193u;
  }
  h = (h ^ (h >> 16)) * 0x85EBCA6Bu;
  h = (h ^ (h >> 13)) * 0xC2B2AE35u;
  return h ^ (h >> 16);
}

// 100 points a node, packed as position * 8 + node number.
std::vector<std::uint64_t> ring(int n) {
  std::vector<std::uint64_t> ring;
  for (int k = 0; k < n * 100; ++k) {
    const int node = k / 100;
    const std::string text = std::format("{}#{}", kNodes[node], k % 100);
    ring.push_back(std::uint64_t{h32(text)} * 8 + node);
  }
  std::ranges::sort(ring);
  return ring;
}

const std::vector<std::uint64_t> kRings[] = {ring(4), ring(5)};

char byRing(int n, const std::string &key) {
  // The first point at or after the key, wrapping round.
  const auto &ring = kRings[n - 4];
  const auto it = std::ranges::lower_bound(ring, std::uint64_t{h32(key)} * 8);
  return kNodes[(it == ring.end() ? ring.front() : *it) % 8];
}

char byRendezvous(int n, const std::string &key) {
  return *std::ranges::max_element(
      std::string_view(kNodes).substr(0, n), {},
      [&](char node) { return h32(std::format("{}|{}", node, key)); });
}

void report(std::string_view name, char (*place)(int, const std::string &)) {
  int moved = 0;
  bool toE = true;
  for (int i = 0; i < 2000; ++i) {
    const std::string key = std::format("user:{}", i);
    if (place(4, key) != place(5, key)) {
      ++moved;
      toE = toE && place(5, key) == 'E';
    }
  }
  std::println("{}: {} keys move, all to E: {}", name, moved,
               toE ? "yes" : "no");
}

int main() {
  report("hash mod N",
         [](int n, const std::string &key) { return kNodes[h32(key) % n]; });
  report("ring", byRing);
  report("rendezvous", byRendezvous);
}

In C++: std::ranges::lower_bound is the ring lookup, and std::ranges::max_element returns the first of equal highest scores.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

using System.Globalization;
using System.Text;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

const string Nodes = "ABCDE";
long[][] rings = [Ring(4), Ring(5)];
(string Name, Func<int, string, char> Place)[] schemes =
[
    ("hash mod N", (n, key) => Nodes[(int)(H32(key) % (uint)n)]),
    ("ring", (n, key) => ByRing(rings[n - 4], key)),
    ("rendezvous", ByRendezvous),
];

var keys = Enumerable.Range(0, 2_000).Select(i => $"user:{i}").ToList();
foreach (var (name, place) in schemes)
{
    var moved = keys.Where(key => place(4, key) != place(5, key)).ToList();
    string toE = moved.All(key => place(5, key) == 'E') ? "yes" : "no";
    Console.WriteLine($"{name}: {moved.Count} keys move, all to E: {toE}");
}

static uint H32(string text)
{
    // FNV-1a, then MurmurHash3's final mix.
    uint h = 0x811C9DC5;
    foreach (byte b in Encoding.UTF8.GetBytes(text))
    {
        h = (h ^ b) * 0x01000193;
    }
    h = (h ^ (h >> 16)) * 0x85EBCA6B;
    h = (h ^ (h >> 13)) * 0xC2B2AE35;
    return h ^ (h >> 16);
}

// 100 points a node, packed as position * 8 + node number.
static long[] Ring(int n)
{
    long[] ring = [.. Enumerable.Range(0, n * 100)
        .Select(k => H32($"{Nodes[k / 100]}#{k % 100}") * 8L + k / 100)];
    Array.Sort(ring);
    return ring;
}

static char ByRing(long[] ring, string key)
{
    // The first point at or after the key, wrapping round.
    int i = Array.BinarySearch(ring, H32(key) * 8L);
    return Nodes[(int)(ring[(i >= 0 ? i : ~i) % ring.Length] % 8)];
}

static char ByRendezvous(int n, string key) => Nodes[..n].MaxBy(node => H32($"{node}|{key}"));

In C#: uint arithmetic wraps by default, so H32 needs no mask. Array.BinarySearch returns the complement of the insertion point when the value is absent, and MaxBy returns the first of equal top scores.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

static const char NODES[] = "ABCDE";
static uint64_t rings[6][5 * 100]; // rings[n]: the ring of the first n nodes

static uint32_t h32(const char *text) {
  // FNV-1a, then MurmurHash3's final mix.
  uint32_t h = 0x811C9DC5u;
  for (; *text != '\0'; text++)
    h = (h ^ (unsigned char)*text) * 0x01000193u;
  h = (h ^ (h >> 16)) * 0x85EBCA6Bu;
  h = (h ^ (h >> 13)) * 0xC2B2AE35u;
  return h ^ (h >> 16);
}

static int ascending(const void *a, const void *b) {
  const uint64_t x = *(const uint64_t *)a, y = *(const uint64_t *)b;
  return (x > y) - (x < y);
}

// 100 points a node, packed as position * 8 + node number.
static void build_ring(int n) {
  char text[8];
  for (int k = 0; k < n * 100; k++) {
    snprintf(text, sizeof text, "%c#%d", NODES[k / 100], k % 100);
    rings[n][k] = (uint64_t)h32(text) * 8 + (uint64_t)(k / 100);
  }
  qsort(rings[n], (size_t)(n * 100), sizeof rings[n][0], ascending);
}

static char by_modulo(int n, const char *key) { return NODES[h32(key) % n]; }

static char by_ring(int n, const char *key) {
  // The first point at or after the key, wrapping round.
  const uint64_t target = (uint64_t)h32(key) * 8;
  int lo = 0, hi = n * 100;
  while (lo < hi) {
    const int mid = (lo + hi) / 2;
    if (rings[n][mid] < target)
      lo = mid + 1;
    else
      hi = mid;
  }
  return NODES[rings[n][lo % (n * 100)] % 8];
}

static char by_rendezvous(int n, const char *key) {
  char best = 0, text[24];
  uint32_t top = 0;
  for (int i = 0; i < n; i++) {
    snprintf(text, sizeof text, "%c|%s", NODES[i], key);
    if (best == 0 || h32(text) > top) {
      top = h32(text);
      best = NODES[i];
    }
  }
  return best;
}

static void report(const char *name, char (*place)(int, const char *)) {
  int moved = 0, to_e = 1;
  char key[16];
  for (int i = 0; i < 2000; i++) {
    snprintf(key, sizeof key, "user:%d", i);
    const char was = place(4, key), now = place(5, key);
    moved += was != now;
    to_e = to_e && (was == now || now == 'E');
  }
  printf("%s: %d keys move, all to E: %s\n", name, moved, to_e ? "yes" : "no");
}

int main(void) {
  build_ring(4);
  build_ring(5);
  report("hash mod N", by_modulo);
  report("ring", by_ring);
  report("rendezvous", by_rendezvous);
}

In C: Ring points are uint64_t values sorted by qsort, and rings[n] holds the ring of the first n nodes. bsearch finds only an equal value, so by_ring writes its own search for the first point at or after the key.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

const NODES = 'ABCDE';

/** The low 32 bits of $a * $b, in parts that fit PHP's 64-bit integers. */
function mul32(int $a, int $b): int
{
    return (((($a * ($b >> 16)) & 0xFFFF) << 16) + $a * ($b & 0xFFFF)) & 0xFFFFFFFF;
}

function h32(string $text): int
{
    // FNV-1a, then MurmurHash3's final mix.
    $h = 0x811C9DC5;
    foreach (unpack('C*', $text) as $byte) {
        $h = mul32($h ^ $byte, 0x01000193);
    }
    $h = mul32($h ^ ($h >> 16), 0x85EBCA6B);
    $h = mul32($h ^ ($h >> 13), 0xC2B2AE35);
    return $h ^ ($h >> 16);
}

/** 100 points a node, packed as position * 8 + node number. */
function ring(int $n): array
{
    $ring = [];
    for ($k = 0; $k < $n * 100; $k++) {
        $node = intdiv($k, 100);
        $ring[] = h32(NODES[$node] . '#' . $k % 100) * 8 + $node;
    }
    sort($ring);
    return $ring;
}

function byRing(int $n, string $key): string
{
    // The first point at or after the key, wrapping round.
    static $rings = [];
    $ring = $rings[$n] ??= ring($n);
    $target = h32($key) * 8;
    [$lo, $hi] = [0, count($ring)];
    while ($lo < $hi) {
        $mid = intdiv($lo + $hi, 2);
        if ($ring[$mid] < $target) {
            $lo = $mid + 1;
        } else {
            $hi = $mid;
        }
    }
    return NODES[$ring[$lo % count($ring)] % 8];
}

function byRendezvous(int $n, string $key): string
{
    $best = NODES[0];
    foreach (str_split(substr(NODES, 1, $n - 1)) as $node) {
        if (h32("{$node}|{$key}") > h32("{$best}|{$key}")) {
            $best = $node;
        }
    }
    return $best;
}

$keys = array_map(fn(int $i): string => "user:{$i}", range(0, 1999));
$schemes = [
    'hash mod N' => fn(int $n, string $key): string => NODES[h32($key) % $n],
    'ring' => byRing(...),
    'rendezvous' => byRendezvous(...),
];
foreach ($schemes as $name => $place) {
    $moved = array_filter($keys, fn(string $k): bool => $place(4, $k) !== $place(5, $k));
    $toE = array_all($moved, fn(string $k): bool => $place(5, $k) === 'E') ? 'yes' : 'no';
    printf("%s: %d keys move, all to E: %s\n", $name, count($moved), $toE);
}

In PHP: PHP's integers are signed 64-bit, so mul32 multiplies in two halves to keep the low 32 bits exact; the browser build of PHP has 32-bit integers. PHP has no binary search, so byRing writes one.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. To run it yourself: php main.php

Rust 1.99 · main.rs

use std::sync::LazyLock;

const NODES: [char; 5] = ['A', 'B', 'C', 'D', 'E'];

static RINGS: LazyLock<[Vec<u64>; 2]> = LazyLock::new(|| [ring(4), ring(5)]);

fn h32(text: &str) -> u32 {
    // FNV-1a, then MurmurHash3's final mix.
    let mut h: u32 = 0x811C_9DC5;
    for &byte in text.as_bytes() {
        h = (h ^ u32::from(byte)).wrapping_mul(0x0100_0193);
    }
    h = (h ^ (h >> 16)).wrapping_mul(0x85EB_CA6B);
    h = (h ^ (h >> 13)).wrapping_mul(0xC2B2_AE35);
    h ^ (h >> 16)
}

// 100 points a node, packed as position * 8 + node number.
fn ring(n: usize) -> Vec<u64> {
    let mut ring = Vec::new();
    for k in 0..n * 100 {
        let node = k / 100;
        ring.push(u64::from(h32(&format!("{}#{}", NODES[node], k % 100))) * 8 + node as u64);
    }
    ring.sort_unstable();
    ring
}

fn by_ring(n: usize, key: &str) -> char {
    // The first point at or after the key, wrapping round.
    let ring = &RINGS[n - 4];
    let target = u64::from(h32(key)) * 8;
    NODES[(ring[ring.partition_point(|&p| p < target) % ring.len()] % 8) as usize]
}

fn by_rendezvous(n: usize, key: &str) -> char {
    let mut best = NODES[0];
    for &node in &NODES[1..n] {
        if h32(&format!("{node}|{key}")) > h32(&format!("{best}|{key}")) {
            best = node;
        }
    }
    best
}

fn main() {
    let keys: Vec<String> = (0..2_000).map(|i| format!("user:{i}")).collect();
    let schemes: [(&str, fn(usize, &str) -> char); 3] = [
        ("hash mod N", |n, key| NODES[h32(key) as usize % n]),
        ("ring", by_ring),
        ("rendezvous", by_rendezvous),
    ];
    for (name, place) in schemes {
        let moved: Vec<&String> = keys.iter().filter(|k| place(4, k) != place(5, k)).collect();
        let all_to_e = moved.iter().all(|k| place(5, k) == 'E');
        let to_e = if all_to_e { "yes" } else { "no" };
        println!("{name}: {} keys move, all to E: {to_e}", moved.len());
    }
}

In Rust: wrapping_mul makes the 32-bit wraparound explicit, partition_point is the binary search for the first point at or after the key, and LazyLock builds the two rings on first use. The strict > keeps the first of equal scores.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

type Place = (n: number, key: string) => string;

const NODES = "ABCDE";

function h32(text: string): number {
  // FNV-1a, then MurmurHash3's final mix.
  let h = 0x811c9dc5;
  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 0x01000193);
  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
  return (h ^ (h >>> 16)) >>> 0;
}

// 100 points a node, packed as position * 8 + node number.
const ring = (n: number): number[] =>
  Array.from({ length: n * 100 }, (_, k) => {
    const node = Math.floor(k / 100);
    return h32(`${NODES[node]}#${k % 100}`) * 8 + node;
  }).sort((a, b) => a - b);
const RINGS: Record<number, number[]> = { 4: ring(4), 5: ring(5) };

const byRing: Place = (n, key) => {
  // The first point at or after the key, wrapping round.
  const ring = RINGS[n];
  const target = h32(key) * 8;
  let lo = 0;
  let hi = ring.length;
  while (lo < hi) {
    const mid = (lo + hi) >>> 1;
    if (ring[mid] < target) lo = mid + 1;
    else hi = mid;
  }
  return NODES[ring[lo % ring.length] % 8];
};

const byRendezvous: Place = (n, key) => {
  const score = (node: string) => h32(`${node}|${key}`);
  return [...NODES.slice(0, n)].reduce((best, node) => (score(node) > score(best) ? node : best));
};

const keys = Array.from({ length: 2000 }, (_, i) => `user:${i}`);
const schemes: Record<string, Place> = {
  "hash mod N": (n, key) => NODES[h32(key) % n],
  ring: byRing,
  rendezvous: byRendezvous,
};
for (const [name, place] of Object.entries(schemes)) {
  const moved = keys.filter((key) => place(4, key) !== place(5, key));
  const toE = moved.every((key) => place(5, key) === "E") ? "yes" : "no";
  console.log(`${name}: ${moved.length} keys move, all to E: ${toE}`);
}

In TypeScript: The keys are ASCII, so each charCodeAt is the byte that the other languages hash. The standard library has no binary search, so byRing writes its own; reduce keeps the first of equal top scores.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"cmp"
	"fmt"
	"slices"
)

const nodes = "ABCDE"

var rings = map[int][]uint64{4: ring(4), 5: ring(5)}

func h32(text string) uint32 {
	// FNV-1a, then MurmurHash3's final mix.
	h := uint32(0x811C9DC5)
	for i := 0; i < len(text); i++ {
		h = (h ^ uint32(text[i])) * 0x01000193
	}
	h = (h ^ h>>16) * 0x85EBCA6B
	h = (h ^ h>>13) * 0xC2B2AE35
	return h ^ h>>16
}

// 100 points a node, packed as position * 8 + node number.
func ring(n int) []uint64 {
	var ring []uint64
	for k := range n * 100 {
		text := fmt.Sprintf("%c#%d", nodes[k/100], k%100)
		ring = append(ring, uint64(h32(text))*8+uint64(k/100))
	}
	slices.Sort(ring)
	return ring
}

func byRing(n int, key string) byte {
	// The first point at or after the key, wrapping round.
	ring := rings[n]
	i, _ := slices.BinarySearch(ring, uint64(h32(key))*8)
	return nodes[ring[i%len(ring)]%8]
}

func byRendezvous(n int, key string) byte {
	return slices.MaxFunc([]byte(nodes[:n]), func(a, b byte) int {
		return cmp.Compare(h32(fmt.Sprintf("%c|%s", a, key)), h32(fmt.Sprintf("%c|%s", b, key)))
	})
}

func main() {
	const keys = 2000
	byModulo := func(n int, key string) byte { return nodes[h32(key)%uint32(n)] }
	names := []string{"hash mod N", "ring", "rendezvous"}
	for s, place := range []func(int, string) byte{byModulo, byRing, byRendezvous} {
		moved, toE := 0, "yes"
		for i := range keys {
			key := fmt.Sprintf("user:%d", i)
			if now := place(5, key); place(4, key) != now {
				moved++
				if now != 'E' {
					toE = "no"
				}
			}
		}
		fmt.Printf("%s: %d keys move, all to E: %s\n", names[s], moved, toE)
	}
}

In Go: uint32 arithmetic wraps, slices.BinarySearch returns the index of the first point at or after the key, and slices.MaxFunc returns the first of equal top scores.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

let nodes = Array("ABCDE")

func h32(_ text: String) -> UInt32 {
  // FNV-1a, then MurmurHash3's final mix.
  var h: UInt32 = 0x811C_9DC5
  for byte in text.utf8 {
    h = (h ^ UInt32(byte)) &* 0x0100_0193
  }
  h = (h ^ (h >> 16)) &* 0x85EB_CA6B
  h = (h ^ (h >> 13)) &* 0xC2B2_AE35
  return h ^ (h >> 16)
}

// 100 points a node, packed as position * 8 + node number.
func ring(_ n: Int) -> [UInt64] {
  let ring = (0..<n * 100).map { k in
    UInt64(h32("\(nodes[k / 100])#\(k % 100)")) * 8 + UInt64(k / 100)
  }
  return ring.sorted()
}

let rings = [ring(4), ring(5)]

func byRing(_ n: Int, _ key: String) -> Character {
  // The first point at or after the key, wrapping round.
  let ring = rings[n - 4]
  let target = UInt64(h32(key)) * 8
  var (lo, hi) = (0, ring.count)
  while lo < hi {
    let mid = (lo + hi) / 2
    if ring[mid] < target { lo = mid + 1 } else { hi = mid }
  }
  return nodes[Int(ring[lo % ring.count] % 8)]
}

func byRendezvous(_ n: Int, _ key: String) -> Character {
  nodes[..<n].max { h32("\($0)|\(key)") < h32("\($1)|\(key)") } ?? nodes[0]
}

let keys = (0..<2_000).map { "user:\($0)" }
let schemes: [(String, (Int, String) -> Character)] = [
  ("hash mod N", { n, key in nodes[Int(h32(key) % UInt32(n))] }),
  ("ring", byRing),
  ("rendezvous", byRendezvous),
]
for (name, place) in schemes {
  let moved = keys.filter { place(4, $0) != place(5, $0) }
  let toE = moved.allSatisfy { place(5, $0) == "E" } ? "yes" : "no"
  print("\(name): \(moved.count) keys move, all to E: \(toE)")
}

In Swift: &* is the multiplication that wraps around; plain * would stop the program on overflow. The standard library has no binary search, so byRing writes one, and max(by:) keeps the first of equal scores.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

NODES = %w[A B C D E].freeze

def h32(text)
  # FNV-1a, then MurmurHash3's final mix.
  h = text.each_byte.reduce(0x811C9DC5) { |acc, byte| ((acc ^ byte) * 0x01000193) & 0xFFFFFFFF }
  h = ((h ^ (h >> 16)) * 0x85EBCA6B) & 0xFFFFFFFF
  h = ((h ^ (h >> 13)) * 0xC2B2AE35) & 0xFFFFFFFF
  h ^ (h >> 16)
end

# 100 points a node, packed as position * 8 + node number.
def ring(count)
  points = Array.new(count * 100) do |k|
    (h32("#{NODES[k / 100]}##{k % 100}") * 8) + (k / 100)
  end
  points.sort
end

RINGS = { 4 => ring(4), 5 => ring(5) }.freeze

def by_ring(count, key)
  # The first point at or after the key, wrapping round.
  ring = RINGS.fetch(count)
  target = h32(key) * 8
  NODES[ring[ring.bsearch_index { |point| point >= target } || 0] % 8]
end

def by_rendezvous(count, key)
  NODES.first(count).max_by { |node| h32("#{node}|#{key}") }
end

keys = Array.new(2_000) { |i| "user:#{i}" }
schemes = {
  'hash mod N' => ->(count, key) { NODES[h32(key) % count] },
  'ring' => method(:by_ring),
  'rendezvous' => method(:by_rendezvous)
}
schemes.each do |name, place|
  moved = keys.reject { |key| place.call(4, key) == place.call(5, key) }
  to_e = moved.all? { |key| place.call(5, key) == 'E' } ? 'yes' : 'no'
  puts "#{name}: #{moved.size} keys move, all to E: #{to_e}"
end

In Ruby: Integers never overflow, so each step masks with 0xFFFFFFFF; bsearch_index finds the first point at or after the key, and max_by keeps the first of equal highest scores.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

const val NODES = "ABCDE"

fun h32(text: String): UInt {
    // FNV-1a, then MurmurHash3's final mix.
    var h = 0x811C9DC5u
    for (byte in text.encodeToByteArray()) h = (h xor byte.toUByte().toUInt()) * 0x01000193u
    h = (h xor (h shr 16)) * 0x85EBCA6Bu
    h = (h xor (h shr 13)) * 0xC2B2AE35u
    return h xor (h shr 16)
}

// 100 points a node, packed as position * 8 + node number.
fun ring(n: Int): List<ULong> =
    List(n * 100) { k ->
        h32("${NODES[k / 100]}#${k % 100}").toULong() * 8u + (k / 100).toULong()
    }.sorted()

val rings = mapOf(4 to ring(4), 5 to ring(5))

fun byRing(
    n: Int,
    key: String,
): Char {
    // The first point at or after the key, wrapping round.
    val ring = rings.getValue(n)
    val found = ring.binarySearch(h32(key).toULong() * 8u)
    return NODES[(ring[(if (found >= 0) found else -found - 1) % ring.size] % 8u).toInt()]
}

fun byRendezvous(
    n: Int,
    key: String,
): Char = NODES.take(n).maxBy { h32("$it|$key") }

fun main() {
    val keys = (0 until 2_000).map { "user:$it" }
    val schemes: List<Pair<String, (Int, String) -> Char>> =
        listOf(
            "hash mod N" to { n, key -> NODES[(h32(key) % n.toUInt()).toInt()] },
            "ring" to ::byRing,
            "rendezvous" to ::byRendezvous,
        )
    for ((name, place) in schemes) {
        val moved = keys.filter { place(4, it) != place(5, it) }
        val toE = if (moved.all { place(5, it) == 'E' }) "yes" else "no"
        println("$name: ${moved.size} keys move, all to E: $toE")
    }
}

In Kotlin: UInt arithmetic wraps around, binarySearch searches the sorted list of ring points, and maxBy returns the first character with the largest score.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

import 'dart:convert';

const nodes = 'ABCDE';

int h32(String text) {
  // FNV-1a, then MurmurHash3's final mix.
  var h = 0x811C9DC5;
  for (final byte in utf8.encode(text)) {
    h = ((h ^ byte) * 0x01000193) & 0xFFFFFFFF;
  }
  h = ((h ^ (h >> 16)) * 0x85EBCA6B) & 0xFFFFFFFF;
  h = ((h ^ (h >> 13)) * 0xC2B2AE35) & 0xFFFFFFFF;
  return h ^ (h >> 16);
}

// 100 points a node, packed as position * 8 + node number.
List<int> ring(int n) => [
  for (var k = 0; k < n * 100; k++)
    h32('${nodes[k ~/ 100]}#${k % 100}') * 8 + k ~/ 100,
]..sort();

final rings = {4: ring(4), 5: ring(5)};

String byRing(int n, String key) {
  // The first point at or after the key, wrapping round.
  final ring = rings[n]!;
  final target = h32(key) * 8;
  var (lo, hi) = (0, ring.length);
  while (lo < hi) {
    final mid = (lo + hi) ~/ 2;
    if (ring[mid] < target) {
      lo = mid + 1;
    } else {
      hi = mid;
    }
  }
  return nodes[ring[lo % ring.length] % 8];
}

String byRendezvous(int n, String key) {
  int score(String node) => h32('$node|$key');
  return nodes
      .substring(0, n)
      .split('')
      .reduce((best, node) => score(node) > score(best) ? node : best);
}

void main() {
  final keys = [for (var i = 0; i < 2000; i++) 'user:$i'];
  final schemes = {
    'hash mod N': (int n, String key) => nodes[h32(key) % n],
    'ring': byRing,
    'rendezvous': byRendezvous,
  };
  for (final MapEntry(key: name, value: place) in schemes.entries) {
    final moved = keys.where((key) => place(4, key) != place(5, key)).toList();
    final toE = moved.every((key) => place(5, key) == 'E') ? 'yes' : 'no';
    print('$name: ${moved.length} keys move, all to E: $toE');
  }
}

In Dart: Each step masks with 0xFFFFFFFF, because Dart's int has 64 bits. dart:core has no binary search, so byRing writes one; reduce keeps the first of equal top scores.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart