diff --git a/Cargo.lock b/Cargo.lock
index 11660908..5397a242 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1199,6 +1199,61 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "axum"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
+dependencies = [
+ "async-trait",
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tower 0.5.2",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.75"
@@ -1841,8 +1896,10 @@ checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
+ "js-sys",
  "num-traits",
  "serde",
+ "wasm-bindgen",
  "windows-link",
 ]
 
@@ -4076,12 +4133,24 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "http-range-header"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c"
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
 
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
 [[package]]
 name = "humantime"
 version = "2.2.0"
@@ -4111,6 +4180,7 @@ dependencies = [
  "http",
  "http-body",
  "httparse",
+ "httpdate",
  "itoa",
  "pin-project-lite",
  "pin-utils",
@@ -4893,6 +4963,12 @@ dependencies = [
  "regex-automata 0.1.10",
 ]
 
+[[package]]
+name = "matchit"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+
 [[package]]
 name = "matrixmultiply"
 version = "0.3.10"
@@ -4957,6 +5033,22 @@ dependencies = [
  "libmimalloc-sys",
 ]
 
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.8.9"
@@ -8635,8 +8727,8 @@ dependencies = [
  "sync_wrapper",
  "tokio",
  "tokio-native-tls",
- "tower",
- "tower-http",
+ "tower 0.5.2",
+ "tower-http 0.6.6",
  "tower-service",
  "url",
  "wasm-bindgen",
@@ -8723,9 +8815,17 @@ name = "revive-explorer"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "axum",
+ "chrono",
  "clap",
+ "mime_guess",
  "num_cpus",
  "revive-yul",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tower 0.4.13",
+ "tower-http 0.5.2",
 ]
 
 [[package]]
@@ -9586,6 +9686,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59fab13f937fa393d08645bf3a84bdfe86e296747b506ada67bb15f10f218b2a"
+dependencies = [
+ "itoa",
+ "serde",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "0.6.9"
@@ -9729,6 +9839,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a4719bff48cee6b39d12c020eeb490953ad2443b7055bd0b21fca26bd8c28b"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "signature"
 version = "2.2.0"
@@ -11149,12 +11268,26 @@ dependencies = [
  "io-uring",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
+ "signal-hook-registry",
  "slab",
  "socket2",
+ "tokio-macros",
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "tokio-macros"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
 [[package]]
 name = "tokio-native-tls"
 version = "0.3.1"
@@ -11165,6 +11298,19 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "tokio-util"
+version = "0.7.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14307c986784f72ef81c89db7d9e28d6ac26d16213b109ea501696195e6e3ce5"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "toml"
 version = "0.5.11"
@@ -11215,6 +11361,17 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
 [[package]]
 name = "tower"
 version = "0.5.2"
@@ -11228,6 +11385,32 @@ dependencies = [
  "tokio",
  "tower-layer",
  "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5"
+dependencies = [
+ "bitflags 2.9.2",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "http-range-header",
+ "httpdate",
+ "mime",
+ "mime_guess",
+ "percent-encoding",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+ "tower-layer",
+ "tower-service",
+ "tracing",
 ]
 
 [[package]]
@@ -11243,7 +11426,7 @@ dependencies = [
  "http-body",
  "iri-string",
  "pin-project-lite",
- "tower",
+ "tower 0.5.2",
  "tower-layer",
  "tower-service",
 ]
@@ -11416,6 +11599,12 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
+[[package]]
+name = "unicase"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
diff --git a/crates/explorer/Cargo.toml b/crates/explorer/Cargo.toml
index 3ba90758..4917710d 100644
--- a/crates/explorer/Cargo.toml
+++ b/crates/explorer/Cargo.toml
@@ -15,6 +15,14 @@ path = "src/main.rs"
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["help", "std", "derive"] }
 num_cpus = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+tokio = { version = "1.0", features = ["full"] }
+axum = "0.7"
+tower = "0.4"
+tower-http = { version = "0.5", features = ["fs", "cors"] }
+mime_guess = "2.0"
+chrono = { version = "0.4", features = ["serde"] }
 
 revive-yul = { workspace = true }
 
diff --git a/crates/explorer/src/api.rs b/crates/explorer/src/api.rs
new file mode 100644
index 00000000..f637574e
--- /dev/null
+++ b/crates/explorer/src/api.rs
@@ -0,0 +1,261 @@
+//! REST API endpoints for the Compiler Explorer WebUI.
+//!
+//! This module provides HTTP endpoints that serve YUL source code,
+//! RISC-V assembly instructions, and location mappings to the browser-based UI.
+
+use crate::assembly_analyzer::AssemblyInstruction;
+use crate::source_mapper::{LocationMapping, SourceMapper};
+use serde::{Deserialize, Serialize};
+
+/// Response containing YUL source code.
+#[derive(Debug, Serialize)]
+pub struct YulSourceResponse {
+    /// The YUL source code content
+    pub content: String,
+    /// Name of the source file
+    pub filename: String,
+    /// Total number of lines
+    pub line_count: usize,
+}
+
+impl YulSourceResponse {
+    /// Creates a new YUL source response from file content.
+    pub fn new(content: String, filename: String) -> Self {
+        let line_count = content.lines().count();
+        Self {
+            content,
+            filename,
+            line_count,
+        }
+    }
+}
+
+/// Response containing RISC-V assembly instructions.
+#[derive(Debug, Serialize)]
+pub struct AssemblyResponse {
+    /// List of assembly instructions
+    pub instructions: Vec<AssemblyInstructionDto>,
+    /// Total number of instructions
+    pub instruction_count: usize,
+}
+
+impl AssemblyResponse {
+    /// Creates a new assembly response from instruction data.
+    pub fn new(instructions: Vec<AssemblyInstruction>) -> Self {
+        let instruction_count = instructions.len();
+        let instructions = instructions
+            .into_iter()
+            .map(AssemblyInstructionDto::from)
+            .collect();
+
+        Self {
+            instructions,
+            instruction_count,
+        }
+    }
+}
+
+/// Data transfer object for assembly instructions.
+#[derive(Debug, Serialize)]
+pub struct AssemblyInstructionDto {
+    /// Formatted memory address (e.g., "0x1000")
+    pub address: String,
+    /// Raw instruction bytes
+    pub bytes: String,
+    /// Full instruction text (mnemonic + operands)
+    pub instruction: String,
+    /// Associated source line number (if available)
+    pub line_number: Option<usize>,
+}
+
+impl From<AssemblyInstruction> for AssemblyInstructionDto {
+    fn from(instr: AssemblyInstruction) -> Self {
+        let instruction = if instr.operands.is_empty() {
+            instr.mnemonic
+        } else {
+            format!("{}\t{}", instr.mnemonic, instr.operands)
+        };
+
+        Self {
+            address: format!("0x{:x}", instr.address),
+            bytes: instr.bytes,
+            instruction,
+            line_number: instr.line_number,
+        }
+    }
+}
+
+/// Response containing source-to-assembly mappings.
+#[derive(Debug, Serialize)]
+pub struct MappingResponse {
+    /// List of location mappings
+    pub mappings: Vec<LocationMapping>,
+    /// Total number of mappings
+    pub mapping_count: usize,
+}
+
+impl MappingResponse {
+    /// Creates a new mapping response from source mapper.
+    pub fn new(source_mapper: &SourceMapper) -> Self {
+        let mappings = source_mapper.to_location_mappings();
+        let mapping_count = mappings.len();
+
+        Self {
+            mappings,
+            mapping_count,
+        }
+    }
+}
+
+/// Complete analysis data for the WebUI.
+#[derive(Debug, Serialize)]
+pub struct AnalysisResponse {
+    /// YUL source information
+    pub yul_source: YulSourceResponse,
+    /// Assembly instructions
+    pub assembly: AssemblyResponse,
+    /// Location mappings
+    pub mapping: MappingResponse,
+    /// Analysis metadata
+    pub metadata: AnalysisMetadata,
+}
+
+/// Metadata about the analysis.
+#[derive(Debug, Serialize)]
+pub struct AnalysisMetadata {
+    /// Path to the analyzed shared object
+    pub shared_object_path: String,
+    /// Path to the YUL source file
+    pub yul_source_path: String,
+    /// Timestamp when analysis was performed
+    pub analyzed_at: String,
+    /// Tool versions used
+    pub tools: ToolVersions,
+}
+
+/// Information about tool versions used in analysis.
+#[derive(Debug, Serialize)]
+pub struct ToolVersions {
+    /// dwarfdump version/path
+    pub dwarfdump: String,
+    /// objdump version/path
+    pub objdump: String,
+    /// revive-explorer version
+    pub revive_explorer: String,
+}
+
+impl ToolVersions {
+    /// Creates tool version info with default/detected values.
+    pub fn detect() -> Self {
+        Self {
+            dwarfdump: "llvm-dwarfdump".to_string(),
+            objdump: "objdump".to_string(),
+            revive_explorer: env!("CARGO_PKG_VERSION").to_string(),
+        }
+    }
+}
+
+/// Error response for API endpoints.
+#[derive(Debug, Serialize)]
+pub struct ErrorResponse {
+    /// Error type/category
+    pub error: String,
+    /// Human-readable error message
+    pub message: String,
+    /// Optional detailed error information
+    pub details: Option<String>,
+}
+
+impl ErrorResponse {
+    /// Creates a new error response.
+    pub fn new(error: impl Into<String>, message: impl Into<String>) -> Self {
+        Self {
+            error: error.into(),
+            message: message.into(),
+            details: None,
+        }
+    }
+
+    /// Creates an error response with details.
+    pub fn with_details(
+        error: impl Into<String>,
+        message: impl Into<String>,
+        details: impl Into<String>,
+    ) -> Self {
+        Self {
+            error: error.into(),
+            message: message.into(),
+            details: Some(details.into()),
+        }
+    }
+}
+
+/// Request parameters for line-based queries.
+#[derive(Debug, Deserialize)]
+pub struct LineQueryParams {
+    /// Line number to query (1-based)
+    pub line: u32,
+}
+
+/// Request parameters for address-based queries.
+#[derive(Debug, Deserialize)]
+pub struct AddressQueryParams {
+    /// Memory address to query (hex format, e.g., "0x1000")
+    pub address: String,
+}
+
+impl AddressQueryParams {
+    /// Parses the address string to a u64.
+    pub fn parse_address(&self) -> Result<u64, String> {
+        let addr_str = self.address.trim_start_matches("0x");
+        u64::from_str_radix(addr_str, 16)
+            .map_err(|_| format!("Invalid address format: {}", self.address))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assembly_analyzer::AssemblyInstruction;
+
+    #[test]
+    fn test_yul_source_response() {
+        let content = "function test() {\n    let x := 1\n}".to_string();
+        let response = YulSourceResponse::new(content.clone(), "test.yul".to_string());
+
+        assert_eq!(response.content, content);
+        assert_eq!(response.filename, "test.yul");
+        assert_eq!(response.line_count, 3);
+    }
+
+    #[test]
+    fn test_assembly_instruction_dto() {
+        let instruction = AssemblyInstruction {
+            address: 0x1000,
+            bytes: "13 81 00 02".to_string(),
+            mnemonic: "addi".to_string(),
+            operands: "sp,sp,2".to_string(),
+            line_number: Some(5),
+        };
+
+        let dto = AssemblyInstructionDto::from(instruction);
+        assert_eq!(dto.address, "0x1000");
+        assert_eq!(dto.instruction, "addi\tsp,sp,2");
+        assert_eq!(dto.line_number, Some(5));
+    }
+
+    #[test]
+    fn test_address_query_params() {
+        let params = AddressQueryParams {
+            address: "0x1000".to_string(),
+        };
+
+        assert_eq!(params.parse_address().unwrap(), 0x1000);
+
+        let invalid_params = AddressQueryParams {
+            address: "invalid".to_string(),
+        };
+
+        assert!(invalid_params.parse_address().is_err());
+    }
+}
diff --git a/crates/explorer/src/assembly_analyzer.rs b/crates/explorer/src/assembly_analyzer.rs
new file mode 100644
index 00000000..0976ff4f
--- /dev/null
+++ b/crates/explorer/src/assembly_analyzer.rs
@@ -0,0 +1,180 @@
+//! Assembly analysis using objdump for RISC-V disassembly.
+//!
+//! This module integrates objdump to extract RISC-V assembly instructions
+//! from compiled shared objects, as requested in issue #366.
+
+use anyhow::{anyhow, Result};
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+pub static OBJDUMP_EXECUTABLE: &str = "objdump";
+pub static OBJDUMP_DISASSEMBLE_ARGUMENTS: [&str; 2] = ["-d", "--no-show-raw-insn"];
+
+/// Represents a single assembly instruction with metadata.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct AssemblyInstruction {
+    /// Memory address of the instruction
+    pub address: u64,
+    /// Raw instruction bytes
+    pub bytes: String,
+    /// Assembly mnemonic (e.g., "addi", "lw")
+    pub mnemonic: String,
+    /// Instruction operands
+    pub operands: String,
+    /// Associated source line number (if available from debug info)
+    pub line_number: Option<usize>,
+}
+
+/// Assembly analyzer that uses objdump to disassemble RISC-V code.
+pub struct AssemblyAnalyzer {
+    objdump_path: Option<PathBuf>,
+}
+
+impl AssemblyAnalyzer {
+    /// Creates a new assembly analyzer.
+    ///
+    /// `objdump_path` can be provided to override the default objdump executable.
+    pub fn new(objdump_path: Option<PathBuf>) -> Self {
+        Self { objdump_path }
+    }
+
+    /// Disassembles a shared object file and returns structured assembly instructions.
+    ///
+    /// This method calls objdump to disassemble the RISC-V code and parses the output
+    /// into structured data that can be consumed by the WebUI.
+    pub fn disassemble(&self, shared_object: &Path) -> Result<Vec<AssemblyInstruction>> {
+        let output = self.run_objdump(shared_object)?;
+        self.parse_objdump_output(&output)
+    }
+
+    /// Runs objdump with disassembly arguments.
+    fn run_objdump(&self, shared_object: &Path) -> Result<String> {
+        let executable = self
+            .objdump_path
+            .as_ref()
+            .map(|p| p.as_path())
+            .unwrap_or_else(|| Path::new(OBJDUMP_EXECUTABLE));
+
+        let output = Command::new(executable)
+            .args(&OBJDUMP_DISASSEMBLE_ARGUMENTS)
+            .arg(shared_object)
+            .stdin(Stdio::null())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()?
+            .wait_with_output()?;
+
+        if !output.status.success() {
+            return Err(anyhow!(
+                "objdump failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            ));
+        }
+
+        Ok(String::from_utf8_lossy(&output.stdout).to_string())
+    }
+
+    /// Parses objdump output into structured assembly instructions.
+    fn parse_objdump_output(&self, output: &str) -> Result<Vec<AssemblyInstruction>> {
+        let mut instructions = Vec::new();
+
+        for line in output.lines() {
+            if let Some(instruction) = self.parse_instruction_line(line)? {
+                instructions.push(instruction);
+            }
+        }
+
+        Ok(instructions)
+    }
+
+    /// Parses a single line of objdump output.
+    ///
+    /// Example objdump line:
+    /// "  400000:	02 00 81 13 	addi	sp,sp,2"
+    fn parse_instruction_line(&self, line: &str) -> Result<Option<AssemblyInstruction>> {
+        let line = line.trim();
+
+        // Skip empty lines and section headers
+        if line.is_empty() || !line.contains(':') {
+            return Ok(None);
+        }
+
+        // Skip lines that don't look like instruction disassembly
+        if line.starts_with("Disassembly") || line.starts_with("file format") {
+            return Ok(None);
+        }
+
+        // Parse address
+        let colon_pos = line
+            .find(':')
+            .ok_or_else(|| anyhow!("No colon found in line"))?;
+        let address_str = &line[..colon_pos].trim();
+        let address = u64::from_str_radix(address_str, 16)
+            .map_err(|_| anyhow!("Failed to parse address: {}", address_str))?;
+
+        // Parse the rest of the line after the colon
+        let rest = &line[colon_pos + 1..].trim();
+
+        // Split into bytes and instruction parts
+        let parts: Vec<&str> = rest.splitn(2, '\t').collect();
+        if parts.len() < 2 {
+            return Ok(None);
+        }
+
+        let bytes = parts[0].trim().to_string();
+        let instruction_part = parts[1].trim();
+
+        // Split instruction into mnemonic and operands
+        let instruction_parts: Vec<&str> = instruction_part.splitn(2, '\t').collect();
+        let mnemonic = instruction_parts[0].trim().to_string();
+        let operands = if instruction_parts.len() > 1 {
+            instruction_parts[1].trim().to_string()
+        } else {
+            String::new()
+        };
+
+        Ok(Some(AssemblyInstruction {
+            address,
+            bytes,
+            mnemonic,
+            operands,
+            line_number: None, // Will be populated by source mapper
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_instruction_line() {
+        let analyzer = AssemblyAnalyzer::new(None);
+
+        let line = "  400000:\t02 00 81 13 \taddi\tsp,sp,2";
+        let result = analyzer.parse_instruction_line(line).unwrap();
+
+        assert!(result.is_some());
+        let instruction = result.unwrap();
+        assert_eq!(instruction.address, 0x400000);
+        assert_eq!(instruction.bytes, "02 00 81 13");
+        assert_eq!(instruction.mnemonic, "addi");
+        assert_eq!(instruction.operands, "sp,sp,2");
+    }
+
+    #[test]
+    fn test_skip_invalid_lines() {
+        let analyzer = AssemblyAnalyzer::new(None);
+
+        let invalid_lines = [
+            "Disassembly of section .text:",
+            "",
+            "file format elf64-littleriscv",
+        ];
+
+        for line in &invalid_lines {
+            let result = analyzer.parse_instruction_line(line).unwrap();
+            assert!(result.is_none(), "Should skip line: {}", line);
+        }
+    }
+}
diff --git a/crates/explorer/src/lib.rs b/crates/explorer/src/lib.rs
index bdb725df..3cddd7d3 100644
--- a/crates/explorer/src/lib.rs
+++ b/crates/explorer/src/lib.rs
@@ -4,3 +4,9 @@ pub mod dwarfdump;
 pub mod dwarfdump_analyzer;
 pub mod location_mapper;
 pub mod yul_phaser;
+
+// WebUI modules for issue #366
+pub mod api;
+pub mod assembly_analyzer;
+pub mod source_mapper;
+pub mod web_server;
diff --git a/crates/explorer/src/main.rs b/crates/explorer/src/main.rs
index 10036d19..7185ba8b 100644
--- a/crates/explorer/src/main.rs
+++ b/crates/explorer/src/main.rs
@@ -10,6 +10,7 @@ use revive_explorer::{dwarfdump, dwarfdump_analyzer::DwarfdumpAnalyzer, yul_phas
 /// - The count of each YUL statement translated.
 /// - A per YUL statement break-down of bytecode size contributed per.
 /// - Estimated `yul-phaser` cost parameters.
+/// - WebUI mode: Interactive two-pane interface showing YUL ↔ RISC-V mapping (issue #366)
 ///
 /// Note: This tool might not be fully accurate, especially when the code was optimized.
 #[derive(Parser, Debug)]
@@ -27,6 +28,18 @@ struct Args {
     #[arg(short, long)]
     yul_phaser: Option<PathBuf>,
 
+    /// Start web server mode for interactive YUL ↔ RISC-V analysis (issue #366).
+    #[arg(long)]
+    web: bool,
+
+    /// Port for web server (default: 8080).
+    #[arg(long, default_value_t = 8080)]
+    port: u16,
+
+    /// Path of the objdump executable for assembly disassembly.
+    #[arg(long)]
+    objdump: Option<PathBuf>,
+
     /// Path of the shared object to analyze.
     /// It must have been compiled with debug info (-g).
     file: PathBuf,
@@ -35,6 +48,11 @@ struct Args {
 fn main() -> anyhow::Result<()> {
     let args = Args::parse();
 
+    // Handle web mode for issue #366
+    if args.web {
+        return run_web_server(args);
+    }
+
     let source_file = dwarfdump::source_file(&args.file, &args.dwarfdump)?;
     let debug_lines = dwarfdump::debug_lines(&args.file, &args.dwarfdump)?;
     let mut analyzer = DwarfdumpAnalyzer::new(source_file.as_path(), debug_lines);
@@ -57,3 +75,16 @@ fn main() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+/// Runs the web server mode for the Compiler Explorer UI (issue #366).
+#[tokio::main]
+async fn run_web_server(args: Args) -> anyhow::Result<()> {
+    use revive_explorer::web_server::WebServer;
+
+    let source_file = dwarfdump::source_file(&args.file, &args.dwarfdump)?;
+
+    let server = WebServer::new(args.file, source_file, args.dwarfdump, args.objdump);
+
+    println!("🚀 Starting Revive Compiler Explorer WebUI...");
+    server.serve(args.port).await
+}
diff --git a/crates/explorer/src/source_mapper.rs b/crates/explorer/src/source_mapper.rs
new file mode 100644
index 00000000..e7281b47
--- /dev/null
+++ b/crates/explorer/src/source_mapper.rs
@@ -0,0 +1,275 @@
+//! Maps YUL source locations to assembly instructions using debug information.
+//!
+//! This module creates bidirectional mappings between YUL source code locations
+//! and RISC-V assembly instructions, enabling the interactive navigation
+//! requested in issue #366.
+
+use crate::assembly_analyzer::AssemblyInstruction;
+use anyhow::{anyhow, Result};
+use revive_yul::lexer::token::location::Location;
+use std::collections::HashMap;
+
+/// Bidirectional mapping between YUL source and assembly instructions.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct SourceMapper {
+    /// Maps YUL source locations to assembly instruction addresses
+    pub yul_to_assembly: HashMap<Location, Vec<u64>>,
+    /// Maps assembly instruction addresses to YUL source locations
+    pub assembly_to_yul: HashMap<u64, Location>,
+    /// Maps line numbers to YUL locations for easier lookup
+    pub line_to_location: HashMap<u32, Vec<Location>>,
+}
+
+/// Represents a mapping entry for the WebUI API.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct LocationMapping {
+    pub yul_line: u32,
+    pub yul_column: u32,
+    pub assembly_addresses: Vec<String>,
+}
+
+impl SourceMapper {
+    /// Creates a new empty source mapper.
+    pub fn new() -> Self {
+        Self {
+            yul_to_assembly: HashMap::new(),
+            assembly_to_yul: HashMap::new(),
+            line_to_location: HashMap::new(),
+        }
+    }
+
+    /// Builds the mapping between YUL source and assembly instructions.
+    ///
+    /// This method correlates debug information from dwarfdump with assembly
+    /// instructions from objdump to create the interactive navigation mapping.
+    pub fn build_mapping(
+        &mut self,
+        debug_lines: &str,
+        instructions: &[AssemblyInstruction],
+    ) -> Result<()> {
+        // Parse debug line information to get address-to-source mappings
+        let debug_entries = self.parse_debug_lines(debug_lines)?;
+
+        // Create address lookup for quick assembly instruction finding
+        let address_to_instruction: HashMap<u64, usize> = instructions
+            .iter()
+            .enumerate()
+            .map(|(idx, instr)| (instr.address, idx))
+            .collect();
+
+        // Build the bidirectional mapping
+        for entry in debug_entries {
+            let yul_location = Location::new(entry.line, entry.column);
+
+            // Find assembly instructions that correspond to this source location
+            let mut assembly_addresses = Vec::new();
+
+            // Look for instructions in the address range
+            for instruction in instructions {
+                if instruction.address >= entry.address
+                    && instruction.address < entry.address + entry.size.unwrap_or(4)
+                {
+                    assembly_addresses.push(instruction.address);
+
+                    // Add to assembly-to-YUL mapping
+                    self.assembly_to_yul
+                        .insert(instruction.address, yul_location);
+                }
+            }
+
+            if !assembly_addresses.is_empty() {
+                // Add to YUL-to-assembly mapping
+                self.yul_to_assembly
+                    .insert(yul_location, assembly_addresses);
+
+                // Add to line-to-location mapping for easier UI lookups
+                self.line_to_location
+                    .entry(entry.line)
+                    .or_insert_with(Vec::new)
+                    .push(yul_location);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Gets assembly addresses for a given YUL line number.
+    pub fn get_assembly_for_line(&self, line: u32) -> Vec<u64> {
+        self.line_to_location
+            .get(&line)
+            .map(|locations| {
+                locations
+                    .iter()
+                    .flat_map(|loc| self.yul_to_assembly.get(loc))
+                    .flatten()
+                    .copied()
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Gets the YUL location for a given assembly address.
+    pub fn get_yul_for_address(&self, address: u64) -> Option<Location> {
+        self.assembly_to_yul.get(&address).copied()
+    }
+
+    /// Converts the mapping to a format suitable for the WebUI API.
+    pub fn to_location_mappings(&self) -> Vec<LocationMapping> {
+        let mut mappings = Vec::new();
+
+        for (location, addresses) in &self.yul_to_assembly {
+            mappings.push(LocationMapping {
+                yul_line: location.line,
+                yul_column: location.column,
+                assembly_addresses: addresses
+                    .iter()
+                    .map(|addr| format!("0x{:x}", addr))
+                    .collect(),
+            });
+        }
+
+        // Sort by line number for consistent output
+        mappings.sort_by_key(|m| (m.yul_line, m.yul_column));
+        mappings
+    }
+
+    /// Parses debug line information from dwarfdump output.
+    fn parse_debug_lines(&self, debug_lines: &str) -> Result<Vec<DebugLineEntry>> {
+        let mut entries = Vec::new();
+        let mut parsing_entries = false;
+
+        for line in debug_lines.lines() {
+            // Skip until we reach the actual debug line entries
+            if line.starts_with("Address") && line.contains("Line") && line.contains("Column") {
+                parsing_entries = true;
+                continue;
+            }
+
+            if !parsing_entries {
+                continue;
+            }
+
+            // Skip separator lines
+            if line.starts_with("-") || line.trim().is_empty() {
+                continue;
+            }
+
+            if let Some(entry) = self.parse_debug_line_entry(line)? {
+                entries.push(entry);
+            }
+        }
+
+        Ok(entries)
+    }
+
+    /// Parses a single debug line entry.
+    ///
+    /// Example line format from dwarfdump:
+    /// "0x0000000000001000     1      5      0             0  is_stmt"
+    fn parse_debug_line_entry(&self, line: &str) -> Result<Option<DebugLineEntry>> {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+
+        if parts.len() < 3 {
+            return Ok(None);
+        }
+
+        // Parse address
+        let address_str = parts[0].trim_start_matches("0x");
+        let address = u64::from_str_radix(address_str, 16)
+            .map_err(|_| anyhow!("Failed to parse address: {}", parts[0]))?;
+
+        // Parse line number
+        let line_num = parts[1]
+            .parse::<u32>()
+            .map_err(|_| anyhow!("Failed to parse line number: {}", parts[1]))?;
+
+        // Parse column number
+        let column_num = parts[2]
+            .parse::<u32>()
+            .map_err(|_| anyhow!("Failed to parse column number: {}", parts[2]))?;
+
+        Ok(Some(DebugLineEntry {
+            address,
+            line: line_num,
+            column: column_num,
+            size: None, // We don't have size info from dwarfdump, estimate as 4 bytes
+        }))
+    }
+}
+
+impl Default for SourceMapper {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Represents a debug line entry from dwarfdump output.
+#[derive(Debug, Clone)]
+struct DebugLineEntry {
+    address: u64,
+    line: u32,
+    column: u32,
+    size: Option<u64>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_debug_line_entry() {
+        let mapper = SourceMapper::new();
+
+        let line = "0x0000000000001000     1      5      0             0  is_stmt";
+        let result = mapper.parse_debug_line_entry(line).unwrap();
+
+        assert!(result.is_some());
+        let entry = result.unwrap();
+        assert_eq!(entry.address, 0x1000);
+        assert_eq!(entry.line, 1);
+        assert_eq!(entry.column, 5);
+    }
+
+    #[test]
+    fn test_get_assembly_for_line() {
+        let mut mapper = SourceMapper::new();
+
+        // Manually insert test data
+        let location = Location::new(10, 5);
+        mapper
+            .yul_to_assembly
+            .insert(location, vec![0x1000, 0x1004]);
+        mapper
+            .line_to_location
+            .entry(10)
+            .or_insert_with(Vec::new)
+            .push(location);
+
+        let addresses = mapper.get_assembly_for_line(10);
+        assert_eq!(addresses, vec![0x1000, 0x1004]);
+
+        let empty_addresses = mapper.get_assembly_for_line(99);
+        assert!(empty_addresses.is_empty());
+    }
+
+    #[test]
+    fn test_to_location_mappings() {
+        let mut mapper = SourceMapper::new();
+
+        // Add test data
+        let location1 = Location::new(1, 0);
+        let location2 = Location::new(2, 5);
+        mapper.yul_to_assembly.insert(location1, vec![0x1000]);
+        mapper
+            .yul_to_assembly
+            .insert(location2, vec![0x1004, 0x1008]);
+
+        let mappings = mapper.to_location_mappings();
+        assert_eq!(mappings.len(), 2);
+
+        // Should be sorted by line number
+        assert_eq!(mappings[0].yul_line, 1);
+        assert_eq!(mappings[1].yul_line, 2);
+        assert_eq!(mappings[1].assembly_addresses, vec!["0x1004", "0x1008"]);
+    }
+}
diff --git a/crates/explorer/src/web_server.rs b/crates/explorer/src/web_server.rs
new file mode 100644
index 00000000..d8f49da8
--- /dev/null
+++ b/crates/explorer/src/web_server.rs
@@ -0,0 +1,254 @@
+//! HTTP server for the Compiler Explorer WebUI.
+//!
+//! This module implements the web server that serves the two-pane interface
+//! and provides REST API endpoints for YUL source and RISC-V assembly data.
+
+use anyhow::{anyhow, Result};
+use axum::{
+    extract::{Query, State},
+    http::{header, StatusCode},
+    response::{Html, Json, Response},
+    routing::get,
+    Router,
+};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tokio::fs;
+use tower::ServiceBuilder;
+use tower_http::{cors::CorsLayer, services::ServeDir};
+
+use crate::{
+    api::{
+        AnalysisMetadata, AnalysisResponse, AssemblyResponse, ErrorResponse, LineQueryParams,
+        MappingResponse, ToolVersions, YulSourceResponse,
+    },
+    assembly_analyzer::AssemblyAnalyzer,
+    dwarfdump,
+    dwarfdump_analyzer::DwarfdumpAnalyzer,
+    source_mapper::SourceMapper,
+};
+
+/// Shared application state for the web server.
+#[derive(Debug, Clone)]
+pub struct AppState {
+    /// Analysis data computed at startup
+    pub analysis: Arc<AnalysisData>,
+}
+
+/// Complete analysis data for a shared object.
+#[derive(Debug)]
+pub struct AnalysisData {
+    /// YUL source content and metadata
+    pub yul_source: YulSourceResponse,
+    /// RISC-V assembly instructions
+    pub assembly: AssemblyResponse,
+    /// Source-to-assembly mapping
+    pub source_mapper: SourceMapper,
+    /// Analysis metadata
+    pub metadata: AnalysisMetadata,
+}
+
+/// Web server for the Compiler Explorer UI.
+pub struct WebServer {
+    shared_object_path: PathBuf,
+    yul_source_path: PathBuf,
+    dwarfdump_path: Option<PathBuf>,
+    objdump_path: Option<PathBuf>,
+}
+
+impl WebServer {
+    /// Creates a new web server instance.
+    pub fn new(
+        shared_object_path: PathBuf,
+        yul_source_path: PathBuf,
+        dwarfdump_path: Option<PathBuf>,
+        objdump_path: Option<PathBuf>,
+    ) -> Self {
+        Self {
+            shared_object_path,
+            yul_source_path,
+            dwarfdump_path,
+            objdump_path,
+        }
+    }
+
+    /// Starts the web server on the specified port.
+    pub async fn serve(self, port: u16) -> Result<()> {
+        println!(
+            "🔍 Analyzing shared object: {}",
+            self.shared_object_path.display()
+        );
+
+        // Perform analysis at startup as requested in the issue
+        let analysis_data = self.analyze().await?;
+        let app_state = AppState {
+            analysis: Arc::new(analysis_data),
+        };
+
+        println!("✅ Analysis complete, starting web server...");
+
+        // Create the router with API endpoints and static file serving
+        let app = Router::new()
+            .route("/", get(serve_index))
+            .route("/api/analysis", get(get_analysis))
+            .route("/api/yul", get(get_yul_source))
+            .route("/api/assembly", get(get_assembly))
+            .route("/api/mapping", get(get_mapping))
+            .route("/api/assembly-for-line", get(get_assembly_for_line))
+            .nest_service("/static", ServeDir::new("static"))
+            .layer(ServiceBuilder::new().layer(CorsLayer::permissive()))
+            .with_state(app_state);
+
+        let bind_addr = format!("127.0.0.1:{}", port);
+        let listener = tokio::net::TcpListener::bind(&bind_addr).await?;
+
+        println!(
+            "🚀 Revive Compiler Explorer running at: http://{}",
+            bind_addr
+        );
+        println!("📖 Open the URL in your browser to view the YUL ↔ RISC-V interface");
+
+        axum::serve(listener, app).await?;
+        Ok(())
+    }
+
+    /// Performs the complete analysis as specified in issue #366.
+    async fn analyze(&self) -> Result<AnalysisData> {
+        // Step 1: Extract YUL source file path and debug info using dwarfdump
+        let source_file = dwarfdump::source_file(&self.shared_object_path, &self.dwarfdump_path)?;
+        let debug_lines = dwarfdump::debug_lines(&self.shared_object_path, &self.dwarfdump_path)?;
+
+        // Step 2: Read YUL source content
+        let yul_content = fs::read_to_string(&source_file).await.map_err(|e| {
+            anyhow!(
+                "Failed to read YUL source file {}: {}",
+                source_file.display(),
+                e
+            )
+        })?;
+
+        let yul_source = YulSourceResponse::new(
+            yul_content,
+            source_file
+                .file_name()
+                .unwrap_or_default()
+                .to_string_lossy()
+                .to_string(),
+        );
+
+        // Step 3: Disassemble using objdump to get RISC-V instructions
+        let assembly_analyzer = AssemblyAnalyzer::new(self.objdump_path.clone());
+        let assembly_instructions = assembly_analyzer.disassemble(&self.shared_object_path)?;
+        let assembly = AssemblyResponse::new(assembly_instructions.clone());
+
+        // Step 4: Build source-to-assembly mapping using debug information
+        let mut analyzer = DwarfdumpAnalyzer::new(&source_file, debug_lines.clone());
+        analyzer.analyze()?;
+
+        let mut source_mapper = SourceMapper::new();
+        source_mapper.build_mapping(&debug_lines, &assembly_instructions)?;
+
+        // Step 5: Create metadata
+        let metadata = AnalysisMetadata {
+            shared_object_path: self.shared_object_path.to_string_lossy().to_string(),
+            yul_source_path: source_file.to_string_lossy().to_string(),
+            analyzed_at: chrono::Utc::now().to_rfc3339(),
+            tools: ToolVersions::detect(),
+        };
+
+        Ok(AnalysisData {
+            yul_source,
+            assembly,
+            source_mapper,
+            metadata,
+        })
+    }
+}
+
+// HTTP Handler Functions
+
+/// Serves the main HTML page with the two-pane interface.
+async fn serve_index() -> Html<&'static str> {
+    Html(include_str!("../static/index.html"))
+}
+
+/// Returns complete analysis data.
+async fn get_analysis(State(state): State<AppState>) -> Json<AnalysisResponse> {
+    let analysis = &state.analysis;
+    Json(AnalysisResponse {
+        yul_source: analysis.yul_source.clone(),
+        assembly: analysis.assembly.clone(),
+        mapping: MappingResponse::new(&analysis.source_mapper),
+        metadata: analysis.metadata.clone(),
+    })
+}
+
+/// Returns YUL source code.
+async fn get_yul_source(State(state): State<AppState>) -> Json<YulSourceResponse> {
+    Json(state.analysis.yul_source.clone())
+}
+
+/// Returns RISC-V assembly instructions.
+async fn get_assembly(State(state): State<AppState>) -> Json<AssemblyResponse> {
+    Json(state.analysis.assembly.clone())
+}
+
+/// Returns source-to-assembly mappings.
+async fn get_mapping(State(state): State<AppState>) -> Json<MappingResponse> {
+    Json(MappingResponse::new(&state.analysis.source_mapper))
+}
+
+/// Returns assembly addresses for a specific YUL line number.
+async fn get_assembly_for_line(
+    Query(params): Query<LineQueryParams>,
+    State(state): State<AppState>,
+) -> Result<Json<Vec<String>>, Response> {
+    let addresses = state
+        .analysis
+        .source_mapper
+        .get_assembly_for_line(params.line);
+    let formatted_addresses: Vec<String> = addresses
+        .into_iter()
+        .map(|addr| format!("0x{:x}", addr))
+        .collect();
+
+    Ok(Json(formatted_addresses))
+}
+
+/// Helper function to create error responses.
+async fn create_error_response(status: StatusCode, error: &str, message: &str) -> Response {
+    let error_response = ErrorResponse::new(error, message);
+    let json_body = serde_json::to_string(&error_response).unwrap_or_default();
+
+    Response::builder()
+        .status(status)
+        .header(header::CONTENT_TYPE, "application/json")
+        .body(json_body.into())
+        .unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_web_server_creation() {
+        let server = WebServer::new(
+            PathBuf::from("/test/object.so"),
+            PathBuf::from("/test/source.yul"),
+            None,
+            None,
+        );
+
+        assert_eq!(server.shared_object_path, PathBuf::from("/test/object.so"));
+        assert_eq!(server.yul_source_path, PathBuf::from("/test/source.yul"));
+    }
+
+    #[tokio::test]
+    async fn test_serve_index() {
+        let response = serve_index().await;
+        // The response should contain HTML
+        assert!(response.0.contains("html") || response.0.contains("HTML"));
+    }
+}
diff --git a/crates/explorer/static/css/main.css b/crates/explorer/static/css/main.css
new file mode 100644
index 00000000..af40f63b
--- /dev/null
+++ b/crates/explorer/static/css/main.css
@@ -0,0 +1,223 @@
+/* Revive Compiler Explorer - Two-Pane Interface Styles */
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+    background: #f8f9fa;
+    color: #333;
+    line-height: 1.4;
+}
+
+.container {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+}
+
+.header {
+    background: #2c3e50;
+    color: white;
+    padding: 16px 20px;
+    text-align: center;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.header h1 {
+    font-size: 24px;
+    margin-bottom: 4px;
+}
+
+.header p {
+    font-size: 14px;
+    opacity: 0.9;
+}
+
+.main-content {
+    display: flex;
+    flex: 1;
+    gap: 2px;
+    background: #ddd;
+    overflow: hidden;
+}
+
+.pane {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: white;
+    min-width: 0;
+}
+
+.pane-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 16px;
+    background: #f5f5f5;
+    border-bottom: 1px solid #ddd;
+    font-weight: 600;
+    font-size: 14px;
+}
+
+.pane-title {
+    color: #2c3e50;
+}
+
+.pane-info {
+    font-size: 12px;
+    color: #666;
+    font-weight: normal;
+}
+
+.pane-content {
+    flex: 1;
+    overflow: auto;
+    position: relative;
+}
+
+.code-block {
+    margin: 0;
+    padding: 16px;
+    font-size: 13px;
+    line-height: 1.5;
+    background: #fafafa;
+    min-height: 100%;
+    white-space: pre;
+    overflow-x: auto;
+    counter-reset: line-number;
+}
+
+.code-line {
+    display: block;
+    position: relative;
+    padding-left: 60px;
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+}
+
+.code-line:hover {
+    background-color: #f0f8ff;
+}
+
+.code-line:before {
+    counter-increment: line-number;
+    content: counter(line-number);
+    position: absolute;
+    left: 8px;
+    width: 40px;
+    text-align: right;
+    color: #999;
+    font-size: 12px;
+    user-select: none;
+}
+
+/* Highlighting styles for interactive navigation */
+.highlighted-line {
+    background-color: #fff3cd !important;
+    border-left: 3px solid #f0ad4e;
+}
+
+.selected-line {
+    background-color: #d4edda !important;
+    border-left: 3px solid #28a745;
+}
+
+/* Assembly-specific styles */
+.assembly-instruction {
+    display: block;
+    padding: 2px 0;
+    font-family: 'Monaco', 'Menlo', monospace;
+}
+
+.assembly-address {
+    color: #6f42c1;
+    width: 100px;
+    display: inline-block;
+}
+
+.assembly-bytes {
+    color: #dc3545;
+    width: 120px;
+    display: inline-block;
+    font-size: 11px;
+}
+
+.assembly-instruction-text {
+    color: #333;
+}
+
+/* YUL syntax highlighting */
+.yul-keyword {
+    color: #d73a49;
+    font-weight: bold;
+}
+
+.yul-builtin {
+    color: #6f42c1;
+}
+
+.yul-identifier {
+    color: #24292e;
+}
+
+.yul-literal {
+    color: #032f62;
+}
+
+.yul-comment {
+    color: #6a737d;
+    font-style: italic;
+}
+
+.footer {
+    background: #f8f9fa;
+    padding: 8px 20px;
+    text-align: center;
+    border-top: 1px solid #ddd;
+    font-size: 12px;
+    color: #666;
+}
+
+/* Loading states */
+.loading {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .main-content {
+        flex-direction: column;
+    }
+    
+    .pane {
+        min-height: 300px;
+    }
+    
+    .header h1 {
+        font-size: 20px;
+    }
+}
+
+/* Scrollbar styling */
+.pane-content::-webkit-scrollbar {
+    width: 8px;
+}
+
+.pane-content::-webkit-scrollbar-track {
+    background: #f1f1f1;
+}
+
+.pane-content::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+.pane-content::-webkit-scrollbar-thumb:hover {
+    background: #a8a8a8;
+}
diff --git a/crates/explorer/static/index.html b/crates/explorer/static/index.html
new file mode 100644
index 00000000..b9e51241
--- /dev/null
+++ b/crates/explorer/static/index.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Revive Compiler Explorer - YUL ↔ RISC-V</title>
+    <link rel="stylesheet" href="/static/css/main.css">
+</head>
+<body>
+    <div class="container">
+        <header class="header">
+            <h1>🔍 Revive Compiler Explorer</h1>
+            <p>Interactive YUL Source ↔ RISC-V Assembly Analysis</p>
+        </header>
+        
+        <div class="main-content">
+            <div class="pane yul-pane">
+                <div class="pane-header">
+                    <span class="pane-title">YUL Source</span>
+                    <span class="pane-info" id="yul-info">Loading...</span>
+                </div>
+                <div class="pane-content">
+                    <pre id="yul-source" class="code-block">Loading YUL source...</pre>
+                </div>
+            </div>
+            
+            <div class="pane assembly-pane">
+                <div class="pane-header">
+                    <span class="pane-title">RISC-V Assembly</span>
+                    <span class="pane-info" id="asm-info">Loading...</span>
+                </div>
+                <div class="pane-content">
+                    <pre id="assembly-output" class="code-block">Loading assembly...</pre>
+                </div>
+            </div>
+        </div>
+        
+        <footer class="footer">
+            <p>Click on YUL lines to highlight corresponding RISC-V instructions</p>
+        </footer>
+    </div>
+    
+    <script src="/static/js/main.js"></script>
+</body>
+</html>
diff --git a/crates/explorer/static/js/main.js b/crates/explorer/static/js/main.js
new file mode 100644
index 00000000..342853ad
--- /dev/null
+++ b/crates/explorer/static/js/main.js
@@ -0,0 +1,201 @@
+// Revive Compiler Explorer - Interactive YUL ↔ RISC-V Navigation
+class ReviveExplorer {
+    constructor() {
+        this.mapping = null;
+        this.yulData = null;
+        this.assemblyData = null;
+        this.currentHighlight = null;
+        
+        this.yulElement = document.getElementById('yul-source');
+        this.assemblyElement = document.getElementById('assembly-output');
+        this.yulInfo = document.getElementById('yul-info');
+        this.asmInfo = document.getElementById('asm-info');
+        
+        this.init();
+    }
+    
+    async init() {
+        console.log('🚀 Initializing Revive Compiler Explorer...');
+        
+        try {
+            await this.loadData();
+            this.setupEventListeners();
+            this.renderContent();
+            console.log('✅ Initialization complete');
+        } catch (error) {
+            console.error('❌ Failed to initialize:', error);
+            this.showError('Failed to load analysis data: ' + error.message);
+        }
+    }
+    
+    async loadData() {
+        console.log('📡 Loading analysis data...');
+        
+        // Load all data in parallel for better performance
+        const [yulResponse, assemblyResponse, mappingResponse] = await Promise.all([
+            fetch('/api/yul').then(r => r.json()),
+            fetch('/api/assembly').then(r => r.json()),
+            fetch('/api/mapping').then(r => r.json())
+        ]);
+        
+        this.yulData = yulResponse;
+        this.assemblyData = assemblyResponse;
+        this.mapping = mappingResponse;
+        
+        console.log(`📊 Loaded: ${this.yulData.line_count} YUL lines, ${this.assemblyData.instruction_count} instructions, ${this.mapping.mapping_count} mappings`);
+    }
+    
+    renderContent() {
+        this.renderYulSource();
+        this.renderAssembly();
+        this.updateInfo();
+    }
+    
+    renderYulSource() {
+        if (!this.yulData) return;
+        
+        const lines = this.yulData.content.split('\n');
+        const html = lines.map((line, index) => 
+            `<span class="code-line" data-line="${index + 1}">${this.escapeHtml(line)}</span>`
+        ).join('\n');
+        
+        this.yulElement.innerHTML = html;
+    }
+    
+    renderAssembly() {
+        if (!this.assemblyData) return;
+        
+        const html = this.assemblyData.instructions.map(instr => 
+            `<div class="assembly-instruction" data-address="${instr.address}">` +
+            `<span class="assembly-address">${instr.address}</span>` +
+            `<span class="assembly-bytes">${instr.bytes}</span>` +
+            `<span class="assembly-instruction-text">${this.escapeHtml(instr.instruction)}</span>` +
+            `</div>`
+        ).join('\n');
+        
+        this.assemblyElement.innerHTML = html;
+    }
+    
+    updateInfo() {
+        if (this.yulData) {
+            this.yulInfo.textContent = `${this.yulData.line_count} lines • ${this.yulData.filename}`;
+        }
+        
+        if (this.assemblyData) {
+            this.asmInfo.textContent = `${this.assemblyData.instruction_count} instructions`;
+        }
+    }
+    
+    setupEventListeners() {
+        // Make YUL lines clickable for navigation
+        this.yulElement.addEventListener('click', (event) => {
+            const lineElement = event.target.closest('.code-line');
+            if (lineElement) {
+                const lineNumber = parseInt(lineElement.dataset.line);
+                this.navigateToLine(lineNumber);
+            }
+        });
+        
+        // Make assembly instructions clickable for reverse navigation
+        this.assemblyElement.addEventListener('click', (event) => {
+            const instrElement = event.target.closest('.assembly-instruction');
+            if (instrElement) {
+                const address = instrElement.dataset.address;
+                this.navigateToAddress(address);
+            }
+        });
+    }
+    
+    async navigateToLine(lineNumber) {
+        console.log(`🎯 Navigating to YUL line ${lineNumber}`);
+        
+        try {
+            // Get assembly addresses for this line
+            const response = await fetch(`/api/assembly-for-line?line=${lineNumber}`);
+            const addresses = await response.json();
+            
+            this.highlightYulLine(lineNumber);
+            this.highlightAssemblyAddresses(addresses);
+            
+            // Scroll to first assembly instruction if any
+            if (addresses.length > 0) {
+                this.scrollToAssemblyAddress(addresses[0]);
+            }
+            
+        } catch (error) {
+            console.error('Failed to navigate to line:', error);
+        }
+    }
+    
+    navigateToAddress(address) {
+        console.log(`🎯 Reverse navigation from address ${address}`);
+        
+        // Find YUL line for this address from mapping
+        const mapping = this.mapping.mappings.find(m => 
+            m.assembly_addresses.includes(address)
+        );
+        
+        if (mapping) {
+            this.highlightYulLine(mapping.yul_line);
+            this.highlightAssemblyAddresses([address]);
+            this.scrollToYulLine(mapping.yul_line);
+        }
+    }
+    
+    highlightYulLine(lineNumber) {
+        // Clear previous highlights
+        this.yulElement.querySelectorAll('.highlighted-line, .selected-line')
+            .forEach(el => el.classList.remove('highlighted-line', 'selected-line'));
+        
+        // Highlight the selected line
+        const lineElement = this.yulElement.querySelector(`[data-line="${lineNumber}"]`);
+        if (lineElement) {
+            lineElement.classList.add('selected-line');
+        }
+    }
+    
+    highlightAssemblyAddresses(addresses) {
+        // Clear previous assembly highlights
+        this.assemblyElement.querySelectorAll('.highlighted-line, .selected-line')
+            .forEach(el => el.classList.remove('highlighted-line', 'selected-line'));
+        
+        // Highlight corresponding assembly instructions
+        addresses.forEach(address => {
+            const instrElement = this.assemblyElement.querySelector(`[data-address="${address}"]`);
+            if (instrElement) {
+                instrElement.classList.add('highlighted-line');
+            }
+        });
+    }
+    
+    scrollToYulLine(lineNumber) {
+        const lineElement = this.yulElement.querySelector(`[data-line="${lineNumber}"]`);
+        if (lineElement) {
+            lineElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        }
+    }
+    
+    scrollToAssemblyAddress(address) {
+        const instrElement = this.assemblyElement.querySelector(`[data-address="${address}"]`);
+        if (instrElement) {
+            instrElement.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        }
+    }
+    
+    escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+    
+    showError(message) {
+        this.yulElement.innerHTML = `<div style="color: red; padding: 20px;">Error: ${message}</div>`;
+        this.assemblyElement.innerHTML = `<div style="color: red; padding: 20px;">Error: ${message}</div>`;
+    }
+}
+
+// Initialize when DOM loads
+document.addEventListener('DOMContentLoaded', () => {
+    console.log('🔍 Starting Revive Compiler Explorer...');
+    new ReviveExplorer();
+});