diff --git a/include/revng/DataLayoutAnalysis/DLATypeSystem.h b/include/revng/DataLayoutAnalysis/DLATypeSystem.h
index e221688af..2957e45d6 100644
--- a/include/revng/DataLayoutAnalysis/DLATypeSystem.h
+++ b/include/revng/DataLayoutAnalysis/DLATypeSystem.h
@@ -152,7 +152,7 @@ public:
   std::strong_ordering operator<=>(const TypeLinkTag &Other) const = default;
 
   friend void
-  writeToLog(Logger<true> &L, const dla::TypeLinkTag &T, int /* Ignore */);
+  writeToLog(Logger &L, const dla::TypeLinkTag &T, int /* Ignore */);
 
 }; // end class TypeLinkTag
 
diff --git a/include/revng/EarlyFunctionAnalysis/AnalyzeRegisterUsage.h b/include/revng/EarlyFunctionAnalysis/AnalyzeRegisterUsage.h
index e458d2416..b01601d71 100644
--- a/include/revng/EarlyFunctionAnalysis/AnalyzeRegisterUsage.h
+++ b/include/revng/EarlyFunctionAnalysis/AnalyzeRegisterUsage.h
@@ -68,8 +68,7 @@ public:
   void dump(T &Output, const char *Prefix = "") const;
 };
 
-extern template void RUAResults::dump<Logger<true>>(Logger<true> &,
-                                                    const char *) const;
+extern template void RUAResults::dump<Logger>(Logger &, const char *) const;
 
 RUAResults analyzeRegisterUsage(llvm::Function *F,
                                 const GeneratedCodeBasicInfo &,
diff --git a/include/revng/Lift/CSVOffsets.h b/include/revng/Lift/CSVOffsets.h
index c84fbd8bf..95e76dd31 100644
--- a/include/revng/Lift/CSVOffsets.h
+++ b/include/revng/Lift/CSVOffsets.h
@@ -8,7 +8,6 @@
 
 #include "revng/Support/Assert.h"
 
-template<bool StaticallyEnabled>
 class Logger;
 
 /// Different types of accesses to the CPU State Variables (CSVs), with a set of
@@ -72,7 +71,7 @@ public:
   }
 
 public:
-  friend void writeToLog(Logger<true> &L, const CSVOffsets &O, int /*Ignore*/);
+  friend void writeToLog(Logger &L, const CSVOffsets &O, int /*Ignore*/);
 
 private:
   explicit operator Kind() const { return OffsetKind; }
diff --git a/include/revng/MFP/MFP.h b/include/revng/MFP/MFP.h
index 589cc64c4..fdaf5e2be 100644
--- a/include/revng/MFP/MFP.h
+++ b/include/revng/MFP/MFP.h
@@ -22,7 +22,7 @@
 
 namespace MFP {
 
-inline Logger<> NullLogger("");
+inline Logger NullLogger("");
 
 template<typename T>
 void dump(llvm::raw_ostream &Stream, unsigned Indent, const T &Element) {
@@ -87,7 +87,7 @@ getMaximalFixedPoint(const MFIType &MFI,
                      typename MFIType::LatticeElement ExtremalValue,
                      const std::vector<typename MFIType::Label> &ExtremalLabels,
                      const std::vector<typename MFIType::Label> &InitialNodes,
-                     Logger<> &Logger = NullLogger) {
+                     Logger &Logger = NullLogger) {
   using Label = typename MFIType::Label;
   using LatticeElement = typename MFIType::LatticeElement;
 
@@ -111,13 +111,13 @@ getMaximalFixedPoint(const MFIType &MFI,
 
   if (Logger.isEnabled()) {
     revng_log(Logger, "Initializing extremal labels");
-    LoggerIndent<> Indent(Logger);
+    LoggerIndent Indent(Logger);
     Logger << "Extremal value:\n";
     MFP::dump(*Logger.getAsLLVMStream(), 1, ExtremalValue);
     Logger << DoLog;
 
     Logger << "Extremal labels:" << DoLog;
-    LoggerIndent<> Indent2(Logger);
+    LoggerIndent Indent2(Logger);
     for (Label ExtremalLabel : ExtremalLabels) {
       MFP::dumpLabel(*Logger.getAsLLVMStream(), ExtremalLabel);
       Logger << DoLog;
@@ -129,13 +129,13 @@ getMaximalFixedPoint(const MFIType &MFI,
 
   if (Logger.isEnabled()) {
     revng_log(Logger, "Initializing initial nodes");
-    LoggerIndent<> Indent(Logger);
+    LoggerIndent Indent(Logger);
     Logger << "Initial value:\n";
     MFP::dump(*Logger.getAsLLVMStream(), 1, InitialValue);
     Logger << DoLog;
 
     Logger << "Initial labels:" << DoLog;
-    LoggerIndent<> Indent2(Logger);
+    LoggerIndent Indent2(Logger);
     for (Label InitialNode : InitialNodes) {
       MFP::dumpLabel(*Logger.getAsLLVMStream(), InitialNode);
       Logger << DoLog;
@@ -163,7 +163,7 @@ getMaximalFixedPoint(const MFIType &MFI,
 
   // Step 2 iterations
   revng_log(Logger, "Starting the iterations");
-  LoggerIndent<> Indent(Logger);
+  LoggerIndent Indent(Logger);
 
   unsigned IterationIndex = 0;
   while (not Worklist.empty()) {
@@ -180,7 +180,7 @@ getMaximalFixedPoint(const MFIType &MFI,
       Logger << DoLog;
     }
 
-    LoggerIndent<> Indent(Logger);
+    LoggerIndent Indent(Logger);
 
     if (Logger.isEnabled()) {
       Logger << "Initial value:\n";
@@ -199,7 +199,7 @@ getMaximalFixedPoint(const MFIType &MFI,
     Logger.unindent();
 
     if (Logger.isEnabled()) {
-      LoggerIndent<> Indent(Logger);
+      LoggerIndent Indent(Logger);
       Logger << "New final value:\n";
       MFP::dump(*Logger.getAsLLVMStream(), 1, New);
       Logger << DoLog;
@@ -212,7 +212,7 @@ getMaximalFixedPoint(const MFIType &MFI,
 
     // Enqueue successors that need to be recomputed
     revng_log(Logger, "Processing successors:");
-    LoggerIndent<> Indent2(Logger);
+    LoggerIndent Indent2(Logger);
     for (Label Successor : successors<GT>(Start)) {
       auto &SuccessorResults = AnalysisResult.at(Successor);
 
@@ -222,12 +222,12 @@ getMaximalFixedPoint(const MFIType &MFI,
         Logger << DoLog;
 
         Logger << "Initial value:\n";
-        LoggerIndent<> Indent(Logger);
+        LoggerIndent Indent(Logger);
         Logger << DoLog;
         MFP::dump(*Logger.getAsLLVMStream(), 1, SuccessorResults.InValue);
         Logger << DoLog;
       }
-      LoggerIndent<> Indent(Logger);
+      LoggerIndent Indent(Logger);
 
       if (not MFI.isLessOrEqual(LabelAnalysis.OutValue,
                                 SuccessorResults.InValue)) {
@@ -265,7 +265,7 @@ getMaximalFixedPoint(const MFI &Instance,
                      typename MFI::LatticeElement InitialValue,
                      typename MFI::LatticeElement ExtremalValue,
                      const std::vector<typename MFI::Label> &ExtremalLabels,
-                     Logger<> &Logger = NullLogger) {
+                     Logger &Logger = NullLogger) {
   using Label = typename MFI::Label;
   std::vector<Label> InitialNodes(ExtremalLabels);
 
diff --git a/include/revng/Model/Importer/Binary/BinaryImporterHelper.h b/include/revng/Model/Importer/Binary/BinaryImporterHelper.h
index c3a21be95..4545885e4 100644
--- a/include/revng/Model/Importer/Binary/BinaryImporterHelper.h
+++ b/include/revng/Model/Importer/Binary/BinaryImporterHelper.h
@@ -16,14 +16,14 @@ class BinaryImporterHelper {
 protected:
   model::Binary &Binary;
   uint64_t BaseAddress = 0;
-  Logger<> &Logger;
+  Logger &Logger;
   llvm::SmallVector<const model::Segment *> ExecutableSegments;
   bool SegmentsInitialized = false;
 
 public:
   BinaryImporterHelper(model::Binary &Binary,
                        uint64_t BaseAddress,
-                       ::Logger<> &Logger) :
+                       ::Logger &Logger) :
     Binary(Binary), BaseAddress(BaseAddress), Logger(Logger) {}
 
 public:
diff --git a/include/revng/Model/RawBinaryView.h b/include/revng/Model/RawBinaryView.h
index 4e9c7e0f4..a10b9ef0c 100644
--- a/include/revng/Model/RawBinaryView.h
+++ b/include/revng/Model/RawBinaryView.h
@@ -77,5 +77,4 @@ public:
 private:
   std::pair<const model::Segment *, uint64_t>
   findOffsetInSegment(MetaAddress Address, uint64_t Size) const;
-
 };
diff --git a/include/revng/Model/VerifyHelper.h b/include/revng/Model/VerifyHelper.h
index 7ed120d7f..1408ba5c2 100644
--- a/include/revng/Model/VerifyHelper.h
+++ b/include/revng/Model/VerifyHelper.h
@@ -16,7 +16,7 @@
 #include "revng/Support/Debug.h"
 #include "revng/TupleTree/TupleTree.h"
 
-inline Logger<> ModelVerifyLogger("model-verify");
+inline Logger ModelVerifyLogger("model-verify");
 
 namespace model {
 class TypeDefinition;
diff --git a/include/revng/Pipeline/Context.h b/include/revng/Pipeline/Context.h
index 6809d2394..2c9b980fb 100644
--- a/include/revng/Pipeline/Context.h
+++ b/include/revng/Pipeline/Context.h
@@ -25,8 +25,8 @@
 
 namespace pipeline {
 
-extern Logger<> ExplanationLogger;
-extern Logger<> CommandLogger;
+extern Logger ExplanationLogger;
+extern Logger CommandLogger;
 
 /// A class that contains every object that has a lifetime longer than a
 /// pipeline.
diff --git a/include/revng/Pipeline/LLVMContainer.h b/include/revng/Pipeline/LLVMContainer.h
index e3eb66266..07bb512c7 100644
--- a/include/revng/Pipeline/LLVMContainer.h
+++ b/include/revng/Pipeline/LLVMContainer.h
@@ -7,7 +7,7 @@
 #include "revng/Pipeline/ContainerEnumerator.h"
 #include "revng/Pipeline/Pipe.h"
 
-inline Logger<> ModuleStatisticsLogger("module-statistics");
+inline Logger ModuleStatisticsLogger("module-statistics");
 
 namespace pipeline {
 
diff --git a/include/revng/Pipeline/Pipe.h b/include/revng/Pipeline/Pipe.h
index 4f9cdf360..95c6d908a 100644
--- a/include/revng/Pipeline/Pipe.h
+++ b/include/revng/Pipeline/Pipe.h
@@ -30,7 +30,7 @@
 #include "revng/Pipeline/Target.h"
 #include "revng/Support/Debug.h"
 
-inline Logger<> InvalidationLog("invalidation");
+inline Logger InvalidationLog("invalidation");
 
 namespace pipeline {
 
@@ -179,7 +179,7 @@ public:
                   const ContainerToTargetsMap &Target) const override {
     revng_log(InvalidationLog,
               "Computing requirements for " << this->Invokable.getName());
-    LoggerIndent<> Imdent(InvalidationLog);
+    LoggerIndent Imdent(InvalidationLog);
 
     const auto &Contracts = Invokable.getPipe().getContract();
     ContainerToTargetsMap Input = Target;
@@ -327,7 +327,7 @@ public:
                                   llvm::StringRef GlobalName,
                                   const TupleTreePath &Path,
                                   ContainerToTargetsMap &Out,
-                                  Logger<> &Log) const;
+                                  Logger &Log) const;
 
   void remove(const ContainerToTargetsMap &Map);
 
diff --git a/include/revng/Pipeline/Step.h b/include/revng/Pipeline/Step.h
index e748fc0ab..3d53e21ca 100644
--- a/include/revng/Pipeline/Step.h
+++ b/include/revng/Pipeline/Step.h
@@ -106,7 +106,7 @@ public:
   void registerTargetsDependingOn(llvm::StringRef GlobalName,
                                   const TupleTreePath &Path,
                                   TargetInStepSet &Out,
-                                  Logger<> &Log) const;
+                                  Logger &Log) const;
 
 private:
   llvm::Error loadInvalidationMetadataImpl(const revng::DirectoryPath &Path,
diff --git a/include/revng/RestructureCFG/GenerateAst.h b/include/revng/RestructureCFG/GenerateAst.h
index 9a00306ef..d0f73d76c 100644
--- a/include/revng/RestructureCFG/GenerateAst.h
+++ b/include/revng/RestructureCFG/GenerateAst.h
@@ -37,13 +37,13 @@
 
 class GHASTDumper {
   size_t GraphLogCounter;
-  Logger<> &Logger;
+  Logger &Logger;
   std::string FunctionName;
   const ASTTree &AST;
   std::string FolderName;
 
 public:
-  GHASTDumper(::Logger<> &Logger,
+  GHASTDumper(::Logger &Logger,
               const llvm::Function &F,
               const ASTTree &TheAST,
               const std::string &FolderName) :
diff --git a/include/revng/RestructureCFG/Utils.h b/include/revng/RestructureCFG/Utils.h
index 07aa8dfff..a7405a9e6 100644
--- a/include/revng/RestructureCFG/Utils.h
+++ b/include/revng/RestructureCFG/Utils.h
@@ -16,7 +16,7 @@
 
 // TODO: move the definition of this object in an unique place, to avoid using
 // an extern declaration
-extern Logger<> CombLogger;
+extern Logger CombLogger;
 
 template<class NodeT>
 using RegionCFGEdge = typename BasicBlockNode<NodeT>::EdgeDescriptor;
diff --git a/include/revng/Support/Debug.h b/include/revng/Support/Debug.h
index 47e2c4ec2..586a33d62 100644
--- a/include/revng/Support/Debug.h
+++ b/include/revng/Support/Debug.h
@@ -38,7 +38,6 @@ struct LogTerminator {
 ///
 /// The typical usage of this class is to be a static global variable in a
 /// translation unit.
-template<bool StaticEnabled = true>
 class Logger {
 private:
   static unsigned IndentLevel;
@@ -50,7 +49,7 @@ public:
   void unindent(unsigned Level = 1);
   void setIndentation(unsigned Level);
 
-  bool isEnabled() const { return StaticEnabled && Enabled; }
+  bool isEnabled() const { return Enabled; }
   llvm::StringRef name() const { return Name; }
   // TODO: allow optional description
   llvm::StringRef description() const { return ""; }
@@ -74,11 +73,10 @@ public:
     return *this;
   }
 
-  template<bool X>
-  friend void writeToLog(Logger<X> &This, const LogTerminator &T, int Ignore);
+  friend void writeToLog(Logger &This, const LogTerminator &T, int Ignore);
 
-  template<bool X, typename T, typename LowPrio>
-  friend void writeToLog(Logger<X> &This, const T Other, LowPrio Ignore);
+  template<typename T, typename LowPrio>
+  friend void writeToLog(Logger &This, const T Other, LowPrio Ignore);
 
   std::unique_ptr<llvm::raw_ostream> getAsLLVMStream() {
     if (Enabled)
@@ -96,14 +94,13 @@ private:
 };
 
 /// Indent all loggers within the scope of this object
-template<bool StaticEnabled = true>
 class LoggerIndent {
 public:
-  LoggerIndent(Logger<StaticEnabled> &L) : L(L) { L.indent(); }
+  LoggerIndent(Logger &L) : L(L) { L.indent(); }
   ~LoggerIndent() { L.unindent(); }
 
 private:
-  Logger<StaticEnabled> &L;
+  Logger &L;
 };
 
 /// Emit a message for the specified logger upon return
@@ -111,14 +108,13 @@ private:
 /// You can create an instance of this object associated to a Logger, so that
 /// when the object goes out of scope (typically, on return), the emit method
 /// will be invoked.
-template<bool StaticEnabled = true>
 class LogOnReturn {
 public:
-  LogOnReturn(Logger<StaticEnabled> &L) : L(L) {}
+  LogOnReturn(Logger &L) : L(L) {}
   ~LogOnReturn() { L.flush(); }
 
 private:
-  Logger<StaticEnabled> &L;
+  Logger &L;
 };
 
 /// The catch-all function for logging, it can log any type not already handled
@@ -135,27 +131,24 @@ private:
 /// overloads should never have overlapping types for \p Other.
 ///
 /// For an example see the next specialization.
-template<bool X, typename T, typename LowPrio>
-inline void writeToLog(Logger<X> &This, const T Other, LowPrio) {
+template<typename T, typename LowPrio>
+inline void writeToLog(Logger &This, const T Other, LowPrio) {
   if (This.isEnabled())
     This.Buffer << Other;
 }
 
 /// Specialization of writeToLog to emit a message
-template<bool X>
-inline void writeToLog(Logger<X> &This, const LogTerminator &LineInfo, int) {
+inline void writeToLog(Logger &This, const LogTerminator &LineInfo, int) {
   This.flush(LineInfo);
 }
 
 /// Specialization for llvm::StringRef
-template<bool X>
-inline void writeToLog(Logger<X> &This, const llvm::StringRef &S, int Ign) {
+inline void writeToLog(Logger &This, const llvm::StringRef &S, int Ign) {
   writeToLog(This, S.str(), Ign);
 }
 
 /// Specialization for llvm::Error
-template<bool X>
-inline void writeToLog(Logger<X> &This, const llvm::Error &Error, int Ign) {
+inline void writeToLog(Logger &This, const llvm::Error &Error, int Ign) {
   std::string Message;
   {
     llvm::raw_string_ostream Stream(Message);
@@ -203,9 +196,9 @@ private:
     }                            \
   } while (0)
 
-extern Logger<> NRALog;
-extern Logger<> PassesLog;
-extern Logger<> ReleaseLog;
-extern Logger<> VerifyLog;
+extern Logger NRALog;
+extern Logger PassesLog;
+extern Logger ReleaseLog;
+extern Logger VerifyLog;
 
 void writeToFile(llvm::StringRef What, llvm::StringRef Path) debug_function;
diff --git a/include/revng/Support/IRHelpers.h b/include/revng/Support/IRHelpers.h
index 671e5fff2..de09f5bd7 100644
--- a/include/revng/Support/IRHelpers.h
+++ b/include/revng/Support/IRHelpers.h
@@ -503,7 +503,7 @@ inline llvm::BasicBlock *blockByName(llvm::Function *F, const char *Name) {
 /// Specialization of writeToLog for llvm::Value-derived types
 template<typename T>
   requires std::derived_from<llvm::Value, std::remove_const_t<T>>
-inline void writeToLog(Logger<true> &This, T *I, int) {
+inline void writeToLog(Logger &This, T *I, int) {
   if (I != nullptr)
     This << getName(I);
   else
@@ -1049,8 +1049,8 @@ concept LLVMRawOStreamDumpable = not ValueLikePrintable<T>
                                                  llvm::raw_ostream &>());
                                      };
 
-template<bool B, LLVMRawOStreamDumpable Dumpable>
-inline void writeToLog(Logger<B> &L, const Dumpable &P, int /* Ignore */) {
+template<LLVMRawOStreamDumpable Dumpable>
+inline void writeToLog(Logger &L, const Dumpable &P, int /* Ignore */) {
   if (L.isEnabled()) {
     llvm::SmallString<32> Buffer;
     {
diff --git a/include/revng/TupleTree/TupleTreeReference.h b/include/revng/TupleTree/TupleTreeReference.h
index b7a7406eb..6edcff712 100644
--- a/include/revng/TupleTree/TupleTreeReference.h
+++ b/include/revng/TupleTree/TupleTreeReference.h
@@ -224,10 +224,9 @@ struct llvm::yaml::ScalarTraits<T> {
 };
 
 /// Specialization for the std::variant we have in TupleTreeReference
-template<bool X, typename T>
-inline void writeToLog(Logger<X> &This,
-                       const std::variant<T *, const T *> &Var,
-                       int Ignored) {
+template<typename T>
+inline void
+writeToLog(Logger &This, const std::variant<T *, const T *> &Var, int Ignored) {
   if (Var.index() == std::variant_npos)
     writeToLog(This, llvm::StringRef("std::variant_npos"), Ignored);
   else if (std::holds_alternative<T *>(Var))
diff --git a/include/revng/ValueMaterializer/Helpers.h b/include/revng/ValueMaterializer/Helpers.h
index 40f73c44d..7065693ac 100644
--- a/include/revng/ValueMaterializer/Helpers.h
+++ b/include/revng/ValueMaterializer/Helpers.h
@@ -13,7 +13,7 @@ namespace llvm {
 class APInt;
 }
 
-inline Logger<> ValueMaterializerLogger("value-materializer");
+inline Logger ValueMaterializerLogger("value-materializer");
 
 std::string aviFormatter(const llvm::APInt &Value);
 
diff --git a/lib/Backend/DecompileFunction.cpp b/lib/Backend/DecompileFunction.cpp
index 03885fcf0..81913a114 100644
--- a/lib/Backend/DecompileFunction.cpp
+++ b/lib/Backend/DecompileFunction.cpp
@@ -94,8 +94,8 @@ using TokenMapT = std::map<const llvm::Value *, std::string>;
 using ModelTypesMap = std::map<const llvm::Value *,
                                const model::UpcastableType>;
 
-static Logger<> Log{ "c-backend" };
-static Logger<> VisitLog{ "c-backend-visit-order" };
+static Logger Log{ "c-backend" };
+static Logger VisitLog{ "c-backend-visit-order" };
 
 static bool isStackFrameDecl(const llvm::Value *I) {
   auto *Call = dyn_cast_or_null<llvm::CallInst>(I);
diff --git a/lib/Canonicalize/DiscardBrokenDebugInformation.cpp b/lib/Canonicalize/DiscardBrokenDebugInformation.cpp
index 047456a6b..c230d3d47 100644
--- a/lib/Canonicalize/DiscardBrokenDebugInformation.cpp
+++ b/lib/Canonicalize/DiscardBrokenDebugInformation.cpp
@@ -11,7 +11,7 @@
 #include "revng/Support/Error.h"
 #include "revng/Support/IRHelpers.h"
 
-static Logger<> Log("discarded-debug-information");
+static Logger Log("discarded-debug-information");
 
 struct DiscardBrokenDebugInformation : public llvm::FunctionPass {
 public:
diff --git a/lib/Canonicalize/ExitSSAPass.cpp b/lib/Canonicalize/ExitSSAPass.cpp
index c56ff1174..957745fda 100644
--- a/lib/Canonicalize/ExitSSAPass.cpp
+++ b/lib/Canonicalize/ExitSSAPass.cpp
@@ -33,7 +33,7 @@
 
 using namespace llvm;
 
-static Logger<> Log{ "exit-ssa" };
+static Logger Log{ "exit-ssa" };
 
 struct ExitSSAPass : public FunctionPass {
 public:
diff --git a/lib/Canonicalize/FoldModelGEP.cpp b/lib/Canonicalize/FoldModelGEP.cpp
index 92fd1c8b3..449dc102a 100644
--- a/lib/Canonicalize/FoldModelGEP.cpp
+++ b/lib/Canonicalize/FoldModelGEP.cpp
@@ -18,7 +18,7 @@
 #include "revng/Support/DecompilationHelpers.h"
 #include "revng/Support/YAMLTraits.h"
 
-static Logger<> Log{ "fold-model-gep" };
+static Logger Log{ "fold-model-gep" };
 
 struct FoldModelGEP : public llvm::FunctionPass {
 public:
diff --git a/lib/Canonicalize/ImplicitModelCastPass.cpp b/lib/Canonicalize/ImplicitModelCastPass.cpp
index 53e78ab42..3f80cffc3 100644
--- a/lib/Canonicalize/ImplicitModelCastPass.cpp
+++ b/lib/Canonicalize/ImplicitModelCastPass.cpp
@@ -24,7 +24,7 @@
 #include "revng/TypeNames/LLVMTypeNames.h"
 #include "revng/TypeNames/ModelCBuilder.h"
 
-static Logger<> Log{ "implicit-model-cast" };
+static Logger Log{ "implicit-model-cast" };
 
 using ValueTypeMap = std::map<const llvm::Value *, const model::UpcastableType>;
 using ModelPromotedTypesMap = std::map<const llvm::Instruction *, ValueTypeMap>;
diff --git a/lib/Canonicalize/LoopRewriteWithCanonicalIV.cpp b/lib/Canonicalize/LoopRewriteWithCanonicalIV.cpp
index f38abf3d4..302fb01d9 100644
--- a/lib/Canonicalize/LoopRewriteWithCanonicalIV.cpp
+++ b/lib/Canonicalize/LoopRewriteWithCanonicalIV.cpp
@@ -19,7 +19,7 @@
 
 using namespace llvm;
 
-static Logger<> Log{ "loop-rewrite-with-canonical-induction-variable" };
+static Logger Log{ "loop-rewrite-with-canonical-induction-variable" };
 
 class LoopRewriteIV {
 public:
diff --git a/lib/Canonicalize/MakeModelCastPass.cpp b/lib/Canonicalize/MakeModelCastPass.cpp
index 654b37197..db7d69c79 100644
--- a/lib/Canonicalize/MakeModelCastPass.cpp
+++ b/lib/Canonicalize/MakeModelCastPass.cpp
@@ -25,7 +25,7 @@
 #include "revng/Support/YAMLTraits.h"
 #include "revng/TypeNames/LLVMTypeNames.h"
 
-static Logger<> Log{ "make-model-cast" };
+static Logger Log{ "make-model-cast" };
 
 using namespace llvm;
 
diff --git a/lib/Canonicalize/MakeModelGEPPass.cpp b/lib/Canonicalize/MakeModelGEPPass.cpp
index 4c8f428f7..aee3f6f3c 100644
--- a/lib/Canonicalize/MakeModelGEPPass.cpp
+++ b/lib/Canonicalize/MakeModelGEPPass.cpp
@@ -70,7 +70,7 @@ using llvm::Value;
 using model::CABIFunctionDefinition;
 using model::RawFunctionDefinition;
 
-static Logger<> ModelGEPLog{ "make-model-gep" };
+static Logger ModelGEPLog{ "make-model-gep" };
 
 // This struct represents an llvm::Value for which it has been determined that
 // it has pointer semantic on the model, along with the type of the pointee.
diff --git a/lib/Canonicalize/PeepholeOptimizationPass.cpp b/lib/Canonicalize/PeepholeOptimizationPass.cpp
index 3a06ec0cd..298de1a53 100644
--- a/lib/Canonicalize/PeepholeOptimizationPass.cpp
+++ b/lib/Canonicalize/PeepholeOptimizationPass.cpp
@@ -21,7 +21,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("peephole-opt-for-decompilation");
+static Logger Log("peephole-opt-for-decompilation");
 
 struct PeepholeOptimizationPass : public FunctionPass {
 public:
diff --git a/lib/Canonicalize/SimplifySwitchPass.cpp b/lib/Canonicalize/SimplifySwitchPass.cpp
index 3a83ce84d..ee3b04037 100644
--- a/lib/Canonicalize/SimplifySwitchPass.cpp
+++ b/lib/Canonicalize/SimplifySwitchPass.cpp
@@ -31,7 +31,7 @@
 using namespace llvm;
 using namespace ::revng::kinds;
 
-static Logger<> Log("switch-opt");
+static Logger Log("switch-opt");
 
 class RawBinaryMemoryOracle final : public MemoryOracle {
 private:
diff --git a/lib/Canonicalize/SwitchToStatements.cpp b/lib/Canonicalize/SwitchToStatements.cpp
index 9b928d5cd..6bc2fcf01 100644
--- a/lib/Canonicalize/SwitchToStatements.cpp
+++ b/lib/Canonicalize/SwitchToStatements.cpp
@@ -41,7 +41,7 @@
 #include "revng/Support/Debug.h"
 #include "revng/Support/DecompilationHelpers.h"
 
-static Logger<> Log{ "switch-to-statements" };
+static Logger Log{ "switch-to-statements" };
 
 using namespace llvm;
 
diff --git a/lib/Clifter/Clifter.cpp b/lib/Clifter/Clifter.cpp
index ce9127d97..4bf14c158 100644
--- a/lib/Clifter/Clifter.cpp
+++ b/lib/Clifter/Clifter.cpp
@@ -27,8 +27,8 @@ using namespace clift;
 
 namespace {
 
-static Logger<> BasicBlockLog{ "llvm-to-clift-basic-blocks" };
-static Logger<> ExpressionLog{ "llvm-to-clift-expressions" };
+static Logger BasicBlockLog{ "llvm-to-clift-basic-blocks" };
+static Logger ExpressionLog{ "llvm-to-clift-expressions" };
 
 // These helper functions are used to save insertion points *after* an
 // operation, while the usual operating mode of `OpBuilder::InsertPoint` is
diff --git a/lib/DataLayoutAnalysis/Backend/DLAMakeModelTypes.cpp b/lib/DataLayoutAnalysis/Backend/DLAMakeModelTypes.cpp
index 0414f6e74..6b8395718 100644
--- a/lib/DataLayoutAnalysis/Backend/DLAMakeModelTypes.cpp
+++ b/lib/DataLayoutAnalysis/Backend/DLAMakeModelTypes.cpp
@@ -25,9 +25,9 @@
 using namespace model;
 using namespace dla;
 
-static Logger<> Log("dla-make-model");
-static Logger<> ModelLog("dla-dump-model");
-static Logger<> TypeMapLog("dla-type-map");
+static Logger Log("dla-make-model");
+static Logger ModelLog("dla-dump-model");
+static Logger TypeMapLog("dla-type-map");
 
 using model::UpcastableType;
 using LTSN = LayoutTypeSystemNode;
diff --git a/lib/DataLayoutAnalysis/Backend/DLAUpdateModelTypes.cpp b/lib/DataLayoutAnalysis/Backend/DLAUpdateModelTypes.cpp
index 268f372ec..6521248da 100644
--- a/lib/DataLayoutAnalysis/Backend/DLAUpdateModelTypes.cpp
+++ b/lib/DataLayoutAnalysis/Backend/DLAUpdateModelTypes.cpp
@@ -40,8 +40,8 @@ using namespace dla;
 
 using llvm::dyn_cast;
 
-static Logger<> Log("dla-update-model-funcs");
-static Logger<> ModelLog("dla-dump-model-with-funcs");
+static Logger Log("dla-update-model-funcs");
+static Logger ModelLog("dla-dump-model-with-funcs");
 
 using model::PrimitiveKind::Generic;
 using model::PrimitiveKind::PointerOrNumber;
diff --git a/lib/DataLayoutAnalysis/DLAPass.cpp b/lib/DataLayoutAnalysis/DLAPass.cpp
index ada81e761..cddb46739 100644
--- a/lib/DataLayoutAnalysis/DLAPass.cpp
+++ b/lib/DataLayoutAnalysis/DLAPass.cpp
@@ -17,7 +17,7 @@
 
 char DLAPass::ID = 0;
 
-static Logger<> BuilderLog("dla-builder-log");
+static Logger BuilderLog("dla-builder-log");
 
 using Register = llvm::RegisterPass<DLAPass>;
 static ::Register X("dla", "Data Layout Analysis Pass", false, false);
diff --git a/lib/DataLayoutAnalysis/DLATypeSystem.cpp b/lib/DataLayoutAnalysis/DLATypeSystem.cpp
index a67f1e79b..de4ff033e 100644
--- a/lib/DataLayoutAnalysis/DLATypeSystem.cpp
+++ b/lib/DataLayoutAnalysis/DLATypeSystem.cpp
@@ -25,7 +25,7 @@ using namespace llvm;
 
 using NodeAllocatorT = SpecificBumpPtrAllocator<dla::LayoutTypeSystemNode>;
 
-static Logger<> CollapsedNodePrinter("dla-print-collapsed-in-dot");
+static Logger CollapsedNodePrinter("dla-print-collapsed-in-dot");
 
 void *operator new(size_t, NodeAllocatorT &NodeAllocator);
 void *operator new(size_t, NodeAllocatorT &NodeAllocator) {
@@ -289,7 +289,7 @@ static void fixPredSucc(LayoutTypeSystemNode *From,
   }
 }
 
-static Logger<> MergeLog("dla-merge-nodes");
+static Logger MergeLog("dla-merge-nodes");
 
 void LayoutTypeSystem::mergeNodes(llvm::ArrayRef<LayoutTypeSystemNode *>
                                     ToMerge) {
@@ -489,7 +489,7 @@ void LayoutTypeSystem::dropOutgoingEdges(LayoutTypeSystemNode *N) {
     It = eraseEdge(N, It);
 }
 
-static Logger<> VerifyDLALog("dla-verify-strict");
+static Logger VerifyDLALog("dla-verify-strict");
 
 bool LayoutTypeSystem::verifyConsistency() const {
   for (LayoutTypeSystemNode *NodePtr : Layouts) {
@@ -805,7 +805,7 @@ void TSDebugPrinter::printNodeContent(const LayoutTypeSystem &TS,
   File << "]" << DoRet;
 }
 
-void writeToLog(Logger<true> &Log, const TypeLinkTag &Tag, int /* Ignore */) {
+void writeToLog(Logger &Log, const TypeLinkTag &Tag, int /* Ignore */) {
 
   switch (Tag.getKind()) {
   case TypeLinkTag::LK_Equality: {
diff --git a/lib/DataLayoutAnalysis/Middleend/ArrangeAccessesHierarchically.cpp b/lib/DataLayoutAnalysis/Middleend/ArrangeAccessesHierarchically.cpp
index 5a179e19b..d6e54f3a6 100644
--- a/lib/DataLayoutAnalysis/Middleend/ArrangeAccessesHierarchically.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/ArrangeAccessesHierarchically.cpp
@@ -22,7 +22,7 @@
 #include "DLAStep.h"
 #include "FieldSizeComputation.h"
 
-static Logger<> Log{ "sort-accesses-hierarchically" };
+static Logger Log{ "sort-accesses-hierarchically" };
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/CollapseSCC.cpp b/lib/DataLayoutAnalysis/Middleend/CollapseSCC.cpp
index 398de038d..9ff845547 100644
--- a/lib/DataLayoutAnalysis/Middleend/CollapseSCC.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/CollapseSCC.cpp
@@ -21,7 +21,7 @@
 
 using namespace llvm;
 
-static Logger<> LogVerbose("dla-collapse-verbose");
+static Logger LogVerbose("dla-collapse-verbose");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/DLACollapseSingleChild.cpp b/lib/DataLayoutAnalysis/Middleend/DLACollapseSingleChild.cpp
index 61e4f028b..8108ae745 100644
--- a/lib/DataLayoutAnalysis/Middleend/DLACollapseSingleChild.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/DLACollapseSingleChild.cpp
@@ -16,7 +16,7 @@ using PointerFilterT = EdgeFilteredGraph<LTSN *, dla::isPointerEdge>;
 
 using namespace llvm;
 
-static Logger<> Log("dla-collapse-single-child");
+static Logger Log("dla-collapse-single-child");
 
 namespace dla {
 bool CollapseSingleChild::collapseSingle(LayoutTypeSystem &TS,
diff --git a/lib/DataLayoutAnalysis/Middleend/DLAComputeUpperMemberAccess.cpp b/lib/DataLayoutAnalysis/Middleend/DLAComputeUpperMemberAccess.cpp
index d80dc6f9a..0f8df9d0f 100644
--- a/lib/DataLayoutAnalysis/Middleend/DLAComputeUpperMemberAccess.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/DLAComputeUpperMemberAccess.cpp
@@ -20,7 +20,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("dla-compute-upper-member-access");
+static Logger Log("dla-compute-upper-member-access");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/DLAPruneLayoutNodesWithoutLayout.cpp b/lib/DataLayoutAnalysis/Middleend/DLAPruneLayoutNodesWithoutLayout.cpp
index 26c314f87..70769585b 100644
--- a/lib/DataLayoutAnalysis/Middleend/DLAPruneLayoutNodesWithoutLayout.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/DLAPruneLayoutNodesWithoutLayout.cpp
@@ -15,7 +15,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("dla-prune");
+static Logger Log("dla-prune");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/DLAStep.cpp b/lib/DataLayoutAnalysis/Middleend/DLAStep.cpp
index 331d6223b..26ad748da 100644
--- a/lib/DataLayoutAnalysis/Middleend/DLAStep.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/DLAStep.cpp
@@ -68,8 +68,8 @@ static std::string getStepNameFromID(const void *ID) {
     revng_abort("Unexpected ID for DLAStep");
 }
 
-static Logger<> DLAStepManagerLog("dla-step-manager");
-static Logger<> DLADumpDot("dla-step-dump-dot");
+static Logger DLAStepManagerLog("dla-step-manager");
+static Logger DLADumpDot("dla-step-dump-dot");
 
 [[nodiscard]] bool StepManager::addStep(std::unique_ptr<Step> S) {
   const void *StepID = S->getStepID();
diff --git a/lib/DataLayoutAnalysis/Middleend/DeduplicateFields.cpp b/lib/DataLayoutAnalysis/Middleend/DeduplicateFields.cpp
index fd8445891..3509eac10 100644
--- a/lib/DataLayoutAnalysis/Middleend/DeduplicateFields.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/DeduplicateFields.cpp
@@ -32,8 +32,8 @@ using NonPointerFilterT = EdgeFilteredGraph<LTSN *, dla::isNotPointerEdge>;
 
 using namespace llvm;
 
-static Logger<> Log("dla-deduplicate-union-fields");
-static Logger<> CmpLog("dla-duf-comparisons");
+static Logger Log("dla-deduplicate-union-fields");
+static Logger CmpLog("dla-duf-comparisons");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/MergePointeesOfPointerUnion.cpp b/lib/DataLayoutAnalysis/Middleend/MergePointeesOfPointerUnion.cpp
index 5c98e633a..410839a9c 100644
--- a/lib/DataLayoutAnalysis/Middleend/MergePointeesOfPointerUnion.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/MergePointeesOfPointerUnion.cpp
@@ -20,7 +20,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("dla-merge-pointees-of-ptr-union");
+static Logger Log("dla-merge-pointees-of-ptr-union");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/MergePointerNodes.cpp b/lib/DataLayoutAnalysis/Middleend/MergePointerNodes.cpp
index 8ba039b85..e2d315cff 100644
--- a/lib/DataLayoutAnalysis/Middleend/MergePointerNodes.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/MergePointerNodes.cpp
@@ -10,7 +10,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("dla-merge-pointer-nodes");
+static Logger Log("dla-merge-pointer-nodes");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/RemoveBackedges.cpp b/lib/DataLayoutAnalysis/Middleend/RemoveBackedges.cpp
index 9418a9903..45d854f4a 100644
--- a/lib/DataLayoutAnalysis/Middleend/RemoveBackedges.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/RemoveBackedges.cpp
@@ -21,7 +21,7 @@
 
 #include "RemoveBackedges.h"
 
-static Logger<> Log("dla-remove-backedges");
+static Logger Log("dla-remove-backedges");
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/RemoveInvalidStrideEdges.cpp b/lib/DataLayoutAnalysis/Middleend/RemoveInvalidStrideEdges.cpp
index 8990c6bf6..692d893f6 100644
--- a/lib/DataLayoutAnalysis/Middleend/RemoveInvalidStrideEdges.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/RemoveInvalidStrideEdges.cpp
@@ -9,7 +9,7 @@
 #include "DLAStep.h"
 #include "FieldSizeComputation.h"
 
-static Logger<> Log{ "dla-remove-stride-edges" };
+static Logger Log{ "dla-remove-stride-edges" };
 
 namespace dla {
 
diff --git a/lib/DataLayoutAnalysis/Middleend/SimplifyInstanceAtOffset0.cpp b/lib/DataLayoutAnalysis/Middleend/SimplifyInstanceAtOffset0.cpp
index fd041ea87..c0c3117fe 100644
--- a/lib/DataLayoutAnalysis/Middleend/SimplifyInstanceAtOffset0.cpp
+++ b/lib/DataLayoutAnalysis/Middleend/SimplifyInstanceAtOffset0.cpp
@@ -32,7 +32,7 @@ using InverseInstanceT = llvm::Inverse<InstanceT>;
 using CPointerT = EdgeFilteredGraph<const dla::LayoutTypeSystemNode *,
                                     dla::isPointerEdge>;
 
-static Logger<> Log{ "dla-simplify-instance-off0" };
+static Logger Log{ "dla-simplify-instance-off0" };
 
 namespace dla {
 
diff --git a/lib/EarlyFunctionAnalysis/AnalyzeRegisterUsage.cpp b/lib/EarlyFunctionAnalysis/AnalyzeRegisterUsage.cpp
index f4b97587f..38c2cd3a1 100644
--- a/lib/EarlyFunctionAnalysis/AnalyzeRegisterUsage.cpp
+++ b/lib/EarlyFunctionAnalysis/AnalyzeRegisterUsage.cpp
@@ -28,12 +28,11 @@
 
 using namespace llvm;
 
-static Logger<> Log("rua-analyses");
+static Logger Log("rua-analyses");
 
 namespace efa {
 
-template void RUAResults::dump<Logger<true>>(Logger<true> &,
-                                             const char *) const;
+template void RUAResults::dump<Logger>(Logger &, const char *) const;
 
 struct CallSite {
   using Node = rua::Function::Node;
diff --git a/lib/EarlyFunctionAnalysis/AttachDebugInfo.cpp b/lib/EarlyFunctionAnalysis/AttachDebugInfo.cpp
index 86b8516b8..bc3080788 100644
--- a/lib/EarlyFunctionAnalysis/AttachDebugInfo.cpp
+++ b/lib/EarlyFunctionAnalysis/AttachDebugInfo.cpp
@@ -44,7 +44,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("attach-debug-info");
+static Logger Log("attach-debug-info");
 
 class AttachDebugInfo : public pipeline::FunctionPassImpl {
 private:
diff --git a/lib/EarlyFunctionAnalysis/CFGAnalyzer.cpp b/lib/EarlyFunctionAnalysis/CFGAnalyzer.cpp
index a34fe0f12..db1f0c162 100644
--- a/lib/EarlyFunctionAnalysis/CFGAnalyzer.cpp
+++ b/lib/EarlyFunctionAnalysis/CFGAnalyzer.cpp
@@ -59,7 +59,7 @@ static opt<std::string> IndirectBranchInfoSummaryPath("indirect-branch-info-"
                                                            "of SA2 on disk."),
                                                       value_desc("filename"));
 
-static Logger<> Log("cfg-analyzer");
+static Logger Log("cfg-analyzer");
 
 static MetaAddress getFinalAddressOfBasicBlock(llvm::BasicBlock *BB) {
   auto &&[End, Size] = getPC(BB->getTerminator());
@@ -264,7 +264,7 @@ CFGAnalyzer::collectDirectCFG(OutlinedFunction *OF) {
   using namespace llvm;
   using llvm::BasicBlock;
   revng_log(Log, "collectDirectCFG(" << OF->Function->getName().str() << ")");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   SortedVector<efa::BasicBlock> CFG;
 
@@ -285,7 +285,7 @@ CFGAnalyzer::collectDirectCFG(OutlinedFunction *OF) {
                 "Creating block starting at " << ID.toString()
                                               << " (preliminary ending is "
                                               << Block.End().toString() << ")");
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
 
       OnceQueue<BasicBlock *> Queue;
       Queue.insert(&BB);
@@ -312,7 +312,7 @@ CFGAnalyzer::collectDirectCFG(OutlinedFunction *OF) {
         }
 
         revng_log(Log, "Considering successors");
-        LoggerIndent<> Indent2(Log);
+        LoggerIndent Indent2(Log);
 
         for (BasicBlock *Succ : successors(Current)) {
           revng_log(Log, "Considering successor " << getName(Succ));
@@ -739,11 +739,11 @@ FunctionSummary CFGAnalyzer::milkInfo(OutlinedFunction *OutlinedFunction,
   int64_t CallPushSize = getCallPushSize(Binary->Architecture());
 
   revng_log(Log, "Milking info for " << OutlinedFunction->Address.toString());
-  LoggerIndent<> Ident(Log);
+  LoggerIndent Ident(Log);
 
   revng_log(Log, "Initial CFG:\n");
   if (Log.isEnabled()) {
-    LoggerIndent<> Ident(Log);
+    LoggerIndent Ident(Log);
     for (const efa::BasicBlock &Block : CFG) {
       serialize(Log, Block);
       Log << DoLog;
@@ -1018,7 +1018,7 @@ FunctionSummary CFGAnalyzer::milkInfo(OutlinedFunction *OutlinedFunction,
 
   revng_log(Log, "Final CFG:\n");
   if (Log.isEnabled()) {
-    LoggerIndent<> Ident(Log);
+    LoggerIndent Ident(Log);
     for (const efa::BasicBlock &Block : CFG) {
       serialize(Log, Block);
       Log << DoLog;
diff --git a/lib/EarlyFunctionAnalysis/CollectFunctionsFromCalleesPass.cpp b/lib/EarlyFunctionAnalysis/CollectFunctionsFromCalleesPass.cpp
index 663c8e68b..bfe434e2f 100644
--- a/lib/EarlyFunctionAnalysis/CollectFunctionsFromCalleesPass.cpp
+++ b/lib/EarlyFunctionAnalysis/CollectFunctionsFromCalleesPass.cpp
@@ -19,7 +19,7 @@ static Register Y("collect-functions-from-callees",
                   true,
                   true);
 
-static Logger<> Log("functions-from-callees-collection");
+static Logger Log("functions-from-callees-collection");
 
 using CFFCWP = CollectFunctionsFromCalleesWrapperPass;
 void CFFCWP::getAnalysisUsage(AnalysisUsage &AU) const {
diff --git a/lib/EarlyFunctionAnalysis/CollectFunctionsFromUnusedAddressesPass.cpp b/lib/EarlyFunctionAnalysis/CollectFunctionsFromUnusedAddressesPass.cpp
index db8d42aad..b8fdf41c0 100644
--- a/lib/EarlyFunctionAnalysis/CollectFunctionsFromUnusedAddressesPass.cpp
+++ b/lib/EarlyFunctionAnalysis/CollectFunctionsFromUnusedAddressesPass.cpp
@@ -25,7 +25,7 @@ static Register Y("collect-functions-from-unused-addresses",
                   true,
                   true);
 
-static Logger<> Log("functions-from-unused-addresses-collection");
+static Logger Log("functions-from-unused-addresses-collection");
 
 class CFFUAImpl {
 public:
diff --git a/lib/EarlyFunctionAnalysis/DetectABI.cpp b/lib/EarlyFunctionAnalysis/DetectABI.cpp
index 7e5ede15a..19dcc1969 100644
--- a/lib/EarlyFunctionAnalysis/DetectABI.cpp
+++ b/lib/EarlyFunctionAnalysis/DetectABI.cpp
@@ -83,7 +83,7 @@ static opt<ABIOpt> ABIEnforcement("abi-enforcement-level",
                                                     "found.")),
                                   init(ABIOpt::FullABIEnforcement));
 
-static Logger<> Log("detect-abi");
+static Logger Log("detect-abi");
 
 struct Changes {
   bool Function = false;
@@ -323,7 +323,7 @@ void DetectABI::computeApproximateCallGraph() {
 
 void DetectABI::preliminaryFunctionAnalysis() {
   revng_log(Log, "Running the preliminary function analysis");
-  LoggerIndent<> LodIndent(Log);
+  LoggerIndent LodIndent(Log);
 
   BasicBlockQueue EntrypointsQueue;
 
@@ -354,7 +354,7 @@ void DetectABI::preliminaryFunctionAnalysis() {
     const BasicBlockNode *EntryNode = EntrypointsQueue.pop();
     MetaAddress EntryPointAddress = EntryNode->Address;
     revng_log(Log, "Analyzing " << EntryPointAddress.toString());
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     FunctionSummary AnalysisResult = Analyzer.analyze(EntryNode->Address);
 
@@ -392,7 +392,7 @@ void DetectABI::preliminaryFunctionAnalysis() {
     if (Changed) {
       revng_log(Log,
                 "Entry " << EntryPointAddress.toString() << " has changed");
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
       OnceQueue<const BasicBlockNode *> InlineFunctionWorklist;
       InlineFunctionWorklist.insert(EntryNode);
 
@@ -401,7 +401,7 @@ void DetectABI::preliminaryFunctionAnalysis() {
         MetaAddress NodeAddress = Node->Address;
         revng_log(Log,
                   "Re-enqueuing callers of " << NodeAddress.toString() << ":");
-        LoggerIndent<> Indent(Log);
+        LoggerIndent Indent(Log);
         for (auto *Caller : Node->predecessors()) {
           // Root node?
           if (Caller->Address.isInvalid())
@@ -450,7 +450,7 @@ void DetectABI::preliminaryFunctionAnalysis() {
 
 void DetectABI::analyzeABI() {
   revng_log(Log, "Running ABI analyses");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   llvm::Task Task(2, "analyzeABI");
   std::map<MetaAddress, std::unique_ptr<OutlinedFunction>> Functions;
@@ -494,7 +494,7 @@ void DetectABI::analyzeABI() {
 
     if (Changes.Function) {
       revng_log(Log, "The function has changed, re-enqueing all callers:");
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
       // The prototype of the function we analyzed has changed, reanalyze
       // callers
       auto &FunctionNode = BasicBlockNodeMap[GCBI.getBlockAt(Function.Entry())];
@@ -758,7 +758,7 @@ void DetectABI::propagatePrototypesInFunction(model::Function &Function) {
   const MetaAddress &Entry = Function.Entry();
 
   revng_log(Log, "Trying to propagate prototypes for " << Entry.toString());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   FunctionSummary &Summary = Oracle.getLocalFunction(Entry);
   RUAResults &ABI = Summary.ABIResults;
diff --git a/lib/EarlyFunctionAnalysis/FunctionSummaryOracle.cpp b/lib/EarlyFunctionAnalysis/FunctionSummaryOracle.cpp
index 1ac368e0f..b402c220b 100644
--- a/lib/EarlyFunctionAnalysis/FunctionSummaryOracle.cpp
+++ b/lib/EarlyFunctionAnalysis/FunctionSummaryOracle.cpp
@@ -10,7 +10,7 @@
 #include "revng/ADT/STLExtras.h"
 #include "revng/EarlyFunctionAnalysis/FunctionSummaryOracle.h"
 
-static Logger<> Log("efa-import-model");
+static Logger Log("efa-import-model");
 
 namespace efa {
 
diff --git a/lib/FunctionCallIdentification/FunctionCallIdentification.cpp b/lib/FunctionCallIdentification/FunctionCallIdentification.cpp
index b154efd75..ed791d17c 100644
--- a/lib/FunctionCallIdentification/FunctionCallIdentification.cpp
+++ b/lib/FunctionCallIdentification/FunctionCallIdentification.cpp
@@ -22,7 +22,7 @@ static RegisterPass<FunctionCallIdentification> X("fci",
                                                   true,
                                                   true);
 
-static Logger<> FilteredCFGLog("filtered-cfg");
+static Logger FilteredCFGLog("filtered-cfg");
 
 bool FunctionCallIdentification::runOnModule(llvm::Module &M) {
   revng_log(PassesLog, "Starting FunctionCallIdentification");
diff --git a/lib/FunctionIsolation/EnforceABI.cpp b/lib/FunctionIsolation/EnforceABI.cpp
index 1764bdfe4..c4ca72d05 100644
--- a/lib/FunctionIsolation/EnforceABI.cpp
+++ b/lib/FunctionIsolation/EnforceABI.cpp
@@ -110,7 +110,7 @@ using Register = RegisterPass<pipeline::FunctionPass<EnforceABI>>;
 
 static Register X("enforce-abi", "Enforce ABI Pass", true, true);
 
-static Logger<> EnforceABILog("enforce-abi");
+static Logger EnforceABILog("enforce-abi");
 
 bool EnforceABI::prologue() {
   FunctionDispatcher = getIRHelper("function_dispatcher", M);
diff --git a/lib/FunctionIsolation/IsolateFunctions.cpp b/lib/FunctionIsolation/IsolateFunctions.cpp
index 785accef0..db5cb25ed 100644
--- a/lib/FunctionIsolation/IsolateFunctions.cpp
+++ b/lib/FunctionIsolation/IsolateFunctions.cpp
@@ -61,7 +61,7 @@ using namespace llvm;
 
 class IsolateFunctionsImpl;
 
-static Logger<> TheLogger("isolation");
+static Logger TheLogger("isolation");
 
 // Define an alias for the data structure that will contain the LLVM functions
 using FunctionsMap = std::map<MDString *, Function *>;
diff --git a/lib/HeadersGeneration/HelpersToHeader.cpp b/lib/HeadersGeneration/HelpersToHeader.cpp
index 33e149f69..af6e56097 100644
--- a/lib/HeadersGeneration/HelpersToHeader.cpp
+++ b/lib/HeadersGeneration/HelpersToHeader.cpp
@@ -30,7 +30,7 @@
 
 using llvm::dyn_cast;
 
-static Logger<> Log{ "helpers-to-header" };
+static Logger Log{ "helpers-to-header" };
 
 /// Print the declaration a C struct corresponding to an LLVM struct
 /// type.
diff --git a/lib/HeadersGeneration/ModelToHeader.cpp b/lib/HeadersGeneration/ModelToHeader.cpp
index 7ec266421..73448fa67 100644
--- a/lib/HeadersGeneration/ModelToHeader.cpp
+++ b/lib/HeadersGeneration/ModelToHeader.cpp
@@ -25,7 +25,7 @@
 #include "revng/Support/Debug.h"
 #include "revng/Support/YAMLTraits.h"
 
-static Logger<> Log{ "model-to-header" };
+static Logger Log{ "model-to-header" };
 
 bool ptml::HeaderBuilder::printModelHeader() {
 
diff --git a/lib/HelperArgumentsAnalysis/AnalyzeHelperArguments.cpp b/lib/HelperArgumentsAnalysis/AnalyzeHelperArguments.cpp
index d1256aebf..0b3df73f1 100644
--- a/lib/HelperArgumentsAnalysis/AnalyzeHelperArguments.cpp
+++ b/lib/HelperArgumentsAnalysis/AnalyzeHelperArguments.cpp
@@ -69,7 +69,7 @@ static aua::StructPointers collectOffsetTypes(Module &Module,
       revng_log(Log,
                 "Considering argument " << Argument->getArgNo() << " of "
                                         << F.getName().str());
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
 
       auto *DIArgumentType = dyn_cast_or_null<DIDerivedType>(Type);
       if (DIArgumentType == nullptr
diff --git a/lib/HelperArgumentsAnalysis/ArgumentUsageAnalysis.cpp b/lib/HelperArgumentsAnalysis/ArgumentUsageAnalysis.cpp
index 35dde1ed7..1523cbda1 100644
--- a/lib/HelperArgumentsAnalysis/ArgumentUsageAnalysis.cpp
+++ b/lib/HelperArgumentsAnalysis/ArgumentUsageAnalysis.cpp
@@ -26,7 +26,7 @@ namespace aua {
 
 void ArgumentUsageAnalysis::run() {
   revng_log(Log, "Running ArgumentUsageAnalysis");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Analyze functions in post order
   llvm::CallGraph CG(M);
@@ -39,7 +39,7 @@ void ArgumentUsageAnalysis::run() {
 
 void ArgumentUsageAnalysis::analyzeFunction(llvm::Function &F) {
   revng_log(Log, "Analyzing " << F.getName());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   auto [It, New] = Results.insert({ &F, Function(TheContext) });
   revng_assert(New);
@@ -59,7 +59,7 @@ void ArgumentUsageAnalysis::analyzeFunction(llvm::Function &F) {
   // expressions
   {
     revng_log(Log, "Running analyzeInstruction");
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // We do one sweep in reverse-post order. This means that, before we visit
     // an instruction all of its operands will have been visited already. The
@@ -77,7 +77,7 @@ void ArgumentUsageAnalysis::analyzeFunction(llvm::Function &F) {
     // Do a final pass to register memory accesses (load, store, memcpy),
     // function calls and escaped arguments
     revng_log(Log, "Running registerFunctionResults");
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
     for (llvm::BasicBlock &BB : F)
       for (llvm::Instruction &I : BB)
         if (not I.isDebugOrPseudoInst())
@@ -92,7 +92,7 @@ void ArgumentUsageAnalysis::analyzeFunction(llvm::Function &F) {
 void ArgumentUsageAnalysis::taintAnalysis(Function &FunctionResults,
                                           const llvm::Function &F) {
   revng_log(Log, "Running taint analysis");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   revng_assert(not isVarArg(F));
   revng_assert(F.arg_size() <= 64);
@@ -334,7 +334,7 @@ void ArgumentUsageAnalysis::registerCall(Function &FunctionResults,
     Log << DoLog;
   }
 
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
   if (Log.isEnabled()) {
     CallSite.dump(Log);
     Log << DoLog;
diff --git a/lib/HelperArgumentsAnalysis/CPUStateUsage.cpp b/lib/HelperArgumentsAnalysis/CPUStateUsage.cpp
index 7af175c4b..88899f2f6 100644
--- a/lib/HelperArgumentsAnalysis/CPUStateUsage.cpp
+++ b/lib/HelperArgumentsAnalysis/CPUStateUsage.cpp
@@ -111,7 +111,7 @@ CPUStateUsageAnalysis::computeAccessesInRoot(const Value &Offset) const {
 
   for (const PointerSet &Pointer : Pointers) {
     revng_log(Log, "Considering " << Pointer.toString());
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // Collect the number of elements in arrays whose elements match the
     // strides in Pointer
@@ -248,7 +248,7 @@ void CPUStateUsageAnalysis::analyze(llvm::Function &Function) {
   llvm::Task T(2, "Analyze CPU state usage of " + Function.getName());
   FastValuePrinter Printer(*Function.getParent());
   revng_log(Log, "Collecting interprocedural data in " << Function.getName());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   revng_log(Log, "Collecting global results");
   T.advance("Collecting global results");
@@ -257,7 +257,7 @@ void CPUStateUsageAnalysis::analyze(llvm::Function &Function) {
 
   T.advance("Processing arguments");
   revng_log(Log, "Processing arguments of " << Function.getName());
-  LoggerIndent<> Indent2(Log);
+  LoggerIndent Indent2(Log);
 
   for (auto &&[ArgumentIndex, Argument] : llvm::enumerate(Function.args())) {
     auto &Offsets = Initializer.getOffsetsFor(Argument);
@@ -277,7 +277,7 @@ void CPUStateUsageAnalysis::analyze(llvm::Function &Function) {
       Log << DoLog;
     }
 
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // If the argument is escaping, bail out
     bool Escapes = false;
@@ -452,7 +452,7 @@ CPUStateUsageAnalysis::collectGlobalAUAResults(const llvm::Function &Function) {
       Callee.dump(Log, "    ");
       Log << DoLog;
     }
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // Register escaped arguments replacing arguments
     for (const EscapedArgument &EscapedArgument :
@@ -548,7 +548,7 @@ void StructPointers::visitType(llvm::Type &Type, uint64_t StartingOffset) {
     revng_log(Log,
               "Registering an instance of " << Struct->getName()
                                             << " at offset " << StartingOffset);
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
     if (Struct->getName().size() != 0)
       OffsetsOfStructs[Struct].push_back(StartingOffset);
 
@@ -560,7 +560,7 @@ void StructPointers::visitType(llvm::Type &Type, uint64_t StartingOffset) {
   } else if (auto *Array = dyn_cast<llvm::ArrayType>(&Type)) {
     auto ElementsCount = Array->getNumElements();
     revng_log(Log, "Handling an array of " << ElementsCount << " elements");
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
     auto &ElementType = *Array->getElementType();
     auto ElementSize = DL.getTypeAllocSize(&ElementType);
     for (unsigned I = 0; I < ElementsCount; ++I)
diff --git a/lib/HelperArgumentsAnalysis/FixHelpers.cpp b/lib/HelperArgumentsAnalysis/FixHelpers.cpp
index 8c11b6249..4f5e76f63 100644
--- a/lib/HelperArgumentsAnalysis/FixHelpers.cpp
+++ b/lib/HelperArgumentsAnalysis/FixHelpers.cpp
@@ -40,7 +40,7 @@ using namespace llvm;
 
 using std::string;
 
-static Logger<> Log("fix-helpers");
+static Logger Log("fix-helpers");
 
 static cl::opt<string> ArchitectureName("fix-helpers-architecture",
                                         cl::desc("architecture of the helper "
@@ -53,7 +53,7 @@ static void setMetadata(VariableManager &Variables,
                         StringRef MetadataName,
                         const aua::Annotation::OffsetAndSizeSet &Offsets) {
   revng_log(Log, "Parsing " << MetadataName << ":");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   QuickMetadata QMD(getContext(&F));
   SmallVector<Metadata *, 2> CSVList;
@@ -97,7 +97,7 @@ static void convertToCSVAnnotation(VariableManager &Variables,
                                    Function &F,
                                    const aua::Annotation &Annotation) {
   revng_log(Log, "Converting CSV to annotations");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
   setMetadata(Variables, F, "revng.csvaccess.offsets.load", Annotation.Reads);
   setMetadata(Variables, F, "revng.csvaccess.offsets.store", Annotation.Writes);
 }
@@ -253,7 +253,7 @@ void AccessFixer::handle(Instruction &I,
   revng_log(Log,
             "Handling " << getName(&I) << ", which has " << Targets.size()
                         << " targets");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Handle the single-offset situation
   if (Targets.size() == 1) {
@@ -344,7 +344,7 @@ AccessFixer::decomposeMemcpy(llvm::Instruction &I) {
 void AccessFixer::fixMemoryAccess(Instruction &I,
                                   const aua::Annotation &Annotation) {
   revng_log(Log, "Handling memory access " << getName(&I));
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   revng_assert(not I.isTerminator());
   auto *Load = dyn_cast<LoadInst>(&I);
@@ -392,7 +392,7 @@ static void fixHelpers(VariableManager &Variables, Module &Module) {
 
   for (Function &F : Module) {
     revng_log(Log, "Handling " << F.getName());
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     auto Annotation = aua::Annotation::deserialize(F)
                         .value_or(aua::Annotation());
diff --git a/lib/HelperArgumentsAnalysis/Function.h b/lib/HelperArgumentsAnalysis/Function.h
index e6dc1c38e..b7eaf32b9 100644
--- a/lib/HelperArgumentsAnalysis/Function.h
+++ b/lib/HelperArgumentsAnalysis/Function.h
@@ -13,7 +13,7 @@
 #include "Context.h"
 #include "Value.h"
 
-inline Logger<> Log("argument-usage-analysis");
+inline Logger Log("argument-usage-analysis");
 
 template<typename O>
 void dumpCall(O &Output, const llvm::CallInst *Call) {
diff --git a/lib/ImportFromC/ImportFromCAnalysis.cpp b/lib/ImportFromC/ImportFromCAnalysis.cpp
index 4437afea7..99376c5ac 100644
--- a/lib/ImportFromC/ImportFromCAnalysis.cpp
+++ b/lib/ImportFromC/ImportFromCAnalysis.cpp
@@ -72,7 +72,7 @@ static std::optional<std::string> findHeaderFile(const std::string &File) {
   return (*MaybeHeaderPath).substr(0, Index);
 }
 
-static Logger<> Log("header-to-model-errors");
+static Logger Log("header-to-model-errors");
 
 struct ImportFromCAnalysis {
   static constexpr auto Name = "import-from-c";
diff --git a/lib/InitModelTypes/InitModelTypes.cpp b/lib/InitModelTypes/InitModelTypes.cpp
index 37b3b14b1..8a6554a48 100644
--- a/lib/InitModelTypes/InitModelTypes.cpp
+++ b/lib/InitModelTypes/InitModelTypes.cpp
@@ -57,7 +57,7 @@ using TypeVector = llvm::SmallVector<model::UpcastableType, 8>;
 using ModelTypesMap = std::map<const llvm::Value *,
                                const model::UpcastableType>;
 
-static Logger<> Log{ "init-model-types" };
+static Logger Log{ "init-model-types" };
 
 /// Map each llvm::Argument of the given llvm::Function to its type in the model
 static void addArgumentsTypes(const llvm::Function &LLVMFunc,
diff --git a/lib/Lift/CSVOffsets.cpp b/lib/Lift/CSVOffsets.cpp
index 321534b99..6b5f4e9e5 100644
--- a/lib/Lift/CSVOffsets.cpp
+++ b/lib/Lift/CSVOffsets.cpp
@@ -7,7 +7,7 @@
 #include "revng/Lift/CSVOffsets.h"
 #include "revng/Support/Debug.h"
 
-void writeToLog(Logger<true> &L, const CSVOffsets &O, int /*Ignore*/) {
+void writeToLog(Logger &L, const CSVOffsets &O, int /*Ignore*/) {
   L << "Kind: " << CSVOffsets::toString(O.OffsetKind);
   L << " Offsets = { ";
   for (const auto &Offset : O)
diff --git a/lib/Lift/CodeGenerator.cpp b/lib/Lift/CodeGenerator.cpp
index 6bd1e2ba4..24f4c14ec 100644
--- a/lib/Lift/CodeGenerator.cpp
+++ b/lib/Lift/CodeGenerator.cpp
@@ -73,8 +73,8 @@ static cl::opt<bool> RecordTCG("record-tcg",
                                cl::desc("create metadata for TCG"),
                                cl::cat(MainCategory));
 
-static Logger<> LibTcgLog("libtcg");
-static Logger<> Log("lift");
+static Logger LibTcgLog("libtcg");
+static Logger Log("lift");
 
 template<typename T, typename... ArgTypes>
 constexpr std::array<T, sizeof...(ArgTypes)> make_array(ArgTypes &&...Args) {
@@ -411,7 +411,7 @@ void CodeGenerator::translate(LibTcg &LibTcg,
       static std::array<char, 128> DumpBuf{ 0 };
       LibTcgLog << "Translation starting from " << VirtualAddress.toGeneric()
                 << " (size: " << ConsumedSize << " bytes)" << DoLog;
-      LoggerIndent<> Indent(LibTcgLog);
+      LoggerIndent Indent(LibTcgLog);
       LibTcgLog.indent();
       for (size_t I = 0; I < TranslationBlock->instruction_count; ++I) {
         auto Opcode = TranslationBlock->list[I].opcode;
diff --git a/lib/Lift/InstructionTranslator.cpp b/lib/Lift/InstructionTranslator.cpp
index 7da902a91..432ea5477 100644
--- a/lib/Lift/InstructionTranslator.cpp
+++ b/lib/Lift/InstructionTranslator.cpp
@@ -38,7 +38,7 @@ RegisterIRHelper NewPCHelper("newpc");
 
 using namespace llvm;
 
-static Logger<> Log("instruction-translator");
+static Logger Log("instruction-translator");
 
 using IT = InstructionTranslator;
 
diff --git a/lib/Lift/JumpTargetManager.cpp b/lib/Lift/JumpTargetManager.cpp
index 23ee73312..5cbd72e03 100644
--- a/lib/Lift/JumpTargetManager.cpp
+++ b/lib/Lift/JumpTargetManager.cpp
@@ -32,8 +32,8 @@ using namespace llvm;
 
 namespace {
 
-Logger<> JTCountLog("jtcount");
-Logger<> RegisterJTLog("registerjt");
+Logger JTCountLog("jtcount");
+Logger RegisterJTLog("registerjt");
 
 CounterMap<std::string> HarvestingStats("harvesting");
 
@@ -918,7 +918,7 @@ BasicBlock *JumpTargetManager::registerJT(MetaAddress PC,
   revng_log(RegisterJTLog,
             "Registering bb." << nameForAddress(PC) << " for "
                               << JTReason::getName(Reason));
-  LoggerIndent<> Indent(RegisterJTLog);
+  LoggerIndent Indent(RegisterJTLog);
 
   // Do we already have a BasicBlock for this PC?
   BlockMap::iterator TargetIt = JumpTargets.find(PC);
diff --git a/lib/Lift/RootAnalyzer.cpp b/lib/Lift/RootAnalyzer.cpp
index d854f7dfd..98a8bc770 100644
--- a/lib/Lift/RootAnalyzer.cpp
+++ b/lib/Lift/RootAnalyzer.cpp
@@ -49,8 +49,8 @@ RunningStatistics DetectedEdgesStatistics("detected-edges");
 RunningStatistics StoredInMemoryStatistics("stored-in-memory");
 RunningStatistics LoadAddressStatistics("load-address");
 
-Logger<> NewEdgesLog("new-edges");
-static Logger<> Log("root-analyzer");
+Logger NewEdgesLog("new-edges");
+static Logger Log("root-analyzer");
 
 // NOTE: Setting this to 1 gives us performance improvement. We have tested and
 // realized that there is an impact on performance if setting it to 2.
@@ -720,7 +720,7 @@ void RootAnalyzer::collectMaterializedValues(AnalysisRegistry &AR) {
 
   for (auto &[ValueMaterializerID, Operands] : MaterializedValuesById) {
     revng_log(Log, "Parsing ID " << ValueMaterializerID);
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // Remove duplicates
     llvm::sort(Operands);
diff --git a/lib/Lift/VariableManager.cpp b/lib/Lift/VariableManager.cpp
index f2e2d2196..d89ac23d9 100644
--- a/lib/Lift/VariableManager.cpp
+++ b/lib/Lift/VariableManager.cpp
@@ -38,7 +38,7 @@
 // This name corresponds to a function in `early-linked`.
 RegisterIRHelper SetRegisterMarker("set_register");
 
-static Logger<> Log("csv-at-offset");
+static Logger Log("csv-at-offset");
 
 using namespace llvm;
 
@@ -488,7 +488,7 @@ VariableManager::getByCPUStateOffsetWithRemainder(intptr_t Offset) {
     return MaybeResult.value();
 
   revng_log(Log, "Considering offset " << Offset);
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Get the type of the field at that offset (if any) and obtain the offset
   // within the field
diff --git a/lib/Model/Binary.cpp b/lib/Model/Binary.cpp
index 6003e432f..8e78745b9 100644
--- a/lib/Model/Binary.cpp
+++ b/lib/Model/Binary.cpp
@@ -20,7 +20,7 @@
 namespace {
 
 // TODO: all this logic should be moved to lib/TupleTree
-Logger<> FieldAccessedLogger("field-accessed");
+Logger FieldAccessedLogger("field-accessed");
 
 constexpr const char *StructNameHelpText = "regex that will make the program "
                                            "assert when a model struct which "
diff --git a/lib/Model/Importer/Binary/ELFImporter.cpp b/lib/Model/Importer/Binary/ELFImporter.cpp
index fd5f9d43e..3fb03222e 100644
--- a/lib/Model/Importer/Binary/ELFImporter.cpp
+++ b/lib/Model/Importer/Binary/ELFImporter.cpp
@@ -35,7 +35,7 @@
 using namespace llvm;
 using namespace llvm::object;
 
-Logger<> ELFImporterLog("elf-importer");
+Logger ELFImporterLog("elf-importer");
 
 template<typename A, typename B>
 static bool hasFlag(A Flag, B Value) {
diff --git a/lib/Model/Importer/Binary/ELFImporter.h b/lib/Model/Importer/Binary/ELFImporter.h
index 8d4c889d5..98618a5e1 100644
--- a/lib/Model/Importer/Binary/ELFImporter.h
+++ b/lib/Model/Importer/Binary/ELFImporter.h
@@ -14,7 +14,7 @@
 #include "DwarfReader.h"
 #include "SegmentImportHelpers.h"
 
-extern Logger<> ELFImporterLog;
+extern Logger ELFImporterLog;
 
 namespace {
 
diff --git a/lib/Model/Importer/Binary/MachOImporter.cpp b/lib/Model/Importer/Binary/MachOImporter.cpp
index beed70ce2..216f14c1a 100644
--- a/lib/Model/Importer/Binary/MachOImporter.cpp
+++ b/lib/Model/Importer/Binary/MachOImporter.cpp
@@ -27,7 +27,7 @@ using namespace llvm::object;
 using namespace llvm;
 using namespace model;
 
-static Logger<> Log("macho-importer");
+static Logger Log("macho-importer");
 
 template<typename R>
 void swapBytes(R &Value) {
diff --git a/lib/Model/Importer/Binary/PECOFFImporter.cpp b/lib/Model/Importer/Binary/PECOFFImporter.cpp
index 5d38504ef..3ddf891e2 100644
--- a/lib/Model/Importer/Binary/PECOFFImporter.cpp
+++ b/lib/Model/Importer/Binary/PECOFFImporter.cpp
@@ -24,7 +24,7 @@
 using namespace llvm;
 using namespace llvm::object;
 
-static Logger<> Log("pecoff-importer");
+static Logger Log("pecoff-importer");
 
 using PELDDTree = std::map<std::string, std::vector<std::string>>;
 
diff --git a/lib/Model/Importer/DebugInfo/DwarfImporter.cpp b/lib/Model/Importer/DebugInfo/DwarfImporter.cpp
index 091f52548..d32df8466 100644
--- a/lib/Model/Importer/DebugInfo/DwarfImporter.cpp
+++ b/lib/Model/Importer/DebugInfo/DwarfImporter.cpp
@@ -40,7 +40,7 @@
 using namespace llvm;
 using namespace llvm::dwarf;
 
-static Logger<> DILogger("dwarf-importer");
+static Logger DILogger("dwarf-importer");
 static const std::string GlobalDebugDirectory = "/usr/lib/debug/";
 
 template<typename M>
@@ -1064,7 +1064,7 @@ findDebugInfoFileByName(StringRef FileName,
                         llvm::object::ObjectFile *ELF) {
   revng_log(DILogger,
             "Looking for \"" << DebugFileName << "\" for " << FileName << "\"");
-  LoggerIndent<> Indent(DILogger);
+  LoggerIndent Indent(DILogger);
 
   // Let's find it in canonical places, where debug info was fetched.
   //  1) Look for a .gnu_debuglink/.gnu_debugaltlink/.debug_sup section.
@@ -1170,7 +1170,7 @@ void DwarfImporter::import(StringRef FileName, const ImporterOptions &Options) {
   revng_log(DILogger,
             "Importing DWARF information for "
               << llvm::sys::path::filename(FileName));
-  LoggerIndent<> Indent(DILogger);
+  LoggerIndent Indent(DILogger);
 
   Task T(3,
          "Importing DWARF information for "
diff --git a/lib/Model/Importer/DebugInfo/PDBImporter.cpp b/lib/Model/Importer/DebugInfo/PDBImporter.cpp
index 930983785..14cd3da86 100644
--- a/lib/Model/Importer/DebugInfo/PDBImporter.cpp
+++ b/lib/Model/Importer/DebugInfo/PDBImporter.cpp
@@ -51,7 +51,7 @@ using namespace llvm::codeview;
 using namespace llvm::object;
 using namespace llvm::pdb;
 
-static Logger<> Log("pdb-importer");
+static Logger Log("pdb-importer");
 
 // Force using a specific PDB.
 static llvm::cl::opt<std::string> UsePDB("use-pdb",
diff --git a/lib/Model/Pass/DeduplicateEquivalentTypes.cpp b/lib/Model/Pass/DeduplicateEquivalentTypes.cpp
index 0af290f16..72bee642d 100644
--- a/lib/Model/Pass/DeduplicateEquivalentTypes.cpp
+++ b/lib/Model/Pass/DeduplicateEquivalentTypes.cpp
@@ -18,7 +18,7 @@
 using namespace llvm;
 using namespace model;
 
-static Logger<> Log("model-types-deduplication");
+static Logger Log("model-types-deduplication");
 
 static RegisterModelPass R("deduplicate-equivalent-types",
                            "Best-effort deduplication of types that are "
diff --git a/lib/Model/Pass/PurgeUnnamedAndUnreachableTypes.cpp b/lib/Model/Pass/PurgeUnnamedAndUnreachableTypes.cpp
index f1a2b31ec..b24196d29 100644
--- a/lib/Model/Pass/PurgeUnnamedAndUnreachableTypes.cpp
+++ b/lib/Model/Pass/PurgeUnnamedAndUnreachableTypes.cpp
@@ -15,7 +15,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("purge-model-types");
+static Logger Log("purge-model-types");
 
 static RegisterModelPass R0("purge-invalid-types",
                             "Remove all the types that do not verify",
diff --git a/lib/Pipeline/Context.cpp b/lib/Pipeline/Context.cpp
index e6af103f4..b231f340c 100644
--- a/lib/Pipeline/Context.cpp
+++ b/lib/Pipeline/Context.cpp
@@ -15,8 +15,8 @@
 
 using namespace pipeline;
 
-Logger<> pipeline::ExplanationLogger("pipeline");
-Logger<> pipeline::CommandLogger("commands");
+Logger pipeline::ExplanationLogger("pipeline");
+Logger pipeline::CommandLogger("commands");
 
 Context::Context() : TheKindRegistry(Registry::registerAllKinds()) {
 }
diff --git a/lib/Pipeline/Pipe.cpp b/lib/Pipeline/Pipe.cpp
index 955dfcc4f..fd3df3823 100644
--- a/lib/Pipeline/Pipe.cpp
+++ b/lib/Pipeline/Pipe.cpp
@@ -16,7 +16,7 @@ void InvalidationMetadata::registerTargetsDependingOn(const Context &Context,
                                                       const TupleTreePath &Path,
                                                       ContainerToTargetsMap
                                                         &Out,
-                                                      Logger<> &Log) const {
+                                                      Logger &Log) const {
   if (auto Iter = PathCache.find(GlobalName); Iter != PathCache.end()) {
 
     auto &Bimap = Iter->second;
diff --git a/lib/Pipeline/Runner.cpp b/lib/Pipeline/Runner.cpp
index cb72d0677..472fe27de 100644
--- a/lib/Pipeline/Runner.cpp
+++ b/lib/Pipeline/Runner.cpp
@@ -454,7 +454,7 @@ void Runner::getDiffInvalidations(const GlobalTupleTreeDiff &Diff,
     T.advance(Step.getName(), true);
     revng_log(InvalidationLog,
               "Computing invalidations in step " << Step.getName());
-    LoggerIndent<> I(InvalidationLog);
+    LoggerIndent I(InvalidationLog);
 
     ContainerToTargetsMap &StepInvalidations = Map[Step.getName()];
 
@@ -472,7 +472,7 @@ void Runner::getDiffInvalidations(const GlobalTupleTreeDiff &Diff,
     revng_log(InvalidationLog, ChangedPaths.size() << " paths have changed");
     for (const TupleTreePath *Path : ChangedPaths) {
       revng_log(InvalidationLog, "Processing " << *Diff.pathAsString(*Path));
-      LoggerIndent<> Indent(InvalidationLog);
+      LoggerIndent Indent(InvalidationLog);
       Step.registerTargetsDependingOn(Diff.getGlobalName(),
                                       *Path,
                                       Map,
diff --git a/lib/Pipeline/Step.cpp b/lib/Pipeline/Step.cpp
index 2aa1ba6f9..24ef53810 100644
--- a/lib/Pipeline/Step.cpp
+++ b/lib/Pipeline/Step.cpp
@@ -411,7 +411,7 @@ Error Step::load(const revng::DirectoryPath &DirPath) {
 void Step::registerTargetsDependingOn(llvm::StringRef GlobalName,
                                       const TupleTreePath &Path,
                                       TargetInStepSet &Out,
-                                      Logger<> &Log) const {
+                                      Logger &Log) const {
   ContainerToTargetsMap ToInvalidateMap;
 
   Task T(3, "Computing invalidation for step " + getName());
@@ -422,7 +422,7 @@ void Step::registerTargetsDependingOn(llvm::StringRef GlobalName,
   for (const PipeWrapper &Pipe : Pipes) {
     T2.advance(Pipe.Pipe->getName(), true);
     revng_log(Log, "Handling the " << Pipe.Pipe->getName() << " pipe");
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
     Pipe.InvalidationMetadata.registerTargetsDependingOn(*TheContext,
                                                          GlobalName,
                                                          Path,
diff --git a/lib/PipelineC/Tracing/Runner.cpp b/lib/PipelineC/Tracing/Runner.cpp
index 451dc0fec..886538907 100644
--- a/lib/PipelineC/Tracing/Runner.cpp
+++ b/lib/PipelineC/Tracing/Runner.cpp
@@ -27,7 +27,7 @@ using ArgumentRef = const revng::tracing::Argument &;
 using ArgumentsRef = const llvm::ArrayRef<revng::tracing::Argument>;
 using ReturnRef = const llvm::StringRef;
 
-static Logger<> TraceRunnerLogger("trace-runner");
+static Logger TraceRunnerLogger("trace-runner");
 
 namespace utils {
 // Utility functions for decoding arguments
diff --git a/lib/PromoteStackPointer/ComputeStackAccessesBoundsPass.cpp b/lib/PromoteStackPointer/ComputeStackAccessesBoundsPass.cpp
index eb3705a7c..3f8d78236 100644
--- a/lib/PromoteStackPointer/ComputeStackAccessesBoundsPass.cpp
+++ b/lib/PromoteStackPointer/ComputeStackAccessesBoundsPass.cpp
@@ -25,7 +25,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("compute-stack-accesses-bounds");
+static Logger Log("compute-stack-accesses-bounds");
 
 template<typename T, std::ranges::range R>
 bool areAll(const R &Range) {
@@ -38,7 +38,7 @@ getSCEVBoundaries(ScalarEvolution &SE, PostDominatorTree &PDT, Instruction *I) {
   auto FullSet = ConstantRange::getFull(SCEV->getType()->getIntegerBitWidth());
 
   revng_log(Log, "getSCEVBoundaries on " << dumpToString(*SCEV));
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   auto *AddRec = dyn_cast<SCEVAddRecExpr>(SCEV);
   if (AddRec == nullptr)
@@ -106,7 +106,7 @@ getSCEVBoundaries(ScalarEvolution &SE, PostDominatorTree &PDT, Instruction *I) {
 
 bool ComputeStackAccessesBoundsPass::runOnFunction(Function &F) {
   revng_log(Log, "Running on " << F.getName().str());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   PostDominatorTree &PDT = getAnalysis<PostDominatorTreeWrapperPass>()
diff --git a/lib/PromoteStackPointer/DetectStackSizePass.cpp b/lib/PromoteStackPointer/DetectStackSizePass.cpp
index 270eaa724..4379b3aa7 100644
--- a/lib/PromoteStackPointer/DetectStackSizePass.cpp
+++ b/lib/PromoteStackPointer/DetectStackSizePass.cpp
@@ -26,7 +26,7 @@
 using namespace llvm;
 using model::RawFunctionDefinition;
 
-static Logger<> Log("detect-stack-size");
+static Logger Log("detect-stack-size");
 
 static bool isValidStackSize(uint64_t Size) {
   return 0 < Size and Size < 10 * 1024 * 1024;
@@ -147,7 +147,7 @@ void DetectStackSize::collectStackBounds(Function &F) {
             "Collecting stack bounds for "
               << model::CNameBuilder(*Binary).name(ModelFunction));
 
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Check if this function already has information about stack
   // frame/arguments
@@ -265,7 +265,7 @@ void DetectStackSize::electFunctionStackFrameSize(FunctionStackInfo &FSI) {
             "electFunctionStackFrameSize: "
               << model::CNameBuilder(*Binary).name(ModelFunction));
 
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   if (FSI.MaxStackSize)
     revng_log(Log, "MaxStackSize: " << *FSI.MaxStackSize);
@@ -302,7 +302,7 @@ void DetectStackSize::electFunctionStackFrameSize(FunctionStackInfo &FSI) {
 std::optional<uint64_t>
 DetectStackSize::handleCallSite(const CallSite &CallSite) {
   revng_log(Log, "CallSite");
-  LoggerIndent<> Indent2(Log);
+  LoggerIndent Indent2(Log);
   revng_log(Log, "CallSite.StackSize: " << CallSite.StackSize.value_or(0));
   revng_log(Log, "StackArgumentsSize: " << std::get<0>(CallSite.CallType));
 
diff --git a/lib/PromoteStackPointer/InstrumentStackAccessesPass.cpp b/lib/PromoteStackPointer/InstrumentStackAccessesPass.cpp
index 813e5246a..ed3d07086 100644
--- a/lib/PromoteStackPointer/InstrumentStackAccessesPass.cpp
+++ b/lib/PromoteStackPointer/InstrumentStackAccessesPass.cpp
@@ -13,7 +13,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("instrument-stack-accesses");
+static Logger Log("instrument-stack-accesses");
 
 class InstrumentStackAccesses {
 private:
@@ -32,7 +32,7 @@ public:
 public:
   void run(Function &F) {
     revng_log(Log, "Instrumenting " << F.getName());
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     reset();
 
diff --git a/lib/PromoteStackPointer/PromoteStackPointerPass.cpp b/lib/PromoteStackPointer/PromoteStackPointerPass.cpp
index db0d73afd..b2cfda625 100644
--- a/lib/PromoteStackPointer/PromoteStackPointerPass.cpp
+++ b/lib/PromoteStackPointer/PromoteStackPointerPass.cpp
@@ -37,7 +37,7 @@ RegisterIRHelper IBIMarker("revng_undefined_local_sp");
 
 using namespace llvm;
 
-static Logger<> Log("promote-stack-pointer");
+static Logger Log("promote-stack-pointer");
 
 struct PromoteStackPointerPassImpl : public pipeline::FunctionPassImpl {
 private:
diff --git a/lib/PromoteStackPointer/SegregateStackAccessesPass.cpp b/lib/PromoteStackPointer/SegregateStackAccessesPass.cpp
index ba4314391..f80e12440 100644
--- a/lib/PromoteStackPointer/SegregateStackAccessesPass.cpp
+++ b/lib/PromoteStackPointer/SegregateStackAccessesPass.cpp
@@ -34,7 +34,7 @@
 
 using namespace llvm;
 
-static Logger<> Log("segregate-stack-accesses");
+static Logger Log("segregate-stack-accesses");
 
 inline Value *createAdd(revng::IRBuilder &B, Value *V, uint64_t Addend) {
   return B.CreateAdd(V, ConstantInt::get(V->getType(), Addend));
@@ -204,7 +204,7 @@ struct SegregateStackAccessesMFI : public SetUnionLattice<Lattice> {
                                               const LatticeElement &Value) {
     using namespace llvm;
     revng_log(Log, "Analyzing block " << getName(BB));
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     LatticeElement StackBytes = Value;
 
@@ -219,7 +219,7 @@ struct SegregateStackAccessesMFI : public SetUnionLattice<Lattice> {
         continue;
 
       revng_log(Log, "Analyzing instruction " << getName(&I));
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
 
       // Get stack offset, if available
       auto MaybeStartStackOffset = getStackOffset(&I);
@@ -795,7 +795,7 @@ private:
               "Segregating "
                 << model::CNameBuilder(Binary).name(ModelFunction));
 
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     // Lookup the redirector, if any
     auto It = StackArgumentsRedirectors.find(&F);
@@ -822,7 +822,7 @@ private:
     MFIResult AnalysisResult;
     {
       revng_log(Log, "Running SegregateStackAccessesMFI");
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
       using SSAMFI = SegregateStackAccessesMFI;
       BasicBlock *Entry = &F.getEntryBlock();
       AnalysisResult = MFP::getMaximalFixedPoint<SSAMFI>({},
@@ -873,7 +873,7 @@ private:
   }
 
   void handleCallSite(MFIResult &AnalysisResult, CallInst *SSACSCall) {
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     //
     // Find call to revng_undefined_local_sp
@@ -1114,7 +1114,7 @@ private:
 
     if (Log.isEnabled()) {
       Log << "Redirector data:\n";
-      LoggerIndent<> X(Log);
+      LoggerIndent X(Log);
       Redirector.dump(Log);
       Log << DoLog;
     }
@@ -1301,7 +1301,7 @@ private:
                                       - CallInstructionPushSize);
 
       revng_log(Log, "Considering " << getName(Store));
-      LoggerIndent<> Indent(Log);
+      LoggerIndent Indent(Log);
       revng_log(Log, "Size: " << Size);
       revng_log(Log, "Info.Count: " << Info.Count);
       revng_log(Log, "Info.Offset: " << Info.Count);
@@ -1339,7 +1339,7 @@ private:
   void handleMemoryAccess(const StackAccessRedirector &Redirector,
                           Instruction *I) {
     revng_log(Log, "Handling memory access " << getName(I));
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     auto MaybeStackOffset = getStackOffset(I);
     if (not MaybeStackOffset)
diff --git a/lib/RestructureCFG/BeautifyGHAST.cpp b/lib/RestructureCFG/BeautifyGHAST.cpp
index faba7b7d3..b058fcf8f 100644
--- a/lib/RestructureCFG/BeautifyGHAST.cpp
+++ b/lib/RestructureCFG/BeautifyGHAST.cpp
@@ -37,7 +37,7 @@ using std::unique_ptr;
 
 using namespace llvm;
 
-static Logger<> BeautifyLogger("beautify");
+static Logger BeautifyLogger("beautify");
 
 // Prefix for the short circuit metrics dir.
 static cl::opt<std::string> OutputPath("short-circuit-metrics-output-dir",
diff --git a/lib/RestructureCFG/DAGifyPass.cpp b/lib/RestructureCFG/DAGifyPass.cpp
index 17ab16bee..67320417a 100644
--- a/lib/RestructureCFG/DAGifyPass.cpp
+++ b/lib/RestructureCFG/DAGifyPass.cpp
@@ -18,7 +18,7 @@
 using namespace llvm;
 
 // Debug logger
-static Logger<> Log("dagify");
+static Logger Log("dagify");
 
 class DAGifyPassImpl {
   Function &F;
diff --git a/lib/RestructureCFG/GenericRegionInfo.cpp b/lib/RestructureCFG/GenericRegionInfo.cpp
index 20f67ee9d..42e5454fb 100644
--- a/lib/RestructureCFG/GenericRegionInfo.cpp
+++ b/lib/RestructureCFG/GenericRegionInfo.cpp
@@ -18,7 +18,7 @@
 using namespace llvm;
 
 // Debug logger
-Logger<> GenericRegionInfoLogger("generic-region-info");
+Logger GenericRegionInfoLogger("generic-region-info");
 
 /// Helper function which mimics the `at` behavior for a `llvm::SmallDenseMap`
 template<class KeyT, class ValueT>
diff --git a/lib/RestructureCFG/MaterializeTrivialGotoPass.cpp b/lib/RestructureCFG/MaterializeTrivialGotoPass.cpp
index 49765499f..e5acad01f 100644
--- a/lib/RestructureCFG/MaterializeTrivialGotoPass.cpp
+++ b/lib/RestructureCFG/MaterializeTrivialGotoPass.cpp
@@ -17,7 +17,7 @@
 using namespace llvm;
 
 // Debug logger
-Logger<> MaterializeTrivialGotoLogger("materialize-trivial-goto");
+Logger MaterializeTrivialGotoLogger("materialize-trivial-goto");
 
 static void eraseGoto(ScopeGraphBuilder &SGBuilder, BasicBlock &BB) {
 
diff --git a/lib/RestructureCFG/RestructureCFG.cpp b/lib/RestructureCFG/RestructureCFG.cpp
index 2cf0679e0..05ba24408 100644
--- a/lib/RestructureCFG/RestructureCFG.cpp
+++ b/lib/RestructureCFG/RestructureCFG.cpp
@@ -41,8 +41,8 @@ using std::string;
 
 // TODO: Move the initialization of the logger here from "Utils.h"
 // Debug logger.
-Logger<> CombLogger("restructure");
-Logger<> LogShortestPath("restructure-shortest-path");
+Logger CombLogger("restructure");
+Logger LogShortestPath("restructure-shortest-path");
 
 // EdgeDescriptor is a handy way to create and manipulate edges on the
 // RegionCFG.
diff --git a/lib/RestructureCFG/SelectScopePass.cpp b/lib/RestructureCFG/SelectScopePass.cpp
index 2f2922459..cd32a8348 100644
--- a/lib/RestructureCFG/SelectScopePass.cpp
+++ b/lib/RestructureCFG/SelectScopePass.cpp
@@ -24,7 +24,7 @@
 using namespace llvm;
 
 // Debug logger
-static Logger<> Log("select-scope");
+static Logger Log("select-scope");
 
 static std::map<BasicBlock *, size_t>
 initializeScopeMap(SmallSetVector<BasicBlock *, 2> &ConditionalSuccessors) {
diff --git a/lib/Support/Debug.cpp b/lib/Support/Debug.cpp
index b6cd8cca1..8941584c6 100644
--- a/lib/Support/Debug.cpp
+++ b/lib/Support/Debug.cpp
@@ -39,13 +39,12 @@ class LoggersRegistry {
 public:
   LoggersRegistry() {}
 
-  void add(Logger<true> *L) { Loggers.push_back(L); }
-  void add(Logger<false> *) {}
+  void add(Logger *L) { Loggers.push_back(L); }
 
   size_t size() const { return Loggers.size(); }
 
   void enable(llvm::StringRef Name) {
-    for (Logger<true> *L : Loggers) {
+    for (Logger *L : Loggers) {
       if (L->name() == Name) {
         L->enable();
         return;
@@ -56,7 +55,7 @@ public:
   }
 
   void disable(llvm::StringRef Name) {
-    for (Logger<true> *L : Loggers) {
+    for (Logger *L : Loggers) {
       if (L->name() == Name) {
         L->disable();
         return;
@@ -69,7 +68,7 @@ public:
   void registerArguments() const;
 
 private:
-  std::vector<Logger<true> *> Loggers;
+  std::vector<Logger *> Loggers;
 };
 
 static llvm::ManagedStatic<LoggersRegistry> Loggers;
@@ -87,13 +86,12 @@ ScopedDebugFeature::~ScopedDebugFeature() {
 
 std::ostream &dbg(std::cerr);
 
-Logger<> PassesLog("passes");
-Logger<> ReleaseLog("release");
-Logger<> VerifyLog("verify");
+Logger PassesLog("passes");
+Logger ReleaseLog("release");
+Logger VerifyLog("verify");
 
-template<bool X>
-void Logger<X>::flush(const LogTerminator &LineInfo) {
-  if (X && Enabled) {
+void Logger::flush(const LogTerminator &LineInfo) {
+  if (Enabled) {
     std::string Pad;
 
     if (MaxLocationLength != 0) {
@@ -167,8 +165,7 @@ static std::unique_ptr<cl::alias> DebugLoggingAlias;
 
 llvm::ManagedStatic<DebugLogOptionWrapper> DebugLogOption;
 
-template<>
-void Logger<true>::init() {
+void Logger::init() {
   Loggers->add(this);
   if (Name.size() > 0) {
     auto &Parser = DebugLogOption->TheOption.getParser();
@@ -176,37 +173,25 @@ void Logger<true>::init() {
   }
 }
 
-template<>
-void Logger<false>::init() {
-}
+unsigned Logger::IndentLevel;
 
-template<bool X>
-unsigned Logger<X>::IndentLevel;
-
-template<bool X>
-void Logger<X>::indent(unsigned Level) {
+void Logger::indent(unsigned Level) {
   if (isEnabled())
     IndentLevel += Level;
 }
 
-template<bool X>
-void Logger<X>::unindent(unsigned Level) {
+void Logger::unindent(unsigned Level) {
   if (isEnabled()) {
     revng_assert(IndentLevel - Level >= 0);
     IndentLevel -= Level;
   }
 }
 
-template<bool X>
-void Logger<X>::setIndentation(unsigned Level) {
+void Logger::setIndentation(unsigned Level) {
   if (isEnabled())
     IndentLevel = Level;
 }
 
-// Force instantiation
-template class Logger<true>;
-template class Logger<false>;
-
 void writeToFile(llvm::StringRef What, llvm::StringRef Path) {
   std::error_code EC;
   llvm::raw_fd_ostream File(Path, EC);
diff --git a/lib/Support/LDDTree.cpp b/lib/Support/LDDTree.cpp
index 82a49cad3..fcd3a5b9f 100644
--- a/lib/Support/LDDTree.cpp
+++ b/lib/Support/LDDTree.cpp
@@ -27,7 +27,7 @@ extern "C" {
 #include "revng/Support/LDDTree.h"
 #include "revng/Support/OverflowSafeInt.h"
 
-static Logger<> Log("lddtree");
+static Logger Log("lddtree");
 
 using namespace llvm;
 
@@ -165,7 +165,7 @@ findLibrary(StringRef ToImport,
             std::optional<StringRef> RPath,
             std::optional<StringRef> RunPath) {
   revng_log(Log, "Looking for " << ToImport);
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   SmallVector<std::string, 16> SearchPaths;
 
@@ -414,7 +414,7 @@ static RecursiveCoroutine<void> lddtreeHelper(LDDTree &Dependencies,
                                               unsigned CurrentLevel,
                                               unsigned DepthLevel) {
   revng_log(Log, "lddtree for " << Path << "\n");
-  LoggerIndent<> Ident(Log);
+  LoggerIndent Ident(Log);
 
   using namespace object;
   auto MaybeBinary = createBinary(Path);
diff --git a/lib/Support/PathList.cpp b/lib/Support/PathList.cpp
index 5d8d685d1..c244d25a5 100644
--- a/lib/Support/PathList.cpp
+++ b/lib/Support/PathList.cpp
@@ -22,7 +22,7 @@ extern "C" {
 #include "revng/Support/Debug.h"
 #include "revng/Support/PathList.h"
 
-static Logger<> Log("find-resources");
+static Logger Log("find-resources");
 
 struct Resources {
   bool FirstCall = true;
@@ -103,7 +103,7 @@ findFileInPaths(llvm::StringRef FileName,
     llvm::SmallString<64> FullFileName;
     llvm::sys::path::append(FullFileName, Path, FileName);
 
-    LoggerIndent<> Indent(Log);
+    LoggerIndent Indent(Log);
 
     if (not llvm::sys::fs::exists(FullFileName)) {
       revng_log(Log, "File not found: " << FullFileName.str().str());
diff --git a/lib/Support/ProgramRunner.cpp b/lib/Support/ProgramRunner.cpp
index 31772a86c..e310441b6 100644
--- a/lib/Support/ProgramRunner.cpp
+++ b/lib/Support/ProgramRunner.cpp
@@ -21,7 +21,7 @@
 #include "revng/Support/ProgramRunner.h"
 #include "revng/Support/TemporaryFile.h"
 
-static Logger<> Log("program-runner");
+static Logger Log("program-runner");
 
 ProgramRunner Runner;
 
diff --git a/lib/TypeNames/DependencyGraph.cpp b/lib/TypeNames/DependencyGraph.cpp
index 4c1fb27fa..3a59b1cb5 100644
--- a/lib/TypeNames/DependencyGraph.cpp
+++ b/lib/TypeNames/DependencyGraph.cpp
@@ -23,7 +23,7 @@
 #include "revng/TypeNames/DependencyGraph.h"
 #include "revng/TypeNames/ModelCBuilder.h"
 
-static Logger<> Log{ "type-dependency-graph" };
+static Logger Log{ "type-dependency-graph" };
 
 using namespace llvm;
 
diff --git a/lib/TypeNames/ModelTypeNames.cpp b/lib/TypeNames/ModelTypeNames.cpp
index 6940043bb..5c1c93c1c 100644
--- a/lib/TypeNames/ModelTypeNames.cpp
+++ b/lib/TypeNames/ModelTypeNames.cpp
@@ -443,7 +443,7 @@ void ptml::ModelCBuilder::printSegmentType(const model::Segment &Segment) {
   *Out << getCommentableTag(std::move(Result) + ";\n", Binary, Segment);
 }
 
-Logger<> VariableNamingLog("variable-naming");
+Logger VariableNamingLog("variable-naming");
 
 ptml::ModelCBuilder::TagPair
 ptml::ModelCBuilder::getVariableTags(VariableNameBuilder &VariableNameBuilder,
diff --git a/lib/TypeNames/TypePrinters.cpp b/lib/TypeNames/TypePrinters.cpp
index e3e4817d8..ce93d45d3 100644
--- a/lib/TypeNames/TypePrinters.cpp
+++ b/lib/TypeNames/TypePrinters.cpp
@@ -273,7 +273,7 @@ void ptml::ModelCBuilder::printDefinition(const model::TypeDefinition &T) {
     revng_abort("Unsupported type definition.");
 }
 
-static Logger<> TypePrinterLog{ "type-definition-printer" };
+static Logger TypePrinterLog{ "type-definition-printer" };
 
 void ptml::ModelCBuilder::printTypeDefinitions() {
   if (not DependencyCache.has_value())
diff --git a/lib/UnitTestHelpers/DotGraphObject.cpp b/lib/UnitTestHelpers/DotGraphObject.cpp
index bec93d4ee..358a0a9b1 100644
--- a/lib/UnitTestHelpers/DotGraphObject.cpp
+++ b/lib/UnitTestHelpers/DotGraphObject.cpp
@@ -16,7 +16,7 @@
 
 using namespace llvm;
 
-Logger<> DotLogger("parsedot");
+Logger DotLogger("parsedot");
 
 void DotNode::addSuccessor(DotNode *NewSuccessor) {
 
diff --git a/lib/ValueMaterializer/AdvancedValueInfo.cpp b/lib/ValueMaterializer/AdvancedValueInfo.cpp
index 4200294a2..6aad20b2c 100644
--- a/lib/ValueMaterializer/AdvancedValueInfo.cpp
+++ b/lib/ValueMaterializer/AdvancedValueInfo.cpp
@@ -40,7 +40,7 @@
 
 using namespace llvm;
 
-static Logger<> AVILogger("avi");
+static Logger AVILogger("avi");
 
 inline RunningStatistics AVICFEGSizeStatitistics("avi-cfeg-size");
 
@@ -82,7 +82,7 @@ AdvancedValueInfoMFI::applyTransferFunction(Label L,
                                             const LatticeElement &E) const {
 
   revng_log(AVILogger, "   " << L->toString());
-  LoggerIndent<> Indent(AVILogger);
+  LoggerIndent Indent(AVILogger);
 
   LatticeElement Result = E;
 
@@ -326,7 +326,7 @@ runAVI(const DataFlowGraph &DFG,
 
   if (AVILogger.isEnabled()) {
     AVILogger << "Dumping MFP results:" << DoLog;
-    LoggerIndent<> Indent(AVILogger);
+    LoggerIndent Indent(AVILogger);
     for (const auto &[Node, AnalysisResults] : AllResults) {
       AVILogger << Node->toString() << ":\n";
       AVILogger << "  Initial value:\n";
diff --git a/lib/ValueMaterializer/DataFlowGraph.cpp b/lib/ValueMaterializer/DataFlowGraph.cpp
index d1ce40dd1..0e7cf6bea 100644
--- a/lib/ValueMaterializer/DataFlowGraph.cpp
+++ b/lib/ValueMaterializer/DataFlowGraph.cpp
@@ -16,7 +16,7 @@ using namespace llvm;
 
 using range_size_t = uint64_t;
 
-static Logger<> &Log = ValueMaterializerLogger;
+static Logger &Log = ValueMaterializerLogger;
 
 const range_size_t MaxMaterializedValues = (1 << 16);
 
@@ -291,7 +291,7 @@ DataFlowGraph::materializeImpl(DataFlowGraph::Node *N,
     rc_return It->second;
 
   revng_log(Log, "Materializing " << N->valueToString());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Prevent attempting to materialize more than MaxMaterializedValues
   if (N->SizeLowerBound > MaxMaterializedValues) {
diff --git a/lib/ValueMaterializer/DataFlowRangeAnalysis.cpp b/lib/ValueMaterializer/DataFlowRangeAnalysis.cpp
index cc52fe962..6eae0db62 100644
--- a/lib/ValueMaterializer/DataFlowRangeAnalysis.cpp
+++ b/lib/ValueMaterializer/DataFlowRangeAnalysis.cpp
@@ -11,7 +11,7 @@
 #include "revng/ADT/RecursiveCoroutine.h"
 #include "revng/ValueMaterializer/DataFlowRangeAnalysis.h"
 
-static Logger<> Log("data-flow-range-analysis");
+static Logger Log("data-flow-range-analysis");
 
 static bool isSigned(llvm::ICmpInst::Predicate Predicate) {
   switch (Predicate) {
@@ -217,7 +217,7 @@ private:
 std::optional<ConstantRangeSet>
 DataFlowRangeAnalysis::visit(llvm::Value &Constraint, llvm::Value &Variable) {
   revng_log(Log, "New analysis");
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   if (Log.isEnabled()) {
     Log << "Constraint: ";
@@ -242,7 +242,7 @@ revng::detail::Visitor::visit(llvm::Value &Constraint) {
     Constraint.print(*Log.getAsLLVMStream(), MST, true);
     Log << DoLog;
   }
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   // Check cache
   if (auto *Ranges = tryGet(Constraint)) {
diff --git a/lib/ValueMaterializer/ValueMaterializer.cpp b/lib/ValueMaterializer/ValueMaterializer.cpp
index e6c6492be..b15d921c6 100644
--- a/lib/ValueMaterializer/ValueMaterializer.cpp
+++ b/lib/ValueMaterializer/ValueMaterializer.cpp
@@ -13,7 +13,7 @@ void ValueMaterializer::run() {
   revng_log(ValueMaterializerLogger,
             "Evaluating " << getName(V) << " using " << getName(Context)
                           << " as context");
-  LoggerIndent<> Indent(ValueMaterializerLogger);
+  LoggerIndent Indent(ValueMaterializerLogger);
 
   DataFlowGraph = DataFlowGraph::fromValue(V, TheLimits);
 
diff --git a/lib/Yield/Assembly/DisassemblyHelper.cpp b/lib/Yield/Assembly/DisassemblyHelper.cpp
index fec1ce01b..7188e322e 100644
--- a/lib/Yield/Assembly/DisassemblyHelper.cpp
+++ b/lib/Yield/Assembly/DisassemblyHelper.cpp
@@ -13,7 +13,7 @@
 #include "revng/Yield/Assembly/DisassemblyHelper.h"
 #include "revng/Yield/Assembly/LLVMDisassemblerInterface.h"
 
-static Logger<> Log("disassemble");
+static Logger Log("disassemble");
 
 namespace detail {
 
@@ -114,7 +114,7 @@ yield::Function DH::disassemble(const model::Function &Function,
                                 const model::Binary &Binary,
                                 const model::AssemblyNameBuilder &NameBuilder) {
   revng_log(Log, "Disassembling function at " << Function.Entry().toString());
-  LoggerIndent<> Indent(Log);
+  LoggerIndent Indent(Log);
 
   yield::Function ResultFunction;
   ResultFunction.Entry() = Function.Entry();
@@ -123,7 +123,7 @@ yield::Function DH::disassemble(const model::Function &Function,
     revng_log(Log,
               "Disassembling block " << BasicBlock.ID().toString() << "-"
                                      << BasicBlock.End().toString());
-    LoggerIndent<> Indent2(Log);
+    LoggerIndent Indent2(Log);
 
     auto &Helper = getDisassemblerFor(BasicBlock.ID().start().type(),
                                       Binary.Configuration().Disassembly());
diff --git a/tools/model/import/debug-info/Main.cpp b/tools/model/import/debug-info/Main.cpp
index 586275f22..d4ac27249 100644
--- a/tools/model/import/debug-info/Main.cpp
+++ b/tools/model/import/debug-info/Main.cpp
@@ -22,7 +22,7 @@
 
 namespace cl = llvm::cl;
 
-static Logger<> Log("import-debug-info");
+static Logger Log("import-debug-info");
 
 static cl::OptionCategory ThisToolCategory("Tool options", "");