Version 1.0.0

Ignores differences in relocation targets. (Address, name, etc)

Resolves #34

.github/workflows/build.yaml

@@ -29,7 +29,7 @@ jobs:
       - name: Setup Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
-          components: rustfmt, clippy
+          components: clippy
       - name: Cargo check
         run: cargo check
       - name: Cargo clippy
@@ -97,15 +97,19 @@ jobs:
             target: x86_64-unknown-linux-gnu
             name: linux-x86_64
             packages: libgtk-3-dev
+            features: default
           - platform: windows-latest
             target: x86_64-pc-windows-msvc
             name: windows-x86_64
+            features: default
           - platform: macos-latest
             target: x86_64-apple-darwin
             name: macos-x86_64
+            features: default
           - platform: macos-latest
             target: aarch64-apple-darwin
             name: macos-arm64
+            features: default
       fail-fast: false
     runs-on: ${{ matrix.platform }}
     steps:
@@ -121,7 +125,7 @@ jobs:
         with:
           targets: ${{ matrix.target }}
       - name: Cargo build
-        run: cargo build --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }} --bin ${{ env.CARGO_BIN_NAME }}
+        run: cargo build --profile ${{ env.BUILD_PROFILE }} --target ${{ matrix.target }} --bin ${{ env.CARGO_BIN_NAME }} --features ${{ matrix.features }}
       - name: Upload artifacts
         uses: actions/upload-artifact@v3
         with:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "objdiff"
-version = "0.6.1"
+version = "1.0.0"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -19,53 +19,57 @@ lto = "thin"
 strip = "debuginfo"
 
 [features]
-default = []
+default = ["wgpu", "wsl"]
 wgpu = ["eframe/wgpu"]
 wsl = []
 
 [dependencies]
-anyhow = "1.0.75"
+anyhow = "1.0.79"
 byteorder = "1.5.0"
 bytes = "1.5.0"
 cfg-if = "1.0.0"
 const_format = "0.2.32"
 cwdemangle = "0.1.6"
 dirs = "5.0.1"
-eframe = { version = "0.23.0", features = ["persistence"] }
-egui = "0.23.0"
-egui_extras = "0.23.0"
-filetime = "0.2.22"
+eframe = { version = "0.25.0", features = ["persistence"] }
+egui = "0.25.0"
+egui_extras = "0.25.0"
+filetime = "0.2.23"
 flagset = "0.4.4"
-globset = { version = "0.4.13", features = ["serde1"] }
+float-ord = "0.3.2"
+font-kit = "0.12.0"
+gimli = { version = "0.28.1", default-features = false, features = ["read-all"] }
+globset = { version = "0.4.14", features = ["serde1"] }
 log = "0.4.20"
-memmap2 = "0.9.0"
+memmap2 = "0.9.3"
 notify = "6.1.1"
-object = { version = "0.32.1", features = ["read_core", "std", "elf"], default-features = false }
-png = "0.17.10"
+object = { version = "0.32.2", features = ["read_core", "std", "elf"], default-features = false }
+png = "0.17.11"
 pollster = "0.3.0"
 ppc750cl = { git = "https://github.com/encounter/ppc750cl", rev = "4a2bbbc6f84dcb76255ab6f3595a8d4a0ce96618" }
-rabbitizer = "1.8.0"
-rfd = { version = "0.12.1" } #, default-features = false, features = ['xdg-portal']
+rabbitizer = "1.8.1"
+rfd = { version = "0.13.0" } #, default-features = false, features = ['xdg-portal']
 ron = "0.8.1"
-semver = "1.0.20"
+semver = "1.0.21"
 serde = { version = "1", features = ["derive"] }
-serde_json = "1.0.108"
-serde_yaml = "0.9.27"
-similar = "2.3.0"
-tempfile = "3.8.1"
-thiserror = "1.0.50"
-time = { version = "0.3.30", features = ["formatting", "local-offset"] }
+serde_json = "1.0.111"
+serde_yaml = "0.9.30"
+shell-escape = "0.1.5"
+similar = "2.4.0"
+tempfile = "3.9.0"
+thiserror = "1.0.56"
+time = { version = "0.3.31", features = ["formatting", "local-offset"] }
 toml = "0.8.8"
 twox-hash = "1.6.3"
 
 # For Linux static binaries, use rustls
 [target.'cfg(target_os = "linux")'.dependencies]
-reqwest = { version = "0.11.22", default-features = false, features = ["blocking", "json", "rustls"] }
+reqwest = { version = "0.11.23", default-features = false, features = ["blocking", "json", "multipart", "rustls"] }
 self_update = { version = "0.39.0", default-features = false, features = ["rustls"] }
 
 # For all other platforms, use native TLS
 [target.'cfg(not(target_os = "linux"))'.dependencies]
-reqwest = "0.11.22"
+reqwest = { version = "0.11.23", default-features = false, features = ["blocking", "json", "multipart", "default-tls"] }
 self_update = "0.39.0"
 
 [target.'cfg(windows)'.dependencies]
@@ -88,5 +92,5 @@ console_error_panic_hook = "0.1.7"
 tracing-wasm = "0.2"
 
 [build-dependencies]
-anyhow = "1.0.75"
-vergen = { version = "8.2.6", features = ["build", "cargo", "git", "gitcl"] }
+anyhow = "1.0.79"
+vergen = { version = "8.3.1", features = ["build", "cargo", "git", "gitcl"] }

README.md

@@ -3,7 +3,15 @@
 [Build Status]: https://github.com/encounter/objdiff/actions/workflows/build.yaml/badge.svg
 [actions]: https://github.com/encounter/objdiff/actions
 
-A local diffing tool for decompilation projects.
+A local diffing tool for decompilation projects. Inspired by [decomp.me](https://decomp.me) and [asm-differ](https://github.com/simonlindholm/asm-differ).
+
+Features:
+- Compare entire object files: functions and data.
+- Built-in symbol demangling for C++.
+- Automatic rebuild on source file changes.
+- Project integration via [configuration file](#configuration).
+- Search and filter all of a project's objects and quickly switch.
+- Click to highlight all instances of values and registers.
 
 Supports:
 - PowerPC 750CL (GameCube & Wii)
@@ -118,7 +126,17 @@ If not specified, objdiff will use the default patterns listed above.
 > `reverse_fn_order` _(optional)_: Displays function symbols in reversed order.  
 Used to support MWCC's `-inline deferred` option, which reverses the order of functions in the object file.
 
+## Building
 
+Install Rust via [rustup](https://rustup.rs).
+
+```shell
+$ git clone https://github.com/encounter/objdiff.git
+$ cd objdiff
+$ cargo run --release
+# or, for wgpu backend (recommended on macOS)
+$ cargo run --release --features wgpu
+```
 
 ## License
 

src/app.rs

@@ -16,7 +16,7 @@ use time::UtcOffset;
 
 use crate::{
     app_config::{deserialize_config, AppConfigVersion},
-    config::{build_globset, load_project_config, ProjectObject, ProjectObjectNode},
+    config::{build_globset, load_project_config, ProjectObject, ProjectObjectNode, ScratchConfig},
     diff::DiffAlg,
     jobs::{
         objdiff::{start_build, ObjDiffConfig},
@@ -25,7 +25,8 @@ use crate::{
     views::{
         appearance::{appearance_window, Appearance},
         config::{
-            config_ui, diff_options_window, project_window, ConfigViewState, DEFAULT_WATCH_PATTERNS,
+            config_ui, diff_options_window, project_window, ConfigViewState, CONFIG_DISABLED_TEXT,
+            DEFAULT_WATCH_PATTERNS,
         },
         data_diff::data_diff_ui,
         debug::debug_window,
@@ -59,6 +60,7 @@ pub struct ObjectConfig {
     pub base_path: Option<PathBuf>,
     pub reverse_fn_order: Option<bool>,
     pub complete: Option<bool>,
+    pub scratch: Option<ScratchConfig>,
 }
 
 #[derive(Clone, Eq, PartialEq)]
@@ -109,6 +111,8 @@ pub struct AppConfig {
     pub code_alg: DiffAlg,
     #[serde(default)]
     pub data_alg: DiffAlg,
+    #[serde(default)]
+    pub relax_reloc_diffs: bool,
 
     #[serde(skip)]
     pub objects: Vec<ProjectObject>,
@@ -125,6 +129,8 @@ pub struct AppConfig {
     #[serde(skip)]
     pub queue_reload: bool,
     #[serde(skip)]
+    pub queue_scratch: bool,
+    #[serde(skip)]
     pub project_config_info: Option<ProjectConfigInfo>,
 }
 
@@ -146,6 +152,7 @@ impl Default for AppConfig {
             recent_projects: vec![],
             code_alg: Default::default(),
             data_alg: Default::default(),
+            relax_reloc_diffs: false,
             objects: vec![],
             object_nodes: vec![],
             watcher_change: false,
@@ -153,6 +160,7 @@ impl Default for AppConfig {
             obj_change: false,
             queue_build: false,
             queue_reload: false,
+            queue_scratch: false,
             project_config_info: None,
         }
     }
@@ -223,9 +231,6 @@ impl App {
         utc_offset: UtcOffset,
         relaunch_path: Rc<Mutex<Option<PathBuf>>>,
     ) -> Self {
-        // This is also where you can customized the look at feel of egui using
-        // `cc.egui_ctx.set_visuals` and `cc.egui_ctx.set_fonts`.
-
         // Load previous app state (if any).
         // Note that you must enable the `persistence` feature for this to work.
         let mut app = Self::default();
@@ -245,12 +250,15 @@ impl App {
                 app.config = Arc::new(RwLock::new(config));
             }
         }
+        app.appearance.init_fonts(&cc.egui_ctx);
         app.appearance.utc_offset = utc_offset;
         app.relaunch_path = relaunch_path;
         app
     }
 
-    fn pre_update(&mut self) {
+    fn pre_update(&mut self, ctx: &egui::Context) {
+        self.appearance.pre_update(ctx);
+
         let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
 
         let mut results = vec![];
@@ -306,9 +314,11 @@ impl App {
     }
 
     fn post_update(&mut self, ctx: &egui::Context) {
+        self.appearance.post_update(ctx);
+
         let ViewState { jobs, diff_state, config_state, .. } = &mut self.view_state;
         config_state.post_update(ctx, jobs, &self.config);
-        diff_state.post_update(&self.config);
+        diff_state.post_update(ctx, jobs, &self.config);
 
         let Ok(mut config) = self.config.write() else {
             return;
@@ -396,15 +406,13 @@ impl eframe::App for App {
     /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         if self.should_relaunch {
-            frame.close();
+            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
             return;
         }
 
-        self.pre_update();
+        self.pre_update(ctx);
 
         let Self { config, appearance, view_state, .. } = self;
-        ctx.set_style(appearance.apply(ctx.style().as_ref()));
-
         let ViewState {
             jobs,
             config_state,
@@ -458,7 +466,7 @@ impl eframe::App for App {
                         ui.close_menu();
                     }
                     if ui.button("Quit").clicked() {
-                        frame.close();
+                        ctx.send_viewport_cmd(egui::ViewportCommand::Close);
                     }
                 });
                 ui.menu_button("Tools", |ui| {
@@ -486,13 +494,20 @@ impl eframe::App for App {
                             "Reverse function order (-inline deferred)",
                         ),
                     )
-                    .on_disabled_hover_text(
-                        "Option disabled because it's set by the project configuration file.",
-                    );
+                    .on_disabled_hover_text(CONFIG_DISABLED_TEXT);
                     ui.checkbox(
                         &mut diff_state.symbol_state.show_hidden_symbols,
                         "Show hidden symbols",
                     );
+                    if ui
+                        .checkbox(&mut config.relax_reloc_diffs, "Relax relocation diffs")
+                        .on_hover_text(
+                            "Ignores differences in relocation targets. (Address, name, etc)",
+                        )
+                        .changed()
+                    {
+                        config.queue_reload = true;
+                    }
                 });
             });
         });

src/app_config.rs

@@ -60,6 +60,7 @@ impl ObjectConfigV0 {
             base_path: Some(self.base_path),
             reverse_fn_order: self.reverse_fn_order,
             complete: None,
+            scratch: None,
         }
     }
 }

src/config.rs

@@ -50,6 +50,22 @@ pub struct ProjectObject {
     pub reverse_fn_order: Option<bool>,
     #[serde(default)]
     pub complete: Option<bool>,
+    #[serde(default)]
+    pub scratch: Option<ScratchConfig>,
+}
+
+#[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+pub struct ScratchConfig {
+    #[serde(default)]
+    pub platform: Option<String>,
+    #[serde(default)]
+    pub compiler: Option<String>,
+    #[serde(default)]
+    pub c_flags: Option<String>,
+    #[serde(default)]
+    pub ctx_path: Option<PathBuf>,
+    #[serde(default)]
+    pub build_ctx: bool,
 }
 
 impl ProjectObject {
@@ -66,7 +82,7 @@ impl ProjectObject {
 
 #[derive(Clone)]
 pub enum ProjectObjectNode {
-    File(String, ProjectObject),
+    File(String, Box<ProjectObject>),
     Dir(String, Vec<ProjectObjectNode>),
 }
 
@@ -114,7 +130,7 @@ fn build_nodes(
                 }
             }
         }
-        let mut object = object.clone();
+        let mut object = Box::new(object.clone());
         if let (Some(target_obj_dir), Some(path), None) =
             (target_obj_dir, &object.path, &object.target_path)
         {

src/diff/code.rs

@@ -10,7 +10,7 @@ use similar::{capture_diff_slices_deadline, Algorithm};
 use crate::{
     diff::{
         editops::{editops_find, LevEditType},
-        DiffAlg, ProcessCodeResult,
+        DiffAlg, DiffObjConfig, ProcessCodeResult,
     },
     obj::{
         mips, ppc, ObjArchitecture, ObjInfo, ObjInsArg, ObjInsArgDiff, ObjInsBranchFrom,
@@ -23,7 +23,7 @@ pub fn no_diff_code(
     data: &[u8],
     symbol: &mut ObjSymbol,
     relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
+    line_info: &Option<BTreeMap<u64, u64>>,
 ) -> Result<()> {
     let code =
         &data[symbol.section_address as usize..(symbol.section_address + symbol.size) as usize];
@@ -49,7 +49,7 @@ pub fn no_diff_code(
 
 #[allow(clippy::too_many_arguments)]
 pub fn diff_code(
-    alg: DiffAlg,
+    config: &DiffObjConfig,
     arch: ObjArchitecture,
     left_data: &[u8],
     right_data: &[u8],
@@ -57,8 +57,8 @@ pub fn diff_code(
     right_symbol: &mut ObjSymbol,
     left_relocs: &[ObjReloc],
     right_relocs: &[ObjReloc],
-    left_line_info: &Option<BTreeMap<u32, u32>>,
-    right_line_info: &Option<BTreeMap<u32, u32>>,
+    left_line_info: &Option<BTreeMap<u64, u64>>,
+    right_line_info: &Option<BTreeMap<u64, u64>>,
 ) -> Result<()> {
     let left_code = &left_data[left_symbol.section_address as usize
         ..(left_symbol.section_address + left_symbol.size) as usize];
@@ -89,7 +89,7 @@ pub fn diff_code(
 
     let mut left_diff = Vec::<ObjInsDiff>::new();
     let mut right_diff = Vec::<ObjInsDiff>::new();
-    match alg {
+    match config.code_alg {
         DiffAlg::Levenshtein => {
             diff_instructions_lev(
                 &mut left_diff,
@@ -134,7 +134,7 @@ pub fn diff_code(
 
     let mut diff_state = InsDiffState::default();
     for (left, right) in left_diff.iter_mut().zip(right_diff.iter_mut()) {
-        let result = compare_ins(left, right, &mut diff_state)?;
+        let result = compare_ins(config, left, right, &mut diff_state)?;
         left.kind = result.kind;
         right.kind = result.kind;
         left.arg_diff = result.left_args_diff;
@@ -322,13 +322,20 @@ fn address_eq(left: &ObjSymbol, right: &ObjSymbol) -> bool {
     left.address as i64 + left.addend == right.address as i64 + right.addend
 }
 
-fn reloc_eq(left_reloc: Option<&ObjReloc>, right_reloc: Option<&ObjReloc>) -> bool {
+fn reloc_eq(
+    config: &DiffObjConfig,
+    left_reloc: Option<&ObjReloc>,
+    right_reloc: Option<&ObjReloc>,
+) -> bool {
     let (Some(left), Some(right)) = (left_reloc, right_reloc) else {
         return false;
     };
     if left.kind != right.kind {
         return false;
     }
+    if config.relax_reloc_diffs {
+        return true;
+    }
 
     let name_matches = left.target.name == right.target.name;
     match (&left.target_section, &right.target_section) {
@@ -346,6 +353,7 @@ fn reloc_eq(left_reloc: Option<&ObjReloc>, right_reloc: Option<&ObjReloc>) -> bo
 }
 
 fn arg_eq(
+    config: &DiffObjConfig,
     left: &ObjInsArg,
     right: &ObjInsArg,
     left_diff: &ObjInsDiff,
@@ -359,6 +367,7 @@ fn arg_eq(
         ObjInsArg::Reloc => {
             matches!(right, ObjInsArg::Reloc)
                 && reloc_eq(
+                    config,
                     left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                     right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                 )
@@ -366,6 +375,7 @@ fn arg_eq(
         ObjInsArg::RelocWithBase => {
             matches!(right, ObjInsArg::RelocWithBase)
                 && reloc_eq(
+                    config,
                     left_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                     right_diff.ins.as_ref().and_then(|i| i.reloc.as_ref()),
                 )
@@ -398,6 +408,7 @@ struct InsDiffResult {
 }
 
 fn compare_ins(
+    config: &DiffObjConfig,
     left: &ObjInsDiff,
     right: &ObjInsDiff,
     state: &mut InsDiffState,
@@ -416,7 +427,7 @@ fn compare_ins(
             state.diff_count += 1;
         }
         for (a, b) in left_ins.args.iter().zip(&right_ins.args) {
-            if arg_eq(a, b, left, right) {
+            if arg_eq(config, a, b, left, right) {
                 result.left_args_diff.push(None);
                 result.right_args_diff.push(None);
             } else {

src/diff/mod.rs

@@ -25,6 +25,7 @@ pub enum DiffAlg {
 pub struct DiffObjConfig {
     pub code_alg: DiffAlg,
     pub data_alg: DiffAlg,
+    pub relax_reloc_diffs: bool,
 }
 
 pub struct ProcessCodeResult {
@@ -51,7 +52,7 @@ pub fn diff_objs(
                         left_symbol.diff_symbol = Some(right_symbol.name.clone());
                         right_symbol.diff_symbol = Some(left_symbol.name.clone());
                         diff_code(
-                            config.code_alg,
+                            config,
                             left.architecture,
                             &left_section.data,
                             &right_section.data,

src/fonts/matching.rs

@@ -0,0 +1,146 @@
+// font-kit/src/matching.rs
+//
+// Copyright © 2018 The Pathfinder Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Determines the closest font matching a description per the CSS Fonts Level 3 specification.
+
+use float_ord::FloatOrd;
+use font_kit::{
+    error::SelectionError,
+    properties::{Properties, Stretch, Style, Weight},
+};
+
+/// This follows CSS Fonts Level 3 § 5.2 [1].
+///
+/// https://drafts.csswg.org/css-fonts-3/#font-style-matching
+pub fn find_best_match(
+    candidates: &[Properties],
+    query: &Properties,
+) -> Result<usize, SelectionError> {
+    // Step 4.
+    let mut matching_set: Vec<usize> = (0..candidates.len()).collect();
+    if matching_set.is_empty() {
+        return Err(SelectionError::NotFound);
+    }
+
+    // Step 4a (`font-stretch`).
+    let matching_stretch = if matching_set
+        .iter()
+        .any(|&index| candidates[index].stretch == query.stretch)
+    {
+        // Exact match.
+        query.stretch
+    } else if query.stretch <= Stretch::NORMAL {
+        // Closest width, first checking narrower values and then wider values.
+        match matching_set
+            .iter()
+            .filter(|&&index| candidates[index].stretch < query.stretch)
+            .min_by_key(|&&index| FloatOrd(query.stretch.0 - candidates[index].stretch.0))
+        {
+            Some(&matching_index) => candidates[matching_index].stretch,
+            None => {
+                let matching_index = *matching_set
+                    .iter()
+                    .min_by_key(|&&index| FloatOrd(candidates[index].stretch.0 - query.stretch.0))
+                    .unwrap();
+                candidates[matching_index].stretch
+            }
+        }
+    } else {
+        // Closest width, first checking wider values and then narrower values.
+        match matching_set
+            .iter()
+            .filter(|&&index| candidates[index].stretch > query.stretch)
+            .min_by_key(|&&index| FloatOrd(candidates[index].stretch.0 - query.stretch.0))
+        {
+            Some(&matching_index) => candidates[matching_index].stretch,
+            None => {
+                let matching_index = *matching_set
+                    .iter()
+                    .min_by_key(|&&index| FloatOrd(query.stretch.0 - candidates[index].stretch.0))
+                    .unwrap();
+                candidates[matching_index].stretch
+            }
+        }
+    };
+    matching_set.retain(|&index| candidates[index].stretch == matching_stretch);
+
+    // Step 4b (`font-style`).
+    let style_preference = match query.style {
+        Style::Italic => [Style::Italic, Style::Oblique, Style::Normal],
+        Style::Oblique => [Style::Oblique, Style::Italic, Style::Normal],
+        Style::Normal => [Style::Normal, Style::Oblique, Style::Italic],
+    };
+    let matching_style = *style_preference
+        .iter()
+        .find(|&query_style| {
+            matching_set.iter().any(|&index| candidates[index].style == *query_style)
+        })
+        .unwrap();
+    matching_set.retain(|&index| candidates[index].style == matching_style);
+
+    // Step 4c (`font-weight`).
+    //
+    // The spec doesn't say what to do if the weight is between 400 and 500 exclusive, so we
+    // just use 450 as the cutoff.
+    let matching_weight =
+        if matching_set.iter().any(|&index| candidates[index].weight == query.weight) {
+            query.weight
+        } else if query.weight >= Weight(400.0)
+            && query.weight < Weight(450.0)
+            && matching_set.iter().any(|&index| candidates[index].weight == Weight(500.0))
+        {
+            // Check 500 first.
+            Weight(500.0)
+        } else if query.weight >= Weight(450.0)
+            && query.weight <= Weight(500.0)
+            && matching_set.iter().any(|&index| candidates[index].weight == Weight(400.0))
+        {
+            // Check 400 first.
+            Weight(400.0)
+        } else if query.weight <= Weight(500.0) {
+            // Closest weight, first checking thinner values and then fatter ones.
+            match matching_set
+                .iter()
+                .filter(|&&index| candidates[index].weight <= query.weight)
+                .min_by_key(|&&index| FloatOrd(query.weight.0 - candidates[index].weight.0))
+            {
+                Some(&matching_index) => candidates[matching_index].weight,
+                None => {
+                    let matching_index = *matching_set
+                        .iter()
+                        .min_by_key(|&&index| FloatOrd(candidates[index].weight.0 - query.weight.0))
+                        .unwrap();
+                    candidates[matching_index].weight
+                }
+            }
+        } else {
+            // Closest weight, first checking fatter values and then thinner ones.
+            match matching_set
+                .iter()
+                .filter(|&&index| candidates[index].weight >= query.weight)
+                .min_by_key(|&&index| FloatOrd(candidates[index].weight.0 - query.weight.0))
+            {
+                Some(&matching_index) => candidates[matching_index].weight,
+                None => {
+                    let matching_index = *matching_set
+                        .iter()
+                        .min_by_key(|&&index| FloatOrd(query.weight.0 - candidates[index].weight.0))
+                        .unwrap();
+                    candidates[matching_index].weight
+                }
+            }
+        };
+    matching_set.retain(|&index| candidates[index].weight == matching_weight);
+
+    // Step 4d concerns `font-size`, but fonts in `font-kit` are unsized, so we ignore that.
+
+    // Return the result.
+    matching_set.into_iter().next().ok_or(SelectionError::NotFound)
+}

src/fonts/mod.rs

@@ -0,0 +1,104 @@
+pub mod matching;
+
+use std::{borrow::Cow, fs, sync::Arc};
+
+use anyhow::{Context, Result};
+
+use crate::fonts::matching::find_best_match;
+
+pub struct LoadedFontFamily {
+    pub family_name: String,
+    pub fonts: Vec<font_kit::font::Font>,
+    pub handles: Vec<font_kit::handle::Handle>,
+    pub properties: Vec<font_kit::properties::Properties>,
+    pub default_index: usize,
+}
+
+pub struct LoadedFont {
+    pub font_name: String,
+    pub font_data: egui::FontData,
+}
+
+pub fn load_font_family(
+    source: &font_kit::source::SystemSource,
+    name: &str,
+) -> Option<LoadedFontFamily> {
+    let family_handle = source.select_family_by_name(name).ok()?;
+    if family_handle.fonts().is_empty() {
+        log::warn!("No fonts found for family '{}'", name);
+        return None;
+    }
+    let handles = family_handle.fonts().to_vec();
+    let mut loaded = Vec::with_capacity(handles.len());
+    for handle in handles.iter() {
+        match font_kit::loaders::default::Font::from_handle(handle) {
+            Ok(font) => loaded.push(font),
+            Err(err) => {
+                log::warn!("Failed to load font '{}': {}", name, err);
+                return None;
+            }
+        }
+    }
+    let properties = loaded.iter().map(|f| f.properties()).collect::<Vec<_>>();
+    let default_index =
+        find_best_match(&properties, &font_kit::properties::Properties::new()).unwrap_or(0);
+    let font_family_name =
+        loaded.first().map(|f| f.family_name()).unwrap_or_else(|| name.to_string());
+    Some(LoadedFontFamily {
+        family_name: font_family_name,
+        fonts: loaded,
+        handles,
+        properties,
+        default_index,
+    })
+}
+
+pub fn load_font(handle: &font_kit::handle::Handle) -> Result<LoadedFont> {
+    let loaded = font_kit::loaders::default::Font::from_handle(handle)?;
+    let data = match handle {
+        font_kit::handle::Handle::Memory { bytes, font_index } => egui::FontData {
+            font: Cow::Owned(bytes.to_vec()),
+            index: *font_index,
+            tweak: Default::default(),
+        },
+        font_kit::handle::Handle::Path { path, font_index } => {
+            let vec = fs::read(path).with_context(|| {
+                format!("Failed to load font '{}' (index {})", path.display(), font_index)
+            })?;
+            egui::FontData { font: Cow::Owned(vec), index: *font_index, tweak: Default::default() }
+        }
+    };
+    Ok(LoadedFont { font_name: loaded.full_name(), font_data: data })
+}
+
+pub fn load_font_if_needed(
+    ctx: &egui::Context,
+    source: &font_kit::source::SystemSource,
+    font_id: &egui::FontId,
+    base_family: egui::FontFamily,
+    fonts: &mut egui::FontDefinitions,
+) -> Result<()> {
+    if fonts.families.contains_key(&font_id.family) {
+        return Ok(());
+    }
+    let family_name = match &font_id.family {
+        egui::FontFamily::Proportional | egui::FontFamily::Monospace => return Ok(()),
+        egui::FontFamily::Name(v) => v,
+    };
+    let family = load_font_family(source, family_name)
+        .with_context(|| format!("Failed to load font family '{}'", family_name))?;
+    let default_fonts = fonts.families.get(&base_family).cloned().unwrap_or_default();
+    // FIXME clean up
+    let default_font_ref = family.fonts.get(family.default_index).unwrap();
+    let default_font = family.handles.get(family.default_index).unwrap();
+    let default_font_data = load_font(default_font).unwrap();
+    log::info!("Loaded font family '{}'", family.family_name);
+    fonts.font_data.insert(default_font_ref.full_name(), default_font_data.font_data);
+    fonts
+        .families
+        .entry(egui::FontFamily::Name(Arc::from(family.family_name)))
+        .or_insert_with(|| default_fonts)
+        .insert(0, default_font_ref.full_name());
+    ctx.set_fonts(fonts.clone());
+    Ok(())
+}

src/jobs/create_scratch.rs

@@ -0,0 +1,135 @@
+use std::{fs, path::PathBuf, sync::mpsc::Receiver};
+
+use anyhow::{anyhow, bail, Context, Result};
+use const_format::formatcp;
+
+use crate::{
+    app::AppConfig,
+    jobs::{
+        objdiff::{run_make, BuildConfig, BuildStatus},
+        start_job, update_status, Job, JobContext, JobResult, JobState,
+    },
+};
+
+#[derive(Debug, Clone)]
+pub struct CreateScratchConfig {
+    pub build_config: BuildConfig,
+    pub context_path: Option<PathBuf>,
+    pub build_context: bool,
+
+    // Scratch fields
+    pub compiler: String,
+    pub platform: String,
+    pub compiler_flags: String,
+    pub function_name: String,
+    pub target_obj: PathBuf,
+}
+
+impl CreateScratchConfig {
+    pub(crate) fn from_config(config: &AppConfig, function_name: String) -> Result<Self> {
+        let Some(selected_obj) = &config.selected_obj else {
+            bail!("No object selected");
+        };
+        let Some(target_path) = &selected_obj.target_path else {
+            bail!("No target path for {}", selected_obj.name);
+        };
+        let Some(scratch_config) = &selected_obj.scratch else {
+            bail!("No scratch configuration for {}", selected_obj.name);
+        };
+        Ok(Self {
+            build_config: BuildConfig::from_config(config),
+            context_path: scratch_config.ctx_path.clone(),
+            build_context: scratch_config.build_ctx,
+            compiler: scratch_config.compiler.clone().unwrap_or_default(),
+            platform: scratch_config.platform.clone().unwrap_or_default(),
+            compiler_flags: scratch_config.c_flags.clone().unwrap_or_default(),
+            function_name,
+            target_obj: target_path.to_path_buf(),
+        })
+    }
+
+    pub fn is_available(config: &AppConfig) -> bool {
+        let Some(selected_obj) = &config.selected_obj else {
+            return false;
+        };
+        selected_obj.target_path.is_some() && selected_obj.scratch.is_some()
+    }
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct CreateScratchResult {
+    pub scratch_url: String,
+}
+
+#[derive(Debug, Default, Clone, serde::Deserialize)]
+struct CreateScratchResponse {
+    pub slug: String,
+    pub claim_token: String,
+}
+
+const API_HOST: &str = "http://127.0.0.1:8000";
+const WEB_HOST: &str = "http://localhost:8080";
+
+fn run_create_scratch(
+    status: &JobContext,
+    cancel: Receiver<()>,
+    config: CreateScratchConfig,
+) -> Result<Box<CreateScratchResult>> {
+    let project_dir =
+        config.build_config.project_dir.as_ref().ok_or_else(|| anyhow!("Missing project dir"))?;
+
+    let mut context = None;
+    if let Some(context_path) = &config.context_path {
+        if config.build_context {
+            update_status(status, "Building context".to_string(), 0, 2, &cancel)?;
+            match run_make(&config.build_config, context_path) {
+                BuildStatus { success: true, .. } => {}
+                BuildStatus { success: false, stdout, stderr, .. } => {
+                    bail!("Failed to build context:\n{stdout}\n{stderr}")
+                }
+            }
+        }
+        let context_path = project_dir.join(context_path);
+        context = Some(
+            fs::read_to_string(&context_path)
+                .map_err(|e| anyhow!("Failed to read {}: {}", context_path.display(), e))?,
+        );
+    }
+
+    update_status(status, "Creating scratch".to_string(), 1, 2, &cancel)?;
+    let diff_flags = [format!("--disassemble={}", config.function_name)];
+    let diff_flags = serde_json::to_string(&diff_flags).unwrap();
+    let obj_path = project_dir.join(&config.target_obj);
+    let file = reqwest::blocking::multipart::Part::file(&obj_path)
+        .with_context(|| format!("Failed to open {}", obj_path.display()))?;
+    let form = reqwest::blocking::multipart::Form::new()
+        .text("compiler", config.compiler.clone())
+        .text("platform", config.platform.clone())
+        .text("compiler_flags", config.compiler_flags.clone())
+        .text("diff_label", config.function_name.clone())
+        .text("diff_flags", diff_flags)
+        .text("context", context.unwrap_or_default())
+        .text("source_code", "// Move related code from Context tab to here")
+        .part("target_obj", file);
+    let client = reqwest::blocking::Client::new();
+    let response = client
+        .post(formatcp!("{API_HOST}/api/scratch"))
+        .multipart(form)
+        .send()
+        .map_err(|e| anyhow!("Failed to send request: {}", e))?;
+    if !response.status().is_success() {
+        return Err(anyhow!("Failed to create scratch: {}", response.text()?));
+    }
+    let body: CreateScratchResponse = response.json().context("Failed to parse response")?;
+    let scratch_url = format!("{WEB_HOST}/scratch/{}/claim?token={}", body.slug, body.claim_token);
+
+    update_status(status, "Complete".to_string(), 2, 2, &cancel)?;
+    Ok(Box::from(CreateScratchResult { scratch_url }))
+}
+
+pub fn start_create_scratch(ctx: &egui::Context, config: CreateScratchConfig) -> JobState {
+    start_job(ctx, "Create scratch", Job::CreateScratch, move |context, cancel| {
+        run_create_scratch(&context, cancel, config)
+            .map(|result| JobResult::CreateScratch(Some(result)))
+    })
+}

src/jobs/mod.rs

@@ -9,9 +9,13 @@ use std::{
 
 use anyhow::Result;
 
-use crate::jobs::{check_update::CheckUpdateResult, objdiff::ObjDiffResult, update::UpdateResult};
+use crate::jobs::{
+    check_update::CheckUpdateResult, create_scratch::CreateScratchResult, objdiff::ObjDiffResult,
+    update::UpdateResult,
+};
 
 pub mod check_update;
+pub mod create_scratch;
 pub mod objdiff;
 pub mod update;
 
@@ -20,6 +24,7 @@ pub enum Job {
     ObjDiff,
     CheckUpdate,
     Update,
+    CreateScratch,
 }
 pub static JOB_ID: AtomicUsize = AtomicUsize::new(0);
 
@@ -119,6 +124,7 @@ pub enum JobResult {
     ObjDiff(Option<Box<ObjDiffResult>>),
     CheckUpdate(Option<Box<CheckUpdateResult>>),
     Update(Box<UpdateResult>),
+    CreateScratch(Option<Box<CreateScratchResult>>),
 }
 
 fn should_cancel(rx: &Receiver<()>) -> bool {

src/jobs/objdiff.rs

@@ -17,31 +17,59 @@ use crate::{
 
 pub struct BuildStatus {
     pub success: bool,
-    pub log: String,
+    pub cmdline: String,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+impl Default for BuildStatus {
+    fn default() -> Self {
+        BuildStatus {
+            success: true,
+            cmdline: String::new(),
+            stdout: String::new(),
+            stderr: String::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BuildConfig {
+    pub project_dir: Option<PathBuf>,
+    pub custom_make: Option<String>,
+    pub selected_wsl_distro: Option<String>,
+}
+
+impl BuildConfig {
+    pub(crate) fn from_config(config: &AppConfig) -> Self {
+        Self {
+            project_dir: config.project_dir.clone(),
+            custom_make: config.custom_make.clone(),
+            selected_wsl_distro: config.selected_wsl_distro.clone(),
+        }
+    }
 }
 
 pub struct ObjDiffConfig {
+    pub build_config: BuildConfig,
     pub build_base: bool,
     pub build_target: bool,
-    pub custom_make: Option<String>,
-    pub project_dir: Option<PathBuf>,
     pub selected_obj: Option<ObjectConfig>,
-    pub selected_wsl_distro: Option<String>,
     pub code_alg: DiffAlg,
     pub data_alg: DiffAlg,
+    pub relax_reloc_diffs: bool,
 }
 
 impl ObjDiffConfig {
     pub(crate) fn from_config(config: &AppConfig) -> Self {
-        ObjDiffConfig {
+        Self {
+            build_config: BuildConfig::from_config(config),
             build_base: config.build_base,
             build_target: config.build_target,
-            custom_make: config.custom_make.clone(),
-            project_dir: config.project_dir.clone(),
             selected_obj: config.selected_obj.clone(),
-            selected_wsl_distro: config.selected_wsl_distro.clone(),
             code_alg: config.code_alg,
             data_alg: config.data_alg,
+            relax_reloc_diffs: config.relax_reloc_diffs,
         }
     }
 }
@@ -54,7 +82,14 @@ pub struct ObjDiffResult {
     pub time: OffsetDateTime,
 }
 
-fn run_make(cwd: &Path, arg: &Path, config: &ObjDiffConfig) -> BuildStatus {
+pub(crate) fn run_make(config: &BuildConfig, arg: &Path) -> BuildStatus {
+    let Some(cwd) = &config.project_dir else {
+        return BuildStatus {
+            success: false,
+            stderr: "Missing project dir".to_string(),
+            ..Default::default()
+        };
+    };
     match (|| -> Result<BuildStatus> {
         let make = config.custom_make.as_deref().unwrap_or("make");
         #[cfg(not(windows))]
@@ -88,16 +123,24 @@ fn run_make(cwd: &Path, arg: &Path, config: &ObjDiffConfig) -> BuildStatus {
             command.creation_flags(winapi::um::winbase::CREATE_NO_WINDOW);
             command
         };
+        let mut cmdline =
+            shell_escape::escape(command.get_program().to_string_lossy()).into_owned();
+        for arg in command.get_args() {
+            cmdline.push(' ');
+            cmdline.push_str(shell_escape::escape(arg.to_string_lossy()).as_ref());
+        }
         let output = command.output().context("Failed to execute build")?;
         let stdout = from_utf8(&output.stdout).context("Failed to process stdout")?;
         let stderr = from_utf8(&output.stderr).context("Failed to process stderr")?;
         Ok(BuildStatus {
             success: output.status.code().unwrap_or(-1) == 0,
-            log: format!("{stdout}\n{stderr}"),
+            cmdline,
+            stdout: stdout.to_string(),
+            stderr: stderr.to_string(),
         })
     })() {
         Ok(status) => status,
-        Err(e) => BuildStatus { success: false, log: e.to_string() },
+        Err(e) => BuildStatus { success: false, stderr: e.to_string(), ..Default::default() },
     }
 }
 
@@ -107,8 +150,11 @@ fn run_build(
     config: ObjDiffConfig,
 ) -> Result<Box<ObjDiffResult>> {
     let obj_config = config.selected_obj.as_ref().ok_or_else(|| Error::msg("Missing obj path"))?;
-    let project_dir =
-        config.project_dir.as_ref().ok_or_else(|| Error::msg("Missing project dir"))?;
+    let project_dir = config
+        .build_config
+        .project_dir
+        .as_ref()
+        .ok_or_else(|| Error::msg("Missing project dir"))?;
     let target_path_rel = if let Some(target_path) = &obj_config.target_path {
         Some(target_path.strip_prefix(project_dir).map_err(|_| {
             anyhow!(
@@ -148,9 +194,9 @@ fn run_build(
                 total,
                 &cancel,
             )?;
-            run_make(project_dir, target_path_rel, &config)
+            run_make(&config.build_config, target_path_rel)
         }
-        _ => BuildStatus { success: true, log: String::new() },
+        _ => BuildStatus::default(),
     };
 
     let second_status = match base_path_rel {
@@ -162,9 +208,9 @@ fn run_build(
                 total,
                 &cancel,
             )?;
-            run_make(project_dir, base_path_rel, &config)
+            run_make(&config.build_config, base_path_rel)
         }
-        _ => BuildStatus { success: true, log: String::new() },
+        _ => BuildStatus::default(),
     };
 
     let time = OffsetDateTime::now_utc();
@@ -204,7 +250,11 @@ fn run_build(
     };
 
     update_status(context, "Performing diff".to_string(), 4, total, &cancel)?;
-    let diff_config = DiffObjConfig { code_alg: config.code_alg, data_alg: config.data_alg };
+    let diff_config = DiffObjConfig {
+        code_alg: config.code_alg,
+        data_alg: config.data_alg,
+        relax_reloc_diffs: config.relax_reloc_diffs,
+    };
     diff_objs(&diff_config, first_obj.as_mut(), second_obj.as_mut())?;
 
     update_status(context, "Complete".to_string(), total, total, &cancel)?;

src/lib.rs

@@ -6,6 +6,7 @@ mod app;
 mod app_config;
 mod config;
 mod diff;
+mod fonts;
 mod jobs;
 mod obj;
 mod update;

src/main.rs

@@ -1,14 +1,17 @@
 #![warn(clippy::all, rust_2018_idioms)]
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
 
-use std::{path::PathBuf, rc::Rc, sync::Mutex};
+use std::{
+    path::PathBuf,
+    rc::Rc,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::{Error, Result};
 use cfg_if::cfg_if;
-use eframe::IconData;
 use time::UtcOffset;
 
-fn load_icon() -> Result<IconData> {
+fn load_icon() -> Result<egui::IconData> {
     use bytes::Buf;
     let decoder = png::Decoder::new(include_bytes!("../assets/icon_64.png").reader());
     let mut reader = decoder.read_info()?;
@@ -21,7 +24,7 @@ fn load_icon() -> Result<IconData> {
         return Err(Error::msg("Invalid color type"));
     }
     buf.truncate(info.buffer_size());
-    Ok(IconData { rgba: buf, width: info.width, height: info.height })
+    Ok(egui::IconData { rgba: buf, width: info.width, height: info.height })
 }
 
 // When compiling natively:
@@ -41,7 +44,7 @@ fn main() {
         eframe::NativeOptions { follow_system_theme: false, ..Default::default() };
     match load_icon() {
         Ok(data) => {
-            native_options.icon_data = Some(data);
+            native_options.viewport.icon = Some(Arc::new(data));
         }
         Err(e) => {
             log::warn!("Failed to load application icon: {}", e);

src/obj/elf.rs

@@ -1,4 +1,4 @@
-use std::{collections::BTreeMap, fs, io::Cursor, path::Path};
+use std::{borrow::Cow, collections::BTreeMap, fs, io::Cursor, path::Path};
 
 use anyhow::{anyhow, bail, Context, Result};
 use byteorder::{BigEndian, ReadBytesExt};
@@ -6,8 +6,8 @@ use cwdemangle::demangle;
 use filetime::FileTime;
 use flagset::Flags;
 use object::{
-    elf, Architecture, File, Object, ObjectSection, ObjectSymbol, RelocationKind, RelocationTarget,
-    SectionIndex, SectionKind, Symbol, SymbolKind, SymbolScope, SymbolSection,
+    elf, Architecture, Endianness, File, Object, ObjectSection, ObjectSymbol, RelocationKind,
+    RelocationTarget, SectionIndex, SectionKind, Symbol, SymbolKind, SymbolScope, SymbolSection,
 };
 
 use crate::obj::{
@@ -278,7 +278,9 @@ fn relocations_by_section(
     Ok(relocations)
 }
 
-fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u32, u32>>> {
+fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u64, u64>>> {
+    // DWARF 1.1
+    let mut map = BTreeMap::new();
     if let Some(section) = obj_file.section_by_name(".line") {
         if section.size() == 0 {
             return Ok(None);
@@ -286,22 +288,49 @@ fn line_info(obj_file: &File<'_>) -> Result<Option<BTreeMap<u32, u32>>> {
         let data = section.uncompressed_data()?;
         let mut reader = Cursor::new(data.as_ref());
 
-        let mut map = BTreeMap::new();
         let size = reader.read_u32::<BigEndian>()?;
-        let base_address = reader.read_u32::<BigEndian>()?;
+        let base_address = reader.read_u32::<BigEndian>()? as u64;
         while reader.position() < size as u64 {
-            let line_number = reader.read_u32::<BigEndian>()?;
+            let line_number = reader.read_u32::<BigEndian>()? as u64;
             let statement_pos = reader.read_u16::<BigEndian>()?;
             if statement_pos != 0xFFFF {
                 log::warn!("Unhandled statement pos {}", statement_pos);
             }
-            let address_delta = reader.read_u32::<BigEndian>()?;
+            let address_delta = reader.read_u32::<BigEndian>()? as u64;
             map.insert(base_address + address_delta, line_number);
         }
-        // log::debug!("Line info: {map:#X?}");
-        return Ok(Some(map));
     }
-    Ok(None)
+
+    // DWARF 2+
+    let dwarf_cow = gimli::Dwarf::load(|id| {
+        Ok::<_, gimli::Error>(
+            obj_file
+                .section_by_name(id.name())
+                .and_then(|section| section.uncompressed_data().ok())
+                .unwrap_or(Cow::Borrowed(&[][..])),
+        )
+    })?;
+    let endian = match obj_file.endianness() {
+        Endianness::Little => gimli::RunTimeEndian::Little,
+        Endianness::Big => gimli::RunTimeEndian::Big,
+    };
+    let dwarf = dwarf_cow.borrow(|section| gimli::EndianSlice::new(section, endian));
+    let mut iter = dwarf.units();
+    while let Some(header) = iter.next()? {
+        let unit = dwarf.unit(header)?;
+        if let Some(program) = unit.line_program.clone() {
+            let mut rows = program.rows();
+            while let Some((_header, row)) = rows.next_row()? {
+                if let Some(line) = row.line() {
+                    map.insert(row.address(), line.get());
+                }
+            }
+        }
+    }
+    if map.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(map))
 }
 
 pub fn read(obj_path: &Path) -> Result<ObjInfo> {

src/obj/mips.rs

@@ -19,7 +19,7 @@ pub fn process_code(
     start_address: u64,
     end_address: u64,
     relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
+    line_info: &Option<BTreeMap<u64, u64>>,
 ) -> Result<ProcessCodeResult> {
     configure_rabbitizer();
 
@@ -83,8 +83,9 @@ pub fn process_code(
                 }
             }
         }
-        let line =
-            line_info.as_ref().and_then(|map| map.range(..=cur_addr).last().map(|(_, &b)| b));
+        let line = line_info
+            .as_ref()
+            .and_then(|map| map.range(..=cur_addr as u64).last().map(|(_, &b)| b));
         insts.push(ObjIns {
             address: cur_addr,
             code,

src/obj/mod.rs

@@ -61,6 +61,16 @@ impl ObjInsArg {
                         | (ppc750cl::Argument::Offset(off), ppc750cl::Argument::Simm(simm)) => {
                             simm.0 == off.0
                         }
+                        // Consider Uimm and Offset equivalent
+                        (ppc750cl::Argument::Uimm(uimm), ppc750cl::Argument::Offset(off))
+                        | (ppc750cl::Argument::Offset(off), ppc750cl::Argument::Uimm(uimm)) => {
+                            uimm.0 == off.0 as u16
+                        }
+                        // Consider Uimm and Simm equivalent
+                        (ppc750cl::Argument::Uimm(uimm), ppc750cl::Argument::Simm(simm))
+                        | (ppc750cl::Argument::Simm(simm), ppc750cl::Argument::Uimm(uimm)) => {
+                            uimm.0 == simm.0 as u16
+                        }
                         _ => false,
                     }
             }
@@ -113,7 +123,7 @@ pub struct ObjIns {
     pub reloc: Option<ObjReloc>,
     pub branch_dest: Option<u32>,
     /// Line info
-    pub line: Option<u32>,
+    pub line: Option<u64>,
     /// Original (unsimplified) instruction
     pub orig: Option<String>,
 }
@@ -172,7 +182,7 @@ pub struct ObjInfo {
     pub timestamp: FileTime,
     pub sections: Vec<ObjSection>,
     pub common: Vec<ObjSymbol>,
-    pub line_info: Option<BTreeMap<u32, u32>>,
+    pub line_info: Option<BTreeMap<u64, u64>>,
 }
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub enum ObjRelocKind {

src/obj/ppc.rs

@@ -24,7 +24,7 @@ pub fn process_code(
     data: &[u8],
     address: u64,
     relocs: &[ObjReloc],
-    line_info: &Option<BTreeMap<u32, u32>>,
+    line_info: &Option<BTreeMap<u64, u64>>,
 ) -> Result<ProcessCodeResult> {
     let ins_count = data.len() / 4;
     let mut ops = Vec::<u8>::with_capacity(ins_count);
@@ -82,7 +82,7 @@ pub fn process_code(
         ops.push(simplified.ins.op as u8);
         let line = line_info
             .as_ref()
-            .and_then(|map| map.range(..=simplified.ins.addr).last().map(|(_, &b)| b));
+            .and_then(|map| map.range(..=simplified.ins.addr as u64).last().map(|(_, &b)| b));
         insts.push(ObjIns {
             address: simplified.ins.addr,
             code: simplified.ins.code,

src/views/appearance.rs

@@ -1,6 +1,10 @@
-use egui::{Color32, FontFamily, FontId, TextStyle};
+use std::sync::Arc;
+
+use egui::{text::LayoutJob, Color32, FontFamily, FontId, TextStyle, Widget};
 use time::UtcOffset;
 
+use crate::fonts::load_font_if_needed;
+
 #[derive(serde::Deserialize, serde::Serialize)]
 #[serde(default)]
 pub struct Appearance {
@@ -28,13 +32,29 @@ pub struct Appearance {
     // Global
     #[serde(skip)]
     pub utc_offset: UtcOffset,
+    #[serde(skip)]
+    pub fonts: FontState,
+    #[serde(skip)]
+    pub next_ui_font: Option<FontId>,
+    #[serde(skip)]
+    pub next_code_font: Option<FontId>,
 }
 
+pub struct FontState {
+    definitions: egui::FontDefinitions,
+    source: font_kit::source::SystemSource,
+    family_names: Vec<String>,
+    // loaded_families: HashMap<String, LoadedFontFamily>,
+}
+
+const DEFAULT_UI_FONT: FontId = FontId { size: 12.0, family: FontFamily::Proportional };
+const DEFAULT_CODE_FONT: FontId = FontId { size: 14.0, family: FontFamily::Monospace };
+
 impl Default for Appearance {
     fn default() -> Self {
         Self {
-            ui_font: FontId { size: 12.0, family: FontFamily::Proportional },
-            code_font: FontId { size: 14.0, family: FontFamily::Monospace },
+            ui_font: DEFAULT_UI_FONT,
+            code_font: DEFAULT_CODE_FONT,
             diff_colors: DEFAULT_COLOR_ROTATION.to_vec(),
             theme: eframe::Theme::Dark,
             text_color: Color32::GRAY,
@@ -45,13 +65,27 @@ impl Default for Appearance {
             insert_color: Color32::GREEN,
             delete_color: Color32::from_rgb(200, 40, 41),
             utc_offset: UtcOffset::UTC,
+            fonts: FontState::default(),
+            next_ui_font: None,
+            next_code_font: None,
+        }
+    }
+}
+
+impl Default for FontState {
+    fn default() -> Self {
+        Self {
+            definitions: Default::default(),
+            source: font_kit::source::SystemSource::new(),
+            family_names: Default::default(),
+            // loaded_families: Default::default(),
         }
     }
 }
 
 impl Appearance {
-    pub fn apply(&mut self, style: &egui::Style) -> egui::Style {
-        let mut style = style.clone();
+    pub fn pre_update(&mut self, ctx: &egui::Context) {
+        let mut style = ctx.style().as_ref().clone();
         style.text_styles.insert(TextStyle::Body, FontId {
             size: (self.ui_font.size * 0.75).floor(),
             family: self.ui_font.family.clone(),
@@ -85,7 +119,71 @@ impl Appearance {
                 self.delete_color = Color32::from_rgb(200, 40, 41);
             }
         }
-        style
+        ctx.set_style(style);
+    }
+
+    pub fn post_update(&mut self, ctx: &egui::Context) {
+        // Load fonts for next frame
+        if let Some(next_ui_font) = self.next_ui_font.take() {
+            match load_font_if_needed(
+                ctx,
+                &self.fonts.source,
+                &next_ui_font,
+                DEFAULT_UI_FONT.family,
+                &mut self.fonts.definitions,
+            ) {
+                Ok(()) => self.ui_font = next_ui_font,
+                Err(e) => {
+                    log::error!("Failed to load font: {}", e)
+                }
+            }
+        }
+        if let Some(next_code_font) = self.next_code_font.take() {
+            match load_font_if_needed(
+                ctx,
+                &self.fonts.source,
+                &next_code_font,
+                DEFAULT_CODE_FONT.family,
+                &mut self.fonts.definitions,
+            ) {
+                Ok(()) => self.code_font = next_code_font,
+                Err(e) => {
+                    log::error!("Failed to load font: {}", e)
+                }
+            }
+        }
+    }
+
+    pub fn init_fonts(&mut self, ctx: &egui::Context) {
+        self.fonts.family_names = self.fonts.source.all_families().unwrap_or_default();
+        match load_font_if_needed(
+            ctx,
+            &self.fonts.source,
+            &self.ui_font,
+            DEFAULT_UI_FONT.family,
+            &mut self.fonts.definitions,
+        ) {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("Failed to load font: {}", e);
+                // Revert to default
+                self.ui_font = DEFAULT_UI_FONT;
+            }
+        }
+        match load_font_if_needed(
+            ctx,
+            &self.fonts.source,
+            &self.code_font,
+            DEFAULT_CODE_FONT.family,
+            &mut self.fonts.definitions,
+        ) {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("Failed to load font: {}", e);
+                // Revert to default
+                self.code_font = DEFAULT_CODE_FONT;
+            }
+        }
     }
 }
 
@@ -101,6 +199,65 @@ pub const DEFAULT_COLOR_ROTATION: [Color32; 9] = [
     Color32::from_rgb(213, 138, 138),
 ];
 
+fn font_id_ui(
+    ui: &mut egui::Ui,
+    label: &str,
+    mut font_id: FontId,
+    default: FontId,
+    appearance: &Appearance,
+) -> Option<FontId> {
+    ui.push_id(label, |ui| {
+        let font_size = font_id.size;
+        let label_job = LayoutJob::simple(
+            font_id.family.to_string(),
+            font_id.clone(),
+            appearance.text_color,
+            0.0,
+        );
+        let mut changed = ui
+            .horizontal(|ui| {
+                ui.label(label);
+                let mut changed = egui::Slider::new(&mut font_id.size, 4.0..=40.0)
+                    .max_decimals(1)
+                    .ui(ui)
+                    .changed();
+                if ui.button("Reset").clicked() {
+                    font_id = default;
+                    changed = true;
+                }
+                changed
+            })
+            .inner;
+        let family = &mut font_id.family;
+        changed |= egui::ComboBox::from_label("Font family")
+            .selected_text(label_job)
+            .width(font_size * 20.0)
+            .show_ui(ui, |ui| {
+                let mut result = false;
+                result |= ui
+                    .selectable_value(family, FontFamily::Proportional, "Proportional (built-in)")
+                    .changed();
+                result |= ui
+                    .selectable_value(family, FontFamily::Monospace, "Monospace (built-in)")
+                    .changed();
+                for family_name in &appearance.fonts.family_names {
+                    result |= ui
+                        .selectable_value(
+                            family,
+                            FontFamily::Name(Arc::from(family_name.as_str())),
+                            family_name,
+                        )
+                        .changed();
+                }
+                result
+            })
+            .inner
+            .unwrap_or(false);
+        changed.then_some(font_id)
+    })
+    .inner
+}
+
 pub fn appearance_window(ctx: &egui::Context, show: &mut bool, appearance: &mut Appearance) {
     egui::Window::new("Appearance").open(show).show(ctx, |ui| {
         egui::ComboBox::from_label("Theme")
@@ -109,11 +266,17 @@ pub fn appearance_window(ctx: &egui::Context, show: &mut bool, appearance: &mut
                 ui.selectable_value(&mut appearance.theme, eframe::Theme::Dark, "Dark");
                 ui.selectable_value(&mut appearance.theme, eframe::Theme::Light, "Light");
             });
-        ui.label("UI font:");
-        egui::introspection::font_id_ui(ui, &mut appearance.ui_font);
         ui.separator();
-        ui.label("Code font:");
-        egui::introspection::font_id_ui(ui, &mut appearance.code_font);
+        appearance.next_ui_font =
+            font_id_ui(ui, "UI font:", appearance.ui_font.clone(), DEFAULT_UI_FONT, appearance);
+        ui.separator();
+        appearance.next_code_font = font_id_ui(
+            ui,
+            "Code font:",
+            appearance.code_font.clone(),
+            DEFAULT_CODE_FONT,
+            appearance,
+        );
         ui.separator();
         ui.label("Diff colors:");
         if ui.button("Reset").clicked() {

src/views/config.rs

@@ -1,4 +1,4 @@
-#[cfg(feature = "wsl")]
+#[cfg(all(windows, feature = "wsl"))]
 use std::string::FromUtf16Error;
 use std::{
     borrow::Cow,
@@ -6,7 +6,7 @@ use std::{
     path::{PathBuf, MAIN_SEPARATOR},
 };
 
-#[cfg(feature = "wsl")]
+#[cfg(all(windows, feature = "wsl"))]
 use anyhow::{Context, Result};
 use const_format::formatcp;
 use egui::{
@@ -46,7 +46,7 @@ pub struct ConfigViewState {
     pub object_search: String,
     pub filter_diffable: bool,
     pub filter_incomplete: bool,
-    #[cfg(feature = "wsl")]
+    #[cfg(all(windows, feature = "wsl"))]
     pub available_wsl_distros: Option<Vec<String>>,
     pub file_dialog_state: FileDialogState,
 }
@@ -93,6 +93,7 @@ impl ConfigViewState {
                             base_path: Some(path),
                             reverse_fn_order: None,
                             complete: None,
+                            scratch: None,
                         });
                     } else if let Ok(obj_path) = path.strip_prefix(target_dir) {
                         let base_path = base_dir.join(obj_path);
@@ -102,6 +103,7 @@ impl ConfigViewState {
                             base_path: Some(base_path),
                             reverse_fn_order: None,
                             complete: None,
+                            scratch: None,
                         });
                     }
                 }
@@ -134,7 +136,7 @@ pub const DEFAULT_WATCH_PATTERNS: &[&str] = &[
     "*.inc", "*.py", "*.yml", "*.txt", "*.json",
 ];
 
-#[cfg(feature = "wsl")]
+#[cfg(all(windows, feature = "wsl"))]
 fn process_utf16(bytes: &[u8]) -> Result<String, FromUtf16Error> {
     let u16_bytes: Vec<u16> = bytes
         .chunks_exact(2)
@@ -143,7 +145,7 @@ fn process_utf16(bytes: &[u8]) -> Result<String, FromUtf16Error> {
     String::from_utf16(&u16_bytes)
 }
 
-#[cfg(feature = "wsl")]
+#[cfg(all(windows, feature = "wsl"))]
 fn wsl_cmd(args: &[&str]) -> Result<String> {
     use std::{os::windows::process::CommandExt, process::Command};
     let output = Command::new("wsl")
@@ -154,7 +156,7 @@ fn wsl_cmd(args: &[&str]) -> Result<String> {
     process_utf16(&output.stdout).context("Failed to process stdout")
 }
 
-#[cfg(feature = "wsl")]
+#[cfg(all(windows, feature = "wsl"))]
 fn fetch_wsl2_distros() -> Vec<String> {
     wsl_cmd(&["-l", "-q"])
         .map(|stdout| {
@@ -176,7 +178,6 @@ pub fn config_ui(
 ) {
     let mut config_guard = config.write().unwrap();
     let AppConfig {
-        selected_wsl_distro,
         target_obj_dir,
         base_obj_dir,
         selected_obj,
@@ -227,27 +228,6 @@ pub fn config_ui(
     }
     ui.separator();
 
-    #[cfg(feature = "wsl")]
-    {
-        ui.heading("Build");
-        if state.available_wsl_distros.is_none() {
-            state.available_wsl_distros = Some(fetch_wsl2_distros());
-        }
-        egui::ComboBox::from_label("Run in WSL2")
-            .selected_text(selected_wsl_distro.as_ref().unwrap_or(&"Disabled".to_string()))
-            .show_ui(ui, |ui| {
-                ui.selectable_value(selected_wsl_distro, None, "Disabled");
-                for distro in state.available_wsl_distros.as_ref().unwrap() {
-                    ui.selectable_value(selected_wsl_distro, Some(distro.clone()), distro);
-                }
-            });
-        ui.separator();
-    }
-    #[cfg(not(feature = "wsl"))]
-    {
-        let _ = selected_wsl_distro;
-    }
-
     ui.horizontal(|ui| {
         ui.heading("Project");
         if ui.button(RichText::new("Settings")).clicked() {
@@ -415,6 +395,7 @@ fn display_object(
             base_path: object.base_path.clone(),
             reverse_fn_order: object.reverse_fn_order,
             complete: object.complete,
+            scratch: object.scratch.clone(),
         });
     }
 }
@@ -540,6 +521,9 @@ fn format_path(path: &Option<PathBuf>, appearance: &Appearance) -> RichText {
     RichText::new(text).color(color).family(FontFamily::Monospace)
 }
 
+pub const CONFIG_DISABLED_TEXT: &str =
+    "Option disabled because it's set by the project configuration file.";
+
 fn pick_folder_ui(
     ui: &mut egui::Ui,
     dir: &Option<PathBuf>,
@@ -552,6 +536,7 @@ fn pick_folder_ui(
         subheading(ui, label, appearance);
         ui.link(HELP_ICON).on_hover_ui(tooltip);
         ui.add_enabled(enabled, egui::Button::new("Select"))
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
     });
     ui.label(format_path(dir, appearance));
     response.inner
@@ -642,13 +627,38 @@ fn split_obj_config_ui(
         });
     });
     let mut custom_make_str = config.custom_make.clone().unwrap_or_default();
-    if ui.text_edit_singleline(&mut custom_make_str).changed() {
+    if ui
+        .add_enabled(
+            config.project_config_info.is_none(),
+            egui::TextEdit::singleline(&mut custom_make_str),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .changed()
+    {
         if custom_make_str.is_empty() {
             config.custom_make = None;
         } else {
             config.custom_make = Some(custom_make_str);
         }
     }
+    #[cfg(all(windows, feature = "wsl"))]
+    {
+        if state.available_wsl_distros.is_none() {
+            state.available_wsl_distros = Some(fetch_wsl2_distros());
+        }
+        egui::ComboBox::from_label("Run in WSL2")
+            .selected_text(config.selected_wsl_distro.as_ref().unwrap_or(&"Disabled".to_string()))
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut config.selected_wsl_distro, None, "Disabled");
+                for distro in state.available_wsl_distros.as_ref().unwrap() {
+                    ui.selectable_value(
+                        &mut config.selected_wsl_distro,
+                        Some(distro.clone()),
+                        distro,
+                    );
+                }
+            });
+    }
     ui.separator();
 
     if let Some(project_dir) = config.project_dir.clone() {
@@ -679,7 +689,12 @@ fn split_obj_config_ui(
                 FileDialogResult::TargetDir,
             );
         }
-        ui.checkbox(&mut config.build_target, "Build target objects").on_hover_ui(|ui| {
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::Checkbox::new(&mut config.build_target, "Build target objects"),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .on_hover_ui(|ui| {
             let mut job = LayoutJob::default();
             job.append(
                 "Tells the build system to produce the target object.\n",
@@ -730,7 +745,12 @@ fn split_obj_config_ui(
                 FileDialogResult::BaseDir,
             );
         }
-        ui.checkbox(&mut config.build_base, "Build base objects").on_hover_ui(|ui| {
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::Checkbox::new(&mut config.build_base, "Build base objects"),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+        .on_hover_ui(|ui| {
             let mut job = LayoutJob::default();
             job.append(
                 "Tells the build system to produce the base object.\n",
@@ -773,7 +793,11 @@ fn split_obj_config_ui(
 
     ui.horizontal(|ui| {
         ui.label(RichText::new("File patterns").color(appearance.text_color));
-        if ui.button("Reset").clicked() {
+        if ui
+            .add_enabled(config.project_config_info.is_none(), egui::Button::new("Reset"))
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+            .clicked()
+        {
             config.watch_patterns =
                 DEFAULT_WATCH_PATTERNS.iter().map(|s| Glob::new(s).unwrap()).collect();
             config.watcher_change = true;
@@ -787,7 +811,11 @@ fn split_obj_config_ui(
                     .color(appearance.text_color)
                     .family(FontFamily::Monospace),
             );
-            if ui.small_button("-").clicked() {
+            if ui
+                .add_enabled(config.project_config_info.is_none(), egui::Button::new("-").small())
+                .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+                .clicked()
+            {
                 remove_at = Some(idx);
             }
         });
@@ -797,8 +825,16 @@ fn split_obj_config_ui(
         config.watcher_change = true;
     }
     ui.horizontal(|ui| {
-        egui::TextEdit::singleline(&mut state.watch_pattern_text).desired_width(100.0).show(ui);
-        if ui.small_button("+").clicked() {
+        ui.add_enabled(
+            config.project_config_info.is_none(),
+            egui::TextEdit::singleline(&mut state.watch_pattern_text).desired_width(100.0),
+        )
+        .on_disabled_hover_text(CONFIG_DISABLED_TEXT);
+        if ui
+            .add_enabled(config.project_config_info.is_none(), egui::Button::new("+").small())
+            .on_disabled_hover_text(CONFIG_DISABLED_TEXT)
+            .clicked()
+        {
             if let Ok(glob) = Glob::new(&state.watch_pattern_text) {
                 config.watch_patterns.push(glob);
                 config.watcher_change = true;

src/views/data_diff.rs

@@ -154,7 +154,8 @@ fn data_table_ui(
     let right_diffs = right_section.map(|section| split_diffs(&section.data_diff));
 
     table.body(|body| {
-        body.rows(config.code_font.size, total_rows, |row_index, mut row| {
+        body.rows(config.code_font.size, total_rows, |mut row| {
+            let row_index = row.index();
             let address = row_index * BYTES_PER_ROW;
             row.col(|ui| {
                 if let Some(left_diffs) = &left_diffs {
@@ -191,7 +192,7 @@ pub fn data_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance: &A
                 |ui| {
                     ui.set_width(column_width);
 
-                    if ui.button("Back").clicked() {
+                    if ui.button("⏴ Back").clicked() {
                         state.current_view = View::SymbolDiff;
                     }
 

src/views/function_diff.rs

@@ -4,8 +4,7 @@ use std::{
 };
 
 use cwdemangle::demangle;
-use eframe::emath::Align;
-use egui::{text::LayoutJob, Color32, Label, Layout, RichText, Sense, TextFormat, Vec2};
+use egui::{text::LayoutJob, Align, Color32, Label, Layout, RichText, Sense, TextFormat, Vec2};
 use egui_extras::{Column, TableBuilder, TableRow};
 use ppc750cl::Argument;
 use time::format_description;
@@ -538,7 +537,8 @@ fn asm_table_ui(
     let right_symbol = right_obj.and_then(|obj| find_symbol(obj, selected_symbol));
     let instructions_len = left_symbol.or(right_symbol).map(|s| s.instructions.len())?;
     table.body(|body| {
-        body.rows(appearance.code_font.size, instructions_len, |row_index, mut row| {
+        body.rows(appearance.code_font.size, instructions_len, |mut row| {
+            let row_index = row.index();
             if let Some(symbol) = left_symbol {
                 asm_col_ui(
                     &mut row,
@@ -586,9 +586,23 @@ pub fn function_diff_ui(ui: &mut egui::Ui, state: &mut DiffViewState, appearance
                 |ui| {
                     ui.set_width(column_width);
 
-                    if ui.button("Back").clicked() {
-                        state.current_view = View::SymbolDiff;
-                    }
+                    ui.horizontal(|ui| {
+                        if ui.button("⏴ Back").clicked() {
+                            state.current_view = View::SymbolDiff;
+                        }
+                        ui.separator();
+                        if ui
+                            .add_enabled(
+                                !state.scratch_running && state.scratch_available,
+                                egui::Button::new("📲 decomp.me"),
+                            )
+                            .on_hover_text_at_pointer("Create a new scratch on decomp.me (beta)")
+                            .on_disabled_hover_text("Scratch configuration missing")
+                            .clicked()
+                        {
+                            state.queue_scratch = true;
+                        }
+                    });
 
                     let demangled = demangle(&selected_symbol.symbol_name, &Default::default());
                     let name = demangled.as_deref().unwrap_or(&selected_symbol.symbol_name);

src/views/symbol_diff.rs

@@ -1,14 +1,15 @@
 use std::mem::take;
 
 use egui::{
-    text::LayoutJob, Align, CollapsingHeader, Color32, Layout, ScrollArea, SelectableLabel,
-    TextEdit, Ui, Vec2, Widget,
+    text::LayoutJob, Align, CollapsingHeader, Color32, Id, Layout, OpenUrl, ScrollArea,
+    SelectableLabel, TextEdit, Ui, Vec2, Widget,
 };
 use egui_extras::{Size, StripBuilder};
 
 use crate::{
     app::AppConfigRef,
     jobs::{
+        create_scratch::{start_create_scratch, CreateScratchConfig, CreateScratchResult},
         objdiff::{BuildStatus, ObjDiffResult},
         Job, JobQueue, JobResult,
     },
@@ -33,12 +34,16 @@ pub enum View {
 #[derive(Default)]
 pub struct DiffViewState {
     pub build: Option<Box<ObjDiffResult>>,
+    pub scratch: Option<Box<CreateScratchResult>>,
     pub current_view: View,
     pub symbol_state: SymbolViewState,
     pub function_state: FunctionViewState,
     pub search: String,
     pub queue_build: bool,
     pub build_running: bool,
+    pub scratch_available: bool,
+    pub queue_scratch: bool,
+    pub scratch_running: bool,
 }
 
 #[derive(Default)]
@@ -52,15 +57,19 @@ pub struct SymbolViewState {
 
 impl DiffViewState {
     pub fn pre_update(&mut self, jobs: &mut JobQueue, config: &AppConfigRef) {
-        jobs.results.retain_mut(|result| {
-            if let JobResult::ObjDiff(result) = result {
+        jobs.results.retain_mut(|result| match result {
+            JobResult::ObjDiff(result) => {
                 self.build = take(result);
                 false
-            } else {
-                true
             }
+            JobResult::CreateScratch(result) => {
+                self.scratch = take(result);
+                false
+            }
+            _ => true,
         });
         self.build_running = jobs.is_running(Job::ObjDiff);
+        self.scratch_running = jobs.is_running(Job::CreateScratch);
 
         self.symbol_state.disable_reverse_fn_order = false;
         if let Ok(config) = config.read() {
@@ -70,16 +79,41 @@ impl DiffViewState {
                     self.symbol_state.disable_reverse_fn_order = true;
                 }
             }
+            self.scratch_available = CreateScratchConfig::is_available(&config);
         }
     }
 
-    pub fn post_update(&mut self, config: &AppConfigRef) {
+    pub fn post_update(&mut self, ctx: &egui::Context, jobs: &mut JobQueue, config: &AppConfigRef) {
+        if let Some(result) = take(&mut self.scratch) {
+            ctx.output_mut(|o| o.open_url = Some(OpenUrl::new_tab(result.scratch_url)));
+        }
+
         if self.queue_build {
             self.queue_build = false;
             if let Ok(mut config) = config.write() {
                 config.queue_build = true;
             }
         }
+
+        if self.queue_scratch {
+            self.queue_scratch = false;
+            if let Some(function_name) =
+                self.symbol_state.selected_symbol.as_ref().map(|sym| sym.symbol_name.clone())
+            {
+                if let Ok(config) = config.read() {
+                    match CreateScratchConfig::from_config(&config, function_name) {
+                        Ok(config) => {
+                            jobs.push_once(Job::CreateScratch, || {
+                                start_create_scratch(ctx, config)
+                            });
+                        }
+                        Err(err) => {
+                            log::error!("Failed to create scratch config: {err}");
+                        }
+                    }
+                }
+            }
+        }
     }
 }
 
@@ -234,6 +268,7 @@ fn symbol_list_ui(
 
             for section in &obj.sections {
                 CollapsingHeader::new(format!("{} ({:x})", section.name, section.size))
+                    .id_source(Id::new(section.name.clone()).with(section.index))
                     .default_open(true)
                     .show(ui, |ui| {
                         if section.kind == ObjSectionKind::Code && state.reverse_fn_order {
@@ -262,11 +297,23 @@ fn symbol_list_ui(
 
 fn build_log_ui(ui: &mut Ui, status: &BuildStatus, appearance: &Appearance) {
     ScrollArea::both().auto_shrink([false, false]).show(ui, |ui| {
+        ui.horizontal(|ui| {
+            if ui.button("Copy command").clicked() {
+                ui.output_mut(|output| output.copied_text = status.cmdline.clone());
+            }
+            if ui.button("Copy log").clicked() {
+                ui.output_mut(|output| {
+                    output.copied_text = format!("{}\n{}", status.stdout, status.stderr)
+                });
+            }
+        });
         ui.scope(|ui| {
             ui.style_mut().override_text_style = Some(egui::TextStyle::Monospace);
             ui.style_mut().wrap = Some(false);
 
-            ui.colored_label(appearance.replace_color, &status.log);
+            ui.label(&status.cmdline);
+            ui.colored_label(appearance.replace_color, &status.stdout);
+            ui.colored_label(appearance.delete_color, &status.stderr);
         });
     });
 }