diff --git a/src/PowerPlant.cpp b/src/PowerPlant.cpp
index f4f271e8..15ecc76f 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 27270e0f..5b5cfd52 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 d0b5368b..00000000
--- 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 f5005746..4416bc0f 100644
--- a/src/Reactor.hpp
+++ b/src/Reactor.hpp
@@ -425,7 +425,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/dsl/fusion/BindFusion.hpp b/src/dsl/fusion/BindFusion.hpp
index 3b44f3ff..3422a302 100644
--- a/src/dsl/fusion/BindFusion.hpp
+++ b/src/dsl/fusion/BindFusion.hpp
@@ -23,8 +23,8 @@
 #ifndef NUCLEAR_DSL_FUSION_BINDFUSION_HPP
 #define NUCLEAR_DSL_FUSION_BINDFUSION_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"
 
diff --git a/src/dsl/fusion/GetFusion.hpp b/src/dsl/fusion/GetFusion.hpp
index bc9ab8e5..47636ce7 100644
--- a/src/dsl/fusion/GetFusion.hpp
+++ b/src/dsl/fusion/GetFusion.hpp
@@ -23,7 +23,7 @@
 #ifndef NUCLEAR_DSL_FUSION_GETFUSION_HPP
 #define NUCLEAR_DSL_FUSION_GETFUSION_HPP
 
-#include "../../threading/ReactionHandle.hpp"
+#include "../../threading/Reaction.hpp"
 #include "../../util/tuplify.hpp"
 #include "../operation/DSLProxy.hpp"
 #include "has_get.hpp"
diff --git a/src/dsl/word/MainThread.hpp b/src/dsl/word/MainThread.hpp
index 61175a44..e42bdda3 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/emit/Direct.hpp b/src/dsl/word/emit/Direct.hpp
index fc71d1fa..84cbe4a2 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/extension/ChronoController.cpp b/src/extension/ChronoController.cpp
new file mode 100644
index 00000000..30149d18
--- /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 b5a73f20..e3954f6e 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/nuclear.in b/src/nuclear.in
index 461bf888..06991ec7 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/util/CallbackGenerator.hpp b/src/util/CallbackGenerator.hpp
index 7234d13e..ed48dd2c 100644
--- a/src/util/CallbackGenerator.hpp
+++ b/src/util/CallbackGenerator.hpp
@@ -25,14 +25,14 @@
 
 #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 {
diff --git a/src/util/TransientDataElements.hpp b/src/util/TransientDataElements.hpp
index 5a183e32..813e50c4 100644
--- a/src/util/TransientDataElements.hpp
+++ b/src/util/TransientDataElements.hpp
@@ -20,8 +20,10 @@
  * 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"
 
 namespace NUClear {
 namespace util {
@@ -53,4 +55,4 @@ namespace util {
 }  // namespace util
 }  // namespace NUClear
 
-#endif  // NUCLEAR_UTIL_TRANSIENTDATAELEMENTS_HPP
+#endif  // NUCLEAR_UTIL_TRANSIENT_DATA_ELEMENTS_HPP