diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 2b98da2..52cd944 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -3443,7 +3443,7 @@ checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
 [[package]]
 name = "linux-terminal-launch"
 version = "0.1.0"
-source = "git+https://github.com/cst8t/linux-terminal-launch#1c2db9bb27d735fece63448cd3c0781e20a92437"
+source = "git+https://github.com/cst8t/linux-terminal-launch#d256bca7868c22a909ac2290f1bbce2e12db5b8c"
 
 [[package]]
 name = "litemap"
diff --git a/src-tauri/config.example.toml b/src-tauri/config.example.toml
index 3b9d053..afe2b9a 100644
--- a/src-tauri/config.example.toml
+++ b/src-tauri/config.example.toml
@@ -82,6 +82,14 @@ updateEndpoint = "https://github.com/cst8t/gitmun/releases/latest/download/lates
 # "Native" applies no overrides; uses full hardware acceleration.
 linuxGraphicsMode = "Auto"
 
+# Terminal emulator for Linux repository opens.
+# Use "auto", "custom", or a known terminal ID such as "ghostty" or "gnome-terminal".
+linuxTerminalEmulator = "auto"
+
+# Custom Linux terminal command. Used only when linuxTerminalEmulator is "custom".
+# Use {path} where the repository path should be inserted.
+linuxTerminalCustomCommand = ""
+
 # Behaviour when opening a repository.
 # "Ask" prompts for which window to use.
 # "ExistingWindow" opens the repository in the current window.
diff --git a/src-tauri/src/commands/repo.rs b/src-tauri/src/commands/repo.rs
index e7469f6..b8c84d9 100644
--- a/src-tauri/src/commands/repo.rs
+++ b/src-tauri/src/commands/repo.rs
@@ -1,15 +1,14 @@
-#[cfg(target_os = "linux")]
-use crate::git::types::LinuxTerminalEmulator;
 use crate::git::types::{
     CloneRequest, CommitDetails, CommitDetailsRequest, CommitFileItem, CommitFilesRequest,
     CommitMarkers, CommitMessageRecovery, CommitRequest, DiffRequest, ExportCommitPatchRequest,
-    ExportPatchRequest,
-    ExternalDiffRequest, FetchRequest, FileDiff, FileRequest, GitIdentity, HunkStageRequest,
-    IdentityRequest, ImportPatchRequest, NumstatRequest, NumstatResult, OperationResult,
-    PullAnalysis, PullStrategyRequest, PushRequest, PushResult, RepoRequest, RepoStatus,
-    SetIdentityRequest, SshAllowedSignerStatus, StageFilesRequest, StashEntry, StashPushRequest,
-    StashRequest, SubmoduleActionRequest,
+    ExportPatchRequest, ExternalDiffRequest, FetchRequest, FileDiff, FileRequest, GitIdentity,
+    HunkStageRequest, IdentityRequest, ImportPatchRequest, NumstatRequest, NumstatResult,
+    OperationResult, PullAnalysis, PullStrategyRequest, PushRequest, PushResult, RepoRequest,
+    RepoStatus, SetIdentityRequest, SshAllowedSignerStatus, StageFilesRequest, StashEntry,
+    StashPushRequest, StashRequest, SubmoduleActionRequest,
 };
+#[cfg(target_os = "linux")]
+use crate::git::types::{LINUX_TERMINAL_AUTO_ID, LINUX_TERMINAL_CUSTOM_ID};
 use crate::{AppState, CloneCancelFlag, configure_command};
 use serde::{Deserialize, Serialize};
 use std::io::Read;
@@ -268,7 +267,7 @@ fn default_file_manager_label() -> &'static str {
 fn default_terminal_label(settings: &crate::git::types::Settings) -> String {
     #[cfg(target_os = "linux")]
     {
-        return linux_terminal_label(settings).to_string();
+        return linux_terminal_label(settings);
     }
 
     #[cfg(not(target_os = "linux"))]
@@ -370,9 +369,10 @@ fn open_terminal_at_linux(
 }
 
 #[cfg(target_os = "linux")]
-fn linux_terminal_label(settings: &crate::git::types::Settings) -> &'static str {
-    linux_terminal_launch::terminal_label(linux_terminal_preference(
-        settings.linux_terminal_emulator,
+fn linux_terminal_label(settings: &crate::git::types::Settings) -> String {
+    let registry = linux_terminal_launch::TerminalRegistry::with_known_terminals();
+    registry.label_for_preference(&linux_terminal_preference(
+        settings.linux_terminal_emulator.as_str(),
     ))
 }
 
@@ -383,40 +383,20 @@ fn linux_terminal_launcher(
 ) -> linux_terminal_launch::TerminalLauncher {
     linux_terminal_launch::TerminalLauncher::new()
         .working_dir(path)
-        .preference(linux_terminal_preference(settings.linux_terminal_emulator))
+        .registry(linux_terminal_launch::TerminalRegistry::with_known_terminals())
+        .preference(linux_terminal_preference(
+            settings.linux_terminal_emulator.as_str(),
+        ))
         .custom_command(settings.linux_terminal_custom_command.clone())
         .detach_from_parent(true)
 }
 
 #[cfg(target_os = "linux")]
-fn linux_terminal_preference(
-    emulator: LinuxTerminalEmulator,
-) -> linux_terminal_launch::TerminalPreference {
-    use linux_terminal_launch::{KnownTerminal, TerminalPreference};
-
-    match emulator {
-        LinuxTerminalEmulator::Auto => TerminalPreference::Auto,
-        LinuxTerminalEmulator::Konsole => TerminalPreference::Known(KnownTerminal::Konsole),
-        LinuxTerminalEmulator::GnomeTerminal => {
-            TerminalPreference::Known(KnownTerminal::GnomeTerminal)
-        }
-        LinuxTerminalEmulator::GnomeConsole => {
-            TerminalPreference::Known(KnownTerminal::GnomeConsole)
-        }
-        LinuxTerminalEmulator::Xfce4Terminal => {
-            TerminalPreference::Known(KnownTerminal::Xfce4Terminal)
-        }
-        LinuxTerminalEmulator::MateTerminal => {
-            TerminalPreference::Known(KnownTerminal::MateTerminal)
-        }
-        LinuxTerminalEmulator::Lxterminal => TerminalPreference::Known(KnownTerminal::Lxterminal),
-        LinuxTerminalEmulator::Alacritty => TerminalPreference::Known(KnownTerminal::Alacritty),
-        LinuxTerminalEmulator::Ghostty => TerminalPreference::Known(KnownTerminal::Ghostty),
-        LinuxTerminalEmulator::Kitty => TerminalPreference::Known(KnownTerminal::Kitty),
-        LinuxTerminalEmulator::WezTerm => TerminalPreference::Known(KnownTerminal::WezTerm),
-        LinuxTerminalEmulator::Foot => TerminalPreference::Known(KnownTerminal::Foot),
-        LinuxTerminalEmulator::Xterm => TerminalPreference::Known(KnownTerminal::Xterm),
-        LinuxTerminalEmulator::Custom => TerminalPreference::Custom,
+fn linux_terminal_preference(id: &str) -> linux_terminal_launch::TerminalPreference {
+    match id {
+        LINUX_TERMINAL_AUTO_ID => linux_terminal_launch::TerminalPreference::Auto,
+        LINUX_TERMINAL_CUSTOM_ID => linux_terminal_launch::TerminalPreference::Custom,
+        other => linux_terminal_launch::TerminalPreference::registered(other),
     }
 }
 
diff --git a/src-tauri/src/commands/settings.rs b/src-tauri/src/commands/settings.rs
index baff225..34d779a 100644
--- a/src-tauri/src/commands/settings.rs
+++ b/src-tauri/src/commands/settings.rs
@@ -1,7 +1,8 @@
 use crate::git::types::{
     AvatarProviderMode, BackendMode, CommitDateMode, CommitPrimaryAction, ExternalDiffTool,
-    LinuxGraphicsMode, LinuxTerminalEmulator, OperationResult, RepoOpenBehaviour, RowStriping,
-    Settings, ThemeMode,
+    LINUX_TERMINAL_AUTO_ID, LINUX_TERMINAL_CUSTOM_ID, LinuxGraphicsMode, LinuxTerminalId,
+    OperationResult, RepoOpenBehaviour, RowStriping, Settings, ThemeMode,
+    normalise_linux_terminal_id,
 };
 use crate::{AppState, configure_command, git_command};
 use reqwest::header::{ACCEPT, HeaderValue, RANGE};
@@ -1130,8 +1131,8 @@ pub fn set_linux_graphics_mode(
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LinuxTerminalOption {
-    pub emulator: LinuxTerminalEmulator,
-    pub label: &'static str,
+    pub id: LinuxTerminalId,
+    pub label: String,
 }
 
 #[tauri::command]
@@ -1141,74 +1142,52 @@ pub fn get_linux_terminal_options() -> Vec<LinuxTerminalOption> {
 
 #[cfg(target_os = "linux")]
 fn linux_terminal_options() -> Vec<LinuxTerminalOption> {
+    let registry = linux_terminal_launch::TerminalRegistry::with_known_terminals();
     let mut options = vec![LinuxTerminalOption {
-        emulator: LinuxTerminalEmulator::Auto,
-        label: linux_terminal_launch::terminal_label(
-            linux_terminal_launch::TerminalPreference::Auto,
-        ),
+        id: LINUX_TERMINAL_AUTO_ID.to_string(),
+        label: registry.label_for_preference(&linux_terminal_launch::TerminalPreference::Auto),
     }];
 
     options.extend(
-        linux_terminal_launch::known_terminals()
+        registry
+            .definitions()
             .iter()
             .map(|terminal| LinuxTerminalOption {
-                emulator: linux_terminal_emulator(terminal.terminal),
-                label: terminal.label,
+                id: terminal.id().to_string(),
+                label: terminal.label().to_string(),
             }),
     );
 
     options.push(LinuxTerminalOption {
-        emulator: LinuxTerminalEmulator::Custom,
-        label: linux_terminal_launch::terminal_label(
-            linux_terminal_launch::TerminalPreference::Custom,
-        ),
+        id: LINUX_TERMINAL_CUSTOM_ID.to_string(),
+        label: registry.label_for_preference(&linux_terminal_launch::TerminalPreference::Custom),
     });
 
     options
 }
 
-#[cfg(target_os = "linux")]
-fn linux_terminal_emulator(
-    terminal: linux_terminal_launch::KnownTerminal,
-) -> LinuxTerminalEmulator {
-    match terminal {
-        linux_terminal_launch::KnownTerminal::Konsole => LinuxTerminalEmulator::Konsole,
-        linux_terminal_launch::KnownTerminal::GnomeTerminal => LinuxTerminalEmulator::GnomeTerminal,
-        linux_terminal_launch::KnownTerminal::GnomeConsole => LinuxTerminalEmulator::GnomeConsole,
-        linux_terminal_launch::KnownTerminal::Xfce4Terminal => LinuxTerminalEmulator::Xfce4Terminal,
-        linux_terminal_launch::KnownTerminal::MateTerminal => LinuxTerminalEmulator::MateTerminal,
-        linux_terminal_launch::KnownTerminal::Lxterminal => LinuxTerminalEmulator::Lxterminal,
-        linux_terminal_launch::KnownTerminal::Alacritty => LinuxTerminalEmulator::Alacritty,
-        linux_terminal_launch::KnownTerminal::Ghostty => LinuxTerminalEmulator::Ghostty,
-        linux_terminal_launch::KnownTerminal::Kitty => LinuxTerminalEmulator::Kitty,
-        linux_terminal_launch::KnownTerminal::WezTerm => LinuxTerminalEmulator::WezTerm,
-        linux_terminal_launch::KnownTerminal::Foot => LinuxTerminalEmulator::Foot,
-        linux_terminal_launch::KnownTerminal::Xterm => LinuxTerminalEmulator::Xterm,
-    }
-}
-
 #[cfg(not(target_os = "linux"))]
 fn linux_terminal_options() -> Vec<LinuxTerminalOption> {
     vec![
         LinuxTerminalOption {
-            emulator: LinuxTerminalEmulator::Auto,
-            label: "Terminal",
+            id: LINUX_TERMINAL_AUTO_ID.to_string(),
+            label: "Terminal".to_string(),
         },
         LinuxTerminalOption {
-            emulator: LinuxTerminalEmulator::Custom,
-            label: "Terminal",
+            id: LINUX_TERMINAL_CUSTOM_ID.to_string(),
+            label: "Terminal".to_string(),
         },
     ]
 }
 
 #[tauri::command]
 pub fn set_linux_terminal_emulator(
-    linux_terminal_emulator: LinuxTerminalEmulator,
+    linux_terminal_emulator: LinuxTerminalId,
     state: tauri::State<'_, AppState>,
 ) -> Settings {
     state
         .git_service
-        .set_linux_terminal_emulator(linux_terminal_emulator)
+        .set_linux_terminal_emulator(normalise_linux_terminal_id(&linux_terminal_emulator))
 }
 
 #[tauri::command]
diff --git a/src-tauri/src/config_file.rs b/src-tauri/src/config_file.rs
index 7000d9e..d83984a 100644
--- a/src-tauri/src/config_file.rs
+++ b/src-tauri/src/config_file.rs
@@ -212,6 +212,33 @@ mod tests {
         assert_eq!(settings.ui_text_scale, 1.2);
     }
 
+    #[test]
+    fn load_toml_normalises_old_linux_terminal_values() {
+        let dir = TempDir::new().unwrap();
+        let toml_path = dir.path().join("config.toml");
+        let json_path = dir.path().join("config.json");
+
+        write_file(&toml_path, "linuxTerminalEmulator = \"GnomeTerminal\"\n");
+
+        let (settings, should_persist) = load_or_migrate(&toml_path, &json_path);
+        assert!(!should_persist);
+        assert_eq!(settings.linux_terminal_emulator, "gnome-terminal");
+    }
+
+    #[test]
+    fn load_toml_defaults_empty_linux_terminal_value() {
+        let settings: Settings = toml::from_str("linuxTerminalEmulator = \"\"\n").unwrap();
+
+        assert_eq!(settings.linux_terminal_emulator, "auto");
+    }
+
+    #[test]
+    fn load_toml_preserves_unknown_linux_terminal_id() {
+        let settings: Settings = toml::from_str("linuxTerminalEmulator = \"coolterm\"\n").unwrap();
+
+        assert_eq!(settings.linux_terminal_emulator, "coolterm");
+    }
+
     #[test]
     fn load_toml_ignores_old_ms_store_update_flow_config() {
         let dir = TempDir::new().unwrap();
diff --git a/src-tauri/src/git/cli.rs b/src-tauri/src/git/cli.rs
index 744e9d0..d68d1ea 100644
--- a/src-tauri/src/git/cli.rs
+++ b/src-tauri/src/git/cli.rs
@@ -2907,11 +2907,13 @@ impl GitOperationHandler for CliGitHandler {
             "--date=iso-strict",
             pretty.as_str(),
         ];
+        if request.topo_order || request.scope == CommitLogScope::AllRefs {
+            args.push("--topo-order");
+        }
         if request.scope == CommitLogScope::AllRefs {
             args.push("--branches");
             args.push("--tags");
             args.push("--remotes");
-            args.push("--topo-order");
         }
 
         let output = match Self::run_git(args.as_slice(), Some(&repo_path)) {
diff --git a/src-tauri/src/git/gix_handler.rs b/src-tauri/src/git/gix_handler.rs
index e64f0fc..805ed26 100644
--- a/src-tauri/src/git/gix_handler.rs
+++ b/src-tauri/src/git/gix_handler.rs
@@ -1156,7 +1156,7 @@ impl GitOperationHandler for GixGitHandler {
         &self,
         request: &CommitHistoryRequest,
     ) -> GitResult<Vec<CommitHistoryItem>> {
-        if request.scope == CommitLogScope::AllRefs {
+        if request.topo_order || request.scope == CommitLogScope::AllRefs {
             return self.cli_fallback.get_commit_history(request);
         }
 
diff --git a/src-tauri/src/git/handler.rs b/src-tauri/src/git/handler.rs
index fceec63..5e30744 100644
--- a/src-tauri/src/git/handler.rs
+++ b/src-tauri/src/git/handler.rs
@@ -352,12 +352,9 @@ impl GitService {
         })
     }
 
-    pub fn set_linux_terminal_emulator(
-        &self,
-        emulator: super::types::LinuxTerminalEmulator,
-    ) -> Settings {
+    pub fn set_linux_terminal_emulator(&self, id: super::types::LinuxTerminalId) -> Settings {
         self.update_settings(|settings| {
-            settings.linux_terminal_emulator = emulator;
+            settings.linux_terminal_emulator = id;
         })
     }
 
diff --git a/src-tauri/src/git/types.rs b/src-tauri/src/git/types.rs
index 15a2fa8..f3953c3 100644
--- a/src-tauri/src/git/types.rs
+++ b/src-tauri/src/git/types.rs
@@ -112,29 +112,10 @@ impl Default for LinuxGraphicsMode {
     }
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
-pub enum LinuxTerminalEmulator {
-    Auto,
-    Konsole,
-    GnomeTerminal,
-    GnomeConsole,
-    Xfce4Terminal,
-    MateTerminal,
-    Lxterminal,
-    Alacritty,
-    Ghostty,
-    Kitty,
-    WezTerm,
-    Foot,
-    Xterm,
-    Custom,
-}
-
-impl Default for LinuxTerminalEmulator {
-    fn default() -> Self {
-        Self::Auto
-    }
-}
+pub type LinuxTerminalId = String;
+
+pub const LINUX_TERMINAL_AUTO_ID: &str = "auto";
+pub const LINUX_TERMINAL_CUSTOM_ID: &str = "custom";
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 pub enum RepoOpenBehaviour {
@@ -227,6 +208,38 @@ where
     Ok(normalise_ui_text_scale(scale))
 }
 
+fn default_linux_terminal_id() -> LinuxTerminalId {
+    LINUX_TERMINAL_AUTO_ID.to_string()
+}
+
+pub fn normalise_linux_terminal_id(value: &str) -> LinuxTerminalId {
+    match value.trim() {
+        "" | "Auto" | "auto" => LINUX_TERMINAL_AUTO_ID.to_string(),
+        "Custom" | "custom" => LINUX_TERMINAL_CUSTOM_ID.to_string(),
+        "Konsole" | "konsole" => "konsole".to_string(),
+        "GnomeTerminal" | "gnome-terminal" => "gnome-terminal".to_string(),
+        "GnomeConsole" | "gnome-console" => "gnome-console".to_string(),
+        "Xfce4Terminal" | "xfce4-terminal" => "xfce4-terminal".to_string(),
+        "MateTerminal" | "mate-terminal" => "mate-terminal".to_string(),
+        "Lxterminal" | "lxterminal" => "lxterminal".to_string(),
+        "Alacritty" | "alacritty" => "alacritty".to_string(),
+        "Ghostty" | "ghostty" => "ghostty".to_string(),
+        "Kitty" | "kitty" => "kitty".to_string(),
+        "WezTerm" | "wezterm" => "wezterm".to_string(),
+        "Foot" | "foot" => "foot".to_string(),
+        "Xterm" | "xterm" => "xterm".to_string(),
+        other => other.to_string(),
+    }
+}
+
+fn deserialise_linux_terminal_id<'de, D>(deserialiser: D) -> Result<LinuxTerminalId, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = String::deserialize(deserialiser)?;
+    Ok(normalise_linux_terminal_id(&value))
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Settings {
@@ -279,8 +292,11 @@ pub struct Settings {
     pub update_endpoint: String,
     #[serde(default)]
     pub linux_graphics_mode: LinuxGraphicsMode,
-    #[serde(default)]
-    pub linux_terminal_emulator: LinuxTerminalEmulator,
+    #[serde(
+        default = "default_linux_terminal_id",
+        deserialize_with = "deserialise_linux_terminal_id"
+    )]
+    pub linux_terminal_emulator: LinuxTerminalId,
     #[serde(default)]
     pub linux_terminal_custom_command: String,
     #[serde(default)]
@@ -352,7 +368,7 @@ impl Default for Settings {
             auto_install_updates: false,
             update_endpoint: Self::default_update_endpoint(),
             linux_graphics_mode: LinuxGraphicsMode::Auto,
-            linux_terminal_emulator: LinuxTerminalEmulator::Auto,
+            linux_terminal_emulator: default_linux_terminal_id(),
             linux_terminal_custom_command: String::new(),
             repo_open_behaviour: RepoOpenBehaviour::Ask,
             git_executable_path: String::new(),
@@ -439,6 +455,8 @@ pub struct CommitHistoryRequest {
     pub commit_date_mode: CommitDateMode,
     #[serde(default)]
     pub scope: CommitLogScope,
+    #[serde(default)]
+    pub topo_order: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
diff --git a/src-tauri/tests/git.rs b/src-tauri/tests/git.rs
index 5dba63f..23814c3 100644
--- a/src-tauri/tests/git.rs
+++ b/src-tauri/tests/git.rs
@@ -190,6 +190,7 @@ fn history_request(dir: &TempDir) -> CommitHistoryRequest {
         offset: None,
         commit_date_mode: Default::default(),
         scope: Default::default(),
+        topo_order: false,
     }
 }
 
@@ -1190,6 +1191,7 @@ fn commit_creates_entry_in_log() {
             offset: None,
             commit_date_mode: Default::default(),
             scope: Default::default(),
+            topo_order: false,
         })
         .expect("get_commit_history");
     assert!(commits.iter().any(|c| c.message == "add b.txt"));
@@ -1564,6 +1566,7 @@ fn commit_history_all_refs_includes_branch_outside_detached_head() {
             offset: None,
             commit_date_mode: Default::default(),
             scope: CommitLogScope::CurrentCheckout,
+            topo_order: false,
         })
         .expect("get current checkout history");
 
@@ -1575,6 +1578,7 @@ fn commit_history_all_refs_includes_branch_outside_detached_head() {
             offset: None,
             commit_date_mode: Default::default(),
             scope: CommitLogScope::AllRefs,
+            topo_order: false,
         })
         .expect("get all refs history");
 
@@ -1630,6 +1634,7 @@ fn assert_commit_history_includes_merge_parents(handler: impl GitOperationHandle
             offset: None,
             commit_date_mode: Default::default(),
             scope: CommitLogScope::CurrentCheckout,
+            topo_order: false,
         })
         .expect("get commit history");
 
@@ -1672,6 +1677,7 @@ fn assert_commit_history_includes_ref_decorations(handler: impl GitOperationHand
             offset: None,
             commit_date_mode: Default::default(),
             scope: CommitLogScope::CurrentCheckout,
+            topo_order: false,
         })
         .expect("get commit history");
 
@@ -1791,6 +1797,7 @@ fn commit_history_respects_limit() {
             offset: None,
             commit_date_mode: Default::default(),
             scope: Default::default(),
+            topo_order: false,
         })
         .expect("get_commit_history");
     assert_eq!(commits.len(), 3);
@@ -1812,6 +1819,7 @@ fn commit_history_returns_commits_newest_first() {
             offset: None,
             commit_date_mode: Default::default(),
             scope: Default::default(),
+            topo_order: false,
         })
         .expect("get_commit_history");
     assert_eq!(commits[0].message, "third");
@@ -1952,15 +1960,18 @@ fn gix_commit_history_matches_git_log_order_for_merge_commits() {
         .map(ToString::to_string)
         .collect();
 
+    let history_request = |topo_order| CommitHistoryRequest {
+        repo_path: dir.path().to_str().unwrap().to_string(),
+        limit: Some(5),
+        after_hash: None,
+        offset: None,
+        commit_date_mode: Default::default(),
+        scope: Default::default(),
+        topo_order,
+    };
+
     let commits = gix_handler()
-        .get_commit_history(&CommitHistoryRequest {
-            repo_path: dir.path().to_str().unwrap().to_string(),
-            limit: Some(5),
-            after_hash: None,
-            offset: None,
-            commit_date_mode: Default::default(),
-            scope: Default::default(),
-        })
+        .get_commit_history(&history_request(false))
         .expect("get gix commit history");
     let actual_messages: Vec<String> = commits
         .iter()
@@ -1968,6 +1979,30 @@ fn gix_commit_history_matches_git_log_order_for_merge_commits() {
         .collect();
 
     assert_eq!(actual_messages, expected_messages);
+
+    let expected_topo_messages: Vec<String> =
+        git_stdout(dir.path(), &["log", "--topo-order", "-5", "--format=%s"])
+            .lines()
+            .map(ToString::to_string)
+            .collect();
+
+    let cli_topo_commits = handler()
+        .get_commit_history(&history_request(true))
+        .expect("get cli topo commit history");
+    let cli_topo_messages: Vec<String> = cli_topo_commits
+        .iter()
+        .map(|commit| commit.message.clone())
+        .collect();
+    assert_eq!(cli_topo_messages, expected_topo_messages);
+
+    let gix_topo_commits = gix_handler()
+        .get_commit_history(&history_request(true))
+        .expect("get gix topo commit history");
+    let gix_topo_messages: Vec<String> = gix_topo_commits
+        .iter()
+        .map(|commit| commit.message.clone())
+        .collect();
+    assert_eq!(gix_topo_messages, expected_topo_messages);
 }
 
 // commit_details: CLI handler
diff --git a/src/api/commands.ts b/src/api/commands.ts
index 9451dab..8b4d0e5 100644
--- a/src/api/commands.ts
+++ b/src/api/commands.ts
@@ -54,7 +54,7 @@ import type {
     TagInfo,
     BackendMode,
     LinuxTerminalOption,
-    LinuxTerminalEmulator,
+    LinuxTerminalId,
     ThemeMode,
     ThemeBundle,
     UiTextScale,
@@ -140,8 +140,9 @@ export function getCommitHistory(
     afterHash?: string,
     offset?: number,
     scope?: CommitLogScope,
+    topoOrder?: boolean,
 ): Promise<CommitHistoryItem[]> {
-    return invoke<CommitHistoryItem[]>("get_commit_history", {request: {repoPath, limit, afterHash, offset, scope}});
+    return invoke<CommitHistoryItem[]>("get_commit_history", {request: {repoPath, limit, afterHash, offset, scope, topoOrder}});
 }
 
 export function verifyCommits(repoPath: string, hashes: string[]): Promise<CommitVerification[]> {
@@ -501,7 +502,7 @@ export function getLinuxTerminalOptions(): Promise<LinuxTerminalOption[]> {
     return invoke<LinuxTerminalOption[]>("get_linux_terminal_options");
 }
 
-export function setLinuxTerminalEmulator(linuxTerminalEmulator: LinuxTerminalEmulator): Promise<Settings> {
+export function setLinuxTerminalEmulator(linuxTerminalEmulator: LinuxTerminalId): Promise<Settings> {
     return invoke<Settings>("set_linux_terminal_emulator", {linuxTerminalEmulator});
 }
 
diff --git a/src/components/ProjectView.tsx b/src/components/ProjectView.tsx
index 8190623..0da9850 100644
--- a/src/components/ProjectView.tsx
+++ b/src/components/ProjectView.tsx
@@ -83,6 +83,16 @@ const EMPTY_COMMIT_MARKERS: CommitMarkers = {
   upstreamRef: null,
 };
 
+const SHOW_COMMIT_GRAPH_KEY = "gitmun.showCommitGraph";
+
+function readShowCommitGraphPreference(): boolean {
+  try {
+    return localStorage.getItem(SHOW_COMMIT_GRAPH_KEY) === "true";
+  } catch {
+    return false;
+  }
+}
+
 function isStagingOperationKind(kind: LongRunningOperationKind): kind is StagingOperationKind {
   return kind === "stage" || kind === "stageAll" || kind === "unstage" || kind === "unstageAll";
 }
@@ -393,6 +403,7 @@ export function ProjectView({
   const [wrapDiffLines, setWrapDiffLines] = useState(false);
   const [rowStriping, setRowStriping] = useState<RowStriping>("Off");
   const [showCommitGraphButton, setShowCommitGraphButton] = useState(false);
+  const [showCommitGraph, setShowCommitGraph] = useState(readShowCommitGraphPreference);
   const [searchQuery, setSearchQuery] = useState("");
   const [windowFocused, setWindowFocused] = useState(() => (
     typeof document === "undefined" ? true : document.hasFocus()
@@ -415,6 +426,9 @@ export function ProjectView({
   const initials = (displayName ?? "?")
     .split(" ").map(w => w[0]).join("").slice(0, 2).toUpperCase();
   const [identityAvatar, setIdentityAvatar] = useState<string | null>(null);
+  const handleCommitGraphVisibilityChange = useCallback((visible: boolean) => {
+    setShowCommitGraph(visible);
+  }, []);
 
   const currentBranch = status?.currentBranch ?? null;
   const {
@@ -427,7 +441,7 @@ export function ProjectView({
     loadMoreError: logLoadMoreError,
     pageSize: logPageSize,
     refresh: refreshLog,
-  } = useGitLog(repoPath, logScope, windowFocused);
+  } = useGitLog(repoPath, logScope, windowFocused, showCommitGraphButton && showCommitGraph);
   const stagedFiles = status?.stagedFiles ?? [];
   const unstagedFiles = status?.changedFiles ?? [];
   const unversionedFiles = status?.unversionedFiles ?? [];
@@ -2623,6 +2637,7 @@ export function ProjectView({
                   logScope={logScope}
                   rowStriping={rowStriping}
                   showCommitGraphButton={showCommitGraphButton}
+                  onCommitGraphVisibilityChange={handleCommitGraphVisibilityChange}
                   onLogScopeChange={setLogScope}
                   detachedHead={status?.detachedHead ?? false}
                   shallow={status?.shallow ?? false}
diff --git a/src/components/Titlebar.test.tsx b/src/components/Titlebar.test.tsx
index 24b4a13..48e254a 100644
--- a/src/components/Titlebar.test.tsx
+++ b/src/components/Titlebar.test.tsx
@@ -165,6 +165,25 @@ describe("Titlebar", () => {
     expect(within(disclosure).getByText("/home/conor/GitmunProjects/gitmun")).toBeInTheDocument();
   });
 
+  it("shows the full project name when the repository button clips the label", () => {
+    const projectName = "Project Atlas With A Long Display Name";
+    renderTitlebar([makeBranch()], "Push", "/home/conor/GitmunProjects/gitmun", vi.fn(), {
+      repoDisplayName: projectName,
+    });
+
+    const repoButton = screen.getByLabelText("Copy repository path");
+    const repoName = screen.getByText(projectName);
+    setRenderedWidth(repoName, 180, 180);
+    setRenderedWidth(repoButton, 320, 200);
+    fireEvent.mouseEnter(repoButton);
+
+    const disclosure = screen.getByRole("tooltip");
+    expect(within(disclosure).getByText("Project")).toBeInTheDocument();
+    expect(within(disclosure).getByText(projectName)).toBeInTheDocument();
+    expect(within(disclosure).getByText("Repository path")).toBeInTheDocument();
+    expect(within(disclosure).getByText("/home/conor/GitmunProjects/gitmun")).toBeInTheDocument();
+  });
+
   it("keeps the project copy affordance without repeating the project name when the label fits", () => {
     renderTitlebar([makeBranch()], "Push", "/home/conor/GitmunProjects/gitmun", vi.fn(), {
       repoDisplayName: "Project Atlas",
diff --git a/src/components/Titlebar.tsx b/src/components/Titlebar.tsx
index 437f718..a26f0e4 100644
--- a/src/components/Titlebar.tsx
+++ b/src/components/Titlebar.tsx
@@ -62,6 +62,7 @@ export function Titlebar({
   const [searchFocused, setSearchFocused] = useState(false);
   const [repoPathCopied, setRepoPathCopied] = useState(false);
   const [openDisclosure, setOpenDisclosure] = useState<{ kind: "repo" | "branch"; truncated: boolean } | null>(null);
+  const repoButtonRef = useRef<HTMLButtonElement>(null);
   const repoNameRef = useRef<HTMLSpanElement>(null);
   const branchNameRef = useRef<HTMLSpanElement>(null);
   const repoPathCopiedTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -82,7 +83,10 @@ export function Titlebar({
   };
 
   const showRepoDisclosure = () => {
-    setOpenDisclosure({ kind: "repo", truncated: isOverflowing(repoNameRef.current) });
+    setOpenDisclosure({
+      kind: "repo",
+      truncated: isOverflowing(repoNameRef.current) || isOverflowing(repoButtonRef.current),
+    });
   };
 
   const showBranchDisclosure = () => {
@@ -132,6 +136,7 @@ export function Titlebar({
         <div className="titlebar__repo-area">
           <div className="titlebar__repo-wrap" onMouseLeave={closeDisclosure}>
             <button
+              ref={repoButtonRef}
               type="button"
               className="titlebar__repo"
               onClick={copyRepoPath}
diff --git a/src/components/centre/CentrePanel.css b/src/components/centre/CentrePanel.css
index 9c9a09a..fe32aa8 100644
--- a/src/components/centre/CentrePanel.css
+++ b/src/components/centre/CentrePanel.css
@@ -844,24 +844,15 @@
 
 .log-view__graph-connector {
   stroke-width: 3;
-  stroke-linecap: round;
-}
-
-.log-view__graph-vertical {
-  position: absolute;
-  width: 3px;
-  margin-left: -1px;
-  border-radius: 999px;
+  stroke-linejoin: round;
 }
 
-.log-view__graph-vertical--top {
-  top: -1px;
-  height: calc(50% + 1px);
+.log-view__graph-connector--curve {
+  stroke-linecap: round;
 }
 
-.log-view__graph-vertical--bottom {
-  top: 50%;
-  bottom: -1px;
+.log-view__graph-connector--vertical {
+  stroke-linecap: square;
 }
 
 .log-view__graph-node {
@@ -870,15 +861,11 @@
   border-radius: 50%;
   min-width: 8px;
   min-height: 8px;
-  box-shadow: 0 0 0 1.5px var(--bg-surface);
-}
-
-.log-view__row--selected .log-view__graph-node {
-  box-shadow: 0 0 0 1.5px var(--selection-bg);
 }
 
 .log-view__graph-piece--dimmed {
   background: var(--border-strong, var(--border)) !important;
+  fill: var(--border-strong, var(--border)) !important;
   stroke: var(--border-strong, var(--border)) !important;
 }
 
diff --git a/src/components/centre/CentrePanel.tsx b/src/components/centre/CentrePanel.tsx
index 33edc90..356632e 100644
--- a/src/components/centre/CentrePanel.tsx
+++ b/src/components/centre/CentrePanel.tsx
@@ -68,6 +68,7 @@ type CentrePanelProps = {
   logScope: CommitLogScope;
   rowStriping: RowStriping;
   showCommitGraphButton: boolean;
+  onCommitGraphVisibilityChange?: (visible: boolean) => void;
   onLogScopeChange: (scope: CommitLogScope) => void;
   detachedHead: boolean;
   shallow: boolean;
@@ -219,6 +220,10 @@ export function CentrePanel(props: CentrePanelProps) {
   const submoduleChanges = props.submodules.filter(submodule => submodule.state !== "clean").length;
   const totalChanges = props.stagedFiles.length + props.unstagedFiles.length + props.unversionedFiles.length + submoduleChanges;
 
+  React.useEffect(() => {
+    props.onCommitGraphVisibilityChange?.(effectiveShowCommitGraph);
+  }, [effectiveShowCommitGraph, props.onCommitGraphVisibilityChange]);
+
   const handleToggleCommitGraph = () => {
     setShowCommitGraph(previous => {
       const next = !previous;
diff --git a/src/components/centre/CommitGraphGutter.tsx b/src/components/centre/CommitGraphGutter.tsx
new file mode 100644
index 0000000..ccb9619
--- /dev/null
+++ b/src/components/centre/CommitGraphGutter.tsx
@@ -0,0 +1,195 @@
+import { useTranslation } from "react-i18next";
+import type { CommitHistoryItem } from "../../types";
+import type { CommitGraphRow, CommitGraphSegment } from "../../utils/commitGraph";
+
+const GRAPH_LANE_WIDTH = 12;
+const GRAPH_NODE_RADIUS = 4;
+const GRAPH_UNIT_HEIGHT = 100;
+
+function graphLaneColour(lane: number): string {
+  const colours = [
+    "var(--accent)",
+    "var(--green)",
+    "var(--yellow)",
+    "var(--red)",
+    "#c4b5fd",
+    "#6ee7b7",
+    "#f0abfc",
+    "#93c5fd",
+  ];
+  return colours[lane % colours.length];
+}
+
+function graphWidth(laneCount: number): number {
+  return Math.max(14, laneCount * GRAPH_LANE_WIDTH);
+}
+
+function graphX(lane: number, laneCount: number): number {
+  return 5 + Math.min(lane, laneCount - 1) * GRAPH_LANE_WIDTH;
+}
+
+function graphPieceClass(baseClass: string, active: boolean | null): string {
+  if (active === null) return baseClass;
+  return `${baseClass} ${active ? "log-view__graph-piece--active" : "log-view__graph-piece--dimmed"}`;
+}
+
+function formatGraphNumber(value: number): string {
+  return Number.isInteger(value) ? String(value) : value.toFixed(2);
+}
+
+function graphCurvePath(
+  fromLane: number,
+  toLane: number,
+  fromUnit: number,
+  toUnit: number,
+  laneCount: number,
+): string {
+  const fromX = graphX(fromLane, laneCount);
+  const toX = graphX(toLane, laneCount);
+  const verticalDistance = toUnit - fromUnit;
+  const controlY1 = fromUnit + verticalDistance * 0.44;
+  const controlY2 = fromUnit + verticalDistance * 0.56;
+  return [
+    `M ${formatGraphNumber(fromX)} ${formatGraphNumber(fromUnit)}`,
+    `C ${formatGraphNumber(fromX)} ${formatGraphNumber(controlY1)}`,
+    `${formatGraphNumber(toX)} ${formatGraphNumber(controlY2)}`,
+    `${formatGraphNumber(toX)} ${formatGraphNumber(toUnit)}`,
+  ].join(" ");
+}
+
+function graphVerticalPath(lane: number, fromUnit: number, toUnit: number, laneCount: number): string {
+  const x = graphX(lane, laneCount);
+  return `M ${formatGraphNumber(x)} ${formatGraphNumber(fromUnit)} L ${formatGraphNumber(x)} ${formatGraphNumber(toUnit)}`;
+}
+
+function graphTitle(
+  commit: CommitHistoryItem,
+  t: (key: string, options?: Record<string, unknown>) => string,
+): string {
+  const lines = [
+    t("log.graphCommit", { hash: commit.shortHash }),
+    t("log.graphLaneHint"),
+  ];
+  const firstParent = commit.parentHashes[0];
+  const mergedParents = commit.parentHashes.slice(1);
+  if (firstParent) {
+    lines.push(t("log.graphFirstParent", { hash: firstParent.slice(0, 7) }));
+  }
+  if (mergedParents.length > 0) {
+    lines.push(t("log.graphMergedParents", { hashes: mergedParents.map(hash => hash.slice(0, 7)).join(", ") }));
+  }
+  if (commit.refDecorations.length > 0) {
+    lines.push(t("log.graphRefs", { refs: commit.refDecorations.map(ref => ref.name).join(", ") }));
+  }
+  return lines.join("\n");
+}
+
+function segmentKey(segment: CommitGraphSegment, index: number): string {
+  if (segment.kind === "curve") {
+    return `${index}-curve-${segment.fromLane}-${segment.toLane}-${segment.hash}`;
+  }
+  return `${index}-${segment.kind}-${segment.lane}-${segment.hash}`;
+}
+
+function graphGradientId(commitHash: string, segment: CommitGraphSegment, index: number): string {
+  const key = segmentKey(segment, index).replace(/[^A-Za-z0-9_-]/g, "_");
+  return `graph-gradient-${commitHash.slice(0, 12)}-${key}`;
+}
+
+export function CommitGraphGutter({
+  row,
+  laneCount,
+  commit,
+  highlightedHashes,
+}: {
+  row: CommitGraphRow | undefined;
+  laneCount: number;
+  commit: CommitHistoryItem;
+  highlightedHashes: Set<string> | null;
+}) {
+  const { t } = useTranslation("centre");
+  const width = graphWidth(laneCount);
+  if (!row) {
+    return <div className="log-view__graph" style={{ width }} aria-hidden="true" />;
+  }
+
+  const graphTitleText = graphTitle(commit, t);
+  const hasHighlight = highlightedHashes !== null;
+  const isActiveHash = (hash: string): boolean | null => {
+    if (!highlightedHashes) return null;
+    return highlightedHashes.has(hash);
+  };
+  const viewBoxHeight = row.heightUnits * GRAPH_UNIT_HEIGHT;
+  const curves = row.segments.filter(segment => segment.kind === "curve");
+  const verticals = row.segments.filter(segment => segment.kind === "vertical");
+  const nodes = row.segments.filter(segment => segment.kind === "node");
+  const curveStroke = (segment: typeof curves[number], index: number): string => (
+    segment.fromLane === segment.toLane
+      ? graphLaneColour(segment.colourLane)
+      : `url(#${graphGradientId(commit.hash, segment, index)})`
+  );
+
+  return (
+    <div
+      className="log-view__graph"
+      style={{
+        width,
+        minHeight: row.heightUnits > 1 ? `${row.heightUnits * 56}px` : undefined,
+      }}
+      title={graphTitleText}
+      aria-label={graphTitleText}
+    >
+      <svg className="log-view__graph-connectors" width={width} height="100%" viewBox={`0 0 ${width} ${viewBoxHeight}`} preserveAspectRatio="none">
+        <defs>
+          {curves.map((segment, index) => (
+            <linearGradient
+              key={graphGradientId(commit.hash, segment, index)}
+              id={graphGradientId(commit.hash, segment, index)}
+              gradientUnits="userSpaceOnUse"
+              x1={graphX(segment.fromLane, laneCount)}
+              y1={segment.fromUnit}
+              x2={graphX(segment.toLane, laneCount)}
+              y2={segment.toUnit}
+            >
+              <stop offset="0%" stopColor={graphLaneColour(segment.fromLane)} />
+              <stop offset="100%" stopColor={graphLaneColour(segment.toLane)} />
+            </linearGradient>
+          ))}
+        </defs>
+        {curves.map((segment, index) => (
+          <path
+            key={segmentKey(segment, index)}
+            d={graphCurvePath(segment.fromLane, segment.toLane, segment.fromUnit, segment.toUnit, laneCount)}
+            stroke={curveStroke(segment, index)}
+            className={graphPieceClass("log-view__graph-connector log-view__graph-connector--curve", isActiveHash(segment.hash))}
+            vectorEffect="non-scaling-stroke"
+            fill="none"
+          />
+        ))}
+        {verticals.map((segment, index) => (
+          <path
+            key={segmentKey(segment, index)}
+            d={graphVerticalPath(segment.lane, segment.fromUnit, segment.toUnit, laneCount)}
+            stroke={graphLaneColour(segment.colourLane)}
+            className={graphPieceClass("log-view__graph-connector log-view__graph-connector--vertical", isActiveHash(segment.hash))}
+            vectorEffect="non-scaling-stroke"
+            fill="none"
+          />
+        ))}
+      </svg>
+      {nodes.map((segment, index) => (
+        <span
+          key={segmentKey(segment, index)}
+          className={graphPieceClass("log-view__graph-node", hasHighlight ? highlightedHashes.has(segment.hash) : null)}
+          style={{
+            left: graphX(segment.lane, laneCount) - GRAPH_NODE_RADIUS,
+            top: `calc(${(segment.unit / viewBoxHeight) * 100}% - ${GRAPH_NODE_RADIUS}px)`,
+            width: GRAPH_NODE_RADIUS * 2,
+            height: GRAPH_NODE_RADIUS * 2,
+            background: graphLaneColour(segment.colourLane),
+          }}
+        />
+      ))}
+    </div>
+  );
+}
diff --git a/src/components/centre/LogView.test.tsx b/src/components/centre/LogView.test.tsx
index 5f39372..6f0cd2f 100644
--- a/src/components/centre/LogView.test.tsx
+++ b/src/components/centre/LogView.test.tsx
@@ -199,7 +199,7 @@ const settingsPayload: Settings = {
   autoInstallUpdates: false,
   updateEndpoint: "",
   linuxGraphicsMode: "Auto",
-  linuxTerminalEmulator: "Auto",
+  linuxTerminalEmulator: "auto",
   linuxTerminalCustomCommand: "",
   repoOpenBehaviour: "Ask",
   gitExecutablePath: "",
@@ -370,14 +370,32 @@ describe("LogView commit selection", () => {
     renderLog({ commits: [merge, feature, main] });
 
     const mergeRow = rowFor("Subject 1");
-    const sideConnector = mergeRow.querySelector(".log-view__graph-connectors line[x2='17']");
-    const bottomLaneOffsets = Array.from(mergeRow.querySelectorAll<HTMLElement>(".log-view__graph-vertical--bottom"))
-      .map(lane => lane.style.left);
-
-    expect(sideConnector).toHaveAttribute("x1", "5");
-    expect(sideConnector).toHaveAttribute("y2", "100");
-    expect(bottomLaneOffsets).toContain("5px");
-    expect(bottomLaneOffsets).not.toContain("17px");
+    const sideConnector = mergeRow.querySelector(".log-view__graph-connectors path[d='M 5 50 C 5 72 17 78 17 100']");
+    const firstParentContinuation = mergeRow.querySelector(".log-view__graph-connectors path[d='M 5 50 L 5 100']");
+    const prematureSideContinuation = mergeRow.querySelector(".log-view__graph-connectors path[d='M 17 50 L 17 100']");
+
+    expect(sideConnector).not.toBeNull();
+    expect(firstParentContinuation).not.toBeNull();
+    expect(prematureSideContinuation).toBeNull();
+  });
+
+  it("blends colours across lane-changing graph curves", () => {
+    const main = commit(3);
+    const feature = commit(2, { parentHashes: [main.hash] });
+    const merge = commit(1, { parentHashes: [main.hash, feature.hash] });
+    renderLog({ commits: [merge, feature, main] });
+
+    const mergeRow = rowFor("Subject 1");
+    const sideConnector = mergeRow.querySelector(".log-view__graph-connectors path[d='M 5 50 C 5 72 17 78 17 100']");
+    const stroke = sideConnector?.getAttribute("stroke") ?? "";
+    const gradientId = stroke.match(/^url\(#(.+)\)$/)?.[1];
+    const gradient = gradientId
+      ? mergeRow.querySelector(`linearGradient[id="${gradientId}"]`)
+      : null;
+    const stops = Array.from(gradient?.querySelectorAll("stop") ?? []);
+
+    expect(gradient).not.toBeNull();
+    expect(stops.map(stop => stop.getAttribute("stop-color"))).toEqual(["var(--accent)", "var(--green)"]);
   });
 
   it("keeps an active parent lane continuous through a branch join", () => {
@@ -387,10 +405,31 @@ describe("LogView commit selection", () => {
     renderLog({ commits: [merge, feature, main] });
 
     const joinRow = rowFor("Subject 2");
-    const bottomLaneOffsets = Array.from(joinRow.querySelectorAll<HTMLElement>(".log-view__graph-vertical--bottom"))
-      .map(lane => lane.style.left);
+    const collapsedLane = joinRow.querySelector(".log-view__graph-connectors path[d='M 17 50 C 17 72 5 78 5 100']");
+    const duplicateCollapsedContinuation = joinRow.querySelector(".log-view__graph-connectors path[d='M 5 50 L 5 100']");
+
+    expect(collapsedLane).not.toBeNull();
+    expect(duplicateCollapsedContinuation).toBeNull();
+  });
 
-    expect(bottomLaneOffsets).toContain("5px");
+  it("draws a transition when a new merge parent shifts an active lane", () => {
+    const base = commit(7);
+    const unrelatedBase = commit(6);
+    const feature = commit(5, { parentHashes: [base.hash] });
+    const main = commit(4, { parentHashes: [base.hash] });
+    const merge = commit(3, { parentHashes: [main.hash, feature.hash] });
+    const unrelatedTip = commit(2, { parentHashes: [unrelatedBase.hash] });
+    const afterMerge = commit(1, { parentHashes: [merge.hash] });
+    renderLog({ commits: [afterMerge, unrelatedTip, merge, main, feature, unrelatedBase, base] });
+
+    const mergeRow = rowFor("Subject 3");
+    const shiftedLane = mergeRow.querySelector(".log-view__graph-connectors path[d='M 17 50 C 17 72 29 78 29 100']");
+    const shiftedTopContinuation = mergeRow.querySelector(".log-view__graph-connectors path[d='M 17 0 L 17 50']");
+    const shiftedBottomContinuation = mergeRow.querySelector(".log-view__graph-connectors path[d='M 29 50 L 29 100']");
+
+    expect(shiftedLane).not.toBeNull();
+    expect(shiftedTopContinuation).not.toBeNull();
+    expect(shiftedBottomContinuation).toBeNull();
   });
 
   it("renders rows without the commit graph when hidden", () => {
diff --git a/src/components/centre/LogView.tsx b/src/components/centre/LogView.tsx
index d02124c..98f0a4f 100644
--- a/src/components/centre/LogView.tsx
+++ b/src/components/centre/LogView.tsx
@@ -23,6 +23,7 @@ import {
 } from "../../api/commands";
 import { buildCommitGraph, type CommitGraphRow } from "../../utils/commitGraph";
 import { ContextMenu } from "../shared/ContextMenu";
+import { CommitGraphGutter } from "./CommitGraphGutter";
 
 function getInitials(name: string): string {
   return name.split(" ").map(w => w[0]).join("").slice(0, 2).toUpperCase();
@@ -35,20 +36,6 @@ function hashColour(name: string): string {
   return colours[Math.abs(h) % colours.length];
 }
 
-function graphLaneColour(lane: number): string {
-  const colours = [
-    "var(--accent)",
-    "var(--green)",
-    "var(--yellow)",
-    "var(--red)",
-    "#c4b5fd",
-    "#6ee7b7",
-    "#f0abfc",
-    "#93c5fd",
-  ];
-  return colours[lane % colours.length];
-}
-
 function relativeTime(dateStr: string, t: (key: string, options?: Record<string, unknown>) => string): string {
   try {
     const date = new Date(dateStr);
@@ -294,156 +281,10 @@ type CommitRowProps = {
   onBadgeClick: (rect: DOMRect, status: SignatureStatus, signer: string | null, fingerprint: string | null, keyType: string | null, date: string) => void;
 };
 
-const GRAPH_LANE_WIDTH = 12;
-const GRAPH_NODE_RADIUS = 4;
 const MAX_VISIBLE_REF_CHIPS = 4;
 const MAX_VERIFICATION_BATCH_SIZE = 20;
 const BACKGROUND_VERIFICATION_PUMP_DELAY_MS = 25;
 
-function graphWidth(laneCount: number): number {
-  return Math.max(14, laneCount * GRAPH_LANE_WIDTH);
-}
-
-function graphX(lane: number, laneCount: number): number {
-  return 5 + Math.min(lane, laneCount - 1) * GRAPH_LANE_WIDTH;
-}
-
-function graphPieceClass(baseClass: string, active: boolean | null): string {
-  if (active === null) return baseClass;
-  return `${baseClass} ${active ? "log-view__graph-piece--active" : "log-view__graph-piece--dimmed"}`;
-}
-
-function graphTitle(
-  commit: CommitHistoryItem,
-  t: (key: string, options?: Record<string, unknown>) => string,
-): string {
-  const lines = [
-    t("log.graphCommit", { hash: commit.shortHash }),
-    t("log.graphLaneHint"),
-  ];
-  const firstParent = commit.parentHashes[0];
-  const mergedParents = commit.parentHashes.slice(1);
-  if (firstParent) {
-    lines.push(t("log.graphFirstParent", { hash: firstParent.slice(0, 7) }));
-  }
-  if (mergedParents.length > 0) {
-    lines.push(t("log.graphMergedParents", { hashes: mergedParents.map(hash => hash.slice(0, 7)).join(", ") }));
-  }
-  if (commit.refDecorations.length > 0) {
-    lines.push(t("log.graphRefs", { refs: commit.refDecorations.map(ref => ref.name).join(", ") }));
-  }
-  return lines.join("\n");
-}
-
-function CommitGraphGutter({
-  row,
-  laneCount,
-  commit,
-  highlightedHashes,
-}: {
-  row: CommitGraphRow | undefined;
-  laneCount: number;
-  commit: CommitHistoryItem;
-  highlightedHashes: Set<string> | null;
-}) {
-  const { t } = useTranslation("centre");
-  const width = graphWidth(laneCount);
-  if (!row) {
-    return <div className="log-view__graph" style={{ width }} aria-hidden="true" />;
-  }
-
-  const commitX = graphX(row.commitLane, laneCount);
-  const nodeSize = GRAPH_NODE_RADIUS * 2;
-  const hasHighlight = highlightedHashes !== null;
-  const graphTitleText = graphTitle(commit, t);
-  const isActiveHash = (hash: string): boolean | null => {
-    if (!highlightedHashes) return null;
-    return highlightedHashes.has(hash);
-  };
-  const topLaneKeys = new Set(row.topLanes.map(lane => `${lane.lane}:${lane.hash}`));
-  const connectedParentLaneKeys = new Set(
-    row.parentLanes
-      .filter(parent => (
-        parent.sourceLane !== undefined
-        || (parent.lane !== row.commitLane && !topLaneKeys.has(`${parent.lane}:${parent.hash}`))
-      ))
-      .map(parent => `${parent.lane}:${parent.hash}`),
-  );
-
-  return (
-    <div className="log-view__graph" style={{ width }} title={graphTitleText} aria-label={graphTitleText}>
-      {row.topLanes.map(lane => {
-        const x = graphX(lane.lane, laneCount);
-        return (
-          <span
-            key={`top-${lane.lane}-${lane.hash}`}
-            className={graphPieceClass(
-              "log-view__graph-vertical log-view__graph-vertical--top",
-              isActiveHash(lane.hash),
-            )}
-            style={{ left: x, background: graphLaneColour(lane.lane) }}
-          />
-        );
-      })}
-      <svg className="log-view__graph-connectors" width={width} height="100%" viewBox={`0 0 ${width} 100`} preserveAspectRatio="none">
-        {row.parentLanes.map(parent => {
-          const x = graphX(parent.lane, laneCount);
-          const sourceLane = parent.sourceLane;
-          const sourceX = sourceLane === undefined ? null : graphX(sourceLane, laneCount);
-          if (sourceLane !== undefined && sourceX !== null && sourceX !== x) {
-            return (
-              <polyline
-                key={`parent-${parent.lane}-${parent.hash}`}
-                points={`${sourceX},50 ${commitX},50 ${x},100`}
-                stroke={graphLaneColour(sourceLane)}
-                className={graphPieceClass("log-view__graph-connector", isActiveHash(parent.hash))}
-                vectorEffect="non-scaling-stroke"
-                fill="none"
-              />
-            );
-          }
-          if (x === commitX) return null;
-          return (
-            <line
-              key={`parent-${parent.lane}-${parent.hash}`}
-              x1={commitX}
-              y1="50"
-              x2={x}
-              y2="100"
-              stroke={graphLaneColour(parent.lane)}
-              className={graphPieceClass("log-view__graph-connector", isActiveHash(parent.hash))}
-              vectorEffect="non-scaling-stroke"
-            />
-          );
-        })}
-      </svg>
-      {row.bottomLanes.filter(lane => !connectedParentLaneKeys.has(`${lane.lane}:${lane.hash}`)).map(lane => {
-        const x = graphX(lane.lane, laneCount);
-        return (
-          <span
-            key={`bottom-${lane.lane}-${lane.hash}`}
-            className={graphPieceClass(
-              "log-view__graph-vertical log-view__graph-vertical--bottom",
-              isActiveHash(lane.hash),
-            )}
-            style={{ left: x, background: graphLaneColour(lane.lane) }}
-          />
-        );
-      })}
-      <span
-        className={graphPieceClass("log-view__graph-node", hasHighlight ? highlightedHashes.has(row.hash) : null)}
-        style={{
-          left: commitX - GRAPH_NODE_RADIUS,
-          top: `calc(50% - ${GRAPH_NODE_RADIUS}px)`,
-          width: nodeSize,
-          height: nodeSize,
-          background: graphLaneColour(row.commitLane),
-        }}
-      />
-    </div>
-  );
-}
-
 function refTitle(
   decoration: CommitRefDecoration,
   t: (key: string, options?: Record<string, unknown>) => string,
diff --git a/src/components/settings/SettingsWindow.test.tsx b/src/components/settings/SettingsWindow.test.tsx
index 175df4d..c40fd46 100644
--- a/src/components/settings/SettingsWindow.test.tsx
+++ b/src/components/settings/SettingsWindow.test.tsx
@@ -37,7 +37,7 @@ const settings: Settings = {
     autoInstallUpdates: false,
     updateEndpoint: "https://github.com/cst8t/gitmun/releases/latest/download/latest.json",
     linuxGraphicsMode: "Auto",
-    linuxTerminalEmulator: "Auto",
+    linuxTerminalEmulator: "auto",
     linuxTerminalCustomCommand: "",
     repoOpenBehaviour: "Ask",
     gitExecutablePath: "",
@@ -94,9 +94,9 @@ vi.mock("../../api/commands", () => ({
     getGlobalDiffToolPath: vi.fn(async () => null),
     getGlobalGpgProgramPath: vi.fn(async () => null),
     getLinuxTerminalOptions: vi.fn(async () => [
-        {emulator: "Auto", label: "Terminal"},
-        {emulator: "Ghostty", label: "Ghostty"},
-        {emulator: "Custom", label: "Terminal"},
+        {id: "auto", label: "Terminal"},
+        {id: "ghostty", label: "Ghostty"},
+        {id: "custom", label: "Terminal"},
     ]),
     openResultLogWindow: vi.fn(async () => {}),
     setGlobalDiffToolWithPath: vi.fn(async () => ({message: "Updated diff tool."})),
@@ -221,7 +221,7 @@ describe("SettingsWindow", () => {
         expect(await screen.findByLabelText("Terminal")).toBeInTheDocument();
         expect(screen.queryByPlaceholderText("my-terminal --working-directory {path}")).not.toBeInTheDocument();
 
-        fireEvent.change(screen.getByLabelText("Terminal"), {target: {value: "Custom"}});
+        fireEvent.change(screen.getByLabelText("Terminal"), {target: {value: "custom"}});
 
         expect(screen.getByPlaceholderText("my-terminal --working-directory {path}")).toBeInTheDocument();
     });
@@ -229,7 +229,7 @@ describe("SettingsWindow", () => {
     it("saves Linux terminal settings", async () => {
         render(<SettingsWindow/>);
 
-        fireEvent.change(await screen.findByLabelText("Terminal"), {target: {value: "Custom"}});
+        fireEvent.change(await screen.findByLabelText("Terminal"), {target: {value: "custom"}});
         fireEvent.change(screen.getByPlaceholderText("my-terminal --working-directory {path}"), {
             target: {value: "kitty --directory {path}"},
         });
@@ -237,7 +237,7 @@ describe("SettingsWindow", () => {
 
         await waitFor(() => {
             expect(mocks.invoke).toHaveBeenCalledWith("set_linux_terminal_emulator", {
-                linuxTerminalEmulator: "Custom",
+                linuxTerminalEmulator: "custom",
             });
             expect(mocks.invoke).toHaveBeenCalledWith("set_linux_terminal_custom_command", {
                 linuxTerminalCustomCommand: "kitty --directory {path}",
diff --git a/src/components/settings/SettingsWindow.tsx b/src/components/settings/SettingsWindow.tsx
index cf07566..838b131 100644
--- a/src/components/settings/SettingsWindow.tsx
+++ b/src/components/settings/SettingsWindow.tsx
@@ -13,7 +13,7 @@ import type {
     CommitDateMode,
     ExternalDiffTool,
     LinuxGraphicsMode,
-    LinuxTerminalEmulator,
+    LinuxTerminalId,
     LinuxTerminalOption,
     RepoOpenBehaviour,
     RowStriping,
@@ -51,8 +51,8 @@ const DEFAULT_COMMIT_MESSAGE_RECOMMENDED_LENGTH = 72;
 const DEFAULT_ERROR_TOAST_CLEAR_DELAY_MS = 8000;
 const MIN_ERROR_TOAST_CLEAR_DELAY_MS = 1000;
 const DEFAULT_LINUX_TERMINAL_OPTIONS: LinuxTerminalOption[] = [
-    {emulator: "Auto", label: "Terminal"},
-    {emulator: "Custom", label: "Terminal"},
+    {id: "auto", label: "Terminal"},
+    {id: "custom", label: "Terminal"},
 ];
 
 function normaliseOptionalGitConfig(value: string | null | undefined): string {
@@ -190,7 +190,7 @@ export function SettingsWindow() {
     const [updateEndpoint, setUpdateEndpointState] = useState(DEFAULT_UPDATE_ENDPOINT);
     const [linuxGraphicsMode, setLinuxGraphicsMode] = useState<LinuxGraphicsMode>("Auto");
     const [linuxTerminalOptions, setLinuxTerminalOptions] = useState<LinuxTerminalOption[]>(DEFAULT_LINUX_TERMINAL_OPTIONS);
-    const [linuxTerminalEmulator, setLinuxTerminalEmulator] = useState<LinuxTerminalEmulator>("Auto");
+    const [linuxTerminalEmulator, setLinuxTerminalEmulator] = useState<LinuxTerminalId>("auto");
     const [linuxTerminalCustomCommand, setLinuxTerminalCustomCommand] = useState("");
     const [repoOpenBehaviour, setRepoOpenBehaviour] = useState<RepoOpenBehaviour>("Ask");
     const [isLinux, setIsLinux] = useState(false);
@@ -227,10 +227,10 @@ export function SettingsWindow() {
         }
     }, [t]);
     const labelLinuxTerminal = useCallback((option: LinuxTerminalOption): string => {
-        switch (option.emulator) {
-            case "Auto":
+        switch (option.id) {
+            case "auto":
                 return t("options.linuxTerminalAuto");
-            case "Custom":
+            case "custom":
                 return t("options.linuxTerminalCustom");
             default:
                 return option.label;
@@ -366,7 +366,7 @@ export function SettingsWindow() {
             setAutoInstallUpdates(settings.autoInstallUpdates ?? false);
             setUpdateEndpointState(settings.updateEndpoint ?? DEFAULT_UPDATE_ENDPOINT);
             setLinuxGraphicsMode(settings.linuxGraphicsMode ?? "Auto");
-            setLinuxTerminalEmulator(settings.linuxTerminalEmulator ?? "Auto");
+            setLinuxTerminalEmulator(settings.linuxTerminalEmulator ?? "auto");
             setLinuxTerminalCustomCommand(settings.linuxTerminalCustomCommand ?? "");
             setRepoOpenBehaviour(settings.repoOpenBehaviour ?? "Ask");
             setGpgKeyserverVerificationEnabledState(settings.gpgKeyserverVerificationEnabled ?? false);
@@ -935,13 +935,13 @@ export function SettingsWindow() {
                                     id="settings-linux-terminal"
                                     className="settings-window__select"
                                     value={linuxTerminalEmulator}
-                                    onChange={e => setLinuxTerminalEmulator(e.target.value as LinuxTerminalEmulator)}
+                                    onChange={e => setLinuxTerminalEmulator(e.target.value)}
                                 >
                                     {linuxTerminalOptions.map(option => (
-                                        <option key={option.emulator} value={option.emulator}>{labelLinuxTerminal(option)}</option>
+                                        <option key={option.id} value={option.id}>{labelLinuxTerminal(option)}</option>
                                     ))}
                                 </select>
-                                {linuxTerminalEmulator === "Custom" && (
+                                {linuxTerminalEmulator === "custom" && (
                                     <input
                                         className="settings-window__input"
                                         type="text"
diff --git a/src/hooks/useGitLog.test.ts b/src/hooks/useGitLog.test.ts
index e814a3d..610eddd 100644
--- a/src/hooks/useGitLog.test.ts
+++ b/src/hooks/useGitLog.test.ts
@@ -170,7 +170,25 @@ describe("useGitLog", () => {
     rerender({ scope: "allRefs" });
     expect(result.current.commits).toHaveLength(0);
     await waitFor(() => expect(result.current.commits).toHaveLength(2));
-    expect(mockGetCommitHistory).toHaveBeenLastCalledWith("/repo", 100, undefined, undefined, "allRefs");
+    expect(mockGetCommitHistory).toHaveBeenLastCalledWith("/repo", 100, undefined, undefined, "allRefs", false);
+  });
+
+  test("refetches with topo order when requested", async () => {
+    mockGetCommitHistory
+      .mockResolvedValueOnce(makeCommits(1))
+      .mockResolvedValueOnce(makeCommits(2, 10));
+    const { result, rerender } = renderHook(
+      ({ topoOrder }) => useGitLog("/repo", "currentCheckout", true, topoOrder),
+      { initialProps: { topoOrder: false } },
+    );
+    await waitFor(() => expect(result.current.commits).toHaveLength(1));
+    expect(mockGetCommitHistory).toHaveBeenLastCalledWith("/repo", 100, undefined, undefined, "currentCheckout", false);
+
+    rerender({ topoOrder: true });
+
+    expect(result.current.commits).toHaveLength(0);
+    await waitFor(() => expect(result.current.commits).toHaveLength(2));
+    expect(mockGetCommitHistory).toHaveBeenLastCalledWith("/repo", 100, undefined, undefined, "currentCheckout", true);
   });
 
   test("sets error on fetch failure", async () => {
diff --git a/src/hooks/useGitLog.ts b/src/hooks/useGitLog.ts
index 08ddd52..bc65187 100644
--- a/src/hooks/useGitLog.ts
+++ b/src/hooks/useGitLog.ts
@@ -8,6 +8,7 @@ export function useGitLog(
   repoPath: string | null,
   scope: CommitLogScope = "currentCheckout",
   windowFocused = true,
+  topoOrder = false,
 ) {
   const [commits, setCommits] = useState<CommitHistoryItem[]>([]);
   const [loading, setLoading] = useState(false);
@@ -21,6 +22,8 @@ export function useGitLog(
   currentRepoRef.current = repoPath;
   const currentScopeRef = useRef(scope);
   currentScopeRef.current = scope;
+  const currentTopoOrderRef = useRef(topoOrder);
+  currentTopoOrderRef.current = topoOrder;
 
   const refreshRequestId = useRef(0);
   const loadMoreRequestId = useRef(0);
@@ -39,7 +42,7 @@ export function useGitLog(
     setLoadMoreError(null);
     cursorRef.current = undefined;
     commitCountRef.current = 0;
-  }, [repoPath, scope]);
+  }, [repoPath, scope, topoOrder]);
 
   const refresh = useCallback(async (options?: { force?: boolean }) => {
     if (!windowFocused && options?.force !== true) {
@@ -60,10 +63,11 @@ export function useGitLog(
     setError(null);
     setLoadMoreError(null);
     try {
-      const page = await getCommitHistory(repoPath, requestedLimit, undefined, undefined, scope);
+      const page = await getCommitHistory(repoPath, requestedLimit, undefined, undefined, scope, topoOrder);
       if (
         currentRepoRef.current === repoPath
         && currentScopeRef.current === scope
+        && currentTopoOrderRef.current === topoOrder
         && refreshRequestId.current === myId
         && commitCountRef.current <= requestedLimit
       ) {
@@ -74,17 +78,17 @@ export function useGitLog(
         commitCountRef.current = page.length;
       }
     } catch (e) {
-      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && refreshRequestId.current === myId) {
+      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && currentTopoOrderRef.current === topoOrder && refreshRequestId.current === myId) {
         setError(String(e));
       }
     } finally {
-      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && refreshRequestId.current === myId) {
+      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && currentTopoOrderRef.current === topoOrder && refreshRequestId.current === myId) {
         setLoading(false);
       }
     }
-  }, [repoPath, scope, windowFocused]);
+  }, [repoPath, scope, topoOrder, windowFocused]);
 
-  useEffect(() => { refresh(); }, [repoPath, scope]);
+  useEffect(() => { refresh(); }, [repoPath, scope, topoOrder]);
 
   useEffect(() => {
     if (!windowFocused || !pendingBlurredRefreshRef.current) return;
@@ -101,10 +105,11 @@ export function useGitLog(
     setLoadMoreError(null);
     try {
       const offset = commitCountRef.current; // CLI fallback uses --skip
-      const page = await getCommitHistory(repoPath, PAGE_SIZE, afterHash, offset, scope);
+      const page = await getCommitHistory(repoPath, PAGE_SIZE, afterHash, offset, scope, topoOrder);
       if (
         currentRepoRef.current === repoPath
         && currentScopeRef.current === scope
+        && currentTopoOrderRef.current === topoOrder
         && loadMoreRequestId.current === myId
         && cursorRef.current === afterHash
         && commitCountRef.current === offset
@@ -124,15 +129,15 @@ export function useGitLog(
         }
       }
     } catch (e) {
-      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && loadMoreRequestId.current === myId) {
+      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && currentTopoOrderRef.current === topoOrder && loadMoreRequestId.current === myId) {
         setLoadMoreError(String(e));
       }
     } finally {
-      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && loadMoreRequestId.current === myId) {
+      if (currentRepoRef.current === repoPath && currentScopeRef.current === scope && currentTopoOrderRef.current === topoOrder && loadMoreRequestId.current === myId) {
         setLoadingMore(false);
       }
     }
-  }, [repoPath, scope, loadingMore, hasMore]);
+  }, [repoPath, scope, topoOrder, loadingMore, hasMore]);
 
   return { commits, loading, loadingMore, loadMoreError, hasMore, error, pageSize: PAGE_SIZE, refresh, loadMore };
 }
diff --git a/src/types.ts b/src/types.ts
index d475359..9e5827c 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -26,23 +26,9 @@ export type OperationFeedbackContent = {
     message: string;
 };
 export type LinuxGraphicsMode = "Auto" | "Safe" | "Native";
-export type LinuxTerminalEmulator =
-    | "Auto"
-    | "Konsole"
-    | "GnomeTerminal"
-    | "GnomeConsole"
-    | "Xfce4Terminal"
-    | "MateTerminal"
-    | "Lxterminal"
-    | "Alacritty"
-    | "Ghostty"
-    | "Kitty"
-    | "WezTerm"
-    | "Foot"
-    | "Xterm"
-    | "Custom";
+export type LinuxTerminalId = string;
 export type LinuxTerminalOption = {
-    emulator: LinuxTerminalEmulator;
+    id: LinuxTerminalId;
     label: string;
 };
 export type RepoOpenBehaviour = "Ask" | "ExistingWindow" | "NewWindow";
@@ -102,7 +88,7 @@ export type Settings = {
     autoInstallUpdates: boolean;
     updateEndpoint: string;
     linuxGraphicsMode: LinuxGraphicsMode;
-    linuxTerminalEmulator: LinuxTerminalEmulator;
+    linuxTerminalEmulator: LinuxTerminalId;
     linuxTerminalCustomCommand: string;
     repoOpenBehaviour: RepoOpenBehaviour;
     gitExecutablePath: string;
@@ -265,6 +251,7 @@ export type CommitHistoryRequest = RepoRequest & {
     afterHash?: string;
     offset?: number;
     scope?: CommitLogScope;
+    topoOrder?: boolean;
 };
 
 export type CommitFilesRequest = RepoRequest & {
diff --git a/src/utils/commitGraph.test.ts b/src/utils/commitGraph.test.ts
index 64a6915..1a2b05b 100644
--- a/src/utils/commitGraph.test.ts
+++ b/src/utils/commitGraph.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { CommitHistoryItem } from "../types";
-import { buildCommitGraph } from "./commitGraph";
+import { buildCommitGraph, type CommitGraphSegment } from "./commitGraph";
 
 function commit(hash: string, parentHashes: string[] = []): CommitHistoryItem {
   return {
@@ -17,6 +17,119 @@ function commit(hash: string, parentHashes: string[] = []): CommitHistoryItem {
   };
 }
 
+function curves(segments: CommitGraphSegment[]) {
+  return segments.filter(segment => segment.kind === "curve");
+}
+
+function verticals(segments: CommitGraphSegment[]) {
+  return segments.filter(segment => segment.kind === "vertical");
+}
+
+function gitkComparisonCommits(): CommitHistoryItem[] {
+  return [
+    commit("m350000", ["trunk01", "branchA"]),
+    commit("trunk01", ["trunk02", "branchB"]),
+    commit("trunk02", ["trunk03"]),
+    commit("branchB", ["bot0001"]),
+    commit("branchA", ["msix001"]),
+    commit("trunk03", ["trunk04"]),
+    commit("bot0001", ["common1"]),
+    commit("msix001", ["common1"]),
+    commit("trunk04", ["trunk05"]),
+    commit("common1", ["trunk05"]),
+    commit("trunk05", ["main000"]),
+    commit("main000", ["base001", "side001"]),
+    commit("side001", ["dep0001"]),
+    commit("base001", ["base002"]),
+    commit("dep0001", ["base002"]),
+    commit("base002"),
+  ];
+}
+
+function allRefsComparisonCommits(): CommitHistoryItem[] {
+  return [
+    commit("b03f190", ["5adfc06"]),
+    commit("5adfc06", ["944b856", "46acab3"]),
+    commit("46acab3", ["8cad84d"]),
+    commit("8cad84d", ["240dc66"]),
+    commit("240dc66", ["14b4519"]),
+    commit("14b4519", ["107c01b"]),
+    commit("107c01b", ["5ad6049"]),
+    commit("5ad6049", ["91ff990", "b90460d"]),
+    commit("b90460d", ["c89ff95"]),
+    commit("c89ff95", ["774d89c"]),
+    commit("91ff990", ["774d89c"]),
+    commit("774d89c", ["73dd177"]),
+    commit("73dd177", ["2d2158d"]),
+    commit("2d2158d", ["944b856"]),
+    commit("944b856", ["5b9d95f"]),
+    commit("5b9d95f", ["74f5d91"]),
+    commit("74f5d91", ["4b16751"]),
+    commit("4b16751", ["be42942"]),
+    commit("be42942", ["440e90f", "935d400"]),
+    commit("440e90f", ["5469009", "9370356"]),
+    commit("9370356", ["2aefbe4"]),
+    commit("2aefbe4", ["9c25e0d"]),
+    commit("9c25e0d", ["80d675f"]),
+    commit("80d675f", ["220f7e3"]),
+    commit("220f7e3", ["5469009"]),
+    commit("5469009", ["4490dd8"]),
+    commit("4490dd8", ["38450bb"]),
+    commit("38450bb", ["b7055ec"]),
+    commit("b7055ec", ["59e3633", "36235d0"]),
+    commit("36235d0", ["43e51b3"]),
+    commit("43e51b3", ["4909592"]),
+    commit("4909592", ["ef2da30"]),
+    commit("ef2da30", ["72319d2"]),
+    commit("72319d2", ["82f749a"]),
+    commit("82f749a", ["0a60a51"]),
+    commit("0a60a51", ["2661559"]),
+    commit("2661559", ["1f838a5"]),
+    commit("1f838a5", ["59e3633"]),
+    commit("59e3633"),
+  ];
+}
+
+function segmentReachesBottom(
+  segment: CommitGraphSegment,
+  hash: string,
+  lane: number,
+  bottomUnit: number,
+): boolean {
+  if (segment.hash !== hash) return false;
+  if (segment.kind === "vertical") {
+    return segment.lane === lane && segment.toUnit === bottomUnit;
+  }
+  if (segment.kind === "curve") {
+    return segment.toLane === lane && segment.toUnit === bottomUnit;
+  }
+  return false;
+}
+
+function expectNoUnexplainedTopStarts(commits: CommitHistoryItem[]) {
+  const graph = buildCommitGraph(commits);
+
+  for (const [index, commit] of commits.entries()) {
+    const row = graph.rows[commit.hash];
+    const topVerticals = verticals(row.segments).filter(segment => segment.fromUnit === 0);
+    if (index === 0) {
+      expect(topVerticals).toEqual([]);
+      continue;
+    }
+
+    const previousCommit = commits[index - 1];
+    const previousRow = graph.rows[previousCommit.hash];
+    const previousBottom = previousRow.heightUnits * 100;
+    for (const segment of topVerticals) {
+      expect(
+        previousRow.segments.some(previousSegment => (
+          segmentReachesBottom(previousSegment, segment.hash, segment.lane, previousBottom)
+        )),
+      ).toBe(true);
+    }
+  }
+}
+
 describe("commit graph", () => {
   it("keeps linear history on one lane", () => {
     const graph = buildCommitGraph([
@@ -26,9 +139,17 @@ describe("commit graph", () => {
     ]);
 
     expect(graph.visibleLaneCount).toBe(1);
-    expect(graph.rows.c.commitLane).toBe(0);
-    expect(graph.rows.b.commitLane).toBe(0);
-    expect(graph.rows.a.commitLane).toBe(0);
+    expect(graph.rows.c.nodeLane).toBe(0);
+    expect(graph.rows.b.nodeLane).toBe(0);
+    expect(graph.rows.a.nodeLane).toBe(0);
+    expect(verticals(graph.rows.c.segments)).toContainEqual({
+      kind: "vertical",
+      lane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "b",
+      colourLane: 0,
+    });
   });
 
   it("adds a second lane for merge parents", () => {
@@ -40,8 +161,17 @@ describe("commit graph", () => {
     ]);
 
     expect(graph.visibleLaneCount).toBe(2);
-    expect(graph.rows.m.parentLanes.map(parent => parent.lane)).toEqual([0, 1]);
-    expect(graph.rows.b.commitLane).toBe(1);
+    expect(graph.rows.m.nodeLane).toBe(0);
+    expect(curves(graph.rows.m.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 0,
+      toLane: 1,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "b",
+      colourLane: 0,
+    });
+    expect(graph.rows.b.nodeLane).toBe(1);
   });
 
   it("keeps the first parent on the straight lane", () => {
@@ -52,12 +182,25 @@ describe("commit graph", () => {
       commit("base"),
     ]);
 
-    expect(graph.rows.m.parentLanes).toEqual([
-      { hash: "later", lane: 0 },
-      { hash: "next", lane: 1 },
-    ]);
-    expect(graph.rows.next.commitLane).toBe(1);
-    expect(graph.rows.later.commitLane).toBe(0);
+    expect(graph.rows.m.segments).toContainEqual({
+      kind: "vertical",
+      lane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "later",
+      colourLane: 0,
+    });
+    expect(curves(graph.rows.m.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 0,
+      toLane: 1,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "next",
+      colourLane: 0,
+    });
+    expect(graph.rows.next.nodeLane).toBe(1);
+    expect(graph.rows.later.nodeLane).toBe(0);
   });
 
   it("keeps the first parent straight when the second parent is listed next", () => {
@@ -68,12 +211,25 @@ describe("commit graph", () => {
       commit("main", ["base"]),
     ]);
 
-    expect(graph.rows.merge.parentLanes).toEqual([
-      { hash: "main", lane: 0 },
-      { hash: "feature-2", lane: 1 },
-    ]);
-    expect(graph.rows["feature-2"].commitLane).toBe(1);
-    expect(graph.rows.main.commitLane).toBe(0);
+    expect(graph.rows.merge.segments).toContainEqual({
+      kind: "vertical",
+      lane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "main",
+      colourLane: 0,
+    });
+    expect(curves(graph.rows.merge.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 0,
+      toLane: 1,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "feature-2",
+      colourLane: 0,
+    });
+    expect(graph.rows["feature-2"].nodeLane).toBe(1);
+    expect(graph.rows.main.nodeLane).toBe(0);
   });
 
   it("continues unloaded parents past the loaded page", () => {
@@ -81,22 +237,203 @@ describe("commit graph", () => {
       commit("head", ["parent-not-loaded"]),
     ]);
 
-    expect(graph.rows.head.bottomLanes).toEqual([
-      { hash: "parent-not-loaded", lane: 0 },
-    ]);
+    expect(graph.rows.head.segments).toContainEqual({
+      kind: "vertical",
+      lane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "parent-not-loaded",
+      colourLane: 0,
+    });
   });
 
-  it("tracks active parent source lanes when a side lane collapses", () => {
+  it("collapses an active first parent on the right into the node lane", () => {
     const graph = buildCommitGraph([
       commit("merge", ["feature", "side"]),
       commit("feature", ["side"]),
       commit("side", ["base"]),
     ]);
 
-    expect(graph.rows.feature.topLanes).toContainEqual({ hash: "side", lane: 1 });
-    expect(graph.rows.feature.parentLanes).toEqual([
-      { hash: "side", lane: 0, sourceLane: 1 },
+    expect(verticals(graph.rows.feature.segments)).toContainEqual({
+      kind: "vertical",
+      lane: 1,
+      fromUnit: 0,
+      toUnit: 50,
+      hash: "side",
+      colourLane: 1,
+    });
+    expect(curves(graph.rows.feature.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 1,
+      toLane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "side",
+      colourLane: 1,
+    });
+    expect(graph.rows.side.nodeLane).toBe(0);
+  });
+
+  it("introduces merge side parents beside the merge path", () => {
+    const graph = buildCommitGraph([
+      commit("after-merge", ["merge"]),
+      commit("unrelated-tip", ["unrelated-base"]),
+      commit("merge", ["main", "feature"]),
+      commit("main", ["base"]),
+      commit("feature", ["base"]),
+      commit("unrelated-base"),
+      commit("base"),
     ]);
+
+    expect(curves(graph.rows.merge.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 1,
+      toLane: 2,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "unrelated-base",
+      colourLane: 1,
+    });
+    expect(curves(graph.rows.merge.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 0,
+      toLane: 1,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "feature",
+      colourLane: 0,
+    });
+    const unrelatedMove = curves(graph.rows.merge.segments).find(segment => segment.hash === "unrelated-base");
+    expect(unrelatedMove?.colourLane).toBe(unrelatedMove?.fromLane);
+  });
+
+  it("keeps a gitk-like trunk with short side excursions", () => {
+    const graph = buildCommitGraph(gitkComparisonCommits());
+
+    expect([
+      graph.rows.m350000.nodeLane,
+      graph.rows.trunk01.nodeLane,
+      graph.rows.trunk02.nodeLane,
+      graph.rows.trunk03.nodeLane,
+      graph.rows.trunk04.nodeLane,
+      graph.rows.trunk05.nodeLane,
+      graph.rows.main000.nodeLane,
+    ]).toEqual([0, 0, 0, 0, 0, 0, 0]);
+
+    expect(graph.rows.branchB.nodeLane).toBe(1);
+    expect(graph.rows.bot0001.nodeLane).toBe(1);
+    expect(graph.rows.branchA.nodeLane).toBe(2);
+    expect(graph.rows.msix001.nodeLane).toBe(2);
+    expect(graph.rows.side001.nodeLane).toBe(1);
+    expect(graph.rows.dep0001.nodeLane).toBe(1);
+    expect(graph.rows.trunk05.laneCount).toBe(1);
+    expect(verticals(graph.rows.trunk05.segments).filter(segment => segment.lane > 0)).toEqual([]);
+
+    expect(curves(graph.rows.trunk01.segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 1,
+      toLane: 2,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "branchA",
+      colourLane: 1,
+    });
+    expect(verticals(graph.rows.trunk02.segments)).toContainEqual({
+      kind: "vertical",
+      lane: 2,
+      fromUnit: 0,
+      toUnit: 50,
+      hash: "branchA",
+      colourLane: 2,
+    });
+  });
+
+  it("collapses an already-active shared first parent back onto the trunk", () => {
+    const graph = buildCommitGraph([
+      commit("5ad6049", ["91ff990", "b90460d"]),
+      commit("b90460d", ["c89ff95"]),
+      commit("c89ff95", ["774d89c"]),
+      commit("91ff990", ["774d89c"]),
+      commit("774d89c", ["73dd177"]),
+      commit("73dd177"),
+    ]);
+
+    expect(graph.rows["91ff990"].nodeLane).toBe(0);
+    expect(graph.rows.b90460d.nodeLane).toBe(1);
+    expect(graph.rows.c89ff95.nodeLane).toBe(1);
+    expect(graph.rows["774d89c"].nodeLane).toBe(0);
+    expect(verticals(graph.rows["91ff990"].segments)).toContainEqual({
+      kind: "vertical",
+      lane: 1,
+      fromUnit: 0,
+      toUnit: 50,
+      hash: "774d89c",
+      colourLane: 1,
+    });
+    expect(curves(graph.rows["91ff990"].segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 1,
+      toLane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "774d89c",
+      colourLane: 1,
+    });
+  });
+
+  it("does not start visible rails without previous-row continuity", () => {
+    expectNoUnexplainedTopStarts(gitkComparisonCommits());
+    expectNoUnexplainedTopStarts(allRefsComparisonCommits());
+  });
+
+  it("does not move an active trunk right for a side branch parent", () => {
+    const graph = buildCommitGraph([
+      commit("merge", ["main", "feature-2"]),
+      commit("other-tip", ["other-base"]),
+      commit("feature-2", ["feature-1"]),
+      commit("feature-1", ["main"]),
+      commit("main", ["base"]),
+      commit("other-base"),
+      commit("base"),
+    ]);
+
+    expect(graph.rows["feature-1"].nodeLane).toBe(1);
+    expect(curves(graph.rows["feature-1"].segments)).toContainEqual({
+      kind: "curve",
+      fromLane: 1,
+      toLane: 0,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "main",
+      colourLane: 0,
+    });
+    expect(graph.rows.main.nodeLane).toBe(0);
+  });
+
+  it("keeps sibling merge parents continuous until their shared parent", () => {
+    const graph = buildCommitGraph([
+      commit("merge", ["left", "right"]),
+      commit("left", ["base"]),
+      commit("right", ["base"]),
+      commit("base"),
+    ]);
+
+    expect(verticals(graph.rows.left.segments)).toContainEqual({
+      kind: "vertical",
+      lane: 1,
+      fromUnit: 50,
+      toUnit: 100,
+      hash: "right",
+      colourLane: 1,
+    });
+    expect(verticals(graph.rows.right.segments)).toContainEqual({
+      kind: "vertical",
+      lane: 0,
+      fromUnit: 0,
+      toUnit: 50,
+      hash: "base",
+      colourLane: 0,
+    });
   });
 
   it("caps visible lane count", () => {
@@ -105,6 +442,9 @@ describe("commit graph", () => {
     ], 3);
 
     expect(graph.visibleLaneCount).toBe(3);
-    expect(graph.rows.wide.parentLanes.map(parent => parent.lane)).toEqual([0, 1, 2, 3]);
+    expect(graph.rows.wide.laneCount).toBe(4);
+    expect(graph.rows.wide.heightUnits).toBe(3);
+    expect(curves(graph.rows.wide.segments).map(segment => segment.toLane)).toEqual([1, 2, 3]);
+    expect(curves(graph.rows.wide.segments).map(segment => segment.toUnit)).toEqual([300, 300, 300]);
   });
 });
diff --git a/src/utils/commitGraph.ts b/src/utils/commitGraph.ts
index e821ab8..6ed8f55 100644
--- a/src/utils/commitGraph.ts
+++ b/src/utils/commitGraph.ts
@@ -1,20 +1,37 @@
 import type { CommitHistoryItem } from "../types";
 
-export type CommitGraphLane = {
-  lane: number;
-  hash: string;
-};
-
-export type CommitGraphParent = CommitGraphLane & {
-  sourceLane?: number;
-};
+export type CommitGraphSegment =
+  | {
+      kind: "vertical";
+      lane: number;
+      fromUnit: number;
+      toUnit: number;
+      hash: string;
+      colourLane: number;
+    }
+  | {
+      kind: "curve";
+      fromLane: number;
+      toLane: number;
+      fromUnit: number;
+      toUnit: number;
+      hash: string;
+      colourLane: number;
+    }
+  | {
+      kind: "node";
+      lane: number;
+      unit: number;
+      hash: string;
+      colourLane: number;
+    };
 
 export type CommitGraphRow = {
   hash: string;
-  commitLane: number;
-  topLanes: CommitGraphLane[];
-  bottomLanes: CommitGraphLane[];
-  parentLanes: CommitGraphParent[];
+  nodeLane: number;
+  laneCount: number;
+  heightUnits: number;
+  segments: CommitGraphSegment[];
 };
 
 export type CommitGraph = {
@@ -23,10 +40,11 @@ export type CommitGraph = {
 };
 
 const DEFAULT_MAX_VISIBLE_LANES = 10;
+const ROW_TOP = 0;
+const ROW_CENTRE = 50;
+const ROW_BOTTOM = 100;
 
-function laneItems(lanes: string[]): CommitGraphLane[] {
-  return lanes.map((hash, lane) => ({ hash, lane }));
-}
+type ActiveLane = string | null;
 
 function uniqueParents(parents: string[]): string[] {
   const seen = new Set<string>();
@@ -37,63 +55,192 @@ function uniqueParents(parents: string[]): string[] {
   });
 }
 
+function addVertical(
+  segments: CommitGraphSegment[],
+  lane: number,
+  fromUnit: number,
+  toUnit: number,
+  hash: string,
+  colourLane = lane,
+) {
+  if (fromUnit === toUnit) return;
+  segments.push({ kind: "vertical", lane, fromUnit, toUnit, hash, colourLane });
+}
+
+function addConnection(
+  segments: CommitGraphSegment[],
+  fromLane: number,
+  toLane: number,
+  fromUnit: number,
+  toUnit: number,
+  hash: string,
+  colourLane = fromLane,
+) {
+  if (fromLane === toLane) {
+    addVertical(segments, fromLane, fromUnit, toUnit, hash, colourLane);
+    return;
+  }
+  segments.push({ kind: "curve", fromLane, toLane, fromUnit, toUnit, hash, colourLane });
+}
+
+function placeHashInLane(lanes: ActiveLane[], hash: string, targetLane: number): number {
+  const currentLane = lanes.indexOf(hash);
+  if (currentLane !== -1) {
+    lanes[currentLane] = null;
+  }
+
+  while (lanes.length < targetLane) {
+    lanes.push(null);
+  }
+
+  if (targetLane === lanes.length || lanes[targetLane] === null) {
+    lanes[targetLane] = hash;
+    return targetLane;
+  }
+
+  lanes.splice(targetLane, 0, hash);
+  return targetLane;
+}
+
+function compactLanes(lanes: ActiveLane[]): ActiveLane[] {
+  return lanes.filter(hash => hash !== null);
+}
+
 export function buildCommitGraph(
   commits: CommitHistoryItem[],
   maxVisibleLanes = DEFAULT_MAX_VISIBLE_LANES,
 ): CommitGraph {
   const rows: Record<string, CommitGraphRow> = {};
-  let activeLanes: string[] = [];
+  let activeLanes: ActiveLane[] = [];
   let widestLane = 0;
 
   for (const commit of commits) {
-    let commitLane = activeLanes.indexOf(commit.hash);
-    const laneAlreadyActive = commitLane !== -1;
-    const activeLaneByHash = new Map(activeLanes.map((hash, lane) => [hash, lane]));
+    let nodeLane = activeLanes.indexOf(commit.hash);
+    const laneAlreadyActive = nodeLane !== -1;
+    const activeLaneByHash = new Map<string, number>();
+    for (const [lane, hash] of activeLanes.entries()) {
+      if (hash !== null) {
+        activeLaneByHash.set(hash, lane);
+      }
+    }
 
     if (!laneAlreadyActive) {
-      commitLane = activeLanes.length;
+      nodeLane = activeLanes.length;
       activeLanes = [...activeLanes, commit.hash];
     }
 
-    const topLanes = laneItems(activeLanes).filter(lane => (
-      laneAlreadyActive || lane.lane !== commitLane
-    ));
     const nextLanes = [...activeLanes];
-    nextLanes.splice(commitLane, 1);
+    nextLanes[nodeLane] = null;
 
-    const parentLanes: CommitGraphParent[] = [];
     const parents = uniqueParents(commit.parentHashes);
+    const heightUnits = Math.max(1, parents.length - 1);
+    const rowBottom = heightUnits * ROW_BOTTOM;
+    const parentLaneByHash = new Map<string, number>();
+    let previousParentLane = Math.min(nodeLane, nextLanes.length);
     for (const [index, parent] of parents.entries()) {
-      let parentLane = nextLanes.indexOf(parent);
-      if (parentLane === -1) {
-        parentLane = index === 0 ? Math.min(commitLane, nextLanes.length) : nextLanes.length;
-        nextLanes.splice(parentLane, 0, parent);
+      const currentParentLane = nextLanes.indexOf(parent);
+      let parentLane = currentParentLane;
+      if (index === 0 && parentLane !== -1 && parentLane > nodeLane) {
+        parentLane = placeHashInLane(nextLanes, parent, nodeLane);
+      } else if (parentLane === -1) {
+        const targetLane = index === 0
+          ? nodeLane
+          : previousParentLane + 1;
+        parentLane = placeHashInLane(nextLanes, parent, targetLane);
+      }
+      previousParentLane = parentLane;
+      parentLaneByHash.set(parent, parentLane);
+    }
+    const compactedNextLanes = compactLanes(nextLanes);
+    nextLanes.splice(0, nextLanes.length, ...compactedNextLanes);
+    parentLaneByHash.clear();
+    for (const parent of parents) {
+      const parentLane = nextLanes.indexOf(parent);
+      if (parentLane !== -1) {
+        parentLaneByHash.set(parent, parentLane);
       }
+    }
+
+    const segments: CommitGraphSegment[] = [];
+    for (const [lane, hash] of activeLanes.entries()) {
+      if (hash === null) continue;
+      if (!laneAlreadyActive && lane === nodeLane) continue;
+      addVertical(segments, lane, ROW_TOP, ROW_CENTRE, hash);
+    }
+
+    const parentHashes = new Set(parentLaneByHash.keys());
+    const connectedBottomLaneKeys = new Set<string>();
+
+    for (const parent of parents) {
+      const parentLane = parentLaneByHash.get(parent);
+      if (parentLane === undefined) continue;
+
       const sourceLane = activeLaneByHash.get(parent);
-      parentLanes.push({
-        hash: parent,
-        lane: parentLane,
-        ...(sourceLane !== undefined && sourceLane !== parentLane ? { sourceLane } : {}),
-      });
+      if (sourceLane !== undefined && sourceLane !== parentLane) {
+        addConnection(segments, sourceLane, parentLane, ROW_CENTRE, rowBottom, parent);
+        connectedBottomLaneKeys.add(`${parentLane}:${parent}`);
+        if (parentLane !== nodeLane) {
+          addConnection(segments, nodeLane, parentLane, ROW_CENTRE, rowBottom, parent, parentLane);
+        }
+      } else if (sourceLane !== undefined && parentLane !== nodeLane) {
+        addConnection(segments, nodeLane, parentLane, ROW_CENTRE, rowBottom, parent, parentLane);
+        connectedBottomLaneKeys.add(`${parentLane}:${parent}`);
+      } else {
+        addConnection(segments, nodeLane, parentLane, ROW_CENTRE, rowBottom, parent);
+        connectedBottomLaneKeys.add(`${parentLane}:${parent}`);
+      }
+    }
+
+    const bottomLaneByHash = new Map<string, number>();
+    for (const [lane, hash] of nextLanes.entries()) {
+      if (hash !== null) {
+        bottomLaneByHash.set(hash, lane);
+      }
+    }
+    for (const [hash, sourceLane] of activeLaneByHash) {
+      if (hash === commit.hash || parentHashes.has(hash)) continue;
+      const targetLane = bottomLaneByHash.get(hash);
+      if (targetLane === undefined || targetLane === sourceLane) continue;
+      addConnection(segments, sourceLane, targetLane, ROW_CENTRE, rowBottom, hash);
+      connectedBottomLaneKeys.add(`${targetLane}:${hash}`);
+    }
+
+    for (const [lane, hash] of nextLanes.entries()) {
+      if (hash === null) continue;
+      if (connectedBottomLaneKeys.has(`${lane}:${hash}`)) continue;
+      addVertical(segments, lane, ROW_CENTRE, rowBottom, hash);
     }
 
-    const bottomLanes = laneItems(nextLanes);
-    widestLane = Math.max(
-      widestLane,
-      commitLane,
-      ...topLanes.map(lane => lane.lane),
-      ...bottomLanes.map(lane => lane.lane),
-      ...parentLanes.map(lane => lane.lane),
+    segments.push({
+      kind: "node",
+      lane: nodeLane,
+      unit: ROW_CENTRE,
+      hash: commit.hash,
+      colourLane: nodeLane,
+    });
+
+    const rowWidestLane = Math.max(
+      nodeLane,
+      ...activeLanes.map((_, lane) => lane),
+      ...nextLanes.map((_, lane) => lane),
+      ...segments.flatMap(segment => {
+        if (segment.kind === "curve") return [segment.fromLane, segment.toLane];
+        return [segment.lane];
+      }),
     );
+    widestLane = Math.max(widestLane, rowWidestLane);
 
     rows[commit.hash] = {
       hash: commit.hash,
-      commitLane,
-      topLanes,
-      bottomLanes,
-      parentLanes,
+      nodeLane,
+      laneCount: Math.max(1, rowWidestLane + 1),
+      heightUnits,
+      segments,
     };
 
+    while (nextLanes[nextLanes.length - 1] === null) {
+      nextLanes.pop();
+    }
     activeLanes = nextLanes;
   }