diff --git a/ext/ghoul b/ext/ghoul
index c478ec84d5..212f1efd5d 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit c478ec84d584d4cd843ec2e472d7e84b4ec91791
+Subproject commit 212f1efd5d9ecd1e84937a01ee9f04a0e10b8a58
diff --git a/include/openspace/engine/logfactory.h b/include/openspace/engine/logfactory.h
index ab615b4236..2af0fde8df 100644
--- a/include/openspace/engine/logfactory.h
+++ b/include/openspace/engine/logfactory.h
@@ -25,21 +25,35 @@
 #ifndef __LOGFACTORY_H__
 #define __LOGFACTORY_H__
 
-#include <ghoul/misc/dictionary.h>
 #include <memory>
 
 namespace ghoul {
-namespace logging {
-	class Log;
-} // logging
-} // ghoul
+    class Dictionary;
+    namespace logging {
+        class Log;
+    }
+}
 
 namespace openspace {
 
-class LogFactory {
-public:
-    static std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictionary);
-};
+/**
+ * This function provides the capabilities to create a new ghoul::logging::Log from the
+ * provided ghoul::Dictionary%. The Dictionary must at least contain a <code>Type</code>
+ * value that determines the type of the created Log. Currently the types
+ * <code>HTML</code> and <code>Text</code> are supported which create a
+ * ghoul::logging::TextLog%, and ghoul::logging::HTMLLog respectively with both also
+ * require the <code>FileName</code> value for the location at which the logfile should be
+ * created . Both logs can be customized using the <code>Append</code>,
+ * <code>TimeStamping</code>, <code>DateStamping</code>, <code>CategoryStamping</code>,
+ * and <code>LogLevelStamping</code> values.
+ * \param dictionary The dictionary from which the ghoul::logging::Log should be created
+ * \return The created ghoul::logging::Log
+ * \post The return value will not be <code>nullptr</code>
+ * \throw ghoul::RuntimeError If there was an error creating the ghoul::logging::Log
+ * \sa ghoul::logging::TextLeg
+ * \sa ghoul::logging::HTMLLog
+ */
+std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictionary);
 
 } // namespace openspace
 
diff --git a/include/openspace/engine/openspaceengine.h b/include/openspace/engine/openspaceengine.h
index f44b4cb4ad..7879b20cd9 100644
--- a/include/openspace/engine/openspaceengine.h
+++ b/include/openspace/engine/openspaceengine.h
@@ -25,27 +25,19 @@
 #ifndef __OPENSPACEENGINE_H__
 #define __OPENSPACEENGINE_H__
 
-
-#include <ghoul/glm.h>
-
-#include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/util/keys.h>
 #include <openspace/util/mouse.h>
 
-#include <ghoul/font/fontmanager.h>
+#include <ghoul/glm.h>
 #include <ghoul/misc/dictionary.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 namespace ghoul {
-namespace cmdparser {
-    class CommandlineParser;
-}
-namespace fontrendering {
-    class FontManager;
-}
-
+namespace cmdparser { class CommandlineParser; }
+namespace fontrendering { class FontManager; }
 }
 
 namespace openspace {
@@ -57,28 +49,17 @@ class GUI;
 class RenderEngine;
 class SyncBuffer;
 class ModuleEngine;
+class WindowWrapper;
 
-namespace interaction {
-    class InteractionHandler;
-}
-namespace gui {
-    class GUI;
-}
-namespace scripting {
-	class ScriptEngine;
-}
-    
-namespace network {
-    class ParallelConnection;
-}
-    
-namespace properties {
-    class PropertyOwner;
-}
+namespace interaction { class InteractionHandler; }
+namespace gui { class GUI; }
+namespace scripting { class ScriptEngine; }
+namespace network { class ParallelConnection; }
+namespace properties { class PropertyOwner; }
  
 class OpenSpaceEngine {
 public:
-    static bool create(int argc, char** argv, WindowWrapper* windowWrapper, std::vector<std::string>& sgctArguments);
+    static bool create(int argc, char** argv, std::unique_ptr<WindowWrapper> windowWrapper, std::vector<std::string>& sgctArguments);
     static void destroy();
     static OpenSpaceEngine& ref();
 
@@ -91,27 +72,25 @@ public:
     static bool findConfiguration(std::string& filename);
 
     // Guaranteed to return a valid pointer
-    ConfigurationManager* configurationManager();
-    interaction::InteractionHandler* interactionHandler();
-    RenderEngine* renderEngine();
-	scripting::ScriptEngine* scriptEngine();
-    NetworkEngine* networkEngine();
-	LuaConsole* console();
-    ModuleEngine* moduleEngine();
-    network::ParallelConnection* parallelConnection();
-    properties::PropertyOwner* globalPropertyOwner();
+    ConfigurationManager& configurationManager();
+    interaction::InteractionHandler& interactionHandler();
+    RenderEngine& renderEngine();
+	scripting::ScriptEngine& scriptEngine();
+    NetworkEngine& networkEngine();
+	LuaConsole& console();
+    ModuleEngine& moduleEngine();
+    network::ParallelConnection& parallelConnection();
+    properties::PropertyOwner& globalPropertyOwner();
     WindowWrapper& windowWrapper();
     ghoul::fontrendering::FontManager& fontManager();
-
-	gui::GUI* gui();
+	gui::GUI& gui();
 
     // SGCT callbacks
     bool initializeGL();
     void preSynchronization();
     void postSynchronizationPreDraw();
-	void render(const glm::mat4 &projectionMatrix, const glm::mat4 &viewMatrix);
+	void render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix);
 	void postDraw();
-//	void keyboardCallback(int key, int action);
     void keyboardCallback(Key key, KeyModifier mod, KeyAction action);
 	void charCallback(unsigned int codepoint, KeyModifier mod);
     void mouseButtonCallback(MouseButton button, MouseAction action);
@@ -127,40 +106,39 @@ public:
     void runSettingsScripts();
 
 private:
-    OpenSpaceEngine(std::string programName, WindowWrapper* windowWrapper);
+    OpenSpaceEngine(std::string programName, std::unique_ptr<WindowWrapper> windowWrapper);
     ~OpenSpaceEngine();
-    OpenSpaceEngine(const OpenSpaceEngine& rhs) = delete;
 
 	void clearAllWindows();
 	bool gatherCommandlineArguments();
 	bool loadSpiceKernels();
-	void loadFonts();
-    void loadFonts2();
+    void loadFonts();
     void runScripts(const ghoul::Dictionary& scripts);
     void runStartupScripts();
 	void configureLogging();
 
-    static OpenSpaceEngine* _engine;
 
-    ConfigurationManager* _configurationManager;
-    interaction::InteractionHandler* _interactionHandler;
-    RenderEngine* _renderEngine;
-	scripting::ScriptEngine* _scriptEngine;
-    NetworkEngine* _networkEngine;
-	ghoul::cmdparser::CommandlineParser* _commandlineParser;
-	LuaConsole* _console;
-    ModuleEngine* _moduleEngine;
-    gui::GUI* _gui;
-    network::ParallelConnection* _parallelConnection;
-    WindowWrapper* _windowWrapper;
-    ghoul::fontrendering::FontManager*_fontManager;
+    std::unique_ptr<ConfigurationManager> _configurationManager;
+    std::unique_ptr<interaction::InteractionHandler> _interactionHandler;
+    std::unique_ptr<RenderEngine> _renderEngine;
+	std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
+    std::unique_ptr<NetworkEngine> _networkEngine;
+	std::unique_ptr<ghoul::cmdparser::CommandlineParser> _commandlineParser;
+	std::unique_ptr<LuaConsole> _console;
+    std::unique_ptr<ModuleEngine> _moduleEngine;
+    std::unique_ptr<gui::GUI> _gui;
+    std::unique_ptr<network::ParallelConnection> _parallelConnection;
+    std::unique_ptr<WindowWrapper> _windowWrapper;
+    std::unique_ptr<ghoul::fontrendering::FontManager> _fontManager;
     
-    properties::PropertyOwner* _globalPropertyNamespace;
+    std::unique_ptr<properties::PropertyOwner> _globalPropertyNamespace;
     
 	bool _isMaster;
     double _runTime;
 
-	SyncBuffer* _syncBuffer;
+	std::unique_ptr<SyncBuffer> _syncBuffer;
+
+    static OpenSpaceEngine* _engine;
 };
 
 #define OsEng (openspace::OpenSpaceEngine::ref())
diff --git a/modules/base/rendering/renderableplane.cpp b/modules/base/rendering/renderableplane.cpp
index a3c27a1e96..096f972cee 100644
--- a/modules/base/rendering/renderableplane.cpp
+++ b/modules/base/rendering/renderableplane.cpp
@@ -186,7 +186,7 @@ void RenderablePlane::render(const RenderData& data) {
 	_shader->activate();
 	if (_projectionListener){
 		//get parent node-texture and set with correct dimensions  
-		SceneGraphNode* textureNode = OsEng.renderEngine()->scene()->sceneGraphNode(_nodeName)->parent();
+		SceneGraphNode* textureNode = OsEng.renderEngine().scene()->sceneGraphNode(_nodeName)->parent();
 		if (textureNode != nullptr){
 			RenderablePlanetProjection* t = static_cast<RenderablePlanetProjection*>(textureNode->renderable());
             _texture = std::unique_ptr<ghoul::opengl::Texture>(t->baseTexture());
diff --git a/modules/base/rendering/renderableplanet.cpp b/modules/base/rendering/renderableplanet.cpp
index ffd2db0fd5..84e0f99aa5 100644
--- a/modules/base/rendering/renderableplanet.cpp
+++ b/modules/base/rendering/renderableplanet.cpp
@@ -123,9 +123,9 @@ RenderablePlanet::~RenderablePlanet() {
 
 bool RenderablePlanet::initialize() {
     if (_programObject == nullptr && _hasNightTexture)
-		OsEng.ref().configurationManager()->getValue("nightTextureProgram", _programObject);
+		OsEng.ref().configurationManager().getValue("nightTextureProgram", _programObject);
 	else if (_programObject == nullptr)
-		OsEng.ref().configurationManager()->getValue("pscShader", _programObject);
+		OsEng.ref().configurationManager().getValue("pscShader", _programObject);
 
     loadTexture();
     _geometry->initialize(this);
diff --git a/modules/base/rendering/renderablesphericalgrid.cpp b/modules/base/rendering/renderablesphericalgrid.cpp
index 24a26d912e..41a4228589 100644
--- a/modules/base/rendering/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/renderablesphericalgrid.cpp
@@ -166,7 +166,7 @@ bool RenderableSphericalGrid::deinitialize(){
 bool RenderableSphericalGrid::initialize(){
 	bool completeSuccess = true;
 	if (_gridProgram == nullptr)
-		completeSuccess &= OsEng.ref().configurationManager()->getValue("GridProgram", _gridProgram);
+		completeSuccess &= OsEng.ref().configurationManager().getValue("GridProgram", _gridProgram);
 
 	// Initialize and upload to graphics card
 	glGenVertexArrays(1, &_vaoID);
diff --git a/modules/newhorizons/rendering/renderableplaneprojection.cpp b/modules/newhorizons/rendering/renderableplaneprojection.cpp
index d4cc1ad2c9..6c8cc6e0b2 100644
--- a/modules/newhorizons/rendering/renderableplaneprojection.cpp
+++ b/modules/newhorizons/rendering/renderableplaneprojection.cpp
@@ -259,8 +259,8 @@ void RenderablePlaneProjection::updatePlane(const Image img, double currentTime)
 	}
 
 	if (!_moving) {
-		SceneGraphNode* thisNode = OsEng.renderEngine()->scene()->sceneGraphNode(_name);
-		SceneGraphNode* newParent = OsEng.renderEngine()->scene()->sceneGraphNode(_target.node);
+		SceneGraphNode* thisNode = OsEng.renderEngine().scene()->sceneGraphNode(_name);
+		SceneGraphNode* newParent = OsEng.renderEngine().scene()->sceneGraphNode(_target.node);
 		if (thisNode != nullptr && newParent != nullptr)
 			thisNode->setParent(newParent);
 	}
@@ -294,7 +294,7 @@ void RenderablePlaneProjection::setTarget(std::string body) {
 	if (body == "")
 		return;
 
-	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine()->scene()->allSceneGraphNodes();
+	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
 	Renderable* possibleTarget;
 	bool hasBody, found = false;
 	std::string targetBody;
@@ -321,7 +321,7 @@ std::string RenderablePlaneProjection::findClosestTarget(double currentTime) {
 
 	std::vector<std::string> targets;
 
-	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine()->scene()->allSceneGraphNodes();
+	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
 	Renderable* possibleTarget;
 	std::string targetBody;
 	bool hasBody, found = false;
diff --git a/modules/newhorizons/util/sequenceparser.cpp b/modules/newhorizons/util/sequenceparser.cpp
index 1a8d2d8554..fa4c7f0ea7 100644
--- a/modules/newhorizons/util/sequenceparser.cpp
+++ b/modules/newhorizons/util/sequenceparser.cpp
@@ -77,7 +77,7 @@ void writeToBuffer<std::string>(std::vector<char>& buffer, size_t& currentWriteL
 
 void SequenceParser::sendPlaybookInformation(const std::string& name) {
     std::string fullName = PlaybookIdentifierName + "_" + name;
-    _messageIdentifier = OsEng.networkEngine()->identifier(fullName);
+    _messageIdentifier = OsEng.networkEngine().identifier(fullName);
 
     std::vector<char> buffer(1024);
     size_t currentWriteLocation = 0;
@@ -165,7 +165,7 @@ void SequenceParser::sendPlaybookInformation(const std::string& name) {
     buffer.resize(currentWriteLocation);
 
     //OsEng.networkEngine()->publishMessage(PlaybookIdentifier, buffer);
-    OsEng.networkEngine()->setInitialConnectionMessage(_messageIdentifier, buffer);
+    OsEng.networkEngine().setInitialConnectionMessage(_messageIdentifier, buffer);
 }
 
 }
\ No newline at end of file
diff --git a/modules/onscreengui/src/gui.cpp b/modules/onscreengui/src/gui.cpp
index 0caa5a48bc..9abed3ed75 100644
--- a/modules/onscreengui/src/gui.cpp
+++ b/modules/onscreengui/src/gui.cpp
@@ -384,11 +384,11 @@ void GUI::renderMainWindow() {
     bool toJupiter = ImGui::Button("Coordinate System to Jupiter");
 
     if (toSun)
-        OsEng.scriptEngine()->queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Sun');");
+        OsEng.scriptEngine().queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Sun');");
     if (toPluto)
-        OsEng.scriptEngine()->queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Pluto');");
+        OsEng.scriptEngine().queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Pluto');");
     if (toJupiter)
-        OsEng.scriptEngine()->queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Jupiter');");
+        OsEng.scriptEngine().queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', 'Jupiter');");
 
 	ImGui::Checkbox("Help", &_help._isEnabled);
 
@@ -536,7 +536,7 @@ int show(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui()->setEnabled(true);
+	OsEng.gui().setEnabled(true);
 	return 0;
 }
 
@@ -550,7 +550,7 @@ int hide(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui()->setEnabled(false);
+	OsEng.gui().setEnabled(false);
 	return 0;
 }
 
@@ -564,7 +564,7 @@ int toggle(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui()->setEnabled(!OsEng.gui()->isEnabled());
+	OsEng.gui().setEnabled(!OsEng.gui().isEnabled());
 	return 0;
 }
 
diff --git a/modules/onscreengui/src/guiorigincomponent.cpp b/modules/onscreengui/src/guiorigincomponent.cpp
index e07a1c9aee..34abe5940c 100644
--- a/modules/onscreengui/src/guiorigincomponent.cpp
+++ b/modules/onscreengui/src/guiorigincomponent.cpp
@@ -39,9 +39,9 @@ namespace openspace {
 namespace gui {
 
 void GuiOriginComponent::render() {
-    const SceneGraphNode* currentFocus = OsEng.interactionHandler()->focusNode();
+    const SceneGraphNode* currentFocus = OsEng.interactionHandler().focusNode();
 
-    std::vector<SceneGraphNode*> nodes = OsEng.renderEngine()->scene()->allSceneGraphNodes();
+    std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
     std::sort(nodes.begin(), nodes.end(), [](SceneGraphNode* lhs, SceneGraphNode* rhs) { return lhs->name() < rhs->name(); });
     auto it = std::find(nodes.begin(), nodes.end(), currentFocus);
     ghoul_assert(it != nodes.end(), "Focus node not found");
@@ -57,7 +57,7 @@ void GuiOriginComponent::render() {
 
     if (result) {
         LINFO("openspace.setPropertyValue('Interaction.origin', '" + nodes[position]->name() + "');");
-        OsEng.scriptEngine()->queueScript("openspace.setPropertyValue('Interaction.origin', '" + nodes[position]->name() + "');");
+        OsEng.scriptEngine().queueScript("openspace.setPropertyValue('Interaction.origin', '" + nodes[position]->name() + "');");
     }
 
 }
diff --git a/modules/onscreengui/src/guiperformancecomponent.cpp b/modules/onscreengui/src/guiperformancecomponent.cpp
index 0d6e07558b..f76967314b 100644
--- a/modules/onscreengui/src/guiperformancecomponent.cpp
+++ b/modules/onscreengui/src/guiperformancecomponent.cpp
@@ -76,7 +76,7 @@ void GuiPerformanceComponent::render() {
 	};
 
 	ImGui::Begin("Performance", &_isEnabled);
-	if (OsEng.renderEngine()->doesPerformanceMeasurements() &&
+	if (OsEng.renderEngine().doesPerformanceMeasurements() &&
 			ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
 	{
 		ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
diff --git a/modules/onscreengui/src/guipropertycomponent.cpp b/modules/onscreengui/src/guipropertycomponent.cpp
index 15b3977e2b..9f44f84138 100644
--- a/modules/onscreengui/src/guipropertycomponent.cpp
+++ b/modules/onscreengui/src/guipropertycomponent.cpp
@@ -48,7 +48,7 @@ namespace {
     void executeScript(const std::string& id, const std::string& value) {
         std::string script =
             "openspace.setPropertyValue('" + id + "', " + value + ");";
-        OsEng.scriptEngine()->queueScript(script);
+        OsEng.scriptEngine().queueScript(script);
     }
 
     void renderBoolProperty(Property* prop, const std::string& ownerName) {
@@ -432,17 +432,17 @@ void GuiPropertyComponent::render() {
 	ImGui::Begin("Properties", &_isEnabled, size, 0.5f);
 
     if (ImGui::CollapsingHeader("OnScreen GUI")) {
-        glm::vec2& pos = OsEng.renderEngine()->_onScreenInformation._position;
+        glm::vec2& pos = OsEng.renderEngine()._onScreenInformation._position;
         Vec2Property::ValueType value = pos;
         ImGui::SliderFloat2("Position", &value.x, -1.f, 1.f);
         pos = value;
      
-        unsigned int& size = OsEng.renderEngine()->_onScreenInformation._size;
+        unsigned int& size = OsEng.renderEngine()._onScreenInformation._size;
         int sizeValue = static_cast<int>(size);
         ImGui::SliderInt("Size", &sizeValue, 0, 36);
         size = static_cast<unsigned int>(sizeValue);
 
-        int& node = OsEng.renderEngine()->_onScreenInformation._node;
+        int& node = OsEng.renderEngine()._onScreenInformation._node;
         int iValue = node;
         ImGui::SliderInt("Node#", &iValue, 0, 30);
         node = iValue;
diff --git a/modules/onscreengui/src/guitimecomponent.cpp b/modules/onscreengui/src/guitimecomponent.cpp
index 85c0d90d1c..959d0a7a11 100644
--- a/modules/onscreengui/src/guitimecomponent.cpp
+++ b/modules/onscreengui/src/guitimecomponent.cpp
@@ -42,7 +42,7 @@ void GuiTimeComponent::render() {
     
     bool changed = ImGui::SliderFloat("Delta Time", &deltaTime, -100.f, 100.f);
     if (changed)
-        OsEng.scriptEngine()->queueScript("openspace.time.setDeltaTime(" + std::to_string(deltaTime) + ")");
+        OsEng.scriptEngine().queueScript("openspace.time.setDeltaTime(" + std::to_string(deltaTime) + ")");
 
 
     //char dateBuffer[512] = {};
diff --git a/modules/volume/rendering/renderablevolumegl.cpp b/modules/volume/rendering/renderablevolumegl.cpp
index b738995cab..2ff94ce6d7 100644
--- a/modules/volume/rendering/renderablevolumegl.cpp
+++ b/modules/volume/rendering/renderablevolumegl.cpp
@@ -177,13 +177,13 @@ bool RenderableVolumeGL::initialize() {
     if(_filename != "") {
         _volume = loadVolume(_filename, _hintsDictionary);
         _volume->uploadTexture();
-        OsEng.renderEngine()->aBuffer()->addVolume(_volumeName, _volume);
+        OsEng.renderEngine().aBuffer()->addVolume(_volumeName, _volume);
     }
 
     if(_transferFunctionPath != "") {
         _transferFunction = loadTransferFunction(_transferFunctionPath);
         _transferFunction->uploadTexture();
-        OsEng.renderEngine()->aBuffer()->addTransferFunction(_transferFunctionName, _transferFunction);
+        OsEng.renderEngine().aBuffer()->addTransferFunction(_transferFunctionName, _transferFunction);
 
         auto textureCallback = [this](const ghoul::filesystem::File& file) {
             _updateTransferfunction = true;
@@ -192,9 +192,9 @@ bool RenderableVolumeGL::initialize() {
     }
 
     // add the sampler and get the ID
-    _id = OsEng.renderEngine()->aBuffer()->addSamplerfile(_samplerFilename);
+    _id = OsEng.renderEngine().aBuffer()->addSamplerfile(_samplerFilename);
 
-    OsEng.configurationManager()->getValue("RaycastProgram", _boxProgram);
+    OsEng.configurationManager().getValue("RaycastProgram", _boxProgram);
 
     // ============================
     //      GEOMETRY (box)
diff --git a/src/abuffer/abuffer.cpp b/src/abuffer/abuffer.cpp
index 7f7b5396af..8a48854b1e 100644
--- a/src/abuffer/abuffer.cpp
+++ b/src/abuffer/abuffer.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/abuffer/abuffer.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/file.h>
diff --git a/src/engine/logfactory.cpp b/src/engine/logfactory.cpp
index 6e668993de..c318e74ac8 100644
--- a/src/engine/logfactory.cpp
+++ b/src/engine/logfactory.cpp
@@ -24,13 +24,13 @@
 
 #include <openspace/engine/logfactory.h>
 
+#include <ghoul/misc/dictionary.h>
+#include <ghoul/misc/exception.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/htmllog.h>
 #include <ghoul/logging/textlog.h>
-#include <ghoul/filesystem/filesystem.h>
 
 namespace {
-	const std::string _loggerCat = "LogFactory";
-
 	const std::string keyType = "Type";
 	const std::string keyFilename = "FileName";
 	const std::string keyAppend = "Append";
@@ -45,20 +45,21 @@ namespace {
 
 namespace openspace {
 
-std::unique_ptr<ghoul::logging::Log> LogFactory::createLog(const ghoul::Dictionary& dictionary) {
+std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictionary) {
 	std::string type;
 	bool typeSuccess = dictionary.getValue(keyType, type);
 	if (!typeSuccess) {
-		LERROR("Requested log did not contain a key '" << keyType << "'");
-		return nullptr;
+        throw ghoul::RuntimeError(
+            "Requested log did not contain key '" + keyType + "'", "LogFactory"
+        );
 	}
 
 	std::string filename;
 	bool filenameSuccess = dictionary.getValue(keyFilename, filename);
 	if (!filenameSuccess) {
-		LERROR("Requested log of type '" << keyType << "' did not contain a key '"
-			<< keyFilename << "'");
-		return nullptr;
+        throw ghoul::RuntimeError(
+            "Requested log did not contain key '" + keyFilename + "'", "LogFactory"
+        );
 	}
 	filename = absPath(filename);
 
@@ -84,9 +85,10 @@ std::unique_ptr<ghoul::logging::Log> LogFactory::createLog(const ghoul::Dictiona
         );
 	}
 	else {
-		LERROR("Log with type '" << type << "' did not name a valid log");
-		return nullptr;
+        throw ghoul::RuntimeError(
+            "Log with type '" + type + "' did not name a valid log", "LogFactory"
+        );
 	}
 }
-
+    
 } // namespace openspace
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index 3d445a13ff..b6e0e49533 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -24,12 +24,13 @@
 
 #include <openspace/engine/openspaceengine.h>
 
-#include <ghoul/opengl/ghoul_gl.h>
-
 #include <openspace/version.h>
 
 #include <openspace/engine/configurationmanager.h>
+#include <openspace/engine/downloadmanager.h>
 #include <openspace/engine/logfactory.h>
+#include <openspace/engine/moduleengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/interaction/interactionhandler.h>
 #include <openspace/interaction/keyboardcontroller.h>
 #include <openspace/interaction/luaconsole.h>
@@ -39,28 +40,24 @@
 #include <openspace/rendering/renderengine.h>
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/scene/scene.h>
+#include <openspace/util/constants.h>
+#include <openspace/util/factorymanager.h>
 #include <openspace/util/time.h>
 #include <openspace/util/spicemanager.h>
-#include <openspace/util/factorymanager.h>
-#include <openspace/util/constants.h>
-#include <openspace/util/spicemanager.h>
 #include <openspace/util/syncbuffer.h>
-#include <openspace/engine/moduleengine.h>
-#include <openspace/engine/downloadmanager.h>
 
 #include <ghoul/ghoul.h>
 #include <ghoul/cmdparser/commandlineparser.h>
 #include <ghoul/cmdparser/singlecommand.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/cachemanager.h>
+#include <ghoul/font/fontmanager.h>
+#include <ghoul/font/fontrenderer.h>
 #include <ghoul/logging/consolelog.h>
 #include <ghoul/lua/ghoul_lua.h>
 #include <ghoul/lua/lua_helper.h>
 #include <ghoul/systemcapabilities/systemcapabilities>
-#include <ghoul/font/fontrenderer.h>
 
-#include <iostream>
-#include <memory>
 #include <fstream>
 
 #ifdef OPENSPACE_MODULE_ONSCREENGUI_ENABLED
@@ -100,7 +97,8 @@ namespace openspace {
 
 OpenSpaceEngine* OpenSpaceEngine::_engine = nullptr;
 
-OpenSpaceEngine::OpenSpaceEngine(std::string programName, WindowWrapper* windowWrapper)
+OpenSpaceEngine::OpenSpaceEngine(std::string programName,
+                                 std::unique_ptr<WindowWrapper> windowWrapper)
     : _configurationManager(new ConfigurationManager)
     , _interactionHandler(new interaction::InteractionHandler)
     , _renderEngine(new RenderEngine)
@@ -111,14 +109,14 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName, WindowWrapper* windowW
     , _moduleEngine(new ModuleEngine)
     , _gui(new gui::GUI)
     , _parallelConnection(new network::ParallelConnection)
-    , _windowWrapper(windowWrapper)
+    , _windowWrapper(std::move(windowWrapper))
     , _globalPropertyNamespace(new properties::PropertyOwner)
 	, _isMaster(false)
     , _runTime(0.0)
-    , _syncBuffer(nullptr)
+    , _syncBuffer(new SyncBuffer(1024))
 {
-    _interactionHandler->setPropertyOwner(_globalPropertyNamespace);
-    _globalPropertyNamespace->addPropertySubOwner(_interactionHandler);
+    _interactionHandler->setPropertyOwner(_globalPropertyNamespace.get());
+    _globalPropertyNamespace->addPropertySubOwner(_interactionHandler.get());
     FactoryManager::initialize();
     SpiceManager::initialize();
     Time::initialize();
@@ -128,43 +126,18 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName, WindowWrapper* windowW
 OpenSpaceEngine::~OpenSpaceEngine() {
     _gui->deinitializeGL();
 
-    delete _globalPropertyNamespace;
     _globalPropertyNamespace = nullptr;
-
-    delete _windowWrapper;
     _windowWrapper = nullptr;
-
-	delete _parallelConnection;
     _parallelConnection = nullptr;
-
-    delete _configurationManager;
     _configurationManager = nullptr;
-
-    delete _interactionHandler;
     _interactionHandler = nullptr;
-
-    delete _renderEngine;
     _renderEngine = nullptr;
-
-    delete _scriptEngine;
     _scriptEngine = nullptr;
-
-    delete _networkEngine;
     _networkEngine = nullptr;
-
-    delete _commandlineParser;
     _commandlineParser = nullptr;
-
-    delete _console;
     _console = nullptr;
-
-    delete _moduleEngine;
     _moduleEngine = nullptr;
-
-    delete _gui;
     _gui = nullptr;
-
-	delete _syncBuffer;
 	_syncBuffer = nullptr;
 }
 
@@ -173,15 +146,14 @@ OpenSpaceEngine& OpenSpaceEngine::ref() {
     return *_engine;
 }
 
-bool OpenSpaceEngine::create(
-    int argc, char** argv,
-    WindowWrapper* windowWrapper,
-    std::vector<std::string>& sgctArguments)
+bool OpenSpaceEngine::create(int argc, char** argv,
+                             std::unique_ptr<WindowWrapper> windowWrapper,
+                             std::vector<std::string>& sgctArguments)
 {
-    ghoul::initialize();
-
     ghoul_assert(!_engine, "OpenSpaceEngine was already created");
     ghoul_assert(windowWrapper != nullptr, "No Window Wrapper was provided");
+    
+    ghoul::initialize();
 
 	// Initialize the LogManager and add the console log as this will be used every time
 	// and we need a fall back if something goes wrong between here and when we add the
@@ -208,7 +180,7 @@ bool OpenSpaceEngine::create(
 
 	// Create other objects
 	LDEBUG("Creating OpenSpaceEngine");
-	_engine = new OpenSpaceEngine(std::string(argv[0]), windowWrapper);
+    _engine = new OpenSpaceEngine(std::string(argv[0]), std::move(windowWrapper));
 
 	// Query modules for commandline arguments
 	bool gatherSuccess = _engine->gatherCommandlineArguments();
@@ -239,7 +211,7 @@ bool OpenSpaceEngine::create(
 
 	// Loading configuration from disk
 	LDEBUG("Loading configuration from disk");
-	const bool configLoadSuccess = _engine->configurationManager()->loadFromFile(
+	const bool configLoadSuccess = _engine->configurationManager().loadFromFile(
 																configurationFilePath);
 	if (!configLoadSuccess) {
 		LFATAL("Loading of configuration file '" << configurationFilePath << "' failed");
@@ -268,18 +240,18 @@ bool OpenSpaceEngine::create(
     _engine->_moduleEngine->create();
 
 	// Create the cachemanager
-	FileSys.createCacheManager(absPath("${" + ConfigurationManager::KeyCache + "}"), CacheVersion);
+	FileSys.createCacheManager(
+        absPath("${" + ConfigurationManager::KeyCache + "}"), CacheVersion
+    );
 	_engine->_console->initialize();
 
 	// Register the provided shader directories
 	ghoul::opengl::ShaderPreprocessor::addIncludePath(absPath("${SHADERS}"));
 
-	_engine->_syncBuffer = new SyncBuffer(1024);
-
 	// Determining SGCT configuration file
 	LDEBUG("Determining SGCT configuration file");
 	std::string sgctConfigurationPath = _sgctDefaultConfigFile;
-	_engine->configurationManager()->getValue(
+	_engine->configurationManager().getValue(
 		ConfigurationManager::KeyConfigSgct, sgctConfigurationPath);
 
 	if (!commandlineArgumentPlaceholders.sgctConfigurationName.empty()) {
@@ -331,21 +303,21 @@ bool OpenSpaceEngine::initialize() {
 
     using Verbosity = ghoul::systemcapabilities::SystemCapabilitiesComponent::Verbosity;
     Verbosity verbosity = Verbosity::Default;
-    if (configurationManager()->hasKeyAndValue<std::string>(ConfigurationManager::KeyCapabilitiesVerbosity)) {
+    if (configurationManager().hasKeyAndValue<std::string>(ConfigurationManager::KeyCapabilitiesVerbosity)) {
         std::map<std::string, Verbosity> verbosityMap = {
             { "Minimal", Verbosity::Minimal },
             { "Default", Verbosity::Default },
             { "Full", Verbosity::Full }
         };
 
-        std::string v = configurationManager()->value<std::string>(ConfigurationManager::KeyCapabilitiesVerbosity);
+        std::string v = configurationManager().value<std::string>(ConfigurationManager::KeyCapabilitiesVerbosity);
         if (verbosityMap.find(v) != verbosityMap.end())
             verbosity = verbosityMap[v];
     }
 	SysCap.logCapabilities(verbosity);
     
     std::string requestURL = "";
-    bool success = configurationManager()->getValue(ConfigurationManager::KeyDownloadRequestURL, requestURL);
+    bool success = configurationManager().getValue(ConfigurationManager::KeyDownloadRequestURL, requestURL);
     if (success)
         DownloadManager::initialize(requestURL, DownloadVersion);
 
@@ -365,23 +337,23 @@ bool OpenSpaceEngine::initialize() {
     _scriptEngine->addLibrary(network::ParallelConnection::luaLibrary());
 
 	// TODO: Maybe move all scenegraph and renderengine stuff to initializeGL
-	scriptEngine()->initialize();
+	scriptEngine().initialize();
 
 	// If a LuaDocumentationFile was specified, generate it now
-	const bool hasType = configurationManager()->hasKey(ConfigurationManager::KeyLuaDocumentationType);
-	const bool hasFile = configurationManager()->hasKey(ConfigurationManager::KeyLuaDocumentationFile);
+	const bool hasType = configurationManager().hasKey(ConfigurationManager::KeyLuaDocumentationType);
+	const bool hasFile = configurationManager().hasKey(ConfigurationManager::KeyLuaDocumentationFile);
 	if (hasType && hasFile) {
 		std::string luaDocumentationType;
-		configurationManager()->getValue(ConfigurationManager::KeyLuaDocumentationType, luaDocumentationType);
+		configurationManager().getValue(ConfigurationManager::KeyLuaDocumentationType, luaDocumentationType);
 		std::string luaDocumentationFile;
-		configurationManager()->getValue(ConfigurationManager::KeyLuaDocumentationFile, luaDocumentationFile);
+		configurationManager().getValue(ConfigurationManager::KeyLuaDocumentationFile, luaDocumentationFile);
 
 		luaDocumentationFile = absPath(luaDocumentationFile);
 		_scriptEngine->writeDocumentation(luaDocumentationFile, luaDocumentationType);
 	}
 
     bool disableMasterRendering = false;
-    configurationManager()->getValue(
+    configurationManager().getValue(
         ConfigurationManager::KeyDisableMasterRendering, disableMasterRendering);
     _renderEngine->setDisableRenderingOnMaster(disableMasterRendering);
 
@@ -396,7 +368,7 @@ bool OpenSpaceEngine::initialize() {
 
     std::string sceneDescriptionPath = "";
     if (commandlineArgumentPlaceholders.sceneName.empty()) {
-	    success = configurationManager()->getValue(
+	    success = configurationManager().getValue(
 		    ConfigurationManager::KeyConfigScene, sceneDescriptionPath);
     }
     else
@@ -410,8 +382,7 @@ bool OpenSpaceEngine::initialize() {
 	runStartupScripts();
 
 	// Load a light and a monospaced font
-	loadFonts();
-    loadFonts2();
+    loadFonts();
 
     LINFO("Initializing GUI");
 	_gui->initialize();
@@ -483,7 +454,7 @@ bool OpenSpaceEngine::findConfiguration(std::string& filename) {
 bool OpenSpaceEngine::loadSpiceKernels() {
 	// Load time kernel
 	std::string timeKernel;
-	bool success = configurationManager()->getValue(ConfigurationManager::KeySpiceTimeKernel, timeKernel);
+	bool success = configurationManager().getValue(ConfigurationManager::KeySpiceTimeKernel, timeKernel);
     // Move this to configurationmanager::completenesscheck ---abock
 	if (!success) {
 		LERROR("Configuration file does not contain a '" << ConfigurationManager::KeySpiceTimeKernel << "'");
@@ -494,7 +465,7 @@ bool OpenSpaceEngine::loadSpiceKernels() {
 
 	// Load SPICE leap second kernel
 	std::string leapSecondKernel;
-	success = configurationManager()->getValue(ConfigurationManager::KeySpiceLeapsecondKernel, leapSecondKernel);
+	success = configurationManager().getValue(ConfigurationManager::KeySpiceLeapsecondKernel, leapSecondKernel);
 	if (!success) {
         // Move this to configurationmanager::completenesscheck ---abock
 		LERROR("Configuration file does not have a '" << ConfigurationManager::KeySpiceLeapsecondKernel << "'");
@@ -519,7 +490,7 @@ void OpenSpaceEngine::runScripts(const ghoul::Dictionary& scripts) {
         std::string scriptPath;
         scripts.getValue(key, scriptPath);
         std::string&& absoluteScriptPath = absPath(scriptPath);
-        _engine->scriptEngine()->runScriptFile(absoluteScriptPath);
+        _engine->scriptEngine().runScriptFile(absoluteScriptPath);
         
         //@JK
         //temporary solution to ensure that startup scripts may be syncrhonized over parallel connection
@@ -531,9 +502,9 @@ void OpenSpaceEngine::runScripts(const ghoul::Dictionary& scripts) {
             //valid line and not a comment
             if(line.size() > 0 && line.at(0) != '-'){
                 std::string lib, func;
-                if(_engine->scriptEngine()->parseLibraryAndFunctionNames(lib, func, line) &&
-                   _engine->scriptEngine()->shouldScriptBeSent(lib, func)){
-                    _engine->scriptEngine()->cacheScript(lib, func, line);
+                if(_engine->scriptEngine().parseLibraryAndFunctionNames(lib, func, line) &&
+                   _engine->scriptEngine().shouldScriptBeSent(lib, func)){
+                    _engine->scriptEngine().cacheScript(lib, func, line);
                 }
             }
         }
@@ -543,51 +514,31 @@ void OpenSpaceEngine::runScripts(const ghoul::Dictionary& scripts) {
 
 void OpenSpaceEngine::runStartupScripts() {
 	ghoul::Dictionary scripts;
-	configurationManager()->getValue(
+	configurationManager().getValue(
 		ConfigurationManager::KeyStartupScript, scripts);
     runScripts(scripts);
 }
 
 void OpenSpaceEngine::runSettingsScripts() {
     ghoul::Dictionary scripts;
-    configurationManager()->getValue(
+    configurationManager().getValue(
         ConfigurationManager::KeySettingsScript, scripts);
     runScripts(scripts);
 }
 
 void OpenSpaceEngine::loadFonts() {
-	sgct_text::FontManager::FontPath local = sgct_text::FontManager::FontPath::FontPath_Local;
-
-	ghoul::Dictionary fonts;
-	configurationManager()->getValue(ConfigurationManager::KeyFonts, fonts);
-
-	for (const std::string& key : fonts.keys()) {
-		std::string font;
-		fonts.getValue(key, font);
-		font = absPath(font);
-        if(!FileSys.fileExists(font)) {
-            LERROR("Could not find font '" << font << "'");
-            continue;
-        }
-
-		LINFO("Registering font '" << font << "' with key '" << key << "'");
-		sgct_text::FontManager::instance()->addFont(key, font, local);
-	}
-}
-
-void OpenSpaceEngine::loadFonts2() {
     ghoul::Dictionary fonts;
-    configurationManager()->getValue(ConfigurationManager::KeyFonts, fonts);
+    configurationManager().getValue(ConfigurationManager::KeyFonts, fonts);
 
     const glm::ivec3 fontAtlasSize{1024, 1024, 1};
-    _fontManager = new ghoul::fontrendering::FontManager(fontAtlasSize);
+    _fontManager = std::make_unique<ghoul::fontrendering::FontManager>(fontAtlasSize);
     
     for (const std::string& key : fonts.keys()) {
         std::string font;
         fonts.getValue(key, font);
         font = absPath(font);
         
-        if(!FileSys.fileExists(font)) {
+        if (!FileSys.fileExists(font)) {
             LERROR("Could not find font '" << font << "'");
             continue;
         }
@@ -608,12 +559,12 @@ void OpenSpaceEngine::loadFonts2() {
 }
     
 void OpenSpaceEngine::configureLogging() {
-	if (configurationManager()->hasKeyAndValue<std::string>(ConfigurationManager::KeyLogLevel)) {
+	if (configurationManager().hasKeyAndValue<std::string>(ConfigurationManager::KeyLogLevel)) {
 		std::string logLevel;
-		configurationManager()->getValue(ConfigurationManager::KeyLogLevel, logLevel);
+		configurationManager().getValue(ConfigurationManager::KeyLogLevel, logLevel);
 
 		bool immediateFlush = false;
-		configurationManager()->getValue(ConfigurationManager::KeyLogImmediateFlush, immediateFlush);
+		configurationManager().getValue(ConfigurationManager::KeyLogImmediateFlush, immediateFlush);
 
 		LogManager::LogLevel level = LogManager::levelFromString(logLevel);
 		LogManager::deinitialize();
@@ -621,52 +572,24 @@ void OpenSpaceEngine::configureLogging() {
 		LogMgr.addLog(std::make_unique<ConsoleLog>());
 	}
 
-	if (configurationManager()->hasKeyAndValue<ghoul::Dictionary>(ConfigurationManager::KeyLogs)) {
+	if (configurationManager().hasKeyAndValue<ghoul::Dictionary>(ConfigurationManager::KeyLogs)) {
 		ghoul::Dictionary logs;
-		configurationManager()->getValue(ConfigurationManager::KeyLogs, logs);
+		configurationManager().getValue(ConfigurationManager::KeyLogs, logs);
 
 		for (size_t i = 1; i <= logs.size(); ++i) {
 			ghoul::Dictionary logInfo;
 			logs.getValue(std::to_string(i), logInfo);
 
-            std::unique_ptr<Log> log = LogFactory::createLog(logInfo);
-
-			if (log)
-                LogMgr.addLog(std::move(log));
+            try {
+                LogMgr.addLog(createLog(logInfo));
+            }
+            catch (const ghoul::RuntimeError& e) {
+                LERRORC(e.component, e.message);
+            }
 		}
 	}
 }
 
-ConfigurationManager* OpenSpaceEngine::configurationManager() {
-    ghoul_assert(_configurationManager != nullptr, "ConfigurationManager is nullptr");
-    return _configurationManager;
-}
-
-interaction::InteractionHandler* OpenSpaceEngine::interactionHandler() {
-    ghoul_assert(_interactionHandler != nullptr, "InteractionHandler is nullptr");
-    return _interactionHandler;
-}
-
-RenderEngine* OpenSpaceEngine::renderEngine() {
-    ghoul_assert(_renderEngine != nullptr, "RenderEngine is nullptr");
-    return _renderEngine;
-}
-
-ScriptEngine* OpenSpaceEngine::scriptEngine() {
-    ghoul_assert(_scriptEngine != nullptr, "ScriptEngine is nullptr");
-    return _scriptEngine;
-}
-
-LuaConsole* OpenSpaceEngine::console() {
-    ghoul_assert(_console != nullptr, "LuaConsole is nullptr");
-	return _console;
-}
-
-gui::GUI* OpenSpaceEngine::gui() {
-    ghoul_assert(_gui != nullptr, "GUI is nullptr");
-	return _gui;
-}
-
 bool OpenSpaceEngine::initializeGL() {
     LINFO("Initializing Rendering Engine");
     bool success = _renderEngine->initializeGL();
@@ -701,11 +624,8 @@ void OpenSpaceEngine::preSynchronization() {
 		Time::ref().preSynchronization();
 		
         _interactionHandler->update(dt);
-
-		_scriptEngine->preSynchronization();			
-		
+		_scriptEngine->preSynchronization();
         _renderEngine->preSynchronization();
-        
         _parallelConnection->preSynchronization();
     }
 }
@@ -765,7 +685,7 @@ void OpenSpaceEngine::keyboardCallback(Key key, KeyModifier mod, KeyAction actio
 void OpenSpaceEngine::charCallback(unsigned int codepoint, KeyModifier modifier) {
 	if (_isMaster) {
 		if (_gui->isEnabled()) {
-			bool isConsumed = _gui->charCallback(codepoint, modifier);
+			const bool isConsumed = _gui->charCallback(codepoint, modifier);
 			if (isConsumed)
 				return;
 		}
@@ -779,7 +699,7 @@ void OpenSpaceEngine::charCallback(unsigned int codepoint, KeyModifier modifier)
 void OpenSpaceEngine::mouseButtonCallback(MouseButton button, MouseAction action) {
 	if (_isMaster) {
 		if (_gui->isEnabled()) {
-			bool isConsumed = _gui->mouseButtonCallback(button, action);
+			const bool isConsumed = _gui->mouseButtonCallback(button, action);
             if (isConsumed && action != MouseAction::Release)
 				return;
 		}
@@ -797,7 +717,7 @@ void OpenSpaceEngine::mousePositionCallback(double x, double y) {
 void OpenSpaceEngine::mouseScrollWheelCallback(double pos) {
 	if (_isMaster) {
 		if (_gui->isEnabled()) {
-			bool isConsumed = _gui->mouseWheelCallback(pos);
+			const bool isConsumed = _gui->mouseWheelCallback(pos);
 			if (isConsumed)
 				return;
 		}
@@ -808,9 +728,9 @@ void OpenSpaceEngine::mouseScrollWheelCallback(double pos) {
 
 void OpenSpaceEngine::encode() {
 	if (_syncBuffer) {
-		Time::ref().serialize(_syncBuffer);
-		_scriptEngine->serialize(_syncBuffer);
-		_renderEngine->serialize(_syncBuffer);		
+		Time::ref().serialize(_syncBuffer.get());
+		_scriptEngine->serialize(_syncBuffer.get());
+		_renderEngine->serialize(_syncBuffer.get());
 		
 		_syncBuffer->write();
 	}
@@ -822,14 +742,14 @@ void OpenSpaceEngine::decode() {
 	if (_syncBuffer) {
 		_syncBuffer->read();
 
-		Time::ref().deserialize(_syncBuffer);
-		_scriptEngine->deserialize(_syncBuffer);
-		_renderEngine->deserialize(_syncBuffer);
+		Time::ref().deserialize(_syncBuffer.get());
+		_scriptEngine->deserialize(_syncBuffer.get());
+		_renderEngine->deserialize(_syncBuffer.get());
 	}
 }
 
-void OpenSpaceEngine::externalControlCallback(const char* receivedChars,
-                                              int size, int clientId)
+void OpenSpaceEngine::externalControlCallback(const char* receivedChars, int size,
+                                              int clientId)
 {
 	if (size == 0)
 		return;
@@ -845,31 +765,66 @@ void OpenSpaceEngine::disableBarrier() {
     _windowWrapper->setBarrier(false);
 }
 
-NetworkEngine* OpenSpaceEngine::networkEngine() {
-    return _networkEngine;
+NetworkEngine& OpenSpaceEngine::networkEngine() {
+    ghoul_assert(_networkEngine, "NetworkEngine must not be nullptr");
+    return *_networkEngine;
 }
 
-ModuleEngine* OpenSpaceEngine::moduleEngine() {
-    return _moduleEngine;
+ModuleEngine& OpenSpaceEngine::moduleEngine() {
+    ghoul_assert(_moduleEngine, "ModuleEngine must not be nullptr");
+    return *_moduleEngine;
+}
+
+ConfigurationManager& OpenSpaceEngine::configurationManager() {
+    ghoul_assert(_configurationManager, "ConfigurationManager must not be nullptr");
+    return *_configurationManager;
+}
+
+interaction::InteractionHandler& OpenSpaceEngine::interactionHandler() {
+    ghoul_assert(_interactionHandler, "InteractionHandler must not be nullptr");
+    return *_interactionHandler;
+}
+
+RenderEngine& OpenSpaceEngine::renderEngine() {
+    ghoul_assert(_renderEngine, "RenderEngine must not be nullptr");
+    return *_renderEngine;
+}
+
+ScriptEngine& OpenSpaceEngine::scriptEngine() {
+    ghoul_assert(_scriptEngine, "ScriptEngine must not be nullptr");
+    return *_scriptEngine;
+}
+
+LuaConsole& OpenSpaceEngine::console() {
+    ghoul_assert(_console, "LuaConsole must not be nullptr");
+    return *_console;
+}
+
+gui::GUI& OpenSpaceEngine::gui() {
+    ghoul_assert(_gui, "GUI must not be nullptr");
+    return *_gui;
+}
+
+network::ParallelConnection& OpenSpaceEngine::parallelConnection() {
+    ghoul_assert(_parallelConnection, "ParallelConnection must not be nullptr");
+    return *_parallelConnection;
 }
     
-network::ParallelConnection* OpenSpaceEngine::parallelConnection() {
-    ghoul_assert(_parallelConnection != nullptr, "ParallelConnection is nullptr");
-    return _parallelConnection;
-}
-    
-properties::PropertyOwner* OpenSpaceEngine::globalPropertyOwner() {
-    ghoul_assert(_globalPropertyNamespace, "Global Property Namespace");
-    return _globalPropertyNamespace;
+properties::PropertyOwner& OpenSpaceEngine::globalPropertyOwner() {
+    ghoul_assert(
+        _globalPropertyNamespace,
+        "Global Property Namespace must not be nullptr"
+    );
+    return *_globalPropertyNamespace;
 }
 
 WindowWrapper& OpenSpaceEngine::windowWrapper() {
-    ghoul_assert(_windowWrapper, "Window Wrapper");
+    ghoul_assert(_windowWrapper, "Window Wrapper must not be nullptr");
     return *_windowWrapper;
 }
     
 ghoul::fontrendering::FontManager& OpenSpaceEngine::fontManager() {
-    ghoul_assert(_fontManager, "Font Manager");
+    ghoul_assert(_fontManager, "Font Manager must not be nullptr");
     return *_fontManager;
 }
 
diff --git a/src/interaction/interactionhandler.cpp b/src/interaction/interactionhandler.cpp
index 2e8a5784f9..74f09ae4a1 100644
--- a/src/interaction/interactionhandler.cpp
+++ b/src/interaction/interactionhandler.cpp
@@ -139,7 +139,7 @@ InteractionHandler::InteractionHandler()
     addProperty(_origin);
     
     _coordinateSystem.onChange([this](){
-        OsEng.renderEngine()->changeViewPoint(_coordinateSystem.value());
+        OsEng.renderEngine().changeViewPoint(_coordinateSystem.value());
     });
     addProperty(_coordinateSystem);
 }
@@ -552,14 +552,14 @@ void InteractionHandler::keyboardCallback(Key key, KeyModifier modifier, KeyActi
 	        rotateDelta(rot);
 	    }
         if ((key == Key::KeypadSubtract) && (modifier == KeyModifier::NoModifier)) {
-			glm::vec2 s = OsEng.renderEngine()->camera()->scaling();
+			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
 			s[1] -= 0.5f;
-			OsEng.renderEngine()->camera()->setScaling(s);
+			OsEng.renderEngine().camera()->setScaling(s);
 		}
         if ((key == Key::KeypadAdd) && (modifier == KeyModifier::NoModifier)) {
-			glm::vec2 s = OsEng.renderEngine()->camera()->scaling();
+			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
 			s[1] += 0.5f;
-			OsEng.renderEngine()->camera()->setScaling(s);
+			OsEng.renderEngine().camera()->setScaling(s);
 		}
 
 		// iterate over key bindings
@@ -567,7 +567,7 @@ void InteractionHandler::keyboardCallback(Key key, KeyModifier modifier, KeyActi
 		auto ret = _keyLua.equal_range(key);
 		for (auto it = ret.first; it != ret.second; ++it) {
 			//OsEng.scriptEngine()->runScript(it->second);
-			OsEng.scriptEngine()->queueScript(it->second);
+			OsEng.scriptEngine().queueScript(it->second);
 			if (!_validKeyLua) {
 				break;
 			}
diff --git a/src/interaction/interactionhandler_lua.inl b/src/interaction/interactionhandler_lua.inl
index c735aefb61..3ec1b507df 100644
--- a/src/interaction/interactionhandler_lua.inl
+++ b/src/interaction/interactionhandler_lua.inl
@@ -51,7 +51,7 @@ int setOrigin(lua_State* L) {
 		return 0;
 	}
 
-	OsEng.interactionHandler()->setFocusNode(node);
+	OsEng.interactionHandler().setFocusNode(node);
 
 	return 0;
 }
@@ -84,7 +84,7 @@ int bindKey(lua_State* L) {
 	}
 
 
-	OsEng.interactionHandler()->bindKey(iKey, command);
+	OsEng.interactionHandler().bindKey(iKey, command);
 
 	return 0;
 }
@@ -102,7 +102,7 @@ int clearKeys(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.interactionHandler()->resetKeyBindings();
+	OsEng.interactionHandler().resetKeyBindings();
 
 	return 0;
 }
@@ -117,7 +117,7 @@ int dt(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	lua_pushnumber(L,OsEng.interactionHandler()->deltaTime());
+	lua_pushnumber(L,OsEng.interactionHandler().deltaTime());
 	return 1;
 }
 
@@ -134,7 +134,7 @@ int distance(lua_State* L) {
 	double d1 = luaL_checknumber(L, -2);
 	double d2 = luaL_checknumber(L, -1);
 	PowerScaledScalar dist(static_cast<float>(d1), static_cast<float>(d2));
-	OsEng.interactionHandler()->distanceDelta(dist);
+	OsEng.interactionHandler().distanceDelta(dist);
 	return 0;
 }
 
@@ -149,7 +149,7 @@ int setInteractionSensitivity(lua_State* L) {
         return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
 
     float sensitivity = static_cast<float>(luaL_checknumber(L, -1));
-    OsEng.interactionHandler()->setInteractionSensitivity(sensitivity);
+    OsEng.interactionHandler().setInteractionSensitivity(sensitivity);
     return 0;
 }
 
@@ -159,7 +159,7 @@ int setInteractionSensitivity(lua_State* L) {
  * Returns the current, global interaction sensitivity
  */
 int interactionSensitivity(lua_State* L) {
-    float sensitivity = OsEng.interactionHandler()->interactionSensitivity();
+    float sensitivity = OsEng.interactionHandler().interactionSensitivity();
     lua_pushnumber(L, sensitivity);
     return 1;
 }
@@ -175,7 +175,7 @@ int setInvertRoll(lua_State* L) {
         return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
 
     bool invert = lua_toboolean(L, -1) == 1;
-    OsEng.interactionHandler()->setInvertRoll(invert);
+    OsEng.interactionHandler().setInvertRoll(invert);
     return 0;
 }
 
@@ -185,7 +185,7 @@ int setInvertRoll(lua_State* L) {
  * Returns the current setting for inversion of roll movement
  */
 int invertRoll(lua_State* L) {
-    bool invert = OsEng.interactionHandler()->invertRoll();
+    bool invert = OsEng.interactionHandler().invertRoll();
     lua_pushboolean(L, invert);
     return 1;
 }
@@ -201,7 +201,7 @@ int setInvertRotation(lua_State* L) {
         return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
 
     bool invert = lua_toboolean(L, -1) == 1;
-    OsEng.interactionHandler()->setInvertRotation(invert);
+    OsEng.interactionHandler().setInvertRotation(invert);
     return 0;
 }
 
@@ -211,7 +211,7 @@ int setInvertRotation(lua_State* L) {
  * Returns the current setting for inversion of rotation movement
  */
 int invertRotation(lua_State* L) {
-    bool invert = OsEng.interactionHandler()->invertRotation();
+    bool invert = OsEng.interactionHandler().invertRotation();
     lua_pushboolean(L, invert);
     return 1;
 }
diff --git a/src/interaction/keyboardcontroller.cpp b/src/interaction/keyboardcontroller.cpp
index 10eecfa151..9328a88c95 100644
--- a/src/interaction/keyboardcontroller.cpp
+++ b/src/interaction/keyboardcontroller.cpp
@@ -117,14 +117,14 @@ void KeyboardControllerFixed::keyPressed(KeyAction action, Key key, KeyModifier
 		}
 	
 		if (key == Key::KeypadSubtract) {
-			glm::vec2 s = OsEng.renderEngine()->camera()->scaling();
+			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
 			s[1] -= 0.5;
-			OsEng.renderEngine()->camera()->setScaling(s);
+			OsEng.renderEngine().camera()->setScaling(s);
 		}
 		if (key == Key::KeypadAdd) {
-			glm::vec2 s = OsEng.renderEngine()->camera()->scaling();
+			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
 			s[1] += 0.5;
-			OsEng.renderEngine()->camera()->setScaling(s);
+			OsEng.renderEngine().camera()->setScaling(s);
 		}
 	}
 	/*
diff --git a/src/interaction/luaconsole.cpp b/src/interaction/luaconsole.cpp
index ab4eb35f14..38076ee860 100644
--- a/src/interaction/luaconsole.cpp
+++ b/src/interaction/luaconsole.cpp
@@ -171,7 +171,7 @@ void LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
 			else {
 				if (_commands.at(_activeCommand) != "") {
 					//OsEng.scriptEngine()->runScript(_commands.at(_activeCommand));
-					OsEng.scriptEngine()->queueScript(_commands.at(_activeCommand));
+					OsEng.scriptEngine().queueScript(_commands.at(_activeCommand));
 					if (!_commandsHistory.empty() &&
 						_commands.at(_activeCommand) != _commandsHistory.at(_commandsHistory.size() - 1))
 						_commandsHistory.push_back(_commands.at(_activeCommand));
@@ -197,7 +197,7 @@ void LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
             // find the value before the one that was previously found
             if (_autoCompleteInfo.lastIndex != NoAutoComplete && modifierShift)
                 _autoCompleteInfo.lastIndex -= 2;
-            std::vector<std::string> allCommands = OsEng.scriptEngine()->allLuaFunctions();
+            std::vector<std::string> allCommands = OsEng.scriptEngine().allLuaFunctions();
             std::sort(allCommands.begin(), allCommands.end());
 
             std::string currentCommand = _commands.at(_activeCommand);
diff --git a/src/interaction/luaconsole_lua.inl b/src/interaction/luaconsole_lua.inl
index 368855d411..2507bf4089 100644
--- a/src/interaction/luaconsole_lua.inl
+++ b/src/interaction/luaconsole_lua.inl
@@ -36,7 +36,7 @@ int show(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.console()->setVisible(true);
+	OsEng.console().setVisible(true);
 	return 0;
 }
 
@@ -50,7 +50,7 @@ int hide(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.console()->setVisible(false);
+	OsEng.console().setVisible(false);
 	return 0;
 }
 
@@ -64,7 +64,7 @@ int toggle(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.console()->toggleVisibility();
+	OsEng.console().toggleVisibility();
 	return 0;
 }
 
diff --git a/src/interaction/mousecontroller.cpp b/src/interaction/mousecontroller.cpp
index d465ae0d89..274fcb9b1f 100644
--- a/src/interaction/mousecontroller.cpp
+++ b/src/interaction/mousecontroller.cpp
@@ -25,6 +25,7 @@
 #include <openspace/interaction/mousecontroller.h>
 
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 
 #include <openspace/interaction/interactionhandler.h>
 
@@ -218,9 +219,9 @@ void OrbitalMouseController::scrollWheel(int pos) {
 }
 
 void OrbitalMouseController::update(const double& dt){
-    const float interactionSpeed = OsEng.interactionHandler()->interactionSensitivity();
-    const bool rotationInvert = OsEng.interactionHandler()->invertRotation();
-    const bool rollInvert = OsEng.interactionHandler()->invertRoll();
+    const float interactionSpeed = OsEng.interactionHandler().interactionSensitivity();
+    const bool rotationInvert = OsEng.interactionHandler().invertRotation();
+    const bool rollInvert = OsEng.interactionHandler().invertRoll();
 	
 	//if (_leftMouseButtonDown || _rightMouseButtonDown || _middleMouseButtonDown){
 		_handler->orbit(
diff --git a/src/network/networkengine.cpp b/src/network/networkengine.cpp
index 83265ec2be..24d089d0af 100644
--- a/src/network/networkengine.cpp
+++ b/src/network/networkengine.cpp
@@ -23,9 +23,9 @@
  ****************************************************************************************/
 
 #include <openspace/network/networkengine.h>
-
 #include <openspace/util/time.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 
 #include <array>
 #include <chrono>
@@ -67,7 +67,7 @@ bool NetworkEngine::handleMessage(const std::string& message) {
     {
         std::string script = message.substr(1);
         //LINFO("Received Lua Script: '" << script << "'");
-        OsEng.scriptEngine()->queueScript(script);
+        OsEng.scriptEngine().queueScript(script);
         return true;
     }
     case MessageTypeExternalControlConnected:
diff --git a/src/network/parallelconnection.cpp b/src/network/parallelconnection.cpp
index 9f24d40a95..e1157cf53d 100644
--- a/src/network/parallelconnection.cpp
+++ b/src/network/parallelconnection.cpp
@@ -470,7 +470,7 @@ void ParallelConnection::initializationMessageReceived(){
         script.assign(buffer.begin(), buffer.end());
                 
         //queue received script
-        OsEng.scriptEngine()->queueScript(script);
+        OsEng.scriptEngine().queueScript(script);
     }
             
     //we've gone through all scripts, initialization is done
@@ -540,7 +540,7 @@ void ParallelConnection::dataMessageReceived(){
             kf.deserialize(buffer);
                     
             //add the keyframe to the interaction handler
-            OsEng.interactionHandler()->addKeyframe(kf);
+            OsEng.interactionHandler().addKeyframe(kf);
             break;
         }
         case network::datamessagestructures::TimeData:{
@@ -587,7 +587,7 @@ void ParallelConnection::dataMessageReceived(){
             sm.deserialize(buffer);
                     
             //Que script to be executed by script engine
-            OsEng.scriptEngine()->queueScript(sm._script);
+            OsEng.scriptEngine().queueScript(sm._script);
             break;
         }
         default:{
@@ -682,7 +682,7 @@ void ParallelConnection::hostInfoMessageReceived(){
 			}
                     
             //clear buffered any keyframes
-            OsEng.interactionHandler()->clearKeyframes();
+            OsEng.interactionHandler().clearKeyframes();
                     
             //request init package from the host
             int size = headerSize();
@@ -1037,8 +1037,8 @@ void ParallelConnection::broadcast(){
 
         //create a keyframe with current position and orientation of camera
         network::datamessagestructures::PositionKeyframe kf;
-		kf._position = OsEng.interactionHandler()->camera()->position();
-		kf._viewRotationQuat = glm::quat_cast(OsEng.interactionHandler()->camera()->viewRotationMatrix());
+		kf._position = OsEng.interactionHandler().camera()->position();
+		kf._viewRotationQuat = glm::quat_cast(OsEng.interactionHandler().camera()->viewRotationMatrix());
 				
         //timestamp as current runtime of OpenSpace instance
         kf._timeStamp = OsEng.runTime();
diff --git a/src/network/parallelconnection_lua.inl b/src/network/parallelconnection_lua.inl
index 059129e20a..7fd5cd7afb 100644
--- a/src/network/parallelconnection_lua.inl
+++ b/src/network/parallelconnection_lua.inl
@@ -45,7 +45,7 @@ int setPort(lua_State* L) {
 		int value = lua_tonumber(L, -1);
 		std::string port = std::to_string(value);
         if(OsEng.isMaster()){
-            OsEng.parallelConnection()->setPort(port);
+            OsEng.parallelConnection().setPort(port);
         }
 		return 0;
 	}
@@ -71,7 +71,7 @@ int setAddress(lua_State* L) {
 	if (type == LUA_TSTRING) {
 		std::string address = luaL_checkstring(L, -1);
         if(OsEng.isMaster()){
-            OsEng.parallelConnection()->setAddress(address);
+            OsEng.parallelConnection().setAddress(address);
         }
 		return 0;
 	}
@@ -97,7 +97,7 @@ int setPassword(lua_State* L) {
 	if (type == LUA_TSTRING) {
 		std::string pwd = luaL_checkstring(L, -1);
         if(OsEng.isMaster()){
-            OsEng.parallelConnection()->setPassword(pwd);
+            OsEng.parallelConnection().setPassword(pwd);
         }
 		return 0;
 	}
@@ -123,7 +123,7 @@ int setDisplayName(lua_State* L) {
 	if (type == LUA_TSTRING) {
 		std::string name = luaL_checkstring(L, -1);
         if(OsEng.isMaster()){
-            OsEng.parallelConnection()->setName(name);
+            OsEng.parallelConnection().setName(name);
         }
 		return 0;
 	}
@@ -142,7 +142,7 @@ int connect(lua_State* L) {
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
     if(OsEng.isMaster()){
-        OsEng.parallelConnection()->clientConnect();
+        OsEng.parallelConnection().clientConnect();
     }
 	return 0;
 }
@@ -153,7 +153,7 @@ int disconnect(lua_State* L) {
     if (nArguments != 0)
     return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
     if(OsEng.isMaster()){
-        OsEng.parallelConnection()->signalDisconnect();
+        OsEng.parallelConnection().signalDisconnect();
     }
     return 0;
 }
@@ -171,7 +171,7 @@ int requestHostship(lua_State* L) {
     if (type == LUA_TSTRING) {
         std::string pwd = luaL_checkstring(L, -1);
         if(OsEng.isMaster()){
-            OsEng.parallelConnection()->requestHostship(pwd);
+            OsEng.parallelConnection().requestHostship(pwd);
         }
         return 0;
     }
diff --git a/src/query/query.cpp b/src/query/query.cpp
index f0fa4a087e..7b0a20db4c 100644
--- a/src/query/query.cpp
+++ b/src/query/query.cpp
@@ -38,7 +38,7 @@ namespace {
 }
 
 Scene* sceneGraph() {
-    return OsEng.renderEngine()->scene();
+    return OsEng.renderEngine().scene();
 }
 
 SceneGraphNode* sceneGraphNode(const std::string& name) {
@@ -52,7 +52,7 @@ Renderable* renderable(const std::string& name) {
 }
 
 properties::Property* property(const std::string& uri) {
-    properties::Property* globalProp = OsEng.globalPropertyOwner()->property(uri);
+    properties::Property* globalProp = OsEng.globalPropertyOwner().property(uri);
     if (globalProp) {
         return globalProp;
     }
diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index a7161f578f..a1317bd135 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -53,6 +53,7 @@
 #include <ghoul/font/fontrenderer.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/glm.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 
 #include <ghoul/io/texture/texturereader.h>
 #ifdef GHOUL_USE_DEVIL
@@ -136,8 +137,8 @@ bool RenderEngine::initialize() {
     std::string renderingMethod = DefaultRenderingMethod;
     
     // If the user specified a rendering method that he would like to use, use that
-    if (OsEng.configurationManager()->hasKeyAndValue<std::string>(KeyRenderingMethod))
-        renderingMethod = OsEng.configurationManager()->value<std::string>(KeyRenderingMethod);
+    if (OsEng.configurationManager().hasKeyAndValue<std::string>(KeyRenderingMethod))
+        renderingMethod = OsEng.configurationManager().value<std::string>(KeyRenderingMethod);
     else {
         using Version = ghoul::systemcapabilities::OpenGLCapabilitiesComponent::Version;
 
@@ -179,7 +180,7 @@ bool RenderEngine::initialize() {
 	_mainCamera = new Camera();
 	_mainCamera->setScaling(glm::vec2(1.0, -8.0));
 	_mainCamera->setPosition(psc(0.f, 0.f, 1.499823f, 11.f));
-	OsEng.interactionHandler()->setCamera(_mainCamera);
+	OsEng.interactionHandler().setCamera(_mainCamera);
 
 #ifdef GHOUL_USE_DEVIL
     ghoul::io::TextureReader::ref().addReader(std::make_shared<ghoul::io::TextureReaderDevIL>());
diff --git a/src/rendering/renderengine_lua.inl b/src/rendering/renderengine_lua.inl
index 7d0ea22a00..d166317f5a 100644
--- a/src/rendering/renderengine_lua.inl
+++ b/src/rendering/renderengine_lua.inl
@@ -47,7 +47,7 @@ int takeScreenshot(lua_State* L) {
 	int nArguments = lua_gettop(L);
 	if (nArguments != 0)
 		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
-	OsEng.renderEngine()->takeScreenshot();
+	OsEng.renderEngine().takeScreenshot();
 	return 0;
 }
 
@@ -65,7 +65,7 @@ int visualizeABuffer(lua_State* L) {
     if (type != LUA_TBOOLEAN)
         return luaL_error(L, "Expected argument of type 'bool'");
 	bool b = lua_toboolean(L, -1) != 0;
-	OsEng.renderEngine()->toggleVisualizeABuffer(b);
+	OsEng.renderEngine().toggleVisualizeABuffer(b);
 	return 0;
 }
 
@@ -83,7 +83,7 @@ int showRenderInformation(lua_State* L) {
     if (type != LUA_TBOOLEAN)
         return luaL_error(L, "Expected argument of type 'bool'");
 	bool b = lua_toboolean(L, -1) != 0;
-	OsEng.renderEngine()->toggleInfoText(b);
+	OsEng.renderEngine().toggleInfoText(b);
 	return 0;
 }
 
@@ -98,7 +98,7 @@ int setPerformanceMeasurement(lua_State* L) {
 		return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
 
 	bool b = lua_toboolean(L, -1) != 0;
-	OsEng.renderEngine()->setPerformanceMeasurements(b);
+	OsEng.renderEngine().setPerformanceMeasurements(b);
 	return 0;
 }
 
@@ -114,7 +114,7 @@ int fadeIn(lua_State* L) {
 
 	double t = luaL_checknumber(L, -1);
 			
-	OsEng.renderEngine()->startFading(1, static_cast<float>(t));
+	OsEng.renderEngine().startFading(1, static_cast<float>(t));
 	return 0;
 }
 /**
@@ -129,7 +129,7 @@ int fadeOut(lua_State* L) {
 
 	double t = luaL_checknumber(L, -1);
 
-	OsEng.renderEngine()->startFading(-1, static_cast<float>(t));
+	OsEng.renderEngine().startFading(-1, static_cast<float>(t));
 	return 0;
 }
 
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
index ae850d3465..996cdb6af0 100644
--- a/src/scene/scene.cpp
+++ b/src/scene/scene.cpp
@@ -96,7 +96,7 @@ bool Scene::initialize() {
 		"${SHADERS}/fboPass_fs.glsl");
 	if (!prg) return false;
 	prg->setProgramObjectCallback(cb);
-    OsEng.ref().configurationManager()->setValue("fboPassProgram", prg.get());
+    OsEng.ref().configurationManager().setValue("fboPassProgram", prg.get());
     _programs.push_back(std::move(prg));
 
 	// pscstandard
@@ -105,7 +105,7 @@ bool Scene::initialize() {
 		"${SHADERS}/pscstandard_fs.glsl");
     if (! prg) return false;
 	prg->setProgramObjectCallback(cb);
-    OsEng.ref().configurationManager()->setValue("pscShader", prg.get());
+    OsEng.ref().configurationManager().setValue("pscShader", prg.get());
     _programs.push_back(std::move(prg));
 
 	// Night texture program
@@ -114,7 +114,7 @@ bool Scene::initialize() {
 		"${SHADERS}/nighttexture_fs.glsl");
 	if (!prg) return false;
 	prg->setProgramObjectCallback(cb);
-    OsEng.ref().configurationManager()->setValue("nightTextureProgram", prg.get());
+    OsEng.ref().configurationManager().setValue("nightTextureProgram", prg.get());
     _programs.push_back(std::move(prg));
 
     // RaycastProgram
@@ -123,7 +123,7 @@ bool Scene::initialize() {
 		"${SHADERS}/exitpoints.frag");
 	if (!prg) return false;
 	prg->setProgramObjectCallback(cb);
-    OsEng.ref().configurationManager()->setValue("RaycastProgram", prg.get());
+    OsEng.ref().configurationManager().setValue("RaycastProgram", prg.get());
     _programs.push_back(std::move(prg));
 
     return true;
@@ -140,12 +140,12 @@ bool Scene::deinitialize() {
 
 void Scene::update(const UpdateData& data) {
 	if (!_sceneGraphToLoad.empty()) {
-		OsEng.renderEngine()->scene()->clearSceneGraph();
+		OsEng.renderEngine().scene()->clearSceneGraph();
 		bool success = loadSceneInternal(_sceneGraphToLoad);
 		_sceneGraphToLoad = "";
 		if (!success)
 			return;
-		OsEng.renderEngine()->aBuffer()->invalidateABuffer();
+		OsEng.renderEngine().aBuffer()->invalidateABuffer();
 	}
     for (SceneGraphNode* node : _graph.nodes())
         node->update(data);
@@ -257,7 +257,7 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
     //_root->calculateBoundingSphere();
 
     // set the camera position
-	Camera* c = OsEng.ref().renderEngine()->camera();
+	Camera* c = OsEng.ref().renderEngine().camera();
     //auto focusIterator = _allNodes.find(_focus);
     auto focusIterator = std::find_if(
                 _graph.nodes().begin(),
@@ -304,10 +304,10 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
       //  c->setScaling(scaling);
 
         // Set the focus node for the interactionhandler
-        OsEng.interactionHandler()->setFocusNode(focusNode);
+        OsEng.interactionHandler().setFocusNode(focusNode);
     }
     else
-        OsEng.interactionHandler()->setFocusNode(_graph.rootNode());
+        OsEng.interactionHandler().setFocusNode(_graph.rootNode());
 
 	glm::vec4 position;
 	if (cameraDictionary.hasKey(KeyPositionObject)
@@ -324,7 +324,7 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 	}
 
 	// the camera position
-	const SceneGraphNode* fn = OsEng.interactionHandler()->focusNode();
+	const SceneGraphNode* fn = OsEng.interactionHandler().focusNode();
     // Check crash for when fn == nullptr
 
 	glm::mat4 la = glm::lookAt(cameraPosition.vec3(), fn->worldPosition().vec3(), c->lookUpVector());
@@ -344,18 +344,18 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 	for (SceneGraphNode* node : _graph.nodes()) {
 		std::vector<properties::Property*> properties = node->propertiesRecursive();
 		for (properties::Property* p : properties) {
-            OsEng.gui()->_property.registerProperty(p);
+            OsEng.gui()._property.registerProperty(p);
 		}
 	}
 
     // If a LuaDocumentationFile was specified, generate it now
-    const bool hasType = OsEng.configurationManager()->hasKey(ConfigurationManager::KeyPropertyDocumentationType);
-    const bool hasFile = OsEng.configurationManager()->hasKey(ConfigurationManager::KeyPropertyDocumentationFile);
+    const bool hasType = OsEng.configurationManager().hasKey(ConfigurationManager::KeyPropertyDocumentationType);
+    const bool hasFile = OsEng.configurationManager().hasKey(ConfigurationManager::KeyPropertyDocumentationFile);
     if (hasType && hasFile) {
         std::string propertyDocumentationType;
-        OsEng.configurationManager()->getValue(ConfigurationManager::KeyPropertyDocumentationType, propertyDocumentationType);
+        OsEng.configurationManager().getValue(ConfigurationManager::KeyPropertyDocumentationType, propertyDocumentationType);
         std::string propertyDocumentationFile;
-        OsEng.configurationManager()->getValue(ConfigurationManager::KeyPropertyDocumentationFile, propertyDocumentationFile);
+        OsEng.configurationManager().getValue(ConfigurationManager::KeyPropertyDocumentationFile, propertyDocumentationFile);
 
         propertyDocumentationFile = absPath(propertyDocumentationFile);
         writePropertyDocumentation(propertyDocumentationFile, propertyDocumentationType);
diff --git a/src/scene/scene_lua.inl b/src/scene/scene_lua.inl
index 79fbe882bf..269994832a 100644
--- a/src/scene/scene_lua.inl
+++ b/src/scene/scene_lua.inl
@@ -62,7 +62,7 @@ int property_setValue(lua_State* L) {
         //ensure properties are synced over parallel connection
         std::string value;
         prop->getStringValue(value);
-        OsEng.parallelConnection()->scriptMessage(prop->fullyQualifiedIdentifier(), value);
+        OsEng.parallelConnection().scriptMessage(prop->fullyQualifiedIdentifier(), value);
     }
 
 	return 0;
@@ -107,7 +107,7 @@ int loadScene(lua_State* L) {
 
 	std::string sceneFile = luaL_checkstring(L, -1);
 
-	OsEng.renderEngine()->scene()->scheduleLoadSceneFile(sceneFile);
+	OsEng.renderEngine().scene()->scheduleLoadSceneFile(sceneFile);
 
 	return 0;
 }
diff --git a/src/scene/scenegraph.cpp b/src/scene/scenegraph.cpp
index 6f00479de4..0934f01af4 100644
--- a/src/scene/scenegraph.cpp
+++ b/src/scene/scenegraph.cpp
@@ -125,7 +125,7 @@ bool SceneGraph::loadFromFile(const std::string& sceneDescription) {
         return true;
 
     lua_State* state = ghoul::lua::createNewLuaState();
-    OsEng.scriptEngine()->initializeLuaState(state);
+    OsEng.scriptEngine().initializeLuaState(state);
 
     // Get the common directory
     bool commonFolderSpecified = sceneDictionary.hasKey(KeyCommonFolder);
@@ -343,7 +343,7 @@ bool SceneGraph::sortTopologically() {
 
     }
 
-    RenderEngine::ABufferImplementation i = OsEng.renderEngine()->aBufferImplementation();
+    RenderEngine::ABufferImplementation i = OsEng.renderEngine().aBufferImplementation();
     if (i == RenderEngine::ABufferImplementation::FrameBuffer) {
         auto it = std::find_if(
                                _topologicalSortedNodes.begin(),
diff --git a/src/scripting/scriptengine.cpp b/src/scripting/scriptengine.cpp
index 097697c54a..48413a9b41 100644
--- a/src/scripting/scriptengine.cpp
+++ b/src/scripting/scriptengine.cpp
@@ -156,7 +156,7 @@ bool ScriptEngine::runScript(const std::string& script) {
     }
     
     //if we're currently hosting the parallel session, find out if script should be synchronized.
-	if (OsEng.parallelConnection()->isHost()){
+	if (OsEng.parallelConnection().isHost()){
 
 		std::string lib, func;
 		if (parseLibraryAndFunctionNames(lib, func, script) && shouldScriptBeSent(lib, func)){
diff --git a/src/util/screenlog.cpp b/src/util/screenlog.cpp
index fdffd770f0..106ad9e859 100644
--- a/src/util/screenlog.cpp
+++ b/src/util/screenlog.cpp
@@ -25,6 +25,7 @@
 #include <openspace/util/screenlog.h>
 
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 
 #include <ghoul/opengl/ghoul_gl.h>