diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..239097c
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: yarn
+
+      - name: Enable Corepack
+        run: corepack enable
+
+      - name: Install dependencies
+        run: yarn install --immutable
+
+      - name: Test
+        run: yarn test:ci
+
+      - name: Lint
+        run: yarn lint
+
+      - name: Build
+        run: yarn build
diff --git a/pages/new.tsx b/pages/new.tsx
index 43a6d79..d4eef2f 100644
--- a/pages/new.tsx
+++ b/pages/new.tsx
@@ -11,6 +11,7 @@ import { useRouter } from "next/router";
 import { Fragment, useEffect, useRef, useState } from "react";
 import { AddUser, Delete, People, User, Document } from "react-iconly";
 import { Court } from "../src/Court";
+import { PairLinkIcon } from "../src/PlayerBadge";
 import {
   newGame,
   useShufflerDispatch,
@@ -19,6 +20,49 @@ import {
 } from "../src/useShuffler";
 import { ResetPlayersModal } from "../src/ResetPlayersModal";
 
+type NamePair = [string, string];
+
+function getPartner(name: string, pairs: NamePair[]): string | null {
+  for (const [a, b] of pairs) {
+    if (a === name) return b;
+    if (b === name) return a;
+  }
+  return null;
+}
+
+function isPaired(name: string, pairs: NamePair[]): boolean {
+  return getPartner(name, pairs) !== null;
+}
+
+function removePairForPlayer(pairs: NamePair[], name: string): NamePair[] {
+  return pairs.filter(([a, b]) => a !== name && b !== name);
+}
+
+function addPair(pairs: NamePair[], a: string, b: string): NamePair[] {
+  const sorted: NamePair = a.localeCompare(b) <= 0 ? [a, b] : [b, a];
+  return [
+    ...removePairForPlayer(pairs, a),
+    ...removePairForPlayer(pairs, b),
+    sorted,
+  ];
+}
+
+function renameInPairs(
+  pairs: NamePair[],
+  oldName: string,
+  newName: string
+): NamePair[] {
+  return pairs.map(([a, b]) => {
+    const next: NamePair = [
+      a === oldName ? newName : a,
+      b === oldName ? newName : b,
+    ];
+    return next[0].localeCompare(next[1]) <= 0
+      ? next
+      : [next[1], next[0]];
+  });
+}
+
 function NewGame() {
   const router = useRouter();
   const state = useShufflerState();
@@ -36,6 +80,8 @@ function NewGame() {
   const [courts, setCourts] = useState(state.courts.toString());
   const [customizeCourtNames, setCustomizeCourtNames] = useState(false);
   const [courtNames, setCourtNames] = useState<string[]>([]);
+  const [fixedPairs, setFixedPairs] = useState<NamePair[]>([]);
+  const [linkingPlayer, setLinkingPlayer] = useState<string | null>(null);
 
   const handleAddPlayers = () => {
     if (!playerInput) return;
@@ -64,7 +110,19 @@ function NewGame() {
       setCustomizeCourtNames(true);
       setCourtNames(state.courtNames);
     }
-  }, [state.players, state.courts, state.courtNames]);
+
+    if (state.fixedPairs?.length) {
+      const namePairs = state.fixedPairs
+        .map(([a, b]) => {
+          const nameA = playersById[a]?.name;
+          const nameB = playersById[b]?.name;
+          if (nameA && nameB) return [nameA, nameB] as NamePair;
+          return null;
+        })
+        .filter((pair): pair is NamePair => pair !== null);
+      setFixedPairs(namePairs);
+    }
+  }, [state.players, state.courts, state.courtNames, state.fixedPairs, playersById]);
 
   const handleNewGame = async () => {
     const names = players;
@@ -89,6 +147,7 @@ function NewGame() {
       names,
       courts: courtCount,
       courtNames: customizeCourtNames ? courtNames : [],
+      fixedPairs,
     });
     router.push("/rounds");
   };
@@ -97,6 +156,33 @@ function NewGame() {
     setModal("reset-players");
   };
 
+  const handleLinkClick = (name: string) => {
+    if (isPaired(name, fixedPairs)) return;
+
+    if (linkingPlayer === null) {
+      setLinkingPlayer(name);
+      return;
+    }
+
+    if (linkingPlayer === name) {
+      setLinkingPlayer(null);
+      return;
+    }
+
+    if (isPaired(linkingPlayer, fixedPairs)) {
+      setLinkingPlayer(name);
+      return;
+    }
+
+    setFixedPairs(addPair(fixedPairs, linkingPlayer, name));
+    setLinkingPlayer(null);
+  };
+
+  const handleUnlink = (name: string) => {
+    setFixedPairs(removePairForPlayer(fixedPairs, name));
+    if (linkingPlayer === name) setLinkingPlayer(null);
+  };
+
   const playerError = formStatus === "validating" && players.length < 4;
   const courtsError =
     formStatus === "validating" &&
@@ -120,6 +206,8 @@ function NewGame() {
           onClose={() => setModal("none")}
           onSubmit={() => {
             setPlayers([]);
+            setFixedPairs([]);
+            setLinkingPlayer(null);
             setModal("none");
           }}
         />
@@ -179,48 +267,114 @@ function NewGame() {
                 </Button>
               </div>
               <Spacer y={2} />
-              {players.map((name, index) => (
-                <Fragment key={index}>
-                  <div className="flex items-center gap-1">
-                    <User primaryColor="#888" size="medium" />
-                    <span className="text-sm text-gray-500 w-4">
-                      {index + 1}
-                    </span>
-                    <Input
-                      className="flex-1"
-                      aria-label="Player"
-                      value={name}
-                      size="sm"
-                      type="text"
-                      variant="underlined"
-                      onChange={(e) => {
-                        const newName = e.currentTarget.value;
-                        setPlayers([
-                          ...players.slice(0, index),
-                          newName,
-                          ...players.slice(index + 1),
-                        ]);
-                      }}
-                      fullWidth
-                    />
-                    <Button
-                      variant="flat"
-                      color="default"
-                      aria-label={`Remove player named ${name}`}
-                      isIconOnly
-                      onPress={() => {
-                        // Delete this player
-                        setPlayers((players) => [
-                          ...players.slice(0, index),
-                          ...players.slice(index + 1),
-                        ]);
-                      }}
+              {players.map((name, index) => {
+                const partner = getPartner(name, fixedPairs);
+                const paired = partner !== null;
+                const linking = linkingPlayer === name;
+                return (
+                  <Fragment key={index}>
+                    <div
+                      className={`flex items-center gap-1 rounded-lg px-1 ${
+                        linking
+                          ? "ring-2 ring-primary bg-primary-50"
+                          : paired
+                          ? "bg-secondary-50"
+                          : ""
+                      }`}
                     >
-                      <Delete />
-                    </Button>
-                  </div>
-                </Fragment>
-              ))}
+                      <User
+                        primaryColor={paired ? "#7828c8" : "#888"}
+                        size="medium"
+                      />
+                      <span className="text-sm text-gray-500 w-4">
+                        {index + 1}
+                      </span>
+                      <Input
+                        className="flex-1"
+                        aria-label="Player"
+                        value={name}
+                        size="sm"
+                        type="text"
+                        variant="underlined"
+                        onChange={(e) => {
+                          const newName = e.currentTarget.value;
+                          setFixedPairs(
+                            renameInPairs(fixedPairs, name, newName)
+                          );
+                          if (linkingPlayer === name) setLinkingPlayer(newName);
+                          setPlayers([
+                            ...players.slice(0, index),
+                            newName,
+                            ...players.slice(index + 1),
+                          ]);
+                        }}
+                        fullWidth
+                      />
+                      {paired ? (
+                        <>
+                          <span
+                            className="text-xs text-secondary whitespace-nowrap"
+                            title={`Paired with ${partner}`}
+                          >
+                            ↔ {partner}
+                          </span>
+                          <Button
+                            variant="flat"
+                            color="secondary"
+                            aria-label={`Unlink ${name} from ${partner}`}
+                            isIconOnly
+                            onPress={() => handleUnlink(name)}
+                          >
+                            <Delete primaryColor="#7828c8" size="small" />
+                          </Button>
+                        </>
+                      ) : (
+                        <Button
+                          variant={linking ? "solid" : "flat"}
+                          color={linking ? "primary" : "default"}
+                          aria-label={
+                            linkingPlayer && linkingPlayer !== name
+                              ? `Pair ${linkingPlayer} with ${name}`
+                              : `Link ${name} as a fixed pair`
+                          }
+                          isIconOnly
+                          onPress={() => handleLinkClick(name)}
+                        >
+                          <PairLinkIcon
+                            color={linking ? "#fff" : "#888"}
+                            size={16}
+                          />
+                        </Button>
+                      )}
+                      <Button
+                        variant="flat"
+                        color="default"
+                        aria-label={`Remove player named ${name}`}
+                        isIconOnly
+                        onPress={() => {
+                          setFixedPairs(removePairForPlayer(fixedPairs, name));
+                          if (linkingPlayer === name) setLinkingPlayer(null);
+                          setPlayers((players) => [
+                            ...players.slice(0, index),
+                            ...players.slice(index + 1),
+                          ]);
+                        }}
+                      >
+                        <Delete />
+                      </Button>
+                    </div>
+                  </Fragment>
+                );
+              })}
+              {linkingPlayer && !isPaired(linkingPlayer, fixedPairs) && (
+                <>
+                  <Spacer y={1} />
+                  <p className="text-sm text-primary">
+                    Tap another player to pair with {linkingPlayer}, or tap{" "}
+                    {linkingPlayer}&apos;s link button again to cancel.
+                  </p>
+                </>
+              )}
             </div>
             <Spacer y={3} />
             <label>
diff --git a/pages/rounds.tsx b/pages/rounds.tsx
index 4931b3e..a39f7f9 100644
--- a/pages/rounds.tsx
+++ b/pages/rounds.tsx
@@ -159,7 +159,11 @@ export default function Rounds() {
                     <Spacer y={0.5} />
                     <BadgeGroup>
                       {sitOuts.map((playerId) => (
-                        <PlayerBadge key={playerId} color="default">
+                        <PlayerBadge
+                          key={playerId}
+                          color="default"
+                          playerId={playerId}
+                        >
                           {playerName(playerId)}
                           {volunteers.includes(playerId) ? (
                             <span className="text-neutral-500 font-semibold text-medium">
diff --git a/src/PlayerBadge.tsx b/src/PlayerBadge.tsx
index 5b4cb56..70c545e 100644
--- a/src/PlayerBadge.tsx
+++ b/src/PlayerBadge.tsx
@@ -1,17 +1,68 @@
 import React from "react";
 import clsx from "clsx";
+import { PlayerId } from "./matching/heuristics";
+import { getPartnerName, useFixedPairs } from "./fixedPairs";
+import { useShufflerState } from "./useShuffler";
+
+export function PairLinkIcon({
+  partnerName,
+  className,
+  color = "currentColor",
+  size = 16,
+}: {
+  partnerName?: string;
+  className?: string;
+  color?: string;
+  size?: number;
+}) {
+  const icon = (
+    <svg
+      width={size}
+      height={size}
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke={color}
+      strokeWidth="2"
+      aria-hidden
+    >
+      <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71" />
+      <path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71" />
+    </svg>
+  );
+
+  if (!partnerName) return icon;
+
+  return (
+    <span
+      className={clsx("inline-flex items-center", className)}
+      aria-label={`Fixed pair with ${partnerName}`}
+      title={`Fixed pair with ${partnerName}`}
+    >
+      {icon}
+    </span>
+  );
+}
 
 export function PlayerBadge({
   color,
   children,
+  playerId,
 }: {
   children: React.ReactNode;
   color: "primary" | "secondary" | "default";
+  playerId?: PlayerId;
 }) {
+  const fixedPairs = useFixedPairs();
+  const state = useShufflerState();
+  const partnerName =
+    playerId && fixedPairs.length
+      ? getPartnerName(playerId, fixedPairs, state.playersById)
+      : undefined;
+
   return (
     <p
       className={clsx(
-        "border-2 font-semibold text-lg sm:text-medium",
+        "border-2 font-semibold text-lg sm:text-medium inline-flex items-center gap-1",
         `text-${color} border-${color} rounded-lg px-2 py-1`,
         {
           "bg-slate-100": color === "default",
@@ -20,6 +71,9 @@ export function PlayerBadge({
         }
       )}
     >
+      {partnerName ? (
+        <PairLinkIcon partnerName={partnerName} className="opacity-80" />
+      ) : null}
       {children}
     </p>
   );
diff --git a/src/TeamBadges.tsx b/src/TeamBadges.tsx
index 66693ad..77ad517 100644
--- a/src/TeamBadges.tsx
+++ b/src/TeamBadges.tsx
@@ -1,5 +1,12 @@
+import clsx from "clsx";
 import { BadgeGroup } from "./BadgeGroup";
-import { PlayerBadge } from "./PlayerBadge";
+import { PairLinkIcon, PlayerBadge } from "./PlayerBadge";
+import {
+  areFixedPartners,
+  getPlayerIdByName,
+  useFixedPairs,
+} from "./fixedPairs";
+import { useShufflerState } from "./useShuffler";
 
 export default function TeamBadges({
   team,
@@ -9,12 +16,46 @@ export default function TeamBadges({
   isHome?: boolean;
 }) {
   const [player1, player2] = team;
+  const fixedPairs = useFixedPairs();
+  const { playersById } = useShufflerState();
+  const color = isHome ? "primary" : "secondary";
+
+  const player1Id = getPlayerIdByName(player1, playersById);
+  const player2Id = getPlayerIdByName(player2, playersById);
+  const isFixedPairTeam =
+    player1Id &&
+    player2Id &&
+    fixedPairs.length > 0 &&
+    areFixedPartners(player1Id, player2Id, fixedPairs);
+
+  if (isFixedPairTeam) {
+    return (
+      <div
+        className={clsx(
+          "inline-flex items-center gap-1 rounded-xl border-2 border-dashed px-1 py-0.5",
+          isHome ? "border-primary/60" : "border-secondary/60"
+        )}
+        aria-label={`Fixed pair: ${player1} and ${player2}`}
+      >
+        <PlayerBadge color={color} playerId={player1Id}>
+          {player1}
+        </PlayerBadge>
+        <span className="opacity-70" aria-hidden>
+          <PairLinkIcon />
+        </span>
+        <PlayerBadge color={color} playerId={player2Id}>
+          {player2}
+        </PlayerBadge>
+      </div>
+    );
+  }
+
   return (
     <BadgeGroup>
-      <PlayerBadge color={isHome ? "primary" : "secondary"}>
+      <PlayerBadge color={color} playerId={player1Id}>
         {player1}
       </PlayerBadge>
-      <PlayerBadge color={isHome ? "primary" : "secondary"}>
+      <PlayerBadge color={color} playerId={player2Id}>
         {player2}
       </PlayerBadge>
     </BadgeGroup>
diff --git a/src/fixedPairs.ts b/src/fixedPairs.ts
new file mode 100644
index 0000000..e8eff01
--- /dev/null
+++ b/src/fixedPairs.ts
@@ -0,0 +1,55 @@
+import { PlayerId, Team } from "./matching/heuristics";
+import { useShufflerState } from "./useShuffler";
+
+type StateWithFixedPairs = {
+  fixedPairs?: Team[];
+  playersById?: Record<PlayerId, { name: string; id: PlayerId }>;
+};
+
+export function useFixedPairs(): Team[] {
+  const state = useShufflerState() as StateWithFixedPairs;
+  const fixedPairs = state.fixedPairs;
+  return Array.isArray(fixedPairs) ? fixedPairs : [];
+}
+
+export function getFixedPairPartnerMap(
+  fixedPairs: Team[]
+): Map<PlayerId, PlayerId> {
+  const partnerMap = new Map<PlayerId, PlayerId>();
+  for (const [a, b] of fixedPairs) {
+    partnerMap.set(a, b);
+    partnerMap.set(b, a);
+  }
+  return partnerMap;
+}
+
+export function getPartnerId(
+  playerId: PlayerId,
+  fixedPairs: Team[]
+): PlayerId | undefined {
+  return getFixedPairPartnerMap(fixedPairs).get(playerId);
+}
+
+export function getPartnerName(
+  playerId: PlayerId,
+  fixedPairs: Team[],
+  playersById: Record<PlayerId, { name: string }>
+): string | undefined {
+  const partnerId = getPartnerId(playerId, fixedPairs);
+  return partnerId ? playersById[partnerId]?.name : undefined;
+}
+
+export function areFixedPartners(
+  playerA: PlayerId,
+  playerB: PlayerId,
+  fixedPairs: Team[]
+): boolean {
+  return getPartnerId(playerA, fixedPairs) === playerB;
+}
+
+export function getPlayerIdByName(
+  name: string,
+  playersById: Record<PlayerId, { name: string; id: PlayerId }>
+): PlayerId | undefined {
+  return Object.values(playersById).find((player) => player.name === name)?.id;
+}
diff --git a/src/useShuffler.tsx b/src/useShuffler.tsx
index 0b27417..b1abfd1 100644
--- a/src/useShuffler.tsx
+++ b/src/useShuffler.tsx
@@ -13,7 +13,7 @@ type NewGameOptions = {
   names: string[];
   courts: number;
   courtNames: string[];
-  fixedPairs?: Team[];
+  fixedPairs?: [string, string][];
 };
 
 type EditCourts = {
@@ -160,6 +160,7 @@ function cacheState(state: State): State {
       players,
       courts,
       courtNames,
+      fixedPairs,
       rounds,
       volunteerSitoutsByRound,
       playersById,
@@ -171,6 +172,7 @@ function cacheState(state: State): State {
         players,
         courts,
         courtNames,
+        fixedPairs,
         rounds,
         volunteerSitoutsByRound,
         playersById,
@@ -277,12 +279,16 @@ async function newGame(
 ) {
   if (!worker) return;
   if (state.generating) return;
-  const { courts, names, courtNames, fixedPairs = [] } = payload;
+  const { courts, names, courtNames, fixedPairs: namePairs = [] } = payload;
   const players = createPlayers(names).sort((a, b) =>
     a.name.localeCompare(b.name)
   );
   const playerIds = players.map(({ id }) => id);
   const playersById = getPlayersById({}, players);
+  const nameToId = Object.fromEntries(players.map((p) => [p.name, p.id]));
+  const fixedPairs: Team[] = namePairs
+    .map(([a, b]) => [nameToId[a], nameToId[b]] as Team)
+    .filter(([a, b]) => a && b);
   dispatch({
     type: "new-game-start",
     payload: {
diff --git a/test/heuristics.spec.tsx b/test/heuristics.spec.tsx
index 3d710bc..20ea0e2 100644
--- a/test/heuristics.spec.tsx
+++ b/test/heuristics.spec.tsx
@@ -16,6 +16,14 @@ const getStats = (numbers: number[]) => ({
   max: max(numbers),
 });
 
+const mockSeededRandom = (seed: number) => {
+  let state = seed;
+  return jest.spyOn(Math, "random").mockImplementation(() => {
+    state = (state * 16807) % 2147483647;
+    return (state - 1) / 2147483646;
+  });
+};
+
 const roundsToString = (rounds: Round[]) =>
   rounds
     .map(
@@ -198,47 +206,59 @@ describe("calculateHeuristics()", () => {
   });
 
   test("5 players, 5 games", async () => {
-    const players = sampleNames.slice(0, 5);
-    const rounds: Round[] = [];
-    for (let player in players) {
-      rounds.push(await getNextBestRound(rounds, players, 1));
-    }
-    const uniqueTeams = new Set();
-    const uniqueSits = new Set();
-    rounds.forEach(({ matches, sitOuts }) => {
-      matches.forEach((match) =>
-        match.forEach((team) => uniqueTeams.add(team.toString()))
-      );
-      sitOuts.forEach((sit) => uniqueSits.add(sit));
-    });
-    expect(uniqueSits.size).toEqual(5);
-    expect(uniqueTeams.size).toEqual(10);
-  });
-
-  test("5 players, 15 games", async () => {
-    const results = [];
-    for (let generations = 0; generations < 50; generations++) {
+    const randomSpy = mockSeededRandom(42);
+    try {
       const players = sampleNames.slice(0, 5);
       const rounds: Round[] = [];
-      for (let i = 0; i < 15; i++) {
+      for (let player in players) {
         rounds.push(await getNextBestRound(rounds, players, 1));
       }
-      const uniqueMatches = new Set();
-      rounds.forEach(({ matches }) => {
-        matches.forEach((match) => {
-          const sortedTeams = match.map((team) => team.sort().join(" "));
-          const teamString = sortedTeams.sort().join(" vs ");
-          uniqueMatches.add(teamString);
-        });
+      const uniqueTeams = new Set();
+      const uniqueSits = new Set();
+      rounds.forEach(({ matches, sitOuts }) => {
+        matches.forEach((match) =>
+          match.forEach((team) => uniqueTeams.add(team.toString()))
+        );
+        sitOuts.forEach((sit) => uniqueSits.add(sit));
       });
-      results.push(uniqueMatches.size);
+      expect(uniqueSits.size).toEqual(5);
+      expect(uniqueTeams.size).toEqual(10);
+    } finally {
+      randomSpy.mockRestore();
     }
+  });
+
+  test("5 players, 15 games", async () => {
+    const randomSpy = mockSeededRandom(42);
+    try {
+      const results = [];
+      for (let generations = 0; generations < 50; generations++) {
+        const players = sampleNames.slice(0, 5);
+        const rounds: Round[] = [];
+        for (let i = 0; i < 15; i++) {
+          rounds.push(await getNextBestRound(rounds, players, 1));
+        }
+        const uniqueMatches = new Set();
+        rounds.forEach(({ matches }) => {
+          matches.forEach((match) => {
+            const sortedTeams = match.map((team) =>
+              [...team].sort().join(" ")
+            );
+            const teamString = sortedTeams.sort().join(" vs ");
+            uniqueMatches.add(teamString);
+          });
+        });
+        results.push(uniqueMatches.size);
+      }
 
-    const stats = getStats(results);
-    // Probabilistic scheduling: best run hits all 15 unique matchups; assert strong diversity.
-    expect(stats.max).toBe(15);
-    expect(stats.min).toBeGreaterThanOrEqual(9);
-    expect(stats.mean).toBeGreaterThanOrEqual(12);
+      const stats = getStats(results);
+      // Probabilistic scheduling: best run hits all 15 unique matchups; assert strong diversity.
+      expect(stats.max).toBe(15);
+      expect(stats.min).toBeGreaterThanOrEqual(9);
+      expect(stats.mean).toBeGreaterThanOrEqual(12);
+    } finally {
+      randomSpy.mockRestore();
+    }
   });
 
   test("volunteer 1/2 sit outs", async () => {