diff --git a/diffs.html b/diffs.html
index 5efda6c..228a8cf 100644
--- a/diffs.html
+++ b/diffs.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html>
+<html lang="en">
     <head>
         <meta charset="UTF-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -13,44 +13,364 @@
         />
         <link
             rel="stylesheet"
-            type="text/css"
-            href="https://cdn.jsdelivr.net/npm/diff2html@3.4.48/bundles/css/diff2html.min.css"
-            integrity="sha384-iBvSlI3tNrrSIy7s6mvLg+5B2Z/QXbR4L0Pzg1nRf8zkXrz5JF316MLm2igMIpi2"
+            href="https://cdn.jsdelivr.net/npm/diff2html@3.4.56/bundles/css/diff2html.min.css"
+            integrity="sha384-PdRCG/+r1waybtXfuDB9Kmv2h7AGoN6WaTZ5OF+ctPeR9BGne0FaKRQnUeGV4nDL"
             crossorigin="anonymous"
         />
+        <style>
+            :root {
+                --bg: #f6f8fa;
+                --surface: #fff;
+                --border: #d0d7de;
+                --text: #1f2328;
+                --muted: #656d76;
+                --danger: #cf222e;
+                --radius: 8px;
+                --space: 1rem;
+                --space-sm: 0.75rem;
+                --max-width: 1200px;
+                --font: system-ui, sans-serif;
+                --mono: ui-monospace, monospace;
+                --font-size: 14px;
+                --font-size-sm: 0.875rem;
+                --font-size-code: 12px;
+            }
+
+            /* app chrome */
+            body {
+                margin: 0 auto;
+                max-width: var(--max-width);
+                padding: 1.5rem;
+                background: var(--bg);
+                color: var(--text);
+                font: var(--font-size) / 1.5 var(--font);
+            }
+
+            h1 {
+                margin: 0 0 var(--space);
+                font-size: 1.25rem;
+                font-weight: 600;
+            }
+
+            #message {
+                margin-bottom: var(--space);
+                color: var(--muted);
+            }
+
+            #message.error {
+                color: var(--danger);
+            }
+
+            #diffs {
+                display: flex;
+                flex-direction: column;
+                gap: var(--space);
+            }
+
+            /* card */
+            .repo {
+                overflow: hidden;
+                border: 1px solid var(--border);
+                border-radius: var(--radius);
+                background: var(--surface);
+            }
+
+            .repo h2 {
+                margin: 0;
+                padding: var(--space-sm) var(--space);
+                border-bottom: 1px solid var(--border);
+                background: var(--bg);
+                font-size: var(--font-size-sm);
+                font-weight: 600;
+                word-break: break-all;
+            }
+
+            /* diff2html overrides */
+            .repo .d2h-wrapper {
+                margin: 0;
+            }
+
+            .repo .d2h-file-wrapper {
+                border: 0;
+                border-radius: 0;
+                margin: 0;
+            }
+
+            .repo .d2h-file-header {
+                border-top: 1px solid var(--border);
+            }
+
+            .repo .d2h-file-wrapper:first-child .d2h-file-header {
+                border-top: 0;
+            }
+
+            .repo .d2h-code-line-ctn {
+                font-family: var(--mono);
+                font-size: var(--font-size-code);
+                word-break: break-word;
+            }
+        </style>
     </head>
     <body>
+        <h1>Git Diffs</h1>
         <div id="message">Loading diffs...</div>
         <div id="diffs"></div>
 
         <script
-            type="text/javascript"
-            src="https://cdn.jsdelivr.net/npm/diff2html@3.4.48/bundles/js/diff2html-ui.min.js"
-            integrity="sha384-99bAn+VpNpavq3FarkwuSuDPDHMeakTiNqxxz3ezwdGUr414srIXY3YmXjaAkYne"
+            src="https://cdn.jsdelivr.net/npm/diff2html@3.4.56/bundles/js/diff2html-ui.min.js"
+            integrity="sha384-NRd5i/CwvZ20mJEQt3yaDU1LeU+tu0bqyVYojXi8d7Lf1B0/TIs2K3FTvlf8aO7p"
             crossorigin="anonymous"
         ></script>
         <script>
             const message = document.getElementById("message");
             const diffs = document.getElementById("diffs");
-            let currentDiff = "";
+            const VIEWED_KEY = "diff-server-viewed";
+            const repoSections = new Map();
+
+            const viewedStore = {
+                load() {
+                    try {
+                        return JSON.parse(
+                            localStorage.getItem(VIEWED_KEY) ?? "{}",
+                        );
+                    } catch {
+                        return {};
+                    }
+                },
+                save(state) {
+                    localStorage.setItem(VIEWED_KEY, JSON.stringify(state));
+                },
+            };
+
+            async function hashText(text) {
+                const buf = await crypto.subtle.digest(
+                    "SHA-256",
+                    new TextEncoder().encode(text),
+                );
+                return Array.from(new Uint8Array(buf), (b) =>
+                    b.toString(16).padStart(2, "0"),
+                ).join("");
+            }
+
+            function parseFileDiffs(diffText) {
+                const files = new Map();
+                for (const chunk of diffText.split(/\n(?=diff --git )/)) {
+                    if (!chunk.startsWith("diff --git ")) {
+                        continue;
+                    }
+                    const match = chunk.match(
+                        /^diff --git a\/(.+?) b\/(.+)$/m,
+                    );
+                    if (!match) {
+                        continue;
+                    }
+                    files.set(match[2], chunk);
+                }
+                return files;
+            }
+
+            function fileKey(repo, path) {
+                return repo + ":" + path;
+            }
+
+            function setFileViewed(wrapper, viewed) {
+                const checkbox = wrapper.querySelector('input[name="viewed"]');
+                const collapse = wrapper.querySelector(".d2h-file-collapse");
+                const contents = wrapper.querySelector(
+                    ".d2h-file-diff, .d2h-files-diff",
+                );
+                if (!checkbox || !collapse || !contents) {
+                    return;
+                }
+                checkbox.checked = viewed;
+                collapse.classList.toggle("d2h-selected", viewed);
+                contents.classList.toggle("d2h-d-none", viewed);
+            }
+
+            async function applyViewedState(repo, container, diffText, state) {
+                const fileDiffs = parseFileDiffs(diffText);
+                const entries = [...fileDiffs.entries()];
+                const hashes = new Map(
+                    await Promise.all(
+                        entries.map(async ([path, chunk]) => [
+                            path,
+                            await hashText(chunk),
+                        ]),
+                    ),
+                );
+                const wrappers = container.querySelectorAll(".d2h-file-wrapper");
+
+                wrappers.forEach((wrapper, index) => {
+                    const path = entries[index]?.[0];
+                    if (!path) {
+                        return;
+                    }
+
+                    const hash = hashes.get(path);
+                    const key = fileKey(repo, path);
+                    const checkbox = wrapper.querySelector('input[name="viewed"]');
+                    if (!checkbox) {
+                        return;
+                    }
+
+                    checkbox.addEventListener("change", () => {
+                        if (checkbox.checked && hash) {
+                            state[key] = hash;
+                        } else {
+                            delete state[key];
+                        }
+                        viewedStore.save(state);
+                    });
+
+                    if (hash && state[key] === hash) {
+                        setFileViewed(wrapper, true);
+                    }
+                });
+            }
+
+            function pruneViewedState(state, sections) {
+                const validKeys = new Set();
+                for (const [repo, entry] of sections) {
+                    for (const path of parseFileDiffs(entry.diffText).keys()) {
+                        validKeys.add(fileKey(repo, path));
+                    }
+                }
+
+                for (const key of Object.keys(state)) {
+                    if (!validKeys.has(key)) {
+                        delete state[key];
+                    }
+                }
+            }
+
+            function removeRepoSection(repo) {
+                const entry = repoSections.get(repo);
+                if (!entry) {
+                    return;
+                }
+                entry.section.remove();
+                repoSections.delete(repo);
+            }
+
+            function renderRepoSection(repo) {
+                const section = document.createElement("section");
+                section.className = "repo";
+
+                const title = document.createElement("h2");
+                title.textContent = repo;
+                section.appendChild(title);
+
+                const container = document.createElement("div");
+                container.className = "repo-diff";
+                section.appendChild(container);
+
+                return { section, container };
+            }
 
             async function fetchAndRender() {
+                message.className = "";
+                message.textContent = "Loading diffs...";
+
                 try {
-                    const response = await fetch("/diffs", {
-                        headers: { Accept: "text/x-diff" },
-                    });
-                    const data = await response.text();
+                    const reposResponse = await fetch("/repos");
+                    if (!reposResponse.ok) {
+                        throw new Error("Failed to list repositories");
+                    }
+
+                    const repos = await reposResponse.json();
+                    const viewedState = viewedStore.load();
+                    const activeRepos = new Set(repos);
 
-                    if (data !== currentDiff) {
-                        currentDiff = data;
-                        await new Diff2HtmlUI(diffs, currentDiff).draw();
-                        message.innerHTML = "";
+                    for (const repo of repoSections.keys()) {
+                        if (!activeRepos.has(repo)) {
+                            removeRepoSection(repo);
+                        }
                     }
+
+                    if (repos.length === 0) {
+                        diffs.innerHTML = "";
+                        repoSections.clear();
+                        pruneViewedState(viewedState, repoSections);
+                        viewedStore.save(viewedState);
+                        message.textContent = "No git repositories found.";
+                        return;
+                    }
+
+                    let completed = 0;
+                    let changedRepos = 0;
+
+                    await Promise.all(
+                        repos.map(async (repo) => {
+                            try {
+                                const response = await fetch(
+                                    "/diff?repo=" + encodeURIComponent(repo),
+                                    { headers: { Accept: "text/x-diff" } },
+                                );
+
+                                if (!response.ok) {
+                                    return;
+                                }
+
+                                const data = await response.text();
+
+                                if (!data.trim()) {
+                                    removeRepoSection(repo);
+                                    return;
+                                }
+
+                                changedRepos++;
+
+                                const existing = repoSections.get(repo);
+                                if (existing && existing.diffText === data) {
+                                    return;
+                                }
+
+                                removeRepoSection(repo);
+
+                                const { section, container } =
+                                    renderRepoSection(repo);
+                                diffs.appendChild(section);
+
+                                new Diff2HtmlUI(container, data).draw();
+                                await applyViewedState(
+                                    repo,
+                                    container,
+                                    data,
+                                    viewedState,
+                                );
+                                repoSections.set(repo, {
+                                    diffText: data,
+                                    section,
+                                });
+                            } catch {
+                                return;
+                            } finally {
+                                completed++;
+                                message.textContent =
+                                    "Loading diffs... (" +
+                                    completed +
+                                    "/" +
+                                    repos.length +
+                                    ")";
+                            }
+                        }),
+                    );
+
+                    pruneViewedState(viewedState, repoSections);
+                    viewedStore.save(viewedState);
+
+                    if (changedRepos === 0) {
+                        diffs.innerHTML = "";
+                        repoSections.clear();
+                        message.textContent = "No uncommitted changes.";
+                        return;
+                    }
+
+                    message.textContent = "";
                 } catch (error) {
-                    message.innerHTML =
-                        "<div>Error fetching diffs: " +
-                        error.message +
-                        "</div>";
+                    message.className = "error";
+                    message.textContent =
+                        "Error fetching diffs: " + error.message;
                 }
             }
 
diff --git a/exec.go b/exec.go
new file mode 100644
index 0000000..d890504
--- /dev/null
+++ b/exec.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+	"context"
+	"io"
+	"log"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+const commandTimeout = 30 * time.Second
+
+func runCommand(ctx context.Context, dir string, stdout, stderr io.Writer, name string, args ...string) error {
+	ctx, cancel := context.WithTimeout(ctx, commandTimeout)
+	defer cancel()
+
+	cmdLine := name
+	if len(args) > 0 {
+		cmdLine += " " + strings.Join(args, " ")
+	}
+	if name == "bash" && len(args) >= 2 && args[0] == "-c" {
+		cmdLine = "bash -c <script>"
+	}
+	log.Printf("executing: %s (dir=%s)", cmdLine, dir)
+
+	start := time.Now()
+
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Dir = dir
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+
+	err := cmd.Run()
+	duration := time.Since(start).Round(time.Millisecond)
+	if err != nil {
+		log.Printf("command finished after %s with error (dir=%s): %v", duration, dir, err)
+		return err
+	}
+
+	log.Printf("command finished in %s (dir=%s)", duration, dir)
+	return nil
+}
+
+func gitDiffScript() string {
+	return `
+REPO_NAME="$1"
+DEFAULT_BRANCH=""
+if git rev-parse --verify main >/dev/null 2>&1; then
+  DEFAULT_BRANCH="main"
+elif git rev-parse --verify master >/dev/null 2>&1; then
+  DEFAULT_BRANCH="master"
+fi
+
+CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
+
+if [ -n "$DEFAULT_BRANCH" ] && [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" != "$DEFAULT_BRANCH" ]; then
+  git diff --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" ${DEFAULT_BRANCH}...HEAD
+else
+  git diff --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" HEAD
+fi
+
+git ls-files --others --exclude-standard | while IFS= read -r file; do
+  if [ -n "$file" ]; then
+    git diff --no-index --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" /dev/null "$file" 2>/dev/null || true
+  fi
+done
+`
+}
diff --git a/handlers.go b/handlers.go
index 6ee3a0d..bdbcbb7 100644
--- a/handlers.go
+++ b/handlers.go
@@ -2,26 +2,31 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	_ "embed"
+	"io"
 	"log"
 	"net/http"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"strings"
-	"time"
 )
 
 //go:embed diffs.html
 var diffsHTML []byte
 
 func diffsHandler(w http.ResponseWriter, r *http.Request) {
-	accept := r.Header.Get("Accept")
-
-	if strings.Contains(accept, "text/x-diff") {
-		serveDiffsText(w, r)
-	} else {
-		serveDiffsHTML(w, r)
+	switch r.URL.Path {
+	case "/repos":
+		serveRepos(w, r)
+	case "/diff":
+		serveRepoDiff(w, r)
+	case "/":
+		if strings.Contains(r.Header.Get("Accept"), "text/x-diff") {
+			serveDiffsText(w, r)
+		} else {
+			serveDiffsHTML(w, r)
+		}
+	default:
+		http.NotFound(w, r)
 	}
 }
 
@@ -32,30 +37,50 @@ func serveDiffsHTML(w http.ResponseWriter, _ *http.Request) {
 	}
 }
 
-func findGitRepos(root string) ([]string, error) {
-	var repos []string
+func serveRepos(w http.ResponseWriter, r *http.Request) {
+	repos, err := findGitRepos(".")
+	if err != nil {
+		http.Error(w, "Failed to find git repositories: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 
-	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
+	names := make([]string, 0, len(repos))
+	for _, repoPath := range repos {
+		names = append(names, repoDisplayName(repoPath))
+	}
 
-		if info.IsDir() && info.Name() == ".git" {
-			repoPath := filepath.Dir(path)
-			repos = append(repos, repoPath)
-			return filepath.SkipDir
-		}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	if err := json.NewEncoder(w).Encode(names); err != nil {
+		log.Printf("Failed to encode repos response: %v", err)
+	}
+}
 
-		return nil
-	})
+func serveRepoDiff(w http.ResponseWriter, r *http.Request) {
+	repoName := r.URL.Query().Get("repo")
+	if repoName == "" {
+		http.Error(w, "missing repo query parameter", http.StatusBadRequest)
+		return
+	}
 
-	return repos, err
+	repoPath, err := resolveRepoPath(repoName)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/x-diff; charset=utf-8")
+	writer := &maxSizeWriter{Writer: w, maxSize: 5 * 1024 * 1024}
+	if err := writeRepoDiff(r.Context(), writer, repoPath); err != nil {
+		log.Printf("Failed to write diff for %s: %v", repoPath, err)
+	}
 }
 
-func serveDiffsText(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
-	defer cancel()
+func writeRepoDiff(ctx context.Context, w io.Writer, repoPath string) error {
+	repoName := repoDisplayName(repoPath)
+	return runCommand(ctx, repoPath, w, io.Discard, "bash", "-c", gitDiffScript(), "bash", repoName)
+}
 
+func serveDiffsText(w http.ResponseWriter, r *http.Request) {
 	writer := &maxSizeWriter{Writer: w, maxSize: 5 * 1024 * 1024}
 
 	repos, err := findGitRepos(".")
@@ -67,53 +92,8 @@ func serveDiffsText(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "text/x-diff; charset=utf-8")
 
 	for _, repoPath := range repos {
-		relPath, err := filepath.Rel(".", repoPath)
-		if err != nil {
-			log.Printf("Failed to get relative path for %s: %v", repoPath, err)
-			relPath = repoPath
-		}
-		if relPath == "." {
-			relPath = ""
-		}
-
-		repoName := relPath
-		if repoName == "" {
-			repoName = filepath.Base(repoPath)
-		}
-
-		cmd := exec.CommandContext(ctx, "bash", "-c", `
-# Determine the default branch (main or master)
-DEFAULT_BRANCH=""
-if git rev-parse --verify main >/dev/null 2>&1; then
-  DEFAULT_BRANCH="main"
-elif git rev-parse --verify master >/dev/null 2>&1; then
-  DEFAULT_BRANCH="master"
-fi
-
-# Get current branch
-CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
-
-# Determine what to diff against
-if [ -n "$DEFAULT_BRANCH" ] && [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" != "$DEFAULT_BRANCH" ]; then
-  # On a feature branch: show all changes from branch point
-  git diff --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ ${DEFAULT_BRANCH}...HEAD
-else
-  # On default branch or detached HEAD: show only uncommitted changes
-  git diff --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ HEAD
-fi
-
-# Always show untracked files
-git ls-files --others --exclude-standard | while IFS= read -r file; do
-  if [ -n "$file" ]; then
-    git diff --no-index --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ /dev/null "$file" 2>/dev/null || true
-  fi
-done
-		`)
-		cmd.Dir = repoPath
-		cmd.Stdout = writer
-		cmd.Stderr = writer
-		if err := cmd.Run(); err != nil {
-			log.Printf("Git command failed for %s: %v", repoPath, err)
+		if err := writeRepoDiff(r.Context(), writer, repoPath); err != nil {
+			continue
 		}
 	}
 }
diff --git a/repos.go b/repos.go
new file mode 100644
index 0000000..d684600
--- /dev/null
+++ b/repos.go
@@ -0,0 +1,94 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const maxRepoDepth = 2
+
+func pathDepth(rel string) int {
+	rel = filepath.ToSlash(rel)
+	if rel == "." {
+		return 0
+	}
+	return strings.Count(rel, "/") + 1
+}
+
+func findGitRepos(root string) ([]string, error) {
+	var repos []string
+	root = filepath.Clean(root)
+
+	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		rel, err := filepath.Rel(root, path)
+		if err != nil {
+			return nil
+		}
+
+		if info.IsDir() && info.Name() == ".git" {
+			repoPath := filepath.Dir(path)
+			repoRel, err := filepath.Rel(root, repoPath)
+			if err != nil {
+				return nil
+			}
+			if pathDepth(repoRel) <= maxRepoDepth {
+				repos = append(repos, repoPath)
+			}
+			return filepath.SkipDir
+		}
+
+		if info.IsDir() && pathDepth(rel) > maxRepoDepth {
+			return filepath.SkipDir
+		}
+
+		return nil
+	})
+
+	return repos, err
+}
+
+func repoDisplayName(repoPath string) string {
+	relPath, err := filepath.Rel(".", repoPath)
+	if err != nil || relPath == "." {
+		return filepath.Base(repoPath)
+	}
+	return relPath
+}
+
+func resolveRepoPath(name string) (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+
+	if name == filepath.Base(cwd) {
+		if _, err := os.Stat(filepath.Join(".", ".git")); err == nil {
+			return ".", nil
+		}
+	}
+
+	candidate := filepath.Clean(name)
+	if candidate == ".." || strings.HasPrefix(candidate, "../") {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if _, err := os.Stat(filepath.Join(candidate, ".git")); err != nil {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if pathDepth(candidate) > maxRepoDepth {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if repoDisplayName(candidate) != name {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	return candidate, nil
+}
