diff --git a/Cargo.lock b/Cargo.lock
index d2468f9a..165e97bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -448,6 +448,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75ca66430e33a14957acc24c5077b503e7d374151b2b4b3a10c83b4ceb4be0e"
 dependencies = [
  "clap_builder",
+ "clap_derive",
 ]
 
 [[package]]
@@ -462,6 +463,18 @@ dependencies = [
  "strsim",
 ]
 
+[[package]]
+name = "clap_derive"
+version = "4.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "clap_lex"
 version = "0.7.6"
diff --git a/src/hyperlight_wasm_aot/Cargo.toml b/src/hyperlight_wasm_aot/Cargo.toml
index 16ba914f..e309432c 100644
--- a/src/hyperlight_wasm_aot/Cargo.toml
+++ b/src/hyperlight_wasm_aot/Cargo.toml
@@ -13,7 +13,7 @@ Application to precompile WebAssembly binaries to for hyperlight-wasm.
 
 [dependencies]
 wasmtime = { version = "36.0.5", default-features = false, features = ["cranelift", "runtime", "component-model" ] }
-clap = "4.5"
+clap = { version = "4.5", features = ["derive"] }
 cargo_metadata = "0.23"
 cargo-util-schemas = "0.10.1"
 
diff --git a/src/hyperlight_wasm_aot/src/main.rs b/src/hyperlight_wasm_aot/src/main.rs
index 835e919e..7ad9fcbc 100644
--- a/src/hyperlight_wasm_aot/src/main.rs
+++ b/src/hyperlight_wasm_aot/src/main.rs
@@ -18,95 +18,90 @@ use std::path::Path;
 
 use cargo_metadata::{MetadataCommand, Package};
 use cargo_util_schemas::manifest::PackageName;
-use clap::{Arg, Command};
+use clap::{Parser, Subcommand};
 use wasmtime::{Config, Engine, Module, OptLevel, Precompiled};
 
+#[derive(Parser)]
+#[command(name = "hyperlight-wasm-aot")]
+#[command(version = env!("CARGO_PKG_VERSION"))]
+#[command(about = "Precompile WebAssembly modules and components for hyperlight-wasm")]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Precompile a WebAssembly module or component for Wasmtime
+    Compile {
+        /// The input WebAssembly file
+        input: String,
+
+        /// The output file path (defaults to input with .aot extension)
+        output: Option<String>,
+
+        /// Compile a component rather than a module
+        #[arg(long)]
+        component: bool,
+
+        /// Precompile with debug and disable optimizations
+        #[arg(long)]
+        debug: bool,
+
+        /// Disable address map and native unwind info for smaller binaries
+        #[arg(long)]
+        minimal: bool,
+    },
+
+    /// Check which Wasmtime version was used to precompile a module
+    CheckWasmtimeVersion {
+        /// The precompiled file to check
+        file: String,
+
+        /// Specifies if the module has been compiled with debug support
+        #[arg(long)]
+        debug: bool,
+    },
+}
+
 fn main() {
-    let hyperlight_wasm_aot_version = env!("CARGO_PKG_VERSION");
-    let matches = Command::new("hyperlight-wasm-aot")
-        .version(hyperlight_wasm_aot_version)
-        .about("AOT compilation for hyperlight-wasm")
-        .subcommand(
-            Command::new("compile")
-                .about("Compile a wasm file to an AOT file")
-                .arg(
-                    Arg::new("input")
-                        .help("The input wasm file")
-                        .required(true)
-                        .index(1),
-                )
-                .arg(
-                    Arg::new("output")
-                        .help("The output AOT file")
-                        .required(false)
-                        .index(2),
-                )
-                .arg(
-                    Arg::new("component")
-                        .help("Compile a component rather than a module")
-                        .required(false)
-                        .long("component")
-                        .action(clap::ArgAction::SetTrue),
-                )
-                .arg(
-                    Arg::new("debug")
-                        .help("Precompile with debug and disable optimizations")
-                        .required(false)
-                        .long("debug")
-                        .action(clap::ArgAction::SetTrue),
-                ),
-        )
-        .subcommand(
-            Command::new("check-wasmtime-version")
-                .about("Check the Wasmtime version use to compile a AOT file")
-                .arg(
-                    Arg::new("file")
-                        .help("The aot compiled file to check")
-                        .required(true)
-                        .index(1),
-                )
-                .arg(
-                    Arg::new("debug")
-                        .help("Specifies if the module has been compiled with debug support")
-                        .required(false)
-                        .long("debug")
-                        .action(clap::ArgAction::SetTrue),
-                ),
-        )
-        .get_matches();
-
-    match matches.subcommand_name() {
-        Some("compile") => {
-            let args = matches.subcommand_matches("compile").unwrap();
-            let infile = args.get_one::<String>("input").unwrap();
-            let outfile = match args.get_one::<String>("output") {
-                Some(s) => s.clone(),
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Compile {
+            input,
+            output,
+            component,
+            debug,
+            minimal,
+        } => {
+            let outfile = match output {
+                Some(s) => s,
                 None => {
-                    let mut path = Path::new(infile).to_path_buf();
+                    let mut path = Path::new(&input).to_path_buf();
                     path.set_extension("aot");
-                    path.to_str().unwrap().to_string().clone()
+                    path.to_str().unwrap().to_string()
                 }
             };
-            let debug = args.get_flag("debug");
             if debug {
                 println!(
                     "Aot Compiling {} to {} with debug info and optimizations off",
-                    infile, outfile
+                    input, outfile
                 );
             } else {
-                println!("Aot Compiling {} to {}", infile, outfile);
+                println!("Aot Compiling {} to {}", input, outfile);
             }
-            let config = get_config(debug);
+            let config = get_config(debug, minimal);
             let engine = Engine::new(&config).unwrap();
-            let bytes = std::fs::read(infile).unwrap();
-            let serialized = if args.get_flag("component") {
+            let bytes = std::fs::read(&input).unwrap();
+            let serialized = if component {
                 engine.precompile_component(&bytes).unwrap()
             } else {
                 engine.precompile_module(&bytes).unwrap()
             };
             std::fs::write(outfile, serialized).unwrap();
         }
-        Some("check-wasmtime-version") => {
+        Commands::CheckWasmtimeVersion { file, debug } => {
             // get the wasmtime version used by hyperlight-wasm-aot
             let metadata = MetadataCommand::new().exec().unwrap();
             let package_name = PackageName::new("wasmtime".to_string()).unwrap();
@@ -116,11 +111,6 @@ fn main() {
                 Some(pkg) => pkg.version.clone(),
                 None => panic!("wasmtime dependency not found"),
             };
-            let args = matches
-                .subcommand_matches("check-wasmtime-version")
-                .unwrap();
-            let debug = args.get_flag("debug");
-            let file = args.get_one::<String>("file").unwrap();
             if debug {
                 println!(
                     "Checking Wasmtime version used to compile debug info enabled file: {}",
@@ -130,8 +120,8 @@ fn main() {
                 println!("Checking Wasmtime version used to compile file: {}", file);
             }
             // load the file into wasmtime, check that it is aot compiled and extract the version of wasmtime used to compile it from its metadata
-            let bytes = std::fs::read(file).unwrap();
-            let config = get_config(debug);
+            let bytes = std::fs::read(&file).unwrap();
+            let config = get_config(debug, false);
             let engine = Engine::new(&config).unwrap();
             match Engine::detect_precompiled(&bytes) {
                 Some(pre_compiled) => {
@@ -174,14 +164,11 @@ fn main() {
                 }
             }
         }
-        _ => {
-            println!("No subcommand specified");
-        }
     }
 }
 
 /// Returns a new `Config` for the Wasmtime engine with additional settings for AOT compilation.
-fn get_config(debug: bool) -> Config {
+fn get_config(debug: bool, minimal: bool) -> Config {
     let mut config = Config::new();
     config.target("x86_64-unknown-none").unwrap();
 
@@ -191,5 +178,10 @@ fn get_config(debug: bool) -> Config {
         config.cranelift_opt_level(OptLevel::None);
     }
 
+    if minimal {
+        config.generate_address_map(false);
+        config.native_unwind_info(false);
+    }
+
     config
 }
