diff --git a/compiler/fm/Cargo.toml b/compiler/fm/Cargo.toml
index 1a356d93d89..b48f445be36 100644
--- a/compiler/fm/Cargo.toml
+++ b/compiler/fm/Cargo.toml
@@ -10,6 +10,7 @@ license.workspace = true
 
 [dependencies]
 codespan-reporting.workspace = true
+iter-extended.workspace = true
 serde.workspace = true
 
 [dev-dependencies]
diff --git a/compiler/fm/src/lib.rs b/compiler/fm/src/lib.rs
index 2e52d802479..37da29fc982 100644
--- a/compiler/fm/src/lib.rs
+++ b/compiler/fm/src/lib.rs
@@ -7,6 +7,7 @@ mod file_map;
 
 pub use file_map::{File, FileId, FileMap, PathString};
 
+use iter_extended::vecmap;
 // Re-export for the lsp
 pub use codespan_reporting::files as codespan_files;
 
@@ -103,6 +104,26 @@ impl FileManager {
     pub fn name_to_id(&self, file_name: PathBuf) -> Option<FileId> {
         self.file_map.get_file_id(&PathString::from_path(file_name))
     }
+
+    /// Find a file by its path suffix, e.g. "src/main.nr" is a suffix of
+    /// "some_dir/package_name/src/main.nr"`
+    pub fn find_by_path_suffix(&self, suffix: &str) -> Result<Option<FileId>, Vec<PathBuf>> {
+        let suffix_path: Vec<_> = Path::new(suffix).components().rev().collect();
+        let results: Vec<_> = self
+            .path_to_id
+            .iter()
+            .filter(|(path, _id)| {
+                path.components().rev().zip(suffix_path.iter()).all(|(x, y)| &x == y)
+            })
+            .collect();
+        if results.is_empty() {
+            Ok(None)
+        } else if results.len() == 1 {
+            Ok(Some(*results[0].1))
+        } else {
+            Err(vecmap(results, |(path, _id)| path.clone()))
+        }
+    }
 }
 
 pub trait NormalizePath {
diff --git a/compiler/noirc_driver/src/lib.rs b/compiler/noirc_driver/src/lib.rs
index 4ba9b85f967..2b0769e30d4 100644
--- a/compiler/noirc_driver/src/lib.rs
+++ b/compiler/noirc_driver/src/lib.rs
@@ -103,6 +103,11 @@ pub struct CompileOptions {
     #[arg(long, hide = true)]
     pub use_legacy: bool,
 
+    /// Enable printing results of comptime evaluation: provide a path suffix
+    /// for the module to debug, e.g. "package_name/src/main.nr"
+    #[arg(long)]
+    pub debug_comptime_in_file: Option<String>,
+
     /// Outputs the paths to any modified artifacts
     #[arg(long, hide = true)]
     pub show_artifact_paths: bool,
@@ -258,12 +263,14 @@ pub fn check_crate(
     deny_warnings: bool,
     disable_macros: bool,
     use_legacy: bool,
+    debug_comptime_in_file: Option<&str>,
 ) -> CompilationResult<()> {
     let macros: &[&dyn MacroProcessor] =
         if disable_macros { &[] } else { &[&aztec_macros::AztecMacro as &dyn MacroProcessor] };
 
     let mut errors = vec![];
-    let diagnostics = CrateDefMap::collect_defs(crate_id, context, use_legacy, macros);
+    let diagnostics =
+        CrateDefMap::collect_defs(crate_id, context, use_legacy, debug_comptime_in_file, macros);
     errors.extend(diagnostics.into_iter().map(|(error, file_id)| {
         let diagnostic = CustomDiagnostic::from(&error);
         diagnostic.in_file(file_id)
@@ -301,6 +308,7 @@ pub fn compile_main(
         options.deny_warnings,
         options.disable_macros,
         options.use_legacy,
+        options.debug_comptime_in_file.as_deref(),
     )?;
 
     let main = context.get_main_function(&crate_id).ok_or_else(|| {
@@ -342,6 +350,7 @@ pub fn compile_contract(
         options.deny_warnings,
         options.disable_macros,
         options.use_legacy,
+        options.debug_comptime_in_file.as_deref(),
     )?;
 
     // TODO: We probably want to error if contracts is empty
diff --git a/compiler/noirc_driver/tests/stdlib_warnings.rs b/compiler/noirc_driver/tests/stdlib_warnings.rs
index 47ce893d202..0e098d0d087 100644
--- a/compiler/noirc_driver/tests/stdlib_warnings.rs
+++ b/compiler/noirc_driver/tests/stdlib_warnings.rs
@@ -25,7 +25,7 @@ fn stdlib_does_not_produce_constant_warnings() -> Result<(), ErrorsAndWarnings>
     let root_crate_id = prepare_crate(&mut context, file_name);
 
     let ((), warnings) =
-        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false)?;
+        noirc_driver::check_crate(&mut context, root_crate_id, false, false, false, None)?;
 
     assert_eq!(warnings, Vec::new(), "stdlib is producing {} warnings", warnings.len());
 
diff --git a/compiler/noirc_errors/src/reporter.rs b/compiler/noirc_errors/src/reporter.rs
index ea7c97b1f25..3ce0f268715 100644
--- a/compiler/noirc_errors/src/reporter.rs
+++ b/compiler/noirc_errors/src/reporter.rs
@@ -19,6 +19,7 @@ pub enum DiagnosticKind {
     Error,
     Bug,
     Warning,
+    Info,
 }
 
 /// A count of errors that have been already reported to stderr
@@ -37,30 +38,57 @@ impl CustomDiagnostic {
         }
     }
 
-    pub fn simple_error(
+    fn simple_with_kind(
         primary_message: String,
         secondary_message: String,
         secondary_span: Span,
+        kind: DiagnosticKind,
     ) -> CustomDiagnostic {
         CustomDiagnostic {
             message: primary_message,
             secondaries: vec![CustomLabel::new(secondary_message, secondary_span)],
             notes: Vec::new(),
-            kind: DiagnosticKind::Error,
+            kind,
         }
     }
 
+    pub fn simple_error(
+        primary_message: String,
+        secondary_message: String,
+        secondary_span: Span,
+    ) -> CustomDiagnostic {
+        Self::simple_with_kind(
+            primary_message,
+            secondary_message,
+            secondary_span,
+            DiagnosticKind::Error,
+        )
+    }
+
     pub fn simple_warning(
         primary_message: String,
         secondary_message: String,
         secondary_span: Span,
     ) -> CustomDiagnostic {
-        CustomDiagnostic {
-            message: primary_message,
-            secondaries: vec![CustomLabel::new(secondary_message, secondary_span)],
-            notes: Vec::new(),
-            kind: DiagnosticKind::Warning,
-        }
+        Self::simple_with_kind(
+            primary_message,
+            secondary_message,
+            secondary_span,
+            DiagnosticKind::Warning,
+        )
+    }
+
+    pub fn simple_info(
+        primary_message: String,
+        secondary_message: String,
+        secondary_span: Span,
+    ) -> CustomDiagnostic {
+        Self::simple_with_kind(
+            primary_message,
+            secondary_message,
+            secondary_span,
+            DiagnosticKind::Info,
+        )
     }
 
     pub fn simple_bug(
@@ -96,6 +124,10 @@ impl CustomDiagnostic {
         matches!(self.kind, DiagnosticKind::Warning)
     }
 
+    pub fn is_info(&self) -> bool {
+        matches!(self.kind, DiagnosticKind::Info)
+    }
+
     pub fn is_bug(&self) -> bool {
         matches!(self.kind, DiagnosticKind::Bug)
     }
@@ -191,6 +223,7 @@ fn convert_diagnostic(
 ) -> Diagnostic<fm::FileId> {
     let diagnostic = match (cd.kind, deny_warnings) {
         (DiagnosticKind::Warning, false) => Diagnostic::warning(),
+        (DiagnosticKind::Info, _) => Diagnostic::note(),
         (DiagnosticKind::Bug, ..) => Diagnostic::bug(),
         _ => Diagnostic::error(),
     };
diff --git a/compiler/noirc_frontend/src/elaborator/expressions.rs b/compiler/noirc_frontend/src/elaborator/expressions.rs
index ad79af4e63d..f76ea79488a 100644
--- a/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -9,22 +9,22 @@ use crate::{
         UnresolvedTypeExpression,
     },
     hir::{
-        comptime::{self, Interpreter, InterpreterError},
+        comptime::{self, InterpreterError},
         resolution::{errors::ResolverError, resolver::LambdaContext},
         type_check::TypeCheckError,
     },
     hir_def::{
         expr::{
             HirArrayLiteral, HirBinaryOp, HirBlockExpression, HirCallExpression, HirCastExpression,
-            HirConstructorExpression, HirIfExpression, HirIndexExpression, HirInfixExpression,
-            HirLambda, HirMemberAccess, HirMethodCallExpression, HirMethodReference,
-            HirPrefixExpression,
+            HirConstructorExpression, HirExpression, HirIfExpression, HirIndexExpression,
+            HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
+            HirMethodReference, HirPrefixExpression,
         },
         traits::TraitConstraint,
     },
     macros_api::{
-        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirExpression,
-        HirLiteral, HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
+        BlockExpression, CallExpression, CastExpression, Expression, ExpressionKind, HirLiteral,
+        HirStatement, Ident, IndexExpression, Literal, MemberAccessExpression,
         MethodCallExpression, PrefixExpression,
     },
     node_interner::{DefinitionKind, ExprId, FuncId, ReferenceId},
@@ -660,12 +660,20 @@ impl<'context> Elaborator<'context> {
         // call is not yet solved for.
         self.function_context.push(Default::default());
         let (block, _typ) = self.elaborate_block_expression(block);
-        self.check_and_pop_function_context();
 
-        let mut interpreter =
-            Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
+        self.check_and_pop_function_context();
+        let mut interpreter_errors = vec![];
+        let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
         let value = interpreter.evaluate_block(block);
-        self.inline_comptime_value(value, span)
+        self.include_interpreter_errors(interpreter_errors);
+        let (id, typ) = self.inline_comptime_value(value, span);
+
+        let location = self.interner.id_location(id);
+        self.debug_comptime(location, |interner| {
+            interner.expression(&id).to_display_ast(interner, location.span).kind
+        });
+
+        (id, typ)
     }
 
     pub(super) fn inline_comptime_value(
@@ -736,9 +744,9 @@ impl<'context> Elaborator<'context> {
             }
         };
 
-        let mut interpreter =
-            Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
-
+        let file = self.file;
+        let mut interpreter_errors = vec![];
+        let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
         let mut comptime_args = Vec::new();
         let mut errors = Vec::new();
 
@@ -748,17 +756,19 @@ impl<'context> Elaborator<'context> {
                     let location = interpreter.interner.expr_location(&argument);
                     comptime_args.push((arg, location));
                 }
-                Err(error) => errors.push((error.into(), self.file)),
+                Err(error) => errors.push((error.into(), file)),
             }
         }
 
+        let bindings = interpreter.interner.get_instantiation_bindings(func).clone();
+        let result = interpreter.call_function(function, comptime_args, bindings, location);
+        self.include_interpreter_errors(interpreter_errors);
+
         if !errors.is_empty() {
             self.errors.append(&mut errors);
             return None;
         }
 
-        let bindings = interpreter.interner.get_instantiation_bindings(func).clone();
-        let result = interpreter.call_function(function, comptime_args, bindings, location);
         let (expr_id, typ) = self.inline_comptime_value(result, location.span);
         Some((self.interner.expression(&expr_id), typ))
     }
diff --git a/compiler/noirc_frontend/src/elaborator/mod.rs b/compiler/noirc_frontend/src/elaborator/mod.rs
index 6104da582a7..0862084f02d 100644
--- a/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -1,5 +1,6 @@
 use std::{
     collections::{BTreeMap, BTreeSet},
+    fmt::Display,
     rc::Rc,
 };
 
@@ -157,6 +158,9 @@ pub struct Elaborator<'context> {
     /// up all currently visible definitions. The first scope is always the global scope.
     comptime_scopes: Vec<HashMap<DefinitionId, comptime::Value>>,
 
+    /// The scope of --debug-comptime, or None if unset
+    debug_comptime_in_file: Option<FileId>,
+
     /// These are the globals that have yet to be elaborated.
     /// This map is used to lazily evaluate these globals if they're encountered before
     /// they are elaborated (e.g. in a function's type or another global's RHS).
@@ -178,7 +182,11 @@ struct FunctionContext {
 }
 
 impl<'context> Elaborator<'context> {
-    pub fn new(context: &'context mut Context, crate_id: CrateId) -> Self {
+    pub fn new(
+        context: &'context mut Context,
+        crate_id: CrateId,
+        debug_comptime_in_file: Option<FileId>,
+    ) -> Self {
         Self {
             scopes: ScopeForest::default(),
             errors: Vec::new(),
@@ -198,6 +206,7 @@ impl<'context> Elaborator<'context> {
             function_context: vec![FunctionContext::default()],
             current_trait_impl: None,
             comptime_scopes: vec![HashMap::default()],
+            debug_comptime_in_file,
             unresolved_globals: BTreeMap::new(),
         }
     }
@@ -206,8 +215,9 @@ impl<'context> Elaborator<'context> {
         context: &'context mut Context,
         crate_id: CrateId,
         items: CollectedItems,
+        debug_comptime_in_file: Option<FileId>,
     ) -> Vec<(CompilationError, FileId)> {
-        let mut this = Self::new(context, crate_id);
+        let mut this = Self::new(context, crate_id, debug_comptime_in_file);
 
         // Filter out comptime items to execute their functions first if needed.
         // This step is why comptime items can only refer to other comptime items
@@ -1276,15 +1286,15 @@ impl<'context> Elaborator<'context> {
         let DefinitionKind::Function(function) = definition.kind else {
             return Err((ResolverError::NonFunctionInAnnotation { span }.into(), self.file));
         };
-        let mut interpreter =
-            Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
-
         let location = Location::new(span, self.file);
+        let mut interpreter_errors = vec![];
+        let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
         let arguments = vec![(Value::StructDefinition(struct_id), location)];
 
         let value = interpreter
             .call_function(function, arguments, TypeBindings::new(), location)
             .map_err(|error| error.into_compilation_error_pair())?;
+        self.include_interpreter_errors(interpreter_errors);
 
         if value != Value::Unit {
             let items = value
@@ -1365,9 +1375,8 @@ impl<'context> Elaborator<'context> {
         let global = self.interner.get_global(global_id);
         let definition_id = global.definition_id;
         let location = global.location;
-
-        let mut interpreter =
-            Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
+        let mut interpreter_errors = vec![];
+        let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
 
         if let Err(error) = interpreter.evaluate_let(let_statement) {
             self.errors.push(error.into_compilation_error_pair());
@@ -1376,8 +1385,13 @@ impl<'context> Elaborator<'context> {
                 .lookup_id(definition_id, location)
                 .expect("The global should be defined since evaluate_let did not error");
 
+            self.debug_comptime(location, |interner| {
+                interner.get_global(global_id).let_statement.to_display_ast(interner).kind
+            });
+
             self.interner.get_global_mut(global_id).value = Some(value);
         }
+        self.include_interpreter_errors(interpreter_errors);
     }
 
     fn define_function_metas(
@@ -1473,6 +1487,10 @@ impl<'context> Elaborator<'context> {
         }
     }
 
+    fn include_interpreter_errors(&mut self, errors: Vec<InterpreterError>) {
+        self.errors.extend(errors.into_iter().map(InterpreterError::into_compilation_error_pair));
+    }
+
     /// True if we're currently within a `comptime` block, function, or global
     fn in_comptime_context(&self) -> bool {
         // The first context is the global context, followed by the function-specific context.
@@ -1623,4 +1641,31 @@ impl<'context> Elaborator<'context> {
             }
         }
     }
+
+    fn setup_interpreter<'a>(
+        &'a mut self,
+        interpreter_errors: &'a mut Vec<InterpreterError>,
+    ) -> Interpreter {
+        Interpreter::new(
+            self.interner,
+            &mut self.comptime_scopes,
+            self.crate_id,
+            self.debug_comptime_in_file,
+            interpreter_errors,
+        )
+    }
+
+    fn debug_comptime<T: Display, F: FnMut(&mut NodeInterner) -> T>(
+        &mut self,
+        location: Location,
+        mut expr_f: F,
+    ) {
+        if Some(location.file) == self.debug_comptime_in_file {
+            let displayed_expr = expr_f(self.interner);
+            self.errors.push((
+                InterpreterError::debug_evaluate_comptime(displayed_expr, location).into(),
+                location.file,
+            ));
+        }
+    }
 }
diff --git a/compiler/noirc_frontend/src/elaborator/patterns.rs b/compiler/noirc_frontend/src/elaborator/patterns.rs
index b1c9b1b37cc..48812005d75 100644
--- a/compiler/noirc_frontend/src/elaborator/patterns.rs
+++ b/compiler/noirc_frontend/src/elaborator/patterns.rs
@@ -456,9 +456,16 @@ impl<'context> Elaborator<'context> {
         // Comptime variables must be replaced with their values
         if let Some(definition) = self.interner.try_definition(definition_id) {
             if definition.comptime && !self.in_comptime_context() {
-                let mut interpreter =
-                    Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
+                let mut interpreter_errors = vec![];
+                let mut interpreter = Interpreter::new(
+                    self.interner,
+                    &mut self.comptime_scopes,
+                    self.crate_id,
+                    self.debug_comptime_in_file,
+                    &mut interpreter_errors,
+                );
                 let value = interpreter.evaluate(id);
+                self.include_interpreter_errors(interpreter_errors);
                 return self.inline_comptime_value(value, span);
             }
         }
diff --git a/compiler/noirc_frontend/src/elaborator/statements.rs b/compiler/noirc_frontend/src/elaborator/statements.rs
index 1fc92ad28ba..93e0806aec8 100644
--- a/compiler/noirc_frontend/src/elaborator/statements.rs
+++ b/compiler/noirc_frontend/src/elaborator/statements.rs
@@ -3,7 +3,6 @@ use noirc_errors::{Location, Span};
 use crate::{
     ast::{AssignStatement, ConstrainStatement, LValue},
     hir::{
-        comptime::Interpreter,
         resolution::errors::ResolverError,
         type_check::{Source, TypeCheckError},
     },
@@ -444,11 +443,15 @@ impl<'context> Elaborator<'context> {
         let span = statement.span;
         let (hir_statement, _typ) = self.elaborate_statement(statement);
         self.check_and_pop_function_context();
-
-        let mut interpreter =
-            Interpreter::new(self.interner, &mut self.comptime_scopes, self.crate_id);
+        let mut interpreter_errors = vec![];
+        let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
         let value = interpreter.evaluate_statement(hir_statement);
         let (expr, typ) = self.inline_comptime_value(value, span);
+        self.include_interpreter_errors(interpreter_errors);
+
+        let location = self.interner.id_location(hir_statement);
+        self.debug_comptime(location, |interner| expr.to_display_ast(interner).kind);
+
         (HirStatement::Expression(expr), typ)
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/errors.rs b/compiler/noirc_frontend/src/hir/comptime/errors.rs
index 25ff50085fe..0472b0040e5 100644
--- a/compiler/noirc_frontend/src/hir/comptime/errors.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/errors.rs
@@ -1,3 +1,4 @@
+use std::fmt::Display;
 use std::rc::Rc;
 
 use crate::{
@@ -45,6 +46,7 @@ pub enum InterpreterError {
     NonStructInConstructor { typ: Type, location: Location },
     CannotInlineMacro { value: Value, location: Location },
     UnquoteFoundDuringEvaluation { location: Location },
+    DebugEvaluateComptime { diagnostic: CustomDiagnostic, location: Location },
     FailedToParseMacro { error: ParserError, tokens: Rc<Tokens>, rule: &'static str, file: FileId },
     UnsupportedTopLevelItemUnquote { item: String, location: Location },
     NonComptimeFnCallInSameCrate { function: String, location: Location },
@@ -117,7 +119,8 @@ impl InterpreterError {
             | InterpreterError::NoImpl { location, .. }
             | InterpreterError::ImplMethodTypeMismatch { location, .. }
             | InterpreterError::BreakNotInLoop { location, .. }
-            | InterpreterError::ContinueNotInLoop { location, .. } => *location,
+            | InterpreterError::DebugEvaluateComptime { location, .. } => *location,
+            InterpreterError::ContinueNotInLoop { location, .. } => *location,
             InterpreterError::FailedToParseMacro { error, file, .. } => {
                 Location::new(error.span(), *file)
             }
@@ -129,6 +132,20 @@ impl InterpreterError {
             }
         }
     }
+
+    pub(crate) fn debug_evaluate_comptime(expr: impl Display, location: Location) -> Self {
+        let mut formatted_result = format!("{}", expr);
+        // if multi-line, display on a separate line from the message
+        if formatted_result.contains('\n') {
+            formatted_result.insert(0, '\n');
+        }
+        let diagnostic = CustomDiagnostic::simple_info(
+            "`comptime` expression ran:".to_string(),
+            format!("After evaluation: {}", formatted_result),
+            location.span,
+        );
+        InterpreterError::DebugEvaluateComptime { diagnostic, location }
+    }
 }
 
 impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
@@ -291,6 +308,7 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let secondary = "This is a bug".into();
                 CustomDiagnostic::simple_error(msg, secondary, location.span)
             }
+            InterpreterError::DebugEvaluateComptime { diagnostic, .. } => diagnostic.clone(),
             InterpreterError::FailedToParseMacro { error, tokens, rule, file: _ } => {
                 let message = format!("Failed to parse macro's token stream into {rule}");
                 let tokens = vecmap(&tokens.0, ToString::to_string).join(" ");
diff --git a/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
new file mode 100644
index 00000000000..22763c9cb64
--- /dev/null
+++ b/compiler/noirc_frontend/src/hir/comptime/hir_to_display_ast.rs
@@ -0,0 +1,428 @@
+use iter_extended::vecmap;
+use noirc_errors::{Span, Spanned};
+
+use crate::ast::{
+    ArrayLiteral, AssignStatement, BlockExpression, CallExpression, CastExpression, ConstrainKind,
+    ConstructorExpression, ExpressionKind, ForLoopStatement, ForRange, Ident, IfExpression,
+    IndexExpression, InfixExpression, LValue, Lambda, LetStatement, Literal,
+    MemberAccessExpression, MethodCallExpression, Path, Pattern, PrefixExpression, UnresolvedType,
+    UnresolvedTypeData, UnresolvedTypeExpression,
+};
+use crate::ast::{ConstrainStatement, Expression, Statement, StatementKind};
+use crate::hir_def::expr::{HirArrayLiteral, HirBlockExpression, HirExpression, HirIdent};
+use crate::hir_def::stmt::{HirLValue, HirPattern, HirStatement};
+use crate::hir_def::types::{Type, TypeBinding, TypeVariableKind};
+use crate::macros_api::HirLiteral;
+use crate::node_interner::{ExprId, NodeInterner, StmtId};
+
+// TODO:
+// - Full path for idents & types
+// - Assert/AssertEq information lost
+// - The type name span is lost in constructor patterns & expressions
+// - All type spans are lost
+// - Type::TypeVariable has no equivalent in the Ast
+
+impl HirStatement {
+    pub fn to_display_ast(&self, interner: &NodeInterner, span: Span) -> Statement {
+        let kind = match self {
+            HirStatement::Let(let_stmt) => {
+                let pattern = let_stmt.pattern.to_display_ast(interner);
+                let r#type = interner.id_type(let_stmt.expression).to_display_ast();
+                let expression = let_stmt.expression.to_display_ast(interner);
+                StatementKind::Let(LetStatement {
+                    pattern,
+                    r#type,
+                    expression,
+                    comptime: false,
+                    attributes: Vec::new(),
+                })
+            }
+            HirStatement::Constrain(constrain) => {
+                let expr = constrain.0.to_display_ast(interner);
+                let message = constrain.2.map(|message| message.to_display_ast(interner));
+
+                // TODO: Find difference in usage between Assert & AssertEq
+                StatementKind::Constrain(ConstrainStatement(expr, message, ConstrainKind::Assert))
+            }
+            HirStatement::Assign(assign) => StatementKind::Assign(AssignStatement {
+                lvalue: assign.lvalue.to_display_ast(interner),
+                expression: assign.expression.to_display_ast(interner),
+            }),
+            HirStatement::For(for_stmt) => StatementKind::For(ForLoopStatement {
+                identifier: for_stmt.identifier.to_display_ast(interner),
+                range: ForRange::Range(
+                    for_stmt.start_range.to_display_ast(interner),
+                    for_stmt.end_range.to_display_ast(interner),
+                ),
+                block: for_stmt.block.to_display_ast(interner),
+                span,
+            }),
+            HirStatement::Break => StatementKind::Break,
+            HirStatement::Continue => StatementKind::Continue,
+            HirStatement::Expression(expr) => {
+                StatementKind::Expression(expr.to_display_ast(interner))
+            }
+            HirStatement::Semi(expr) => StatementKind::Semi(expr.to_display_ast(interner)),
+            HirStatement::Error => StatementKind::Error,
+            HirStatement::Comptime(statement) => {
+                StatementKind::Comptime(Box::new(statement.to_display_ast(interner)))
+            }
+        };
+
+        Statement { kind, span }
+    }
+}
+
+impl StmtId {
+    /// Convert to AST for display (some details lost)
+    pub fn to_display_ast(self, interner: &NodeInterner) -> Statement {
+        let statement = interner.statement(&self);
+        let span = interner.statement_span(self);
+
+        statement.to_display_ast(interner, span)
+    }
+}
+
+impl HirExpression {
+    /// Convert to AST for display (some details lost)
+    pub fn to_display_ast(&self, interner: &NodeInterner, span: Span) -> Expression {
+        let kind = match self {
+            HirExpression::Ident(ident, generics) => {
+                let path = Path::from_ident(ident.to_display_ast(interner));
+                ExpressionKind::Variable(
+                    path,
+                    generics.as_ref().map(|option| {
+                        option.iter().map(|generic| generic.to_display_ast()).collect()
+                    }),
+                )
+            }
+            HirExpression::Literal(HirLiteral::Array(array)) => {
+                let array = array.to_display_ast(interner, span);
+                ExpressionKind::Literal(Literal::Array(array))
+            }
+            HirExpression::Literal(HirLiteral::Slice(array)) => {
+                let array = array.to_display_ast(interner, span);
+                ExpressionKind::Literal(Literal::Slice(array))
+            }
+            HirExpression::Literal(HirLiteral::Bool(value)) => {
+                ExpressionKind::Literal(Literal::Bool(*value))
+            }
+            HirExpression::Literal(HirLiteral::Integer(value, sign)) => {
+                ExpressionKind::Literal(Literal::Integer(*value, *sign))
+            }
+            HirExpression::Literal(HirLiteral::Str(string)) => {
+                ExpressionKind::Literal(Literal::Str(string.clone()))
+            }
+            HirExpression::Literal(HirLiteral::FmtStr(string, _exprs)) => {
+                // TODO: Is throwing away the exprs here valid?
+                ExpressionKind::Literal(Literal::FmtStr(string.clone()))
+            }
+            HirExpression::Literal(HirLiteral::Unit) => ExpressionKind::Literal(Literal::Unit),
+            HirExpression::Block(expr) => ExpressionKind::Block(expr.to_display_ast(interner)),
+            HirExpression::Prefix(prefix) => ExpressionKind::Prefix(Box::new(PrefixExpression {
+                operator: prefix.operator,
+                rhs: prefix.rhs.to_display_ast(interner),
+            })),
+            HirExpression::Infix(infix) => ExpressionKind::Infix(Box::new(InfixExpression {
+                lhs: infix.lhs.to_display_ast(interner),
+                operator: Spanned::from(infix.operator.location.span, infix.operator.kind),
+                rhs: infix.rhs.to_display_ast(interner),
+            })),
+            HirExpression::Index(index) => ExpressionKind::Index(Box::new(IndexExpression {
+                collection: index.collection.to_display_ast(interner),
+                index: index.index.to_display_ast(interner),
+            })),
+            HirExpression::Constructor(constructor) => {
+                let type_name = constructor.r#type.borrow().name.to_string();
+                let type_name = Path::from_single(type_name, span);
+                let fields = vecmap(constructor.fields.clone(), |(name, expr): (Ident, ExprId)| {
+                    (name, expr.to_display_ast(interner))
+                });
+                let struct_type = None;
+
+                ExpressionKind::Constructor(Box::new(ConstructorExpression {
+                    type_name,
+                    fields,
+                    struct_type,
+                }))
+            }
+            HirExpression::MemberAccess(access) => {
+                ExpressionKind::MemberAccess(Box::new(MemberAccessExpression {
+                    lhs: access.lhs.to_display_ast(interner),
+                    rhs: access.rhs.clone(),
+                }))
+            }
+            HirExpression::Call(call) => {
+                let func = Box::new(call.func.to_display_ast(interner));
+                let arguments = vecmap(call.arguments.clone(), |arg| arg.to_display_ast(interner));
+                let is_macro_call = false;
+                ExpressionKind::Call(Box::new(CallExpression { func, arguments, is_macro_call }))
+            }
+            HirExpression::MethodCall(method_call) => {
+                ExpressionKind::MethodCall(Box::new(MethodCallExpression {
+                    object: method_call.object.to_display_ast(interner),
+                    method_name: method_call.method.clone(),
+                    arguments: vecmap(method_call.arguments.clone(), |arg| {
+                        arg.to_display_ast(interner)
+                    }),
+                    generics: method_call.generics.clone().map(|option| {
+                        option.iter().map(|generic| generic.to_display_ast()).collect()
+                    }),
+                    is_macro_call: false,
+                }))
+            }
+            HirExpression::Cast(cast) => {
+                let lhs = cast.lhs.to_display_ast(interner);
+                let r#type = cast.r#type.to_display_ast();
+                ExpressionKind::Cast(Box::new(CastExpression { lhs, r#type }))
+            }
+            HirExpression::If(if_expr) => ExpressionKind::If(Box::new(IfExpression {
+                condition: if_expr.condition.to_display_ast(interner),
+                consequence: if_expr.consequence.to_display_ast(interner),
+                alternative: if_expr.alternative.map(|expr| expr.to_display_ast(interner)),
+            })),
+            HirExpression::Tuple(fields) => {
+                ExpressionKind::Tuple(vecmap(fields, |field| field.to_display_ast(interner)))
+            }
+            HirExpression::Lambda(lambda) => {
+                let parameters = vecmap(lambda.parameters.clone(), |(pattern, typ)| {
+                    (pattern.to_display_ast(interner), typ.to_display_ast())
+                });
+                let return_type = lambda.return_type.to_display_ast();
+                let body = lambda.body.to_display_ast(interner);
+                ExpressionKind::Lambda(Box::new(Lambda { parameters, return_type, body }))
+            }
+            HirExpression::Error => ExpressionKind::Error,
+            HirExpression::Comptime(block) => {
+                ExpressionKind::Comptime(block.to_display_ast(interner), span)
+            }
+            HirExpression::Quote(block) => ExpressionKind::Quote(block.clone()),
+
+            // A macro was evaluated here: return the quoted result
+            HirExpression::Unquote(block) => ExpressionKind::Quote(block.clone()),
+        };
+
+        Expression::new(kind, span)
+    }
+}
+
+impl ExprId {
+    /// Convert to AST for display (some details lost)
+    pub fn to_display_ast(self, interner: &NodeInterner) -> Expression {
+        let expression = interner.expression(&self);
+        // TODO: empty 0 span
+        let span = interner.try_expr_span(&self).unwrap_or_else(|| Span::empty(0));
+        expression.to_display_ast(interner, span)
+    }
+}
+
+impl HirPattern {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self, interner: &NodeInterner) -> Pattern {
+        match self {
+            HirPattern::Identifier(ident) => Pattern::Identifier(ident.to_display_ast(interner)),
+            HirPattern::Mutable(pattern, location) => {
+                let pattern = Box::new(pattern.to_display_ast(interner));
+                Pattern::Mutable(pattern, location.span, false)
+            }
+            HirPattern::Tuple(patterns, location) => {
+                let patterns = vecmap(patterns, |pattern| pattern.to_display_ast(interner));
+                Pattern::Tuple(patterns, location.span)
+            }
+            HirPattern::Struct(typ, patterns, location) => {
+                let patterns = vecmap(patterns, |(name, pattern)| {
+                    (name.clone(), pattern.to_display_ast(interner))
+                });
+                let name = match typ.follow_bindings() {
+                    Type::Struct(struct_def, _) => {
+                        let struct_def = struct_def.borrow();
+                        struct_def.name.0.contents.clone()
+                    }
+                    // This pass shouldn't error so if the type isn't a struct we just get a string
+                    // representation of any other type and use that. We're relying on name
+                    // resolution to fail later when this Ast is re-converted to Hir.
+                    other => other.to_string(),
+                };
+                // The name span is lost here
+                let path = Path::from_single(name, location.span);
+                Pattern::Struct(path, patterns, location.span)
+            }
+        }
+    }
+}
+
+impl HirIdent {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self, interner: &NodeInterner) -> Ident {
+        let name = interner.definition_name(self.id).to_owned();
+        Ident(Spanned::from(self.location.span, name))
+    }
+}
+
+impl Type {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self) -> UnresolvedType {
+        let typ = match self {
+            Type::FieldElement => UnresolvedTypeData::FieldElement,
+            Type::Array(length, element) => {
+                let length = length.to_type_expression();
+                let element = Box::new(element.to_display_ast());
+                UnresolvedTypeData::Array(length, element)
+            }
+            Type::Slice(element) => {
+                let element = Box::new(element.to_display_ast());
+                UnresolvedTypeData::Slice(element)
+            }
+            Type::Integer(sign, bit_size) => UnresolvedTypeData::Integer(*sign, *bit_size),
+            Type::Bool => UnresolvedTypeData::Bool,
+            Type::String(length) => {
+                let length = length.to_type_expression();
+                UnresolvedTypeData::String(length)
+            }
+            Type::FmtString(length, element) => {
+                let length = length.to_type_expression();
+                let element = Box::new(element.to_display_ast());
+                UnresolvedTypeData::FormatString(length, element)
+            }
+            Type::Unit => UnresolvedTypeData::Unit,
+            Type::Tuple(fields) => {
+                let fields = vecmap(fields, |field| field.to_display_ast());
+                UnresolvedTypeData::Tuple(fields)
+            }
+            Type::Struct(def, generics) => {
+                let struct_def = def.borrow();
+                let generics = vecmap(generics, |generic| generic.to_display_ast());
+                let name = Path::from_ident(struct_def.name.clone());
+                UnresolvedTypeData::Named(name, generics, false)
+            }
+            Type::Alias(type_def, generics) => {
+                // Keep the alias name instead of expanding this in case the
+                // alias' definition was changed
+                let type_def = type_def.borrow();
+                let generics = vecmap(generics, |generic| generic.to_display_ast());
+                let name = Path::from_ident(type_def.name.clone());
+                UnresolvedTypeData::Named(name, generics, false)
+            }
+            Type::TypeVariable(binding, kind) => {
+                match &*binding.borrow() {
+                    TypeBinding::Bound(typ) => return typ.to_display_ast(),
+                    TypeBinding::Unbound(id) => {
+                        let expression = match kind {
+                            // TODO: fix span or make Option<Span>
+                            TypeVariableKind::Constant(value) => {
+                                UnresolvedTypeExpression::Constant(*value, Span::empty(0))
+                            }
+                            other_kind => {
+                                let name = format!("var_{:?}_{}", other_kind, id);
+
+                                // TODO: fix span or make Option<Span>
+                                let path = Path::from_single(name, Span::empty(0));
+                                UnresolvedTypeExpression::Variable(path)
+                            }
+                        };
+
+                        UnresolvedTypeData::Expression(expression)
+                    }
+                }
+            }
+            Type::TraitAsType(_, name, generics) => {
+                let generics = vecmap(generics, |generic| generic.to_display_ast());
+                let name = Path::from_single(name.as_ref().clone(), Span::default());
+                UnresolvedTypeData::TraitAsType(name, generics)
+            }
+            Type::NamedGeneric(_var, name, _kind) => {
+                let name = Path::from_single(name.as_ref().clone(), Span::default());
+                UnresolvedTypeData::TraitAsType(name, Vec::new())
+            }
+            Type::Function(args, ret, env) => {
+                let args = vecmap(args, |arg| arg.to_display_ast());
+                let ret = Box::new(ret.to_display_ast());
+                let env = Box::new(env.to_display_ast());
+                UnresolvedTypeData::Function(args, ret, env)
+            }
+            Type::MutableReference(element) => {
+                let element = Box::new(element.to_display_ast());
+                UnresolvedTypeData::MutableReference(element)
+            }
+            // Type::Forall is only for generic functions which don't store a type
+            // in their Ast so they don't need to call to_display_ast for their Forall type.
+            // Since there is no UnresolvedTypeData equivalent for Type::Forall, we use
+            // this to ignore this case since it shouldn't be needed anyway.
+            Type::Forall(_, typ) => return typ.to_display_ast(),
+            Type::Constant(_) => panic!("Type::Constant where a type was expected: {self:?}"),
+            Type::Quoted(quoted_type) => UnresolvedTypeData::Quoted(*quoted_type),
+            Type::Error => UnresolvedTypeData::Error,
+        };
+
+        UnresolvedType { typ, span: None }
+    }
+
+    /// Convert to AST for display (some details lost)
+    fn to_type_expression(&self) -> UnresolvedTypeExpression {
+        let span = Span::default();
+
+        match self.follow_bindings() {
+            Type::Constant(length) => UnresolvedTypeExpression::Constant(length, span),
+            Type::NamedGeneric(_var, name, _kind) => {
+                let path = Path::from_single(name.as_ref().clone(), span);
+                UnresolvedTypeExpression::Variable(path)
+            }
+            // TODO: This should be turned into a proper error.
+            other => panic!("Cannot represent {other:?} as type expression"),
+        }
+    }
+}
+
+impl HirLValue {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self, interner: &NodeInterner) -> LValue {
+        match self {
+            HirLValue::Ident(ident, _) => LValue::Ident(ident.to_display_ast(interner)),
+            HirLValue::MemberAccess { object, field_name, field_index: _, typ: _, location } => {
+                let object = Box::new(object.to_display_ast(interner));
+                LValue::MemberAccess { object, field_name: field_name.clone(), span: location.span }
+            }
+            HirLValue::Index { array, index, typ: _, location } => {
+                let array = Box::new(array.to_display_ast(interner));
+                let index = index.to_display_ast(interner);
+                LValue::Index { array, index, span: location.span }
+            }
+            HirLValue::Dereference { lvalue, element_type: _, location } => {
+                let lvalue = Box::new(lvalue.to_display_ast(interner));
+                LValue::Dereference(lvalue, location.span)
+            }
+        }
+    }
+}
+
+impl HirArrayLiteral {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self, interner: &NodeInterner, span: Span) -> ArrayLiteral {
+        match self {
+            HirArrayLiteral::Standard(elements) => {
+                ArrayLiteral::Standard(vecmap(elements, |element| element.to_display_ast(interner)))
+            }
+            HirArrayLiteral::Repeated { repeated_element, length } => {
+                let repeated_element = Box::new(repeated_element.to_display_ast(interner));
+                let length = match length {
+                    Type::Constant(length) => {
+                        let literal = Literal::Integer((*length as u128).into(), false);
+                        let kind = ExpressionKind::Literal(literal);
+                        Box::new(Expression::new(kind, span))
+                    }
+                    other => panic!("Cannot convert non-constant type for repeated array literal from Hir -> Ast: {other:?}"),
+                };
+                ArrayLiteral::Repeated { repeated_element, length }
+            }
+        }
+    }
+}
+
+impl HirBlockExpression {
+    /// Convert to AST for display (some details lost)
+    fn to_display_ast(&self, interner: &NodeInterner) -> BlockExpression {
+        let statements =
+            vecmap(self.statements.clone(), |statement| statement.to_display_ast(interner));
+        BlockExpression { statements }
+    }
+}
diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 605a35780ed..02714f77605 100644
--- a/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -1,6 +1,7 @@
 use std::{collections::hash_map::Entry, rc::Rc};
 
 use acvm::{acir::AcirField, FieldElement};
+use fm::FileId;
 use im::Vector;
 use iter_extended::try_vecmap;
 use noirc_errors::Location;
@@ -19,7 +20,7 @@ use crate::{
     hir_def::{
         expr::{
             HirArrayLiteral, HirBlockExpression, HirCallExpression, HirCastExpression,
-            HirConstructorExpression, HirIdent, HirIfExpression, HirIndexExpression,
+            HirConstructorExpression, HirExpression, HirIdent, HirIfExpression, HirIndexExpression,
             HirInfixExpression, HirLambda, HirMemberAccess, HirMethodCallExpression,
             HirPrefixExpression,
         },
@@ -28,7 +29,7 @@ use crate::{
             HirPattern,
         },
     },
-    macros_api::{HirExpression, HirLiteral, HirStatement, NodeInterner},
+    macros_api::{HirLiteral, HirStatement, NodeInterner},
     node_interner::{DefinitionId, DefinitionKind, ExprId, FuncId, StmtId},
     Shared, Type, TypeBinding, TypeBindings, TypeVariableKind,
 };
@@ -51,6 +52,10 @@ pub struct Interpreter<'interner> {
 
     crate_id: CrateId,
 
+    /// The scope of --debug-comptime, or None if unset
+    pub(super) debug_comptime_in_file: Option<FileId>,
+    pub(super) debug_comptime_evaluations: &'interner mut Vec<InterpreterError>,
+
     in_loop: bool,
 }
 
@@ -60,8 +65,17 @@ impl<'a> Interpreter<'a> {
         interner: &'a mut NodeInterner,
         scopes: &'a mut Vec<HashMap<DefinitionId, Value>>,
         crate_id: CrateId,
+        debug_comptime_in_file: Option<FileId>,
+        debug_comptime_evaluations: &'a mut Vec<InterpreterError>,
     ) -> Self {
-        Self { interner, scopes, crate_id, in_loop: false }
+        Self {
+            interner,
+            scopes,
+            crate_id,
+            debug_comptime_in_file,
+            debug_comptime_evaluations,
+            in_loop: false,
+        }
     }
 
     pub(crate) fn call_function(
diff --git a/compiler/noirc_frontend/src/hir/comptime/mod.rs b/compiler/noirc_frontend/src/hir/comptime/mod.rs
index ab984d2f2be..3cc7b5f7e98 100644
--- a/compiler/noirc_frontend/src/hir/comptime/mod.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/mod.rs
@@ -1,4 +1,5 @@
 mod errors;
+mod hir_to_display_ast;
 mod interpreter;
 mod scan;
 mod tests;
diff --git a/compiler/noirc_frontend/src/hir/comptime/scan.rs b/compiler/noirc_frontend/src/hir/comptime/scan.rs
index 770c523bd7f..f9cc54ef9e4 100644
--- a/compiler/noirc_frontend/src/hir/comptime/scan.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/scan.rs
@@ -29,6 +29,8 @@ use super::{
     Value,
 };
 
+use noirc_errors::Location;
+
 #[allow(dead_code)]
 impl<'interner> Interpreter<'interner> {
     /// Scan through a function, evaluating any Comptime nodes found.
@@ -80,9 +82,10 @@ impl<'interner> Interpreter<'interner> {
             HirExpression::Lambda(lambda) => self.scan_lambda(lambda),
             HirExpression::Comptime(block) => {
                 let location = self.interner.expr_location(&expr);
-                let new_expr =
+                let new_expr_id =
                     self.evaluate_block(block)?.into_hir_expression(self.interner, location)?;
-                let new_expr = self.interner.expression(&new_expr);
+                let new_expr = self.interner.expression(&new_expr_id);
+                self.debug_comptime(new_expr_id, location);
                 self.interner.replace_expr(&expr, new_expr);
                 Ok(())
             }
@@ -118,7 +121,9 @@ impl<'interner> Interpreter<'interner> {
                 if let Ok(value) = self.evaluate_ident(ident, id) {
                     // TODO(#4922): Inlining closures is currently unimplemented
                     if !matches!(value, Value::Closure(..)) {
-                        self.inline_expression(value, id)?;
+                        let new_expr = self.inline_expression(value, id)?;
+                        let location = self.interner.id_location(id);
+                        self.debug_comptime(new_expr, location);
                     }
                 }
                 Ok(())
@@ -231,6 +236,7 @@ impl<'interner> Interpreter<'interner> {
                 let new_expr = self
                     .evaluate_comptime(comptime)?
                     .into_hir_expression(self.interner, location)?;
+                self.debug_comptime(new_expr, location);
                 self.interner.replace_statement(statement, HirStatement::Expression(new_expr));
                 Ok(())
             }
@@ -247,11 +253,19 @@ impl<'interner> Interpreter<'interner> {
         Ok(())
     }
 
-    fn inline_expression(&mut self, value: Value, expr: ExprId) -> IResult<()> {
+    fn inline_expression(&mut self, value: Value, expr: ExprId) -> IResult<ExprId> {
         let location = self.interner.expr_location(&expr);
-        let new_expr = value.into_hir_expression(self.interner, location)?;
-        let new_expr = self.interner.expression(&new_expr);
+        let new_expr_id = value.into_hir_expression(self.interner, location)?;
+        let new_expr = self.interner.expression(&new_expr_id);
         self.interner.replace_expr(&expr, new_expr);
-        Ok(())
+        Ok(new_expr_id)
+    }
+
+    fn debug_comptime(&mut self, expr: ExprId, location: Location) {
+        if Some(location.file) == self.debug_comptime_in_file {
+            let expr = expr.to_display_ast(self.interner);
+            self.debug_comptime_evaluations
+                .push(InterpreterError::debug_evaluate_comptime(expr, location));
+        }
     }
 }
diff --git a/compiler/noirc_frontend/src/hir/comptime/tests.rs b/compiler/noirc_frontend/src/hir/comptime/tests.rs
index 870f2bc458a..e8e05506c94 100644
--- a/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -13,7 +13,15 @@ use crate::hir::type_check::test::type_check_src_code;
 fn interpret_helper(src: &str, func_namespace: Vec<String>) -> Result<Value, InterpreterError> {
     let (mut interner, main_id) = type_check_src_code(src, func_namespace);
     let mut scopes = vec![HashMap::default()];
-    let mut interpreter = Interpreter::new(&mut interner, &mut scopes, CrateId::Root(0));
+    let no_debug_evaluate_comptime = None;
+    let mut interpreter_errors = vec![];
+    let mut interpreter = Interpreter::new(
+        &mut interner,
+        &mut scopes,
+        CrateId::Root(0),
+        no_debug_evaluate_comptime,
+        &mut interpreter_errors,
+    );
 
     let no_location = Location::dummy();
     interpreter.call_function(main_id, Vec::new(), HashMap::new(), no_location)
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 43ab6224ea7..b474ccff0cc 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -29,12 +29,14 @@ use crate::ast::{
 };
 
 use crate::parser::{ParserError, SortedModule};
+use noirc_errors::{CustomDiagnostic, Location, Span};
+
 use fm::FileId;
 use iter_extended::vecmap;
-use noirc_errors::{CustomDiagnostic, Location, Span};
 use rustc_hash::FxHashMap as HashMap;
 use std::collections::BTreeMap;
-
+use std::fmt::Write;
+use std::path::PathBuf;
 use std::vec;
 
 #[derive(Default)]
@@ -42,6 +44,7 @@ pub struct ResolvedModule {
     pub globals: Vec<(FileId, GlobalId)>,
     pub functions: Vec<(FileId, FuncId)>,
     pub trait_impl_functions: Vec<(FileId, FuncId)>,
+    pub debug_comptime_in_file: Option<FileId>,
 
     pub errors: Vec<(CompilationError, FileId)>,
 }
@@ -195,6 +198,7 @@ pub enum CompilationError {
     ResolverError(ResolverError),
     TypeError(TypeCheckError),
     InterpreterError(InterpreterError),
+    DebugComptimeScopeNotFound(Vec<PathBuf>),
 }
 
 impl CompilationError {
@@ -212,6 +216,16 @@ impl<'a> From<&'a CompilationError> for CustomDiagnostic {
             CompilationError::ResolverError(error) => error.into(),
             CompilationError::TypeError(error) => error.into(),
             CompilationError::InterpreterError(error) => error.into(),
+            CompilationError::DebugComptimeScopeNotFound(error) => {
+                let msg = "multiple files found matching --debug-comptime path".into();
+                let secondary = error.iter().fold(String::new(), |mut output, path| {
+                    let _ = writeln!(output, "    {}", path.display());
+                    output
+                });
+                // NOTE: this span is empty as it is not expected to be displayed
+                let dummy_span = Span::default();
+                CustomDiagnostic::simple_error(msg, secondary, dummy_span)
+            }
         }
     }
 }
@@ -271,6 +285,7 @@ impl DefCollector {
         ast: SortedModule,
         root_file_id: FileId,
         use_legacy: bool,
+        debug_comptime_in_file: Option<&str>,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
@@ -288,6 +303,7 @@ impl DefCollector {
                 dep.crate_id,
                 context,
                 use_legacy,
+                debug_comptime_in_file,
                 macro_processors,
             ));
 
@@ -396,13 +412,31 @@ impl DefCollector {
             }
         }
 
+        let handle_missing_file = |err| {
+            errors.push((CompilationError::DebugComptimeScopeNotFound(err), root_file_id));
+            None
+        };
+        let debug_comptime_in_file: Option<FileId> =
+            debug_comptime_in_file.and_then(|debug_comptime_in_file| {
+                context
+                    .file_manager
+                    .find_by_path_suffix(debug_comptime_in_file)
+                    .unwrap_or_else(handle_missing_file)
+            });
+
         if !use_legacy {
-            let mut more_errors = Elaborator::elaborate(context, crate_id, def_collector.items);
+            let mut more_errors = Elaborator::elaborate(
+                context,
+                crate_id,
+                def_collector.items,
+                debug_comptime_in_file,
+            );
             errors.append(&mut more_errors);
             return errors;
         }
 
-        let mut resolved_module = ResolvedModule { errors, ..Default::default() };
+        let mut resolved_module =
+            ResolvedModule { errors, debug_comptime_in_file, ..Default::default() };
 
         // We must first resolve and intern the globals before we can resolve any stmts inside each function.
         // Each function uses its own resolver with a newly created ScopeForest, and must be resolved again to be within a function's scope
@@ -621,7 +655,14 @@ impl ResolvedModule {
     fn evaluate_comptime(&mut self, interner: &mut NodeInterner, crate_id: CrateId) {
         if self.count_errors() == 0 {
             let mut scopes = vec![HashMap::default()];
-            let mut interpreter = Interpreter::new(interner, &mut scopes, crate_id);
+            let mut interpreter_errors = vec![];
+            let mut interpreter = Interpreter::new(
+                interner,
+                &mut scopes,
+                crate_id,
+                self.debug_comptime_in_file,
+                &mut interpreter_errors,
+            );
 
             for (_file, global) in &self.globals {
                 if let Err(error) = interpreter.scan_global(*global) {
@@ -636,6 +677,9 @@ impl ResolvedModule {
                     self.errors.push(error.into_compilation_error_pair());
                 }
             }
+            self.errors.extend(
+                interpreter_errors.into_iter().map(InterpreterError::into_compilation_error_pair),
+            );
         }
     }
 
diff --git a/compiler/noirc_frontend/src/hir/def_map/mod.rs b/compiler/noirc_frontend/src/hir/def_map/mod.rs
index 59205f74d89..43d1548dc29 100644
--- a/compiler/noirc_frontend/src/hir/def_map/mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_map/mod.rs
@@ -74,6 +74,7 @@ impl CrateDefMap {
         crate_id: CrateId,
         context: &mut Context,
         use_legacy: bool,
+        debug_comptime_in_file: Option<&str>,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         // Check if this Crate has already been compiled
@@ -123,6 +124,7 @@ impl CrateDefMap {
             ast,
             root_file_id,
             use_legacy,
+            debug_comptime_in_file,
             macro_processors,
         ));
 
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 588b56afa1a..3296addba8e 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::Hash;
+use std::marker::Copy;
 use std::ops::Deref;
 
 use fm::FileId;
@@ -195,7 +196,7 @@ pub struct NodeInterner {
     /// Edges are directed from reference nodes to referenced nodes.
     /// For example:
     ///
-    /// ```
+    /// ```text
     /// let foo = 3;
     /// //  referenced
     /// //   ^
@@ -1071,6 +1072,10 @@ impl NodeInterner {
         self.id_location(expr_id).span
     }
 
+    pub fn try_expr_span(&self, expr_id: &ExprId) -> Option<Span> {
+        self.try_id_location(expr_id).map(|location| location.span)
+    }
+
     pub fn expr_location(&self, expr_id: &ExprId) -> Location {
         self.id_location(expr_id)
     }
@@ -1175,8 +1180,14 @@ impl NodeInterner {
     }
 
     /// Returns the span of an item stored in the Interner
-    pub fn id_location(&self, index: impl Into<Index>) -> Location {
-        self.id_to_location.get(&index.into()).copied().unwrap()
+    pub fn id_location(&self, index: impl Into<Index> + Copy) -> Location {
+        self.try_id_location(index)
+            .unwrap_or_else(|| panic!("ID is missing a source location: {:?}", index.into()))
+    }
+
+    /// Returns the span of an item stored in the Interner, if present
+    pub fn try_id_location(&self, index: impl Into<Index>) -> Option<Location> {
+        self.id_to_location.get(&index.into()).copied()
     }
 
     /// Replaces the HirExpression at the given ExprId with a new HirExpression
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 70f8f785d68..8cedeeeff0d 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -86,7 +86,8 @@ pub(crate) fn get_program(
             program.clone().into_sorted(),
             root_file_id,
             use_legacy,
-            &[], // No macro processors
+            None, // No debug_comptime_in_file
+            &[],  // No macro processors
         ));
     }
     (program, context, errors)
diff --git a/tooling/lsp/src/lib.rs b/tooling/lsp/src/lib.rs
index e47dfff714a..b62f97a4918 100644
--- a/tooling/lsp/src/lib.rs
+++ b/tooling/lsp/src/lib.rs
@@ -373,7 +373,8 @@ fn prepare_package_from_source_string() {
     let mut state = LspState::new(&client, acvm::blackbox_solver::StubbedBlackBoxSolver);
 
     let (mut context, crate_id) = crate::prepare_source(source.to_string(), &mut state);
-    let _check_result = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
+    let _check_result =
+        noirc_driver::check_crate(&mut context, crate_id, false, false, false, None);
     let main_func_id = context.get_main_function(&crate_id);
     assert!(main_func_id.is_some());
 }
diff --git a/tooling/lsp/src/notifications/mod.rs b/tooling/lsp/src/notifications/mod.rs
index ed0ac13fae5..46a7b1cf866 100644
--- a/tooling/lsp/src/notifications/mod.rs
+++ b/tooling/lsp/src/notifications/mod.rs
@@ -56,7 +56,7 @@ pub(super) fn on_did_change_text_document(
     state.input_files.insert(params.text_document.uri.to_string(), text.clone());
 
     let (mut context, crate_id) = prepare_source(text, state);
-    let _ = check_crate(&mut context, crate_id, false, false, false);
+    let _ = check_crate(&mut context, crate_id, false, false, false, None);
 
     let workspace = match resolve_workspace_for_source_path(
         params.text_document.uri.to_file_path().unwrap().as_path(),
@@ -139,10 +139,11 @@ fn process_noir_document(
             let (mut context, crate_id) =
                 crate::prepare_package(&workspace_file_manager, &parsed_files, package);
 
-            let file_diagnostics = match check_crate(&mut context, crate_id, false, false, false) {
-                Ok(((), warnings)) => warnings,
-                Err(errors_and_warnings) => errors_and_warnings,
-            };
+            let file_diagnostics =
+                match check_crate(&mut context, crate_id, false, false, false, None) {
+                    Ok(((), warnings)) => warnings,
+                    Err(errors_and_warnings) => errors_and_warnings,
+                };
 
             let package_root_dir: String = package.root_dir.as_os_str().to_string_lossy().into();
 
@@ -190,6 +191,7 @@ fn process_noir_document(
                     let severity = match diagnostic.kind {
                         DiagnosticKind::Error => DiagnosticSeverity::ERROR,
                         DiagnosticKind::Warning => DiagnosticSeverity::WARNING,
+                        DiagnosticKind::Info => DiagnosticSeverity::INFORMATION,
                         DiagnosticKind::Bug => DiagnosticSeverity::WARNING,
                     };
                     Some(Diagnostic {
diff --git a/tooling/lsp/src/requests/code_lens_request.rs b/tooling/lsp/src/requests/code_lens_request.rs
index 744bddedd9d..0b8803edc6f 100644
--- a/tooling/lsp/src/requests/code_lens_request.rs
+++ b/tooling/lsp/src/requests/code_lens_request.rs
@@ -67,7 +67,7 @@ fn on_code_lens_request_inner(
     let (mut context, crate_id) = prepare_source(source_string, state);
     // We ignore the warnings and errors produced by compilation for producing code lenses
     // because we can still get the test functions even if compilation fails
-    let _ = check_crate(&mut context, crate_id, false, false, false);
+    let _ = check_crate(&mut context, crate_id, false, false, false, None);
 
     let collected_lenses =
         collect_lenses_for_package(&context, crate_id, &workspace, package, None);
diff --git a/tooling/lsp/src/requests/mod.rs b/tooling/lsp/src/requests/mod.rs
index 266b5b124ac..48299ff7459 100644
--- a/tooling/lsp/src/requests/mod.rs
+++ b/tooling/lsp/src/requests/mod.rs
@@ -294,7 +294,7 @@ where
         interner = def_interner;
     } else {
         // We ignore the warnings and errors produced by compilation while resolving the definition
-        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false);
+        let _ = noirc_driver::check_crate(&mut context, crate_id, false, false, false, None);
         interner = &context.def_interner;
     }
 
diff --git a/tooling/lsp/src/requests/test_run.rs b/tooling/lsp/src/requests/test_run.rs
index acd4f5800f3..b4b9b62d6b6 100644
--- a/tooling/lsp/src/requests/test_run.rs
+++ b/tooling/lsp/src/requests/test_run.rs
@@ -59,7 +59,7 @@ fn on_test_run_request_inner(
         Some(package) => {
             let (mut context, crate_id) =
                 crate::prepare_package(&workspace_file_manager, &parsed_files, package);
-            if check_crate(&mut context, crate_id, false, false, false).is_err() {
+            if check_crate(&mut context, crate_id, false, false, false, None).is_err() {
                 let result = NargoTestRunResult {
                     id: params.id.clone(),
                     result: "error".to_string(),
diff --git a/tooling/lsp/src/requests/tests.rs b/tooling/lsp/src/requests/tests.rs
index a2aa3ebc0bf..fb8b845df04 100644
--- a/tooling/lsp/src/requests/tests.rs
+++ b/tooling/lsp/src/requests/tests.rs
@@ -61,7 +61,7 @@ fn on_tests_request_inner(
                 crate::prepare_package(&workspace_file_manager, &parsed_files, package);
             // We ignore the warnings and errors produced by compilation for producing tests
             // because we can still get the test functions even if compilation fails
-            let _ = check_crate(&mut context, crate_id, false, false, false);
+            let _ = check_crate(&mut context, crate_id, false, false, false, None);
 
             // We don't add test headings for a package if it contains no `#[test]` functions
             get_package_tests_in_crate(&context, &crate_id, &package.name)
diff --git a/tooling/nargo_cli/src/cli/check_cmd.rs b/tooling/nargo_cli/src/cli/check_cmd.rs
index 2db3b10429a..95726492418 100644
--- a/tooling/nargo_cli/src/cli/check_cmd.rs
+++ b/tooling/nargo_cli/src/cli/check_cmd.rs
@@ -88,6 +88,7 @@ fn check_package(
         compile_options.disable_macros,
         compile_options.silence_warnings,
         compile_options.use_legacy,
+        compile_options.debug_comptime_in_file.as_deref(),
     )?;
 
     if package.is_library() || package.is_contract() {
@@ -161,8 +162,16 @@ pub(crate) fn check_crate_and_report_errors(
     disable_macros: bool,
     silence_warnings: bool,
     use_legacy: bool,
+    debug_comptime_in_file: Option<&str>,
 ) -> Result<(), CompileError> {
-    let result = check_crate(context, crate_id, deny_warnings, disable_macros, use_legacy);
+    let result = check_crate(
+        context,
+        crate_id,
+        deny_warnings,
+        disable_macros,
+        use_legacy,
+        debug_comptime_in_file,
+    );
     report_errors(result, &context.file_manager, deny_warnings, silence_warnings)
 }
 
diff --git a/tooling/nargo_cli/src/cli/export_cmd.rs b/tooling/nargo_cli/src/cli/export_cmd.rs
index ee30b29b0f0..105190c653f 100644
--- a/tooling/nargo_cli/src/cli/export_cmd.rs
+++ b/tooling/nargo_cli/src/cli/export_cmd.rs
@@ -90,6 +90,7 @@ fn compile_exported_functions(
         compile_options.disable_macros,
         compile_options.silence_warnings,
         compile_options.use_legacy,
+        compile_options.debug_comptime_in_file.as_deref(),
     )?;
 
     let exported_functions = context.get_all_exported_functions_in_crate(&crate_id);
diff --git a/tooling/nargo_cli/src/cli/test_cmd.rs b/tooling/nargo_cli/src/cli/test_cmd.rs
index de9e8dc5d7c..27c66c956d9 100644
--- a/tooling/nargo_cli/src/cli/test_cmd.rs
+++ b/tooling/nargo_cli/src/cli/test_cmd.rs
@@ -177,6 +177,7 @@ fn run_test<S: BlackBoxFunctionSolver<FieldElement> + Default>(
         compile_options.deny_warnings,
         compile_options.disable_macros,
         compile_options.use_legacy,
+        compile_options.debug_comptime_in_file.as_deref(),
     )
     .expect("Any errors should have occurred when collecting test functions");
 
@@ -244,6 +245,7 @@ fn get_tests_in_package(
         compile_options.disable_macros,
         compile_options.silence_warnings,
         compile_options.use_legacy,
+        compile_options.debug_comptime_in_file.as_deref(),
     )?;
 
     Ok(context
diff --git a/tooling/nargo_cli/tests/stdlib-tests.rs b/tooling/nargo_cli/tests/stdlib-tests.rs
index bf6614860e2..10711b6d011 100644
--- a/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -32,7 +32,7 @@ fn run_stdlib_tests() {
     let (mut context, dummy_crate_id) =
         prepare_package(&file_manager, &parsed_files, &dummy_package);
 
-    let result = check_crate(&mut context, dummy_crate_id, false, false, false);
+    let result = check_crate(&mut context, dummy_crate_id, false, false, false, None);
     report_errors(result, &context.file_manager, true, false)
         .expect("Error encountered while compiling standard library");