diff --git a/src/language/PugsParser.cpp b/src/language/PugsParser.cpp
index 9f528bfce37a5d5eabf6a0c9d60d106730b64441..bf573ac54378d1cfd08d619eb80bfbe69950a6ed 100644
--- a/src/language/PugsParser.cpp
+++ b/src/language/PugsParser.cpp
@@ -1,6 +1,7 @@
 #include <language/PugsParser.hpp>
 
 #include <language/PEGGrammar.hpp>
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNode.hpp>
@@ -31,6 +32,7 @@
 
 #include <fstream>
 #include <iostream>
+#include <memory>
 #include <sstream>
 #include <unordered_map>
 #include <variant>
@@ -53,8 +55,8 @@ parser(const std::string& filename)
 
   auto parse_and_execute = [](auto& input) {
     OperatorRepository::create();
-
-    std::unique_ptr<ASTNode> root_node = ASTBuilder::build(input);
+    ASTBacktrace::create(input);
+    std::unique_ptr<ASTNode> root_node = ASTBuilder::build(*input);
 
     ASTModulesImporter module_importer{*root_node};
     ASTNodeTypeCleaner<language::import_instruction>{*root_node};
@@ -94,8 +96,8 @@ parser(const std::string& filename)
     OperatorRepository::destroy();
   };
 
+  auto input = std::make_shared<TAO_PEGTL_NAMESPACE::file_input<>>(filename);
   if (not SignalManager::pauseOnError()) {
-    TAO_PEGTL_NAMESPACE::file_input input(filename);
     try {
       parse_and_execute(input);
     }
@@ -119,13 +121,12 @@ parser(const std::string& filename)
       std::cerr << rang::style::bold << p.source << ':' << p.line << ':' << p.column << ": " << rang::style::reset
                 << rang::fgB::red << "error: " << rang::fg::reset << rang::style::bold << message << rang::style::reset
                 << '\n'
-                << input.line_at(p) << '\n'
+                << input->line_at(p) << '\n'
                 << std::string(p.column - 1, ' ') << rang::fgB::yellow << '^' << rang::fg::reset << '\n';
       finalize();
       std::exit(1);
     }
   } else {
-    TAO_PEGTL_NAMESPACE::file_input input(filename);
     parse_and_execute(input);
   }
 }
diff --git a/src/language/ast/ASTBacktrace.cpp b/src/language/ast/ASTBacktrace.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90f84bf13fe46299797f11f478fd33f09e0571e9
--- /dev/null
+++ b/src/language/ast/ASTBacktrace.cpp
@@ -0,0 +1,55 @@
+#include <language/ast/ASTBacktrace.hpp>
+
+#include <language/ast/ASTNode.hpp>
+
+ASTBacktrace* ASTBacktrace::m_instance = nullptr;
+
+ASTBacktrace::ASTBacktrace(const std::shared_ptr<TAO_PEGTL_NAMESPACE::file_input<>>& file_input)
+  : m_file_input(file_input)
+{}
+
+std::string
+ASTBacktrace::stackInfo() const
+{
+  auto& stack = ASTBacktrace::getInstance().m_stack;
+  std::ostringstream error_msg;
+
+  auto p = stack[stack.size() - 1]->begin();
+  error_msg << rang::style::bold << p.source << ':' << p.line << ':' << p.column << ": " << rang::style::reset
+            << rang::fgB::red << "error: " << rang::fg::reset << rang::style::bold << "emitted while executing"
+            << rang::style::reset << '\n';
+
+  if (m_file_input.use_count() > 0) {
+    error_msg << m_file_input->line_at(p) << '\n'
+              << std::string(p.column - 1, ' ') << rang::fgB::yellow << '^' << rang::fg::reset << '\n';
+  }
+
+  return error_msg.str();
+}
+
+void
+ASTBacktrace::create()
+{
+  if (m_instance == nullptr) {
+    m_instance = new ASTBacktrace();
+  } else {
+    throw UnexpectedError("ASTBackTrace was already created!");
+  }
+}
+
+void
+ASTBacktrace::create(const std::shared_ptr<TAO_PEGTL_NAMESPACE::file_input<>>& file_input)
+{
+  if (m_instance == nullptr) {
+    m_instance = new ASTBacktrace(file_input);
+  } else {
+    throw UnexpectedError("ASTBackTrace was already created!");
+  }
+}
+
+void
+ASTBacktrace::destroy()
+{
+  delete m_instance;
+  m_instance = nullptr;
+}
diff --git a/src/language/ast/ASTBacktrace.hpp b/src/language/ast/ASTBacktrace.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dfc3c2ba5f8a8f3feca01a2a9edd41bf57d3f63
--- /dev/null
+++ b/src/language/ast/ASTBacktrace.hpp
@@ -0,0 +1,54 @@
+#ifndef AST_BACTRACE_HPP
+#define AST_BACTRACE_HPP
+
+#include <utils/PugsAssert.hpp>
+
+#include <pegtl/file_input.hpp>
+#include <string>
+#include <vector>
+
+class ASTNode;
+class ASTBacktrace
+{
+ private:
+  std::vector<const ASTNode*> m_stack;
+
+  std::shared_ptr<TAO_PEGTL_NAMESPACE::file_input<>> m_file_input;
+
+  static ASTBacktrace* m_instance;
+
+  ASTBacktrace() = default;
+  ASTBacktrace(const std::shared_ptr<TAO_PEGTL_NAMESPACE::file_input<>>& file_input);
+  ~ASTBacktrace() = default;
+
+ public:
+  std::string stackInfo() const;
+
+  void
+  push(const ASTNode* node)
+  {
+    m_stack.push_back(node);
+  }
+
+  void
+  pop()
+  {
+    m_stack.pop_back();
+  }
+
+  static void create();   // for unit tests only
+  static void create(const std::shared_ptr<TAO_PEGTL_NAMESPACE::file_input<>>& file_input);
+  static void destroy();
+
+  static ASTBacktrace&
+  getInstance()
+  {
+    Assert(m_instance != nullptr);
+    return *m_instance;
+  }
+
+  ASTBacktrace(const ASTBacktrace&) = delete;
+  ASTBacktrace(ASTBacktrace&&)      = delete;
+};
+
+#endif   // AST_BACTRACE_HPP
diff --git a/src/language/ast/ASTNode.cpp b/src/language/ast/ASTNode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cddc0b4898035c65f546dd31d0e4eead68c6a998
--- /dev/null
+++ b/src/language/ast/ASTNode.cpp
@@ -0,0 +1,3 @@
+#include <language/ast/ASTNode.hpp>
+
+bool ASTNode::m_stack_details = true;
diff --git a/src/language/ast/ASTNode.hpp b/src/language/ast/ASTNode.hpp
index f9f9ad6db2b7302bb657722a2dc91988e051a146..19b43a9272229d97bef9c96a8210506e23513a40 100644
--- a/src/language/ast/ASTNode.hpp
+++ b/src/language/ast/ASTNode.hpp
@@ -1,6 +1,7 @@
 #ifndef AST_NODE_HPP
 #define AST_NODE_HPP
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/node_processor/ExecutionPolicy.hpp>
 #include <language/node_processor/INodeProcessor.hpp>
 #include <language/utils/ASTNodeDataType.hpp>
@@ -9,13 +10,18 @@
 #include <utils/PugsAssert.hpp>
 #include <utils/PugsMacros.hpp>
 
+#include <pegtl.hpp>
 #include <pegtl/contrib/parse_tree.hpp>
 
+inline TAO_PEGTL_NAMESPACE::file_input<>* p_file_input = nullptr;
+
 class SymbolTable;
 
 class ASTNode : public TAO_PEGTL_NAMESPACE::parse_tree::basic_node<ASTNode>
 {
  private:
+  static bool m_stack_details;
+
   PUGS_INLINE
   decltype(m_end)
   _getEnd() const
@@ -41,6 +47,18 @@ class ASTNode : public TAO_PEGTL_NAMESPACE::parse_tree::basic_node<ASTNode>
   }
 
  public:
+  static bool
+  getStackDetails()
+  {
+    return m_stack_details;
+  }
+
+  static void
+  setStackDetails(const bool stack_details)
+  {
+    m_stack_details = stack_details;
+  }
+
   std::shared_ptr<SymbolTable> m_symbol_table;
   std::unique_ptr<INodeProcessor> m_node_processor;
 
@@ -88,8 +106,29 @@ class ASTNode : public TAO_PEGTL_NAMESPACE::parse_tree::basic_node<ASTNode>
   execute(ExecutionPolicy& exec_policy)
   {
     Assert(m_node_processor, "undefined node processor");
+
     if (exec_policy.exec()) {
-      return m_node_processor->execute(exec_policy);
+      if (m_stack_details) {
+        if (m_node_processor->type() == INodeProcessor::Type::builtin_function_processor) {
+          ASTBacktrace::getInstance().push(this);
+
+          m_stack_details = false;
+          auto result     = m_node_processor->execute(exec_policy);
+          m_stack_details = true;
+
+          ASTBacktrace::getInstance().pop();
+
+          return result;
+        } else {
+          ASTBacktrace::getInstance().push(this);
+          auto result = m_node_processor->execute(exec_policy);
+          ASTBacktrace::getInstance().pop();
+
+          return result;
+        }
+      } else {
+        return m_node_processor->execute(exec_policy);
+      }
     } else {
       return {};
     }
diff --git a/src/language/ast/CMakeLists.txt b/src/language/ast/CMakeLists.txt
index a901d7c09679c37d54420f51d347537fe5e18aef..63e208c2b153b7f05318ee15066f5da0f7e2cb8c 100644
--- a/src/language/ast/CMakeLists.txt
+++ b/src/language/ast/CMakeLists.txt
@@ -1,8 +1,10 @@
 # ------------------- Source files --------------------
 
 add_library(PugsLanguageAST
+  ASTBacktrace.cpp
   ASTBuilder.cpp
   ASTModulesImporter.cpp
+  ASTNode.cpp
   ASTNodeAffectationExpressionBuilder.cpp
   ASTNodeArraySubscriptExpressionBuilder.cpp
   ASTNodeBinaryOperatorExpressionBuilder.cpp
diff --git a/src/language/node_processor/ASTNodeExpressionListProcessor.hpp b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
index 21823176e8b7f8d9eb0c0760c52ae0fb1749f0e3..bc6f2788f1d4e524339f8fc320d7351e1f825836 100644
--- a/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
+++ b/src/language/node_processor/ASTNodeExpressionListProcessor.hpp
@@ -76,6 +76,12 @@ class ASTNodeExpressionListProcessor final : public INodeProcessor
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::expression_list_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/ASTNodeListProcessor.hpp b/src/language/node_processor/ASTNodeListProcessor.hpp
index 5a9d8c0b8be23ad9c563ce7d8ed30f25df29505f..142d33f7d7ce085b57c3a3746f9f559c87e4408e 100644
--- a/src/language/node_processor/ASTNodeListProcessor.hpp
+++ b/src/language/node_processor/ASTNodeListProcessor.hpp
@@ -12,6 +12,12 @@ class ASTNodeListProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::list_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/AffectationProcessor.hpp b/src/language/node_processor/AffectationProcessor.hpp
index 8fea3a7546b9f96298e97b0603a849c84915f47a..b18665a0fdd572590822e2592090ba7441b9856e 100644
--- a/src/language/node_processor/AffectationProcessor.hpp
+++ b/src/language/node_processor/AffectationProcessor.hpp
@@ -453,6 +453,12 @@ class AffectationProcessor final : public INodeProcessor
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -495,6 +501,12 @@ class AffectationToTupleProcessor final : public AffectationToDataVariantProcess
   ASTNode& m_rhs_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -555,6 +567,12 @@ class AffectationFromTupleProcessor final : public AffectationToDataVariantProce
   ASTNode& m_rhs_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -682,6 +700,12 @@ class AffectationToTupleFromListProcessor final : public AffectationToDataVarian
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -755,6 +779,12 @@ class AffectationToTupleFromTupleProcessor final : public AffectationToDataVaria
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -787,6 +817,12 @@ template <typename ValueT>
 class AffectationFromZeroProcessor final : public AffectationToDataVariantProcessorBase
 {
  public:
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy&)
   {
@@ -830,6 +866,12 @@ class ListAffectationProcessor final : public INodeProcessor
     }
   }
 
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -938,6 +980,12 @@ class ListAffectationFromTupleProcessor final : public INodeProcessor
     }
   }
 
+  Type
+  type() const
+  {
+    return Type::affectation_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/ArraySubscriptProcessor.hpp b/src/language/node_processor/ArraySubscriptProcessor.hpp
index 43eb962b9d724b19b4cfe7ab808f52dd73d1fce2..4166c0d98ba34c3d390dc69524a7145b4e4a7cdb 100644
--- a/src/language/node_processor/ArraySubscriptProcessor.hpp
+++ b/src/language/node_processor/ArraySubscriptProcessor.hpp
@@ -12,6 +12,12 @@ class ArraySubscriptProcessor : public INodeProcessor
   ASTNode& m_array_subscript_expression;
 
  public:
+  Type
+  type() const
+  {
+    return Type::array_subscript_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/BinaryExpressionProcessor.hpp b/src/language/node_processor/BinaryExpressionProcessor.hpp
index a2111464ce05a8148ff4886f9614952641ed65d5..d91f39d905c1f055ed7d95d6a15ff7f258fc2385 100644
--- a/src/language/node_processor/BinaryExpressionProcessor.hpp
+++ b/src/language/node_processor/BinaryExpressionProcessor.hpp
@@ -223,6 +223,12 @@ struct BinaryExpressionProcessor final : public INodeProcessor
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::binary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -253,6 +259,12 @@ struct BinaryExpressionProcessor<BinaryOpT, std::shared_ptr<ValueT>, std::shared
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::binary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -290,6 +302,12 @@ struct BinaryExpressionProcessor<BinaryOpT, std::shared_ptr<ValueT>, A_DataT, st
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::binary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -328,6 +346,12 @@ struct BinaryExpressionProcessor<BinaryOpT, std::shared_ptr<ValueT>, std::shared
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::binary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/BreakProcessor.hpp b/src/language/node_processor/BreakProcessor.hpp
index 6f6d4a306c99723ab2e5ce7f4fc4864eebd77926..d403d89fe4b8e5abbad4fec9e85b264e1294017d 100644
--- a/src/language/node_processor/BreakProcessor.hpp
+++ b/src/language/node_processor/BreakProcessor.hpp
@@ -6,6 +6,12 @@
 class BreakProcessor final : public INodeProcessor
 {
  public:
+  Type
+  type() const
+  {
+    return Type::break_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/BuiltinFunctionProcessor.hpp b/src/language/node_processor/BuiltinFunctionProcessor.hpp
index 7e5a112b46f32792cf2fda652379a4a5f2f064aa..708141d17726102e944200f7c496e522885dfd61 100644
--- a/src/language/node_processor/BuiltinFunctionProcessor.hpp
+++ b/src/language/node_processor/BuiltinFunctionProcessor.hpp
@@ -15,6 +15,12 @@ class BuiltinFunctionExpressionProcessor final : public INodeProcessor
   std::shared_ptr<IBuiltinFunctionEmbedder> m_embedded;
 
  public:
+  Type
+  type() const
+  {
+    return Type::builtin_function_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -46,6 +52,12 @@ class BuiltinFunctionProcessor : public INodeProcessor
     m_function_expression_processor = std::move(function_processor);
   }
 
+  Type
+  type() const
+  {
+    return Type::builtin_function_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/ConcatExpressionProcessor.hpp b/src/language/node_processor/ConcatExpressionProcessor.hpp
index 4653c341c7b322fb338e15c09dada90b98472a8c..5fa6bbbdac7c0c06f57737fb2197c8323ef02cf6 100644
--- a/src/language/node_processor/ConcatExpressionProcessor.hpp
+++ b/src/language/node_processor/ConcatExpressionProcessor.hpp
@@ -41,6 +41,12 @@ class ConcatExpressionProcessor final : public INodeProcessor
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::concat_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/ContinueProcessor.hpp b/src/language/node_processor/ContinueProcessor.hpp
index e8e5d6c7daf807c94986ea58f40e327a60f5a7a4..c98ad4312136e89a55a1661ae9bf412e8243e060 100644
--- a/src/language/node_processor/ContinueProcessor.hpp
+++ b/src/language/node_processor/ContinueProcessor.hpp
@@ -6,6 +6,12 @@
 class ContinueProcessor final : public INodeProcessor
 {
  public:
+  Type
+  type() const
+  {
+    return Type::continue_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/DoWhileProcessor.hpp b/src/language/node_processor/DoWhileProcessor.hpp
index 6f3c14b7f8706c6d5480f792e449c1f110b74498..593fd4bf178ea0734ce4e512fd913c4cc760ee98 100644
--- a/src/language/node_processor/DoWhileProcessor.hpp
+++ b/src/language/node_processor/DoWhileProcessor.hpp
@@ -11,6 +11,12 @@ class DoWhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::do_while_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/FakeProcessor.hpp b/src/language/node_processor/FakeProcessor.hpp
index ce3b7d257aa8d3684fd06ff87496ce1b66fa9bf5..f947ec2a10d0e62ac7f1c977e698cf0f1fa46794 100644
--- a/src/language/node_processor/FakeProcessor.hpp
+++ b/src/language/node_processor/FakeProcessor.hpp
@@ -6,6 +6,12 @@
 class FakeProcessor final : public INodeProcessor
 {
  public:
+  Type
+  type() const
+  {
+    return Type::fake_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy&)
   {
diff --git a/src/language/node_processor/ForProcessor.hpp b/src/language/node_processor/ForProcessor.hpp
index 4199e0c42867398167c2f1fa5927d87e7f4fddc6..674c7d05ea4e6f89c4941eddc15540556961ae87 100644
--- a/src/language/node_processor/ForProcessor.hpp
+++ b/src/language/node_processor/ForProcessor.hpp
@@ -11,6 +11,12 @@ class ForProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::for_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/FunctionProcessor.hpp b/src/language/node_processor/FunctionProcessor.hpp
index 2b3e65ecb130c6f50105a5cba08552e43e16596c..69ca0e488be67ae618f2f893049bd48a2a635d8d 100644
--- a/src/language/node_processor/FunctionProcessor.hpp
+++ b/src/language/node_processor/FunctionProcessor.hpp
@@ -16,6 +16,12 @@ class FunctionExpressionProcessor final : public INodeProcessor
   ASTNode& m_function_expression;
 
  public:
+  Type
+  type() const
+  {
+    return Type::function_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -292,6 +298,12 @@ class FunctionProcessor : public INodeProcessor
     m_function_expression_processors.emplace_back(std::move(function_processor));
   }
 
+  Type
+  type() const
+  {
+    return Type::function_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/INodeProcessor.hpp b/src/language/node_processor/INodeProcessor.hpp
index 2c35b6c49cadd69536c415f5a86e5786c953a86c..942a22717c7678d9d82902f4da534b7a0b9e1357 100644
--- a/src/language/node_processor/INodeProcessor.hpp
+++ b/src/language/node_processor/INodeProcessor.hpp
@@ -11,6 +11,37 @@
 class INodeProcessor
 {
  public:
+  enum class Type
+  {
+    affectation_processor,
+    array_subscript_processor,
+    binary_expression_processor,
+    break_processor,
+    builtin_function_expression_processor,
+    builtin_function_processor,
+    concat_expression_processor,
+    continue_processor,
+    do_while_processor,
+    expression_list_processor,
+    fake_processor,
+    for_processor,
+    function_expression_processor,
+    function_processor,
+    if_processor,
+    inc_dec_expression_processor,
+    inner_list_to_vector_processor,
+    list_processor,
+    local_name_processor,
+    name_processor,
+    tiny_matrix_expression_processor,
+    tiny_vector_expression_processor,
+    unary_expression_processor,
+    value_processor,
+    while_processor
+  };
+
+  virtual Type type() const = 0;
+
   virtual DataVariant execute(ExecutionPolicy& exec_policy) = 0;
 
   std::string
diff --git a/src/language/node_processor/IfProcessor.hpp b/src/language/node_processor/IfProcessor.hpp
index 18d87bb89f11ee0f335fe0637f4569dc5b3cab15..0d7497eaf832d257d12dec349de4fe0c6b033ab9 100644
--- a/src/language/node_processor/IfProcessor.hpp
+++ b/src/language/node_processor/IfProcessor.hpp
@@ -11,6 +11,12 @@ class IfProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::if_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/IncDecExpressionProcessor.hpp b/src/language/node_processor/IncDecExpressionProcessor.hpp
index 199d3ebb834e7b89dfdc714b89977c6ae78c7b0c..186d3da7c3e7524863ee690067286a79ff4f34c1 100644
--- a/src/language/node_processor/IncDecExpressionProcessor.hpp
+++ b/src/language/node_processor/IncDecExpressionProcessor.hpp
@@ -71,6 +71,12 @@ class IncDecExpressionProcessor final : public INodeProcessor
   DataVariant* p_value{nullptr};
 
  public:
+  Type
+  type() const
+  {
+    return Type::inc_dec_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy&)
   {
diff --git a/src/language/node_processor/InnerListToVectorProcessor.hpp b/src/language/node_processor/InnerListToVectorProcessor.hpp
index ef74daaabe5c0e2f475b1693b7bb9627ed600f40..12ab335b1c6e38ba477da91a06ad19329c3fc8aa 100644
--- a/src/language/node_processor/InnerListToVectorProcessor.hpp
+++ b/src/language/node_processor/InnerListToVectorProcessor.hpp
@@ -11,6 +11,12 @@ class InnerListToVectorProcessor final : public INodeProcessor
   std::unique_ptr<ASTNodeExpressionListProcessor> m_expression_list_processor;
 
  public:
+  Type
+  type() const
+  {
+    return Type::inner_list_to_vector_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/LocalNameProcessor.hpp b/src/language/node_processor/LocalNameProcessor.hpp
index 51d442b266288360c1d5f6fe000ba72fa7057cb9..e7d7f40d849f6325387be26af49a0bbfe3971a6d 100644
--- a/src/language/node_processor/LocalNameProcessor.hpp
+++ b/src/language/node_processor/LocalNameProcessor.hpp
@@ -13,6 +13,12 @@ class LocalNameProcessor final : public INodeProcessor
   int32_t m_context_id;
 
  public:
+  Type
+  type() const
+  {
+    return Type::local_name_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/NameProcessor.hpp b/src/language/node_processor/NameProcessor.hpp
index d5dee908565a2d7ccdff03ee509c87f841770c8d..04bbde4d01c36d086408601f9ab5875a1f19a01f 100644
--- a/src/language/node_processor/NameProcessor.hpp
+++ b/src/language/node_processor/NameProcessor.hpp
@@ -12,6 +12,12 @@ class NameProcessor final : public INodeProcessor
   DataVariant* p_value{nullptr};
 
  public:
+  Type
+  type() const
+  {
+    return Type::name_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy&)
   {
diff --git a/src/language/node_processor/TinyMatrixExpressionProcessor.hpp b/src/language/node_processor/TinyMatrixExpressionProcessor.hpp
index bcb3e65f35b301c6adbe12eeb02e6024cb9ea0da..91d1a53b2c2c7cb7f8da7af8051d5ebdfd1b3736 100644
--- a/src/language/node_processor/TinyMatrixExpressionProcessor.hpp
+++ b/src/language/node_processor/TinyMatrixExpressionProcessor.hpp
@@ -13,6 +13,12 @@ class TinyMatrixExpressionProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::tiny_matrix_expression_processor;
+  }
+
   PUGS_INLINE
   DataVariant
   execute(ExecutionPolicy& exec_policy)
diff --git a/src/language/node_processor/TinyVectorExpressionProcessor.hpp b/src/language/node_processor/TinyVectorExpressionProcessor.hpp
index ac86b9025b54f673c3cad636aaf1178a55e436a1..5c1a2d946bd37e1d9bb0f9bedb91e54985bf26dc 100644
--- a/src/language/node_processor/TinyVectorExpressionProcessor.hpp
+++ b/src/language/node_processor/TinyVectorExpressionProcessor.hpp
@@ -13,6 +13,12 @@ class TinyVectorExpressionProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::tiny_vector_expression_processor;
+  }
+
   PUGS_INLINE
   DataVariant
   execute(ExecutionPolicy& exec_policy)
diff --git a/src/language/node_processor/UnaryExpressionProcessor.hpp b/src/language/node_processor/UnaryExpressionProcessor.hpp
index cdc4fc54111fd3a52854160347b5753e3787bcd5..06bbfde45ab560112a776ffa765b9277272442c5 100644
--- a/src/language/node_processor/UnaryExpressionProcessor.hpp
+++ b/src/language/node_processor/UnaryExpressionProcessor.hpp
@@ -46,6 +46,12 @@ class UnaryExpressionProcessor final : public INodeProcessor
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::unary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
@@ -72,6 +78,12 @@ class UnaryExpressionProcessor<UnaryOpT, std::shared_ptr<ValueT>, std::shared_pt
   }
 
  public:
+  Type
+  type() const
+  {
+    return Type::unary_expression_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/language/node_processor/ValueProcessor.hpp b/src/language/node_processor/ValueProcessor.hpp
index 342198223e763fdb66781a632da0d107182234d5..66f054fe837cd9de59ad76ddb7f8f513b73a1b15 100644
--- a/src/language/node_processor/ValueProcessor.hpp
+++ b/src/language/node_processor/ValueProcessor.hpp
@@ -12,6 +12,12 @@ class ValueProcessor final : public INodeProcessor
   DataVariant m_value;
 
  public:
+  Type
+  type() const
+  {
+    return Type::value_processor;
+  }
+
   PUGS_INLINE
   DataVariant
   execute(ExecutionPolicy&)
diff --git a/src/language/node_processor/WhileProcessor.hpp b/src/language/node_processor/WhileProcessor.hpp
index af7cc604bb6c2d5f74cb894a1f05ba20acfb35f6..72c8f4186e81cfcc587e6cf55d6f503ee3f0f154 100644
--- a/src/language/node_processor/WhileProcessor.hpp
+++ b/src/language/node_processor/WhileProcessor.hpp
@@ -11,6 +11,12 @@ class WhileProcessor final : public INodeProcessor
   ASTNode& m_node;
 
  public:
+  Type
+  type() const
+  {
+    return Type::while_processor;
+  }
+
   DataVariant
   execute(ExecutionPolicy& exec_policy)
   {
diff --git a/src/utils/SignalManager.cpp b/src/utils/SignalManager.cpp
index 399f3164c2046f4ec25a009160a6f01b11da85ef..1fb5c9949264c9bd6b6b8800d5ea344cf1c73566 100644
--- a/src/utils/SignalManager.cpp
+++ b/src/utils/SignalManager.cpp
@@ -1,5 +1,6 @@
 #include <utils/SignalManager.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <utils/BacktraceManager.hpp>
 #include <utils/ConsoleManager.hpp>
 #include <utils/Messenger.hpp>
@@ -67,41 +68,51 @@ SignalManager::pauseForDebug(int signal)
 void
 SignalManager::handler(int signal)
 {
-  std::signal(SIGFPE, SIG_DFL);
-  std::signal(SIGSEGV, SIG_IGN);
-  std::signal(SIGTERM, SIG_DFL);
-  std::signal(SIGINT, SIG_DFL);
-  std::signal(SIGABRT, SIG_DFL);
-
-  // Each failing process must write
-  std::cerr.setstate(std::ios::goodbit);
-
-  BacktraceManager bm;
-  std::cerr << bm << '\n';
-
-  std::exception_ptr eptr = std::current_exception();
-  try {
-    if (eptr) {
-      std::rethrow_exception(eptr);
+  static std::mutex mutex;
+
+  if (mutex.try_lock()) {
+    std::signal(SIGTERM, SIG_DFL);
+    std::signal(SIGINT, SIG_DFL);
+    std::signal(SIGABRT, SIG_DFL);
+
+    // Each failing process must write
+    std::cerr.setstate(std::ios::goodbit);
+
+    std::ostringstream error_msg;
+
+    BacktraceManager bm;
+    error_msg << bm;
+
+    std::cerr << error_msg.str() << '\n';
+
+    std::exception_ptr eptr = std::current_exception();
+    try {
+      if (eptr) {
+        std::rethrow_exception(eptr);
+      }
     }
-  }
-  catch (const NotImplementedError& not_implemented_error) {
-    std::cerr << not_implemented_error.what() << '\n';
-  }
-  catch (const UnexpectedError& unexpected_error) {
-    std::cerr << unexpected_error.what() << '\n';
-  }
-  catch (const AssertError& assert_error) {
-    std::cerr << assert_error << '\n';
-  }
-  catch (...) {
-    std::cerr << "Unknown exception!\n";
-  }
+    catch (const NotImplementedError& not_implemented_error) {
+      std::cerr << not_implemented_error.what() << '\n';
+    }
+    catch (const UnexpectedError& unexpected_error) {
+      std::cerr << unexpected_error.what() << '\n';
+    }
+    catch (const AssertError& assert_error) {
+      std::cerr << assert_error << '\n';
+    }
+    catch (...) {
+      std::cerr << "Unknown exception!\n";
+    }
+
+    std::cerr << "\n *** " << rang::style::reset << rang::fg::reset << rang::style::bold << "Signal " << rang::fgB::red
+              << signalName(signal) << rang::fg::reset << " caught" << rang::style::reset << " ***\n";
 
-  std::cerr << "\n *** " << rang::style::reset << rang::fg::reset << rang::style::bold << "Signal " << rang::fgB::red
-            << signalName(signal) << rang::fg::reset << " caught" << rang::style::reset << " ***\n";
+    std::cerr << '\n' << ASTBacktrace::getInstance().stackInfo() << '\n';
 
-  SignalManager::pauseForDebug(signal);
+    SignalManager::pauseForDebug(signal);
+
+    mutex.unlock();
+  }
 }
 
 void
diff --git a/tests/test_ASTModulesImporter.cpp b/tests/test_ASTModulesImporter.cpp
index 4be8e087dd89490caf6be0a8ba3132588fd919df..f70fa9b2bc118c4498072de10414d346b17717b4 100644
--- a/tests/test_ASTModulesImporter.cpp
+++ b/tests/test_ASTModulesImporter.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeExpressionBuilder.hpp>
@@ -37,7 +38,9 @@ test_ASTExecutionInfo(const ASTNode& root_node, const ModuleRepository& module_r
     test_ASTExecutionInfo(*ast, module_repository);                                                 \
                                                                                                     \
     ExecutionPolicy exec_policy;                                                                    \
+    ASTBacktrace::create();                                                                         \
     ast->execute(exec_policy);                                                                      \
+    ASTBacktrace::destroy();                                                                        \
                                                                                                     \
     std::stringstream ast_output;                                                                   \
     ast_output << '\n' << ASTPrinter{*ast, ASTPrinter::Format::raw, {ASTPrinter::Info::data_type}}; \
diff --git a/tests/test_ASTNode.cpp b/tests/test_ASTNode.cpp
index bb4b07f9b1d8a2022a0b5961b7e76ac80922f1b9..468a27a89dbe3be40c20ad386cd82434e52f2807 100644
--- a/tests/test_ASTNode.cpp
+++ b/tests/test_ASTNode.cpp
@@ -2,6 +2,7 @@
 #include <catch2/matchers/catch_matchers_all.hpp>
 
 #include <language/PEGGrammar.hpp>
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTNode.hpp>
 #include <language/node_processor/FakeProcessor.hpp>
 #include <utils/Demangle.hpp>
@@ -17,12 +18,16 @@ TEST_CASE("ASTNode", "[language]")
     ExecutionPolicy exec_policy;
 
 #ifndef NDEBUG
+    ASTBacktrace::create();
     REQUIRE_THROWS(ast_node.execute(exec_policy));
+    ASTBacktrace::destroy();
 #endif   // NDEBUG
 
     ast_node.m_node_processor = std::make_unique<FakeProcessor>();
 
+    ASTBacktrace::create();
     REQUIRE_NOTHROW(ast_node.execute(exec_policy));
+    ASTBacktrace::destroy();
   }
 
   SECTION("name")
diff --git a/tests/test_ASTNodeListProcessor.cpp b/tests/test_ASTNodeListProcessor.cpp
index 934eb58912179a90158df2c3885a923ba7cf736c..d858b313aa695d39912953712858bf1bbb5e257e 100644
--- a/tests/test_ASTNodeListProcessor.cpp
+++ b/tests/test_ASTNodeListProcessor.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTNodeDataTypeBuilder.hpp>
 #include <language/ast/ASTNodeDeclarationToAffectationConverter.hpp>
@@ -35,7 +36,9 @@ true;
 
   ASTNodeExpressionBuilder{*ast};
   ExecutionPolicy exec_policy;
+  ASTBacktrace::create();
   ast->execute(exec_policy);
+  ASTBacktrace::destroy();
 
   REQUIRE(ast->children[0]->is_type<language::integer>());
   REQUIRE(ast->children[1]->is_type<language::true_kw>());
diff --git a/tests/test_AffectationProcessor.cpp b/tests/test_AffectationProcessor.cpp
index 71670fd5d75b4ae7d20d8ece4b3ef980165cd382..03781088ae664cff01ebde37314e0af1b15826ca 100644
--- a/tests/test_AffectationProcessor.cpp
+++ b/tests/test_AffectationProcessor.cpp
@@ -16,6 +16,7 @@
 #include <utils/Stringify.hpp>
 
 #include <FixturesForBuiltinT.hpp>
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/utils/BasicAffectationRegistrerFor.hpp>
 
 #include <pegtl/string_input.hpp>
@@ -37,7 +38,9 @@
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
     ExecutionPolicy exec_policy;                                              \
+    ASTBacktrace::create();                                                   \
     ast->execute(exec_policy);                                                \
+    ASTBacktrace::destroy();                                                  \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
                                                                               \
@@ -98,7 +101,9 @@
                                                                                                                 \
     ASTNodeExpressionBuilder{*ast};                                                                             \
     ExecutionPolicy exec_policy;                                                                                \
+    ASTBacktrace::create();                                                                                     \
     ast->execute(exec_policy);                                                                                  \
+    ASTBacktrace::destroy();                                                                                    \
                                                                                                                 \
     using namespace TAO_PEGTL_NAMESPACE;                                                                        \
     position use_position{internal::iterator{"fixture"}, "fixture"};                                            \
@@ -150,7 +155,9 @@
     ASTNodeExpressionBuilder{*ast};                                \
     ExecutionPolicy exec_policy;                                   \
                                                                    \
+    ASTBacktrace::create();                                        \
     REQUIRE_THROWS_WITH(ast->execute(exec_policy), error_message); \
+    ASTBacktrace::destroy();                                       \
   }
 
 // clazy:excludeall=non-pod-global-static
diff --git a/tests/test_AffectationToStringProcessor.cpp b/tests/test_AffectationToStringProcessor.cpp
index 6b20e7ca84e7c7f80654ed6a053a34068df83889..8e15ddc66cb379b841232ad377d244833aa618a6 100644
--- a/tests/test_AffectationToStringProcessor.cpp
+++ b/tests/test_AffectationToStringProcessor.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
@@ -32,7 +33,9 @@
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
     ExecutionPolicy exec_policy;                                              \
+    ASTBacktrace::create();                                                   \
     ast->execute(exec_policy);                                                \
+    ASTBacktrace::destroy();                                                  \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
                                                                               \
diff --git a/tests/test_AffectationToTupleProcessor.cpp b/tests/test_AffectationToTupleProcessor.cpp
index 84d1a1639d52107a802ff66f8cff9dfd3bff0b5f..ca6a6294b77f14ed8846a60823fdf8d8632a56ba 100644
--- a/tests/test_AffectationToTupleProcessor.cpp
+++ b/tests/test_AffectationToTupleProcessor.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
@@ -32,7 +33,9 @@
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
     ExecutionPolicy exec_policy;                                              \
+    ASTBacktrace::create();                                                   \
     ast->execute(exec_policy);                                                \
+    ASTBacktrace::destroy();                                                  \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
                                                                               \
@@ -63,7 +66,9 @@
     ASTNodeExpressionBuilder{*ast};                                \
     ExecutionPolicy exec_policy;                                   \
                                                                    \
+    ASTBacktrace::create();                                        \
     REQUIRE_THROWS_WITH(ast->execute(exec_policy), error_message); \
+    ASTBacktrace::destroy();                                       \
   }
 
 // clazy:excludeall=non-pod-global-static
diff --git a/tests/test_ArraySubscriptProcessor.cpp b/tests/test_ArraySubscriptProcessor.cpp
index 5b1ac6c1cf0a00f56a4da806b86bb4124c42b317..949951c226c55ee77234885175e5f0f9a42f287f 100644
--- a/tests/test_ArraySubscriptProcessor.cpp
+++ b/tests/test_ArraySubscriptProcessor.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeAffectationExpressionBuilder.hpp>
@@ -33,7 +34,9 @@
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
     ExecutionPolicy exec_policy;                                              \
+    ASTBacktrace::create();                                                   \
     ast->execute(exec_policy);                                                \
+    ASTBacktrace::destroy();                                                  \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
                                                                               \
@@ -66,7 +69,9 @@
                                                                  \
       ASTNodeExpressionBuilder{*ast};                            \
       ExecutionPolicy exec_policy;                               \
+      ASTBacktrace::create();                                    \
       ast->execute(exec_policy);                                 \
+      ASTBacktrace::destroy();                                   \
     };                                                           \
                                                                  \
     REQUIRE_THROWS_WITH(eval(), error_message);                  \
diff --git a/tests/test_BinaryExpressionProcessor_arithmetic.cpp b/tests/test_BinaryExpressionProcessor_arithmetic.cpp
index 83869150f8ba220c54c3389b4982eabab3c522d4..c93face344864f42e968322ce86f0f03efeabae9 100644
--- a/tests/test_BinaryExpressionProcessor_arithmetic.cpp
+++ b/tests/test_BinaryExpressionProcessor_arithmetic.cpp
@@ -76,7 +76,9 @@
                                                                                                                 \
     ASTNodeExpressionBuilder{*ast};                                                                             \
     ExecutionPolicy exec_policy;                                                                                \
+    ASTBacktrace::create();                                                                                     \
     ast->execute(exec_policy);                                                                                  \
+    ASTBacktrace::destroy();                                                                                    \
                                                                                                                 \
     using namespace TAO_PEGTL_NAMESPACE;                                                                        \
     position use_position{internal::iterator{"fixture"}, "fixture"};                                            \
@@ -153,7 +155,9 @@
                                                                                                                   \
     ASTNodeExpressionBuilder{*ast};                                                                               \
     ExecutionPolicy exec_policy;                                                                                  \
+    ASTBacktrace::create();                                                                                       \
     REQUIRE_THROWS_WITH(ast->execute(exec_policy), error_msg);                                                    \
+    ASTBacktrace::destroy();                                                                                      \
   }
 
 TEST_CASE("BinaryExpressionProcessor arithmetic", "[language]")
diff --git a/tests/test_BinaryExpressionProcessor_shift.cpp b/tests/test_BinaryExpressionProcessor_shift.cpp
index 71addbac7a1c80aaf49d1b236f1edfed1f182a4e..190b9f2b26d39d831550b70fef528a06f2c4503e 100644
--- a/tests/test_BinaryExpressionProcessor_shift.cpp
+++ b/tests/test_BinaryExpressionProcessor_shift.cpp
@@ -64,7 +64,9 @@ fout << createSocketServer(0) << "\n";)";
 
       ASTNodeExpressionBuilder{*ast};
       ExecutionPolicy exec_policy;
+      ASTBacktrace::create();
       ast->execute(exec_policy);
+      ASTBacktrace::destroy();
     }
 
     REQUIRE(std::filesystem::exists(filename));
diff --git a/tests/test_BinaryExpressionProcessor_utils.hpp b/tests/test_BinaryExpressionProcessor_utils.hpp
index c8e3440cfd75b1320c146d5eb342a2a5d343a20f..5983cda355f76c7ed58d47fa544dc5fd82ba3b09 100644
--- a/tests/test_BinaryExpressionProcessor_utils.hpp
+++ b/tests/test_BinaryExpressionProcessor_utils.hpp
@@ -1,6 +1,7 @@
 #ifndef TEST_BINARY_EXPRESSION_PROCESSOR_UTILS_HPP
 #define TEST_BINARY_EXPRESSION_PROCESSOR_UTILS_HPP
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeDataTypeBuilder.hpp>
@@ -30,7 +31,9 @@
                                                                               \
     ASTNodeExpressionBuilder{*ast};                                           \
     ExecutionPolicy exec_policy;                                              \
+    ASTBacktrace::create();                                                   \
     ast->execute(exec_policy);                                                \
+    ASTBacktrace::destroy();                                                  \
                                                                               \
     auto symbol_table = ast->m_symbol_table;                                  \
                                                                               \
diff --git a/tests/test_BuiltinFunctionProcessor.cpp b/tests/test_BuiltinFunctionProcessor.cpp
index 8de9ec2c2ed9e61479aa2d7165bf6e506fd6caf6..67812b0a4442e4d336dd20d5d579137804fe190b 100644
--- a/tests/test_BuiltinFunctionProcessor.cpp
+++ b/tests/test_BuiltinFunctionProcessor.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_predicate.hpp>
 
+#include <language/ast/ASTBacktrace.hpp>
 #include <language/ast/ASTBuilder.hpp>
 #include <language/ast/ASTModulesImporter.hpp>
 #include <language/ast/ASTNodeDataTypeBuilder.hpp>
@@ -31,7 +32,9 @@
                                                                                                                       \
     ASTNodeExpressionBuilder{*ast};                                                                                   \
     ExecutionPolicy exec_policy;                                                                                      \
+    ASTBacktrace::create();                                                                                           \
     ast->execute(exec_policy);                                                                                        \
+    ASTBacktrace::destroy();                                                                                          \
                                                                                                                       \
     auto symbol_table = ast->m_symbol_table;                                                                          \
                                                                                                                       \
@@ -69,7 +72,9 @@
     ASTNodeExpressionBuilder{*ast};                                                             \
     ExecutionPolicy exec_policy;                                                                \
     using namespace Catch::Matchers;                                                            \
+    ASTBacktrace::create();                                                                     \
     REQUIRE_THROWS_WITH(ast->execute(exec_policy), expected_error);                             \
+    ASTBacktrace::destroy();                                                                    \
   }
 
 // clazy:excludeall=non-pod-global-static
diff --git a/tests/test_DiscreteFunctionIntegrator.cpp b/tests/test_DiscreteFunctionIntegrator.cpp
index b3ba2efba4ae8fe3dc90b8b54f6df6032d622e8c..26a14385f67501c8f9145d5bfa6756517726849e 100644
--- a/tests/test_DiscreteFunctionIntegrator.cpp
+++ b/tests/test_DiscreteFunctionIntegrator.cpp
@@ -31,6 +31,9 @@
 
 TEST_CASE("DiscreteFunctionIntegrator", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     for (ItemIdType item_id = 0; item_id < f.numberOfItems(); ++item_id) {
@@ -749,4 +752,6 @@ let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionIntegratorByZone.cpp b/tests/test_DiscreteFunctionIntegratorByZone.cpp
index 217c15b38d17195f2e3baa56d0a698f0b2c9c2a4..0b550b063fd14ec53df39f9395c4061ef997f17e 100644
--- a/tests/test_DiscreteFunctionIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionIntegratorByZone.cpp
@@ -33,6 +33,9 @@
 
 TEST_CASE("DiscreteFunctionIntegratorByZone", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     for (ItemIdType item_id = 0; item_id < f.numberOfItems(); ++item_id) {
@@ -1030,4 +1033,6 @@ let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       REQUIRE(same_cell_value(cell_value, discrete_function.get<DiscreteFunctionP0<Dimension, const DataType>>()));
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionInterpoler.cpp b/tests/test_DiscreteFunctionInterpoler.cpp
index 0287d97c89ef966f5a4d68ecd091875b3e19e14b..fd3f3b6724e3ff8efd1cd3446d261cd06de448fb 100644
--- a/tests/test_DiscreteFunctionInterpoler.cpp
+++ b/tests/test_DiscreteFunctionInterpoler.cpp
@@ -29,6 +29,9 @@
 
 TEST_CASE("DiscreteFunctionInterpoler", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     for (ItemIdType item_id = 0; item_id < f.numberOfItems(); ++item_id) {
@@ -908,4 +911,6 @@ let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionInterpolerByZone.cpp b/tests/test_DiscreteFunctionInterpolerByZone.cpp
index c4e6f0a00a15a8921615bb0540adf3c3668e7300..8a0297d3ef1de251c23a66107303aa02f3d23fb8 100644
--- a/tests/test_DiscreteFunctionInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionInterpolerByZone.cpp
@@ -31,6 +31,9 @@
 
 TEST_CASE("DiscreteFunctionInterpolerByZone", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     for (ItemIdType item_id = 0; item_id < f.numberOfItems(); ++item_id) {
@@ -1042,4 +1045,6 @@ let R3x3_non_linear_3d: R^3 -> R^3x3, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       REQUIRE(same_cell_value(cell_value, discrete_function.get<DiscreteFunctionP0<Dimension, const DataType>>()));
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionVectorIntegrator.cpp b/tests/test_DiscreteFunctionVectorIntegrator.cpp
index 4c510542ba9b244d505b7531db8d49f0c106bc2d..60afd2dbcf3e1e730cbaf273166e0258d8ae40f2 100644
--- a/tests/test_DiscreteFunctionVectorIntegrator.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegrator.cpp
@@ -32,6 +32,9 @@
 
 TEST_CASE("DiscreteFunctionVectorIntegrator", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](const CellValue<const double>& fi, const size_t i, const auto& f) -> bool {
     for (CellId cell_id = 0; cell_id < fi.numberOfItems(); ++cell_id) {
       if (fi[cell_id] != f[cell_id][i]) {
@@ -396,4 +399,6 @@ Invalid value type: R^2)";
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
index ac516d3ff9b7d20e3cedd152f522c7f7263e8acd..01297d03df6cbadc0a7cff50546aa2737444e4d8 100644
--- a/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorIntegratorByZone.cpp
@@ -34,6 +34,9 @@
 
 TEST_CASE("DiscreteFunctionVectorIntegratorByZone", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](const CellValue<const double>& fi, const size_t i, const auto& f) -> bool {
     for (CellId cell_id = 0; cell_id < fi.numberOfItems(); ++cell_id) {
       if (fi[cell_id] != f[cell_id][i]) {
@@ -438,4 +441,6 @@ let R_scalar_non_linear_3d: R^3 -> R, x -> 2 * exp(x[0] + x[1]) + 3 * x[2];
 
     REQUIRE(i == function_id_list.size());
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionVectorInterpoler.cpp b/tests/test_DiscreteFunctionVectorInterpoler.cpp
index e47b8754d7ff7fe46d8f90d903af2efaed06be51..3a4871076739a3fc873bd0cd69547099f9f67c67 100644
--- a/tests/test_DiscreteFunctionVectorInterpoler.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpoler.cpp
@@ -29,6 +29,9 @@
 
 TEST_CASE("DiscreteFunctionVectorInterpoler", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](const CellValue<const double>& fi, const size_t i, const auto& f) -> bool {
     for (CellId cell_id = 0; cell_id < fi.numberOfItems(); ++cell_id) {
       if (fi[cell_id] != f[cell_id][i]) {
@@ -444,4 +447,6 @@ Invalid interpolation value type: R^2)";
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
index 2fe9849341741d0483202621f40cb45dbc4acc81..0547aa3cf6bfe74a27b44630a34bb1d6f9e7724b 100644
--- a/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
+++ b/tests/test_DiscreteFunctionVectorInterpolerByZone.cpp
@@ -31,6 +31,9 @@
 
 TEST_CASE("DiscreteFunctionVectorInterpolerByZone", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_cell_value = [](const CellValue<const double>& fi, const size_t i, const auto& f) -> bool {
     for (CellId cell_id = 0; cell_id < fi.numberOfItems(); ++cell_id) {
       if (fi[cell_id] != f[cell_id][i]) {
@@ -509,4 +512,6 @@ Invalid interpolation value type: R^2)";
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_InterpolateItemArray.cpp b/tests/test_InterpolateItemArray.cpp
index 6d020282ad0d0a953ca7e815357d5461f5dd3a76..61674ce2d3d5e105fb7f8f1b6322ccc0f6ff4dcd 100644
--- a/tests/test_InterpolateItemArray.cpp
+++ b/tests/test_InterpolateItemArray.cpp
@@ -26,6 +26,9 @@
 
 TEST_CASE("InterpolateItemArray", "[language]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   SECTION("interpolate on all items")
   {
     auto same_cell_array = [](auto f, auto g) -> bool {
@@ -1106,4 +1109,6 @@ let f_3d: R^3 -> (R^3), x -> (2*x, [2*x[0]-x[1], 3*x[2]-x[0], x[1]+x[2]], 0);
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_InterpolateItemValue.cpp b/tests/test_InterpolateItemValue.cpp
index f53921ed19cfdd35549b2c032dd0ce8d27620ff3..9ee0a324f01728d54f88c0d864dd5950c7cb2339 100644
--- a/tests/test_InterpolateItemValue.cpp
+++ b/tests/test_InterpolateItemValue.cpp
@@ -26,6 +26,9 @@
 
 TEST_CASE("InterpolateItemValue", "[language]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   SECTION("interpolate on all items")
   {
     auto same_item_value = [](auto f, auto g) -> bool {
@@ -1085,4 +1088,6 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3 * cos
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_ItemArrayVariantFunctionInterpoler.cpp b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
index 7ceaf2207ef53526f19511aa31415ce8efcd577a..3a2c4aadaaba0794a3ebca697739e093e712ef3e 100644
--- a/tests/test_ItemArrayVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemArrayVariantFunctionInterpoler.cpp
@@ -26,6 +26,9 @@
 
 TEST_CASE("ItemArrayVariantFunctionInterpoler", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_item_array = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     if (f.sizeOfArrays() != g.sizeOfArrays()) {
@@ -672,4 +675,6 @@ let R2x2_non_linear_3d: R^3 -> R^2x2,
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }
diff --git a/tests/test_ItemValueVariantFunctionInterpoler.cpp b/tests/test_ItemValueVariantFunctionInterpoler.cpp
index 19f53e1085fb058960737b2543c2892e8d6d9fb2..be1d4272b8019d493760d228735fa5d08985ef04 100644
--- a/tests/test_ItemValueVariantFunctionInterpoler.cpp
+++ b/tests/test_ItemValueVariantFunctionInterpoler.cpp
@@ -26,6 +26,9 @@
 
 TEST_CASE("ItemValueVariantFunctionInterpoler", "[scheme]")
 {
+  const bool stack_details = ASTNode::getStackDetails();
+  ASTNode::setStackDetails(false);
+
   auto same_item_value = [](auto f, auto g) -> bool {
     using ItemIdType = typename decltype(f)::index_type;
     for (ItemIdType item_id = 0; item_id < f.numberOfItems(); ++item_id) {
@@ -544,4 +547,6 @@ let R2x2_non_linear_3d: R^3 -> R^2x2, x -> [[2 * exp(x[0]) * sin(x[1]) + 3, sin(
       }
     }
   }
+
+  ASTNode::setStackDetails(stack_details);
 }