Hide auto-generated objects in object list

With filter option to display them, if desired. decomp-toolkit will start writing auto-generated objects in objdiff.json for reporting purposes, so this maintains the existing behavior.
Support for progress categories & linked stats
2025-12-17 08:57:25 +00:00 · 2024-09-03 18:59:07 -06:00 · 2024-09-03 00:59:15 -06:00 · 2024-08-25 20:57:45 -06:00 · 2024-08-21 19:48:58 -06:00 · 2024-08-20 21:40:32 -06:00
45 changed files with 6065 additions and 596 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -780,6 +780,16 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "console_log"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
+dependencies = [
+ "log",
+ "web-sys",
+]
+
 [[package]]
 name = "const_format"
 version = "0.2.32"
@@ -1475,6 +1485,12 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
 [[package]]
 name = "flagset"
 version = "0.4.5"
@@ -1931,6 +1947,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"

+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.3.9"
@@ -2192,6 +2214,15 @@ dependencies = [
 "either",
 ]

+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -2479,6 +2510,12 @@ dependencies = [
 "bitflags 2.5.0",
 ]

+[[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
 [[package]]
 name = "naga"
 version = "0.19.2"
@@ -2798,13 +2835,15 @@ dependencies = [

 [[package]]
 name = "objdiff-cli"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 dependencies = [
 "anyhow",
 "argp",
 "crossterm",
 "enable-ansi-support",
+ "memmap2",
 "objdiff-core",
+ "prost",
 "ratatui",
 "rayon",
 "serde",
@@ -2817,11 +2856,13 @@ dependencies = [

 [[package]]
 name = "objdiff-core"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 dependencies = [
 "anyhow",
 "arm-attr",
 "byteorder",
+ "console_error_panic_hook",
+ "console_log",
 "cpp_demangle",
 "cwdemangle",
 "cwextab",
@@ -2835,7 +2876,11 @@ dependencies = [
 "msvc-demangler",
 "num-traits",
 "object 0.35.0",
+ "pbjson",
+ "pbjson-build",
 "ppc750cl",
+ "prost",
+ "prost-build",
 "rabbitizer",
 "semver",
 "serde",
@@ -2843,12 +2888,14 @@ dependencies = [
 "serde_yaml",
 "similar",
 "strum",
+ "tsify-next",
 "unarm",
+ "wasm-bindgen",
 ]

 [[package]]
 name = "objdiff-gui"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 dependencies = [
 "anyhow",
 "bytes",
@@ -3060,12 +3107,44 @@ dependencies = [
 "rustc_version",
 ]

+[[package]]
+name = "pbjson"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7e6349fa080353f4a597daffd05cb81572a9c031a6d4fff7e504947496fcc68"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+]
+
+[[package]]
+name = "pbjson-build"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eea3058763d6e656105d1403cb04e0a41b7bbac6362d413e7c33be0c32279c9"
+dependencies = [
+ "heck 0.5.0",
+ "itertools 0.13.0",
+ "prost",
+ "prost-types",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"

+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.1.5"
@@ -3178,6 +3257,16 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"

+[[package]]
+name = "prettyplease"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "proc-macro-crate"
 version = "1.3.1"
@@ -3212,6 +3301,59 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43d84d1d7a6ac92673717f9f6d1518374ef257669c24ebc5ac25d5033828be58"

+[[package]]
+name = "prost"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13db3d3fde688c61e2446b4d843bc27a7e8af269a69440c0308021dc92333cc"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb182580f71dd070f88d01ce3de9f4da5021db7115d2e1c3605a754153b77c1"
+dependencies = [
+ "bytes",
+ "heck 0.5.0",
+ "itertools 0.13.0",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 2.0.60",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18bec9b0adc4eba778b33684b7ba3e7137789434769ee3ce3930463ef904cfca"
+dependencies = [
+ "anyhow",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cee5168b05f49d4b0ca581206eb14a7b22fafd963efe729ac48eb03266e25cc2"
+dependencies = [
+ "prost",
+]
+
 [[package]]
 name = "pulldown-cmark"
 version = "0.9.6"
@@ -3309,7 +3451,7 @@ dependencies = [
 "compact_str",
 "crossterm",
 "indoc",
- "itertools",
+ "itertools 0.12.1",
 "lru",
 "paste",
 "stability",
@@ -3731,6 +3873,17 @@ dependencies = [
 "serde_derive",
 ]

+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "serde_derive"
 version = "1.0.199"
@@ -3742,6 +3895,17 @@ dependencies = [
 "syn 2.0.60",
 ]

+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "serde_json"
 version = "1.0.116"
@@ -3988,7 +4152,7 @@ version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946"
 dependencies = [
- "heck",
+ "heck 0.4.1",
 "proc-macro2",
 "quote",
 "rustversion",
@@ -4318,6 +4482,30 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"

+[[package]]
+name = "tsify-next"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4a645dca4ee0800f5ab60ce166deba2db6a0315de795a2691e138a3d55d756"
+dependencies = [
+ "serde",
+ "serde-wasm-bindgen",
+ "tsify-next-macros",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "tsify-next-macros"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d5c06f8a51d759bb58129e30b2631739e7e1e4579fad1f30ac09a6c88e488a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "ttf-parser"
 version = "0.20.0"
@@ -4352,9 +4540,9 @@ dependencies = [

 [[package]]
 name = "unarm"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379762d9433a2e6e498cde97801fb238318b024a513d0843eeac98b9056b9f3c"
+checksum = "e82790df6bdacbe2661a9ea0e075d1aefe18198420afaa0662cef93b580c3b26"

 [[package]]
 name = "unicase"
@@ -4493,19 +4681,20 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
 "cfg-if",
+ "once_cell",
 "wasm-bindgen-macro",
 ]

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
 "bumpalo",
 "log",
@@ -4530,9 +4719,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@@ -4540,9 +4729,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -4553,9 +4742,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"

 [[package]]
 name = "wayland-backend"
--- a/objdiff-cli/Cargo.toml
+++ b/objdiff-cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-cli"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -18,7 +18,9 @@ anyhow = "1.0.82"
 argp = "0.3.0"
 crossterm = "0.27.0"
 enable-ansi-support = "0.2.1"
+memmap2 = "0.9.4"
 objdiff-core = { path = "../objdiff-core", features = ["all"] }
+prost = "0.13.1"
 ratatui = "0.26.2"
 rayon = "1.10.0"
 serde = { version = "1", features = ["derive"] }
--- a/objdiff-cli/src/cmd/diff.rs
+++ b/objdiff-cli/src/cmd/diff.rs
@@ -1,4 +1,9 @@
-use std::{fs, io::stdout, path::PathBuf, str::FromStr};
+use std::{
+    fs,
+    io::stdout,
+    path::{Path, PathBuf},
+    str::FromStr,
+};

 use anyhow::{bail, Context, Result};
 use argp::FromArgs;
@@ -14,6 +19,7 @@ use crossterm::{
 };
 use event::KeyModifiers;
 use objdiff_core::{
+    bindings::diff::DiffResult,
    config::{ProjectConfig, ProjectObject},
    diff,
    diff::{
@@ -28,10 +34,13 @@ use ratatui::{
    widgets::{Block, Borders, Clear, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
 };

-use crate::util::term::crossterm_panic_handler;
+use crate::util::{
+    output::{write_output, OutputFormat},
+    term::crossterm_panic_handler,
+};

 #[derive(FromArgs, PartialEq, Debug)]
-/// Diff two object files.
+/// Diff two object files. (Interactive or one-shot mode)
 #[argp(subcommand, name = "diff")]
 pub struct Args {
    #[argp(option, short = '1')]
@@ -49,101 +58,152 @@ pub struct Args {
    #[argp(switch, short = 'x')]
    /// Relax relocation diffs
    relax_reloc_diffs: bool,
+    #[argp(option, short = 'o')]
+    /// Output file (one-shot mode) ("-" for stdout)
+    output: Option<PathBuf>,
+    #[argp(option)]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
    #[argp(positional)]
    /// Function symbol to diff
-    symbol: String,
+    symbol: Option<String>,
 }

 pub fn run(args: Args) -> Result<()> {
-    let (target_path, base_path, project_config) =
-        match (&args.target, &args.base, &args.project, &args.unit) {
-            (Some(t), Some(b), None, None) => (Some(t.clone()), Some(b.clone()), None),
-            (None, None, p, u) => {
-                let project = match p {
-                    Some(project) => project.clone(),
-                    _ => std::env::current_dir().context("Failed to get the current directory")?,
+    let (target_path, base_path, project_config) = match (
+        &args.target,
+        &args.base,
+        &args.project,
+        &args.unit,
+    ) {
+        (Some(t), Some(b), None, None) => (Some(t.clone()), Some(b.clone()), None),
+        (None, None, p, u) => {
+            let project = match p {
+                Some(project) => project.clone(),
+                _ => std::env::current_dir().context("Failed to get the current directory")?,
+            };
+            let Some((project_config, project_config_info)) =
+                objdiff_core::config::try_project_config(&project)
+            else {
+                bail!("Project config not found in {}", &project.display())
+            };
+            let mut project_config = project_config.with_context(|| {
+                format!("Reading project config {}", project_config_info.path.display())
+            })?;
+            let object = {
+                let resolve_paths = |o: &mut ProjectObject| {
+                    o.resolve_paths(
+                        &project,
+                        project_config.target_dir.as_deref(),
+                        project_config.base_dir.as_deref(),
+                    )
                };
-                let Some((project_config, project_config_info)) =
-                    objdiff_core::config::try_project_config(&project)
-                else {
-                    bail!("Project config not found in {}", &project.display())
-                };
-                let mut project_config = project_config.with_context(|| {
-                    format!("Reading project config {}", project_config_info.path.display())
-                })?;
-                let object = {
-                    let resolve_paths = |o: &mut ProjectObject| {
-                        o.resolve_paths(
-                            &project,
-                            project_config.target_dir.as_deref(),
-                            project_config.base_dir.as_deref(),
-                        )
-                    };
-                    if let Some(u) = u {
-                        let unit_path =
-                            PathBuf::from_str(u).ok().and_then(|p| fs::canonicalize(p).ok());
-
-                        let Some(object) = project_config.objects.iter_mut().find_map(|obj| {
-                            if obj.name.as_deref() == Some(u) {
-                                resolve_paths(obj);
-                                return Some(obj);
-                            }
-
-                            let up = unit_path.as_deref()?;
+                if let Some(u) = u {
+                    let unit_path =
+                        PathBuf::from_str(u).ok().and_then(|p| fs::canonicalize(p).ok());

+                    let Some(object) = project_config.objects.iter_mut().find_map(|obj| {
+                        if obj.name.as_deref() == Some(u) {
                            resolve_paths(obj);
-
-                            if [&obj.base_path, &obj.target_path]
-                                .into_iter()
-                                .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
-                                .any(|p| p == up)
-                            {
-                                return Some(obj);
-                            }
-
-                            None
-                        }) else {
-                            bail!("Unit not found: {}", u)
-                        };
-
-                        object
-                    } else {
-                        let mut idx = None;
-                        let mut count = 0usize;
-                        for (i, obj) in project_config.objects.iter_mut().enumerate() {
-                            resolve_paths(obj);
-
-                            if obj
-                                .target_path
-                                .as_deref()
-                                .map(|o| obj::read::has_function(o, &args.symbol))
-                                .transpose()?
-                                .unwrap_or(false)
-                            {
-                                idx = Some(i);
-                                count += 1;
-                                if count > 1 {
-                                    break;
-                                }
-                            }
+                            return Some(obj);
                        }
-                        match (count, idx) {
-                            (0, None) => bail!("Symbol not found: {}", &args.symbol),
-                            (1, Some(i)) => &mut project_config.objects[i],
-                            (2.., Some(_)) => bail!(
-                                "Multiple instances of {} were found, try specifying a unit",
-                                &args.symbol
-                            ),
-                            _ => unreachable!(),
+
+                        let up = unit_path.as_deref()?;
+
+                        resolve_paths(obj);
+
+                        if [&obj.base_path, &obj.target_path]
+                            .into_iter()
+                            .filter_map(|p| p.as_ref().and_then(|p| p.canonicalize().ok()))
+                            .any(|p| p == up)
+                        {
+                            return Some(obj);
+                        }
+
+                        None
+                    }) else {
+                        bail!("Unit not found: {}", u)
+                    };
+
+                    object
+                } else if let Some(symbol_name) = &args.symbol {
+                    let mut idx = None;
+                    let mut count = 0usize;
+                    for (i, obj) in project_config.objects.iter_mut().enumerate() {
+                        resolve_paths(obj);
+
+                        if obj
+                            .target_path
+                            .as_deref()
+                            .map(|o| obj::read::has_function(o, symbol_name))
+                            .transpose()?
+                            .unwrap_or(false)
+                        {
+                            idx = Some(i);
+                            count += 1;
+                            if count > 1 {
+                                break;
+                            }
                        }
                    }
-                };
-                let target_path = object.target_path.clone();
-                let base_path = object.base_path.clone();
-                (target_path, base_path, Some(project_config))
-            }
-            _ => bail!("Either target and base or project and unit must be specified"),
-        };
+                    match (count, idx) {
+                        (0, None) => bail!("Symbol not found: {}", symbol_name),
+                        (1, Some(i)) => &mut project_config.objects[i],
+                        (2.., Some(_)) => bail!(
+                            "Multiple instances of {} were found, try specifying a unit",
+                            symbol_name
+                        ),
+                        _ => unreachable!(),
+                    }
+                } else {
+                    bail!("Must specify one of: symbol, project and unit, target and base objects")
+                }
+            };
+            let target_path = object.target_path.clone();
+            let base_path = object.base_path.clone();
+            (target_path, base_path, Some(project_config))
+        }
+        _ => bail!("Either target and base or project and unit must be specified"),
+    };
+
+    if let Some(output) = &args.output {
+        run_oneshot(&args, output, target_path.as_deref(), base_path.as_deref())
+    } else {
+        run_interactive(args, target_path, base_path, project_config)
+    }
+}
+
+fn run_oneshot(
+    args: &Args,
+    output: &Path,
+    target_path: Option<&Path>,
+    base_path: Option<&Path>,
+) -> Result<()> {
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let config = diff::DiffObjConfig {
+        relax_reloc_diffs: args.relax_reloc_diffs,
+        ..Default::default() // TODO
+    };
+    let target = target_path
+        .map(|p| obj::read::read(p, &config).with_context(|| format!("Loading {}", p.display())))
+        .transpose()?;
+    let base = base_path
+        .map(|p| obj::read::read(p, &config).with_context(|| format!("Loading {}", p.display())))
+        .transpose()?;
+    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
+    let left = target.as_ref().and_then(|o| result.left.as_ref().map(|d| (o, d)));
+    let right = base.as_ref().and_then(|o| result.right.as_ref().map(|d| (o, d)));
+    write_output(&DiffResult::new(left, right), Some(output), output_format)?;
+    Ok(())
+}
+
+fn run_interactive(
+    args: Args,
+    target_path: Option<PathBuf>,
+    base_path: Option<PathBuf>,
+    project_config: Option<ProjectConfig>,
+) -> Result<()> {
+    let Some(symbol_name) = &args.symbol else { bail!("Interactive mode requires a symbol name") };
    let time_format = time::format_description::parse_borrowed::<2>("[hour]:[minute]:[second]")
        .context("Failed to parse time format")?;
    let mut state = Box::new(FunctionDiffUi {
@@ -156,7 +216,7 @@ pub fn run(args: Args) -> Result<()> {
        scroll_state_y: ScrollbarState::default(),
        per_page: 0,
        num_rows: 0,
-        symbol_name: args.symbol.clone(),
+        symbol_name: symbol_name.clone(),
        target_path,
        base_path,
        project_config,
@@ -180,7 +240,7 @@ pub fn run(args: Args) -> Result<()> {
        stdout(),
        EnterAlternateScreen,
        EnableMouseCapture,
-        SetTitle(format!("{} - objdiff", args.symbol)),
+        SetTitle(format!("{} - objdiff", symbol_name)),
    )?;
    let backend = CrosstermBackend::new(stdout());
    let mut terminal = Terminal::new(backend)?;
@@ -750,8 +810,11 @@ impl FunctionDiffUi {
                            base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
                        }
                    }
-                    DiffText::BranchDest(addr) => {
+                    DiffText::BranchDest(addr, diff) => {
                        label_text = format!("{addr:x}");
+                        if let Some(diff) = diff {
+                            base_color = COLOR_ROTATION[diff.idx % COLOR_ROTATION.len()]
+                        }
                    }
                    DiffText::Symbol(sym) => {
                        let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
@@ -811,18 +874,7 @@ impl FunctionDiffUi {
        let prev = self.right_obj.take();
        let config = diff::DiffObjConfig {
            relax_reloc_diffs: self.relax_reloc_diffs,
-            space_between_args: true,                // TODO
-            combine_data_sections: false,            // TODO
-            x86_formatter: Default::default(),       // TODO
-            mips_abi: Default::default(),            // TODO
-            mips_instr_category: Default::default(), // TODO
-            arm_arch_version: Default::default(),    // TODO
-            arm_unified_syntax: true,                // TODO
-            arm_av_registers: false,                 // TODO
-            arm_r9_usage: Default::default(),        // TODO
-            arm_sl_usage: false,                     // TODO
-            arm_fp_usage: false,                     // TODO
-            arm_ip_usage: false,                     // TODO
+            ..Default::default() // TODO
        };
        let target = self
            .target_path
--- a/objdiff-cli/src/cmd/report.rs
+++ b/objdiff-cli/src/cmd/report.rs
@@ -1,7 +1,7 @@
 use std::{
    collections::HashSet,
    fs::File,
-    io::{BufReader, BufWriter, Write},
+    io::Read,
    path::{Path, PathBuf},
    time::Instant,
 };
@@ -9,15 +9,23 @@ use std::{
 use anyhow::{bail, Context, Result};
 use argp::FromArgs;
 use objdiff_core::{
+    bindings::report::{
+        ChangeItem, ChangeItemInfo, ChangeUnit, Changes, ChangesInput, Measures, Report,
+        ReportCategory, ReportItem, ReportItemMetadata, ReportUnit, ReportUnitMetadata,
+        REPORT_VERSION,
+    },
    config::ProjectObject,
    diff, obj,
    obj::{ObjSectionKind, ObjSymbolFlags},
 };
+use prost::Message;
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use tracing::{info, warn};

+use crate::util::output::{write_output, OutputFormat};
+
 #[derive(FromArgs, PartialEq, Debug)]
-/// Commands for processing NVIDIA Shield TV alf files.
+/// Generate a progress report for a project.
 #[argp(subcommand, name = "report")]
 pub struct Args {
    #[argp(subcommand)]
@@ -32,18 +40,21 @@ pub enum SubCommand {
 }

 #[derive(FromArgs, PartialEq, Debug)]
-/// Generate a report from a project.
+/// Generate a progress report for a project.
 #[argp(subcommand, name = "generate")]
 pub struct GenerateArgs {
    #[argp(option, short = 'p')]
    /// Project directory
    project: Option<PathBuf>,
    #[argp(option, short = 'o')]
-    /// Output JSON file
+    /// Output file
    output: Option<PathBuf>,
    #[argp(switch, short = 'd')]
    /// Deduplicate global and weak symbols (runs single-threaded)
    deduplicate: bool,
+    #[argp(option, short = 'f')]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
 }

 #[derive(FromArgs, PartialEq, Debug)]
@@ -51,65 +62,17 @@ pub struct GenerateArgs {
 #[argp(subcommand, name = "changes")]
 pub struct ChangesArgs {
    #[argp(positional)]
-    /// Previous report JSON file
+    /// Previous report file
    previous: PathBuf,
    #[argp(positional)]
-    /// Current report JSON file
+    /// Current report file
    current: PathBuf,
    #[argp(option, short = 'o')]
-    /// Output JSON file
+    /// Output file
    output: Option<PathBuf>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct Report {
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    matched_code_percent: f32,
-    total_data: u64,
-    matched_data: u64,
-    matched_data_percent: f32,
-    total_functions: u32,
-    matched_functions: u32,
-    matched_functions_percent: f32,
-    units: Vec<ReportUnit>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ReportUnit {
-    name: String,
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    total_data: u64,
-    matched_data: u64,
-    total_functions: u32,
-    matched_functions: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    complete: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    module_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    module_id: Option<u32>,
-    sections: Vec<ReportItem>,
-    functions: Vec<ReportItem>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ReportItem {
-    name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    demangled_name: Option<String>,
-    #[serde(
-        default,
-        skip_serializing_if = "Option::is_none",
-        serialize_with = "serialize_hex",
-        deserialize_with = "deserialize_hex"
-    )]
-    address: Option<u64>,
-    size: u64,
-    fuzzy_match_percent: f32,
+    #[argp(option, short = 'f')]
+    /// Output format (json, json-pretty, proto) (default: json)
+    format: Option<String>,
 }

 pub fn run(args: Args) -> Result<()> {
@@ -120,6 +83,7 @@ pub fn run(args: Args) -> Result<()> {
 }

 fn generate(args: GenerateArgs) -> Result<()> {
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
    let project_dir = args.project.as_deref().unwrap_or_else(|| Path::new("."));
    info!("Loading project {}", project_dir.display());

@@ -134,7 +98,7 @@ fn generate(args: GenerateArgs) -> Result<()> {
    );

    let start = Instant::now();
-    let mut report = Report::default();
+    let mut units = vec![];
    let mut existing_functions: HashSet<String> = HashSet::new();
    if args.deduplicate {
        // If deduplicating, we need to run single-threaded
@@ -146,11 +110,11 @@ fn generate(args: GenerateArgs) -> Result<()> {
                project.base_dir.as_deref(),
                Some(&mut existing_functions),
            )? {
-                report.units.push(unit);
+                units.push(unit);
            }
        }
    } else {
-        let units = project
+        let vec = project
            .objects
            .par_iter_mut()
            .map(|object| {
@@ -163,51 +127,23 @@ fn generate(args: GenerateArgs) -> Result<()> {
                )
            })
            .collect::<Result<Vec<Option<ReportUnit>>>>()?;
-        report.units = units.into_iter().flatten().collect();
+        units = vec.into_iter().flatten().collect();
    }
-    for unit in &report.units {
-        report.fuzzy_match_percent += unit.fuzzy_match_percent * unit.total_code as f32;
-        report.total_code += unit.total_code;
-        report.matched_code += unit.matched_code;
-        report.total_data += unit.total_data;
-        report.matched_data += unit.matched_data;
-        report.total_functions += unit.total_functions;
-        report.matched_functions += unit.matched_functions;
+    let measures = units.iter().flat_map(|u| u.measures.into_iter()).collect();
+    let mut categories = Vec::new();
+    for category in &project.progress_categories {
+        categories.push(ReportCategory {
+            id: category.id.clone(),
+            name: category.name.clone(),
+            measures: Some(Default::default()),
+        });
    }
-    if report.total_code == 0 {
-        report.fuzzy_match_percent = 100.0;
-    } else {
-        report.fuzzy_match_percent /= report.total_code as f32;
-    }
-
-    report.matched_code_percent = if report.total_code == 0 {
-        100.0
-    } else {
-        report.matched_code as f32 / report.total_code as f32 * 100.0
-    };
-    report.matched_data_percent = if report.total_data == 0 {
-        100.0
-    } else {
-        report.matched_data as f32 / report.total_data as f32 * 100.0
-    };
-    report.matched_functions_percent = if report.total_functions == 0 {
-        100.0
-    } else {
-        report.matched_functions as f32 / report.total_functions as f32 * 100.0
-    };
+    let mut report =
+        Report { measures: Some(measures), units, version: REPORT_VERSION, categories };
+    report.calculate_progress_categories();
    let duration = start.elapsed();
    info!("Report generated in {}.{:03}s", duration.as_secs(), duration.subsec_millis());
-    if let Some(output) = &args.output {
-        info!("Writing to {}", output.display());
-        let mut output = BufWriter::new(
-            File::create(output)
-                .with_context(|| format!("Failed to create file {}", output.display()))?,
-        );
-        serde_json::to_writer_pretty(&mut output, &report)?;
-        output.flush()?;
-    } else {
-        serde_json::to_writer_pretty(std::io::stdout(), &report)?;
-    }
+    write_output(&report, args.output.as_deref(), output_format)?;
    Ok(())
 }

@@ -220,7 +156,7 @@ fn report_object(
 ) -> Result<Option<ReportUnit>> {
    object.resolve_paths(project_dir, target_dir, base_dir);
    match (&object.target_path, &object.base_path) {
-        (None, Some(_)) if object.complete != Some(true) => {
+        (None, Some(_)) if !object.complete().unwrap_or(false) => {
            warn!("Skipping object without target: {}", object.name());
            return Ok(None);
        }
@@ -246,42 +182,53 @@ fn report_object(
        })
        .transpose()?;
    let result = diff::diff_objs(&config, target.as_ref(), base.as_ref(), None)?;
-    let mut unit = ReportUnit {
-        name: object.name().to_string(),
-        complete: object.complete,
+
+    let metadata = ReportUnitMetadata {
+        complete: object.complete(),
        module_name: target
            .as_ref()
            .and_then(|o| o.split_meta.as_ref())
            .and_then(|m| m.module_name.clone()),
        module_id: target.as_ref().and_then(|o| o.split_meta.as_ref()).and_then(|m| m.module_id),
-        ..Default::default()
+        source_path: object.metadata.as_ref().and_then(|m| m.source_path.clone()),
+        progress_categories: object
+            .metadata
+            .as_ref()
+            .and_then(|m| m.progress_categories.clone())
+            .unwrap_or_default(),
+        auto_generated: object.metadata.as_ref().and_then(|m| m.auto_generated),
    };
-    let obj = target.as_ref().or(base.as_ref()).unwrap();
+    let mut measures = Measures::default();
+    let mut sections = vec![];
+    let mut functions = vec![];

+    let obj = target.as_ref().or(base.as_ref()).unwrap();
    let obj_diff = result.left.as_ref().or(result.right.as_ref()).unwrap();
    for (section, section_diff) in obj.sections.iter().zip(&obj_diff.sections) {
        let section_match_percent = section_diff.match_percent.unwrap_or_else(|| {
            // Support cases where we don't have a target object,
            // assume complete means 100% match
-            if object.complete == Some(true) {
+            if object.complete().unwrap_or(false) {
                100.0
            } else {
                0.0
            }
        });
-        unit.sections.push(ReportItem {
+        sections.push(ReportItem {
            name: section.name.clone(),
-            demangled_name: None,
            fuzzy_match_percent: section_match_percent,
            size: section.size,
-            address: section.virtual_address,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: None,
+                virtual_address: section.virtual_address,
+            }),
        });

        match section.kind {
            ObjSectionKind::Data | ObjSectionKind::Bss => {
-                unit.total_data += section.size;
+                measures.total_data += section.size;
                if section_match_percent == 100.0 {
-                    unit.matched_data += section.size;
+                    measures.matched_data += section.size;
                }
                continue;
            }
@@ -303,155 +250,79 @@ fn report_object(
            let match_percent = symbol_diff.match_percent.unwrap_or_else(|| {
                // Support cases where we don't have a target object,
                // assume complete means 100% match
-                if object.complete == Some(true) {
+                if object.complete().unwrap_or(false) {
                    100.0
                } else {
                    0.0
                }
            });
-            unit.fuzzy_match_percent += match_percent * symbol.size as f32;
-            unit.total_code += symbol.size;
+            measures.fuzzy_match_percent += match_percent * symbol.size as f32;
+            measures.total_code += symbol.size;
            if match_percent == 100.0 {
-                unit.matched_code += symbol.size;
+                measures.matched_code += symbol.size;
            }
-            unit.functions.push(ReportItem {
+            functions.push(ReportItem {
                name: symbol.name.clone(),
-                demangled_name: symbol.demangled_name.clone(),
                size: symbol.size,
                fuzzy_match_percent: match_percent,
-                address: symbol.virtual_address,
+                metadata: Some(ReportItemMetadata {
+                    demangled_name: symbol.demangled_name.clone(),
+                    virtual_address: symbol.virtual_address,
+                }),
            });
            if match_percent == 100.0 {
-                unit.matched_functions += 1;
+                measures.matched_functions += 1;
            }
-            unit.total_functions += 1;
+            measures.total_functions += 1;
        }
    }
-    if unit.total_code == 0 {
-        unit.fuzzy_match_percent = 100.0;
-    } else {
-        unit.fuzzy_match_percent /= unit.total_code as f32;
-    }
-    Ok(Some(unit))
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct Changes {
-    from: ChangeInfo,
-    to: ChangeInfo,
-    units: Vec<ChangeUnit>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-struct ChangeInfo {
-    fuzzy_match_percent: f32,
-    total_code: u64,
-    matched_code: u64,
-    matched_code_percent: f32,
-    total_data: u64,
-    matched_data: u64,
-    matched_data_percent: f32,
-    total_functions: u32,
-    matched_functions: u32,
-    matched_functions_percent: f32,
-}
-
-impl From<&Report> for ChangeInfo {
-    fn from(report: &Report) -> Self {
-        Self {
-            fuzzy_match_percent: report.fuzzy_match_percent,
-            total_code: report.total_code,
-            matched_code: report.matched_code,
-            matched_code_percent: report.matched_code_percent,
-            total_data: report.total_data,
-            matched_data: report.matched_data,
-            matched_data_percent: report.matched_data_percent,
-            total_functions: report.total_functions,
-            matched_functions: report.matched_functions,
-            matched_functions_percent: report.matched_functions_percent,
-        }
-    }
-}
-
-impl From<&ReportUnit> for ChangeInfo {
-    fn from(value: &ReportUnit) -> Self {
-        Self {
-            fuzzy_match_percent: value.fuzzy_match_percent,
-            total_code: value.total_code,
-            matched_code: value.matched_code,
-            matched_code_percent: if value.total_code == 0 {
-                100.0
-            } else {
-                value.matched_code as f32 / value.total_code as f32 * 100.0
-            },
-            total_data: value.total_data,
-            matched_data: value.matched_data,
-            matched_data_percent: if value.total_data == 0 {
-                100.0
-            } else {
-                value.matched_data as f32 / value.total_data as f32 * 100.0
-            },
-            total_functions: value.total_functions,
-            matched_functions: value.matched_functions,
-            matched_functions_percent: if value.total_functions == 0 {
-                100.0
-            } else {
-                value.matched_functions as f32 / value.total_functions as f32 * 100.0
-            },
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ChangeUnit {
-    name: String,
-    from: Option<ChangeInfo>,
-    to: Option<ChangeInfo>,
-    sections: Vec<ChangeItem>,
-    functions: Vec<ChangeItem>,
-}
-
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
-struct ChangeItem {
-    name: String,
-    from: Option<ChangeItemInfo>,
-    to: Option<ChangeItemInfo>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
-struct ChangeItemInfo {
-    fuzzy_match_percent: f32,
-    size: u64,
-}
-
-impl From<&ReportItem> for ChangeItemInfo {
-    fn from(value: &ReportItem) -> Self {
-        Self { fuzzy_match_percent: value.fuzzy_match_percent, size: value.size }
+    if metadata.complete.unwrap_or(false) {
+        measures.complete_code = measures.total_code;
+        measures.complete_data = measures.total_data;
    }
+    measures.calc_fuzzy_match_percent();
+    measures.calc_matched_percent();
+    Ok(Some(ReportUnit {
+        name: object.name().to_string(),
+        measures: Some(measures),
+        sections,
+        functions,
+        metadata: Some(metadata),
+    }))
 }

 fn changes(args: ChangesArgs) -> Result<()> {
-    let previous = read_report(&args.previous)?;
-    let current = read_report(&args.current)?;
-    let mut changes = Changes {
-        from: ChangeInfo::from(&previous),
-        to: ChangeInfo::from(&current),
-        units: vec![],
+    let output_format = OutputFormat::from_option(args.format.as_deref())?;
+    let (previous, current) = if args.previous == Path::new("-") && args.current == Path::new("-") {
+        // Special case for comparing two reports from stdin
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        let input = ChangesInput::decode(data.as_slice())?;
+        (input.from.unwrap(), input.to.unwrap())
+    } else {
+        let previous = read_report(&args.previous)?;
+        let current = read_report(&args.current)?;
+        (previous, current)
    };
+    let mut changes = Changes { from: previous.measures, to: current.measures, units: vec![] };
    for prev_unit in &previous.units {
        let curr_unit = current.units.iter().find(|u| u.name == prev_unit.name);
        let sections = process_items(prev_unit, curr_unit, |u| &u.sections);
        let functions = process_items(prev_unit, curr_unit, |u| &u.functions);

-        let prev_unit_info = ChangeInfo::from(prev_unit);
-        let curr_unit_info = curr_unit.map(ChangeInfo::from);
-        if !functions.is_empty() || !matches!(&curr_unit_info, Some(v) if v == &prev_unit_info) {
+        let prev_measures = prev_unit.measures;
+        let curr_measures = curr_unit.and_then(|u| u.measures);
+        if !functions.is_empty() || prev_measures != curr_measures {
            changes.units.push(ChangeUnit {
                name: prev_unit.name.clone(),
-                from: Some(prev_unit_info),
-                to: curr_unit_info,
+                from: prev_measures,
+                to: curr_measures,
                sections,
                functions,
+                metadata: curr_unit
+                    .as_ref()
+                    .and_then(|u| u.metadata.clone())
+                    .or_else(|| prev_unit.metadata.clone()),
            });
        }
    }
@@ -460,23 +331,14 @@ fn changes(args: ChangesArgs) -> Result<()> {
            changes.units.push(ChangeUnit {
                name: curr_unit.name.clone(),
                from: None,
-                to: Some(ChangeInfo::from(curr_unit)),
+                to: curr_unit.measures,
                sections: process_new_items(&curr_unit.sections),
                functions: process_new_items(&curr_unit.functions),
+                metadata: curr_unit.metadata.clone(),
            });
        }
    }
-    if let Some(output) = &args.output {
-        info!("Writing to {}", output.display());
-        let mut output = BufWriter::new(
-            File::create(output)
-                .with_context(|| format!("Failed to create file {}", output.display()))?,
-        );
-        serde_json::to_writer_pretty(&mut output, &changes)?;
-        output.flush()?;
-    } else {
-        serde_json::to_writer_pretty(std::io::stdout(), &changes)?;
-    }
+    write_output(&changes, args.output.as_deref(), output_format)?;
    Ok(())
 }

@@ -499,6 +361,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                        name: prev_func.name.clone(),
                        from: Some(prev_func_info),
                        to: Some(curr_func_info),
+                        metadata: curr_func.as_ref().unwrap().metadata.clone(),
                    });
                }
            } else {
@@ -506,6 +369,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                    name: prev_func.name.clone(),
                    from: Some(prev_func_info),
                    to: None,
+                    metadata: prev_func.metadata.clone(),
                });
            }
        }
@@ -515,6 +379,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                    name: curr_func.name.clone(),
                    from: None,
                    to: Some(ChangeItemInfo::from(curr_func)),
+                    metadata: curr_func.metadata.clone(),
                });
            }
        }
@@ -524,6 +389,7 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
                name: prev_func.name.clone(),
                from: Some(ChangeItemInfo::from(prev_func)),
                to: None,
+                metadata: prev_func.metadata.clone(),
            });
        }
    }
@@ -533,35 +399,24 @@ fn process_items<F: Fn(&ReportUnit) -> &Vec<ReportItem>>(
 fn process_new_items(items: &[ReportItem]) -> Vec<ChangeItem> {
    items
        .iter()
-        .map(|f| ChangeItem { name: f.name.clone(), from: None, to: Some(ChangeItemInfo::from(f)) })
+        .map(|item| ChangeItem {
+            name: item.name.clone(),
+            from: None,
+            to: Some(ChangeItemInfo::from(item)),
+            metadata: item.metadata.clone(),
+        })
        .collect()
 }

 fn read_report(path: &Path) -> Result<Report> {
-    serde_json::from_reader(BufReader::new(
-        File::open(path).with_context(|| format!("Failed to open {}", path.display()))?,
-    ))
-    .with_context(|| format!("Failed to read report {}", path.display()))
-}
-
-fn serialize_hex<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
-where S: serde::Serializer {
-    if let Some(x) = x {
-        s.serialize_str(&format!("{:#x}", x))
-    } else {
-        s.serialize_none()
-    }
-}
-
-fn deserialize_hex<'de, D>(d: D) -> Result<Option<u64>, D::Error>
-where D: serde::Deserializer<'de> {
-    use serde::Deserialize;
-    let s = String::deserialize(d)?;
-    if s.is_empty() {
-        Ok(None)
-    } else if !s.starts_with("0x") {
-        Err(serde::de::Error::custom("expected hex string"))
-    } else {
-        u64::from_str_radix(&s[2..], 16).map(Some).map_err(serde::de::Error::custom)
+    if path == Path::new("-") {
+        let mut data = vec![];
+        std::io::stdin().read_to_end(&mut data)?;
+        return Report::parse(&data).with_context(|| "Failed to load report from stdin");
    }
+    let file = File::open(path).with_context(|| format!("Failed to open {}", path.display()))?;
+    let mmap = unsafe { memmap2::Mmap::map(&file) }
+        .with_context(|| format!("Failed to map {}", path.display()))?;
+    Report::parse(mmap.as_ref())
+        .with_context(|| format!("Failed to load report {}", path.display()))
 }
--- a/objdiff-cli/src/main.rs
+++ b/objdiff-cli/src/main.rs
@@ -54,7 +54,7 @@ impl FromArgValue for LogLevel {
 }

 #[derive(FromArgs, PartialEq, Debug)]
-/// Yet another GameCube/Wii decompilation toolkit.
+/// A local diffing tool for decompilation projects.
 struct TopLevel {
    #[argp(subcommand)]
    command: SubCommand,
@@ -96,7 +96,7 @@ fn main() {
        // Try to enable ANSI support on Windows.
        let _ = enable_ansi_support();
        // Disable isatty check for supports-color. (e.g. when used with ninja)
-        env::set_var("IGNORE_IS_TERMINAL", "1");
+        unsafe { env::set_var("IGNORE_IS_TERMINAL", "1") };
        supports_color::on(Stream::Stdout).is_some_and(|c| c.has_basic)
    };

--- a/objdiff-cli/src/util/mod.rs
+++ b/objdiff-cli/src/util/mod.rs
@@ -1 +1,2 @@
+pub mod output;
 pub mod term;
--- a/objdiff-cli/src/util/output.rs
+++ b/objdiff-cli/src/util/output.rs
@@ -0,0 +1,84 @@
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+    ops::DerefMut,
+    path::Path,
+};
+
+use anyhow::{bail, Context, Result};
+use tracing::info;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
+pub enum OutputFormat {
+    #[default]
+    Json,
+    JsonPretty,
+    Proto,
+}
+
+impl OutputFormat {
+    pub fn from_str(s: &str) -> Result<Self> {
+        match s.to_ascii_lowercase().as_str() {
+            "json" => Ok(Self::Json),
+            "json-pretty" | "json_pretty" => Ok(Self::JsonPretty),
+            "binpb" | "pb" | "proto" | "protobuf" => Ok(Self::Proto),
+            _ => bail!("Invalid output format: {}", s),
+        }
+    }
+
+    pub fn from_option(s: Option<&str>) -> Result<Self> {
+        match s {
+            Some(s) => Self::from_str(s),
+            None => Ok(Self::default()),
+        }
+    }
+}
+
+pub fn write_output<T>(input: &T, output: Option<&Path>, format: OutputFormat) -> Result<()>
+where T: serde::Serialize + prost::Message {
+    match output {
+        Some(output) if output != Path::new("-") => {
+            info!("Writing to {}", output.display());
+            let file = File::options()
+                .read(true)
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(output)
+                .with_context(|| format!("Failed to create file {}", output.display()))?;
+            match format {
+                OutputFormat::Json => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::JsonPretty => {
+                    let mut output = BufWriter::new(file);
+                    serde_json::to_writer_pretty(&mut output, input)
+                        .context("Failed to write output file")?;
+                    output.flush().context("Failed to flush output file")?;
+                }
+                OutputFormat::Proto => {
+                    file.set_len(input.encoded_len() as u64)?;
+                    let map = unsafe { memmap2::Mmap::map(&file) }
+                        .context("Failed to map output file")?;
+                    let mut output = map.make_mut().context("Failed to remap output file")?;
+                    input.encode(&mut output.deref_mut()).context("Failed to encode output")?;
+                }
+            }
+        }
+        _ => match format {
+            OutputFormat::Json => {
+                serde_json::to_writer(std::io::stdout(), input)?;
+            }
+            OutputFormat::JsonPretty => {
+                serde_json::to_writer_pretty(std::io::stdout(), input)?;
+            }
+            OutputFormat::Proto => {
+                std::io::stdout().write_all(&input.encode_to_vec())?;
+            }
+        },
+    }
+    Ok(())
+}
--- a/objdiff-core/Cargo.toml
+++ b/objdiff-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-core"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -11,8 +11,11 @@ description = """
 A local diffing tool for decompilation projects.
 """

+[lib]
+crate-type = ["cdylib", "rlib"]
+
 [features]
-all = ["config", "dwarf", "mips", "ppc", "x86", "arm"]
+all = ["config", "dwarf", "mips", "ppc", "x86", "arm", "bindings"]
 any-arch = [] # Implicit, used to check if any arch is enabled
 config = ["globset", "semver", "serde_json", "serde_yaml"]
 dwarf = ["gimli"]
@@ -20,6 +23,8 @@ mips = ["any-arch", "rabbitizer"]
 ppc = ["any-arch", "cwdemangle", "cwextab", "ppc750cl"]
 x86 = ["any-arch", "cpp_demangle", "iced-x86", "msvc-demangler"]
 arm = ["any-arch", "cpp_demangle", "unarm", "arm-attr"]
+bindings = ["serde_json", "prost", "pbjson"]
+wasm = ["bindings", "console_error_panic_hook", "console_log"]

 [dependencies]
 anyhow = "1.0.82"
@@ -30,9 +35,15 @@ log = "0.4.21"
 memmap2 = "0.9.4"
 num-traits = "0.2.18"
 object = { version = "0.35.0", features = ["read_core", "std", "elf", "pe"], default-features = false }
+pbjson = { version = "0.7.0", optional = true }
+prost = { version = "0.13.1", optional = true }
 serde = { version = "1", features = ["derive"] }
 similar = { version = "2.5.0", default-features = false }
 strum = { version = "0.26.2", features = ["derive"] }
+wasm-bindgen = "0.2.93"
+tsify-next = { version = "0.5.4", default-features = false, features = ["js"] }
+console_log = { version = "1.0.0", optional = true }
+console_error_panic_hook = { version = "0.1.7", optional = true }

 # config
 globset = { version = "0.4.14", features = ["serde1"], optional = true }
@@ -57,5 +68,9 @@ iced-x86 = { version = "1.21.0", default-features = false, features = ["std", "d
 msvc-demangler = { version = "0.10.0", optional = true }

 # arm
-unarm = { version = "1.4.0", optional = true }
+unarm = { version = "1.5.0", optional = true }
 arm-attr = { version = "0.1.1", optional = true }
+
+[build-dependencies]
+prost-build = "0.13.1"
+pbjson-build = "0.7.0"
--- a/objdiff-core/build.rs
+++ b/objdiff-core/build.rs
@@ -0,0 +1,54 @@
+use std::path::{Path, PathBuf};
+
+fn main() {
+    let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("protos");
+    let descriptor_path = root.join("proto_descriptor.bin");
+    println!("cargo:rerun-if-changed={}", descriptor_path.display());
+    let descriptor_mtime = std::fs::metadata(&descriptor_path)
+        .map(|m| m.modified().unwrap())
+        .unwrap_or(std::time::SystemTime::UNIX_EPOCH);
+    let mut run_protoc = false;
+    let proto_files = vec![root.join("diff.proto"), root.join("report.proto")];
+    for proto_file in &proto_files {
+        println!("cargo:rerun-if-changed={}", proto_file.display());
+        let mtime = match std::fs::metadata(proto_file) {
+            Ok(m) => m.modified().unwrap(),
+            Err(e) => panic!("Failed to stat proto file {}: {:?}", proto_file.display(), e),
+        };
+        if mtime > descriptor_mtime {
+            run_protoc = true;
+        }
+    }
+
+    fn prost_config(descriptor_path: &Path, run_protoc: bool) -> prost_build::Config {
+        let mut config = prost_build::Config::new();
+        config.file_descriptor_set_path(descriptor_path);
+        // If our cached descriptor is up-to-date, we don't need to run protoc.
+        // This is helpful so that users don't need to have protoc installed
+        // unless they're updating the protos.
+        if !run_protoc {
+            config.skip_protoc_run();
+        }
+        config
+    }
+    if let Err(e) =
+        prost_config(&descriptor_path, run_protoc).compile_protos(&proto_files, &[root.as_path()])
+    {
+        if e.kind() == std::io::ErrorKind::NotFound && e.to_string().contains("protoc") {
+            eprintln!("protoc not found, skipping protobuf compilation");
+            prost_config(&descriptor_path, false)
+                .compile_protos(&proto_files, &[root.as_path()])
+                .expect("Failed to compile protos");
+        } else {
+            panic!("Failed to compile protos: {e:?}");
+        }
+    }
+
+    let descriptor_set = std::fs::read(descriptor_path).expect("Failed to read descriptor set");
+    pbjson_build::Builder::new()
+        .register_descriptors(&descriptor_set)
+        .expect("Failed to register descriptors")
+        .preserve_proto_field_names()
+        .build(&[".objdiff"])
+        .expect("Failed to build pbjson");
+}
--- a/objdiff-core/protos/diff.proto
+++ b/objdiff-core/protos/diff.proto
@@ -0,0 +1,163 @@
+syntax = "proto3";
+
+package objdiff.diff;
+
+// A symbol
+message Symbol {
+  // Name of the symbol
+  string name = 1;
+  // Demangled name of the symbol
+  optional string demangled_name = 2;
+  // Symbol address
+  uint64 address = 3;
+  // Symbol size
+  uint64 size = 4;
+  // Bitmask of SymbolFlag
+  uint32 flags = 5;
+}
+
+// Symbol visibility flags
+enum SymbolFlag {
+  SYMBOL_NONE = 0;
+  SYMBOL_GLOBAL = 1;
+  SYMBOL_LOCAL = 2;
+  SYMBOL_WEAK = 3;
+  SYMBOL_COMMON = 4;
+  SYMBOL_HIDDEN = 5;
+}
+
+// A single parsed instruction
+message Instruction {
+  // Instruction address
+  uint64 address = 1;
+  // Instruction size
+  uint32 size = 2;
+  // Instruction opcode
+  uint32 opcode = 3;
+  // Instruction mnemonic
+  string mnemonic = 4;
+  // Instruction formatted string
+  string formatted = 5;
+  // Original (unsimplified) instruction string
+  optional string original = 6;
+  // Instruction arguments
+  repeated Argument arguments = 7;
+  // Instruction relocation
+  optional Relocation relocation = 8;
+  // Instruction branch destination
+  optional uint64 branch_dest = 9;
+  // Instruction line number
+  optional uint32 line_number = 10;
+}
+
+// An instruction argument
+message Argument {
+  oneof value {
+    // Plain text
+    string plain_text = 1;
+    // Value
+    ArgumentValue argument = 2;
+    // Relocation
+    ArgumentRelocation relocation = 3;
+    // Branch destination
+    uint64 branch_dest = 4;
+  }
+}
+
+// An instruction argument value
+message ArgumentValue {
+  oneof value {
+    // Signed integer
+    int64 signed = 1;
+    // Unsigned integer
+    uint64 unsigned = 2;
+    // Opaque value
+    string opaque = 3;
+  }
+}
+
+// Marker type for relocation arguments
+message ArgumentRelocation {
+}
+
+message Relocation {
+  uint32 type = 1;
+  string type_name = 2;
+  RelocationTarget target = 3;
+}
+
+message RelocationTarget {
+  Symbol symbol = 1;
+  int64 addend = 2;
+}
+
+message InstructionDiff {
+  DiffKind diff_kind = 1;
+  optional Instruction instruction = 2;
+  optional InstructionBranchFrom branch_from = 3;
+  optional InstructionBranchTo branch_to = 4;
+  repeated ArgumentDiff arg_diff = 5;
+}
+
+message ArgumentDiff {
+  optional uint32 diff_index = 1;
+}
+
+enum DiffKind {
+  DIFF_NONE = 0;
+  DIFF_REPLACE = 1;
+  DIFF_DELETE = 2;
+  DIFF_INSERT = 3;
+  DIFF_OP_MISMATCH = 4;
+  DIFF_ARG_MISMATCH = 5;
+}
+
+message InstructionBranchFrom {
+  repeated uint32 instruction_index = 1;
+  uint32 branch_index = 2;
+}
+
+message InstructionBranchTo {
+  uint32 instruction_index = 1;
+  uint32 branch_index = 2;
+}
+
+message FunctionDiff {
+  Symbol symbol = 1;
+  repeated InstructionDiff instructions = 2;
+  optional float match_percent = 3;
+}
+
+message DataDiff {
+  DiffKind kind = 1;
+  bytes data = 2;
+  // May be larger than data
+  uint64 size = 3;
+}
+
+message SectionDiff {
+  string name = 1;
+  SectionKind kind = 2;
+  uint64 size = 3;
+  uint64 address = 4;
+  repeated FunctionDiff functions = 5;
+  repeated DataDiff data = 6;
+  optional float match_percent = 7;
+}
+
+enum SectionKind {
+  SECTION_UNKNOWN = 0;
+  SECTION_TEXT = 1;
+  SECTION_DATA = 2;
+  SECTION_BSS = 3;
+  SECTION_COMMON = 4;
+}
+
+message ObjectDiff {
+  repeated SectionDiff sections = 1;
+}
+
+message DiffResult {
+  optional ObjectDiff left = 1;
+  optional ObjectDiff right = 2;
+}
--- a/objdiff-core/protos/proto_descriptor.bin
+++ b/objdiff-core/protos/proto_descriptor.bin
--- a/objdiff-core/protos/report.proto
+++ b/objdiff-core/protos/report.proto
@@ -0,0 +1,160 @@
+syntax = "proto3";
+
+package objdiff.report;
+
+// Progress info for a report or unit
+message Measures {
+  // Overall match percent, including partially matched functions and data
+  float fuzzy_match_percent = 1;
+  // Total size of code in bytes
+  uint64 total_code = 2;
+  // Fully matched code size in bytes
+  uint64 matched_code = 3;
+  // Fully matched code percent
+  float matched_code_percent = 4;
+  // Total size of data in bytes
+  uint64 total_data = 5;
+  // Fully matched data size in bytes
+  uint64 matched_data = 6;
+  // Fully matched data percent
+  float matched_data_percent = 7;
+  // Total number of functions
+  uint32 total_functions = 8;
+  // Fully matched functions
+  uint32 matched_functions = 9;
+  // Fully matched functions percent
+  float matched_functions_percent = 10;
+  // Completed (or "linked") code size in bytes
+  uint64 complete_code = 11;
+  // Completed (or "linked") code percent
+  float complete_code_percent = 12;
+  // Completed (or "linked") data size in bytes
+  uint64 complete_data = 13;
+  // Completed (or "linked") data percent
+  float complete_data_percent = 14;
+}
+
+// Project progress report
+message Report {
+  // Overall progress info
+  Measures measures = 1;
+  // Units within this report
+  repeated ReportUnit units = 2;
+  // Report version
+  uint32 version = 3;
+  // Progress categories
+  repeated ReportCategory categories = 4;
+}
+
+message ReportCategory {
+  // The ID of the category
+  string id = 1;
+  // The name of the category
+  string name = 2;
+  // Progress info for this category
+  Measures measures = 3;
+}
+
+// A unit of the report (usually a translation unit)
+message ReportUnit {
+  // The name of the unit
+  string name = 1;
+  // Progress info for this unit
+  Measures measures = 2;
+  // Sections within this unit
+  repeated ReportItem sections = 3;
+  // Functions within this unit
+  repeated ReportItem functions = 4;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 5;
+}
+
+// Extra metadata for a unit
+message ReportUnitMetadata {
+  // Whether this unit is marked as complete (or "linked")
+  optional bool complete = 1;
+  // The name of the module this unit belongs to
+  optional string module_name = 2;
+  // The ID of the module this unit belongs to
+  optional uint32 module_id = 3;
+  // The path to the source file of this unit
+  optional string source_path = 4;
+  // Progress categories for this unit
+  repeated string progress_categories = 5;
+  // Whether this unit is automatically generated (not user-provided)
+  optional bool auto_generated = 6;
+}
+
+// A section or function within a unit
+message ReportItem {
+  // The name of the item
+  string name = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+  // The overall match percent for this item
+  float fuzzy_match_percent = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+}
+
+// Extra metadata for an item
+message ReportItemMetadata {
+  // The demangled name of the function
+  optional string demangled_name = 1;
+  // The virtual address of the function or section
+  optional uint64 virtual_address = 2;
+}
+
+// A pair of reports to compare and generate changes
+message ChangesInput {
+  // The previous report
+  Report from = 1;
+  // The current report
+  Report to = 2;
+}
+
+// Changes between two reports
+message Changes {
+  // The progress info for the previous report
+  Measures from = 1;
+  // The progress info for the current report
+  Measures to = 2;
+  // Units that changed
+  repeated ChangeUnit units = 3;
+}
+
+// A changed unit
+message ChangeUnit {
+  // The name of the unit
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional Measures from = 2;
+  // The current progress info (omitted if removed)
+  optional Measures to = 3;
+  // Sections that changed
+  repeated ChangeItem sections = 4;
+  // Functions that changed
+  repeated ChangeItem functions = 5;
+  // Extra metadata for this unit
+  optional ReportUnitMetadata metadata = 6;
+}
+
+// A changed section or function
+message ChangeItem {
+  // The name of the item
+  string name = 1;
+  // The previous progress info (omitted if new)
+  optional ChangeItemInfo from = 2;
+  // The current progress info (omitted if removed)
+  optional ChangeItemInfo to = 3;
+  // Extra metadata for this item
+  optional ReportItemMetadata metadata = 4;
+}
+
+// Progress info for a section or function
+message ChangeItemInfo {
+  // The overall match percent for this item
+  float fuzzy_match_percent = 1;
+  // The size of the item in bytes
+  uint64 size = 2;
+}
--- a/objdiff-core/src/arch/arm.rs
+++ b/objdiff-core/src/arch/arm.rs
@@ -111,7 +111,7 @@ impl ObjArch for ObjArchArm {
        code: &[u8],
        section_index: usize,
        relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
        config: &DiffObjConfig,
    ) -> Result<ProcessCodeResult> {
        let start_addr = address as u32;
@@ -150,9 +150,9 @@ impl ObjArch for ObjArchArm {
            object::Endianness::Big => unarm::Endian::Big,
        };

-        let parse_flags = ParseFlags { ual: config.arm_unified_syntax };
+        let parse_flags = ParseFlags { ual: config.arm_unified_syntax, version };

-        let mut parser = Parser::new(version, first_mapping, start_addr, endian, parse_flags, code);
+        let mut parser = Parser::new(first_mapping, start_addr, endian, parse_flags, code);

        let display_options = DisplayOptions {
            reg_names: RegNames {
@@ -168,7 +168,7 @@ impl ObjArch for ObjArchArm {
            },
        };

-        while let Some((address, op, ins)) = parser.next() {
+        while let Some((address, ins, parsed_ins)) = parser.next() {
            if let Some(next) = next_mapping {
                let next_address = parser.address;
                if next_address >= next.address {
@@ -190,12 +190,15 @@ impl ObjArch for ObjArchArm {
                    | RelocationFlags::Elf { r_type: elf::R_ARM_PC24 }
                    | RelocationFlags::Elf { r_type: elf::R_ARM_XPC25 }
                    | RelocationFlags::Elf { r_type: elf::R_ARM_CALL } => {
-                        reloc_arg =
-                            ins.args.iter().rposition(|a| matches!(a, Argument::BranchDest(_)));
+                        reloc_arg = parsed_ins
+                            .args
+                            .iter()
+                            .rposition(|a| matches!(a, Argument::BranchDest(_)));
                    }
                    // Data
                    RelocationFlags::Elf { r_type: elf::R_ARM_ABS32 } => {
-                        reloc_arg = ins.args.iter().rposition(|a| matches!(a, Argument::UImm(_)));
+                        reloc_arg =
+                            parsed_ins.args.iter().rposition(|a| matches!(a, Argument::UImm(_)));
                    }
                    _ => (),
                }
@@ -204,20 +207,20 @@ impl ObjArch for ObjArchArm {
            let (args, branch_dest) = if reloc.is_some() && parser.mode == ParseMode::Data {
                (vec![ObjInsArg::Reloc], None)
            } else {
-                push_args(&ins, config, reloc_arg, address, display_options)?
+                push_args(&parsed_ins, config, reloc_arg, address, display_options)?
            };

-            ops.push(op.id());
+            ops.push(ins.opcode_id());
            insts.push(ObjIns {
                address: address as u64,
                size: (parser.address - address) as u8,
-                op: op.id(),
-                mnemonic: ins.mnemonic.to_string(),
+                op: ins.opcode_id(),
+                mnemonic: parsed_ins.mnemonic.to_string(),
                args,
                reloc,
                branch_dest,
                line,
-                formatted: ins.display(display_options).to_string(),
+                formatted: parsed_ins.display(display_options).to_string(),
                orig: None,
            });
        }
@@ -227,6 +230,7 @@ impl ObjArch for ObjArchArm {

    fn implcit_addend(
        &self,
+        _file: &File<'_>,
        section: &ObjSection,
        address: u64,
        reloc: &Relocation,
@@ -424,7 +428,7 @@ fn push_args(
                | Argument::Shift(_)
                | Argument::CpsrFlags(_)
                | Argument::Endian(_) => args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
-                    arg.display(display_options).to_string().into(),
+                    arg.display(display_options, None).to_string().into(),
                ))),
            }
        }
--- a/objdiff-core/src/arch/mips.rs
+++ b/objdiff-core/src/arch/mips.rs
@@ -1,7 +1,10 @@
 use std::{borrow::Cow, collections::BTreeMap, sync::Mutex};

 use anyhow::{anyhow, bail, Result};
-use object::{elf, Endian, Endianness, File, FileFlags, Object, Relocation, RelocationFlags};
+use object::{
+    elf, Endian, Endianness, File, FileFlags, Object, ObjectSection, ObjectSymbol, Relocation,
+    RelocationFlags, RelocationTarget,
+};
 use rabbitizer::{config, Abi, InstrCategory, Instruction, OperandType};

 use crate::{
@@ -22,6 +25,7 @@ pub struct ObjArchMips {
    pub endianness: Endianness,
    pub abi: Abi,
    pub instr_category: InstrCategory,
+    pub ri_gp_value: i32,
 }

 const EF_MIPS_ABI: u32 = 0x0000F000;
@@ -30,6 +34,8 @@ const EF_MIPS_MACH: u32 = 0x00FF0000;
 const EF_MIPS_MACH_ALLEGREX: u32 = 0x00840000;
 const EF_MIPS_MACH_5900: u32 = 0x00920000;

+const R_MIPS15_S3: u32 = 119;
+
 impl ObjArchMips {
    pub fn new(object: &File) -> Result<Self> {
        let mut abi = Abi::NUMERIC;
@@ -56,7 +62,19 @@ impl ObjArchMips {
            }
            _ => bail!("Unsupported MIPS file flags"),
        }
-        Ok(Self { endianness: object.endianness(), abi, instr_category })
+
+        // Parse the ri_gp_value stored in .reginfo to be able to correctly
+        // calculate R_MIPS_GPREL16 relocations later. The value is stored
+        // 0x14 bytes into .reginfo (on 32 bit platforms)
+        let ri_gp_value = object
+            .section_by_name(".reginfo")
+            .and_then(|section| section.data().ok())
+            .and_then(|data| data.get(0x14..0x18))
+            .and_then(|s| s.try_into().ok())
+            .map(|bytes| object.endianness().read_i32_bytes(bytes))
+            .unwrap_or(0);
+
+        Ok(Self { endianness: object.endianness(), abi, instr_category, ri_gp_value })
    }
 }

@@ -67,7 +85,7 @@ impl ObjArch for ObjArchMips {
        code: &[u8],
        _section_index: usize,
        relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
        config: &DiffObjConfig,
    ) -> Result<ProcessCodeResult> {
        let _guard = RABBITIZER_MUTEX.lock().map_err(|e| anyhow!("Failed to lock mutex: {e}"))?;
@@ -104,7 +122,7 @@ impl ObjArch for ObjArchMips {
            let mnemonic = instruction.opcode_name().to_string();
            let is_branch = instruction.is_branch();
            let branch_offset = instruction.branch_offset();
-            let branch_dest = if is_branch {
+            let mut branch_dest = if is_branch {
                cur_addr.checked_add_signed(branch_offset).map(|a| a as u64)
            } else {
                None
@@ -121,9 +139,7 @@ impl ObjArch for ObjArchMips {
                    OperandType::cpu_immediate
                    | OperandType::cpu_label
                    | OperandType::cpu_branch_target_label => {
-                        if let Some(branch_dest) = branch_dest {
-                            args.push(ObjInsArg::BranchDest(branch_dest));
-                        } else if let Some(reloc) = reloc {
+                        if let Some(reloc) = reloc {
                            if matches!(&reloc.target_section, Some(s) if s == ".text")
                                && reloc.target.address > start_address
                                && reloc.target.address < end_address
@@ -131,7 +147,10 @@ impl ObjArch for ObjArchMips {
                                args.push(ObjInsArg::BranchDest(reloc.target.address));
                            } else {
                                push_reloc(&mut args, reloc)?;
+                                branch_dest = None;
                            }
+                        } else if let Some(branch_dest) = branch_dest {
+                            args.push(ObjInsArg::BranchDest(branch_dest));
                        } else {
                            args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
                                op.disassemble(&instruction, None).into(),
@@ -152,6 +171,18 @@ impl ObjArch for ObjArchMips {
                        )));
                        args.push(ObjInsArg::PlainText(")".into()));
                    }
+                    // OperandType::r5900_immediate15 => match reloc {
+                    //     Some(reloc)
+                    //         if reloc.flags == RelocationFlags::Elf { r_type: R_MIPS15_S3 } =>
+                    //     {
+                    //         push_reloc(&mut args, reloc)?;
+                    //     }
+                    //     _ => {
+                    //         args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
+                    //             op.disassemble(&instruction, None).into(),
+                    //         )));
+                    //     }
+                    // },
                    _ => {
                        args.push(ObjInsArg::Arg(ObjInsArgValue::Opaque(
                            op.disassemble(&instruction, None).into(),
@@ -179,6 +210,7 @@ impl ObjArch for ObjArchMips {

    fn implcit_addend(
        &self,
+        file: &File<'_>,
        section: &ObjSection,
        address: u64,
        reloc: &Relocation,
@@ -187,14 +219,29 @@ impl ObjArch for ObjArchMips {
        let addend = self.endianness.read_u32_bytes(data);
        Ok(match reloc.flags() {
            RelocationFlags::Elf { r_type: elf::R_MIPS_32 } => addend as i64,
+            RelocationFlags::Elf { r_type: elf::R_MIPS_26 } => ((addend & 0x03FFFFFF) << 2) as i64,
            RelocationFlags::Elf { r_type: elf::R_MIPS_HI16 } => {
                ((addend & 0x0000FFFF) << 16) as i32 as i64
            }
            RelocationFlags::Elf {
-                r_type:
-                    elf::R_MIPS_LO16 | elf::R_MIPS_GOT16 | elf::R_MIPS_CALL16 | elf::R_MIPS_GPREL16,
+                r_type: elf::R_MIPS_LO16 | elf::R_MIPS_GOT16 | elf::R_MIPS_CALL16,
            } => (addend & 0x0000FFFF) as i16 as i64,
-            RelocationFlags::Elf { r_type: elf::R_MIPS_26 } => ((addend & 0x03FFFFFF) << 2) as i64,
+            RelocationFlags::Elf { r_type: elf::R_MIPS_GPREL16 | elf::R_MIPS_LITERAL } => {
+                let RelocationTarget::Symbol(idx) = reloc.target() else {
+                    bail!("Unsupported R_MIPS_GPREL16 relocation against a non-symbol");
+                };
+                let sym = file.symbol_by_index(idx)?;
+
+                // if the symbol we are relocating against is in a local section we need to add
+                // the ri_gp_value from .reginfo to the addend.
+                if sym.section().index().is_some() {
+                    ((addend & 0x0000FFFF) as i16 as i64) + self.ri_gp_value as i64
+                } else {
+                    (addend & 0x0000FFFF) as i16 as i64
+                }
+            }
+            RelocationFlags::Elf { r_type: elf::R_MIPS_PC16 } => 0, // PC-relative relocation
+            RelocationFlags::Elf { r_type: R_MIPS15_S3 } => ((addend & 0x001FFFC0) >> 3) as i64,
            flags => bail!("Unsupported MIPS implicit relocation {flags:?}"),
        })
    }
@@ -202,13 +249,16 @@ impl ObjArch for ObjArchMips {
    fn display_reloc(&self, flags: RelocationFlags) -> Cow<'static, str> {
        match flags {
            RelocationFlags::Elf { r_type } => match r_type {
-                elf::R_MIPS_HI16 => Cow::Borrowed("R_MIPS_HI16"),
-                elf::R_MIPS_LO16 => Cow::Borrowed("R_MIPS_LO16"),
-                elf::R_MIPS_GOT16 => Cow::Borrowed("R_MIPS_GOT16"),
-                elf::R_MIPS_CALL16 => Cow::Borrowed("R_MIPS_CALL16"),
-                elf::R_MIPS_GPREL16 => Cow::Borrowed("R_MIPS_GPREL16"),
                elf::R_MIPS_32 => Cow::Borrowed("R_MIPS_32"),
                elf::R_MIPS_26 => Cow::Borrowed("R_MIPS_26"),
+                elf::R_MIPS_HI16 => Cow::Borrowed("R_MIPS_HI16"),
+                elf::R_MIPS_LO16 => Cow::Borrowed("R_MIPS_LO16"),
+                elf::R_MIPS_GPREL16 => Cow::Borrowed("R_MIPS_GPREL16"),
+                elf::R_MIPS_LITERAL => Cow::Borrowed("R_MIPS_LITERAL"),
+                elf::R_MIPS_GOT16 => Cow::Borrowed("R_MIPS_GOT16"),
+                elf::R_MIPS_PC16 => Cow::Borrowed("R_MIPS_PC16"),
+                elf::R_MIPS_CALL16 => Cow::Borrowed("R_MIPS_CALL16"),
+                R_MIPS15_S3 => Cow::Borrowed("R_MIPS15_S3"),
                _ => Cow::Owned(format!("<{flags:?}>")),
            },
            _ => Cow::Owned(format!("<{flags:?}>")),
@@ -244,7 +294,11 @@ fn push_reloc(args: &mut Vec<ObjInsArg>, reloc: &ObjReloc) -> Result<()> {
                args.push(ObjInsArg::Reloc);
                args.push(ObjInsArg::PlainText(")".into()));
            }
-            elf::R_MIPS_32 | elf::R_MIPS_26 => {
+            elf::R_MIPS_32
+            | elf::R_MIPS_26
+            | elf::R_MIPS_LITERAL
+            | elf::R_MIPS_PC16
+            | R_MIPS15_S3 => {
                args.push(ObjInsArg::Reloc);
            }
            _ => bail!("Unsupported ELF MIPS relocation type {r_type}"),
--- a/objdiff-core/src/arch/mod.rs
+++ b/objdiff-core/src/arch/mod.rs
@@ -1,7 +1,7 @@
 use std::{borrow::Cow, collections::BTreeMap};

 use anyhow::{bail, Result};
-use object::{Architecture, Object, ObjectSymbol, Relocation, RelocationFlags, Symbol};
+use object::{Architecture, File, Object, ObjectSymbol, Relocation, RelocationFlags, Symbol};

 use crate::{
    diff::DiffObjConfig,
@@ -24,12 +24,17 @@ pub trait ObjArch: Send + Sync {
        code: &[u8],
        section_index: usize,
        relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
        config: &DiffObjConfig,
    ) -> Result<ProcessCodeResult>;

-    fn implcit_addend(&self, section: &ObjSection, address: u64, reloc: &Relocation)
-        -> Result<i64>;
+    fn implcit_addend(
+        &self,
+        file: &File<'_>,
+        section: &ObjSection,
+        address: u64,
+        reloc: &Relocation,
+    ) -> Result<i64>;

    fn demangle(&self, _name: &str) -> Option<String> { None }

--- a/objdiff-core/src/arch/ppc.rs
+++ b/objdiff-core/src/arch/ppc.rs
@@ -35,7 +35,7 @@ impl ObjArch for ObjArchPpc {
        code: &[u8],
        _section_index: usize,
        relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
        config: &DiffObjConfig,
    ) -> Result<ProcessCodeResult> {
        let ins_count = code.len() / 4;
@@ -150,6 +150,7 @@ impl ObjArch for ObjArchPpc {

    fn implcit_addend(
        &self,
+        _file: &File<'_>,
        _section: &ObjSection,
        address: u64,
        reloc: &Relocation,
--- a/objdiff-core/src/arch/x86.rs
+++ b/objdiff-core/src/arch/x86.rs
@@ -32,7 +32,7 @@ impl ObjArch for ObjArchX86 {
        code: &[u8],
        _section_index: usize,
        relocations: &[ObjReloc],
-        line_info: &BTreeMap<u64, u64>,
+        line_info: &BTreeMap<u64, u32>,
        config: &DiffObjConfig,
    ) -> Result<ProcessCodeResult> {
        let mut result = ProcessCodeResult { ops: Vec::new(), insts: Vec::new() };
@@ -128,6 +128,7 @@ impl ObjArch for ObjArchX86 {

    fn implcit_addend(
        &self,
+        _file: &File<'_>,
        section: &ObjSection,
        address: u64,
        reloc: &Relocation,
--- a/objdiff-core/src/bindings/diff.rs
+++ b/objdiff-core/src/bindings/diff.rs
@@ -0,0 +1,244 @@
+use crate::{
+    diff::{
+        ObjDataDiff, ObjDataDiffKind, ObjDiff, ObjInsArgDiff, ObjInsBranchFrom, ObjInsBranchTo,
+        ObjInsDiff, ObjInsDiffKind, ObjSectionDiff, ObjSymbolDiff,
+    },
+    obj::{
+        ObjInfo, ObjIns, ObjInsArg, ObjInsArgValue, ObjReloc, ObjSectionKind, ObjSymbol,
+        ObjSymbolFlagSet, ObjSymbolFlags,
+    },
+};
+
+// Protobuf diff types
+include!(concat!(env!("OUT_DIR"), "/objdiff.diff.rs"));
+include!(concat!(env!("OUT_DIR"), "/objdiff.diff.serde.rs"));
+
+impl DiffResult {
+    pub fn new(left: Option<(&ObjInfo, &ObjDiff)>, right: Option<(&ObjInfo, &ObjDiff)>) -> Self {
+        Self {
+            left: left.map(|(obj, diff)| ObjectDiff::new(obj, diff)),
+            right: right.map(|(obj, diff)| ObjectDiff::new(obj, diff)),
+        }
+    }
+}
+
+impl ObjectDiff {
+    pub fn new(obj: &ObjInfo, diff: &ObjDiff) -> Self {
+        Self {
+            sections: diff
+                .sections
+                .iter()
+                .enumerate()
+                .map(|(i, d)| SectionDiff::new(obj, i, d))
+                .collect(),
+        }
+    }
+}
+
+impl SectionDiff {
+    pub fn new(obj: &ObjInfo, section_index: usize, section_diff: &ObjSectionDiff) -> Self {
+        let section = &obj.sections[section_index];
+        let functions = section_diff.symbols.iter().map(|d| FunctionDiff::new(obj, d)).collect();
+        let data = section_diff.data_diff.iter().map(|d| DataDiff::new(obj, d)).collect();
+        Self {
+            name: section.name.to_string(),
+            kind: SectionKind::from(section.kind) as i32,
+            size: section.size,
+            address: section.address,
+            functions,
+            data,
+            match_percent: section_diff.match_percent,
+        }
+    }
+}
+
+impl From<ObjSectionKind> for SectionKind {
+    fn from(value: ObjSectionKind) -> Self {
+        match value {
+            ObjSectionKind::Code => SectionKind::SectionText,
+            ObjSectionKind::Data => SectionKind::SectionData,
+            ObjSectionKind::Bss => SectionKind::SectionBss,
+            // TODO common
+        }
+    }
+}
+
+impl FunctionDiff {
+    pub fn new(object: &ObjInfo, symbol_diff: &ObjSymbolDiff) -> Self {
+        let (_section, symbol) = object.section_symbol(symbol_diff.symbol_ref);
+        // let diff_symbol = symbol_diff.diff_symbol.map(|symbol_ref| {
+        //     let (_section, symbol) = object.section_symbol(symbol_ref);
+        //     Symbol::from(symbol)
+        // });
+        let instructions = symbol_diff.instructions.iter().map(InstructionDiff::from).collect();
+        Self {
+            symbol: Some(Symbol::from(symbol)),
+            // diff_symbol,
+            instructions,
+            match_percent: symbol_diff.match_percent,
+        }
+    }
+}
+
+impl DataDiff {
+    pub fn new(_object: &ObjInfo, data_diff: &ObjDataDiff) -> Self {
+        Self {
+            kind: DiffKind::from(data_diff.kind) as i32,
+            data: data_diff.data.clone(),
+            size: data_diff.len as u64,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjSymbol> for Symbol {
+    fn from(value: &'a ObjSymbol) -> Self {
+        Self {
+            name: value.name.to_string(),
+            demangled_name: value.demangled_name.clone(),
+            address: value.address,
+            size: value.size,
+            flags: symbol_flags(value.flags),
+        }
+    }
+}
+
+fn symbol_flags(value: ObjSymbolFlagSet) -> u32 {
+    let mut flags = 0u32;
+    if value.0.contains(ObjSymbolFlags::Global) {
+        flags |= SymbolFlag::SymbolNone as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Local) {
+        flags |= SymbolFlag::SymbolLocal as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Weak) {
+        flags |= SymbolFlag::SymbolWeak as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Common) {
+        flags |= SymbolFlag::SymbolCommon as u32;
+    }
+    if value.0.contains(ObjSymbolFlags::Hidden) {
+        flags |= SymbolFlag::SymbolHidden as u32;
+    }
+    flags
+}
+
+impl<'a> From<&'a ObjIns> for Instruction {
+    fn from(value: &'a ObjIns) -> Self {
+        Self {
+            address: value.address,
+            size: value.size as u32,
+            opcode: value.op as u32,
+            mnemonic: value.mnemonic.clone(),
+            formatted: value.formatted.clone(),
+            arguments: value.args.iter().map(Argument::from).collect(),
+            relocation: value.reloc.as_ref().map(Relocation::from),
+            branch_dest: value.branch_dest,
+            line_number: value.line,
+            original: value.orig.clone(),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsArg> for Argument {
+    fn from(value: &'a ObjInsArg) -> Self {
+        Self {
+            value: Some(match value {
+                ObjInsArg::PlainText(s) => argument::Value::PlainText(s.to_string()),
+                ObjInsArg::Arg(v) => argument::Value::Argument(ArgumentValue::from(v)),
+                ObjInsArg::Reloc => argument::Value::Relocation(ArgumentRelocation {}),
+                ObjInsArg::BranchDest(dest) => argument::Value::BranchDest(*dest),
+            }),
+        }
+    }
+}
+
+impl From<&ObjInsArgValue> for ArgumentValue {
+    fn from(value: &ObjInsArgValue) -> Self {
+        Self {
+            value: Some(match value {
+                ObjInsArgValue::Signed(v) => argument_value::Value::Signed(*v),
+                ObjInsArgValue::Unsigned(v) => argument_value::Value::Unsigned(*v),
+                ObjInsArgValue::Opaque(v) => argument_value::Value::Opaque(v.to_string()),
+            }),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjReloc> for Relocation {
+    fn from(value: &ObjReloc) -> Self {
+        Self {
+            r#type: match value.flags {
+                object::RelocationFlags::Elf { r_type } => r_type,
+                object::RelocationFlags::MachO { r_type, .. } => r_type as u32,
+                object::RelocationFlags::Coff { typ } => typ as u32,
+                object::RelocationFlags::Xcoff { r_rtype, .. } => r_rtype as u32,
+                _ => unreachable!(),
+            },
+            type_name: String::new(), // TODO
+            target: Some(RelocationTarget::from(&value.target)),
+        }
+    }
+}
+
+impl<'a> From<&'a ObjSymbol> for RelocationTarget {
+    fn from(value: &'a ObjSymbol) -> Self {
+        Self { symbol: Some(Symbol::from(value)), addend: value.addend }
+    }
+}
+
+impl<'a> From<&'a ObjInsDiff> for InstructionDiff {
+    fn from(value: &'a ObjInsDiff) -> Self {
+        Self {
+            instruction: value.ins.as_ref().map(Instruction::from),
+            diff_kind: DiffKind::from(value.kind) as i32,
+            branch_from: value.branch_from.as_ref().map(InstructionBranchFrom::from),
+            branch_to: value.branch_to.as_ref().map(InstructionBranchTo::from),
+            arg_diff: value.arg_diff.iter().map(ArgumentDiff::from).collect(),
+        }
+    }
+}
+
+impl From<&Option<ObjInsArgDiff>> for ArgumentDiff {
+    fn from(value: &Option<ObjInsArgDiff>) -> Self {
+        Self { diff_index: value.as_ref().map(|v| v.idx as u32) }
+    }
+}
+
+impl From<ObjInsDiffKind> for DiffKind {
+    fn from(value: ObjInsDiffKind) -> Self {
+        match value {
+            ObjInsDiffKind::None => DiffKind::DiffNone,
+            ObjInsDiffKind::OpMismatch => DiffKind::DiffOpMismatch,
+            ObjInsDiffKind::ArgMismatch => DiffKind::DiffArgMismatch,
+            ObjInsDiffKind::Replace => DiffKind::DiffReplace,
+            ObjInsDiffKind::Delete => DiffKind::DiffDelete,
+            ObjInsDiffKind::Insert => DiffKind::DiffInsert,
+        }
+    }
+}
+
+impl From<ObjDataDiffKind> for DiffKind {
+    fn from(value: ObjDataDiffKind) -> Self {
+        match value {
+            ObjDataDiffKind::None => DiffKind::DiffNone,
+            ObjDataDiffKind::Replace => DiffKind::DiffReplace,
+            ObjDataDiffKind::Delete => DiffKind::DiffDelete,
+            ObjDataDiffKind::Insert => DiffKind::DiffInsert,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsBranchFrom> for InstructionBranchFrom {
+    fn from(value: &'a ObjInsBranchFrom) -> Self {
+        Self {
+            instruction_index: value.ins_idx.iter().map(|&x| x as u32).collect(),
+            branch_index: value.branch_idx as u32,
+        }
+    }
+}
+
+impl<'a> From<&'a ObjInsBranchTo> for InstructionBranchTo {
+    fn from(value: &'a ObjInsBranchTo) -> Self {
+        Self { instruction_index: value.ins_idx as u32, branch_index: value.branch_idx as u32 }
+    }
+}
--- a/objdiff-core/src/bindings/mod.rs
+++ b/objdiff-core/src/bindings/mod.rs
@@ -0,0 +1,5 @@
+#[cfg(feature = "any-arch")]
+pub mod diff;
+pub mod report;
+#[cfg(feature = "wasm")]
+pub mod wasm;
--- a/objdiff-core/src/bindings/report.rs
+++ b/objdiff-core/src/bindings/report.rs
@@ -0,0 +1,332 @@
+use std::ops::AddAssign;
+
+use anyhow::{bail, Result};
+use prost::Message;
+use serde_json::error::Category;
+
+// Protobuf report types
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.rs"));
+include!(concat!(env!("OUT_DIR"), "/objdiff.report.serde.rs"));
+
+pub const REPORT_VERSION: u32 = 1;
+
+impl Report {
+    pub fn parse(data: &[u8]) -> Result<Self> {
+        if data.is_empty() {
+            bail!(std::io::Error::from(std::io::ErrorKind::UnexpectedEof));
+        }
+        let report = if data[0] == b'{' {
+            // Load as JSON
+            Self::from_json(data)?
+        } else {
+            // Load as binary protobuf
+            Self::decode(data)?
+        };
+        Ok(report)
+    }
+
+    fn from_json(bytes: &[u8]) -> Result<Self, serde_json::Error> {
+        match serde_json::from_slice::<Self>(bytes) {
+            Ok(report) => Ok(report),
+            Err(e) => {
+                match e.classify() {
+                    Category::Io | Category::Eof | Category::Syntax => Err(e),
+                    Category::Data => {
+                        // Try to load as legacy report
+                        match serde_json::from_slice::<LegacyReport>(bytes) {
+                            Ok(legacy_report) => Ok(Report::from(legacy_report)),
+                            Err(_) => Err(e),
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn migrate(&mut self) -> Result<()> {
+        if self.version == 0 {
+            self.migrate_v0()?;
+        }
+        if self.version != REPORT_VERSION {
+            bail!("Unsupported report version: {}", self.version);
+        }
+        Ok(())
+    }
+
+    fn migrate_v0(&mut self) -> Result<()> {
+        let Some(measures) = &mut self.measures else {
+            bail!("Missing measures in report");
+        };
+        for unit in &mut self.units {
+            let Some(unit_measures) = &mut unit.measures else {
+                bail!("Missing measures in report unit");
+            };
+            let Some(metadata) = &mut unit.metadata else {
+                bail!("Missing metadata in report unit");
+            };
+            if metadata.module_name.is_some() || metadata.module_id.is_some() {
+                metadata.progress_categories = vec!["modules".to_string()];
+            } else {
+                metadata.progress_categories = vec!["dol".to_string()];
+            }
+            if metadata.complete.unwrap_or(false) {
+                unit_measures.complete_code = unit_measures.total_code;
+                unit_measures.complete_data = unit_measures.total_data;
+                unit_measures.complete_code_percent = 100.0;
+                unit_measures.complete_data_percent = 100.0;
+            } else {
+                unit_measures.complete_code = 0;
+                unit_measures.complete_data = 0;
+                unit_measures.complete_code_percent = 0.0;
+                unit_measures.complete_data_percent = 0.0;
+            }
+            measures.complete_code += unit_measures.complete_code;
+            measures.complete_data += unit_measures.complete_data;
+        }
+        measures.calc_matched_percent();
+        self.version = 1;
+        Ok(())
+    }
+
+    pub fn calculate_progress_categories(&mut self) {
+        for unit in &self.units {
+            let Some(metadata) = unit.metadata.as_ref() else {
+                continue;
+            };
+            let Some(measures) = unit.measures.as_ref() else {
+                continue;
+            };
+            for category_id in &metadata.progress_categories {
+                let category = match self.categories.iter_mut().find(|c| &c.id == category_id) {
+                    Some(category) => category,
+                    None => {
+                        self.categories.push(ReportCategory {
+                            id: category_id.clone(),
+                            name: String::new(),
+                            measures: Some(Default::default()),
+                        });
+                        self.categories.last_mut().unwrap()
+                    }
+                };
+                *category.measures.get_or_insert_with(Default::default) += *measures;
+            }
+        }
+        for category in &mut self.categories {
+            let measures = category.measures.get_or_insert_with(Default::default);
+            measures.calc_fuzzy_match_percent();
+            measures.calc_matched_percent();
+        }
+    }
+}
+
+impl Measures {
+    /// Average the fuzzy match percentage over total code bytes.
+    pub fn calc_fuzzy_match_percent(&mut self) {
+        if self.total_code == 0 {
+            self.fuzzy_match_percent = 100.0;
+        } else {
+            self.fuzzy_match_percent /= self.total_code as f32;
+        }
+    }
+
+    /// Calculate the percentage of matched code, data, and functions.
+    pub fn calc_matched_percent(&mut self) {
+        self.matched_code_percent = if self.total_code == 0 {
+            100.0
+        } else {
+            self.matched_code as f32 / self.total_code as f32 * 100.0
+        };
+        self.matched_data_percent = if self.total_data == 0 {
+            100.0
+        } else {
+            self.matched_data as f32 / self.total_data as f32 * 100.0
+        };
+        self.matched_functions_percent = if self.total_functions == 0 {
+            100.0
+        } else {
+            self.matched_functions as f32 / self.total_functions as f32 * 100.0
+        };
+        self.complete_code_percent = if self.total_code == 0 {
+            100.0
+        } else {
+            self.complete_code as f32 / self.total_code as f32 * 100.0
+        };
+        self.complete_data_percent = if self.total_data == 0 {
+            100.0
+        } else {
+            self.complete_data as f32 / self.total_data as f32 * 100.0
+        };
+    }
+}
+
+impl From<&ReportItem> for ChangeItemInfo {
+    fn from(value: &ReportItem) -> Self {
+        Self { fuzzy_match_percent: value.fuzzy_match_percent, size: value.size }
+    }
+}
+
+impl AddAssign for Measures {
+    fn add_assign(&mut self, other: Self) {
+        self.fuzzy_match_percent += other.fuzzy_match_percent * other.total_code as f32;
+        self.total_code += other.total_code;
+        self.matched_code += other.matched_code;
+        self.total_data += other.total_data;
+        self.matched_data += other.matched_data;
+        self.total_functions += other.total_functions;
+        self.matched_functions += other.matched_functions;
+        self.complete_code += other.complete_code;
+        self.complete_data += other.complete_data;
+    }
+}
+
+/// Allows [collect](Iterator::collect) to be used on an iterator of [Measures].
+impl FromIterator<Measures> for Measures {
+    fn from_iter<T>(iter: T) -> Self
+    where T: IntoIterator<Item = Measures> {
+        let mut measures = Measures::default();
+        for other in iter {
+            measures += other;
+        }
+        measures.calc_fuzzy_match_percent();
+        measures.calc_matched_percent();
+        measures
+    }
+}
+
+// Older JSON report types
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReport {
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    matched_code_percent: f32,
+    total_data: u64,
+    matched_data: u64,
+    matched_data_percent: f32,
+    total_functions: u32,
+    matched_functions: u32,
+    matched_functions_percent: f32,
+    units: Vec<LegacyReportUnit>,
+}
+
+impl From<LegacyReport> for Report {
+    fn from(value: LegacyReport) -> Self {
+        Self {
+            measures: Some(Measures {
+                fuzzy_match_percent: value.fuzzy_match_percent,
+                total_code: value.total_code,
+                matched_code: value.matched_code,
+                matched_code_percent: value.matched_code_percent,
+                total_data: value.total_data,
+                matched_data: value.matched_data,
+                matched_data_percent: value.matched_data_percent,
+                total_functions: value.total_functions,
+                matched_functions: value.matched_functions,
+                matched_functions_percent: value.matched_functions_percent,
+                ..Default::default()
+            }),
+            units: value.units.into_iter().map(ReportUnit::from).collect::<Vec<_>>(),
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReportUnit {
+    name: String,
+    fuzzy_match_percent: f32,
+    total_code: u64,
+    matched_code: u64,
+    total_data: u64,
+    matched_data: u64,
+    total_functions: u32,
+    matched_functions: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    complete: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    module_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    module_id: Option<u32>,
+    sections: Vec<LegacyReportItem>,
+    functions: Vec<LegacyReportItem>,
+}
+
+impl From<LegacyReportUnit> for ReportUnit {
+    fn from(value: LegacyReportUnit) -> Self {
+        let mut measures = Measures {
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            total_code: value.total_code,
+            matched_code: value.matched_code,
+            total_data: value.total_data,
+            matched_data: value.matched_data,
+            total_functions: value.total_functions,
+            matched_functions: value.matched_functions,
+            ..Default::default()
+        };
+        measures.calc_matched_percent();
+        Self {
+            name: value.name.clone(),
+            measures: Some(measures),
+            sections: value.sections.into_iter().map(ReportItem::from).collect(),
+            functions: value.functions.into_iter().map(ReportItem::from).collect(),
+            metadata: Some(ReportUnitMetadata {
+                complete: value.complete,
+                module_name: value.module_name.clone(),
+                module_id: value.module_id,
+                ..Default::default()
+            }),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize)]
+struct LegacyReportItem {
+    name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    demangled_name: Option<String>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        serialize_with = "serialize_hex",
+        deserialize_with = "deserialize_hex"
+    )]
+    address: Option<u64>,
+    size: u64,
+    fuzzy_match_percent: f32,
+}
+
+impl From<LegacyReportItem> for ReportItem {
+    fn from(value: LegacyReportItem) -> Self {
+        Self {
+            name: value.name,
+            size: value.size,
+            fuzzy_match_percent: value.fuzzy_match_percent,
+            metadata: Some(ReportItemMetadata {
+                demangled_name: value.demangled_name,
+                virtual_address: value.address,
+            }),
+        }
+    }
+}
+
+fn serialize_hex<S>(x: &Option<u64>, s: S) -> Result<S::Ok, S::Error>
+where S: serde::Serializer {
+    if let Some(x) = x {
+        s.serialize_str(&format!("{:#x}", x))
+    } else {
+        s.serialize_none()
+    }
+}
+
+fn deserialize_hex<'de, D>(d: D) -> Result<Option<u64>, D::Error>
+where D: serde::Deserializer<'de> {
+    use serde::Deserialize;
+    let s = String::deserialize(d)?;
+    if s.is_empty() {
+        Ok(None)
+    } else if !s.starts_with("0x") {
+        Err(serde::de::Error::custom("expected hex string"))
+    } else {
+        u64::from_str_radix(&s[2..], 16).map(Some).map_err(serde::de::Error::custom)
+    }
+}
--- a/objdiff-core/src/bindings/wasm.rs
+++ b/objdiff-core/src/bindings/wasm.rs
@@ -0,0 +1,78 @@
+use prost::Message;
+use wasm_bindgen::prelude::*;
+
+use crate::{bindings::diff::DiffResult, diff, obj};
+
+fn parse_object(
+    data: Option<Box<[u8]>>,
+    config: &diff::DiffObjConfig,
+) -> Result<Option<obj::ObjInfo>, JsError> {
+    data.as_ref().map(|data| obj::read::parse(data, config)).transpose().to_js()
+}
+
+fn parse_and_run_diff(
+    left: Option<Box<[u8]>>,
+    right: Option<Box<[u8]>>,
+    config: diff::DiffObjConfig,
+) -> Result<DiffResult, JsError> {
+    let target = parse_object(left, &config)?;
+    let base = parse_object(right, &config)?;
+    run_diff(target.as_ref(), base.as_ref(), config)
+}
+
+fn run_diff(
+    left: Option<&obj::ObjInfo>,
+    right: Option<&obj::ObjInfo>,
+    config: diff::DiffObjConfig,
+) -> Result<DiffResult, JsError> {
+    log::debug!("Running diff with config: {:?}", config);
+    let result = diff::diff_objs(&config, left, right, None).to_js()?;
+    let left = left.and_then(|o| result.left.as_ref().map(|d| (o, d)));
+    let right = right.and_then(|o| result.right.as_ref().map(|d| (o, d)));
+    Ok(DiffResult::new(left, right))
+}
+
+// #[wasm_bindgen]
+// pub fn run_diff_json(
+//     left: Option<Box<[u8]>>,
+//     right: Option<Box<[u8]>>,
+//     config: diff::DiffObjConfig,
+// ) -> Result<String, JsError> {
+//     let out = run_diff_opt_box(left, right, config)?;
+//     serde_json::to_string(&out).map_err(|e| JsError::new(&e.to_string()))
+// }
+
+#[wasm_bindgen]
+pub fn run_diff_proto(
+    left: Option<Box<[u8]>>,
+    right: Option<Box<[u8]>>,
+    config: diff::DiffObjConfig,
+) -> Result<Box<[u8]>, JsError> {
+    let out = parse_and_run_diff(left, right, config)?;
+    Ok(out.encode_to_vec().into_boxed_slice())
+}
+
+#[wasm_bindgen(start)]
+fn start() -> Result<(), JsError> {
+    console_error_panic_hook::set_once();
+    #[cfg(debug_assertions)]
+    console_log::init_with_level(log::Level::Debug).to_js()?;
+    #[cfg(not(debug_assertions))]
+    console_log::init_with_level(log::Level::Info).to_js()?;
+    Ok(())
+}
+
+#[inline]
+fn to_js_error(e: impl std::fmt::Display) -> JsError { JsError::new(&e.to_string()) }
+
+trait ToJsResult {
+    type Output;
+
+    fn to_js(self) -> Result<Self::Output, JsError>;
+}
+
+impl<T, E: std::fmt::Display> ToJsResult for Result<T, E> {
+    type Output = T;
+
+    fn to_js(self) -> Result<T, JsError> { self.map_err(to_js_error) }
+}
--- a/objdiff-core/src/config/mod.rs
+++ b/objdiff-core/src/config/mod.rs
@@ -31,6 +31,8 @@ pub struct ProjectConfig {
    pub watch_patterns: Option<Vec<Glob>>,
    #[serde(default, alias = "units")]
    pub objects: Vec<ProjectObject>,
+    #[serde(default)]
+    pub progress_categories: Vec<ProjectProgressCategory>,
 }

 #[derive(Default, Clone, serde::Deserialize)]
@@ -44,11 +46,37 @@ pub struct ProjectObject {
    #[serde(default)]
    pub base_path: Option<PathBuf>,
    #[serde(default)]
+    #[deprecated(note = "Use metadata.reverse_fn_order")]
    pub reverse_fn_order: Option<bool>,
    #[serde(default)]
+    #[deprecated(note = "Use metadata.complete")]
    pub complete: Option<bool>,
    #[serde(default)]
    pub scratch: Option<ScratchConfig>,
+    #[serde(default)]
+    pub metadata: Option<ProjectObjectMetadata>,
+}
+
+#[derive(Default, Clone, serde::Deserialize)]
+pub struct ProjectObjectMetadata {
+    #[serde(default)]
+    pub complete: Option<bool>,
+    #[serde(default)]
+    pub reverse_fn_order: Option<bool>,
+    #[serde(default)]
+    pub source_path: Option<String>,
+    #[serde(default)]
+    pub progress_categories: Option<Vec<String>>,
+    #[serde(default)]
+    pub auto_generated: Option<bool>,
+}
+
+#[derive(Default, Clone, serde::Deserialize)]
+pub struct ProjectProgressCategory {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
 }

 impl ProjectObject {
@@ -82,6 +110,20 @@ impl ProjectObject {
            self.base_path = Some(project_dir.join(path));
        }
    }
+
+    pub fn complete(&self) -> Option<bool> {
+        #[allow(deprecated)]
+        self.metadata.as_ref().and_then(|m| m.complete).or(self.complete)
+    }
+
+    pub fn reverse_fn_order(&self) -> Option<bool> {
+        #[allow(deprecated)]
+        self.metadata.as_ref().and_then(|m| m.reverse_fn_order).or(self.reverse_fn_order)
+    }
+
+    pub fn hidden(&self) -> bool {
+        self.metadata.as_ref().and_then(|m| m.auto_generated).unwrap_or(false)
+    }
 }

 #[derive(Default, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
--- a/objdiff-core/src/diff/code.rs
+++ b/objdiff-core/src/diff/code.rs
@@ -1,8 +1,4 @@
-use std::{
-    cmp::max,
-    collections::BTreeMap,
-    time::{Duration, Instant},
-};
+use std::{cmp::max, collections::BTreeMap};

 use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, Algorithm};
@@ -100,13 +96,8 @@ fn diff_instructions(
    left_code: &ProcessCodeResult,
    right_code: &ProcessCodeResult,
 ) -> Result<()> {
-    let deadline = Instant::now() + Duration::from_secs(5);
-    let ops = capture_diff_slices_deadline(
-        Algorithm::Patience,
-        &left_code.ops,
-        &right_code.ops,
-        Some(deadline),
-    );
+    let ops =
+        capture_diff_slices_deadline(Algorithm::Patience, &left_code.ops, &right_code.ops, None);
    if ops.is_empty() {
        left_diff.extend(
            left_code
--- a/objdiff-core/src/diff/data.rs
+++ b/objdiff-core/src/diff/data.rs
@@ -1,7 +1,4 @@
-use std::{
-    cmp::{max, min, Ordering},
-    time::{Duration, Instant},
-};
+use std::cmp::{max, min, Ordering};

 use anyhow::{anyhow, Result};
 use similar::{capture_diff_slices_deadline, get_diff_ratio, Algorithm};
@@ -47,13 +44,14 @@ pub fn diff_data_section(
    left_section_diff: &ObjSectionDiff,
    right_section_diff: &ObjSectionDiff,
 ) -> Result<(ObjSectionDiff, ObjSectionDiff)> {
-    let deadline = Instant::now() + Duration::from_secs(5);
-    let left_max = left.symbols.iter().map(|s| s.section_address + s.size).max().unwrap_or(0);
-    let right_max = right.symbols.iter().map(|s| s.section_address + s.size).max().unwrap_or(0);
+    let left_max =
+        left.symbols.iter().map(|s| s.section_address + s.size).max().unwrap_or(0).min(left.size);
+    let right_max =
+        right.symbols.iter().map(|s| s.section_address + s.size).max().unwrap_or(0).min(right.size);
    let left_data = &left.data[..left_max as usize];
    let right_data = &right.data[..right_max as usize];
-    let ops =
-        capture_diff_slices_deadline(Algorithm::Patience, left_data, right_data, Some(deadline));
+    let ops = capture_diff_slices_deadline(Algorithm::Patience, left_data, right_data, None);
+    let match_percent = get_diff_ratio(&ops, left_data.len(), right_data.len()) * 100.0;

    let mut left_diff = Vec::<ObjDataDiff>::new();
    let mut right_diff = Vec::<ObjDataDiff>::new();
@@ -127,6 +125,13 @@ pub fn diff_data_section(
        diff_generic_section(left, right, left_section_diff, right_section_diff)?;
    left_section_diff.data_diff = left_diff;
    right_section_diff.data_diff = right_diff;
+    // Use the highest match percent between two options:
+    // - Left symbols matching right symbols by name
+    // - Diff of the data itself
+    if left_section_diff.match_percent.unwrap_or(-1.0) < match_percent {
+        left_section_diff.match_percent = Some(match_percent);
+        right_section_diff.match_percent = Some(match_percent);
+    }
    Ok((left_section_diff, right_section_diff))
 }

@@ -147,9 +152,7 @@ pub fn diff_data_symbol(
    let right_data = &right_section.data[right_symbol.section_address as usize
        ..(right_symbol.section_address + right_symbol.size) as usize];

-    let deadline = Instant::now() + Duration::from_secs(5);
-    let ops =
-        capture_diff_slices_deadline(Algorithm::Patience, left_data, right_data, Some(deadline));
+    let ops = capture_diff_slices_deadline(Algorithm::Patience, left_data, right_data, None);
    let match_percent = get_diff_ratio(&ops, left_data.len(), right_data.len()) * 100.0;

    Ok((
@@ -191,3 +194,29 @@ pub fn diff_generic_section(
        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
    ))
 }
+
+/// Compare the addresses and sizes of each symbol in the BSS sections.
+pub fn diff_bss_section(
+    left: &ObjSection,
+    right: &ObjSection,
+    left_diff: &ObjSectionDiff,
+    right_diff: &ObjSectionDiff,
+) -> Result<(ObjSectionDiff, ObjSectionDiff)> {
+    let left_sizes = left.symbols.iter().map(|s| (s.section_address, s.size)).collect::<Vec<_>>();
+    let right_sizes = right.symbols.iter().map(|s| (s.section_address, s.size)).collect::<Vec<_>>();
+    let ops = capture_diff_slices_deadline(Algorithm::Patience, &left_sizes, &right_sizes, None);
+    let mut match_percent = get_diff_ratio(&ops, left_sizes.len(), right_sizes.len()) * 100.0;
+
+    // Use the highest match percent between two options:
+    // - Left symbols matching right symbols by name
+    // - Diff of the addresses and sizes of each symbol
+    let (generic_diff, _) = diff_generic_section(left, right, left_diff, right_diff)?;
+    if generic_diff.match_percent.unwrap_or(-1.0) > match_percent {
+        match_percent = generic_diff.match_percent.unwrap();
+    }
+
+    Ok((
+        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
+        ObjSectionDiff { symbols: vec![], data_diff: vec![], match_percent: Some(match_percent) },
+    ))
+}
--- a/objdiff-core/src/diff/display.rs
+++ b/objdiff-core/src/diff/display.rs
@@ -12,7 +12,7 @@ pub enum DiffText<'a> {
    /// Colored text
    BasicColor(&'a str, usize),
    /// Line number
-    Line(usize),
+    Line(u32),
    /// Instruction address
    Address(u64),
    /// Instruction mnemonic
@@ -20,7 +20,7 @@ pub enum DiffText<'a> {
    /// Instruction argument
    Argument(&'a ObjInsArgValue, Option<&'a ObjInsArgDiff>),
    /// Branch destination
-    BranchDest(u64),
+    BranchDest(u64, Option<&'a ObjInsArgDiff>),
    /// Symbol name
    Symbol(&'a ObjSymbol),
    /// Number of spaces
@@ -49,7 +49,7 @@ pub fn display_diff<E>(
        return Ok(());
    };
    if let Some(line) = ins.line {
-        cb(DiffText::Line(line as usize))?;
+        cb(DiffText::Line(line))?;
    }
    cb(DiffText::Address(ins.address - base_addr))?;
    if let Some(branch) = &ins_diff.branch_from {
@@ -62,12 +62,12 @@ pub fn display_diff<E>(
        if i == 0 {
            cb(DiffText::Spacing(1))?;
        }
+        let diff = ins_diff.arg_diff.get(i).and_then(|o| o.as_ref());
        match arg {
            ObjInsArg::PlainText(s) => {
                cb(DiffText::Basic(s))?;
            }
            ObjInsArg::Arg(v) => {
-                let diff = ins_diff.arg_diff.get(i).and_then(|o| o.as_ref());
                cb(DiffText::Argument(v, diff))?;
            }
            ObjInsArg::Reloc => {
@@ -75,7 +75,7 @@ pub fn display_diff<E>(
            }
            ObjInsArg::BranchDest(dest) => {
                if let Some(dest) = dest.checked_sub(base_addr) {
-                    cb(DiffText::BranchDest(dest))?;
+                    cb(DiffText::BranchDest(dest, diff))?;
                } else {
                    cb(DiffText::Basic("<unknown>"))?;
                }
@@ -107,7 +107,9 @@ impl PartialEq<DiffText<'_>> for HighlightKind {
            (HighlightKind::Opcode(a), DiffText::Opcode(_, b)) => a == b,
            (HighlightKind::Arg(a), DiffText::Argument(b, _)) => a.loose_eq(b),
            (HighlightKind::Symbol(a), DiffText::Symbol(b)) => a == &b.name,
-            (HighlightKind::Address(a), DiffText::Address(b) | DiffText::BranchDest(b)) => a == b,
+            (HighlightKind::Address(a), DiffText::Address(b) | DiffText::BranchDest(b, _)) => {
+                a == b
+            }
            _ => false,
        }
    }
@@ -123,7 +125,7 @@ impl From<DiffText<'_>> for HighlightKind {
            DiffText::Opcode(_, op) => HighlightKind::Opcode(op),
            DiffText::Argument(arg, _) => HighlightKind::Arg(arg.clone()),
            DiffText::Symbol(sym) => HighlightKind::Symbol(sym.name.to_string()),
-            DiffText::Address(addr) | DiffText::BranchDest(addr) => HighlightKind::Address(addr),
+            DiffText::Address(addr) | DiffText::BranchDest(addr, _) => HighlightKind::Address(addr),
            _ => HighlightKind::None,
        }
    }
--- a/objdiff-core/src/diff/mod.rs
+++ b/objdiff-core/src/diff/mod.rs
@@ -6,8 +6,8 @@ use crate::{
    diff::{
        code::{diff_code, no_diff_code, process_code_symbol},
        data::{
-            diff_bss_symbol, diff_data_section, diff_data_symbol, diff_generic_section,
-            no_diff_symbol,
+            diff_bss_section, diff_bss_symbol, diff_data_section, diff_data_symbol,
+            diff_generic_section, no_diff_symbol,
        },
    },
    obj::{ObjInfo, ObjIns, ObjSection, ObjSectionKind, ObjSymbol, SymbolRef},
@@ -28,6 +28,7 @@ pub mod display;
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
+    tsify_next::Tsify,
 )]
 pub enum X86Formatter {
    #[default]
@@ -52,6 +53,7 @@ pub enum X86Formatter {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
+    tsify_next::Tsify,
 )]
 pub enum MipsAbi {
    #[default]
@@ -76,6 +78,7 @@ pub enum MipsAbi {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
+    tsify_next::Tsify,
 )]
 pub enum MipsInstrCategory {
    #[default]
@@ -104,6 +107,7 @@ pub enum MipsInstrCategory {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
+    tsify_next::Tsify,
 )]
 pub enum ArmArchVersion {
    #[default]
@@ -128,6 +132,7 @@ pub enum ArmArchVersion {
    serde::Serialize,
    strum::VariantArray,
    strum::EnumMessage,
+    tsify_next::Tsify,
 )]
 pub enum ArmR9Usage {
    #[default]
@@ -148,7 +153,8 @@ pub enum ArmR9Usage {
 #[inline]
 const fn default_true() -> bool { true }

-#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, tsify_next::Tsify)]
+#[tsify(from_wasm_abi)]
 #[serde(default)]
 pub struct DiffObjConfig {
    pub relax_reloc_diffs: bool,
@@ -483,7 +489,7 @@ pub fn diff_objs(
            let left_section = &left_obj.sections[left_section_idx];
            let right_section = &right_obj.sections[right_section_idx];
            match section_kind {
-                ObjSectionKind::Code | ObjSectionKind::Bss => {
+                ObjSectionKind::Code => {
                    let left_section_diff = left_out.section_diff(left_section_idx);
                    let right_section_diff = right_out.section_diff(right_section_idx);
                    let (left_diff, right_diff) = diff_generic_section(
@@ -507,6 +513,18 @@ pub fn diff_objs(
                    left_out.section_diff_mut(left_section_idx).merge(left_diff);
                    right_out.section_diff_mut(right_section_idx).merge(right_diff);
                }
+                ObjSectionKind::Bss => {
+                    let left_section_diff = left_out.section_diff(left_section_idx);
+                    let right_section_diff = right_out.section_diff(right_section_idx);
+                    let (left_diff, right_diff) = diff_bss_section(
+                        left_section,
+                        right_section,
+                        left_section_diff,
+                        right_section_diff,
+                    )?;
+                    left_out.section_diff_mut(left_section_idx).merge(left_diff);
+                    right_out.section_diff_mut(right_section_idx).merge(right_diff);
+                }
            }
        }
    }
@@ -546,8 +564,8 @@ fn matching_symbols(
            for (symbol_idx, symbol) in section.symbols.iter().enumerate() {
                let symbol_match = SymbolMatch {
                    left: Some(SymbolRef { section_idx, symbol_idx }),
-                    right: find_symbol(right, symbol, section),
-                    prev: find_symbol(prev, symbol, section),
+                    right: find_symbol(right, symbol, section, Some(&right_used)),
+                    prev: find_symbol(prev, symbol, section, None),
                    section_kind: section.kind,
                };
                matches.push(symbol_match);
@@ -579,7 +597,7 @@ fn matching_symbols(
                matches.push(SymbolMatch {
                    left: None,
                    right: Some(symbol_ref),
-                    prev: find_symbol(prev, symbol, section),
+                    prev: find_symbol(prev, symbol, section, None),
                    section_kind: section.kind,
                });
            }
@@ -600,10 +618,25 @@ fn matching_symbols(
    Ok(matches)
 }

+fn unmatched_symbols<'section, 'used>(
+    section: &'section ObjSection,
+    section_idx: usize,
+    used: Option<&'used HashSet<SymbolRef>>,
+) -> impl Iterator<Item = (usize, &'section ObjSymbol)> + 'used
+where
+    'section: 'used,
+{
+    section.symbols.iter().enumerate().filter(move |&(symbol_idx, _)| {
+        // Skip symbols that have already been matched
+        !used.map(|u| u.contains(&SymbolRef { section_idx, symbol_idx })).unwrap_or(false)
+    })
+}
+
 fn find_symbol(
    obj: Option<&ObjInfo>,
    in_symbol: &ObjSymbol,
    in_section: &ObjSection,
+    used: Option<&HashSet<SymbolRef>>,
 ) -> Option<SymbolRef> {
    let obj = obj?;
    // Try to find an exact name match
@@ -611,8 +644,8 @@ fn find_symbol(
        if section.kind != in_section.kind {
            continue;
        }
-        if let Some(symbol_idx) =
-            section.symbols.iter().position(|symbol| symbol.name == in_symbol.name)
+        if let Some((symbol_idx, _)) = unmatched_symbols(section, section_idx, used)
+            .find(|(_, symbol)| symbol.name == in_symbol.name)
        {
            return Some(SymbolRef { section_idx, symbol_idx });
        }
@@ -625,9 +658,11 @@ fn find_symbol(
        if let Some((section_idx, section)) =
            obj.sections.iter().enumerate().find(|(_, s)| s.name == in_section.name)
        {
-            if let Some(symbol_idx) = section.symbols.iter().position(|symbol| {
-                symbol.address == in_symbol.address && symbol.name.starts_with('@')
-            }) {
+            if let Some((symbol_idx, _)) =
+                unmatched_symbols(section, section_idx, used).find(|(_, symbol)| {
+                    symbol.address == in_symbol.address && symbol.name.starts_with('@')
+                })
+            {
                return Some(SymbolRef { section_idx, symbol_idx });
            }
        }
@@ -641,13 +676,15 @@ fn find_symbol(
            if section.kind != in_section.kind {
                continue;
            }
-            if let Some(symbol_idx) = section.symbols.iter().position(|symbol| {
-                if let Some((p, s)) = symbol.name.split_once('$') {
-                    prefix == p && s.chars().all(char::is_numeric)
-                } else {
-                    false
-                }
-            }) {
+            if let Some((symbol_idx, _)) =
+                unmatched_symbols(section, section_idx, used).find(|&(_, symbol)| {
+                    if let Some((p, s)) = symbol.name.split_once('$') {
+                        prefix == p && s.chars().all(char::is_numeric)
+                    } else {
+                        false
+                    }
+                })
+            {
                return Some(SymbolRef { section_idx, symbol_idx });
            }
        }
--- a/objdiff-core/src/lib.rs
+++ b/objdiff-core/src/lib.rs
@@ -1,9 +1,11 @@
+#[cfg(feature = "any-arch")]
 pub mod arch;
+#[cfg(feature = "bindings")]
+pub mod bindings;
 #[cfg(feature = "config")]
 pub mod config;
+#[cfg(feature = "any-arch")]
 pub mod diff;
+#[cfg(feature = "any-arch")]
 pub mod obj;
 pub mod util;
-
-#[cfg(not(feature = "any-arch"))]
-compile_error!("At least one architecture feature must be enabled.");
--- a/objdiff-core/src/obj/mod.rs
+++ b/objdiff-core/src/obj/mod.rs
@@ -41,7 +41,7 @@ pub struct ObjSection {
    pub relocations: Vec<ObjReloc>,
    pub virtual_address: Option<u64>,
    /// Line number info (.line or .debug_line section)
-    pub line_info: BTreeMap<u64, u64>,
+    pub line_info: BTreeMap<u64, u32>,
 }

 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -103,7 +103,7 @@ pub struct ObjIns {
    pub reloc: Option<ObjReloc>,
    pub branch_dest: Option<u64>,
    /// Line number
-    pub line: Option<u64>,
+    pub line: Option<u32>,
    /// Formatted instruction
    pub formatted: String,
    /// Original (unsimplified) instruction
@@ -136,8 +136,8 @@ pub struct ObjExtab {

 pub struct ObjInfo {
    pub arch: Box<dyn ObjArch>,
-    pub path: PathBuf,
-    pub timestamp: FileTime,
+    pub path: Option<PathBuf>,
+    pub timestamp: Option<FileTime>,
    pub sections: Vec<ObjSection>,
    /// Common BSS symbols
    pub common: Vec<ObjSymbol>,
--- a/objdiff-core/src/obj/read.rs
+++ b/objdiff-core/src/obj/read.rs
@@ -1,7 +1,6 @@
 use std::{collections::HashSet, fs, io::Cursor, path::Path};

 use anyhow::{anyhow, bail, ensure, Context, Result};
-use byteorder::{BigEndian, ReadBytesExt};
 use cwextab::decode_extab;
 use filetime::FileTime;
 use flagset::Flags;
@@ -18,6 +17,7 @@ use crate::{
        ObjExtab, ObjInfo, ObjReloc, ObjSection, ObjSectionKind, ObjSymbol, ObjSymbolFlagSet,
        ObjSymbolFlags,
    },
+    util::{read_u16, read_u32},
 };

 fn to_obj_section_kind(kind: SectionKind) -> Option<ObjSectionKind> {
@@ -149,7 +149,7 @@ fn symbols_by_section(
            }
        }
    }
-    result.sort_by_key(|v| v.address);
+    result.sort_by(|a, b| a.address.cmp(&b.address).then(a.size.cmp(&b.size)));
    let mut iter = result.iter_mut().peekable();
    while let Some(symbol) = iter.next() {
        if symbol.size == 0 {
@@ -160,6 +160,23 @@ fn symbols_by_section(
            }
        }
    }
+    if result.is_empty() {
+        // Dummy symbol for empty sections
+        result.push(ObjSymbol {
+            name: format!("[{}]", section.name),
+            demangled_name: None,
+            has_extab: false,
+            extab_name: None,
+            extabindex_name: None,
+            address: 0,
+            section_address: 0,
+            size: section.size,
+            size_known: true,
+            flags: Default::default(),
+            addend: 0,
+            virtual_address: None,
+        });
+    }
    Ok(result)
 }

@@ -364,7 +381,7 @@ fn relocations_by_section(
            _ => None,
        };
        let addend = if reloc.has_implicit_addend() {
-            arch.implcit_addend(section, address, &reloc)?
+            arch.implcit_addend(obj_file, section, address, &reloc)?
        } else {
            reloc.addend()
        };
@@ -398,8 +415,8 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
                .index()
                .0;
            let start = reader.position();
-            let size = reader.read_u32::<BigEndian>()?;
-            let base_address = reader.read_u32::<BigEndian>()? as u64;
+            let size = read_u32(obj_file, &mut reader)?;
+            let base_address = read_u32(obj_file, &mut reader)? as u64;
            let Some(out_section) =
                sections.iter_mut().find(|s| s.orig_index == text_section_index)
            else {
@@ -409,12 +426,12 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
            };
            let end = start + size as u64;
            while reader.position() < end {
-                let line_number = reader.read_u32::<BigEndian>()? as u64;
-                let statement_pos = reader.read_u16::<BigEndian>()?;
+                let line_number = read_u32(obj_file, &mut reader)?;
+                let statement_pos = read_u16(obj_file, &mut reader)?;
                if statement_pos != 0xFFFF {
                    log::warn!("Unhandled statement pos {}", statement_pos);
                }
-                let address_delta = reader.read_u32::<BigEndian>()? as u64;
+                let address_delta = read_u32(obj_file, &mut reader)? as u64;
                out_section.line_info.insert(base_address + address_delta, line_number);
                log::debug!("Line: {:#x} -> {}", base_address + address_delta, line_number);
            }
@@ -451,7 +468,7 @@ fn line_info(obj_file: &File<'_>, sections: &mut [ObjSection]) -> Result<()> {
                let mut rows = program.rows();
                while let Some((_header, row)) = rows.next_row()? {
                    if let (Some(line), Some(lines)) = (row.line(), &mut lines) {
-                        lines.insert(row.address(), line.get());
+                        lines.insert(row.address(), line.get() as u32);
                    }
                    if row.end_sequence() {
                        // The next row is the start of a new sequence, which means we must
@@ -583,7 +600,14 @@ pub fn read(obj_path: &Path, config: &DiffObjConfig) -> Result<ObjInfo> {
        let timestamp = FileTime::from_last_modification_time(&file.metadata()?);
        (unsafe { memmap2::Mmap::map(&file) }?, timestamp)
    };
-    let obj_file = File::parse(&*data)?;
+    let mut obj = parse(&data, config)?;
+    obj.path = Some(obj_path.to_owned());
+    obj.timestamp = Some(timestamp);
+    Ok(obj)
+}
+
+pub fn parse(data: &[u8], config: &DiffObjConfig) -> Result<ObjInfo> {
+    let obj_file = File::parse(data)?;
    let arch = new_arch(&obj_file)?;
    let split_meta = split_meta(&obj_file)?;
    let mut sections = filter_sections(&obj_file, split_meta.as_ref())?;
@@ -599,7 +623,7 @@ pub fn read(obj_path: &Path, config: &DiffObjConfig) -> Result<ObjInfo> {
    line_info(&obj_file, &mut sections)?;
    let common = common_symbols(arch.as_ref(), &obj_file, split_meta.as_ref())?;
    let extab = exception_tables(&mut sections, &obj_file)?;
-    Ok(ObjInfo { arch, path: obj_path.to_owned(), timestamp, sections, common, extab, split_meta })
+    Ok(ObjInfo { arch, path: None, timestamp: None, sections, common, extab, split_meta })
 }

 pub fn has_function(obj_path: &Path, symbol_name: &str) -> Result<bool> {
--- a/objdiff-core/src/util.rs
+++ b/objdiff-core/src/util.rs
@@ -1,9 +1,15 @@
-use std::fmt::{LowerHex, UpperHex};
+use std::{
+    fmt::{LowerHex, UpperHex},
+    io::Read,
+};

+use anyhow::Result;
+use byteorder::{NativeEndian, ReadBytesExt};
 use num_traits::PrimInt;
+use object::{Endian, Object};

 // https://stackoverflow.com/questions/44711012/how-do-i-format-a-signed-integer-to-a-sign-aware-hexadecimal-representation
-pub(crate) struct ReallySigned<N: PrimInt>(pub(crate) N);
+pub struct ReallySigned<N: PrimInt>(pub(crate) N);

 impl<N: PrimInt> LowerHex for ReallySigned<N> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -22,3 +28,11 @@ impl<N: PrimInt> UpperHex for ReallySigned<N> {
        f.pad_integral(num >= 0, prefix, &bare_hex)
    }
 }
+
+pub fn read_u32<R: Read>(obj_file: &object::File, reader: &mut R) -> Result<u32> {
+    Ok(obj_file.endianness().read_u32(reader.read_u32::<NativeEndian>()?))
+}
+
+pub fn read_u16<R: Read>(obj_file: &object::File, reader: &mut R) -> Result<u16> {
+    Ok(obj_file.endianness().read_u16(reader.read_u16::<NativeEndian>()?))
+}
--- a/objdiff-gui/Cargo.toml
+++ b/objdiff-gui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "objdiff-gui"
-version = "2.0.0-beta.1"
+version = "2.0.0-beta.5"
 edition = "2021"
 rust-version = "1.70"
 authors = ["Luke Street <luke@street.dev>"]
@@ -18,7 +18,7 @@ name = "objdiff"
 path = "src/main.rs"

 [features]
-default = ["wgpu", "wsl"]
+default = ["glow", "wgpu", "wsl"]
 glow = ["eframe/glow"]
 wgpu = ["eframe/wgpu", "dep:wgpu"]
 wsl = []
--- a/objdiff-gui/src/app.rs
+++ b/objdiff-gui/src/app.rs
@@ -275,7 +275,7 @@ impl App {
        #[cfg(feature = "glow")]
        if let Some(gl) = &cc.gl {
            use eframe::glow::HasContext;
-            app.view_state.graphics_state.active_backend = "OpenGL".to_string();
+            app.view_state.graphics_state.active_backend = "OpenGL (Fallback)".to_string();
            app.view_state.graphics_state.active_device =
                unsafe { gl.get_parameter_string(0x1F01) }; // GL_RENDERER
        }
@@ -401,13 +401,17 @@ impl App {

        if let Some(result) = &diff_state.build {
            if let Some((obj, _)) = &result.first_obj {
-                if file_modified(&obj.path, obj.timestamp) {
-                    config.queue_reload = true;
+                if let (Some(path), Some(timestamp)) = (&obj.path, obj.timestamp) {
+                    if file_modified(path, timestamp) {
+                        config.queue_reload = true;
+                    }
                }
            }
            if let Some((obj, _)) = &result.second_obj {
-                if file_modified(&obj.path, obj.timestamp) {
-                    config.queue_reload = true;
+                if let (Some(path), Some(timestamp)) = (&obj.path, obj.timestamp) {
+                    if file_modified(path, timestamp) {
+                        config.queue_reload = true;
+                    }
                }
            }
        }
--- a/objdiff-gui/src/main.rs
+++ b/objdiff-gui/src/main.rs
@@ -11,6 +11,7 @@ mod views;

 use std::{
    path::PathBuf,
+    process::ExitCode,
    rc::Rc,
    sync::{Arc, Mutex},
 };
@@ -37,7 +38,7 @@ const APP_NAME: &str = "objdiff";

 // When compiling natively:
 #[cfg(not(target_arch = "wasm32"))]
-fn main() {
+fn main() -> ExitCode {
    // Log to stdout (if you run with `RUST_LOG=debug`).
    tracing_subscriber::fmt::init();

@@ -48,7 +49,6 @@ fn main() {

    let app_path = std::env::current_exe().ok();
    let exec_path: Rc<Mutex<Option<PathBuf>>> = Rc::new(Mutex::new(None));
-    let exec_path_clone = exec_path.clone();
    let mut native_options =
        eframe::NativeOptions { follow_system_theme: false, ..Default::default() };
    match load_icon() {
@@ -56,7 +56,7 @@ fn main() {
            native_options.viewport.icon = Some(Arc::new(data));
        }
        Err(e) => {
-            log::warn!("Failed to load application icon: {}", e);
+            log::warn!("Failed to load application icon: {e:?}");
        }
    }
    let mut graphics_config = GraphicsConfig::default();
@@ -69,7 +69,7 @@ fn main() {
            }
            Ok(None) => {}
            Err(e) => {
-                log::error!("Failed to load native config: {:?}", e);
+                log::error!("Failed to load native config: {e:?}");
            }
        }
        graphics_config_path = Some(config_path);
@@ -87,6 +87,104 @@ fn main() {
            };
        }
    }
+    let mut eframe_error = None;
+    if let Err(e) = run_eframe(
+        native_options.clone(),
+        utc_offset,
+        exec_path.clone(),
+        app_path.clone(),
+        graphics_config.clone(),
+        graphics_config_path.clone(),
+    ) {
+        eframe_error = Some(e);
+    }
+    #[cfg(feature = "wgpu")]
+    if let Some(e) = eframe_error {
+        // Attempt to relaunch using wgpu auto backend if the desired backend failed
+        #[allow(unused_mut)]
+        let mut should_relaunch = graphics_config.desired_backend != GraphicsBackend::Auto;
+        #[cfg(feature = "glow")]
+        {
+            // If the desired backend is OpenGL, we should try to relaunch using the glow renderer
+            should_relaunch &= graphics_config.desired_backend != GraphicsBackend::OpenGL;
+        }
+        if should_relaunch {
+            log::warn!("Failed to launch application: {e:?}");
+            log::warn!("Attempting to relaunch using auto-detected backend");
+            native_options.wgpu_options.supported_backends = Default::default();
+            if let Err(e) = run_eframe(
+                native_options.clone(),
+                utc_offset,
+                exec_path.clone(),
+                app_path.clone(),
+                graphics_config.clone(),
+                graphics_config_path.clone(),
+            ) {
+                eframe_error = Some(e);
+            } else {
+                eframe_error = None;
+            }
+        } else {
+            eframe_error = Some(e);
+        }
+    }
+    #[cfg(all(feature = "wgpu", feature = "glow"))]
+    if let Some(e) = eframe_error {
+        // Attempt to relaunch using the glow renderer if the wgpu backend failed
+        log::warn!("Failed to launch application: {e:?}");
+        log::warn!("Attempting to relaunch using fallback OpenGL backend");
+        native_options.renderer = eframe::Renderer::Glow;
+        if let Err(e) = run_eframe(
+            native_options,
+            utc_offset,
+            exec_path.clone(),
+            app_path,
+            graphics_config,
+            graphics_config_path,
+        ) {
+            eframe_error = Some(e);
+        } else {
+            eframe_error = None;
+        }
+    }
+    if let Some(e) = eframe_error {
+        log::error!("Failed to launch application: {e:?}");
+        return ExitCode::FAILURE;
+    }
+
+    // Attempt to relaunch application from the updated path
+    if let Ok(mut guard) = exec_path.lock() {
+        if let Some(path) = guard.take() {
+            cfg_if! {
+                if #[cfg(unix)] {
+                    let e = exec::Command::new(path)
+                        .args(&std::env::args().collect::<Vec<String>>())
+                        .exec();
+                    log::error!("Failed to relaunch: {e:?}");
+                    return ExitCode::FAILURE;
+                } else {
+                    let result = std::process::Command::new(path)
+                        .args(std::env::args())
+                        .spawn();
+                    if let Err(e) = result {
+                        log::error!("Failed to relaunch: {e:?}");
+                        return ExitCode::FAILURE;
+                    }
+                }
+            }
+        }
+    };
+    ExitCode::SUCCESS
+}
+
+fn run_eframe(
+    native_options: eframe::NativeOptions,
+    utc_offset: UtcOffset,
+    exec_path_clone: Rc<Mutex<Option<PathBuf>>>,
+    app_path: Option<PathBuf>,
+    graphics_config: GraphicsConfig,
+    graphics_config_path: Option<PathBuf>,
+) -> Result<(), eframe::Error> {
    eframe::run_native(
        APP_NAME,
        native_options,
@@ -101,28 +199,6 @@ fn main() {
            ))
        }),
    )
-    .expect("Failed to run eframe application");
-
-    // Attempt to relaunch application from the updated path
-    if let Ok(mut guard) = exec_path.lock() {
-        if let Some(path) = guard.take() {
-            cfg_if! {
-                if #[cfg(unix)] {
-                    let result = exec::Command::new(path)
-                        .args(&std::env::args().collect::<Vec<String>>())
-                        .exec();
-                    log::error!("Failed to relaunch: {result:?}");
-                } else {
-                    let result = std::process::Command::new(path)
-                        .args(std::env::args())
-                        .spawn();
-                    if let Err(e) = result {
-                        log::error!("Failed to relaunch: {:?}", e);
-                    }
-                }
-            }
-        }
-    };
 }

 // when compiling to web using trunk.
--- a/objdiff-gui/src/views/config.rs
+++ b/objdiff-gui/src/views/config.rs
@@ -1,7 +1,6 @@
 #[cfg(all(windows, feature = "wsl"))]
 use std::string::FromUtf16Error;
 use std::{
-    borrow::Cow,
    mem::take,
    path::{PathBuf, MAIN_SEPARATOR},
 };
@@ -50,6 +49,7 @@ pub struct ConfigViewState {
    pub object_search: String,
    pub filter_diffable: bool,
    pub filter_incomplete: bool,
+    pub show_hidden: bool,
    #[cfg(all(windows, feature = "wsl"))]
    pub available_wsl_distros: Option<Vec<String>>,
    pub file_dialog_state: FileDialogState,
@@ -283,20 +283,18 @@ pub fn config_ui(
                root_open = Some(true);
                node_open = NodeOpen::Object;
            }
-            if ui
-                .selectable_label(state.filter_diffable, "Diffable")
-                .on_hover_text_at_pointer("Only show objects with a source file")
-                .clicked()
-            {
-                state.filter_diffable = !state.filter_diffable;
-            }
-            if ui
-                .selectable_label(state.filter_incomplete, "Incomplete")
-                .on_hover_text_at_pointer("Only show objects not marked complete")
-                .clicked()
-            {
-                state.filter_incomplete = !state.filter_incomplete;
+            let mut filters_text = RichText::new("Filter ⏷");
+            if state.filter_diffable || state.filter_incomplete || state.show_hidden {
+                filters_text = filters_text.color(appearance.replace_color);
            }
+            egui::menu::menu_button(ui, filters_text, |ui| {
+                ui.checkbox(&mut state.filter_diffable, "Diffable")
+                    .on_hover_text_at_pointer("Only show objects with a source file");
+                ui.checkbox(&mut state.filter_incomplete, "Incomplete")
+                    .on_hover_text_at_pointer("Only show objects not marked complete");
+                ui.checkbox(&mut state.show_hidden, "Hidden")
+                    .on_hover_text_at_pointer("Show hidden (auto-generated) objects");
+            });
        });
        if state.object_search.is_empty() {
            if had_search {
@@ -315,27 +313,18 @@ pub fn config_ui(
        .open(root_open)
        .default_open(true)
        .show(ui, |ui| {
-            let mut nodes = Cow::Borrowed(object_nodes);
-            if !state.object_search.is_empty() || state.filter_diffable || state.filter_incomplete {
-                let search = state.object_search.to_ascii_lowercase();
-                nodes = Cow::Owned(
-                    object_nodes
-                        .iter()
-                        .filter_map(|node| {
-                            filter_node(
-                                node,
-                                &search,
-                                state.filter_diffable,
-                                state.filter_incomplete,
-                            )
-                        })
-                        .collect(),
-                );
-            }
-
+            let search = state.object_search.to_ascii_lowercase();
            ui.style_mut().wrap = Some(false);
-            for node in nodes.iter() {
-                display_node(ui, &mut new_selected_obj, node, appearance, node_open);
+            for node in object_nodes.iter().filter_map(|node| {
+                filter_node(
+                    node,
+                    &search,
+                    state.filter_diffable,
+                    state.filter_incomplete,
+                    state.show_hidden,
+                )
+            }) {
+                display_node(ui, &mut new_selected_obj, &node, appearance, node_open);
            }
        });
    }
@@ -365,7 +354,7 @@ fn display_object(
    let selected = matches!(selected_obj, Some(obj) if obj.name == object_name);
    let color = if selected {
        appearance.emphasized_text_color
-    } else if let Some(complete) = object.complete {
+    } else if let Some(complete) = object.complete() {
        if complete {
            appearance.insert_color
        } else {
@@ -392,8 +381,8 @@ fn display_object(
            name: object_name.to_string(),
            target_path: object.target_path.clone(),
            base_path: object.base_path.clone(),
-            reverse_fn_order: object.reverse_fn_order,
-            complete: object.complete,
+            reverse_fn_order: object.reverse_fn_order(),
+            complete: object.complete(),
            scratch: object.scratch.clone(),
        });
    }
@@ -464,13 +453,15 @@ fn filter_node(
    search: &str,
    filter_diffable: bool,
    filter_incomplete: bool,
+    show_hidden: bool,
 ) -> Option<ProjectObjectNode> {
    match node {
        ProjectObjectNode::File(name, object) => {
            if (search.is_empty() || name.to_ascii_lowercase().contains(search))
                && (!filter_diffable
                    || (object.base_path.is_some() && object.target_path.is_some()))
-                && (!filter_incomplete || matches!(object.complete, None | Some(false)))
+                && (!filter_incomplete || matches!(object.complete(), None | Some(false)))
+                && (show_hidden || !object.hidden())
            {
                Some(node.clone())
            } else {
@@ -478,15 +469,11 @@ fn filter_node(
            }
        }
        ProjectObjectNode::Dir(name, children) => {
-            if (search.is_empty() || name.to_ascii_lowercase().contains(search))
-                && !filter_diffable
-                && !filter_incomplete
-            {
-                return Some(node.clone());
-            }
            let new_children = children
                .iter()
-                .filter_map(|child| filter_node(child, search, filter_diffable, filter_incomplete))
+                .filter_map(|child| {
+                    filter_node(child, search, filter_diffable, filter_incomplete, show_hidden)
+                })
                .collect::<Vec<_>>();
            if !new_children.is_empty() {
                Some(ProjectObjectNode::Dir(name.clone(), new_children))
--- a/objdiff-gui/src/views/function_diff.rs
+++ b/objdiff-gui/src/views/function_diff.rs
@@ -216,8 +216,11 @@ fn diff_text_ui(
                base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
            }
        }
-        DiffText::BranchDest(addr) => {
+        DiffText::BranchDest(addr, diff) => {
            label_text = format!("{addr:x}");
+            if let Some(diff) = diff {
+                base_color = appearance.diff_colors[diff.idx % appearance.diff_colors.len()]
+            }
        }
        DiffText::Symbol(sym) => {
            let name = sym.demangled_name.as_ref().unwrap_or(&sym.name);
--- a/objdiff-gui/src/views/graphics.rs
+++ b/objdiff-gui/src/views/graphics.rs
@@ -36,7 +36,7 @@ pub enum GraphicsBackend {
    OpenGL,
 }

-#[derive(Debug, Default, serde::Deserialize, serde::Serialize)]
+#[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
 pub struct GraphicsConfig {
    #[serde(default)]
    pub desired_backend: GraphicsBackend,
--- a/objdiff-gui/src/views/symbol_diff.rs
+++ b/objdiff-gui/src/views/symbol_diff.rs
@@ -233,21 +233,28 @@ fn symbol_ui(
    {
        selected = symbol_diff.symbol_ref == sym_ref;
    }
-    write_text("[", appearance.text_color, &mut job, appearance.code_font.clone());
-    if symbol.flags.0.contains(ObjSymbolFlags::Common) {
-        write_text("c", appearance.replace_color, &mut job, appearance.code_font.clone());
-    } else if symbol.flags.0.contains(ObjSymbolFlags::Global) {
-        write_text("g", appearance.insert_color, &mut job, appearance.code_font.clone());
-    } else if symbol.flags.0.contains(ObjSymbolFlags::Local) {
-        write_text("l", appearance.text_color, &mut job, appearance.code_font.clone());
+    if !symbol.flags.0.is_empty() {
+        write_text("[", appearance.text_color, &mut job, appearance.code_font.clone());
+        if symbol.flags.0.contains(ObjSymbolFlags::Common) {
+            write_text("c", appearance.replace_color, &mut job, appearance.code_font.clone());
+        } else if symbol.flags.0.contains(ObjSymbolFlags::Global) {
+            write_text("g", appearance.insert_color, &mut job, appearance.code_font.clone());
+        } else if symbol.flags.0.contains(ObjSymbolFlags::Local) {
+            write_text("l", appearance.text_color, &mut job, appearance.code_font.clone());
+        }
+        if symbol.flags.0.contains(ObjSymbolFlags::Weak) {
+            write_text("w", appearance.text_color, &mut job, appearance.code_font.clone());
+        }
+        if symbol.flags.0.contains(ObjSymbolFlags::Hidden) {
+            write_text(
+                "h",
+                appearance.deemphasized_text_color,
+                &mut job,
+                appearance.code_font.clone(),
+            );
+        }
+        write_text("] ", appearance.text_color, &mut job, appearance.code_font.clone());
    }
-    if symbol.flags.0.contains(ObjSymbolFlags::Weak) {
-        write_text("w", appearance.text_color, &mut job, appearance.code_font.clone());
-    }
-    if symbol.flags.0.contains(ObjSymbolFlags::Hidden) {
-        write_text("h", appearance.deemphasized_text_color, &mut job, appearance.code_font.clone());
-    }
-    write_text("] ", appearance.text_color, &mut job, appearance.code_font.clone());
    if let Some(match_percent) = symbol_diff.match_percent {
        write_text("(", appearance.text_color, &mut job, appearance.code_font.clone());
        write_text(
--- a/objdiff-wasm/.gitignore
+++ b/objdiff-wasm/.gitignore
@@ -0,0 +1,4 @@
+dist/
+gen/
+node_modules/
+pkg/
--- a/objdiff-wasm/eslint.config.js
+++ b/objdiff-wasm/eslint.config.js
@@ -0,0 +1,28 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default [
+    {files: ["**/*.{js,mjs,cjs,ts}"]},
+    {languageOptions: {globals: globals.browser}},
+    pluginJs.configs.recommended,
+    ...tseslint.configs.recommended,
+    {
+        rules: {
+            "semi": [2, "always"],
+            "@typescript-eslint/no-unused-vars": [
+                "error",
+                // https://typescript-eslint.io/rules/no-unused-vars/#benefits-over-typescript
+                {
+                    "args": "all",
+                    "argsIgnorePattern": "^_",
+                    "caughtErrors": "all",
+                    "caughtErrorsIgnorePattern": "^_",
+                    "destructuredArrayIgnorePattern": "^_",
+                    "varsIgnorePattern": "^_",
+                    "ignoreRestSiblings": true
+                },
+            ],
+        }
+    },
+];
--- a/objdiff-wasm/package-lock.json
+++ b/objdiff-wasm/package-lock.json
--- a/objdiff-wasm/package.json
+++ b/objdiff-wasm/package.json
@@ -0,0 +1,39 @@
+{
+  "name": "objdiff-wasm",
+  "version": "2.0.0-beta.10",
+  "description": "A local diffing tool for decompilation projects.",
+  "author": {
+    "name": "Luke Street",
+    "email": "luke@street.dev"
+  },
+  "license": "MIT OR Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/encounter/objdiff.git"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "build:all": "npm run build:wasm && npm run build:proto && npm run build",
+    "build:proto": "protoc --ts_out=gen --ts_opt add_pb_suffix,eslint_disable,ts_nocheck,use_proto_field_name --proto_path=../objdiff-core/protos ../objdiff-core/protos/*.proto",
+    "build:wasm": "cd ../objdiff-core && wasm-pack build --out-dir ../objdiff-wasm/pkg --target web -- --features arm,dwarf,ppc,x86,wasm"
+  },
+  "dependencies": {
+    "@protobuf-ts/runtime": "^2.9.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.9.0",
+    "@protobuf-ts/plugin": "^2.9.4",
+    "@types/node": "^22.4.1",
+    "esbuild": "^0.23.1",
+    "eslint": "^9.9.0",
+    "globals": "^15.9.0",
+    "tsup": "^8.2.4",
+    "typescript-eslint": "^8.2.0"
+  }
+}
--- a/objdiff-wasm/src/main.ts
+++ b/objdiff-wasm/src/main.ts
@@ -0,0 +1,227 @@
+import {ArgumentValue, DiffResult, InstructionDiff, RelocationTarget} from "../gen/diff_pb";
+import type {
+    ArmArchVersion,
+    ArmR9Usage,
+    DiffObjConfig,
+    MipsAbi,
+    MipsInstrCategory,
+    X86Formatter
+} from '../pkg';
+import {AnyHandlerData, InMessage, OutMessage} from './worker';
+
+// Export wasm types
+export {ArmArchVersion, ArmR9Usage, MipsAbi, MipsInstrCategory, X86Formatter, DiffObjConfig};
+
+// Export protobuf types
+export * from '../gen/diff_pb';
+
+interface PromiseCallbacks<T> {
+    start: number;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: string) => void;
+}
+
+let workerInit = false;
+let workerCallbacks: PromiseCallbacks<Worker>;
+const workerReady = new Promise<Worker>((resolve, reject) => {
+    workerCallbacks = {start: performance.now(), resolve, reject};
+});
+
+export async function initialize(data?: {
+    workerUrl?: string | URL,
+    wasmUrl?: string | URL, // Relative to worker URL
+}): Promise<Worker> {
+    if (workerInit) {
+        return workerReady;
+    }
+    workerInit = true;
+    let {workerUrl, wasmUrl} = data || {};
+    if (!workerUrl) {
+        try {
+            // Bundlers will convert this into an asset URL
+            workerUrl = new URL('./worker.js', import.meta.url);
+        } catch (_) {
+            workerUrl = 'worker.js';
+        }
+    }
+    if (!wasmUrl) {
+        try {
+            // Bundlers will convert this into an asset URL
+            wasmUrl = new URL('./objdiff_core_bg.wasm', import.meta.url);
+        } catch (_) {
+            wasmUrl = 'objdiff_core_bg.js';
+        }
+    }
+    const worker = new Worker(workerUrl, {
+        name: 'objdiff',
+        type: 'module',
+    });
+    worker.onmessage = onMessage;
+    worker.onerror = (event) => {
+        console.error("Worker error", event);
+        workerCallbacks.reject("Worker failed to initialize, wrong URL?");
+    };
+    defer<void>({
+        type: 'init',
+        // URL can't be sent directly
+        wasmUrl: wasmUrl.toString(),
+    }, worker).then(() => {
+        workerCallbacks.resolve(worker);
+    }, (e) => {
+        workerCallbacks.reject(e);
+    });
+    return workerReady;
+}
+
+let globalMessageId = 0;
+const messageCallbacks = new Map<number, PromiseCallbacks<never>>();
+
+function onMessage(event: MessageEvent<OutMessage>) {
+    switch (event.data.type) {
+        case 'result': {
+            const {result, error, messageId} = event.data;
+            const callbacks = messageCallbacks.get(messageId);
+            if (callbacks) {
+                const end = performance.now();
+                console.debug(`Message ${messageId} took ${end - callbacks.start}ms`);
+                messageCallbacks.delete(messageId);
+                if (error != null) {
+                    callbacks.reject(error);
+                } else {
+                    callbacks.resolve(result as never);
+                }
+            } else {
+                console.warn(`Unknown message ID ${messageId}`);
+            }
+            break;
+        }
+    }
+}
+
+async function defer<T>(message: AnyHandlerData, worker?: Worker): Promise<T> {
+    worker = worker || await initialize();
+    const messageId = globalMessageId++;
+    const promise = new Promise<T>((resolve, reject) => {
+        messageCallbacks.set(messageId, {start: performance.now(), resolve, reject});
+    });
+    worker.postMessage({
+        ...message,
+        messageId
+    } as InMessage);
+    return promise;
+}
+
+export async function runDiff(left: Uint8Array | undefined, right: Uint8Array | undefined, config?: DiffObjConfig): Promise<DiffResult> {
+    const data = await defer<Uint8Array>({
+        type: 'run_diff_proto',
+        left,
+        right,
+        config
+    });
+    const parseStart = performance.now();
+    const result = DiffResult.fromBinary(data, {readUnknownField: false});
+    const end = performance.now();
+    console.debug(`Parsing message took ${end - parseStart}ms`);
+    return result;
+}
+
+export type DiffText =
+    DiffTextBasic
+    | DiffTextBasicColor
+    | DiffTextAddress
+    | DiffTextLine
+    | DiffTextOpcode
+    | DiffTextArgument
+    | DiffTextSymbol
+    | DiffTextBranchDest
+    | DiffTextSpacing;
+
+type DiffTextBase = {
+    diff_index?: number,
+};
+export type DiffTextBasic = DiffTextBase & {
+    type: 'basic',
+    text: string,
+};
+export type DiffTextBasicColor = DiffTextBase & {
+    type: 'basic_color',
+    text: string,
+    index: number,
+};
+export type DiffTextAddress = DiffTextBase & {
+    type: 'address',
+    address: bigint,
+};
+export type DiffTextLine = DiffTextBase & {
+    type: 'line',
+    line_number: number,
+};
+export type DiffTextOpcode = DiffTextBase & {
+    type: 'opcode',
+    mnemonic: string,
+    opcode: number,
+};
+export type DiffTextArgument = DiffTextBase & {
+    type: 'argument',
+    value: ArgumentValue,
+};
+export type DiffTextSymbol = DiffTextBase & {
+    type: 'symbol',
+    target: RelocationTarget,
+};
+export type DiffTextBranchDest = DiffTextBase & {
+    type: 'branch_dest',
+    address: bigint,
+};
+export type DiffTextSpacing = DiffTextBase & {
+    type: 'spacing',
+    count: number,
+};
+
+// Native JavaScript implementation of objdiff_core::diff::display::display_diff
+export function displayDiff(diff: InstructionDiff, baseAddr: bigint, cb: (text: DiffText) => void) {
+    const ins = diff.instruction;
+    if (!ins) {
+        return;
+    }
+    if (ins.line_number != null) {
+        cb({type: 'line', line_number: ins.line_number});
+    }
+    cb({type: 'address', address: ins.address - baseAddr});
+    if (diff.branch_from) {
+        cb({type: 'basic_color', text: ' ~> ', index: diff.branch_from.branch_index});
+    } else {
+        cb({type: 'spacing', count: 4});
+    }
+    cb({type: 'opcode', mnemonic: ins.mnemonic, opcode: ins.opcode});
+    for (let i = 0; i < ins.arguments.length; i++) {
+        if (i === 0) {
+            cb({type: 'spacing', count: 1});
+        }
+        const arg = ins.arguments[i].value;
+        const diff_index = diff.arg_diff[i]?.diff_index;
+        switch (arg.oneofKind) {
+            case "plain_text":
+                cb({type: 'basic', text: arg.plain_text, diff_index});
+                break;
+            case "argument":
+                cb({type: 'argument', value: arg.argument, diff_index});
+                break;
+            case "relocation": {
+                const reloc = ins.relocation!;
+                cb({type: 'symbol', target: reloc.target!, diff_index});
+                break;
+            }
+            case "branch_dest":
+                if (arg.branch_dest < baseAddr) {
+                    cb({type: 'basic', text: '<unknown>', diff_index});
+                } else {
+                    cb({type: 'branch_dest', address: arg.branch_dest - baseAddr, diff_index});
+                }
+                break;
+        }
+    }
+    if (diff.branch_to) {
+        cb({type: 'basic_color', text: ' ~> ', index: diff.branch_to.branch_index});
+    }
+}
--- a/objdiff-wasm/src/worker.ts
+++ b/objdiff-wasm/src/worker.ts
@@ -0,0 +1,93 @@
+import wasmInit, * as exports from '../pkg';
+
+const handlers = {
+    init: init,
+    // run_diff_json: run_diff_json,
+    run_diff_proto: run_diff_proto,
+} as const;
+type ExtractData<T> = T extends (arg: infer U) => Promise<unknown> ? U : never;
+type HandlerData = {
+    [K in keyof typeof handlers]: { type: K } & ExtractData<typeof handlers[K]>;
+};
+
+let wasmReady: Promise<void> | null = null;
+
+async function init({wasmUrl}: { wasmUrl?: string }): Promise<void> {
+    if (wasmReady != null) {
+        throw new Error('Already initialized');
+    }
+    wasmReady = wasmInit({module_or_path: wasmUrl})
+        .then(() => {
+        });
+    return wasmReady;
+}
+
+async function initIfNeeded() {
+    if (wasmReady == null) {
+        await init({});
+    }
+    return wasmReady;
+}
+
+// async function run_diff_json({left, right, config}: {
+//     left: Uint8Array | undefined,
+//     right: Uint8Array | undefined,
+//     config?: exports.DiffObjConfig,
+// }): Promise<string> {
+//     config = config || exports.default_diff_obj_config();
+//     return exports.run_diff_json(left, right, cfg);
+// }
+
+async function run_diff_proto({left, right, config}: {
+    left: Uint8Array | undefined,
+    right: Uint8Array | undefined,
+    config?: exports.DiffObjConfig,
+}): Promise<Uint8Array> {
+    config = config || {};
+    return exports.run_diff_proto(left, right, config);
+}
+
+export type AnyHandlerData = HandlerData[keyof HandlerData];
+export type InMessage = AnyHandlerData & { messageId: number };
+
+export type OutMessage = {
+    type: 'result',
+    result: unknown | null,
+    error: string | null,
+    messageId: number,
+};
+
+self.onmessage = (event: MessageEvent<InMessage>) => {
+    const data = event.data;
+    const messageId = data?.messageId;
+    (async () => {
+        if (!data) {
+            throw new Error('No data');
+        }
+        const handler = handlers[data.type];
+        if (handler) {
+            if (data.type !== 'init') {
+                await initIfNeeded();
+            }
+            const start = performance.now();
+            const result = await handler(data as never);
+            const end = performance.now();
+            console.debug(`Worker message ${data.messageId} took ${end - start}ms`);
+            self.postMessage({
+                type: 'result',
+                result: result,
+                error: null,
+                messageId,
+            } as OutMessage);
+        } else {
+            throw new Error(`No handler for ${data.type}`);
+        }
+    })().catch(error => {
+        self.postMessage({
+            type: 'result',
+            result: null,
+            error: error.toString(),
+            messageId,
+        } as OutMessage);
+    });
+};
--- a/objdiff-wasm/tsconfig.json
+++ b/objdiff-wasm/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "module": "ES2022",
+    "moduleResolution": "Node",
+    "strict": true,
+    "target": "ES2022",
+  }
+}
--- a/objdiff-wasm/tsup.config.ts
+++ b/objdiff-wasm/tsup.config.ts
@@ -0,0 +1,33 @@
+import {defineConfig} from 'tsup';
+import fs from 'node:fs/promises';
+
+export default defineConfig([
+    // Build main library
+    {
+        entry: ['src/main.ts'],
+        clean: true,
+        dts: true,
+        format: 'esm',
+        outDir: 'dist',
+        skipNodeModulesBundle: true,
+        sourcemap: true,
+        splitting: false,
+        target: 'es2022',
+    },
+    // Build web worker
+    {
+        entry: ['src/worker.ts'],
+        clean: true,
+        dts: true,
+        format: 'esm', // type: 'module'
+        minify: true,
+        outDir: 'dist',
+        sourcemap: true,
+        splitting: false,
+        target: 'es2022',
+        // https://github.com/egoist/tsup/issues/278
+        async onSuccess() {
+            await fs.copyFile('pkg/objdiff_core_bg.wasm', 'dist/objdiff_core_bg.wasm');
+        }
+    }
+]);
Author	SHA1	Message	Date
Luke Street	b4650b660a	Hide auto-generated objects in object list With filter option to display them, if desired. decomp-toolkit will start writing auto-generated objects in objdiff.json for reporting purposes, so this maintains the existing behavior.	2024-09-03 18:59:07 -06:00
Luke Street	195379968c	Support for progress categories & linked stats	2024-09-03 00:59:15 -06:00
Aetias	3bd8aaee41	Bump unarm to 1.5.0 (#98 )	2024-08-25 20:57:45 -06:00
Luke Street	1f4175dc21	Overall wasm refactoring & improvements	2024-08-21 19:48:58 -06:00
Luke Street	0fccae1049	Add experimental wasm bindings Published to npm as objdiff-wasm	2024-08-20 21:40:32 -06:00
Luke Street	8250d26b77	Support R_MIPS_LITERAL, R_MIPS15_S3 relocations Resolves #92 Resolves #95	2024-08-18 22:05:16 -06:00
Luke Street	fd555a6e0f	Fix reading little-endian `.line` section	2024-08-18 21:57:53 -06:00
Luke Street	3710b6a91e	Try even harder to recover from protoc missing	2024-08-18 14:01:49 -06:00
Luke Street	faebddbc5e	More updates to report types	2024-08-18 13:42:41 -06:00
Luke Street	a733a950a3	Avoid requiring protoc unless protos change	2024-08-18 13:40:49 -06:00
Luke Street	cad9b70632	Support protobuf format for reports This migrates to using protobuf to define the "report" and "changes" formats in objdiff-cli. The JSON output now uses the Proto3 "JSON Mapping", which is slightly incompatible with the existing JSON format. Mainly, 64-bit numbers are represented as strings, and addresses are decimal strings instead of hex. However, the older JSON format is still accepted by "report changes" to ease migration.	2024-08-16 00:52:24 -06:00
Luke Street	cf937b0be9	Guard against symbols larger than section	2024-08-11 16:54:24 -06:00
Luke Street	23b6d33a98	Fix botched find/replace	2024-08-11 16:53:35 -06:00
Luke Street	f17ee83622	Version v2.0.0-beta.3	2024-08-11 16:02:36 -06:00
Luke Street	615ec4c50a	mips: Support R_MIPS_PC16 relocations	2024-08-11 16:00:10 -06:00
Luke Street	2cc10b0d06	cargo +nightly fmt	2024-08-11 14:29:58 -06:00
Luke Street	8091941448	Version v2.0.0-beta.2	2024-08-11 14:27:47 -06:00
Luke Street	de74dfdba7	Add dummy symbols to empty sections Allows diffing sections without symbols Resolves #87	2024-08-11 14:27:27 -06:00
Luke Street	177bd5e895	Fix branch immediates missing diff colors Resolves #86	2024-08-11 14:01:53 -06:00
Luke Street	e1ccee1e73	Improve data section diffing more This re-implements the older algorithm used for data and BSS section match percentages. We perform both and choose the highest match percent between the two options. Resolves #84, #85	2024-08-11 13:53:52 -06:00
Luke Street	952b6a63c3	Better graphics backend fallback This attempts the following in order: - wgpu with user-selected backend - wgpu with automatic backend - glow (fallback OpenGL backend) This should eliminate most issues where objdiff fails to launch.	2024-08-11 13:33:10 -06:00
Steven Casper	09cc9952df	Support R_MIPS_GPREL16 relocations correctly (#88 ) * Support R_MIPS_GPREL16 relocations correctly symbols defined in the same file require adding a special ri_gp_value from the .reginfo section to their relocation calculations. * Run nightly rustfmt * Prevent potential panic when slicing .reginfo	2024-08-08 20:20:41 -06:00