diff --git a/docs/extension.rst b/docs/extension.rst
index a53dccc71..d951e97e2 100644
--- a/docs/extension.rst
+++ b/docs/extension.rst
@@ -43,7 +43,7 @@ Bind
 
 .. codeblock:: c++
     template <typename DSL>
-    static inline void bind(const std::shared_ptr<threading::Reaction>& reaction, /*More arguments can be declared*/)
+    static void bind(const std::shared_ptr<threading::Reaction>& reaction, /*More arguments can be declared*/)
 
 This function is called when the reaction is bound, it should be thought of as the constructor. It is used to setup
 anything that is required by the DSL word.
@@ -68,7 +68,7 @@ Get
 
 .. codeblock:: c++
     template <typename DSL>
-    static inline T get(threading::Reaction&)
+    static T get(threading::Reaction& reaction)
 
 This is used to get the data for the callback. The returned value is passed to the callback.
 
@@ -84,7 +84,7 @@ Precondition
 
 .. codeblock:: c++
     template <typename DSL>
-    static inline bool precondition(threading::Reaction& reaction)
+    static bool precondition(threading::Reaction& reaction)
 
 A precondition is used to test if the reaction should run. On a true return the reaction will run as normal. On a false
 return the reaction will be dropped.
@@ -103,7 +103,7 @@ Reschedule
 
 .. codeblock:: c++
     template <typename DSL>
-    static inline std::unique_ptr<threading::ReactionTask> reschedule(std::unique_ptr<threading::ReactionTask>&& task)
+    static std::unique_ptr<threading::Reaction> reschedule(std::unique_ptr<threading::Reaction>&& task)
 
 The ownership of the reaction task is passed to the DSL word. The task returned will be run instead of the passed in
 reaction task. If the returned task is the one passed in the task will be run normally.
@@ -167,7 +167,7 @@ Now we define the `reschedule` to interrupt any new tasks if we are currently ru
 multithreaded so a mutex is needed when accessing the static members.
 .. codeblock:: c++
         template <typename DSL>
-        static inline std::unique_ptr<threading::ReactionTask> reschedule(
+        static std::unique_ptr<threading::ReactionTask> reschedule(
             std::unique_ptr<threading::ReactionTask>&& task) {
 
             // Lock our mutex
diff --git a/docs/networking.rst b/docs/networking.rst
index f80a561ae..05d0c8edf 100644
--- a/docs/networking.rst
+++ b/docs/networking.rst
@@ -43,8 +43,8 @@ checks explicitly for an explicit type. Be careful about multiple declarations.
 For this partial specialisation three static methods need to be defined.
 
 .. codeblock:: c++
-    static inline std::vector<uint8_t> serialise(const T& in)
+    static std::vector<uint8_t> serialise(const T& in)
 
-    static inline T deserialise(const std::vector<uint8_t>& in)
+    static T deserialise(const std::vector<uint8_t>& in)
 
-    static inline uint64_t hash()
+    static uint64_t hash()
diff --git a/src/PowerPlant.cpp b/src/PowerPlant.cpp
index f4f271e8b..15ecc76f0 100644
--- a/src/PowerPlant.cpp
+++ b/src/PowerPlant.cpp
@@ -22,11 +22,49 @@
 
 #include "PowerPlant.hpp"
 
+#include <exception>
+#include <tuple>
+
+#include "Reactor.hpp"
+#include "dsl/store/DataStore.hpp"
+#include "dsl/word/Shutdown.hpp"
+#include "dsl/word/Startup.hpp"
+#include "dsl/word/emit/Direct.hpp"
+#include "message/CommandLineArguments.hpp"
+#include "message/LogMessage.hpp"
+#include "threading/ReactionTask.hpp"
+
 namespace NUClear {
+namespace util {
+    struct GroupDescriptor;
+    struct ThreadPoolDescriptor;
+}  // namespace util
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 PowerPlant* PowerPlant::powerplant = nullptr;
 
+// This is taking argc and argv as given by main so this should not take an array
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
+PowerPlant::PowerPlant(Configuration config, int argc, const char* argv[]) : scheduler(config.thread_count) {
+
+    // Stop people from making more then one powerplant
+    if (powerplant != nullptr) {
+        throw std::runtime_error("There is already a powerplant in existence (There should be a single PowerPlant)");
+    }
+
+    // Store our static variable
+    powerplant = this;
+
+    // Emit our arguments if any.
+    message::CommandLineArguments args;
+    for (int i = 0; i < argc; ++i) {
+        args.emplace_back(argv[i]);
+    }
+
+    // Emit our command line arguments
+    emit(std::make_unique<message::CommandLineArguments>(args));
+}
+
 PowerPlant::~PowerPlant() {
     // Make sure reactors are destroyed before anything else
     while (!reactors.empty()) {
@@ -50,6 +88,16 @@ void PowerPlant::start() {
     scheduler.start();
 }
 
+void PowerPlant::add_idle_task(const NUClear::id_t& id,
+                               const util::ThreadPoolDescriptor& pool_descriptor,
+                               std::function<void()>&& task) {
+    scheduler.add_idle_task(id, pool_descriptor, std::move(task));
+}
+
+void PowerPlant::remove_idle_task(const NUClear::id_t& id, const util::ThreadPoolDescriptor& pool_descriptor) {
+    scheduler.remove_idle_task(id, pool_descriptor);
+}
+
 void PowerPlant::submit(const NUClear::id_t& id,
                         const int& priority,
                         const util::GroupDescriptor& group,
@@ -75,14 +123,19 @@ void PowerPlant::submit(std::unique_ptr<threading::ReactionTask>&& task, const b
     }
 }
 
-void PowerPlant::add_idle_task(const NUClear::id_t& id,
-                               const util::ThreadPoolDescriptor& pool_descriptor,
-                               std::function<void()>&& task) {
-    scheduler.add_idle_task(id, pool_descriptor, std::move(task));
-}
+void PowerPlant::log(const LogLevel& level, std::string message) {
+    // Get the current task
+    const auto* current_task = threading::ReactionTask::get_current_task();
 
-void PowerPlant::remove_idle_task(const NUClear::id_t& id, const util::ThreadPoolDescriptor& pool_descriptor) {
-    scheduler.remove_idle_task(id, pool_descriptor);
+    // Direct emit the log message so that any direct loggers can use it
+    emit<dsl::word::emit::Direct>(std::make_unique<message::LogMessage>(
+        level,
+        current_task != nullptr ? current_task->parent.reactor.log_level : LogLevel::UNKNOWN,
+        std::move(message),
+        current_task != nullptr ? current_task->stats : nullptr));
+}
+void PowerPlant::log(const LogLevel& level, std::stringstream& message) {
+    log(level, message.str());
 }
 
 void PowerPlant::shutdown() {
@@ -101,4 +154,5 @@ void PowerPlant::shutdown() {
 bool PowerPlant::running() const {
     return is_running.load();
 }
+
 }  // namespace NUClear
diff --git a/src/PowerPlant.hpp b/src/PowerPlant.hpp
index 27270e0f6..5b5cfd526 100644
--- a/src/PowerPlant.hpp
+++ b/src/PowerPlant.hpp
@@ -20,38 +20,41 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_POWERPLANT_HPP
-#define NUCLEAR_POWERPLANT_HPP
+#ifndef NUCLEAR_POWER_PLANT_HPP
+#define NUCLEAR_POWER_PLANT_HPP
 
 #include <atomic>
-#include <iostream>
-#include <map>
+#include <functional>
 #include <memory>
-#include <mutex>
-#include <queue>
-#include <set>
 #include <sstream>
-#include <string>
-#include <thread>
-#include <typeindex>
+#include <utility>
 #include <vector>
 
 // Utilities
 #include "Configuration.hpp"
+#include "Environment.hpp"
 #include "LogLevel.hpp"
 #include "id.hpp"
-#include "message/LogMessage.hpp"
 #include "threading/ReactionTask.hpp"
 #include "threading/TaskScheduler.hpp"
 #include "util/FunctionFusion.hpp"
 #include "util/demangle.hpp"
-#include "util/main_thread_id.hpp"
-#include "util/unpack.hpp"
 
 namespace NUClear {
 
-// Forward declare reactor
+// Forward declarations
 class Reactor;
+namespace util {
+    struct ThreadPoolDescriptor;
+}  // namespace util
+namespace dsl {
+    namespace word {
+        namespace emit {
+            template <typename T>
+            struct Local;
+        }  // namespace emit
+    }  // namespace word
+}  // namespace dsl
 
 /**
  * The PowerPlant is the core of a NUClear system. It holds all Reactors in it and manages their communications.
@@ -64,6 +67,23 @@ class PowerPlant {
     // Reactors and PowerPlants are very tightly linked
     friend class Reactor;
 
+    /**
+     * This is our Function Fusion wrapper class that allows it to call emit functions
+     *
+     * @tparam Handler The emit handler that we are wrapping for
+     */
+    template <typename Handler>
+    struct EmitCaller {
+        template <typename... Arguments>
+        static auto call(Arguments&&... args)
+            // THIS IS VERY IMPORTANT, the return type must be dependent on the function call
+            // otherwise it won't check it's valid in SFINAE (the comma operator does it again!)
+            -> decltype(Handler::emit(std::forward<Arguments>(args)...), true) {
+            Handler::emit(std::forward<Arguments>(args)...);
+            return true;
+        }
+    };
+
 public:
     // There can only be one powerplant, so this is it
     static PowerPlant* powerplant;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -104,7 +124,7 @@ class PowerPlant {
     /**
      * Gets the current running state of the PowerPlant.
      *
-     * @return True if the PowerPlant is running, false if it is shut down, or is in the process of shutting down.
+     * @return `true` if the PowerPlant is running, `false` if it is shut down, or is in the process of shutting down.
      */
     bool running() const;
 
@@ -112,8 +132,7 @@ class PowerPlant {
      * Installs a reactor of a particular type to the system.
      *
      * This function constructs a new Reactor of the template type.
-     * It passes through the specified LogLevel
-     * in the environment of that reactor so that it can be used to filter logs.
+     * It passes the specified LogLevel in the environment of that reactor so that it can be used to filter logs.
      *
      * @tparam T     The type of the reactor to build and install
      * @tparam Args  The types of the extra arguments to pass to the reactor constructor
@@ -124,7 +143,17 @@ class PowerPlant {
      * @return A reference to the installed reactor
      */
     template <typename T, typename... Args>
-    T& install(Args&&... args);
+    T& install(Args&&... args) {
+
+        // Make sure that the class that we received is a reactor
+        static_assert(std::is_base_of<Reactor, T>::value, "You must install Reactors");
+
+        // The reactor constructor should handle subscribing to events
+        reactors.push_back(std::make_unique<T>(std::make_unique<Environment>(*this, util::demangle(typeid(T).name())),
+                                               std::forward<Args>(args)...));
+
+        return static_cast<T&>(*reactors.back());
+    }
 
     /**
      * Adds an idle task to the task scheduler.
@@ -189,7 +218,26 @@ class PowerPlant {
      * @param args The arguments we are logging
      */
     template <enum LogLevel level, typename... Arguments>
-    static void log(Arguments&&... args);
+    void log(Arguments&&... args) {
+        log(level, std::forward<Arguments>(args)...);
+    }
+    template <typename... Arguments>
+    void log(const LogLevel& level, Arguments&&... args) {
+        std::stringstream ss;
+        log(level, ss, std::forward<Arguments>(args)...);
+    }
+    template <typename First, typename... Arguments>
+    void log(const LogLevel& level, std::stringstream& ss, First&& first, Arguments&&... args) {
+        ss << std::forward<First>(first) << " ";
+        log(level, ss, std::forward<Arguments>(args)...);
+    }
+    template <typename Last>
+    void log(const LogLevel& level, std::stringstream& ss, Last&& last) {
+        ss << std::forward<Last>(last);
+        log(level, ss);
+    }
+    void log(const LogLevel& level, std::stringstream& message);
+    void log(const LogLevel& level, std::string message);
 
     /**
      * Emits data to the system and routes it to the other systems that use it.
@@ -203,9 +251,38 @@ class PowerPlant {
      * @param data The data we are emitting
      */
     template <typename T>
-    void emit(std::unique_ptr<T>&& data);
+    void emit(std::unique_ptr<T>&& data) {
+        emit<dsl::word::emit::Local>(std::move(data));
+    }
     template <typename T>
-    void emit(std::unique_ptr<T>& data);
+    void emit(std::unique_ptr<T>& data) {
+        emit<dsl::word::emit::Local>(std::move(data));
+    }
+    template <template <typename> class First,
+              template <typename>
+              class... Remainder,
+              typename T,
+              typename... Arguments>
+    void emit(std::unique_ptr<T>& data, Arguments&&... args) {
+        emit<First, Remainder...>(std::move(data), std::forward<Arguments>(args)...);
+    }
+
+    template <template <typename> class First,
+              template <typename>
+              class... Remainder,
+              typename T,
+              typename... Arguments>
+    void emit(std::unique_ptr<T>&& data, Arguments&&... args) {
+
+        // Release our data from the pointer and wrap it in a shared_ptr
+        emit_shared<First, Remainder...>(std::shared_ptr<T>(std::move(data)), std::forward<Arguments>(args)...);
+    }
+
+    template <template <typename> class First, template <typename> class... Remainder, typename... Arguments>
+    void emit(Arguments&&... args) {
+
+        emit_shared<First, Remainder...>(std::forward<Arguments>(args)...);
+    }
 
     /**
      * Emits data to the system and routes it to the other systems that use it.
@@ -234,29 +311,41 @@ class PowerPlant {
               class... Remainder,
               typename T,
               typename... Arguments>
-    void emit_shared(std::shared_ptr<T> data, Arguments&&... args);
+    void emit_shared(std::shared_ptr<T> data, Arguments&&... args) {
 
-    template <template <typename> class First, template <typename> class... Remainder, typename... Arguments>
-    void emit_shared(Arguments&&... args);
+        using Functions      = std::tuple<First<T>, Remainder<T>...>;
+        using ArgumentPack   = decltype(std::forward_as_tuple(*this, data, std::forward<Arguments>(args)...));
+        using CallerArgs     = std::tuple<>;
+        using FusionFunction = util::FunctionFusion<Functions, ArgumentPack, EmitCaller, CallerArgs, 2>;
 
-    template <template <typename> class First,
-              template <typename>
-              class... Remainder,
-              typename T,
-              typename... Arguments>
-    void emit(std::unique_ptr<T>&& data, Arguments&&... args);
+        // Provide a check to make sure they are passing us the right stuff
+        static_assert(
+            FusionFunction::value,
+            "There was an error with the arguments for the emit function, Check that your scope and arguments "
+            "match what you are trying to do.");
 
-    template <template <typename> class First,
-              template <typename>
-              class... Remainder,
-              typename T,
-              typename... Arguments>
-    void emit(std::unique_ptr<T>& data, Arguments&&... args);
+        // Fuse our emit handlers and call the fused function
+        FusionFunction::call(*this, data, std::forward<Arguments>(args)...);
+    }
 
     template <template <typename> class First, template <typename> class... Remainder, typename... Arguments>
-    void emit(Arguments&&... args);
+    void emit_shared(Arguments&&... args) {
+
+        using Functions      = std::tuple<First<void>, Remainder<void>...>;
+        using ArgumentPack   = decltype(std::forward_as_tuple(*this, std::forward<Arguments>(args)...));
+        using CallerArgs     = std::tuple<>;
+        using FusionFunction = util::FunctionFusion<Functions, ArgumentPack, EmitCaller, CallerArgs, 1>;
+
+        // Provide a check to make sure they are passing us the right stuff
+        static_assert(
+            FusionFunction::value,
+            "There was an error with the arguments for the emit function, Check that your scope and arguments "
+            "match what you are trying to do.");
+
+        // Fuse our emit handlers and call the fused function
+        FusionFunction::call(*this, std::forward<Arguments>(args)...);
+    }
 
-private:
     /// A list of tasks that must be run when the powerplant starts up
     std::vector<std::function<void()>> tasks;
     /// Our TaskScheduler that handles distributing task to the pool threads
@@ -281,21 +370,17 @@ class PowerPlant {
  */
 template <enum LogLevel level = NUClear::DEBUG, typename... Arguments>
 void log(Arguments&&... args) {
-    PowerPlant::log<level>(std::forward<Arguments>(args)...);
+    if (PowerPlant::powerplant != nullptr) {
+        PowerPlant::powerplant->log<level>(std::forward<Arguments>(args)...);
+    }
+}
+template <typename... Arguments>
+void log(const LogLevel& level, Arguments&&... args) {
+    if (PowerPlant::powerplant != nullptr) {
+        PowerPlant::powerplant->log(level, std::forward<Arguments>(args)...);
+    }
 }
 
 }  // namespace NUClear
 
-// Include our Reactor.h first as the tight coupling between powerplant and reactor requires a specific include order
-#include "Reactor.hpp"
-#include "dsl/word/emit/Direct.hpp"
-#include "dsl/word/emit/Initialise.hpp"
-#include "dsl/word/emit/Local.hpp"
-#include "message/CommandLineArguments.hpp"
-#include "message/NetworkConfiguration.hpp"
-#include "message/NetworkEvent.hpp"
-
-// Include all of our implementation files (which use the previously included reactor.h)
-#include "PowerPlant.ipp"
-
-#endif  // NUCLEAR_POWERPLANT_HPP
+#endif  // NUCLEAR_POWER_PLANT_HPP
diff --git a/src/PowerPlant.ipp b/src/PowerPlant.ipp
deleted file mode 100644
index d0b5368b8..000000000
--- a/src/PowerPlant.ipp
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2013 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include "extension/ChronoController.hpp"
-#include "extension/IOController.hpp"
-#include "extension/NetworkController.hpp"
-
-namespace NUClear {
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
-inline PowerPlant::PowerPlant(Configuration config, int argc, const char* argv[]) : scheduler(config.thread_count) {
-
-    // Stop people from making more then one powerplant
-    if (powerplant != nullptr) {
-        throw std::runtime_error("There is already a powerplant in existence (There should be a single PowerPlant)");
-    }
-
-    // Store our static variable
-    powerplant = this;
-
-    // Install the Chrono reactor
-    install<extension::ChronoController>();
-    install<extension::IOController>();
-    install<extension::NetworkController>();
-
-    // Emit our arguments if any.
-    message::CommandLineArguments args;
-    for (int i = 0; i < argc; ++i) {
-        args.emplace_back(argv[i]);
-    }
-
-    // Emit our command line arguments
-    emit(std::make_unique<message::CommandLineArguments>(args));
-}
-
-template <typename T, typename... Args>
-T& PowerPlant::install(Args&&... args) {
-
-    // Make sure that the class that we received is a reactor
-    static_assert(std::is_base_of<Reactor, T>::value, "You must install Reactors");
-
-    // The reactor constructor should handle subscribing to events
-    reactors.push_back(std::make_unique<T>(std::make_unique<Environment>(*this, util::demangle(typeid(T).name())),
-                                           std::forward<Args>(args)...));
-
-    return static_cast<T&>(*reactors.back());
-}
-
-// Default emit with no types
-template <typename T>
-void PowerPlant::emit(std::unique_ptr<T>&& data) {
-
-    emit<dsl::word::emit::Local>(std::move(data));
-}
-// Default emit with no types
-template <typename T>
-void PowerPlant::emit(std::unique_ptr<T>& data) {
-
-    emit<dsl::word::emit::Local>(std::move(data));
-}
-
-// Default emit with no types
-template <template <typename> class First, template <typename> class... Remainder, typename T, typename... Arguments>
-void PowerPlant::emit(std::unique_ptr<T>& data, Arguments&&... args) {
-
-    emit<First, Remainder...>(std::move(data), std::forward<Arguments>(args)...);
-}
-
-/**
- * This is our Function Fusion wrapper class that allows it to call emit functions
- *
- * @tparam Handler The emit handler that we are wrapping for
- */
-template <typename Handler>
-struct EmitCaller {
-    template <typename... Arguments>
-    static auto call(Arguments&&... args)
-        // THIS IS VERY IMPORTANT, the return type must be dependent on the function call
-        // otherwise it won't check it's valid in SFINAE (the comma operator does it again!)
-        -> decltype(Handler::emit(std::forward<Arguments>(args)...), true) {
-        Handler::emit(std::forward<Arguments>(args)...);
-        return true;
-    }
-};
-
-// Global emit handlers
-
-
-template <template <typename> class First, template <typename> class... Remainder, typename T, typename... Arguments>
-void PowerPlant::emit_shared(std::shared_ptr<T> data, Arguments&&... args) {
-
-    using Functions      = std::tuple<First<T>, Remainder<T>...>;
-    using ArgumentPack   = decltype(std::forward_as_tuple(*this, data, std::forward<Arguments>(args)...));
-    using CallerArgs     = std::tuple<>;
-    using FusionFunction = util::FunctionFusion<Functions, ArgumentPack, EmitCaller, CallerArgs, 2>;
-
-    // Provide a check to make sure they are passing us the right stuff
-    static_assert(FusionFunction::value,
-                  "There was an error with the arguments for the emit function, Check that your scope and arguments "
-                  "match what you are trying to do.");
-
-    // Fuse our emit handlers and call the fused function
-    FusionFunction::call(*this, data, std::forward<Arguments>(args)...);
-}
-
-template <template <typename> class First, template <typename> class... Remainder, typename... Arguments>
-void PowerPlant::emit_shared(Arguments&&... args) {
-
-    using Functions      = std::tuple<First<void>, Remainder<void>...>;
-    using ArgumentPack   = decltype(std::forward_as_tuple(*this, std::forward<Arguments>(args)...));
-    using CallerArgs     = std::tuple<>;
-    using FusionFunction = util::FunctionFusion<Functions, ArgumentPack, EmitCaller, CallerArgs, 1>;
-
-    // Provide a check to make sure they are passing us the right stuff
-    static_assert(FusionFunction::value,
-                  "There was an error with the arguments for the emit function, Check that your scope and arguments "
-                  "match what you are trying to do.");
-
-    // Fuse our emit handlers and call the fused function
-    FusionFunction::call(*this, std::forward<Arguments>(args)...);
-}
-
-template <template <typename> class First, template <typename> class... Remainder, typename T, typename... Arguments>
-void PowerPlant::emit(std::unique_ptr<T>&& data, Arguments&&... args) {
-
-    // Release our data from the pointer and wrap it in a shared_ptr
-    emit_shared<First, Remainder...>(std::shared_ptr<T>(std::move(data)), std::forward<Arguments>(args)...);
-}
-
-template <template <typename> class First, template <typename> class... Remainder, typename... Arguments>
-void PowerPlant::emit(Arguments&&... args) {
-
-    emit_shared<First, Remainder...>(std::forward<Arguments>(args)...);
-}
-
-template <typename T>
-inline void log_impl(std::stringstream& output, T&& first) {
-    output << std::forward<T>(first);
-}
-
-template <typename First, typename... Remainder>
-inline void log_impl(std::stringstream& output, First&& first, Remainder&&... args) {
-    output << std::forward<First>(first) << " ";
-    log_impl(output, std::forward<Remainder>(args)...);
-}
-
-template <enum LogLevel level, typename... Arguments>
-void PowerPlant::log(Arguments&&... args) {
-
-    // If there is no powerplant then do nothing
-    if (powerplant == nullptr) {
-        return;
-    }
-
-    // Get the current task
-    const auto* current_task = threading::ReactionTask::get_current_task();
-
-    // Build our log message by concatenating everything to a stream
-    std::stringstream output_stream;
-    log_impl(output_stream, std::forward<Arguments>(args)...);
-
-    // Direct emit the log message so that any direct loggers can use it
-    powerplant->emit<dsl::word::emit::Direct>(std::make_unique<message::LogMessage>(
-        level,
-        current_task != nullptr ? current_task->parent.reactor.log_level : LogLevel::UNKNOWN,
-        output_stream.str(),
-        current_task != nullptr ? current_task->stats : nullptr));
-}
-
-}  // namespace NUClear
diff --git a/src/Reactor.hpp b/src/Reactor.hpp
index f50057462..6aed37499 100644
--- a/src/Reactor.hpp
+++ b/src/Reactor.hpp
@@ -23,11 +23,9 @@
 #ifndef NUCLEAR_REACTOR_HPP
 #define NUCLEAR_REACTOR_HPP
 
-#include <atomic>
 #include <chrono>
 #include <functional>
 #include <regex>
-#include <sstream>
 #include <string>
 #include <typeindex>
 #include <vector>
@@ -40,6 +38,7 @@
 #include "threading/ReactionIdentifiers.hpp"
 #include "util/CallbackGenerator.hpp"
 #include "util/Sequence.hpp"
+#include "util/demangle.hpp"
 #include "util/tuplify.hpp"
 
 namespace NUClear {
@@ -370,7 +369,7 @@ class Reactor {
      * This function is used to create a Reaction in the system.
      * By providing the correct template parameters, this function can modify how and when this reaction runs.
      *
-     * @tparam DSL     The NUClear domain specific language information
+     * @tparam DSL          The NUClear domain specific language information
      * @tparam Arguments    The types of the arguments passed into the function
      *
      * @param args      The arguments that will be passed to each of the binding DSL words in order
@@ -425,7 +424,24 @@ class Reactor {
     void log(Arguments&&... args) const {
 
         // If the log is above or equal to our log level
-        PowerPlant::log<level>(std::forward<Arguments>(args)...);
+        powerplant.log<level>(std::forward<Arguments>(args)...);
+    }
+
+    /**
+     * Log a message through NUClear's system.
+     *
+     * Logs a message through the system so the various log handlers can access it.
+     *
+     * @tparam Arguments The types of the arguments we are logging
+     *
+     * @param level The level to log at
+     * @param args The arguments we are logging
+     */
+    template <typename... Arguments>
+    void log(const LogLevel& level, Arguments&&... args) const {
+
+        // If the log is above or equal to our log level
+        powerplant.log(level, std::forward<Arguments>(args)...);
     }
 };
 
diff --git a/src/clock.cpp b/src/clock.cpp
new file mode 100644
index 000000000..e5990b8fb
--- /dev/null
+++ b/src/clock.cpp
@@ -0,0 +1,85 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2013 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "clock.hpp"
+
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <mutex>
+
+namespace NUClear {
+
+namespace {
+    template <typename T>
+    clock::duration dc(const T& t) {
+        return std::chrono::duration_cast<clock::duration>(t);
+    }
+}  // namespace
+
+clock::time_point clock::now() {
+    const ClockData current = data[active.load(std::memory_order_acquire)];  // Take a copy in case it changes
+    return current.epoch + dc((base_clock::now() - current.base_from) * current.rtf);
+}
+
+void clock::adjust_clock(const duration& adjustment, const double& rtf) {
+    const std::lock_guard<std::mutex> lock(mutex);
+    // Load the current state
+    const int c         = active.load(std::memory_order_relaxed);
+    const auto& current = data[c];
+    const int n         = int((c + 1) % data.size());
+    auto& next          = data[n];
+
+    // Perform the update
+    auto base      = base_clock::now();
+    next.epoch     = current.epoch + adjustment + dc((base - current.base_from) * current.rtf);
+    next.base_from = base;
+    next.rtf       = rtf;
+    active.store(n, std::memory_order_release);
+}
+
+void clock::set_clock(const time_point& time, const double& rtf) {
+    const std::lock_guard<std::mutex> lock(mutex);
+    // Load the next state
+    const int c = active.load(std::memory_order_acquire);
+    const int n = int((c + 1) % data.size());
+    auto& next  = data[n];
+
+    // Perform the update
+    auto base      = base_clock::now();
+    next.epoch     = time;
+    next.base_from = base;
+    next.rtf       = rtf;
+    active         = n;
+}
+
+double clock::rtf() {
+    return data[active.load(std::memory_order_acquire)].rtf;
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::mutex clock::mutex;
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::array<clock::ClockData, 3> clock::data = std::array<typename clock::ClockData, 3>{};
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+std::atomic<int> clock::active{0};
+
+}  // namespace NUClear
diff --git a/src/clock.hpp b/src/clock.hpp
index 8092d677e..6cdcdc4f3 100644
--- a/src/clock.hpp
+++ b/src/clock.hpp
@@ -38,8 +38,7 @@ namespace NUClear {
 /**
  * A clock class that extends a base clock type and allows for clock adjustment and setting.
  */
-template <typename = void>
-struct nuclear_clock : NUCLEAR_CLOCK_TYPE {
+struct clock : NUCLEAR_CLOCK_TYPE {
     using base_clock = NUCLEAR_CLOCK_TYPE;
 
     /**
@@ -47,10 +46,7 @@ struct nuclear_clock : NUCLEAR_CLOCK_TYPE {
      *
      * @return The current time of the clock.
      */
-    static time_point now() {
-        const ClockData current = data[active.load()];  // Take a copy in case it changes
-        return current.epoch + dc((base_clock::now() - current.base_from) * current.rtf);
-    }
+    static time_point now();
 
     /**
      * Adjust the clock by a specified duration and real-time factor.
@@ -58,20 +54,7 @@ struct nuclear_clock : NUCLEAR_CLOCK_TYPE {
      * @param adjustment The duration by which to adjust the clock.
      * @param rtf        The real-time factor to apply to the clock.
      */
-    static void adjust_clock(const duration& adjustment, const double& rtf = 1.0) {
-        const std::lock_guard<std::mutex> lock(mutex);
-        // Load the current state
-        const auto& current = data[active.load()];
-        const int n         = static_cast<int>((active.load() + 1) % data.size());
-        auto& next          = data[n];
-
-        // Perform the update
-        auto base      = base_clock::now();
-        next.epoch     = current.epoch + adjustment + dc((base - current.base_from) * current.rtf);
-        next.base_from = base;
-        next.rtf       = rtf;
-        active         = n;
-    }
+    static void adjust_clock(const duration& adjustment, const double& rtf = 1.0);
 
     /**
      * Set the clock to a specified time and real-time factor.
@@ -79,45 +62,17 @@ struct nuclear_clock : NUCLEAR_CLOCK_TYPE {
      * @param time The time to set the clock to.
      * @param rtf  The real-time factor to apply to the clock.
      */
-    static void set_clock(const time_point& time, const double& rtf = 1.0) {
-        const std::lock_guard<std::mutex> lock(mutex);
-        // Load the current state
-        const int n = static_cast<int>((active.load() + 1) % data.size());
-        auto& next  = data[n];
-
-        // Perform the update
-        auto base      = base_clock::now();
-        next.epoch     = time;
-        next.base_from = base;
-        next.rtf       = rtf;
-        active         = n;
-    }
+    static void set_clock(const time_point& time, const double& rtf = 1.0);
 
 
     /**
      * Get the real-time factor of the clock.
      *
-     * @return The real-time factor of the clock.
+     * @return The real-time factor of the clock
      */
-    static double rtf() {
-        return data[active.load()].rtf;
-    }
+    static double rtf();
 
 private:
-    /**
-     * Convert a duration to the clock's duration type.
-     *
-     * @tparam T The type of the duration.
-     *
-     * @param t The duration to convert.
-     *
-     * @return  The converted duration.
-     */
-    template <typename T>
-    duration static dc(const T& t) {
-        return std::chrono::duration_cast<duration>(t);
-    }
-
     /**
      * Data structure to hold clock information.
      */
@@ -142,20 +97,6 @@ struct nuclear_clock : NUCLEAR_CLOCK_TYPE {
     static std::atomic<int> active;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 };
 
-template <typename T>
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::mutex nuclear_clock<T>::mutex;
-template <typename T>
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::array<typename nuclear_clock<T>::ClockData, 3> nuclear_clock<T>::data =
-    std::array<typename nuclear_clock<T>::ClockData, 3>{};
-template <typename T>
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::atomic<int> nuclear_clock<T>::active{0};
-
-using clock = nuclear_clock<>;
-
-
 }  // namespace NUClear
 
 #endif  // NUCLEAR_CLOCK_HPP
diff --git a/src/dsl/fusion/BindFusion.hpp b/src/dsl/fusion/BindFusion.hpp
index 3b44f3ffb..ffc30fca3 100644
--- a/src/dsl/fusion/BindFusion.hpp
+++ b/src/dsl/fusion/BindFusion.hpp
@@ -20,11 +20,11 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_BINDFUSION_HPP
-#define NUCLEAR_DSL_FUSION_BINDFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
 
-#include "../../threading/ReactionHandle.hpp"
-#include "../../util/tuplify.hpp"
+#include "../../threading/Reaction.hpp"
+#include "../../util/FunctionFusion.hpp"
 #include "../operation/DSLProxy.hpp"
 #include "has_bind.hpp"
 
@@ -152,4 +152,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_BINDFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_BIND_FUSION_HPP
diff --git a/src/dsl/fusion/GetFusion.hpp b/src/dsl/fusion/GetFusion.hpp
index bc9ab8e55..831c7a963 100644
--- a/src/dsl/fusion/GetFusion.hpp
+++ b/src/dsl/fusion/GetFusion.hpp
@@ -20,10 +20,10 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_GETFUSION_HPP
-#define NUCLEAR_DSL_FUSION_GETFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_GET_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_GET_FUSION_HPP
 
-#include "../../threading/ReactionHandle.hpp"
+#include "../../threading/Reaction.hpp"
 #include "../../util/tuplify.hpp"
 #include "../operation/DSLProxy.hpp"
 #include "has_get.hpp"
@@ -110,4 +110,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_GETFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_GET_FUSION_HPP
diff --git a/src/dsl/fusion/GroupFusion.hpp b/src/dsl/fusion/GroupFusion.hpp
index c85891990..2a717d7b0 100644
--- a/src/dsl/fusion/GroupFusion.hpp
+++ b/src/dsl/fusion/GroupFusion.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_GROUPFUSION_HPP
-#define NUCLEAR_DSL_FUSION_GROUPFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
 
 #include <algorithm>
 #include <stdexcept>
@@ -101,4 +101,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_GROUPFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_GROUP_FUSION_HPP
diff --git a/src/dsl/fusion/NoOp.hpp b/src/dsl/fusion/NoOp.hpp
index a2d9e10d5..3adf3e113 100644
--- a/src/dsl/fusion/NoOp.hpp
+++ b/src/dsl/fusion/NoOp.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_NOOP_HPP
-#define NUCLEAR_DSL_FUSION_NOOP_HPP
+#ifndef NUCLEAR_DSL_FUSION_NO_OP_HPP
+#define NUCLEAR_DSL_FUSION_NO_OP_HPP
 
 #include <typeindex>
 
@@ -103,4 +103,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_NOOP_HPP
+#endif  // NUCLEAR_DSL_FUSION_NO_OP_HPP
diff --git a/src/dsl/fusion/PoolFusion.hpp b/src/dsl/fusion/PoolFusion.hpp
index e5f79eef6..4064dc5b9 100644
--- a/src/dsl/fusion/PoolFusion.hpp
+++ b/src/dsl/fusion/PoolFusion.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_POOLFUSION_HPP
-#define NUCLEAR_DSL_FUSION_POOLFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
 
 #include <algorithm>
 #include <stdexcept>
@@ -101,4 +101,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_POOLFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_POOL_FUSION_HPP
diff --git a/src/dsl/fusion/PostconditionFusion.hpp b/src/dsl/fusion/PostconditionFusion.hpp
index 26d8887b9..ac0413c35 100644
--- a/src/dsl/fusion/PostconditionFusion.hpp
+++ b/src/dsl/fusion/PostconditionFusion.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_POSTCONDITIONFUSION_HPP
-#define NUCLEAR_DSL_FUSION_POSTCONDITIONFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
 
 #include "../../threading/ReactionTask.hpp"
 #include "../operation/DSLProxy.hpp"
@@ -105,4 +105,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_POSTCONDITIONFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_POSTCONDITION_FUSION_HPP
diff --git a/src/dsl/fusion/PreconditionFusion.hpp b/src/dsl/fusion/PreconditionFusion.hpp
index d4d16f490..ae1c418e7 100644
--- a/src/dsl/fusion/PreconditionFusion.hpp
+++ b/src/dsl/fusion/PreconditionFusion.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_PRECONDITIONFUSION_HPP
-#define NUCLEAR_DSL_FUSION_PRECONDITIONFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
 
 #include "../../threading/Reaction.hpp"
 #include "../operation/DSLProxy.hpp"
@@ -102,4 +102,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_PRECONDITIONFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_PRECONDITION_FUSION_HPP
diff --git a/src/dsl/fusion/PriorityFusion.hpp b/src/dsl/fusion/PriorityFusion.hpp
index 6f2bf85fd..a28c78af1 100644
--- a/src/dsl/fusion/PriorityFusion.hpp
+++ b/src/dsl/fusion/PriorityFusion.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_FUSION_PRIORITYFUSION_HPP
-#define NUCLEAR_DSL_FUSION_PRIORITYFUSION_HPP
+#ifndef NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
+#define NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
 
 #include "../../threading/Reaction.hpp"
 #include "../operation/DSLProxy.hpp"
@@ -101,4 +101,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_FUSION_PRIORITYFUSION_HPP
+#endif  // NUCLEAR_DSL_FUSION_PRIORITY_FUSION_HPP
diff --git a/src/dsl/operation/CacheGet.hpp b/src/dsl/operation/CacheGet.hpp
index 405fe2c3d..8d2280e4c 100644
--- a/src/dsl/operation/CacheGet.hpp
+++ b/src/dsl/operation/CacheGet.hpp
@@ -20,10 +20,11 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_OPERATION_CACHEGET_HPP
-#define NUCLEAR_DSL_OPERATION_CACHEGET_HPP
+#ifndef NUCLEAR_DSL_OPERATION_CACHE_GET_HPP
+#define NUCLEAR_DSL_OPERATION_CACHE_GET_HPP
 
 #include "../store/DataStore.hpp"
+#include "../store/ThreadStore.hpp"
 
 namespace NUClear {
 namespace dsl {
@@ -54,4 +55,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_OPERATION_CACHEGET_HPP
+#endif  // NUCLEAR_DSL_OPERATION_CACHE_GET_HPP
diff --git a/src/dsl/operation/ChronoTask.hpp b/src/dsl/operation/ChronoTask.hpp
index bf6e20109..1ed433d71 100644
--- a/src/dsl/operation/ChronoTask.hpp
+++ b/src/dsl/operation/ChronoTask.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_OPERATION_CHRONOTASK_HPP
-#define NUCLEAR_DSL_OPERATION_CHRONOTASK_HPP
+#ifndef NUCLEAR_DSL_OPERATION_CHRONO_TASK_HPP
+#define NUCLEAR_DSL_OPERATION_CHRONO_TASK_HPP
 
 #include "../../clock.hpp"
 #include "../../id.hpp"
@@ -107,4 +107,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_OPERATION_CHRONOTASK_HPP
+#endif  // NUCLEAR_DSL_OPERATION_CHRONO_TASK_HPP
diff --git a/src/dsl/operation/DSLProxy.hpp b/src/dsl/operation/DSLProxy.hpp
index 295bbf4d6..8265c4c86 100644
--- a/src/dsl/operation/DSLProxy.hpp
+++ b/src/dsl/operation/DSLProxy.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_OPERATION_DSLPROXY_HPP
-#define NUCLEAR_DSL_OPERATION_DSLPROXY_HPP
+#ifndef NUCLEAR_DSL_OPERATION_DSL_PROXY_HPP
+#define NUCLEAR_DSL_OPERATION_DSL_PROXY_HPP
 
 namespace NUClear {
 namespace dsl {
@@ -43,4 +43,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_OPERATION_DSLPROXY_HPP
+#endif  // NUCLEAR_DSL_OPERATION_DSL_PROXY_HPP
diff --git a/src/dsl/operation/TypeBind.hpp b/src/dsl/operation/TypeBind.hpp
index 1f2defcf4..016fc06ce 100644
--- a/src/dsl/operation/TypeBind.hpp
+++ b/src/dsl/operation/TypeBind.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_OPERATION_TYPEBIND_HPP
-#define NUCLEAR_DSL_OPERATION_TYPEBIND_HPP
+#ifndef NUCLEAR_DSL_OPERATION_TYPE_BIND_HPP
+#define NUCLEAR_DSL_OPERATION_TYPE_BIND_HPP
 
 #include "../store/TypeCallbackStore.hpp"
 
@@ -98,4 +98,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_OPERATION_TYPEBIND_HPP
+#endif  // NUCLEAR_DSL_OPERATION_TYPE_BIND_HPP
diff --git a/src/dsl/trait/is_transient.hpp b/src/dsl/trait/is_transient.hpp
index 01d2af0be..60f682e94 100644
--- a/src/dsl/trait/is_transient.hpp
+++ b/src/dsl/trait/is_transient.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_TRAIT_ISTRANSIENT_HPP
-#define NUCLEAR_DSL_TRAIT_ISTRANSIENT_HPP
+#ifndef NUCLEAR_DSL_TRAIT_IS_TRANSIENT_HPP
+#define NUCLEAR_DSL_TRAIT_IS_TRANSIENT_HPP
 
 namespace NUClear {
 namespace dsl {
@@ -47,4 +47,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_TRAIT_ISTRANSIENT_HPP
+#endif  // NUCLEAR_DSL_TRAIT_IS_TRANSIENT_HPP
diff --git a/src/dsl/word/Always.hpp b/src/dsl/word/Always.hpp
index 10b301514..74885c7c9 100644
--- a/src/dsl/word/Always.hpp
+++ b/src/dsl/word/Always.hpp
@@ -108,10 +108,10 @@ namespace dsl {
                  */
                 auto idle_reaction = std::make_shared<threading::Reaction>(
                     always_reaction->reactor,
-                    threading::ReactionIdentifiers{always_reaction->identifiers.name + " - IDLE Task",
-                                                   always_reaction->identifiers.reactor,
-                                                   always_reaction->identifiers.dsl,
-                                                   always_reaction->identifiers.function},
+                    threading::ReactionIdentifiers{always_reaction->identifiers->name + " - IDLE Task",
+                                                   always_reaction->identifiers->reactor,
+                                                   always_reaction->identifiers->dsl,
+                                                   always_reaction->identifiers->function},
                     [always_reaction](threading::Reaction& ir) -> util::GeneratedCallback {
                         auto callback = [&ir, always_reaction](const threading::ReactionTask& /*task*/) {
                             // Get a task for the always reaction and submit it to the scheduler
diff --git a/src/dsl/word/Every.hpp b/src/dsl/word/Every.hpp
index 45093aafa..91639eab2 100644
--- a/src/dsl/word/Every.hpp
+++ b/src/dsl/word/Every.hpp
@@ -50,7 +50,6 @@ namespace dsl {
         /**
          * This is used to request any periodic reactions in the system.
          *
-         *
          * @code on<Every<ticks, period>>() @endcode
          * This request will enact the execution of a task at a periodic rate.
          * To set the timing, simply specify the desired period with the request.
diff --git a/src/dsl/word/MainThread.hpp b/src/dsl/word/MainThread.hpp
index 61175a443..e42bdda3f 100644
--- a/src/dsl/word/MainThread.hpp
+++ b/src/dsl/word/MainThread.hpp
@@ -20,11 +20,12 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_DSL_WORD_MAINTHREAD_HPP
-#define NUCLEAR_DSL_WORD_MAINTHREAD_HPP
+#ifndef NUCLEAR_DSL_WORD_MAIN_THREAD_HPP
+#define NUCLEAR_DSL_WORD_MAIN_THREAD_HPP
 
 #include "../../threading/ReactionTask.hpp"
 #include "../../util/ThreadPoolDescriptor.hpp"
+#include "../../util/main_thread_id.hpp"
 
 namespace NUClear {
 namespace dsl {
@@ -49,4 +50,4 @@ namespace dsl {
 }  // namespace dsl
 }  // namespace NUClear
 
-#endif  // NUCLEAR_DSL_WORD_MAINTHREAD_HPP
+#endif  // NUCLEAR_DSL_WORD_MAIN_THREAD_HPP
diff --git a/src/dsl/word/Sync.hpp b/src/dsl/word/Sync.hpp
index d7d1fe84d..abeac74dd 100644
--- a/src/dsl/word/Sync.hpp
+++ b/src/dsl/word/Sync.hpp
@@ -61,13 +61,11 @@ namespace dsl {
          * @par Implements
          *  Group
          *
-         * @tparam GroupType        The type/group to synchronize on.
-         *                          This needs to be a declared type within the system.
-         *                          It is common to simply use the reactors name for a reactor with one group.
-         *                          Should more than one group be required, the developer can declare structs within the
-         *                          system, to act as a group reference.
-         *                          Note that the developer is not limited to the use of a struct; any declared type
-         *                          will work.
+         * @tparam GroupType The type/group to synchronize on.
+         *                   This needs to be a declared type within the system.
+         *                   It is common to simply use the reactors name for a reactor with one group.
+         *                   Should more than one group be required, the developer can declare structs within the
+         *                   system, to act as a group reference.
          */
         template <typename SyncGroup>
         struct Sync : Group<SyncGroup, 1> {};
diff --git a/src/dsl/word/Watchdog.hpp b/src/dsl/word/Watchdog.hpp
index 29cf397f2..2f49c698f 100644
--- a/src/dsl/word/Watchdog.hpp
+++ b/src/dsl/word/Watchdog.hpp
@@ -27,6 +27,7 @@
 
 #include "../../threading/Reaction.hpp"
 #include "../../util/demangle.hpp"
+#include "../operation/ChronoTask.hpp"
 #include "../operation/Unbind.hpp"
 #include "../store/DataStore.hpp"
 #include "emit/Direct.hpp"
diff --git a/src/dsl/word/With.hpp b/src/dsl/word/With.hpp
index f2e37a5c7..1bcfdb372 100644
--- a/src/dsl/word/With.hpp
+++ b/src/dsl/word/With.hpp
@@ -33,7 +33,6 @@ namespace dsl {
         /**
          * This is used to define any extra data which should be provided to a subscribing a reaction.
          *
-         *
          * @code on<With<T2>>() @endcode
          * Note that during runtime, the emission of data using this word will not trigger a reaction within the
          * system.
diff --git a/src/dsl/word/emit/Delay.hpp b/src/dsl/word/emit/Delay.hpp
index 72aa53d56..b01424d3f 100644
--- a/src/dsl/word/emit/Delay.hpp
+++ b/src/dsl/word/emit/Delay.hpp
@@ -34,12 +34,10 @@ namespace dsl {
             /**
              * This will emit data, after the provided delay.
              *
-             *
              * @code emit<Scope::DELAY>(data, delay(ticks), dataType); @endcode
              * Emissions under this scope will wait for the provided time delay, and then emit the object utilising a
              * local emit (that is, normal thread pool distribution).
              *
-             *
              * @tparam DataType The datatype of the object to emit
              *
              * @param data  The data to emit
diff --git a/src/dsl/word/emit/Direct.hpp b/src/dsl/word/emit/Direct.hpp
index fc71d1faa..84cbe4a29 100644
--- a/src/dsl/word/emit/Direct.hpp
+++ b/src/dsl/word/emit/Direct.hpp
@@ -23,6 +23,7 @@
 #ifndef NUCLEAR_DSL_WORD_EMIT_DIRECT_HPP
 #define NUCLEAR_DSL_WORD_EMIT_DIRECT_HPP
 
+#include "../../../PowerPlant.hpp"
 #include "../../store/DataStore.hpp"
 #include "../../store/ThreadStore.hpp"
 #include "../../store/TypeCallbackStore.hpp"
diff --git a/src/dsl/word/emit/Local.hpp b/src/dsl/word/emit/Local.hpp
index 20324a43e..1aa8400b0 100644
--- a/src/dsl/word/emit/Local.hpp
+++ b/src/dsl/word/emit/Local.hpp
@@ -23,6 +23,7 @@
 #ifndef NUCLEAR_DSL_WORD_EMIT_LOCAL_HPP
 #define NUCLEAR_DSL_WORD_EMIT_LOCAL_HPP
 
+#include "../../../PowerPlant.hpp"
 #include "../../../util/TypeMap.hpp"
 #include "../../store/DataStore.hpp"
 #include "../../store/ThreadStore.hpp"
@@ -34,8 +35,7 @@ namespace dsl {
         namespace emit {
 
             /**
-             *When emitting data under this scope, tasks are distributed via the thread pool for execution.
-             *
+             * When emitting data under this scope, tasks are distributed via the thread pool for execution.
              *
              * @code emit<Scope::LOCAL>(data, dataType); @endcode
              *
diff --git a/src/dsl/word/emit/Network.hpp b/src/dsl/word/emit/Network.hpp
index 8ae9feeb6..573740019 100644
--- a/src/dsl/word/emit/Network.hpp
+++ b/src/dsl/word/emit/Network.hpp
@@ -47,7 +47,6 @@ namespace dsl {
             /**
              * Emits data over the network to other NUClear environments.
              *
-             *
              * @code emit<Scope::NETWORK>(data, target, reliable, dataType); @endcode
              * Data emitted under this scope can be sent by name to other NUClear systems or to all NUClear systems
              * connected to the NUClear network.
@@ -71,9 +70,10 @@ namespace dsl {
              * @tparam DataType the type of the data to send
              *
              * @param data      the data to emit
-             * @param target    Optional.  The name of the system to send to, or empty for all systems. Defaults to all.
-             *                  (an empty string).
-             * @param reliable  Optional.  True if the delivery of the message should be guaranteed. Defaults to false.
+             * @param target    The name of the system to send to, or empty for all systems.
+             *                  Defaults to all (an empty string).
+             * @param reliable  True if the delivery of the message should be guaranteed.
+             *                  Defaults to false.
              */
             template <typename DataType>
             struct Network {
diff --git a/src/dsl/word/emit/UDP.hpp b/src/dsl/word/emit/UDP.hpp
index 51ea0be90..3ed6e812a 100644
--- a/src/dsl/word/emit/UDP.hpp
+++ b/src/dsl/word/emit/UDP.hpp
@@ -25,6 +25,7 @@
 
 #include <stdexcept>
 
+#include "../../../PowerPlant.hpp"
 #include "../../../util/FileDescriptor.hpp"
 #include "../../../util/network/if_number_from_address.hpp"
 #include "../../../util/platform.hpp"
@@ -40,7 +41,6 @@ namespace dsl {
             /**
              * Emits data as a UDP packet over the network.
              *
-             *
              * @code emit<Scope::UDP>(data, to_addr, to_port); @endcode
              * Emissions under this scope are useful for communicating with other systems using UDP.
              * The target of the packet can be can be a unicast, broadcast or multicast address, specified as a string.
diff --git a/src/dsl/word/emit/Watchdog.hpp b/src/dsl/word/emit/Watchdog.hpp
index 066801157..6024ec595 100644
--- a/src/dsl/word/emit/Watchdog.hpp
+++ b/src/dsl/word/emit/Watchdog.hpp
@@ -25,6 +25,7 @@
 
 #include <stdexcept>
 
+#include "../../../PowerPlant.hpp"
 #include "../../../util/TypeMap.hpp"
 #include "../../../util/demangle.hpp"
 
@@ -84,7 +85,8 @@ namespace dsl {
             };
 
             /**
-             * Handles the data store for the case when no runtime arguments are specified
+             * Handles the data store for the case when no runtime arguments are specified.
+             *
              * @code on<Watchdog<>>() @endcode
              * @code emit<Scope::WATCHDOG>() @endcode
              *
@@ -141,7 +143,6 @@ namespace dsl {
 
             /**
              * When emitting data under this scope, the service time for the watchdog is updated.
-
              *
              * @code emit<Scope::WATCHDOG>(ServiceWatchdog<WatchdogGroup>(data)); @endcode
              * or
diff --git a/src/extension/ChronoController.cpp b/src/extension/ChronoController.cpp
new file mode 100644
index 000000000..30149d181
--- /dev/null
+++ b/src/extension/ChronoController.cpp
@@ -0,0 +1,198 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2014 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "ChronoController.hpp"
+
+#include "../util/precise_sleep.hpp"
+
+namespace NUClear {
+namespace extension {
+
+    ChronoController::ChronoController(std::unique_ptr<NUClear::Environment> environment)
+        : Reactor(std::move(environment)) {
+
+        // Estimate the accuracy of our cv wait and precise sleep
+        for (int i = 0; i < 3; ++i) {
+            // Estimate the accuracy of our cv wait
+            std::mutex test;
+            std::unique_lock<std::mutex> lock(test);
+            const auto cv_s = NUClear::clock::now();
+            wait.wait_for(lock, std::chrono::milliseconds(1));
+            const auto cv_e = NUClear::clock::now();
+            const auto cv_a = NUClear::clock::duration(cv_e - cv_s - std::chrono::milliseconds(1));
+
+            // Estimate the accuracy of our precise sleep
+            const auto ns_s = NUClear::clock::now();
+            util::precise_sleep(std::chrono::milliseconds(1));
+            const auto ns_e = NUClear::clock::now();
+            const auto ns_a = NUClear::clock::duration(ns_e - ns_s - std::chrono::milliseconds(1));
+
+            // Use the largest time we have seen
+            cv_accuracy = cv_a > cv_accuracy ? cv_a : cv_accuracy;
+            ns_accuracy = ns_a > ns_accuracy ? ns_a : ns_accuracy;
+        }
+
+        on<Trigger<ChronoTask>>().then("Add Chrono task", [this](const std::shared_ptr<const ChronoTask>& task) {
+            // Lock the mutex while we're doing stuff
+            const std::lock_guard<std::mutex> lock(mutex);
+
+            // Add our new task to the heap if we are still running
+            if (running.load()) {
+                tasks.push_back(*task);
+                std::push_heap(tasks.begin(), tasks.end(), std::greater<>());
+            }
+
+            // Poke the system
+            wait.notify_all();
+        });
+
+        on<Trigger<dsl::operation::Unbind<ChronoTask>>>().then(
+            "Unbind Chrono Task",
+            [this](const dsl::operation::Unbind<ChronoTask>& unbind) {
+                // Lock the mutex while we're doing stuff
+                const std::lock_guard<std::mutex> lock(mutex);
+
+                // Find the task
+                auto it = std::find_if(tasks.begin(), tasks.end(), [&](const ChronoTask& task) {
+                    return task.id == unbind.id;
+                });
+
+                // Remove if it exists
+                if (it != tasks.end()) {
+                    tasks.erase(it);
+                    std::make_heap(tasks.begin(), tasks.end(), std::greater<>());
+                }
+
+                // Poke the system to make sure it's not waiting on something that's gone
+                wait.notify_all();
+            });
+
+        // When we shutdown we notify so we quit now
+        on<Shutdown>().then("Shutdown Chrono Controller", [this] {
+            const std::lock_guard<std::mutex> lock(mutex);
+            running = false;
+            wait.notify_all();
+        });
+
+        on<Trigger<message::TimeTravel>>().then("Time Travel", [this](const message::TimeTravel& travel) {
+            const std::lock_guard<std::mutex> lock(mutex);
+
+            // Adjust clock to target time and leave chrono tasks where they are
+            switch (travel.type) {
+                case message::TimeTravel::Action::ABSOLUTE: clock::set_clock(travel.target, travel.rtf); break;
+                case message::TimeTravel::Action::RELATIVE: {
+                    auto adjustment = travel.target - NUClear::clock::now();
+                    clock::set_clock(travel.target, travel.rtf);
+                    for (auto& task : tasks) {
+                        task.time += adjustment;
+                    }
+
+                } break;
+                case message::TimeTravel::Action::NEAREST: {
+                    const clock::time_point nearest =
+                        tasks.empty() ? travel.target
+                                      : std::min(travel.target, std::min_element(tasks.begin(), tasks.end())->time);
+                    clock::set_clock(nearest, travel.rtf);
+                } break;
+            }
+
+            // Poke the system
+            wait.notify_all();
+        });
+
+        on<Always, Priority::REALTIME>().then("Chrono Controller", [this] {
+            // Run until we are told to stop
+            while (running.load()) {
+
+                // Acquire the mutex lock so we can wait on it
+                std::unique_lock<std::mutex> lock(mutex);
+
+                // If we have no chrono tasks wait until we are notified
+                if (tasks.empty()) {
+                    wait.wait(lock, [this] { return !running.load() || !tasks.empty(); });
+                }
+                else {
+                    auto start  = NUClear::clock::now();
+                    auto target = tasks.front().time;
+
+                    if (target <= start) {
+                        // Run our task and if it returns false remove it
+                        const bool renew = tasks.front()();
+
+                        // Move this to the back of the list
+                        std::pop_heap(tasks.begin(), tasks.end(), std::greater<>());
+
+                        if (renew) {
+                            // Put the item back in the list
+                            std::push_heap(tasks.begin(), tasks.end(), std::greater<>());
+                        }
+                        else {
+                            // Remove the item from the list
+                            tasks.pop_back();
+                        }
+                    }
+                    else {
+                        const NUClear::clock::duration time_until_task =
+                            std::chrono::duration_cast<NUClear::clock::duration>((target - start) / clock::rtf());
+
+                        if (clock::rtf() == 0.0) {
+                            // If we are paused then just wait until we are unpaused
+                            wait.wait(lock, [&] {
+                                return !running.load() || clock::rtf() != 0.0 || NUClear::clock::now() != start;
+                            });
+                        }
+                        else if (time_until_task > cv_accuracy) {  // A long time in the future
+                            // Wait on the cv
+                            wait.wait_for(lock, time_until_task - cv_accuracy);
+
+                            // Update the accuracy of our cv wait
+                            const auto end   = NUClear::clock::now();
+                            const auto error = end - (target - cv_accuracy);  // when ended - when wanted to end
+                            if (error.count() > 0) {                          // only if we were late
+                                cv_accuracy = error > cv_accuracy ? error : ((cv_accuracy * 99 + error) / 100);
+                            }
+                        }
+                        else if (time_until_task > ns_accuracy) {  // Somewhat close in time
+                            // Wait on nanosleep
+                            const NUClear::clock::duration sleep_time = time_until_task - ns_accuracy;
+                            util::precise_sleep(sleep_time);
+
+                            // Update the accuracy of our precise sleep
+                            const auto end   = NUClear::clock::now();
+                            const auto error = end - (target - ns_accuracy);  // when ended - when wanted to end
+                            if (error.count() > 0) {                          // only if we were late
+                                ns_accuracy = error > ns_accuracy ? error : ((ns_accuracy * 99 + error) / 100);
+                            }
+                        }
+                        else {
+                            while (NUClear::clock::now() < tasks.front().time) {
+                                // Spinlock until we get to the time
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+
+}  // namespace extension
+}  // namespace NUClear
diff --git a/src/extension/ChronoController.hpp b/src/extension/ChronoController.hpp
index b5a73f206..e3954f6e8 100644
--- a/src/extension/ChronoController.hpp
+++ b/src/extension/ChronoController.hpp
@@ -20,12 +20,11 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_EXTENSION_CHRONOCONTROLLER
-#define NUCLEAR_EXTENSION_CHRONOCONTROLLER
+#ifndef NUCLEAR_EXTENSION_CHRONO_CONTROLLER_HPP
+#define NUCLEAR_EXTENSION_CHRONO_CONTROLLER_HPP
 
 #include "../Reactor.hpp"
 #include "../message/TimeTravel.hpp"
-#include "../util/precise_sleep.hpp"
 
 namespace NUClear {
 namespace extension {
@@ -35,171 +34,7 @@ namespace extension {
         using ChronoTask = NUClear::dsl::operation::ChronoTask;
 
     public:
-        explicit ChronoController(std::unique_ptr<NUClear::Environment> environment) : Reactor(std::move(environment)) {
-
-            // Estimate the accuracy of our cv wait and precise sleep
-            for (int i = 0; i < 3; ++i) {
-                // Estimate the accuracy of our cv wait
-                std::mutex test;
-                std::unique_lock<std::mutex> lock(test);
-                const auto cv_s = NUClear::clock::now();
-                wait.wait_for(lock, std::chrono::milliseconds(1));
-                const auto cv_e = NUClear::clock::now();
-                const auto cv_a = NUClear::clock::duration(cv_e - cv_s - std::chrono::milliseconds(1));
-
-                // Estimate the accuracy of our precise sleep
-                const auto ns_s = NUClear::clock::now();
-                util::precise_sleep(std::chrono::milliseconds(1));
-                const auto ns_e = NUClear::clock::now();
-                const auto ns_a = NUClear::clock::duration(ns_e - ns_s - std::chrono::milliseconds(1));
-
-                // Use the largest time we have seen
-                cv_accuracy = cv_a > cv_accuracy ? cv_a : cv_accuracy;
-                ns_accuracy = ns_a > ns_accuracy ? ns_a : ns_accuracy;
-            }
-
-            on<Trigger<ChronoTask>>().then("Add Chrono task", [this](const std::shared_ptr<const ChronoTask>& task) {
-                // Lock the mutex while we're doing stuff
-                const std::lock_guard<std::mutex> lock(mutex);
-
-                // Add our new task to the heap if we are still running
-                if (running.load()) {
-                    tasks.push_back(*task);
-                    std::push_heap(tasks.begin(), tasks.end(), std::greater<>());
-                }
-
-                // Poke the system
-                wait.notify_all();
-            });
-
-            on<Trigger<dsl::operation::Unbind<ChronoTask>>>().then(
-                "Unbind Chrono Task",
-                [this](const dsl::operation::Unbind<ChronoTask>& unbind) {
-                    // Lock the mutex while we're doing stuff
-                    const std::lock_guard<std::mutex> lock(mutex);
-
-                    // Find the task
-                    auto it = std::find_if(tasks.begin(), tasks.end(), [&](const ChronoTask& task) {
-                        return task.id == unbind.id;
-                    });
-
-                    // Remove if it exists
-                    if (it != tasks.end()) {
-                        tasks.erase(it);
-                        std::make_heap(tasks.begin(), tasks.end(), std::greater<>());
-                    }
-
-                    // Poke the system to make sure it's not waiting on something that's gone
-                    wait.notify_all();
-                });
-
-            // When we shutdown we notify so we quit now
-            on<Shutdown>().then("Shutdown Chrono Controller", [this] {
-                const std::lock_guard<std::mutex> lock(mutex);
-                running = false;
-                wait.notify_all();
-            });
-
-            on<Trigger<message::TimeTravel>>().then("Time Travel", [this](const message::TimeTravel& travel) {
-                const std::lock_guard<std::mutex> lock(mutex);
-
-                // Adjust clock to target time and leave chrono tasks where they are
-                switch (travel.type) {
-                    case message::TimeTravel::Action::ABSOLUTE: clock::set_clock(travel.target, travel.rtf); break;
-                    case message::TimeTravel::Action::RELATIVE: {
-                        auto adjustment = travel.target - NUClear::clock::now();
-                        clock::set_clock(travel.target, travel.rtf);
-                        for (auto& task : tasks) {
-                            task.time += adjustment;
-                        }
-
-                    } break;
-                    case message::TimeTravel::Action::NEAREST: {
-                        const clock::time_point nearest =
-                            tasks.empty() ? travel.target
-                                          : std::min(travel.target, std::min_element(tasks.begin(), tasks.end())->time);
-                        clock::set_clock(nearest, travel.rtf);
-                    } break;
-                }
-
-                // Poke the system
-                wait.notify_all();
-            });
-
-            on<Always, Priority::REALTIME>().then("Chrono Controller", [this] {
-                // Run until we are told to stop
-                while (running.load()) {
-
-                    // Acquire the mutex lock so we can wait on it
-                    std::unique_lock<std::mutex> lock(mutex);
-
-                    // If we have no chrono tasks wait until we are notified
-                    if (tasks.empty()) {
-                        wait.wait(lock, [this] { return !running.load() || !tasks.empty(); });
-                    }
-                    else {
-                        auto start  = NUClear::clock::now();
-                        auto target = tasks.front().time;
-
-                        if (target <= start) {
-                            // Run our task and if it returns false remove it
-                            const bool renew = tasks.front()();
-
-                            // Move this to the back of the list
-                            std::pop_heap(tasks.begin(), tasks.end(), std::greater<>());
-
-                            if (renew) {
-                                // Put the item back in the list
-                                std::push_heap(tasks.begin(), tasks.end(), std::greater<>());
-                            }
-                            else {
-                                // Remove the item from the list
-                                tasks.pop_back();
-                            }
-                        }
-                        else {
-                            const NUClear::clock::duration time_until_task =
-                                std::chrono::duration_cast<NUClear::clock::duration>((target - start) / clock::rtf());
-
-                            if (clock::rtf() == 0.0) {
-                                // If we are paused then just wait until we are unpaused
-                                wait.wait(lock, [&] {
-                                    return !running.load() || clock::rtf() != 0.0 || NUClear::clock::now() != start;
-                                });
-                            }
-                            else if (time_until_task > cv_accuracy) {  // A long time in the future
-                                // Wait on the cv
-                                wait.wait_for(lock, time_until_task - cv_accuracy);
-
-                                // Update the accuracy of our cv wait
-                                const auto end   = NUClear::clock::now();
-                                const auto error = end - (target - cv_accuracy);  // when ended - when wanted to end
-                                if (error.count() > 0) {                          // only if we were late
-                                    cv_accuracy = error > cv_accuracy ? error : ((cv_accuracy * 99 + error) / 100);
-                                }
-                            }
-                            else if (time_until_task > ns_accuracy) {  // Somewhat close in time
-                                // Wait on nanosleep
-                                const NUClear::clock::duration sleep_time = time_until_task - ns_accuracy;
-                                util::precise_sleep(sleep_time);
-
-                                // Update the accuracy of our precise sleep
-                                const auto end   = NUClear::clock::now();
-                                const auto error = end - (target - ns_accuracy);  // when ended - when wanted to end
-                                if (error.count() > 0) {                          // only if we were late
-                                    ns_accuracy = error > ns_accuracy ? error : ((ns_accuracy * 99 + error) / 100);
-                                }
-                            }
-                            else {
-                                while (NUClear::clock::now() < tasks.front().time) {
-                                    // Spinlock until we get to the time
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-        }
+        explicit ChronoController(std::unique_ptr<NUClear::Environment> environment);
 
     private:
         /// The list of tasks we need to process
@@ -220,4 +55,4 @@ namespace extension {
 }  // namespace extension
 }  // namespace NUClear
 
-#endif  // NUCLEAR_EXTENSION_CHRONOCONTROLLER
+#endif  // NUCLEAR_EXTENSION_CHRONO_CONTROLLER_HPP
diff --git a/src/extension/NetworkController.cpp b/src/extension/NetworkController.cpp
new file mode 100644
index 000000000..1af37262e
--- /dev/null
+++ b/src/extension/NetworkController.cpp
@@ -0,0 +1,155 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2015 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "NetworkController.hpp"
+
+#include "../message/NetworkEvent.hpp"
+
+namespace NUClear {
+namespace extension {
+
+    using NetworkListen        = dsl::word::NetworkListen;
+    using NetworkEmit          = dsl::word::emit::NetworkEmit;
+    using NetworkConfiguration = message::NetworkConfiguration;
+    using Unbind               = dsl::operation::Unbind<NetworkListen>;
+    struct ProcessNetwork {};
+
+    NetworkController::NetworkController(std::unique_ptr<NUClear::Environment> environment)
+        : Reactor(std::move(environment)) {
+
+        // Set our function callback
+        network.set_packet_callback([this](const network::NUClearNetwork::NetworkTarget& remote,
+                                           const uint64_t& hash,
+                                           const bool& reliable,
+                                           std::vector<uint8_t>&& payload) {
+            // Construct our NetworkSource information
+            dsl::word::NetworkSource src{remote.name, remote.target, reliable};
+
+            // Move the payload in as we are stealing it
+            std::vector<uint8_t> p(std::move(payload));
+
+            // Store in our thread local cache
+            dsl::store::ThreadStore<std::vector<uint8_t>>::value     = &p;
+            dsl::store::ThreadStore<dsl::word::NetworkSource>::value = &src;
+
+            /* Mutex Scope */ {
+                // Lock our reaction mutex
+                const std::lock_guard<std::mutex> lock(reaction_mutex);
+
+                // Find interested reactions
+                auto rs = reactions.equal_range(hash);
+
+                // Execute on our interested reactions
+                for (auto it = rs.first; it != rs.second; ++it) {
+                    powerplant.submit(it->second->get_task());
+                }
+            }
+
+            // Clear our cache
+            dsl::store::ThreadStore<std::vector<uint8_t>>::value     = nullptr;
+            dsl::store::ThreadStore<dsl::word::NetworkSource>::value = nullptr;
+        });
+
+        // Set our join callback
+        network.set_join_callback([this](const network::NUClearNetwork::NetworkTarget& remote) {
+            auto l     = std::make_unique<message::NetworkJoin>();
+            l->name    = remote.name;
+            l->address = remote.target;
+            emit(l);
+        });
+
+        // Set our leave callback
+        network.set_leave_callback([this](const network::NUClearNetwork::NetworkTarget& remote) {
+            auto l     = std::make_unique<message::NetworkLeave>();
+            l->name    = remote.name;
+            l->address = remote.target;
+            emit(l);
+        });
+
+        // Set our event timer callback
+        network.set_next_event_callback([this](std::chrono::steady_clock::time_point t) {
+            const std::chrono::steady_clock::duration emit_offset = t - std::chrono::steady_clock::now();
+            emit<Scope::DELAY>(std::make_unique<ProcessNetwork>(),
+                               std::chrono::duration_cast<NUClear::clock::duration>(emit_offset));
+        });
+
+        // Start listening for a new network type
+        on<Trigger<NetworkListen>>().then("Network Bind", [this](const NetworkListen& l) {
+            // Lock our reaction mutex
+            const std::lock_guard<std::mutex> lock(reaction_mutex);
+
+            // Insert our new reaction
+            reactions.insert(std::make_pair(l.hash, l.reaction));
+        });
+
+        // Stop listening for a network type
+        on<Trigger<Unbind>>().then("Network Unbind", [this](const Unbind& unbind) {
+            // Lock our reaction mutex
+            const std::lock_guard<std::mutex> lock(reaction_mutex);
+
+            // Find and delete this reaction
+            for (auto it = reactions.begin(); it != reactions.end(); ++it) {
+                if (it->second->id == unbind.id) {
+                    reactions.erase(it);
+                    break;
+                }
+            }
+        });
+
+        on<Trigger<NetworkEmit>>().then("Network Emit", [this](const NetworkEmit& emit) {
+            network.send(emit.hash, emit.payload, emit.target, emit.reliable);
+        });
+
+        on<Shutdown>().then("Shutdown Network", [this] { network.shutdown(); });
+
+        // Configure the NUClearNetwork options
+        on<Trigger<NetworkConfiguration>>().then([this](const NetworkConfiguration& config) {
+            // Unbind our announce handle
+            if (process_handle) {
+                process_handle.unbind();
+            }
+
+            // Unbind all our listen handles
+            if (!listen_handles.empty()) {
+                for (auto& h : listen_handles) {
+                    h.unbind();
+                }
+                listen_handles.clear();
+            }
+
+            // Name becomes hostname by default if not set
+            const std::string name = config.name.empty() ? util::get_hostname() : config.name;
+
+            // Reset our network using this configuration
+            network.reset(name, config.announce_address, config.announce_port, config.bind_address, config.mtu);
+
+            // Execution handle
+            process_handle = on<Trigger<ProcessNetwork>>().then("Network processing", [this] { network.process(); });
+
+            for (auto& fd : network.listen_fds()) {
+                listen_handles.push_back(on<IO>(fd, IO::READ).then("Packet", [this] { network.process(); }));
+            }
+        });
+    }
+
+}  // namespace extension
+}  // namespace NUClear
diff --git a/src/extension/NetworkController.hpp b/src/extension/NetworkController.hpp
index 6123d9ffd..1452f4b63 100644
--- a/src/extension/NetworkController.hpp
+++ b/src/extension/NetworkController.hpp
@@ -20,14 +20,16 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_EXTENSION_NETWORKCONTROLLER_HPP
-#define NUCLEAR_EXTENSION_NETWORKCONTROLLER_HPP
+#ifndef NUCLEAR_EXTENSION_NETWORK_CONTROLLER_HPP
+#define NUCLEAR_EXTENSION_NETWORK_CONTROLLER_HPP
 
 #include <algorithm>
 #include <cerrno>
 #include <csignal>
 
+#include "../PowerPlant.hpp"
 #include "../Reactor.hpp"
+#include "../message/NetworkConfiguration.hpp"
 #include "../util/get_hostname.hpp"
 #include "network/NUClearNetwork.hpp"
 
@@ -36,131 +38,8 @@ namespace extension {
 
     class NetworkController : public Reactor {
 
-        using NetworkListen        = dsl::word::NetworkListen;
-        using NetworkEmit          = dsl::word::emit::NetworkEmit;
-        using NetworkConfiguration = message::NetworkConfiguration;
-        using Unbind               = dsl::operation::Unbind<NetworkListen>;
-        struct ProcessNetwork {};
-
     public:
-        explicit NetworkController(std::unique_ptr<NUClear::Environment> environment)
-            : Reactor(std::move(environment)) {
-
-            // Set our function callback
-            network.set_packet_callback([this](const network::NUClearNetwork::NetworkTarget& remote,
-                                               const uint64_t& hash,
-                                               const bool& reliable,
-                                               std::vector<uint8_t>&& payload) {
-                // Construct our NetworkSource information
-                dsl::word::NetworkSource src{remote.name, remote.target, reliable};
-
-                // Move the payload in as we are stealing it
-                std::vector<uint8_t> p(std::move(payload));
-
-                // Store in our thread local cache
-                dsl::store::ThreadStore<std::vector<uint8_t>>::value     = &p;
-                dsl::store::ThreadStore<dsl::word::NetworkSource>::value = &src;
-
-                /* Mutex Scope */ {
-                    // Lock our reaction mutex
-                    const std::lock_guard<std::mutex> lock(reaction_mutex);
-
-                    // Find interested reactions
-                    auto rs = reactions.equal_range(hash);
-
-                    // Execute on our interested reactions
-                    for (auto it = rs.first; it != rs.second; ++it) {
-                        powerplant.submit(it->second->get_task());
-                    }
-                }
-
-                // Clear our cache
-                dsl::store::ThreadStore<std::vector<uint8_t>>::value     = nullptr;
-                dsl::store::ThreadStore<dsl::word::NetworkSource>::value = nullptr;
-            });
-
-            // Set our join callback
-            network.set_join_callback([this](const network::NUClearNetwork::NetworkTarget& remote) {
-                auto l     = std::make_unique<message::NetworkJoin>();
-                l->name    = remote.name;
-                l->address = remote.target;
-                emit(l);
-            });
-
-            // Set our leave callback
-            network.set_leave_callback([this](const network::NUClearNetwork::NetworkTarget& remote) {
-                auto l     = std::make_unique<message::NetworkLeave>();
-                l->name    = remote.name;
-                l->address = remote.target;
-                emit(l);
-            });
-
-            // Set our event timer callback
-            network.set_next_event_callback([this](std::chrono::steady_clock::time_point t) {
-                const std::chrono::steady_clock::duration emit_offset = t - std::chrono::steady_clock::now();
-                emit<Scope::DELAY>(std::make_unique<ProcessNetwork>(),
-                                   std::chrono::duration_cast<NUClear::clock::duration>(emit_offset));
-            });
-
-            // Start listening for a new network type
-            on<Trigger<NetworkListen>>().then("Network Bind", [this](const NetworkListen& l) {
-                // Lock our reaction mutex
-                const std::lock_guard<std::mutex> lock(reaction_mutex);
-
-                // Insert our new reaction
-                reactions.insert(std::make_pair(l.hash, l.reaction));
-            });
-
-            // Stop listening for a network type
-            on<Trigger<Unbind>>().then("Network Unbind", [this](const Unbind& unbind) {
-                // Lock our reaction mutex
-                const std::lock_guard<std::mutex> lock(reaction_mutex);
-
-                // Find and delete this reaction
-                for (auto it = reactions.begin(); it != reactions.end(); ++it) {
-                    if (it->second->id == unbind.id) {
-                        reactions.erase(it);
-                        break;
-                    }
-                }
-            });
-
-            on<Trigger<NetworkEmit>>().then("Network Emit", [this](const NetworkEmit& emit) {
-                network.send(emit.hash, emit.payload, emit.target, emit.reliable);
-            });
-
-            on<Shutdown>().then("Shutdown Network", [this] { network.shutdown(); });
-
-            // Configure the NUClearNetwork options
-            on<Trigger<NetworkConfiguration>>().then([this](const NetworkConfiguration& config) {
-                // Unbind our announce handle
-                if (process_handle) {
-                    process_handle.unbind();
-                }
-
-                // Unbind all our listen handles
-                if (!listen_handles.empty()) {
-                    for (auto& h : listen_handles) {
-                        h.unbind();
-                    }
-                    listen_handles.clear();
-                }
-
-                // Name becomes hostname by default if not set
-                const std::string name = config.name.empty() ? util::get_hostname() : config.name;
-
-                // Reset our network using this configuration
-                network.reset(name, config.announce_address, config.announce_port, config.bind_address, config.mtu);
-
-                // Execution handle
-                process_handle =
-                    on<Trigger<ProcessNetwork>>().then("Network processing", [this] { network.process(); });
-
-                for (auto& fd : network.listen_fds()) {
-                    listen_handles.push_back(on<IO>(fd, IO::READ).then("Packet", [this] { network.process(); }));
-                }
-            });
-        }
+        explicit NetworkController(std::unique_ptr<NUClear::Environment> environment);
 
     private:
         /// Our NUClearNetwork object that handles the networking
@@ -180,4 +59,4 @@ namespace extension {
 }  // namespace extension
 }  // namespace NUClear
 
-#endif  // NUCLEAR_EXTENSION_NETWORKCONTROLLER_HPP
+#endif  // NUCLEAR_EXTENSION_NETWORK_CONTROLLER_HPP
diff --git a/src/extension/network/NUClearNetwork.hpp b/src/extension/network/NUClearNetwork.hpp
index 26f522733..b80d76f0c 100644
--- a/src/extension/network/NUClearNetwork.hpp
+++ b/src/extension/network/NUClearNetwork.hpp
@@ -20,12 +20,13 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_EXTENSION_NETWORK_NUCLEARNETWORK_HPP
-#define NUCLEAR_EXTENSION_NETWORK_NUCLEARNETWORK_HPP
+#ifndef NUCLEAR_EXTENSION_NETWORK_NUCLEAR_NETWORK_HPP
+#define NUCLEAR_EXTENSION_NETWORK_NUCLEAR_NETWORK_HPP
 
 #include <array>
 #include <atomic>
 #include <chrono>
+#include <cstdint>
 #include <functional>
 #include <limits>
 #include <list>
@@ -33,7 +34,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <thread>
+#include <utility>
 #include <vector>
 
 #include "../../util/network/sock_t.hpp"
@@ -353,4 +354,4 @@ namespace extension {
 }  // namespace extension
 }  // namespace NUClear
 
-#endif  // NUCLEAR_EXTENSION_NETWORKCONTROLLER_HPP
+#endif  // NUCLEAR_EXTENSION_NETWORK_NUCLEAR_NETWORK_HPP
diff --git a/src/message/LogMessage.hpp b/src/message/LogMessage.hpp
index 9b1713485..1ac21e206 100644
--- a/src/message/LogMessage.hpp
+++ b/src/message/LogMessage.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_MESSAGE_LOGMESSAGE_HPP
-#define NUCLEAR_MESSAGE_LOGMESSAGE_HPP
+#ifndef NUCLEAR_MESSAGE_LOG_MESSAGE_HPP
+#define NUCLEAR_MESSAGE_LOG_MESSAGE_HPP
 
 #include <memory>
 
@@ -47,7 +47,7 @@ namespace message {
         LogMessage(const LogLevel& level,
                    const LogLevel& display_level,
                    std::string message,
-                   std::shared_ptr<ReactionStatistics> task)
+                   std::shared_ptr<const ReactionStatistics> task)
             : level(level), display_level(display_level), message(std::move(message)), task(std::move(task)) {}
 
         /// The logging level of the log
@@ -60,10 +60,10 @@ namespace message {
         std::string message;
 
         /// The currently executing task that made this message
-        const std::shared_ptr<ReactionStatistics> task{nullptr};
+        const std::shared_ptr<const ReactionStatistics> task{nullptr};
     };
 
 }  // namespace message
 }  // namespace NUClear
 
-#endif  // NUCLEAR_MESSAGE_LOGMESSAGE_HPP
+#endif  // NUCLEAR_MESSAGE_LOG_MESSAGE_HPP
diff --git a/src/message/NetworkConfiguration.hpp b/src/message/NetworkConfiguration.hpp
index d1025cacd..8bd4ca37c 100644
--- a/src/message/NetworkConfiguration.hpp
+++ b/src/message/NetworkConfiguration.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_MESSAGE_NETWORKCONFIGURATION_HPP
-#define NUCLEAR_MESSAGE_NETWORKCONFIGURATION_HPP
+#ifndef NUCLEAR_MESSAGE_NETWORK_CONFIGURATION_HPP
+#define NUCLEAR_MESSAGE_NETWORK_CONFIGURATION_HPP
 
 #include <string>
 
@@ -58,4 +58,4 @@ namespace message {
 }  // namespace message
 }  // namespace NUClear
 
-#endif  // NUCLEAR_MESSAGE_NETWORKCONFIGURATION_HPP
+#endif  // NUCLEAR_MESSAGE_NETWORK_CONFIGURATION_HPP
diff --git a/src/message/NetworkEvent.hpp b/src/message/NetworkEvent.hpp
index e6acdd5bc..50411a272 100644
--- a/src/message/NetworkEvent.hpp
+++ b/src/message/NetworkEvent.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_MESSAGE_NETWORKEVENT_HPP
-#define NUCLEAR_MESSAGE_NETWORKEVENT_HPP
+#ifndef NUCLEAR_MESSAGE_NETWORK_EVENT_HPP
+#define NUCLEAR_MESSAGE_NETWORK_EVENT_HPP
 
 #include "../util/network/sock_t.hpp"
 
@@ -29,15 +29,11 @@ namespace NUClear {
 namespace message {
 
     struct NetworkJoin {
-        NetworkJoin() = default;
-
         std::string name;
         util::network::sock_t address{};
     };
 
     struct NetworkLeave {
-        NetworkLeave() = default;
-
         std::string name;
         util::network::sock_t address{};
     };
@@ -45,4 +41,4 @@ namespace message {
 }  // namespace message
 }  // namespace NUClear
 
-#endif  // NUCLEAR_MESSAGE_NETWORKEVENT_HPP
+#endif  // NUCLEAR_MESSAGE_NETWORK_EVENT_HPP
diff --git a/src/message/ReactionStatistics.hpp b/src/message/ReactionStatistics.hpp
index 3c0825763..840d9a4a0 100644
--- a/src/message/ReactionStatistics.hpp
+++ b/src/message/ReactionStatistics.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_MESSAGE_REACTIONSTATISTICS_HPP
-#define NUCLEAR_MESSAGE_REACTIONSTATISTICS_HPP
+#ifndef NUCLEAR_MESSAGE_REACTION_STATISTICS_HPP
+#define NUCLEAR_MESSAGE_REACTION_STATISTICS_HPP
 
 #include <exception>
 #include <string>
@@ -39,7 +39,7 @@ namespace message {
      */
     struct ReactionStatistics {
 
-        ReactionStatistics(threading::ReactionIdentifiers identifiers,
+        ReactionStatistics(std::shared_ptr<const threading::ReactionIdentifiers> identifiers,
                            const NUClear::id_t& reaction_id,
                            const NUClear::id_t& task_id,
                            const NUClear::id_t& cause_reaction_id,
@@ -59,7 +59,7 @@ namespace message {
             , exception(std::move(exception)) {}
 
         /// A string containing the username/on arguments/and callback name of the reaction
-        threading::ReactionIdentifiers identifiers;
+        std::shared_ptr<const threading::ReactionIdentifiers> identifiers;
         /// The id of this reaction
         NUClear::id_t reaction_id{0};
         /// The task id of this reaction
@@ -81,4 +81,4 @@ namespace message {
 }  // namespace message
 }  // namespace NUClear
 
-#endif  // NUCLEAR_MESSAGE_REACTIONSTATISTICS_HPP
+#endif  // NUCLEAR_MESSAGE_REACTION_STATISTICS_HPP
diff --git a/src/nuclear.in b/src/nuclear.in
index 461bf888e..06991ec78 100644
--- a/src/nuclear.in
+++ b/src/nuclear.in
@@ -23,7 +23,21 @@
 #ifndef NUCLEAR
 #define NUCLEAR
 
+// Main classes
 #include "${nuclear_include_base_directory}PowerPlant.hpp"
 #include "${nuclear_include_base_directory}Reactor.hpp"
 
+// Message types
+#include "${nuclear_include_base_directory}message/CommandLineArguments.hpp"
+#include "${nuclear_include_base_directory}message/LogMessage.hpp"
+#include "${nuclear_include_base_directory}message/NetworkConfiguration.hpp"
+#include "${nuclear_include_base_directory}message/NetworkEvent.hpp"
+#include "${nuclear_include_base_directory}message/ReactionStatistics.hpp"
+#include "${nuclear_include_base_directory}message/TimeTravel.hpp"
+
+// Extensions
+#include "${nuclear_include_base_directory}extension/ChronoController.hpp"
+#include "${nuclear_include_base_directory}extension/IOController.hpp"
+#include "${nuclear_include_base_directory}extension/NetworkController.hpp"
+
 #endif  // NUCLEAR
diff --git a/src/threading/Reaction.cpp b/src/threading/Reaction.cpp
index 8b4a255cf..9527aada9 100644
--- a/src/threading/Reaction.cpp
+++ b/src/threading/Reaction.cpp
@@ -22,6 +22,14 @@
 
 #include "Reaction.hpp"
 
+#include <memory>
+#include <utility>
+
+#include "../id.hpp"
+#include "../util/GeneratedCallback.hpp"
+#include "ReactionIdentifiers.hpp"
+#include "ReactionTask.hpp"
+
 namespace NUClear {
 namespace threading {
 
@@ -29,7 +37,33 @@ namespace threading {
     std::atomic<NUClear::id_t> Reaction::reaction_id_source(0);  // NOLINT
 
     Reaction::Reaction(Reactor& reactor, ReactionIdentifiers&& identifiers, TaskGenerator&& generator)
-        : reactor(reactor), identifiers(std::move(identifiers)), generator(std::move(generator)) {}
+        : reactor(reactor)
+        , identifiers(std::make_shared<ReactionIdentifiers>(std::move(identifiers)))
+        , generator(std::move(generator)) {}
+
+    Reaction::~Reaction() = default;
+
+    std::unique_ptr<ReactionTask> Reaction::get_task() {
+        // If we are not enabled, don't run
+        if (!enabled) {
+            return nullptr;
+        }
+
+        // Run our generator to get a functor we can run
+        auto callback = generator(*this);
+
+        // If our generator returns a valid function
+        if (callback) {
+            return std::make_unique<ReactionTask>(*this,
+                                                  callback.priority,
+                                                  callback.group,
+                                                  callback.pool,
+                                                  std::move(callback.callback));
+        }
+
+        // Otherwise we return a null pointer
+        return nullptr;
+    }
 
     void Reaction::unbind() {
         // Unbind
diff --git a/src/threading/Reaction.hpp b/src/threading/Reaction.hpp
index 0154107e8..c930907ba 100644
--- a/src/threading/Reaction.hpp
+++ b/src/threading/Reaction.hpp
@@ -26,21 +26,25 @@
 #include <atomic>
 #include <functional>
 #include <memory>
-#include <string>
-#include <utility>
+#include <vector>
 
 #include "../id.hpp"
-#include "../util/GeneratedCallback.hpp"
-#include "ReactionIdentifiers.hpp"
-#include "ReactionTask.hpp"
 
 namespace NUClear {
 
 // Forward declare reactor
 class Reactor;
 
+namespace util {
+    struct GeneratedCallback;
+}  // namespace util
+
 namespace threading {
 
+    // Forward declare
+    class ReactionTask;
+    struct ReactionIdentifiers;
+
     /**
      * This class holds the definition of a Reaction.
      *
@@ -52,7 +56,7 @@ namespace threading {
     class Reaction {
         // Reaction handles are given to user code to enable and disable the reaction
         friend class ReactionHandle;
-        friend class Task<Reaction>;
+        friend class ReactionTask;
 
     public:
         // The type of the generator that is used to create functions for ReactionTask objects
@@ -67,44 +71,37 @@ namespace threading {
          */
         Reaction(Reactor& reactor, ReactionIdentifiers&& identifiers, TaskGenerator&& generator);
 
+        // No copying or moving this class
+        Reaction(const Reaction&)            = delete;
+        Reaction(Reaction&&)                 = delete;
+        Reaction& operator=(const Reaction&) = delete;
+        Reaction& operator=(Reaction&&)      = delete;
+
+        // This must go in the c++ file as ReactionTask is an incomplete type at this point
+        ~Reaction();
+
         /**
          * Creates a new databound callback task that can be executed.
          *
          * @return a unique_ptr to a Task which has the data for it's call bound into it
          */
-        std::unique_ptr<ReactionTask> get_task() {
-
-            // If we are not enabled, don't run
-            if (!enabled) {
-                return nullptr;
-            }
-
-            // Run our generator to get a functor we can run
-            auto callback = generator(*this);
-
-            // If our generator returns a valid function
-            if (callback) {
-                return std::make_unique<ReactionTask>(*this,
-                                                      callback.priority,
-                                                      callback.group,
-                                                      callback.pool,
-                                                      std::move(callback.callback));
-            }
-
-            // Otherwise we return a null pointer
-            return nullptr;
-        }
+        std::unique_ptr<ReactionTask> get_task();
 
         /**
          * @return `true` if this reaction is currently enabled
          */
         bool is_enabled() const;
 
+        /**
+         * Unbinds this reaction from it's context
+         */
+        void unbind();
+
         /// the reactor this belongs to
         Reactor& reactor;
 
         /// This holds the identifying strings for this reaction
-        ReactionIdentifiers identifiers;
+        std::shared_ptr<const ReactionIdentifiers> identifiers;
 
         /// the unique identifier for this Reaction object
         const NUClear::id_t id{++reaction_id_source};
@@ -121,16 +118,11 @@ namespace threading {
         /// list of functions to use to unbind the reaction and clean
         std::vector<std::function<void(Reaction&)>> unbinders;
 
-        /**
-         * Unbinds this reaction from it's context
-         */
-        void unbind();
-
     private:
-        /// a source for reaction_ids, atomically creates longs
-        static std::atomic<NUClear::id_t>
-            reaction_id_source;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-        /// the callback generator function (creates databound callbacks)
+        /// A source for reaction_ids, atomically creates ids
+        // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+        static std::atomic<NUClear::id_t> reaction_id_source;
+        /// The callback generator function (creates databound callbacks)
         TaskGenerator generator;
     };
 
diff --git a/src/threading/ReactionHandle.cpp b/src/threading/ReactionHandle.cpp
new file mode 100644
index 000000000..f2c43b2d1
--- /dev/null
+++ b/src/threading/ReactionHandle.cpp
@@ -0,0 +1,77 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2013 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "ReactionHandle.hpp"
+
+#include <memory>
+
+#include "Reaction.hpp"
+
+namespace NUClear {
+namespace threading {
+
+    ReactionHandle::ReactionHandle(const std::shared_ptr<Reaction>& context) : context(context) {}
+
+    ReactionHandle& ReactionHandle::enable() {
+        auto c = context.lock();
+        if (c) {
+            c->enabled = true;
+        }
+        return *this;
+    }
+
+    ReactionHandle& ReactionHandle::disable() {
+        auto c = context.lock();
+        if (c) {
+            c->enabled = false;
+        }
+        return *this;
+    }
+
+    ReactionHandle& ReactionHandle::enable(const bool& set) {
+        auto c = context.lock();
+        if (c) {
+            c->enabled = set;
+        }
+        return *this;
+    }
+
+    bool ReactionHandle::enabled() const {
+        auto c = context.lock();
+        return c ? bool(c->enabled) : false;
+    }
+
+    // Unbind mutates the reaction which this is a handle for
+    // NOLINTNEXTLINE(readability-make-member-function-const)
+    void ReactionHandle::unbind() {
+        auto c = context.lock();
+        if (c) {
+            c->unbind();
+        }
+    }
+
+    ReactionHandle::operator bool() const {
+        return bool(context.lock());
+    }
+
+}  // namespace threading
+}  // namespace NUClear
diff --git a/src/threading/ReactionHandle.hpp b/src/threading/ReactionHandle.hpp
index 9ad3c5e1c..642ab0c75 100644
--- a/src/threading/ReactionHandle.hpp
+++ b/src/threading/ReactionHandle.hpp
@@ -24,11 +24,6 @@
 #define NUCLEAR_THREADING_REACTIONHANDLE_HPP
 
 #include <memory>
-#include <mutex>
-#include <queue>
-#include <string>
-#include <typeindex>
-#include <vector>
 
 #include "Reaction.hpp"
 
@@ -52,18 +47,12 @@ namespace threading {
          *
          * @param context The reaction that we are interacting with
          */
-        explicit ReactionHandle(const std::shared_ptr<Reaction>& context = nullptr) : context(context) {}
+        explicit ReactionHandle(const std::shared_ptr<Reaction>& context = nullptr);
 
         /**
          * Enables the reaction so that associated tasks will be scheduled and queued when the reaction is triggered.
          */
-        ReactionHandle& enable() {
-            auto c = context.lock();
-            if (c) {
-                c->enabled = true;
-            }
-            return *this;
-        }
+        ReactionHandle& enable();
 
         /**
          * Disables the reaction.
@@ -73,38 +62,21 @@ namespace threading {
          * Note that a reaction which has been bound by an on<Always> request should not be disabled as it will
          * continuously spin checking for new tasks.
          */
-        ReactionHandle& disable() {
-            auto c = context.lock();
-            if (c) {
-                c->enabled = false;
-            }
-            return *this;
-        }
+        ReactionHandle& disable();
 
         /**
          * Sets the run status of the reaction handle.
          *
          * @param set true for enable, false for disable
          */
-        ReactionHandle& enable(const bool& set) {
-            auto c = context.lock();
-            if (c) {
-                c->enabled = set;
-            }
-            return *this;
-        }
+        ReactionHandle& enable(const bool& set);
 
         /**
-         * Checks if the reaction is currently enabled.
-         *
-         * Will return false if the reaction has been unbound or for an unbound reaction handle.
+         * Informs if the reaction is currently enabled.
          *
          * @return true if enabled, false if disabled
          */
-        bool enabled() const {
-            auto c = context.lock();
-            return c ? bool(c->enabled) : false;
-        }
+        bool enabled() const;
 
         /**
          * Removes a reaction request from the runtime environment.
@@ -115,21 +87,14 @@ namespace threading {
          * configuration details during runtime.
          */
         // NOLINTNEXTLINE(readability-make-member-function-const) unbinding modifies the reaction
-        void unbind() {
-            auto c = context.lock();
-            if (c) {
-                c->unbind();
-            }
-        }
+        void unbind();
 
         /**
-         * Returns if this reaction handle holds a valid pointer (may be already unbound)
+         * Returns if this reaction handle holds a valid pointer (may be already unbound).
          *
          * @return true if the reaction is still valid
          */
-        operator bool() const {
-            return bool(context.lock());
-        }
+        operator bool() const;
     };
 
 }  // namespace threading
diff --git a/src/threading/ReactionIdentifiers.hpp b/src/threading/ReactionIdentifiers.hpp
index 2f33e5bbf..639afe583 100644
--- a/src/threading/ReactionIdentifiers.hpp
+++ b/src/threading/ReactionIdentifiers.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_THREADING_REACTIONIDENTIFIERS_HPP
-#define NUCLEAR_THREADING_REACTIONIDENTIFIERS_HPP
+#ifndef NUCLEAR_THREADING_REACTION_IDENTIFIERS_HPP
+#define NUCLEAR_THREADING_REACTION_IDENTIFIERS_HPP
 
 #include <string>
 
@@ -57,4 +57,4 @@ namespace threading {
 }  // namespace threading
 }  // namespace NUClear
 
-#endif  // NUCLEAR_THREADING_REACTIONIDENTIFIERS_HPP
+#endif  // NUCLEAR_THREADING_REACTION_IDENTIFIERS_HPP
diff --git a/src/threading/ReactionTask.cpp b/src/threading/ReactionTask.cpp
new file mode 100644
index 000000000..4b9c73bb5
--- /dev/null
+++ b/src/threading/ReactionTask.cpp
@@ -0,0 +1,84 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2013 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "ReactionTask.hpp"
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include "../id.hpp"
+#include "../message/ReactionStatistics.hpp"
+#include "../util/platform.hpp"
+#include "Reaction.hpp"
+
+namespace NUClear {
+namespace threading {
+
+    const ReactionTask* ReactionTask::get_current_task() {
+        return current_task;
+    }
+
+    ReactionTask::ReactionTask(Reaction& parent,
+                               const int& priority,
+                               const util::GroupDescriptor& group_descriptor,
+                               const util::ThreadPoolDescriptor& thread_pool_descriptor,
+                               TaskFunction&& callback)
+        : parent(parent)
+        , priority(priority)
+        , stats(std::make_shared<message::ReactionStatistics>(parent.identifiers,
+                                                              parent.id,
+                                                              id,
+                                                              current_task != nullptr ? current_task->parent.id : 0,
+                                                              current_task != nullptr ? current_task->id : 0,
+                                                              clock::now(),
+                                                              clock::time_point(std::chrono::seconds(0)),
+                                                              clock::time_point(std::chrono::seconds(0)),
+                                                              nullptr))
+        , emit_stats(parent.emit_stats && (current_task != nullptr ? current_task->emit_stats : true))
+        , group_descriptor(group_descriptor)
+        , thread_pool_descriptor(thread_pool_descriptor)
+        , callback(std::move(callback)) {}
+
+    void ReactionTask::run() {
+
+        // Update our current task
+        const std::shared_ptr<ReactionTask> lock(current_task, [](ReactionTask* t) { current_task = t; });
+        current_task = this;
+
+        // Run our callback
+        callback(*this);
+    }
+
+
+    NUClear::id_t ReactionTask::new_task_id() {
+        static std::atomic<NUClear::id_t> task_id_source(0);
+        return ++task_id_source;
+    }
+
+    // Initialize our current task
+    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+    ATTRIBUTE_TLS ReactionTask* ReactionTask::current_task = nullptr;
+
+}  // namespace threading
+}  // namespace NUClear
diff --git a/src/threading/ReactionTask.hpp b/src/threading/ReactionTask.hpp
index 9e9e4d705..606840a7e 100644
--- a/src/threading/ReactionTask.hpp
+++ b/src/threading/ReactionTask.hpp
@@ -20,54 +20,50 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_THREADING_REACTIONTASK_HPP
-#define NUCLEAR_THREADING_REACTIONTASK_HPP
+#ifndef NUCLEAR_THREADING_REACTION_TASK_HPP
+#define NUCLEAR_THREADING_REACTION_TASK_HPP
 
 #include <atomic>
 #include <functional>
 #include <memory>
-#include <typeindex>
-#include <vector>
+#include <set>
 
 #include "../id.hpp"
-#include "../message/ReactionStatistics.hpp"
 #include "../util/GroupDescriptor.hpp"
 #include "../util/ThreadPoolDescriptor.hpp"
 #include "../util/platform.hpp"
+#include "Reaction.hpp"
 
 namespace NUClear {
+
+namespace message {
+    struct ReactionStatistics;
+}  // namespace message
+
 namespace threading {
 
     /**
      * This is a databound call of a Reaction ready to be executed.
      *
-     * @tparam ReactionType the type of the reaction
-     *
      * This class holds a reaction that is ready to be executed.
      * It is a Reaction object which has had it's callback parameters bound with data.
      * This can then be executed as a function to run the call inside it.
      */
-    template <typename ReactionType>
-    class Task {
+    class ReactionTask {
     private:
-        /// A source for task ids, atomically creates longs
-        static std::atomic<NUClear::id_t> task_id_source;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
         /// The current task that is being executed by this thread (or nullptr if none is)
-        static ATTRIBUTE_TLS Task* current_task;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+        static ATTRIBUTE_TLS ReactionTask* current_task;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
     public:
         /// Type of the functions that ReactionTasks execute
-        using TaskFunction = std::function<void(Task<ReactionType>&)>;
+        using TaskFunction = std::function<void(ReactionTask&)>;
 
         /**
          * Gets the current executing task, or nullptr if there isn't one.
          *
          * @return The current executing task or nullptr if there isn't one
          */
-        static const Task* get_current_task() {
-            return current_task;
-        }
+        static const ReactionTask* get_current_task();
 
         /**
          * Creates a new ReactionTask object bound with the parent Reaction object (that created it) and task.
@@ -78,26 +74,11 @@ namespace threading {
          * @param thread_pool_descriptor The descriptor for the thread pool that this task should be queued in
          * @param callback               The data bound callback to be executed in the thread pool
          */
-        Task(ReactionType& parent,
-             const int& priority,
-             const util::GroupDescriptor& group_descriptor,
-             const util::ThreadPoolDescriptor& thread_pool_descriptor,
-             TaskFunction&& callback)
-            : parent(parent)
-            , priority(priority)
-            , stats(std::make_shared<message::ReactionStatistics>(parent.identifiers,
-                                                                  parent.id,
-                                                                  id,
-                                                                  current_task != nullptr ? current_task->parent.id : 0,
-                                                                  current_task != nullptr ? current_task->id : 0,
-                                                                  clock::now(),
-                                                                  clock::time_point(std::chrono::seconds(0)),
-                                                                  clock::time_point(std::chrono::seconds(0)),
-                                                                  nullptr))
-            , emit_stats(parent.emit_stats && (current_task != nullptr ? current_task->emit_stats : true))
-            , group_descriptor(group_descriptor)
-            , thread_pool_descriptor(thread_pool_descriptor)
-            , callback(std::move(callback)) {}
+        ReactionTask(Reaction& parent,
+                     const int& priority,
+                     const util::GroupDescriptor& group_descriptor,
+                     const util::ThreadPoolDescriptor& thread_pool_descriptor,
+                     TaskFunction&& callback);
 
 
         /**
@@ -106,27 +87,17 @@ namespace threading {
          * This runs the internal data bound task and times how long the execution takes.
          * These figures can then be used in a debugging context to calculate how long callbacks are taking to run.
          */
-        void run() {
-
-            // Update our current task
-            const std::shared_ptr<Task> lock(current_task, [](Task* t) { current_task = t; });
-            current_task = this;
-
-            // Run our callback
-            callback(*this);
-        }
+        void run();
 
         /**
          * Generate a new unique task id.
          *
          * @return A new unique task id
          */
-        static NUClear::id_t new_task_id() {
-            return ++task_id_source;
-        }
+        static NUClear::id_t new_task_id();
 
         /// The parent Reaction object which spawned this
-        ReactionType& parent;
+        Reaction& parent;
         /// The task id of this task (the sequence number of this particular task)
         NUClear::id_t id{new_task_id()};
         /// The priority to run this task at
@@ -150,21 +121,7 @@ namespace threading {
         TaskFunction callback;
     };
 
-    // Initialize our id source
-    template <typename ReactionType>
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    std::atomic<NUClear::id_t> Task<ReactionType>::task_id_source(0);
-
-    // Initialize our current task
-    template <typename ReactionType>
-    // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-    ATTRIBUTE_TLS Task<ReactionType>* Task<ReactionType>::current_task = nullptr;
-
-    // Alias the templated Task so that public API remains intact
-    class Reaction;
-    using ReactionTask = Task<Reaction>;
-
 }  // namespace threading
 }  // namespace NUClear
 
-#endif  // NUCLEAR_THREADING_REACTIONTASK_HPP
+#endif  // NUCLEAR_THREADING_REACTION_TASK_HPP
diff --git a/src/util/CallableInfo.hpp b/src/util/CallableInfo.hpp
index 6261a8cf7..8d03963eb 100644
--- a/src/util/CallableInfo.hpp
+++ b/src/util/CallableInfo.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_CALLABLEINFO_HPP
-#define NUCLEAR_UTIL_CALLABLEINFO_HPP
+#ifndef NUCLEAR_UTIL_CALLABLE_INFO_HPP
+#define NUCLEAR_UTIL_CALLABLE_INFO_HPP
 
 namespace NUClear {
 namespace util {
@@ -176,4 +176,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_CALLABLEINFO_HPP
+#endif  // NUCLEAR_UTIL_CALLABLE_INFO_HPP
diff --git a/src/util/CallbackGenerator.hpp b/src/util/CallbackGenerator.hpp
index 7234d13e7..673b6e6f1 100644
--- a/src/util/CallbackGenerator.hpp
+++ b/src/util/CallbackGenerator.hpp
@@ -20,19 +20,19 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_CALLBACKGENERATOR_HPP
-#define NUCLEAR_UTIL_CALLBACKGENERATOR_HPP
+#ifndef NUCLEAR_UTIL_CALLBACK_GENERATOR_HPP
+#define NUCLEAR_UTIL_CALLBACK_GENERATOR_HPP
 
 #include <type_traits>
 
-#include "../dsl/trait/is_transient.hpp"
 #include "../dsl/word/emit/Direct.hpp"
-#include "../util/GeneratedCallback.hpp"
+#include "../message/ReactionStatistics.hpp"
 #include "../util/MergeTransient.hpp"
 #include "../util/TransientDataElements.hpp"
 #include "../util/apply.hpp"
-#include "../util/demangle.hpp"
+#include "../util/unpack.hpp"
 #include "../util/update_current_thread_priority.hpp"
+#include "GeneratedCallback.hpp"
 
 namespace NUClear {
 namespace util {
@@ -146,4 +146,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_CALLBACKGENERATOR_HPP
+#endif  // NUCLEAR_UTIL_CALLBACK_GENERATOR_HPP
diff --git a/src/util/FileDescriptor.cpp b/src/util/FileDescriptor.cpp
index a494d7a35..2c0e691bf 100644
--- a/src/util/FileDescriptor.cpp
+++ b/src/util/FileDescriptor.cpp
@@ -22,6 +22,7 @@
 
 #include "FileDescriptor.hpp"
 
+#include <functional>
 #include <utility>
 
 #include "platform.hpp"
diff --git a/src/util/GeneratedCallback.hpp b/src/util/GeneratedCallback.hpp
index 5cdbac292..bd57c5804 100644
--- a/src/util/GeneratedCallback.hpp
+++ b/src/util/GeneratedCallback.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_GENERATEDCALLBACK_HPP
-#define NUCLEAR_UTIL_GENERATEDCALLBACK_HPP
+#ifndef NUCLEAR_UTIL_GENERATED_CALLBACK_HPP
+#define NUCLEAR_UTIL_GENERATED_CALLBACK_HPP
 
 #include <limits>
 
@@ -62,4 +62,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_GENERATEDCALLBACK_HPP
+#endif  // NUCLEAR_UTIL_GENERATED_CALLBACK_HPP
diff --git a/src/util/GroupDescriptor.hpp b/src/util/GroupDescriptor.hpp
index bc3ca8ded..ce8be7fa4 100644
--- a/src/util/GroupDescriptor.hpp
+++ b/src/util/GroupDescriptor.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_GROUPDESCRIPTOR_HPP
-#define NUCLEAR_UTIL_GROUPDESCRIPTOR_HPP
+#ifndef NUCLEAR_UTIL_GROUP_DESCRIPTOR_HPP
+#define NUCLEAR_UTIL_GROUP_DESCRIPTOR_HPP
 
 #include <atomic>
 #include <cstddef>
@@ -56,4 +56,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_GROUPDESCRIPTOR_HPP
+#endif  // NUCLEAR_UTIL_GROUP_DESCRIPTOR_HPP
diff --git a/src/util/MergeTransient.hpp b/src/util/MergeTransient.hpp
index 2ed436ce7..8967240af 100644
--- a/src/util/MergeTransient.hpp
+++ b/src/util/MergeTransient.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_MERGETRANSIENT_HPP
-#define NUCLEAR_UTIL_MERGETRANSIENT_HPP
+#ifndef NUCLEAR_UTIL_MERGE_TRANSIENT_HPP
+#define NUCLEAR_UTIL_MERGE_TRANSIENT_HPP
 
 namespace NUClear {
 namespace util {
@@ -37,4 +37,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_MERGETRANSIENT_HPP
+#endif  // NUCLEAR_UTIL_MERGE_TRANSIENT_HPP
diff --git a/src/util/ThreadPoolDescriptor.hpp b/src/util/ThreadPoolDescriptor.hpp
index 5d1cd38fa..5e6d9b885 100644
--- a/src/util/ThreadPoolDescriptor.hpp
+++ b/src/util/ThreadPoolDescriptor.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_THREADPOOL_HPP
-#define NUCLEAR_UTIL_THREADPOOL_HPP
+#ifndef NUCLEAR_UTIL_THREAD_POOL_DESCRIPTOR_HPP
+#define NUCLEAR_UTIL_THREAD_POOL_DESCRIPTOR_HPP
 
 #include <atomic>
 #include <cstddef>
@@ -69,4 +69,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_THREADPOOL_HPP
+#endif  // NUCLEAR_UTIL_THREAD_POOL_DESCRIPTOR_HPP
diff --git a/src/util/TransientDataElements.hpp b/src/util/TransientDataElements.hpp
index 9ab9ed52d..65fab318e 100644
--- a/src/util/TransientDataElements.hpp
+++ b/src/util/TransientDataElements.hpp
@@ -20,8 +20,8 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef NUCLEAR_UTIL_TRANSIENTDATAELEMENTS_HPP
-#define NUCLEAR_UTIL_TRANSIENTDATAELEMENTS_HPP
+#ifndef NUCLEAR_UTIL_TRANSIENT_DATA_ELEMENTS_HPP
+#define NUCLEAR_UTIL_TRANSIENT_DATA_ELEMENTS_HPP
 
 #include "../dsl/trait/is_transient.hpp"
 #include "Sequence.hpp"
@@ -56,4 +56,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_TRANSIENTDATAELEMENTS_HPP
+#endif  // NUCLEAR_UTIL_TRANSIENT_DATA_ELEMENTS_HPP
diff --git a/src/util/get_hostname.cpp b/src/util/get_hostname.cpp
new file mode 100644
index 000000000..2cd47c5d6
--- /dev/null
+++ b/src/util/get_hostname.cpp
@@ -0,0 +1,48 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2017 NUClear Contributors
+ *
+ * This file is part of the NUClear codebase.
+ * See https://github.com/Fastcode/NUClear for further info.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "get_hostname.hpp"
+
+#include <string>
+
+#ifdef _WIN32
+
+    #include "platform.hpp"
+
+std::string NUClear::util::get_hostname() {
+    char n[MAX_COMPUTERNAME_LENGTH + 1];
+    DWORD size = sizeof(n);
+    GetComputerName(n, &size);
+    return std::string(n, size);
+}
+
+#else
+
+    #include <sys/utsname.h>
+
+std::string NUClear::util::get_hostname() {
+    utsname u{};
+    uname(&u);
+    return u.nodename;
+}
+
+#endif
diff --git a/src/util/get_hostname.hpp b/src/util/get_hostname.hpp
index 77d62c4a7..0f4033c24 100644
--- a/src/util/get_hostname.hpp
+++ b/src/util/get_hostname.hpp
@@ -23,29 +23,17 @@
 #ifndef NUCLEAR_UTIL_GET_HOSTNAME_HPP
 #define NUCLEAR_UTIL_GET_HOSTNAME_HPP
 
-#ifdef _WIN32
-    #include "platform.hpp"
-#else
-    #include <sys/utsname.h>
-#endif
+#include <string>
 
 namespace NUClear {
 namespace util {
 
-    inline std::string get_hostname() {
-
-// If our config name is empty, use our system name
-#ifdef _WIN32
-        char n[MAX_COMPUTERNAME_LENGTH + 1];
-        DWORD size = sizeof(n);
-        GetComputerName(n, &size);
-        return std::string(n, size);
-#else
-        utsname u{};
-        uname(&u);
-        return u.nodename;
-#endif
-    }
+    /**
+     * Get the hostname of the machine.
+     *
+     * @return the hostname of the machine
+     */
+    std::string get_hostname();
 
 }  // namespace util
 }  // namespace NUClear
diff --git a/src/util/main_thread_id.cpp b/src/util/main_thread_id.cpp
index f0b845f30..41f1e3f88 100644
--- a/src/util/main_thread_id.cpp
+++ b/src/util/main_thread_id.cpp
@@ -22,6 +22,8 @@
 
 #include "main_thread_id.hpp"
 
+#include <thread>
+
 namespace NUClear {
 namespace util {
 
diff --git a/src/util/main_thread_id.hpp b/src/util/main_thread_id.hpp
index 87a0046b5..dd4f0e51d 100644
--- a/src/util/main_thread_id.hpp
+++ b/src/util/main_thread_id.hpp
@@ -30,7 +30,7 @@ namespace util {
 
     /**
      * The thread id of the main execution thread for this process.
-
+     *
      * In order to get the main threads id, we set it as a global static variable.
      * This should result in the static setup code executing on startup (in the main thread).
      */
diff --git a/src/util/network/if_number_from_address.cpp b/src/util/network/if_number_from_address.cpp
index 272aeea5e..1b4cbd400 100644
--- a/src/util/network/if_number_from_address.cpp
+++ b/src/util/network/if_number_from_address.cpp
@@ -24,9 +24,15 @@
 
 #include <algorithm>
 #include <cstring>
+#include <iterator>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
 
 #include "../platform.hpp"
 #include "get_interfaces.hpp"
+#include "sock_t.hpp"
 
 namespace NUClear {
 namespace util {
diff --git a/src/util/network/if_number_from_address.hpp b/src/util/network/if_number_from_address.hpp
index d1b3fc4b2..9f3bd73a8 100644
--- a/src/util/network/if_number_from_address.hpp
+++ b/src/util/network/if_number_from_address.hpp
@@ -23,10 +23,7 @@
 #ifndef NUCLEAR_UTIL_NETWORK_IF_NUMBER_FROM_ADDRESS_HPP
 #define NUCLEAR_UTIL_NETWORK_IF_NUMBER_FROM_ADDRESS_HPP
 
-#include <string>
-#include <vector>
-
-#include "sock_t.hpp"
+struct sockaddr_in6;
 
 namespace NUClear {
 namespace util {
diff --git a/src/util/network/resolve.cpp b/src/util/network/resolve.cpp
index 73435b41b..98034614c 100644
--- a/src/util/network/resolve.cpp
+++ b/src/util/network/resolve.cpp
@@ -22,12 +22,15 @@
 
 #include "resolve.hpp"
 
+#include <cstdint>
 #include <cstring>
-#include <iostream>
 #include <memory>
 #include <stdexcept>
+#include <string>
+#include <system_error>
 
 #include "../platform.hpp"
+#include "sock_t.hpp"
 
 namespace NUClear {
 namespace util {
diff --git a/src/util/network/resolve.hpp b/src/util/network/resolve.hpp
index 388517eb8..0cf5c00b2 100644
--- a/src/util/network/resolve.hpp
+++ b/src/util/network/resolve.hpp
@@ -23,6 +23,7 @@
 #ifndef NUCLEAR_UTIL_NETWORK_RESOLVE_HPP
 #define NUCLEAR_UTIL_NETWORK_RESOLVE_HPP
 
+#include <cstdint>
 #include <string>
 
 #include "sock_t.hpp"
diff --git a/src/util/platform.cpp b/src/util/platform.cpp
index 30f2601de..d177c806e 100644
--- a/src/util/platform.cpp
+++ b/src/util/platform.cpp
@@ -20,10 +20,10 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "platform.hpp"
-
 #ifdef _WIN32
 
+    #include "platform.hpp"
+
     #include <stdexcept>
     #include <system_error>
 LPFN_WSARECVMSG WSARecvMsg = nullptr;
diff --git a/src/util/platform.hpp b/src/util/platform.hpp
index 5cc57dcec..7ce49882b 100644
--- a/src/util/platform.hpp
+++ b/src/util/platform.hpp
@@ -117,6 +117,7 @@
 #ifdef _WIN32
 
     #include <cstdint>
+
 using ssize_t   = SSIZE_T;
 using in_port_t = uint16_t;
 using in_addr_t = uint32_t;
diff --git a/src/util/serialise/xxhash.cpp b/src/util/serialise/xxhash.cpp
index 98253177f..d8e86de63 100644
--- a/src/util/serialise/xxhash.cpp
+++ b/src/util/serialise/xxhash.cpp
@@ -22,6 +22,8 @@
 
 #include "xxhash.hpp"
 
+#include <cstddef>
+#include <cstdint>
 #include <type_traits>
 
 namespace NUClear {
diff --git a/tests/test_util/TestBase.hpp b/tests/test_util/TestBase.hpp
index 1cdf14b0c..583825798 100644
--- a/tests/test_util/TestBase.hpp
+++ b/tests/test_util/TestBase.hpp
@@ -46,11 +46,6 @@ class TestBase : public NUClear::Reactor {
     template <int i>
     struct Step {};
 
-    /**
-     * Struct to handle shutting down the PowerPlant when the system is idle (i.e. the unit test(s) are finished)
-     */
-    struct ShutdownOnIdle {};
-
     explicit TestBase(std::unique_ptr<NUClear::Environment> environment, const bool& shutdown_on_idle = true)
         : Reactor(std::move(environment)) {
 
diff --git a/tests/test_util/diff_string.cpp b/tests/test_util/diff_string.cpp
index 77856ec68..078d24e87 100644
--- a/tests/test_util/diff_string.cpp
+++ b/tests/test_util/diff_string.cpp
@@ -22,7 +22,9 @@
 
 #include "diff_string.hpp"
 
+#include <algorithm>
 #include <cstring>
+#include <utility>
 
 #include "lcs.hpp"
 
diff --git a/tests/test_util/has_ipv6.cpp b/tests/test_util/has_ipv6.cpp
index cd23432f2..ed5afa8eb 100644
--- a/tests/test_util/has_ipv6.cpp
+++ b/tests/test_util/has_ipv6.cpp
@@ -22,7 +22,7 @@
 
 #include "has_ipv6.hpp"
 
-#include "nuclear"
+#include <nuclear>
 
 namespace test_util {
 
diff --git a/tests/tests/api/BaseClock.cpp b/tests/tests/api/BaseClock.cpp
deleted file mode 100644
index 932e52b3b..000000000
--- a/tests/tests/api/BaseClock.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2022 NUClear Contributors
- *
- * This file is part of the NUClear codebase.
- * See https://github.com/Fastcode/NUClear for further info.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
- * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
- * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
- * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <catch2/catch_test_macros.hpp>
-#include <ctime>  // for localtime_r/s
-
-// This define declares that we are using steady_clock as the base clock for NUClear
-#define NUCLEAR_CLOCK_TYPE std::chrono::steady_clock
-
-#include <chrono>
-#include <nuclear>
-#include <utility>
-
-#include "message/ReactionStatistics.hpp"
-#include "test_util/TestBase.hpp"
-
-// Anonymous namespace to keep everything file local
-namespace {
-
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::vector<std::pair<NUClear::clock::time_point, std::chrono::steady_clock::time_point>> times;
-// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
-std::mutex times_mutex;
-constexpr int n_time = 100;
-
-class TestReactor : public NUClear::Reactor {
-public:
-    TestReactor(std::unique_ptr<NUClear::Environment> environment) : Reactor(std::move(environment)) {
-
-        // Have a frequently running reaction so that ReactionStatistics will be emitted
-        on<Every<10, std::chrono::milliseconds>>().then([] {});
-
-        // Trigger on ReactionStatistics so that we can record the times that messages were emitted and compare them
-        // against the current time If everything is working as it should then the emitted times and the current times
-        // should be identical (at least down to the second, but it depends on when the clock ticks over)
-        on<Trigger<NUClear::message::ReactionStatistics>>().then(
-            [this](const NUClear::message::ReactionStatistics& stats) {
-                const std::lock_guard<std::mutex> lock(times_mutex);
-                times.push_back(std::make_pair(stats.finished, std::chrono::steady_clock::now()));
-                if (times.size() > n_time) {
-                    powerplant.shutdown();
-                }
-            });
-    }
-};
-}  // namespace
-
-TEST_CASE("Testing base clock works correctly", "[api][base_clock]") {
-
-    INFO("Ensure NUClear base_clock is the correct type");
-    STATIC_REQUIRE(std::is_base_of<std::chrono::steady_clock, NUClear::clock>::value);
-
-    // Construct the powerplant
-    NUClear::Configuration config;
-    config.thread_count = 1;
-    NUClear::PowerPlant plant(config);
-
-    // Install our test reactor
-    plant.install<TestReactor>();
-
-    // Start the powerplant
-    plant.start();
-
-    // Setup a struct to convert std::tm* into a more usable format and to make comparison cleaner
-    struct TimeData {
-        TimeData(const std::tm* tm)
-            : year(tm->tm_year)
-            , month(tm->tm_mon)
-            , day(tm->tm_mday)
-            , hour(tm->tm_hour)
-            , min(tm->tm_min)
-            , sec(tm->tm_sec) {}
-        bool operator==(const TimeData& other) const {
-            return year == other.year && month == other.month && day == other.day && hour == other.hour
-                   && min == other.min && sec == other.sec;
-        }
-        int year;
-        int month;
-        int day;
-        int hour;
-        int min;
-        int sec;
-    };
-
-    // Compute the differences between the time pairs
-    int match_count = 0;
-    for (const auto& time_pairs : times) {
-        using namespace std::chrono;  // NOLINT(google-build-using-namespace)
-        const std::time_t ntt = system_clock::to_time_t(
-            system_clock::time_point(duration_cast<system_clock::duration>(time_pairs.first.time_since_epoch())));
-        const std::time_t stt = system_clock::to_time_t(
-            system_clock::time_point(duration_cast<system_clock::duration>(time_pairs.second.time_since_epoch())));
-
-        std::tm result{};
-#ifdef WIN32
-        localtime_s(&result, &ntt);
-#else
-        localtime_r(&ntt, &result);
-#endif  // WIN32
-        const TimeData nuclear_clock(&result);
-
-#ifdef WIN32
-        localtime_s(&result, &stt);
-#else
-        localtime_r(&stt, &result);
-#endif  // WIN32
-
-        const TimeData local_clock(&result);
-
-        UNSCOPED_INFO("Year.: " << nuclear_clock.year + 1900 << " == " << local_clock.year + 1900 << "\n"
-                                << "Month: " << nuclear_clock.month << " == " << local_clock.month << "\n"
-                                << "Day..: " << nuclear_clock.day << " == " << local_clock.day << "\n"
-                                << "Hour.: " << nuclear_clock.hour << " == " << local_clock.hour << "\n"
-                                << "Min..: " << nuclear_clock.min << " == " << local_clock.min << "\n"
-                                << "Sec..: " << nuclear_clock.sec << " == " << local_clock.sec);
-        if (nuclear_clock == local_clock) {
-            ++match_count;
-        }
-    }
-
-    // At least 95% of all reaction statistics should match to the second
-    REQUIRE(match_count >= 95);
-}
diff --git a/tests/tests/api/ReactionStatistics.cpp b/tests/tests/api/ReactionStatistics.cpp
index f852f1a00..6974249d8 100644
--- a/tests/tests/api/ReactionStatistics.cpp
+++ b/tests/tests/api/ReactionStatistics.cpp
@@ -52,11 +52,11 @@ class TestReactor : public test_util::TestBase<TestReactor> {
         on<Trigger<ReactionStatistics>>().then("Reaction Stats Handler", [this](const ReactionStatistics& stats) {
             // Other reactions statistics run on this because of built in NUClear reactors (e.g. chrono controller etc)
             // We want to filter those out so only our own stats are shown
-            if (stats.identifiers.name.empty() || stats.identifiers.reactor != reactor_name) {
+            if (stats.identifiers->name.empty() || stats.identifiers->reactor != reactor_name) {
                 return;
             }
-            events.push_back("Stats for " + stats.identifiers.name + " from " + stats.identifiers.reactor);
-            events.push_back(stats.identifiers.dsl);
+            events.push_back("Stats for " + stats.identifiers->name + " from " + stats.identifiers->reactor);
+            events.push_back(stats.identifiers->dsl);
 
             // Ensure exceptions are passed through correctly in the exception handler
             if (stats.exception) {
diff --git a/tests/tests/dsl/Every.cpp b/tests/tests/dsl/Every.cpp
index 54baf339b..63b0dbce7 100644
--- a/tests/tests/dsl/Every.cpp
+++ b/tests/tests/dsl/Every.cpp
@@ -29,9 +29,9 @@
 namespace {
 
 // Store our times
-std::vector<NUClear::clock::time_point> every_times{};    // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-std::vector<NUClear::clock::time_point> per_times{};      // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-std::vector<NUClear::clock::time_point> dynamic_times{};  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+std::vector<NUClear::clock::time_point> every_times;    // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+std::vector<NUClear::clock::time_point> per_times;      // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+std::vector<NUClear::clock::time_point> dynamic_times;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 class TestReactor : public test_util::TestBase<TestReactor, 20000> {
 
diff --git a/tests/tests/dsl/TCP.cpp b/tests/tests/dsl/TCP.cpp
index a5b3a27ea..70c1175fe 100644
--- a/tests/tests/dsl/TCP.cpp
+++ b/tests/tests/dsl/TCP.cpp
@@ -218,7 +218,7 @@ TEST_CASE("Testing listening for TCP connections and receiving data messages", "
     plant.start();
 
     // Get the results for the tests we expect
-    std::vector<std::string> expected{};
+    std::vector<std::string> expected;
     for (const auto& t : active_tests) {
         switch (t) {
             case V4_KNOWN:
diff --git a/tests/tests/util/demangle.cpp b/tests/tests/util/demangle.cpp
index 7c920b81c..0703e7d39 100644
--- a/tests/tests/util/demangle.cpp
+++ b/tests/tests/util/demangle.cpp
@@ -21,11 +21,10 @@
  */
 
 #include <catch2/catch_test_macros.hpp>
+#include <nuclear>
 #include <string>
 #include <typeinfo>
 
-#include "nuclear"
-
 struct TestSymbol {};
 
 template <typename T>
@@ -48,7 +47,7 @@ SCENARIO("Test the demangle function correctly demangles symbols", "[util][deman
 
     GIVEN("An empty symbol") {
         const char* symbol = "";
-        const std::string expected{};
+        const std::string expected;
 
         WHEN("Demangle is called") {
             const std::string result = NUClear::util::demangle(symbol);
diff --git a/tests/tests/util/network/resolve.cpp b/tests/tests/util/network/resolve.cpp
index d5335f6d4..4f83969b4 100644
--- a/tests/tests/util/network/resolve.cpp
+++ b/tests/tests/util/network/resolve.cpp
@@ -23,6 +23,7 @@
 #include "util/network/resolve.hpp"
 
 #include <catch2/catch_test_macros.hpp>
+#include <string>
 
 TEST_CASE("resolve function returns expected socket address", "[util][network][resolve]") {
 
diff --git a/tests/tests/util/serialise/serialise.cpp b/tests/tests/util/serialise/serialise.cpp
index e5f28fe23..5216f98a1 100644
--- a/tests/tests/util/serialise/serialise.cpp
+++ b/tests/tests/util/serialise/serialise.cpp
@@ -26,7 +26,12 @@
 #include <catch2/catch_template_test_macros.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <cstdint>
+#include <iterator>
 #include <list>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
 #include <vector>
 
 SCENARIO("Serialisation works correctly on single primitives", "[util][serialise][single][primitive]") {
@@ -160,7 +165,7 @@ TEMPLATE_TEST_CASE("Scenario: Serialisation works correctly on iterables of prim
     }
 
     GIVEN("empty serialised data") {
-        const std::vector<uint8_t> in{};
+        const std::vector<uint8_t> in;
 
         WHEN("it is deserialised") {
             const auto deserialised = NUClear::util::serialise::Serialise<TestType>::deserialise(in);
diff --git a/tests/tests/util/serialise/xxhash.cpp b/tests/tests/util/serialise/xxhash.cpp
index 3f052f7c5..3013ddfac 100644
--- a/tests/tests/util/serialise/xxhash.cpp
+++ b/tests/tests/util/serialise/xxhash.cpp
@@ -25,6 +25,8 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/generators/catch_generators.hpp>
 #include <cstdint>
+#include <string>
+#include <utility>
 
 // The seed used for the tests (the same one that NUClear uses)
 constexpr uint32_t fixed_seed = 0x4e55436c;