diff --git a/Cargo.lock b/Cargo.lock
index 6fcbda81..b6a5e7f9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -129,7 +129,9 @@ version = "0.9.0"
 dependencies = [
  "anyhow",
  "bincode",
+ "clap",
  "compile_commands",
+ "dialoguer",
  "dirs",
  "flexi_logger",
  "home",
@@ -357,6 +359,19 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "console"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+dependencies = [
+ "encode_unicode",
+ "lazy_static",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "core-foundation"
 version = "0.9.4"
@@ -427,6 +442,20 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "dialoguer"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bce805d770f407bc62102fca7c2c64ceef2fbcb2b8bd19d2765ce093980de"
+dependencies = [
+ "console",
+ "fuzzy-matcher",
+ "shell-words",
+ "tempfile",
+ "thiserror",
+ "zeroize",
+]
+
 [[package]]
 name = "dirs"
 version = "5.0.1"
@@ -477,6 +506,12 @@ dependencies = [
  "stable_deref_trait",
 ]
 
+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
 [[package]]
 name = "encoding_rs"
 version = "0.8.34"
@@ -632,6 +667,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.15"
@@ -1729,6 +1773,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -1993,6 +2043,16 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.8.0"
@@ -2164,6 +2224,12 @@ dependencies = [
  "tinyvec",
 ]
 
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
 [[package]]
 name = "untrusted"
 version = "0.9.0"
diff --git a/Cargo.toml b/Cargo.toml
index 6e5d34a6..b72e61b7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,6 +20,9 @@ license = "BSD-2-Clause"
 [workspace.dependencies]
 anyhow = "1.0.86"
 bincode = "1.3.3"
+dirs = "5.0.1"
+toml = "0.8.1"
+clap = { version = "4.5.8", features = ["derive", "cargo"] }
 serde = { version = "1.0.204", features = ["derive"] }
 
 [workspace.lints.clippy]
diff --git a/README.md b/README.md
index b87c99cd..b51672fa 100644
--- a/README.md
+++ b/README.md
@@ -62,6 +62,28 @@ created for different sub-directories or files within your project as `project`s
 Source files not contained within any `project` configs will use the default configuration
 if provided.
 
+#### Config Builder
+
+Creating a `.asm-lsp.toml` file manually is fine, but can be error-prone as projects
+grow in complexity. Running `asm-lsp gen-config` will walk you through the creation
+of a config interactively, with informative prompts and extra validation checks
+along the way.
+
+```
+$ asm-lsp gen-config --help
+Generate a .asm-lsp.toml config file
+
+Usage: asm-lsp gen-config [OPTIONS]
+
+Options:
+  -o, --output-dir <OUTPUT_DIR>      Directory to place .asm-lsp.toml into. (Default is the current directory)
+  -g, --global-cfg                   Place the config in the global config directory
+  -p, --project-path <PROJECT_PATH>  Path to the project this config is being generated for. (Default is the current directory)
+  -w, --overwrite                    Overwrite any existing .asm-lsp.toml in the target directory
+  -q, --quiet                        Don't display the generated config file after generation
+  -h, --help                         Print help
+```
+
 #### NOTE
 
 If the server reads in an invalid configuration file, it will display an error
diff --git a/asm-lsp/Cargo.toml b/asm-lsp/Cargo.toml
index 9f66436b..963a9a7e 100644
--- a/asm-lsp/Cargo.toml
+++ b/asm-lsp/Cargo.toml
@@ -25,6 +25,9 @@ path = "bin/main.rs"
 anyhow.workspace = true
 bincode.workspace = true
 serde.workspace = true
+dirs.workspace = true
+toml.workspace = true
+clap.workspace = true
 # write to stderr instead of stdout
 flexi_logger = "0.29.3"
 log = { version = "0.4.17" }
@@ -35,10 +38,8 @@ reqwest = { version = "0.12.8", features = ["blocking"] }
 strum = "0.26.3"
 strum_macros = "0.26.4"
 serde_json = "1.0.94"
-toml = "0.8.1"
 home = "0.5.5"
 once_cell = "1.18.0"
-dirs = "5.0.1"
 symbolic = { version = "12.8.0", features = ["demangle"] }
 symbolic-demangle = "12.8.0"
 url-escape = "0.1.1"
@@ -47,6 +48,7 @@ lsp-textdocument = "0.4.0"
 tree-sitter = "0.22.6"
 tree-sitter-asm = "0.22.6"
 compile_commands = "0.3.0"
+dialoguer = { version = "0.11.0", features = ["fuzzy-select"] }
 
 [dev-dependencies]
 mockito = "1.2.0"
diff --git a/asm-lsp/bin/main.rs b/asm-lsp/bin/main.rs
index 626bb769..65455a21 100644
--- a/asm-lsp/bin/main.rs
+++ b/asm-lsp/bin/main.rs
@@ -1,6 +1,8 @@
 use std::thread::sleep;
 use std::time::Duration;
 
+use asm_lsp::config_builder::{gen_config, GenerateArgs, GenerateOpts};
+use asm_lsp::run_info;
 use asm_lsp::types::LspClient;
 
 use asm_lsp::handle::{handle_notification, handle_request};
@@ -9,6 +11,7 @@ use asm_lsp::{
     send_notification, DocumentStore, RootConfig, ServerStore,
 };
 
+use clap::{Command, FromArgMatches as _, Subcommand};
 use lsp_types::{
     CompletionItemKind, CompletionOptions, CompletionOptionsCompletionItem, DiagnosticOptions,
     DiagnosticServerCapabilities, HoverProviderCapability, InitializeParams, MessageType, OneOf,
@@ -20,7 +23,61 @@ use anyhow::Result;
 use log::{info, warn};
 use lsp_server::{Connection, Message};
 
-/// Entry point of the server. Connects to the client, loads documentation resources,
+#[derive(Subcommand)]
+enum Commands {
+    GenConfig(GenerateArgs),
+    /// Print information about asm-lsp
+    Info,
+    #[clap(hide(true))]
+    Run,
+}
+
+/// Entry point of the lsp. Runs a subcommand is specified, otherwise starts the
+/// lsp server
+///
+/// # Errors
+///
+/// Returns `Err` on failure to parse arguments, if a sub command fails, or if the
+/// server returns an error
+pub fn main() -> Result<()> {
+    let cli = Command::new("asm-lsp").subcommand_required(false);
+    let cli = Commands::augment_subcommands(cli);
+
+    let command = match Commands::from_arg_matches(&cli.get_matches()) {
+        Ok(cmd) => cmd,
+        Err(e) => {
+            // If no subcommand is provided, run the server as normal
+            if e.kind() == clap::error::ErrorKind::MissingSubcommand {
+                Commands::Run
+            } else {
+                eprintln!("{e}");
+                std::process::exit(1);
+            }
+        }
+    };
+    match command {
+        Commands::GenConfig(args) => {
+            let opts: GenerateOpts = match args.try_into() {
+                Ok(opts) => opts,
+                Err(e) => {
+                    eprintln!("{e}");
+                    std::process::exit(1);
+                }
+            };
+
+            if let Err(e) = gen_config(&opts) {
+                eprintln!("Error: {e}");
+                std::process::exit(1);
+            }
+        }
+        Commands::Info => run_info(),
+        Commands::Run => run_lsp()?,
+    }
+
+    Ok(())
+}
+
+/// Entry point of the lsp server. Connects to the client, loads documentation resources,
 /// and then enters the main loop
 ///
 /// # Errors
@@ -30,7 +87,7 @@ use lsp_server::{Connection, Message};
 /// # Panics
 ///
 /// Panics if JSON serialization of the server capabilities fails
-pub fn main() -> Result<()> {
+pub fn run_lsp() -> Result<()> {
     // initialisation
     // Set up logging. Because `stdio_transport` gets a lock on stdout and stdin, we must have our
     // logging only write out to stderr.
diff --git a/asm-lsp/config_builder.rs b/asm-lsp/config_builder.rs
new file mode 100644
index 00000000..57f0358f
--- /dev/null
+++ b/asm-lsp/config_builder.rs
@@ -0,0 +1,597 @@
+use std::path::Path;
+use std::string::ToString;
+use std::{env::current_dir, path::PathBuf};
+
+use anyhow::{anyhow, Result};
+use clap::{arg, Args};
+use dirs::config_dir;
+
+use crate::types::{Arch, Assembler, Config, ConfigOptions, ProjectConfig, RootConfig};
+
+use dialoguer::{theme::ColorfulTheme, Confirm, FuzzySelect, Input};
+
+const ARCH_LIST: [Arch; 7] = [
+    Arch::X86,
+    Arch::X86_64,
+    Arch::X86_AND_X86_64,
+    Arch::ARM,
+    Arch::ARM64,
+    Arch::RISCV,
+    Arch::Z80,
+];
+
+const ASSEMBLER_LIST: [Assembler; 4] = [
+    Assembler::Gas,
+    Assembler::Go,
+    Assembler::Masm,
+    Assembler::Nasm,
+];
+
+#[derive(Args, Debug, Clone)]
+#[command(about = "Generate a .asm-lsp.toml config file")]
+pub struct GenerateArgs {
+    #[arg(
+        long,
+        short,
+        help = "Directory to place .asm-lsp.toml into. (Default is the current directory)"
+    )]
+    pub output_dir: Option<PathBuf>,
+    #[arg(
+        long,
+        short,
+        conflicts_with = "output_dir",
+        help = "Place the config in the global config directory"
+    )]
+    pub global_cfg: bool,
+    #[arg(
+        long,
+        short,
+        conflicts_with = "global_cfg",
+        help = "Path to the project this config is being generated for. (Default is the current directory)"
+    )]
+    pub project_path: Option<PathBuf>,
+    #[arg(
+        short = 'w',
+        long,
+        help = "Overwrite any existing .asm-lsp.toml in the target directory"
+    )]
+    pub overwrite: bool,
+    #[arg(
+        short,
+        long,
+        help = "Don't display the generated config file after generation"
+    )]
+    pub quiet: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct GenerateOpts {
+    pub output_path: PathBuf,
+    pub project_path: PathBuf,
+    pub overwrite: bool,
+    pub quiet: bool,
+}
+
+impl TryFrom<GenerateArgs> for GenerateOpts {
+    type Error = String;
+    fn try_from(value: GenerateArgs) -> Result<Self, std::string::String> {
+        let output_path = {
+            if value.global_cfg {
+                let mut path = config_dir().ok_or_else(|| "Failed to detect config directory, try specifying it manually with `--output_dir`".to_string())?;
+                path.push("asm-lsp");
+                path.push(".asm-lsp.toml");
+                path
+            } else if let Some(path) = value.output_dir.as_ref() {
+                let mut canonicalized_path = path.canonicalize().map_err(|e| {
+                    format!(
+                        "Failed to canonicalize target path: \"{}\" -- {e}",
+                        path.display()
+                    )
+                })?;
+                if !canonicalized_path.is_dir() {
+                    let gave_file_name = canonicalized_path.ends_with(".asm-lsp.toml");
+                    return Err(format!(
+                        "Target path \"{}\" is not a directory.{}",
+                        canonicalized_path.display(),
+                        if gave_file_name {
+                            " Hint: Don't include the filename \".asm-lsp.toml\" at the end of your target path."
+                        } else {
+                            ""
+                        }
+                    ));
+                }
+                canonicalized_path.push(".asm-lsp.toml");
+                canonicalized_path
+            } else {
+                let mut path = current_dir()
+                    .map_err(|e| format!("Failed to detect current directory -- {e}"))?;
+                path.push(".asm-lsp.toml");
+                path
+            }
+        };
+        let project_path = {
+            if let Some(path) = value.project_path.as_ref().or(value.output_dir.as_ref()) {
+                let canonicalized_path = path.canonicalize().map_err(|e| {
+                    format!(
+                        "Failed to canonicalize project path: \"{}\" -- {e}",
+                        path.display()
+                    )
+                })?;
+                if !canonicalized_path.is_dir() {
+                    return Err(format!(
+                        "Project path \"{}\" is not a directory.",
+                        canonicalized_path.display(),
+                    ));
+                }
+                canonicalized_path
+            } else {
+                current_dir().map_err(|e| format!("Failed to detect current directory -- {e}"))?
+            }
+        };
+
+        Ok(Self {
+            output_path,
+            project_path,
+            overwrite: value.overwrite,
+            quiet: value.quiet,
+        })
+    }
+}
+
+fn prompt_arch() -> Arch {
+    let arch_choices: Vec<String> = ARCH_LIST.iter().map(ToString::to_string).collect();
+    let arch_selection = FuzzySelect::with_theme(&ColorfulTheme::default())
+        .with_prompt("Select architecture")
+        .default(0)
+        .items(&arch_choices[..])
+        .interact()
+        .unwrap();
+
+    ARCH_LIST[arch_selection]
+}
+
+fn prompt_assembler() -> Assembler {
+    let assem_choices: Vec<String> = ASSEMBLER_LIST.iter().map(ToString::to_string).collect();
+    let assem_selection = FuzzySelect::with_theme(&ColorfulTheme::default())
+        .with_prompt("Select assembler")
+        .default(0)
+        .items(&assem_choices[..])
+        .interact()
+        .unwrap();
+
+    ASSEMBLER_LIST[assem_selection]
+}
+
+fn prompt_project_path(opts: &GenerateOpts) -> PathBuf {
+    println!("Provide a project path:");
+    let fallback_enter = |true_path: &mut PathBuf| {
+        println!(
+            "Warning: Failed to create directory reader for path \"{}\"",
+            true_path.display()
+        );
+        let remaining_path: String = Input::with_theme(&ColorfulTheme::default())
+            .with_prompt("Enter remaining path (Enter an empty string to use the current path)")
+            .allow_empty(true)
+            .interact_text()
+            .unwrap();
+        true_path.push(remaining_path);
+    };
+    let mut true_path = opts.project_path.clone();
+    let mut display_entries = Vec::new();
+    let mut path_entries = Vec::new();
+    loop {
+        let selection_text = format!("{}", true_path.display());
+        // Dummy entry to account for the accept option as the first displayed
+        // option
+        path_entries.push(PathBuf::new());
+        display_entries.push("<Select This Directory>".to_string());
+        let Ok(dir_reader) = std::fs::read_dir(&true_path) else {
+            fallback_enter(&mut true_path);
+            return true_path;
+        };
+
+        let mut dir_entries = Vec::new();
+        let mut file_entries = Vec::new();
+        for entry in dir_reader.filter_map(std::result::Result::ok) {
+            let entry_path = entry.path();
+            if entry_path.is_dir() {
+                dir_entries.push(entry_path);
+            } else {
+                file_entries.push(entry_path);
+            }
+        }
+
+        dir_entries.sort();
+        file_entries.sort();
+
+        for entry_path in dir_entries.into_iter().chain(file_entries) {
+            path_entries.push(entry_path.clone());
+            if let Some(name) = entry_path.file_name() {
+                display_entries.push(name.to_string_lossy().to_string());
+            }
+        }
+        let path_selection = FuzzySelect::with_theme(&ColorfulTheme::default())
+            .with_prompt(&selection_text)
+            .default(0)
+            .items(&display_entries[..])
+            .interact()
+            .unwrap();
+
+        // Select current value of `true_path`
+        if path_selection == 0 {
+            if true_path.to_string_lossy().len() == opts.project_path.to_string_lossy().len() &&
+                !Confirm::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Warning: Creating project config for the entire project. Keep this path selection?")
+                    .default(false)
+                    .interact()
+                    .unwrap() {
+                       continue;
+            }
+            break;
+        }
+
+        true_path.clone_from(&path_entries[path_selection]);
+        if true_path.is_file() {
+            break;
+        }
+        path_entries.clear();
+        display_entries.clear();
+    }
+
+    // Get the project-relative path out for the sake of portability, i.e. if a
+    // user changes the location of their project, their config should still work
+    let mut relative_path = PathBuf::new();
+    for comp in true_path
+        .components()
+        .skip(opts.project_path.components().count())
+    {
+        relative_path.push(comp);
+    }
+
+    relative_path
+}
+
+fn prompt_project(opts: &GenerateOpts) -> ProjectConfig {
+    let path = prompt_project_path(opts);
+    let config = prompt_config();
+
+    ProjectConfig { path, config }
+}
+
+/// Check if a path points to an executable file
+fn is_executable(path: &Path) -> bool {
+    if path.is_file() {
+        #[cfg(unix)]
+        {
+            // On Unix, check the `x` bit
+            use std::fs;
+            use std::os::unix::fs::PermissionsExt;
+            let metadata = fs::metadata(path).unwrap();
+            metadata.permissions().mode() & 0o111 != 0
+        }
+        #[cfg(windows)]
+        {
+            // On Windows, check for common executable extensions
+            let extensions = ["exe", "cmd", "bat", "com"];
+            if let Some(ext) = path.extension().and_then(|s| s.to_str()) {
+                return extensions.contains(&ext);
+            }
+            false
+        }
+    } else {
+        false
+    }
+}
+
+/// Check if `cmd` has a corresponding executable file on $PATH
+#[must_use]
+fn is_executable_on_path(cmd: &str) -> bool {
+    use std::env;
+    // Get the PATH environment variable
+    let path_var = env::var_os("PATH").unwrap();
+
+    for path in env::split_paths(&path_var) {
+        let full_path = path.join(cmd);
+        if is_executable(&full_path) {
+            return true;
+        }
+    }
+    println!("Warning: Unable to find provided compiler as executable file on $PATH");
+    false
+}
+
+fn validate_compiler(comp: &str) -> bool {
+    // Attempt to provide some soft validation, warn the user if something
+    // looks fishy
+    if comp.contains(std::path::MAIN_SEPARATOR) {
+        // Treat it as a path
+        let Ok(path) = PathBuf::from(comp).canonicalize() else {
+            println!("Warning: Failed to canonicalize path \"{comp}\"",);
+            return false;
+        };
+        let exists = path.exists();
+        let is_file = path.is_file();
+        let is_exec = is_executable(&path);
+        if !exists {
+            println!(
+                "Warning: File does not exist at path \"{}\"",
+                path.display()
+            );
+        } else if !is_file {
+            println!(
+                "Warning: Path \"{}\" does not point to a file",
+                path.display()
+            );
+        } else if !is_exec {
+            println!(
+                "Warning: Path \"{}\" does not point to an executable file",
+                path.display()
+            );
+        }
+
+        exists && is_file && is_exec
+    } else {
+        is_executable_on_path(comp)
+    }
+}
+
+fn prompt_compiler() -> Option<String> {
+    if !Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt("Provide compiler to use with `compile_flags.txt` files or the following (optional) compile flags field")
+        .default(true)
+        .interact()
+        .unwrap() {
+        return None;
+    }
+    let mut comp: String;
+    loop {
+        comp = Input::with_theme(&ColorfulTheme::default())
+            .with_prompt("Enter Compiler")
+            .interact_text()
+            .unwrap();
+
+        // Attempt to provide some soft validation, warn the user if something
+        // looks fishy
+        if validate_compiler(&comp)
+            || !Confirm::with_theme(&ColorfulTheme::default())
+                .with_prompt("Re-enter compiler?")
+                .default(true)
+                .interact()
+                .unwrap()
+        {
+            break;
+        }
+    }
+
+    Some(comp)
+}
+
+fn prompt_config_opts() -> ConfigOptions {
+    let compiler = prompt_compiler();
+    // If the user specifies a compiler in their config, it makes sense to provide
+    // corresponding flags.
+    let compile_flags_txt = if compiler.is_some() {
+        let mut flags = Vec::new();
+        loop {
+            let flag: String = Input::with_theme(&ColorfulTheme::default())
+                .with_prompt("Add a compiler flag: (Enter an empty string to stop)")
+                .allow_empty(true)
+                .validate_with(|input: &String| -> Result<()> {
+                    // NOTE: Do we need to handle escaped quotes here?
+                    let mut in_quotes = false;
+                    for (i, c) in input.chars().enumerate() {
+                        match c {
+                            '\"' => in_quotes = !in_quotes,
+                            ' ' => {
+                                if !in_quotes {
+                                    return Err(anyhow!(
+                                        "\n{input}\n{}^\nUnquoted space found, specify each flag separately.",
+                                        " ".repeat(i),
+                                    ));
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                    Ok(())
+                })
+                .interact_text()
+                .unwrap();
+            if flag.is_empty() {
+                break;
+            }
+            flags.push(flag);
+        }
+        Some(flags)
+    } else {
+        None
+    };
+
+    let diagnostics = Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt("Enable diagnostic features?")
+        .default(true)
+        .interact()
+        .unwrap();
+
+    // only offer the `default_diagnostics` option if both
+    //      A) diagnostics are enabled
+    //      B) The user didn't specify compiler instructions via the `compiler`
+    //         field (if they did so, default diagnostics will never be used)
+    let default_diagnostics = if diagnostics && compiler.is_none() && Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt("Attempt to provide diagnostics if no compilation information can be found for a source file?")
+        .default(true)
+        .interact()
+        .unwrap() {
+            Some(true)
+    } else {
+        Some(false)
+    };
+
+    ConfigOptions {
+        compiler,
+        compile_flags_txt,
+        diagnostics: Some(diagnostics),
+        default_diagnostics,
+    }
+}
+
+fn prompt_config() -> Config {
+    let instruction_set = prompt_arch();
+    let assembler = prompt_assembler();
+    let opts = if Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt("Configure diagnostic related features?")
+        .default(true)
+        .interact()
+        .unwrap()
+    {
+        Some(prompt_config_opts())
+    } else {
+        None
+    };
+
+    Config {
+        version: Some(env!("CARGO_PKG_VERSION").to_string()),
+        instruction_set,
+        assembler,
+        opts,
+        client: None,
+    }
+}
+
+fn prompt_root_config(opts: &GenerateOpts) -> RootConfig {
+    let get_project_idx = |path: &PathBuf, projects: &Vec<ProjectConfig>| -> Option<usize> {
+        projects
+            .iter()
+            .enumerate()
+            .find(|(_, p)| p.path == *path)
+            .map(|(idx, _)| idx)
+    };
+    let default_config = if Confirm::with_theme(&ColorfulTheme::default())
+        .with_prompt("Create default config?")
+        .interact()
+        .unwrap()
+    {
+        Some(prompt_config())
+    } else {
+        None
+    };
+
+    let mut projects: Vec<ProjectConfig> = Vec::new();
+    loop {
+        if !Confirm::with_theme(&ColorfulTheme::default())
+            .with_prompt("Add a new project config?")
+            .interact()
+            .unwrap()
+        {
+            break;
+        }
+        let mut new_project = prompt_project(opts);
+        let mut check_action: Option<usize> = None;
+        for (i, project) in projects.iter().enumerate() {
+            if project.path == new_project.path {
+                eprintln!("Error: Multiple project configs with the same project path.");
+                println!(
+                    "Newer project config:\n{}",
+                    toml::to_string_pretty::<ProjectConfig>(&new_project)
+                        .expect("Failed to display project config")
+                );
+                println!(
+                    "Older project config ({i}):\n{}",
+                    toml::to_string_pretty::<ProjectConfig>(project)
+                        .expect("Failed to display project config")
+                );
+                let options = &[
+                    "Discard newer project config",
+                    "Edit newer project config path",
+                    "Discard older project config",
+                    "Edit older project config path",
+                ];
+                check_action = FuzzySelect::with_theme(&ColorfulTheme::default())
+                    .with_prompt("Choose resolution method")
+                    .default(0)
+                    .items(&options[..])
+                    .interact()
+                    .unwrap()
+                    .into();
+                break;
+            }
+        }
+        match check_action {
+            // Everything's good, add the new project
+            None => projects.push(new_project),
+            // Don't push `new_project` into `projects`
+            Some(0) => {}
+            // Prompt the user to change their new project path until one doesn't collide
+            Some(1) => {
+                while let Some(idx) = get_project_idx(&new_project.path, &projects) {
+                    println!(
+                        "Project path collision with project config {idx} -- {}",
+                        new_project.path.display()
+                    );
+                    new_project.path = prompt_project_path(opts);
+                }
+                projects.push(new_project);
+            }
+            // Remove the old project from `projects`
+            Some(2) => {
+                let old_idx = get_project_idx(&new_project.path, &projects).unwrap();
+                projects.remove(old_idx);
+                projects.push(new_project);
+            }
+            // Prompt the user to change their old project path until one doesn't collide
+            Some(3) => {
+                let old_idx = get_project_idx(&new_project.path, &projects).unwrap();
+                while let Some(idx) = get_project_idx(&new_project.path, &projects) {
+                    println!(
+                        "Project path collision with project config {idx} -- {}",
+                        new_project.path.display()
+                    );
+                    projects[old_idx].path = prompt_project_path(opts);
+                }
+                projects.push(new_project);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    RootConfig {
+        default_config,
+        projects: if projects.is_empty() {
+            None
+        } else {
+            Some(projects)
+        },
+    }
+}
+
+/// Prompts the user through generating a `.asm-lsp.toml` config file
+///
+/// # Errors
+///
+/// Returns `Err` if
+///     - A config file exists and the `--overwrite` flag wasn't used
+///     - An error occurs during config generation
+///     - Serialization of the generated config fails
+///     - Writing the serialized config to a file fails
+pub fn gen_config(opts: &GenerateOpts) -> Result<()> {
+    if !opts.overwrite && opts.output_path.exists() {
+        return Err(anyhow!(
+            "The target path \"{}\" already exists and `--overwrite` was not used",
+            opts.output_path.display()
+        ));
+    }
+    let root_config = prompt_root_config(opts);
+    let file_config = toml::to_string_pretty::<RootConfig>(&root_config).map_err(|e| {
+        anyhow!("Failed to serialize configuration -- {e}\nPlease file a bug report: https://github.com/bergercookie/asm-lsp/issues/new")
+    })?;
+    if !opts.quiet {
+        println!("{file_config}");
+    }
+    std::fs::write(&opts.output_path, file_config).map_err(|e| {
+        anyhow!(
+            "Failed to write config file to path \"{}\" -- {e}",
+            opts.output_path.display()
+        )
+    })?;
+    Ok(())
+}
diff --git a/asm-lsp/lib.rs b/asm-lsp/lib.rs
index eaf80a55..00d9c639 100644
--- a/asm-lsp/lib.rs
+++ b/asm-lsp/lib.rs
@@ -1,3 +1,4 @@
+pub mod config_builder;
 pub mod handle;
 pub mod lsp;
 pub mod parser;
diff --git a/asm-lsp/lsp.rs b/asm-lsp/lsp.rs
index 753a8b09..5de15ce1 100644
--- a/asm-lsp/lsp.rs
+++ b/asm-lsp/lsp.rs
@@ -37,6 +37,34 @@ use crate::{
     LspClient, NameToInstructionMap, RootConfig, TreeEntry,
 };
 
+/// Prints information about the server
+///
+/// - Server version
+/// - Attempts to find the global configuration directories on the host machine,
+///   and indicates whether a `.asm-lsp.toml` config file is present
+pub fn run_info() {
+    println!("asm-lsp-{}\n", env!("CARGO_PKG_VERSION"));
+    let mut global_cfgs: Vec<PathBuf> = get_global_cfg_dirs()
+        .iter()
+        .filter_map(|p| (*p).clone())
+        .collect();
+    println!("Default config architecture: {}", Arch::default());
+    println!(
+        "Global config director{}:",
+        if global_cfgs.len() > 1 { "ies" } else { "y" }
+    );
+    for cfg_path in &mut global_cfgs {
+        cfg_path.push("asm-lsp");
+        print!("\t{}", cfg_path.display());
+        cfg_path.push(".asm-lsp.toml");
+        if cfg_path.exists() {
+            println!(" -- Config detected");
+        } else {
+            println!(" -- No config detected");
+        }
+    }
+}
+
 /// Sends an empty, non-error response to the lsp client via `connection`
 ///
 /// # Errors
@@ -1770,14 +1798,19 @@ pub fn get_root_config(params: &InitializeParams) -> Result<RootConfig> {
     Ok(config)
 }
 
-/// Checks ~/.config/asm-lsp for a config file, creating directories along the way as necessary
-fn get_global_config() -> Option<Result<RootConfig>> {
-    let mut paths = if cfg!(target_os = "macos") {
+#[must_use]
+pub fn get_global_cfg_dirs() -> Vec<Option<PathBuf>> {
+    if cfg!(target_os = "macos") {
         // `$HOME`/Library/Application Support/ and `$HOME`/.config/
         vec![config_dir(), alt_mac_config_dir()]
     } else {
         vec![config_dir()]
-    };
+    }
+}
+
+/// Checks ~/.config/asm-lsp for a config file, creating directories along the way as necessary
+fn get_global_config() -> Option<Result<RootConfig>> {
+    let mut paths = get_global_cfg_dirs();
 
     for cfg_path in paths.iter_mut().flatten() {
         cfg_path.push("asm-lsp");
@@ -1817,7 +1850,10 @@ fn get_global_config() -> Option<Result<RootConfig>> {
     None
 }
 
-fn alt_mac_config_dir() -> Option<PathBuf> {
+// Returns `$HOME`/.config/ for usage on MacOS, as this isn't the default
+// config directory
+#[must_use]
+pub fn alt_mac_config_dir() -> Option<PathBuf> {
     home::home_dir().map(|mut path| {
         path.push(".config");
         path
diff --git a/asm_docs_parsing/Cargo.toml b/asm_docs_parsing/Cargo.toml
index 859e4cbb..da967aa8 100644
--- a/asm_docs_parsing/Cargo.toml
+++ b/asm_docs_parsing/Cargo.toml
@@ -13,8 +13,8 @@ edition.workspace = true
 bincode.workspace = true
 anyhow.workspace = true
 serde.workspace = true
+clap.workspace = true
 asm-lsp = { path = "../asm-lsp" }
-clap = { version = "4.5.8", features = ["derive"] }
 
 [lints]
 workspace = true