diff --git a/Jenkinsfile b/Jenkinsfile
index 70a9e84b13..9150da5bef 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -45,7 +45,7 @@ stage('Build') {
         node('windows') {
             timeout(time: 90, unit: 'MINUTES') {
                 // We specify the workspace directory manually to reduce the path length and thus try to avoid MSB3491 on Visual Studio
-                ws("C:/J/O/${env.BRANCH_NAME}") {
+                ws("C:/J/O/${env.BRANCH_NAME}/${env.BUILD_ID}") {
                     deleteDir()
                     checkout scm
                     bat '''
@@ -54,7 +54,7 @@ stage('Build') {
                         cd build
                         cmake -G "Visual Studio 15 2017 Win64" .. ''' +
                         flags + ''' ..
-                        msbuild.exe OpenSpace.sln /nologo /verbosity:minimal /m:4 /p:Configuration=Debug
+                        msbuild.exe OpenSpace.sln /nologo /verbosity:minimal /p:Configuration=Debug /target:OpenSpace
                     '''
                 }
             }
diff --git a/apps/OpenSpace/main.cpp b/apps/OpenSpace/main.cpp
index 42100b12a4..6d61c9663d 100644
--- a/apps/OpenSpace/main.cpp
+++ b/apps/OpenSpace/main.cpp
@@ -43,7 +43,7 @@
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/stacktrace.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include <Windows.h>
 #include <shellapi.h>
@@ -104,7 +104,7 @@ LONG WINAPI generateMiniDump(EXCEPTION_POINTERS* exceptionPointers) {
         GetCurrentThreadId()
     );
 
-    LINFO("Creating dump file: " << dumpFile);
+    LINFO(fmt::format("Creating dump file: {}", dumpFile));
 
     HANDLE hDumpFile = CreateFile(
         dumpFile.c_str(),
@@ -310,7 +310,7 @@ void mainInitFunc() {
 
 #endif // OPENSPACE_HAS_SPOUT
     }
-    
+
     std::string k = openspace::ConfigurationManager::KeyScreenshotUseDate;
     std::string screenshotPath = "${SCREENSHOTS}";
     std::string screenshotNames = "OpenSpace";
@@ -320,19 +320,16 @@ void mainInitFunc() {
         char mbstr[100];
         strftime(mbstr, sizeof(mbstr), "%Y-%m-%d-%H-%M", nowTime);
         screenshotPath += "/" + std::string(mbstr);
-
-        std::string p = absPath(screenshotPath);
-        if (!FileSys.directoryExists(p)) {
-            FileSys.createDirectory(p);
-        }
     }
 
+    FileSys.registerPathToken("${THIS_SCREENSHOT_PATH}", screenshotPath);
+
     for (size_t i = 0; i < nWindows; ++i) {
         sgct_core::ScreenCapture* cpt0 =
             SgctEngine->getWindowPtr(i)->getScreenCapturePointer(0);
         sgct_core::ScreenCapture* cpt1 =
             SgctEngine->getWindowPtr(i)->getScreenCapturePointer(1);
-        
+
         if (cpt0) {
             cpt0->setPathAndFileName(
                 absPath(screenshotPath),
@@ -559,7 +556,9 @@ int main_main(int argc, char** argv) {
     catch (const ghoul::RuntimeError& e) {
         // Write out all of the information about the exception and flush the logs
         LFATALC(e.component, e.message);
-        LogMgr.flushLogs();
+        if (ghoul::logging::LogManager::isInitialized()) {
+            LogMgr.flushLogs();
+        }
         return EXIT_FAILURE;
     }
     catch (const ghoul::AssertionException& e) {
@@ -570,12 +569,16 @@ int main_main(int argc, char** argv) {
     }
     catch (const std::exception& e) {
         LFATALC("Exception", e.what());
-        LogMgr.flushLogs();
+        if (ghoul::logging::LogManager::isInitialized()) {
+            LogMgr.flushLogs();
+        }
         return EXIT_FAILURE;
     }
     catch (...) {
         LFATALC("Exception", "Unknown exception");
-        LogMgr.flushLogs();
+        if (ghoul::logging::LogManager::isInitialized()) {
+            LogMgr.flushLogs();
+        }
         return EXIT_FAILURE;
     }
 
@@ -583,7 +586,9 @@ int main_main(int argc, char** argv) {
         return EXIT_SUCCESS;
     }
 
-    LINFO("Detected OpenGL version: " << glVersion.first << "." << glVersion.second);
+    LINFO(fmt::format(
+        "Detected OpenGL version: {}.{}", glVersion.first, glVersion.second
+    ));
 
     // Create sgct engine c arguments
     int newArgc = static_cast<int>(sgctArguments.size());
diff --git a/apps/Sync/main.cpp b/apps/Sync/main.cpp
index 86bee06c87..22ecaa259f 100644
--- a/apps/Sync/main.cpp
+++ b/apps/Sync/main.cpp
@@ -52,8 +52,11 @@ int main(int argc, char** argv) {
         Task& task = *tasks[i].get();
         LINFOC(
             "Sync",
-            "Synchronizing scene " << (i + 1) << " out of " <<
-                tasks.size() << ": " << task.description()
+            fmt::format(
+                "Synchronizing scene {} out of {}: {}",
+                i + 1, tasks.size(),
+                task.description()
+            )
         );
         ProgressBar progressBar(100);
         task.perform([&progressBar](float progress) {
diff --git a/apps/TaskRunner/main.cpp b/apps/TaskRunner/main.cpp
index 7f6ffe0157..85a206d436 100644
--- a/apps/TaskRunner/main.cpp
+++ b/apps/TaskRunner/main.cpp
@@ -83,15 +83,14 @@ void performTasks(const std::string& path) {
         LINFO("Task queue has 1 item");
     }
     else {
-        LINFO("Task queue has " << tasks.size() << " items");
+        LINFO(fmt::format("Task queue has {} items", tasks.size()));
     }
 
     for (size_t i = 0; i < tasks.size(); i++) {
         Task& task = *tasks[i].get();
-        LINFO(
-            "Performing task " << (i + 1) << " out of " <<
-            tasks.size() << ": " << task.description()
-        );
+        LINFO(fmt::format(
+            "Performing task {} out of {}: {}", i + 1, tasks.size(), task.description()
+        ));
         ProgressBar progressBar(100);
         auto onProgress = [&progressBar](float progress) {
             progressBar.print(static_cast<int>(progress * 100.f));
@@ -135,7 +134,7 @@ int main(int argc, char** argv) {
 
     // If no task file was specified in as argument, run in CLI mode.
 
-    LINFO("Task root: " << absPath("${TASKS}"));
+    LINFO(fmt::format("Task root: {}", absPath("${TASKS}")));
     FileSys.setCurrentDirectory(ghoul::filesystem::Directory(absPath("${TASKS}")));
 
     std::cout << "TASK > ";
diff --git a/data/assets/customization/globebrowsing.asset b/data/assets/customization/globebrowsing.asset
index 105a2b18b0..ccdaec8893 100644
--- a/data/assets/customization/globebrowsing.asset
+++ b/data/assets/customization/globebrowsing.asset
@@ -17,7 +17,7 @@ local vrt_folders = {
         -- tl;dr:  Specify CTX folders first, then HiRISE 
         -- example:   'C:/OpenSpace/GlobeBrowsingData/Mars/CTX'
         '',
-        ''
+        '',
     },
     Moon = {
         -- Add folders here whose contents will be automatically added to the Moon globe
@@ -25,7 +25,6 @@ local vrt_folders = {
         -- if areas overlap, images from the lower results will overwrite the images from former
         -- results
         -- example:  'C:/OpenSpace/GlobeBrowsingData/Moon'
-        '',
         ''
     }
 }
diff --git a/data/assets/default.scene b/data/assets/default.scene
index 56383f8b05..db418c766a 100644
--- a/data/assets/default.scene
+++ b/data/assets/default.scene
@@ -1,5 +1,6 @@
 local assetHelper = asset.require('util/asset_helper')
 local sceneHelper = asset.require('util/scene_helper')
+local propertyHelper = asset.require('util/property_helper')
 
 -- Specifying which other assets should be loaded in this scene
 asset.require('spice/base')
@@ -19,37 +20,37 @@ asset.request('customization/globebrowsing')
 local Keybindings = {
     {
         Key = "s",
-        Command = sceneHelper.property.invert('Earth.RenderableGlobe.Layers.NightLayers.Earth at Night 2012.Enabled') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.PerformShading') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.Atmosphere') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.Layers.WaterMasks.MODIS_Water_Mask.Enabled'),
+        Command = propertyHelper.invert('Scene.Earth.RenderableGlobe.Layers.NightLayers.Earth at Night 2012.Enabled') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.PerformShading') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.Atmosphere') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.Layers.WaterMasks.MODIS_Water_Mask.Enabled'),
         Documentation = "Toggle night texture, shading, atmosphere, and water for Earth.",
         Local = false
     },
     {
         Key = "b",
-        Command = sceneHelper.property.invert('MilkyWay.renderable.Enabled') ..
-                  sceneHelper.property.invert('Stars.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.MilkyWay.renderable.Enabled') ..
+                  propertyHelper.invert('Scene.Stars.renderable.Enabled'),
         Documentation = "Toggle background (Stars and Milkyway).",
         Local = false
     },
     {
         Key = "g",
-        Command = sceneHelper.property.invert('MilkyWay.renderable.Enabled') ..
-                  sceneHelper.property.invert('Stars.renderable.Enabled') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.Layers.NightLayers.Earth at Night 2012.Enabled') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.PerformShading') ..
-                  sceneHelper.property.invert('Mars.RenderableGlobe.PerformShading') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.Atmosphere') ..
-                  sceneHelper.property.invert('Earth.RenderableGlobe.Layers.WaterMasks.MODIS_Water_Mask.Enabled') ..
-                  sceneHelper.property.invert('Moon.RenderableGlobe.Enabled') ..
-                  sceneHelper.property.invert('Sun.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.MilkyWay.renderable.Enabled') ..
+                  propertyHelper.invert('Scene.Stars.renderable.Enabled') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.Layers.NightLayers.Earth at Night 2012.Enabled') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.PerformShading') ..
+                  propertyHelper.invert('Scene.Mars.RenderableGlobe.PerformShading') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.Atmosphere') ..
+                  propertyHelper.invert('Scene.Earth.RenderableGlobe.Layers.WaterMasks.MODIS_Water_Mask.Enabled') ..
+                  propertyHelper.invert('Scene.Moon.RenderableGlobe.Enabled') ..
+                  propertyHelper.invert('Scene.Sun.renderable.Enabled'),
         Documentation = "Toogles background and shading mode on the Earth and Mars alongside visibility of the Moon and the Sun",
         Local = false
     },
     {
         Key = "h",
-        Command = "openspace.setPropertyValue('*Trail.renderable.Enabled', false)",
+        Command = "openspace.setPropertyValue('Scene.*Trail.renderable.Enabled', false)",
         Documentation = "Disables visibility of the trails",
         Local = false
     },
@@ -72,11 +73,10 @@ asset.onInitialize(function ()
         "Earth", "Mars", "Moon"
     })
 
-
     openspace.addVirtualProperty(
         "BoolProperty",
         "Show Trails",
-        "*Trail.renderable.Enabled",
+        "Scene.*Trail.renderable.Enabled",
         "Disable or enable all trails of the scene at the same time",
         true,
         nil,
diff --git a/data/assets/examples/urlsynchronization.asset b/data/assets/examples/urlsynchronization.asset
index cc7e4b1a7c..630eb4762b 100644
--- a/data/assets/examples/urlsynchronization.asset
+++ b/data/assets/examples/urlsynchronization.asset
@@ -3,15 +3,15 @@
 local assetHelper = asset.require("util/asset_helper")
 
 asset.syncedResource({
-    Type = "UrlSynchronization",
     Name = "Example Single",
+    Type = "UrlSynchronization",
     Identifier = "example_single",
     Url = "http://celestrak.com/NORAD/elements/geo.txt"
 })
 
 asset.syncedResource({
-    Type = "UrlSynchronization",
     Name = "Example Multiple",
+    Type = "UrlSynchronization",
     Identifier = "example_multiple",
     Url = {
         "http://celestrak.com/NORAD/elements/stations.txt",
@@ -20,14 +20,23 @@ asset.syncedResource({
 })
 
 asset.syncedResource({
-    Type = "UrlSynchronization",
     Name = "Example Large",
+    Type = "UrlSynchronization",
     Identifier = "example_large",
-    Url = "http://ipv4.download.thinkbroadband.com/100MB.zip"
+    Url = "http://ipv4.download.thinkbroadband.com/100MB.zip",
+    Override = true
 })
 
 asset.syncedResource({
+    Name = "Example Medium",
     Type = "UrlSynchronization",
+    Identifier = "example_medium",
+    Url = "http://ipv4.download.thinkbroadband.com/5MB.zip",
+    Override = true
+})
+
+asset.syncedResource({
     Name = "Example No ident",
+    Type = "UrlSynchronization",
     Url = "http://ipv4.download.thinkbroadband.com/5MB.zip"
 })
diff --git a/data/assets/newhorizons.scene b/data/assets/newhorizons.scene
index fb2e606c93..3b109a3a34 100644
--- a/data/assets/newhorizons.scene
+++ b/data/assets/newhorizons.scene
@@ -1,5 +1,7 @@
 local assetHelper = asset.require('util/asset_helper')
 local sceneHelper = asset.require('util/scene_helper')
+local propertyHelper = asset.require('util/property_helper')
+local renderableHelper = asset.require('util/renderable_helper')
 
 -- Specifying which other assets should be loaded in this scene
 asset.require('spice/base')
@@ -34,94 +36,94 @@ local Keybindings = {
     },
     {
         Key = "F8",
-        Command = "openspace.setPropertyValue('Pluto.renderable.ProjectionComponent.ClearAllProjections', true);" ..
-                  "openspace.setPropertyValue('Charon.renderable.ProjectionComponent.ClearAllProjections', true);",
+        Command = "openspace.setPropertyValue('Scene.Pluto.renderable.ProjectionComponent.ClearAllProjections', true);" ..
+                  "openspace.setPropertyValue('Scene.Charon.renderable.ProjectionComponent.ClearAllProjections', true);",
         Documentation = "Removes all image projections from Pluto and Charon.",
         Local = false
     },
     {
         Key = "F9",
         Command = "openspace.time.setTime('2015-07-14T09:00:00.00');" ..
-                  "openspace.setPropertyValue('Pluto.renderable.ClearAllProjections', true);" ..
-                  "openspace.setPropertyValue('Charon.renderable.ClearAllProjections', true);",
+                  "openspace.setPropertyValue('Scene.Pluto.renderable.ClearAllProjections', true);" ..
+                  "openspace.setPropertyValue('Scene.Charon.renderable.ClearAllProjections', true);",
         Documentation = "Jumps to the 14th of July 2015 at 0900 UTC and clears all projections.",
         Local = false
     },
     {
         Key = "KP_8",
-        Command = sceneHelper.property.increment('Pluto.renderable.HeightExaggeration', 5000000),
+        Command = propertyHelper.increment('Scene.Pluto.renderable.HeightExaggeration', 5000000),
         Documentation = "Increases the height map exaggeration on Pluto.",
         Local = false
     },
     {
         Key = "KP_2",
-        Command = sceneHelper.property.decrement('Pluto.renderable.HeightExaggeration', 5000000),
+        Command = propertyHelper.decrement('Scene.Pluto.renderable.HeightExaggeration', 5000000),
         Documentation = "Decreases the height map exaggeration on Pluto.",
         Local = false
     },
     {
         Key = "KP_9",
-        Command = sceneHelper.property.increment('Charon.renderable.HeightExaggeration', 5000000),
+        Command = propertyHelper.increment('Scene.Charon.renderable.HeightExaggeration', 5000000),
         Documentation = "Increases the height map exaggeration on Charon.",
         Local = false
     },
     {
         Key = "KP_3",
-        Command = sceneHelper.property.decrement('Charon.renderable.HeightExaggeration', 5000000),
+        Command = propertyHelper.decrement('Scene.Charon.renderable.HeightExaggeration', 5000000),
         Documentation = "Decreases the height map exaggeration on Charon.",
         Local = false
     },
     {
         Key = "q",
-        Command = sceneHelper.property.invert('SunMarker.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.SunMarker.renderable.Enabled'),
         Documentation = "Toggles the visibility of the text marking the location of the Sun.",
         Local = false
     },
     {
         Key = "e",
-        Command = sceneHelper.property.invert('EarthMarker.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.EarthMarker.renderable.Enabled'),
         Documentation = "Toggles the visibility of the text marking the location of the Earth.",
         Local = false
     },
     {
         Key = "o",
-        Command = sceneHelper.property.invert('PlutoTrail.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.PlutoTrail.renderable.Enabled'),
         Documentation = "Toggles the visibility of the trail behind Pluto.",
         Local = false
     },
     {
         Key = "j",
-        Command = sceneHelper.renderable.toggle('PlutoText') .. sceneHelper.renderable.toggle('CharonText') ..
-                  sceneHelper.renderable.toggle('HydraText') .. sceneHelper.renderable.toggle('NixText') ..
-                  sceneHelper.renderable.toggle('KerberosText') .. sceneHelper.renderable.toggle('StyxText'),
+        Command = renderableHelper.toggle('Scene.PlutoText') .. renderableHelper.toggle('Scene.CharonText') ..
+                  renderableHelper.toggle('Scene.HydraText') .. renderableHelper.toggle('Scene.NixText') ..
+                  renderableHelper.toggle('Scene.KerberosText') .. renderableHelper.toggle('Scene.StyxText'),
         Documentation = "Toggles the visibility of the text labels of Pluto, Charon, Hydra, Nix, Kerberos, and Styx.",
         Local = false
     },
     {
         Key = "l",
-        Command = sceneHelper.property.invert('Labels.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.Labels.renderable.Enabled'),
         Documentation = "Toggles the visibility of the labels for the New Horizons instruments.",
         Local = false
     },
     {
         Key = "m",
-        Command = sceneHelper.property.invert('NH_LORRI.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_LEISA.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_PAN1.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_PAN2.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_RED.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_BLUE.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_FT.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_METHANE.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_RALPH_MVIC_NIR.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_ALICE_AIRGLOW.renderable.SolidDraw') ..
-                  sceneHelper.property.invert('NH_ALICE_SOC.renderable.SolidDraw'),
+        Command = propertyHelper.invert('Scene.NH_LORRI.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_LEISA.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_PAN1.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_PAN2.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_RED.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_BLUE.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_FT.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_METHANE.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_RALPH_MVIC_NIR.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_ALICE_AIRGLOW.renderable.SolidDraw') ..
+                  propertyHelper.invert('Scene.NH_ALICE_SOC.renderable.SolidDraw'),
         Documentation = "Draws the instrument field of views in a solid color or as lines.",
         Local = false
     },
     {
         Key = "t",
-        Command = sceneHelper.renderable.toggle('PlutoShadow') .. sceneHelper.renderable.toggle('CharonShadow'),
+        Command = renderableHelper.toggle('Scene.PlutoShadow') .. renderableHelper.toggle('Scene.CharonShadow'),
         Documentation = "Toggles the visibility of the shadow visualization of Pluto and Charon.",
         Local = false
     }
diff --git a/data/assets/osirisrex.scene b/data/assets/osirisrex.scene
index 556981a006..98a30d82b0 100644
--- a/data/assets/osirisrex.scene
+++ b/data/assets/osirisrex.scene
@@ -1,5 +1,6 @@
 local assetHelper = asset.require('util/asset_helper')
 local sceneHelper = asset.require('util/scene_helper')
+local propertyHelper = asset.require('util/property_helper')
 
 -- Specifying which other assets should be loaded in this scene
 asset.require('spice/base')
@@ -64,13 +65,13 @@ local Keybindings = {
     },
     {
         Key = "q",
-        Command = sceneHelper.property.invert('SunMarker.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.SunMarker.renderable.Enabled'),
         Documentation = "Toggles the visibility of the text marking the location of the Sun.",
         Local = false
     },
     {
         Key = "e",
-        Command = sceneHelper.property.invert('EarthMarker.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.EarthMarker.renderable.Enabled'),
         Documentation = "Toggles the visibility of the text marking the location of the Earth.",
         Local = false
     }
diff --git a/data/assets/rosetta.scene b/data/assets/rosetta.scene
index 93f37fa291..b4fe3750e1 100644
--- a/data/assets/rosetta.scene
+++ b/data/assets/rosetta.scene
@@ -1,5 +1,7 @@
 local assetHelper = asset.require('util/asset_helper')
 local sceneHelper = asset.require('util/scene_helper')
+local propertyHelper = asset.require('util/property_helper')
+local renderableHelper = asset.require('util/renderable_helper')
 
 -- Specifying which other assets should be loaded in this scene
 asset.require('spice/base')
@@ -41,38 +43,38 @@ local Keybindings = {
     },
     {
         Key = "F8",
-        Command = "openspace.setPropertyValue('67P.renderable.ProjectionComponent.clearAllProjections', true)",
+        Command = "openspace.setPropertyValue('Scene.67P.renderable.ProjectionComponent.clearAllProjections', true)",
         Documentation = "Removes all image projections from 67P.",
         Local = false
     },
     {
         Key = "q",
-        Command = sceneHelper.property.invert('SunMarker.renderable.Enabled'),
+        Command = propertyHelper.invert('Scene.SunMarker.renderable.Enabled'),
         Documentation = "Toggles the visibility of the text marking the location of the Sun.",
         Local = false
     },
     {
         Key = "e",
-        Command = helper.renderable.toggle('JupiterTrail') .. helper.renderable.toggle('SaturnTrail') ..
-                  helper.renderable.toggle('UranusTrail') .. helper.renderable.toggle('NeptuneTrail'),
+        Command = renderableHelper.toggle('Scene.JupiterTrail') .. renderableHelper.toggle('Scene.SaturnTrail') ..
+                  renderableHelper.toggle('Scene.UranusTrail') .. renderableHelper.toggle('Scene.NeptuneTrail'),
         Documentation = "Toggles the visibility of all trails further from the Sun than 67P.",
         Local = false
     },
     {
         Key = "i",
-        Command = sceneHelper.renderable.toggle('ImagePlaneRosetta'),
+        Command = renderableHelper.toggle('Scene.ImagePlaneRosetta'),
         Documentation = "Toggles the visibility of the free floating image plane.",
         Local = false
     },
     {
         Key = "f",
-        Command = sceneHelper.renderable.toggle('PhilaeTrail'),
+        Command = renderableHelper.toggle('Scene.PhilaeTrail'),
         Documentation = "Toggles the visibility of Philae's trail.",
         Local = false
     },
     {
         Key = "p",
-        Command = sceneHelper.property.invert('67P.renderable.ProjectionComponent.performProjection'),
+        Command = propertyHelper.invert('Scene.67P.renderable.ProjectionComponent.performProjection'),
         Documentation = "Enables or disables the image projection on 67P.",
         Local = false
     }
@@ -129,7 +131,7 @@ asset.onInitialize(function ()
         Rotation = { -0.106166, 0.981574, -0.084545, 0.134513 },
     })
 
-    openspace.setPropertyValue('67P.renderable.PerformShading', false);
+    openspace.setPropertyValue('Scene.67P.renderable.PerformShading', false);
 end)
 
 asset.onDeinitialize(function ()
diff --git a/data/assets/scene/digitaluniverse/backgroundradiation.asset b/data/assets/scene/digitaluniverse/backgroundradiation.asset
index 85f10e6393..2652323ae6 100644
--- a/data/assets/scene/digitaluniverse/backgroundradiation.asset
+++ b/data/assets/scene/digitaluniverse/backgroundradiation.asset
@@ -23,7 +23,7 @@ local wmap = {
         Enabled = false,
         Size = 3975.41417036064E23,
         Segments = 80,
-        Alpha = 0.5,
+        Opacity = 0.5,
         Texture = textures .. "/wmap_ilc_7yr_v4_200uK_RGB_sos.png",
         Orientation = "Inside/Outside",
         FadeInThreshould = 8E26
@@ -39,7 +39,7 @@ local cbe = {
         Enabled = false,
         Size = 3975.41417036064E23,
         Segments = 80,
-        Alpha = 0.5,
+        Opacity = 0.5,
         Texture = textures .. "/COBErect.png",
         Orientation = "Inside/Outside",
         FadeInThreshould = 8E26
@@ -54,7 +54,7 @@ local planck = {
         Enabled = false,
         Size = 3975.41417036064E23,
         Segments = 80,
-        Alpha = 0.3,
+        Opacity = 0.3,
         Texture = textures .. "/cmb4k.jpg",
         Orientation = "Inside/Outside",
         FadeInThreshould = 8E26
diff --git a/data/assets/scene/digitaluniverse/milkyway.asset b/data/assets/scene/digitaluniverse/milkyway.asset
index a55dca6ede..cf462f66b0 100644
--- a/data/assets/scene/digitaluniverse/milkyway.asset
+++ b/data/assets/scene/digitaluniverse/milkyway.asset
@@ -29,7 +29,7 @@ local sphere = {
         Type = "RenderableSphere",
         Size = 9.2E20,
         Segments = 40,
-        Alpha = 0.4,
+        Opacity = 0.4,
         Texture = sphereTextures .. "/DarkUniverse_mellinger_4k.jpg",
         Orientation = "Inside/Outside",
         FadeOutThreshould = 0.25
diff --git a/data/assets/scene/milkyway/milkyway/eso.asset b/data/assets/scene/milkyway/milkyway/eso.asset
index cb77f1f655..12bab40860 100644
--- a/data/assets/scene/milkyway/milkyway/eso.asset
+++ b/data/assets/scene/milkyway/milkyway/eso.asset
@@ -15,7 +15,7 @@ local object = {
         Type = "RenderableSphere",
         Size = 9.2E20,
         Segments = 40,
-        Alpha = 0.4,
+        Opacity = 0.4,
         Texture = textures .. "/eso0932a_blend.png",
         Orientation = "Inside/Outside",
         FadeOutThreshould = 0.01
diff --git a/data/assets/scene/solarsystem/missions/osirisrex/osirisrex.asset b/data/assets/scene/solarsystem/missions/osirisrex/osirisrex.asset
index 6d5bff9427..1444106adc 100644
--- a/data/assets/scene/solarsystem/missions/osirisrex/osirisrex.asset
+++ b/data/assets/scene/solarsystem/missions/osirisrex/osirisrex.asset
@@ -2,19 +2,15 @@ asset.request('./bennu')
 asset.request('./model')
 asset.request('./trail')
 
-
+asset.require('./script_schedule')
 
 local mission = asset.localResource('osirisrex.mission')
 local missionName
 
-local scriptSchedule = asset.localResource("scheduled_scripts.lua")
-
 asset.onInitialize(function()
     missionName = openspace.loadMission(mission)
-    openspace.scriptScheduler.loadFile(scriptSchedule)
 end)
 
 asset.onDeinitialize(function()
     openspace.unloadMission(missionName)
-    -- openspace.scriptScheduler.unloadFile
 end)
diff --git a/data/assets/scene/solarsystem/missions/osirisrex/scheduled_scripts.lua b/data/assets/scene/solarsystem/missions/osirisrex/scheduled_scripts.lua
deleted file mode 100644
index 39698b5532..0000000000
--- a/data/assets/scene/solarsystem/missions/osirisrex/scheduled_scripts.lua
+++ /dev/null
@@ -1,14 +0,0 @@
-dofile(openspace.absPath("${SCRIPTS}/common.lua"))
-
-return {
-    helper.scheduledScript.setEnabled("2016 SEP 08 23:05:00", "OsirisRexTrailSolarSystem", false),
-    helper.scheduledScript.setEnabled("2016 SEP 08 23:05:00", "OsirisRexTrailBennu", false),
-
-    helper.scheduledScript.reversible.setEnabled("2016 SEP 08 23:05:01", "OsirisRexTrailEarth", true),
-    helper.scheduledScript.reversible.setEnabled("2016 SEP 09 00:00:00", "OsirisRexTrailSolarSystem", true),
-    helper.scheduledScript.reversible.setEnabled("2016 SEP 09 02:00:00", "OsirisRexTrailEarth", false),
-    helper.scheduledScript.reversible.setEnabled("2018 OCT 11 00:00:00", "OsirisRexTrailBennu", true),
-    helper.scheduledScript.reversible.setEnabled("2018 OCT 15 00:00:00", "OsirisRexTrailSolarSystem", false),
-    helper.scheduledScript.reversible.setEnabled("2019 AUG 01 00:00:00", "OsirisRexTrailSolarSystem", true),
-    helper.scheduledScript.reversible.setEnabled("2019 AUG 01 00:00:00", "OsirisRexTrailBennu", false),
-}
diff --git a/data/assets/scene/solarsystem/missions/osirisrex/script_schedule.asset b/data/assets/scene/solarsystem/missions/osirisrex/script_schedule.asset
new file mode 100644
index 0000000000..147d918cfe
--- /dev/null
+++ b/data/assets/scene/solarsystem/missions/osirisrex/script_schedule.asset
@@ -0,0 +1,18 @@
+local scriptSchedulerHelper = asset.require('util/script_scheduler_helper')
+
+asset.onInitialize(function ()
+    scriptSchedulerHelper.scheduleRenderableEnabled("2016 SEP 08 23:05:00", "OsirisRexTrailSolarSystem", false)
+    scriptSchedulerHelper.scheduleRenderableEnabled("2016 SEP 08 23:05:00", "OsirisRexTrailBennu", false)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2016 SEP 08 23:05:01", "OsirisRexTrailEarth", true)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2016 SEP 09 00:00:00", "OsirisRexTrailSolarSystem", true)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2016 SEP 09 02:00:00", "OsirisRexTrailEarth", false)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2018 OCT 11 00:00:00", "OsirisRexTrailBennu", true)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2018 OCT 15 00:00:00", "OsirisRexTrailSolarSystem", false)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2019 AUG 01 00:00:00", "OsirisRexTrailSolarSystem", true)
+    scriptSchedulerHelper.scheduleRenderableEnabledReversable("2019 AUG 01 00:00:00", "OsirisRexTrailBennu", false)
+end)
+
+
+asset.onDeinitialize(function ()
+	openspace.scriptScheduler.clear()
+end)
\ No newline at end of file
diff --git a/data/assets/scene/solarsystem/planets/earth/earth.asset b/data/assets/scene/solarsystem/planets/earth/earth.asset
index d7e8c4f6e3..f6623a2061 100644
--- a/data/assets/scene/solarsystem/planets/earth/earth.asset
+++ b/data/assets/scene/solarsystem/planets/earth/earth.asset
@@ -16,6 +16,7 @@ local Earth = {
         Type = "RenderableGlobe",
         Radii = earthEllipsoid,
         SegmentsPerPatch = 64,
+        PerformShading = false,
         Layers = {
             ColorLayers = {
                 {
@@ -145,20 +146,10 @@ local Earth = {
                     Name = "Earth at Night 2012",
                     FilePath = mapServiceConfigsPath .. "/GIBS/night/VIIRS_CityLights_2012.wms",
                     Enabled = true,
-                    Settings = {
-                        Opacity = 1.0,
-                        Gamma = 1.5,
-                        Multiplier = 15.0
-                    },
                     Fallback = {
                         Name = "Earth Night",
                         FilePath = texturesPath .. "/earth_night.jpg",
-                        Enabled = true,
-                        Settings = {
-                            Opacity = 1.0,
-                            Gamma = 1.5,
-                            Multiplier = 15.0
-                        },
+                        Enabled = true,                        
                     }
                 },
                 {
diff --git a/data/assets/util/asset_helper.asset b/data/assets/util/asset_helper.asset
index cb70c7b739..bc738cf2e9 100644
--- a/data/assets/util/asset_helper.asset
+++ b/data/assets/util/asset_helper.asset
@@ -93,7 +93,6 @@ local requestAll = function (asset, directory)
        return End=='' or string.sub(String,-string.len(End))==End
     end
 
-    -- directory = asset.localResource('') .. directory
     local files = openspace.walkDirectoryFiles(asset.localResource('') .. directory, true)
     for _, file in pairs(files) do
         if file:ends('.asset') then
diff --git a/data/assets/util/default_keybindings.asset b/data/assets/util/default_keybindings.asset
index 01fcea5ee6..5a8e0b800b 100644
--- a/data/assets/util/default_keybindings.asset
+++ b/data/assets/util/default_keybindings.asset
@@ -1,23 +1,24 @@
-local helper = asset.require('./scene_helper')
+local sceneHelper = asset.require('./scene_helper')
+local propertyHelper = asset.require('./property_helper')
 
 local Keybindings = {
     {
         Key = "F2",
         Command =
-[[local b = openspace.getPropertyValue('Global Properties.ImGUI.Main.Properties.Enabled');
-local c = openspace.getPropertyValue('Global Properties.ImGUI.Main.IsHidden');
-openspace.setPropertyValue('Global Properties.ImGUI.*.Enabled', false);
+[[local b = openspace.getPropertyValue('Modules.ImGUI.Main.Scene Properties.Enabled');
+local c = openspace.getPropertyValue('Modules.ImGUI.Main.IsHidden');
+openspace.setPropertyValue('Modules.ImGUI.*.Enabled', false);
 if b and c then
     -- This can happen if the main properties window is enabled, the main gui is enabled
     -- and then closed again. So the main properties window is enabled, but also all
     -- windows are hidden
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', false);
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.Properties.Enabled', true);
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.Space/Time.Enabled', true);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.IsHidden', false);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.Scene Properties.Enabled', true);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.Space/Time.Enabled', true);
 else
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.Properties.Enabled', not b);
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.Space/Time.Enabled', not b);
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', b);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.Scene Properties.Enabled', not b);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.Space/Time.Enabled', not b);
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.IsHidden', b);
 end]],
         Documentation = "Shows or hides the properties window",
         Local = true
@@ -25,15 +26,15 @@ end]],
     {
         Key = "F3",
         Command = 
-[[local b = openspace.getPropertyValue('Global Properties.ImGUI.Main.Enabled');
-openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.Enabled', not b);
-openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', b);]],
+[[local b = openspace.getPropertyValue('Modules.ImGUI.Main.Enabled');
+openspace.setPropertyValueSingle('Modules.ImGUI.Main.Enabled', not b);
+openspace.setPropertyValueSingle('Modules.ImGUI.Main.IsHidden', b);]],
         Documentation = "Shows or hides the entire user interface",
         Local = true
     },
     {
         Key = "F4",
-        Command = helper.property.invert("RenderEngine.PerformanceMeasurements"),
+        Command = propertyHelper.invert("RenderEngine.PerformanceMeasurements"),
         Documentation = "Toogles performance measurements that shows rendering time informations.",
         Local = true
     },
@@ -57,19 +58,19 @@ openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', b);]],
     },
     {
         Key = "f",
-        Command = helper.property.invert('NavigationHandler.OrbitalNavigator.Friction.RotationalFriction'),
+        Command = propertyHelper.invert('NavigationHandler.OrbitalNavigator.Friction.RotationalFriction'),
         Documentation = "Toggles the rotational friction of the camera. If it is disabled, the camera rotates around the focus object indefinitely.",
         Local = false
     },
     {
         Key = "Shift+f",
-        Command = helper.property.invert('NavigationHandler.OrbitalNavigator.Friction.ZoomFriction'),
+        Command = propertyHelper.invert('NavigationHandler.OrbitalNavigator.Friction.ZoomFriction'),
         Documentation = "Toggles the zoom friction of the camera. If it is disabled, the camera rises up from or closes in towards the focus object indefinitely.",
         Local = false
     },
     {
         Key = "Ctrl+f",
-        Command = helper.property.invert('NavigationHandler.OrbitalNavigator.Friction.RollFriction'),
+        Command = propertyHelper.invert('NavigationHandler.OrbitalNavigator.Friction.RollFriction'),
         Documentation = "Toggles the roll friction of the camera. If it is disabled, the camera rolls around its own axis indefinitely.",
         Local = false
     },
@@ -84,9 +85,9 @@ openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', b);]],
 local DeltaTimeKeys
 
 asset.onInitialize(function()
-    Keys = helper.bindKeys(Keybindings)
+    Keys = sceneHelper.bindKeys(Keybindings)
 
-    DeltaTimeKeys = helper.setDeltaTimeKeys({
+    DeltaTimeKeys = sceneHelper.setDeltaTimeKeys({
     --  1           2           3           4           5           6           7           8           9           0
     --------------------------------------------------------------------------------------------------------------------------
     --  1s          2s          5s          10s         30s         1m          2m          5m          10m         30m
@@ -102,8 +103,8 @@ asset.onInitialize(function()
 end)
 
 asset.onDeinitialize(function ()
-    helper.unbindKeys(Keybindings)
-    helper.unbindKeys(DeltaTimeKeys)
+    sceneHelper.unbindKeys(Keybindings)
+    sceneHelper.unbindKeys(DeltaTimeKeys)
 end)
 
 asset.export("DefaultKeybindings", Keybindings)
diff --git a/data/assets/util/property_helper.asset b/data/assets/util/property_helper.asset
new file mode 100644
index 0000000000..8d3576d130
--- /dev/null
+++ b/data/assets/util/property_helper.asset
@@ -0,0 +1,21 @@
+-- Function that returns the string that inverts the fully qualified boolean property 'property'
+local invert = function(prop)
+    local escaped_property = "'" .. prop .. "'"
+    return "openspace.setPropertyValue(" .. escaped_property .. ", not openspace.getPropertyValue(" .. escaped_property .. "));"
+end
+
+-- Function that returns the string that increments the 'property' by the 'value'
+local increment = function(prop, value)
+    local v = value or 1
+    local escaped_property = "'" .. prop .. "'"
+    return "openspace.setPropertyValue(" .. escaped_property .. ", openspace.getPropertyValue(" .. escaped_property .. ") + " .. v .. ");"
+end
+
+-- Function that returns the string that decrements the 'property' by the 'value'
+local decrement = function(prop, value)
+    return increment(prop, -value)
+end
+
+asset.export('invert', invert)
+asset.export('increment', increment)
+asset.export('decrement', decrement)
diff --git a/data/assets/util/renderable_helper.asset b/data/assets/util/renderable_helper.asset
new file mode 100644
index 0000000000..300e66a574
--- /dev/null
+++ b/data/assets/util/renderable_helper.asset
@@ -0,0 +1,15 @@
+local propertyHelper = asset.require('./property_helper')
+
+-- Function that returns the string that enables/disables the renderable 'renderable'
+local toggle = function(renderable)
+    return propertyHelper.invert(renderable .. ".renderable.Enabled")
+end
+
+-- Function that returns the string that sets the enabled property of <renderable> to <enabled>
+local setEnabled = function(renderable, enabled)
+    return "openspace.setPropertyValue('" .. renderable .. ".renderable.Enabled', " .. (enabled and "true" or "false") .. ");";
+end
+
+
+asset.export('toggle', toggle)
+asset.export('setEnabled', setEnabled)
\ No newline at end of file
diff --git a/data/assets/util/scene_helper.asset b/data/assets/util/scene_helper.asset
index fa84befc03..45139ec6c6 100644
--- a/data/assets/util/scene_helper.asset
+++ b/data/assets/util/scene_helper.asset
@@ -52,11 +52,3 @@ local setDeltaTimeKeys = function(t)
     return result
 end
 asset.export("setDeltaTimeKeys", setDeltaTimeKeys)
-
------------------------------------------------------------------
-
-dofile(openspace.absPath("${SCRIPTS}/common.lua"))
-
-asset.export("property", helper.property)
-asset.export("renderable", helper.renderable)
-asset.export("scheduledScript", helper.scheduledScript)
diff --git a/data/assets/util/script_scheduler_helper.asset b/data/assets/util/script_scheduler_helper.asset
new file mode 100644
index 0000000000..4a3727b9b3
--- /dev/null
+++ b/data/assets/util/script_scheduler_helper.asset
@@ -0,0 +1,24 @@
+local renderableHelper = asset.require('./renderable_helper')
+
+-- Function that schedules scripts setting the enabled property 
+-- of <renderable> to <enabled> at time <time>.
+local scheduleRenderableEnabled = function(time, renderable, enabled)
+    openspace.scriptScheduler.loadScheduledScript(
+        time,
+        renderableHelper.setEnabled(renderable, enabled)
+    )
+end
+
+-- Function that schedules scripts setting the enabled property 
+-- of <renderable> to <enabled> when time <time> is passed
+-- and inverts it if time is passed in reversed order.
+local scheduleRenderableEnabledReversable = function(time, renderable, enabled)
+    openspace.scriptScheduler.loadScheduledScript(
+        time,
+        renderableHelper.setEnabled(renderable, enabled),
+        renderableHelper.setEnabled(renderable, not enabled)
+    )
+end
+
+asset.export('scheduleRenderableEnabledReversable', scheduleRenderableEnabledReversable)
+asset.export('scheduleRenderableEnabled', scheduleRenderableEnabled)
diff --git a/data/web/common/base.js b/data/web/common/base.js
new file mode 100644
index 0000000000..b362bc94fc
--- /dev/null
+++ b/data/web/common/base.js
@@ -0,0 +1,4 @@
+function parseJson(elementId) {
+  var jsonElement = document.getElementById(elementId);
+  return JSON.parse(jsonElement.innerHTML);
+}
diff --git a/data/web/common/style.css b/data/web/common/style.css
index f785e54ff7..b22e07cb61 100644
--- a/data/web/common/style.css
+++ b/data/web/common/style.css
@@ -8,25 +8,40 @@
 
 .documentation-item {
   background-color: #f4f4f4;
-  border-left: 2px solid #888;
+  border-left: 6px solid;
   padding-left: 10px;
   padding-top: 5px;
   padding-right: 5px;
   margin-bottom: 5px;
 }
 
-.documentation-item .documentation-item {
-  border-left: 2px solid #f00;
-  background-color: #fff;
-}
-
-.documentation-item .documentation-item .documentation-item {
-  border-left: 2px solid #080;
+.item-level-1 {
+  border-color: #343C47;
   background-color: #f4f4f4;
 }
 
-.documentation-item .documentation-item .documentation-item .documentation-item {
-  border-left: 2px solid #00f;
+.item-level-2 {
+  border-color: #505760;
+  background-color: #fff;
+}
+
+.item-level-3 {
+  border-color: #5E6C7C;
+  background-color: #f4f4f4;
+}
+
+.item-level-4 {
+  border-color: #537399;
+  background-color: #fff;
+}
+
+.item-level-5 {
+  border-color: #2569BA;
+  background-color: #f4f4f4;
+}
+
+.item-level-6 {
+  border-color: #208AE2;
   background-color: #fff;
 }
 
@@ -69,16 +84,15 @@
   font-size: 0.8em;
 }
 
-
 /*!
  * Start Bootstrap - Simple Sidebar (http://startbootstrap.com/)
  * Copyright 2013-2016 Start Bootstrap
  * Licensed under MIT (https://github.com/BlackrockDigital/startbootstrap/blob/gh-pages/LICENSE)
  */
 
- body {
-    overflow-x: hidden;
- }
+body {
+  overflow-x: hidden;
+}
 
 /* Toggle Styles */
 
diff --git a/data/web/documentation/documentation.hbs b/data/web/documentation/documentation.hbs
index 2b7bbbd84d..b22165447b 100644
--- a/data/web/documentation/documentation.hbs
+++ b/data/web/documentation/documentation.hbs
@@ -1,5 +1,5 @@
 {{#each entries}}
-  <div class="documentation-item">
+  <div class="documentation-item item-level-{{level name}}">
     <div class="row">
       <div class="col-lg-12">
         <p>
diff --git a/data/web/documentation/script.js b/data/web/documentation/script.js
index f9af37e558..00bd699b00 100644
--- a/data/web/documentation/script.js
+++ b/data/web/documentation/script.js
@@ -18,6 +18,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   documentation.sort(function (a, b) {
     return a.name < b.name ? -1 : (a.name > b.name ? 1 : 0);
   });
diff --git a/data/web/factories/factory.hbs b/data/web/factories/factory.hbs
index ea23b014fc..7c73a9462f 100644
--- a/data/web/factories/factory.hbs
+++ b/data/web/factories/factory.hbs
@@ -1,5 +1,5 @@
 {{#each classes}}
-  <div class="documentation-item">
+  <div class="documentation-item item-level-{{level name}}">
     <div class="row">
       <div class="col-lg-12">
         <p>
diff --git a/data/web/factories/script.js b/data/web/factories/script.js
index 4776d5656e..02322b7f3e 100644
--- a/data/web/factories/script.js
+++ b/data/web/factories/script.js
@@ -18,6 +18,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   factories.sort(function (a, b) {
     return a.name < b.name ? -1 : (a.name > b.name ? 1 : 0);
   });
diff --git a/data/web/kameleondocumentation/script.js b/data/web/kameleondocumentation/script.js
index 84f9665e59..5fb0baf75f 100644
--- a/data/web/kameleondocumentation/script.js
+++ b/data/web/kameleondocumentation/script.js
@@ -15,6 +15,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   var dataElement = document.getElementById('data');
   var data = JSON.parse(dataElement.innerHTML);
 
diff --git a/data/web/keybindings/keybinding.hbs b/data/web/keybindings/keybinding.hbs
index 4873cdef05..cca289cb31 100644
--- a/data/web/keybindings/keybinding.hbs
+++ b/data/web/keybindings/keybinding.hbs
@@ -1,11 +1,11 @@
-<div class="documentation-item {{#if remoteScripting}}remote-scripting{{else}}local-scripting{{/if}}">
+<div class="documentation-item item-level-{{level name}} {{#if remoteScripting}}remote-scripting{{else}}local-scripting{{/if}}">
   <div class="row">
     <div class="col-lg-12">
       <p>
         <a href="#{{urlify key}}" name="{{urlify key}}">
           <span class="documentation-key">{{key}}</span> <span class="documentation-type">{{#if remoteScripting}}Remote scripting{{else}}Local scripting{{/if}}</span>
         </a>
-        <p>{{script}}</p>
+        <p><code>{{script}}</code></p>
         <p>{{documentation}}</p>
       </p>
     </div>
diff --git a/data/web/keybindings/script.js b/data/web/keybindings/script.js
index 16e3aa580b..018d49eb48 100644
--- a/data/web/keybindings/script.js
+++ b/data/web/keybindings/script.js
@@ -18,6 +18,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   keybindings.sort(function (a, b) {
     return a.key < b.key ? -1 : (a.key > b.key ? 1 : 0);
   });
diff --git a/data/web/luascripting/script.js b/data/web/luascripting/script.js
index 6d43a33b07..da7dede2e4 100644
--- a/data/web/luascripting/script.js
+++ b/data/web/luascripting/script.js
@@ -18,6 +18,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   scripting.sort(function (a, b) {
     return a.library < b.library ? -1 : (a.library > b.library ? 1 : 0);
   });
diff --git a/data/web/luascripting/scripting.hbs b/data/web/luascripting/scripting.hbs
index 00313e3372..00e35ab6d4 100644
--- a/data/web/luascripting/scripting.hbs
+++ b/data/web/luascripting/scripting.hbs
@@ -1,5 +1,5 @@
 {{#each functions}}
-  <div class="documentation-item">
+  <div class="documentation-item item-level-{{level name}}">
     <div class="row">
       <div class="col-lg-12">
         <p>
diff --git a/data/web/properties/main.hbs b/data/web/properties/main.hbs
index f62398d2bb..ae6024b98f 100644
--- a/data/web/properties/main.hbs
+++ b/data/web/properties/main.hbs
@@ -3,7 +3,7 @@
     <ul class="sidebar-nav">
       <li class="sidebar-brand">
         <a href="#">
-            OpenSpace Scene Properties
+            OpenSpace Properties
         </a>
       </li>
       {{#each propertyOwners}}
@@ -28,8 +28,6 @@
             {{/each}}
             {{#each propertyOwners}}
               {{> propertyOwner}}
-            {{else}}
-              <p>{{name}} has no property owners</p>
             {{/each}}
           </div>
         </div>
diff --git a/data/web/properties/property.hbs b/data/web/properties/property.hbs
index 7a0bd7a430..51dd8ec75c 100644
--- a/data/web/properties/property.hbs
+++ b/data/web/properties/property.hbs
@@ -1,4 +1,4 @@
-<div class="documentation-item">
+<div class="documentation-item item-level-{{level name}}">
   <div class="row">
     <div class="col-lg-12" title="{{guiName}}">
       <p>
@@ -7,7 +7,8 @@
           <span class="documentation-key">{{id}}</span>
         </a>
       </p>
-      <p class="documentation-description">{{fullyQualifiedId}}
+      <p class="documentation-description">
+        <code>{{fullyQualifiedId}}</code>
         <a class="documentation-small" onclick="copyTextToClipboard('{{fullyQualifiedId}}')">copy</a>
       </p>
       <p class="documentation-documentation">{{description}}</p>
diff --git a/data/web/properties/propertyowner.hbs b/data/web/properties/propertyowner.hbs
index 9d0885e0a1..2417eceaf3 100644
--- a/data/web/properties/propertyowner.hbs
+++ b/data/web/properties/propertyowner.hbs
@@ -1,4 +1,4 @@
-<div class="documentation-item">
+<div class="documentation-item item-level-{{level name}}">
   <div class="row">
     <div class="col-lg-12">
       <p>
diff --git a/data/web/properties/script.js b/data/web/properties/script.js
index d63ced4110..642d860c05 100644
--- a/data/web/properties/script.js
+++ b/data/web/properties/script.js
@@ -46,6 +46,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   propertyOwners.sort(function (a, b) {
     return a.name < b.name ? -1 : (a.name > b.name ? 1 : 0);
   });
diff --git a/data/web/scenelicense/script.js b/data/web/scenelicense/script.js
index e0594d2829..9e1e815d80 100644
--- a/data/web/scenelicense/script.js
+++ b/data/web/scenelicense/script.js
@@ -18,6 +18,19 @@ window.onload = function () {
     return identifier;
   });
 
+  Handlebars.registerHelper('level', function(options, context) {
+    var data = context.data;
+    var level = 0;
+
+    while (data = data._parent) {
+      if (data.key !== undefined) {
+        ++level;
+      }
+    }
+
+    return level;
+  });
+
   var data = {
     sceneLicenses: sceneLicenses,
     version: version
diff --git a/ext/ghoul b/ext/ghoul
index 94d740353e..a796b61604 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit 94d740353ecfee60fc64d9364831bef7c92f4066
+Subproject commit a796b61604af408329f5b605d39fe8b56b46df8a
diff --git a/include/openspace/engine/configurationmanager.h b/include/openspace/engine/configurationmanager.h
index b73e823475..cd6735ab3d 100644
--- a/include/openspace/engine/configurationmanager.h
+++ b/include/openspace/engine/configurationmanager.h
@@ -42,135 +42,196 @@ namespace documentation {  struct Documentation; }
 class ConfigurationManager : public ghoul::Dictionary {
 public:
     /// The key that stores the subdirectory containing all predefined path tokens
-    static const std::string KeyPaths;
+    static constexpr const char* KeyPaths = "Paths";
+
     /// The key that stores the location to the cache directory used to store all the
     /// permanent and non-permanent cached files
-    static const std::string KeyCache;
+    static constexpr const char* KeyCachePath = "Paths.CACHE";
+
     /// The key that stores the main directory for fonts
-    static const std::string KeyFonts;
+    static constexpr const char* KeyFonts = "Fonts";
+
     /// The key that stores the location of the SGCT configuration file that is used on
     /// application launch
-    static const std::string KeyConfigSgct;
+    static constexpr const char* KeyConfigSgct = "SGCTConfig";
+
     /// The key that defines a list of scripts for global customization that get executed
     /// regardless of which scene is loaded
-    static const std::string KeyGlobalCustomizationScripts;
+    static constexpr const char* KeyGlobalCustomizationScripts =
+                                                             "GlobalCustomizationScripts";
+
     /// The part of the key that defines the type
-    static const std::string PartType;
+    // static constexpr const char* PartType = "Type";
     /// The part of the key that defines the file
-    static const std::string PartFile;
+    // static constexpr const char* PartFile = "File";
+
     /// The key that stores the Lua documentation
-    static const std::string KeyLuaDocumentation;
+    static constexpr const char* KeyLuaDocumentation = "LuaDocumentation";
+
     /// The key that stores the scripting log
-    static const std::string KeyScriptLog;
-    /// The key that stores the Property documentation
-    static const std::string KeyPropertyDocumentation;
+    static constexpr const char* KeyScriptLog = "ScriptLog";
+
+    /// The key that stores the Scene Property documentation
+    static constexpr const char* KeyScenePropertyDocumentation =
+                                                             "ScenePropertyDocumentation";
+
+    /// The key that stores the Root Property documentation
+    static constexpr const char* KeyPropertyDocumentation = "PropertyDocumentation";
+
     /// The key that stores the keyboard bindings that should be stored
-    static const std::string KeyKeyboardShortcuts;
+    static constexpr const char* KeyKeyboardShortcuts = "KeyboardShortcuts";
+
     /// The key that stores the main documentation
-    static const std::string KeyDocumentation;
+    static constexpr const char* KeyDocumentation = "Documentation";
+
     /// The key that stores the factory documentation values
-    static const std::string KeyFactoryDocumentation;
+    static constexpr const char* KeyFactoryDocumentation = "FactoryDocumentation";
+
     /// The key that stores the location of the asset file that is initially loaded
-    static const std::string KeyConfigAsset;
+    static constexpr const char* KeyConfigAsset = "Asset";
+
     /// The key that stores the scene license documentation values
-    static const std::string KeySceneLicenseDocumentation;
-    /// The key that stores the subdirectory containing a list of all startup scripts to
-    /// be executed on application start before the scene file is loaded
-    static const std::string KeyStartupScript;
-    /// The key that stores the subdirectory containing a list of all settings scripts to
-    /// be executed on application start and after the scene file is loaded
-    static const std::string KeySettingsScript;
+    static constexpr const char* KeySceneLicenseDocumentation = "LicenseDocumentation";
+
     /// The key that stores the settings for determining log-related settings
-    static const std::string KeyLogging;
+    static constexpr const char* KeyLogging = "Logging";
+
     /// The key that stores the directory for Logging
-    static const std::string PartLogDir;
+    static constexpr const char* LoggingDirectory = "Logging.LogDir";
+    static constexpr const char* PartLogDir = "LogDir";
+
     /// The key that stores the desired LogLevel for the whole application
     /// \sa ghoul::logging::LogManager
-    static const std::string PartLogLevel;
+    static constexpr const char* KeyLoggingLogLevel = "Logging.LogLevel";
+    static constexpr const char* PartLogLevel = "LogLevel";
+
     /// The key that stores whether the log should be immediately flushed after a n
     /// \sa ghoul::logging::LogManager
-    static const std::string PartImmediateFlush;
+    static constexpr const char* KeyLoggingImmediateFlush = "Logging.ImmediateFlush";
+    static constexpr const char* PartImmediateFlush = "ImmediateFlush";
+
     /// The key for prefixing PerformanceMeasurement logfiles
-    static const std::string PartLogPerformancePrefix;
+    static constexpr const char* LoggingPerformancePrefix = "Logging.PerformancePrefix";
+    static constexpr const char* PartLogPerformancePrefix = "PerformancePrefix";
     /// The key that stores a subdirectory with a description for additional
     /// ghoul::logging::Log%s to be created
     /// \sa LogFactory
-    static const std::string PartLogs;
+    static constexpr const char* KeyLoggingLogs = "Logging.Logs";
+    static constexpr const char* PartLogs = "Logs";
+
     /// The key that stores whether a log should be appended to or should be overwritten
-    static const std::string PartAppend;
+    static constexpr const char* PartAppend = "Append";
+
     /// The key that stores the verbosity (None, Minimal, Default, Full) of the system
     /// capabilities components
-    static const std::string PartCapabilitiesVerbosity;
+    static constexpr const char* PartCapabilitiesVerbosity = "CapabilitiesVerbosity";
+
     /// The key that stores the settings for determining Launcher-related settings
-    static const std::string KeyLauncher;
+    static constexpr const char* KeyLauncher = "Launcher";
+
     /// The full key that stores the verbosity of the system capabilities component
-    static const std::string KeyCapabilitiesVerbosity;
+    static constexpr const char* KeyCapabilitiesVerbosity =
+                                                          "Logging.CapabilitiesVerbosity";
+
     /// The key that stores the time (in seconds) that the application will wait before
     /// shutting down after the shutdown call is made
-    static const std::string KeyShutdownCountdown;
+    static constexpr const char* KeyShutdownCountdown = "ShutdownCountdown";
+
     /// The key that stores whether the onscreen text should be scaled to the window size
     /// or the window resolution
-    static const std::string KeyOnScreenTextScaling;
+    static constexpr const char* KeyOnScreenTextScaling = "OnScreenTextScaling";
+
     /// The key that stores whether the master node should perform rendering just function
     /// as a pure manager
-    static const std::string KeyDisableMasterRendering;
+    static constexpr const char* KeyDisableMasterRendering = "DisableRenderingOnMaster";
+
     /// The key that stores whether the master node should apply the scene transformation
-    static const std::string KeyDisableSceneOnMaster;
+    static constexpr const char* KeyDisableSceneOnMaster = "DisableSceneOnMaster";
+
     /// The key that stores the switch for enabling/disabling the rendering on a master
     /// computer
-    static const std::string KeyRenderingMethod;
+    static constexpr const char* KeyRenderingMethod = "RenderingMethod";
+
     /// The key that determines whether a new cache folder is used for each scene file
-    static const std::string KeyPerSceneCache;
+    static constexpr const char* KeyPerSceneCache = "PerSceneCache";
+
     /// The key that stores the http proxy settings for the downloadmanager
-    static const std::string KeyHttpProxy;
+    static constexpr const char* KeyHttpProxy = "HttpProxy";
+
     /// The key that stores the address of the http proxy
-    static const std::string PartHttpProxyAddress;
+    static constexpr const char* PartHttpProxyAddress = "Address";
+
     /// The key that stores the port of the http proxy
-    static const std::string PartHttpProxyPort;
+    static constexpr const char* PartHttpProxyPort = "Port";
+
     /// The key that stores the authentication method of the http proxy
-    static const std::string PartHttpProxyAuthentication;
+    static constexpr const char* PartHttpProxyAuthentication = "Authentication";
+
     /// Key that stores the username to use for authentication to access the http proxy
-    static const std::string PartHttpProxyUser;
+    static constexpr const char* PartHttpProxyUser = "User";
+
     /// Key that stores the password to use for authentication to access the http proxy
-    static const std::string PartHttpProxyPassword;
+    static constexpr const char* PartHttpProxyPassword = "Password";
+
     /// The key that stores the dictionary containing information about debug contexts
-    static const std::string KeyOpenGLDebugContext;
+    static constexpr const char* KeyOpenGLDebugContext = "OpenGLDebugContext";
+
     /// The part of the key storing whether an OpenGL Debug context should be created
-    static const std::string PartActivate;
+    static constexpr const char* PartActivate = "Activate";
+
     /// The part of the key storing whether the debug callbacks are performed synchronous
-    static const std::string PartSynchronous;
+    static constexpr const char* PartSynchronous = "Synchronous";
+
     /// The part of the key storing a list of identifiers that should be filtered out
-    static const std::string PartFilterIdentifier;
+    static constexpr const char* PartFilterIdentifier = "FilterIdentifier";
+
     /// The part of the key that stores the source of the ignored identifier
-    static const std::string PartFilterIdentifierSource;
+    static constexpr const char* PartFilterIdentifierSource = "Source";
+
     /// The part of the key that stores the type of the ignored identifier
-    static const std::string PartFilterIdentifierType;
+    static constexpr const char* PartFilterIdentifierType = "Type";
+
     /// The part of the key that stores the identifier of the ignored identifier
-    static const std::string PartFilterIdentifierIdentifier;
+    static constexpr const char* PartFilterIdentifierIdentifier = "Identifier";
+
     /// The part of the key storing a list of severities that should be filtered out
-    static const std::string PartFilterSeverity;
+    static constexpr const char* PartFilterSeverity = "PartFilterSeverity";
+
     /// The part of the key storing whether the OpenGL state should be checked each call
-    static const std::string KeyCheckOpenGLState;
+    static constexpr const char* KeyCheckOpenGLState = "CheckOpenGLState";
+
     /// The part of the key storing whether each OpenGL call should be logged
-    static const std::string KeyLogEachOpenGLCall;
+    static constexpr const char* KeyLogEachOpenGLCall = "LogEachOpenGLCall";
 
     /// This key determines whether the scene graph nodes should initialized multithreaded
-    static const std::string KeyUseMultithreadedInitialization;
+    static constexpr const char* KeyUseMultithreadedInitialization =
+                                                         "UseMultithreadedInitialization";
 
     /// The key under which all of the loading settings are grouped
-    static const std::string KeyLoadingScreen;
+    static constexpr const char* KeyLoadingScreen = "LoadingScreen";
+
     /// The part of the key storing whether the loading screen should display the message
     /// about current status
-    static const std::string PartShowMessage;
+    static constexpr const char* KeyLoadingScreenShowMessage =
+                                                              "LoadingScreen.ShowMessage";
+    static constexpr const char* PartShowMessage = "ShowMessage";
+
     /// The part of the key storing whether the loading screen should display node names
-    static const std::string PartShowNodeNames;
+    static constexpr const char* KeyLoadingScreenShowNodeNames =
+                                                            "LoadingScreen.ShowNodeNames";
+    static constexpr const char* PartShowNodeNames = "ShowNodeNames";
+
     /// The part of the key storing whether the loading screen should contain a progress
     /// bar
-    static const std::string PartShowProgressbar;
+    static constexpr const char* KeyLoadingScreenShowProgressbar =
+                                                          "LoadingScreen.ShowProgressbar";
+    static constexpr const char* PartShowProgressbar = "ShowProgressbar";
+
     /// The key used to specify module specific configurations
-    static const std::string KeyModuleConfigurations;
+    static constexpr const char* KeyModuleConfigurations = "ModuleConfigurations";
+
     /// The key used to specify whether screenshots should contain the current date
-    static const std::string KeyScreenshotUseDate;
+    static constexpr const char* KeyScreenshotUseDate = "ScreenshotUseDate";
 
 
     /**
@@ -200,6 +261,7 @@ public:
      */
     void loadFromFile(const std::string& filename);
 
+
     static documentation::Documentation Documentation();
 };
 
diff --git a/include/openspace/engine/moduleengine.h b/include/openspace/engine/moduleengine.h
index 7acd98dbe2..547f6e5c2c 100644
--- a/include/openspace/engine/moduleengine.h
+++ b/include/openspace/engine/moduleengine.h
@@ -28,6 +28,7 @@
 #include <memory>
 #include <vector>
 
+#include <openspace/properties/propertyowner.h>
 #include <openspace/util/openspacemodule.h>
 
 #include <ghoul/misc/assert.h>
@@ -47,8 +48,10 @@ namespace scripting { struct LuaLibrary; }
  * Additional OpenSpaceModule%s can be registered with the #registerModule function, which
  * will internally call the OpenSpaceModule::initialize method.
  */
-class ModuleEngine {
+class ModuleEngine : public properties::PropertyOwner {
 public:
+    ModuleEngine();
+
     /**
      * Registers all of the OpenSpaceModule%s which are created by the CMake configuration
      * and stored in the <code>moduleregistration.h</code> file. For all of those modules
diff --git a/include/openspace/engine/openspaceengine.h b/include/openspace/engine/openspaceengine.h
index 33d40baead..29d46fcadf 100644
--- a/include/openspace/engine/openspaceengine.h
+++ b/include/openspace/engine/openspaceengine.h
@@ -55,7 +55,6 @@ class ParallelConnection;
 class RenderEngine;
 class Scene;
 class SyncEngine;
-class SettingsEngine;
 class TimeManager;
 class VirtualPropertyManager;
 class WindowWrapper;
@@ -131,12 +130,12 @@ public:
     NetworkEngine& networkEngine();
     ParallelConnection& parallelConnection();
     RenderEngine& renderEngine();
-    SettingsEngine& settingsEngine();
     TimeManager& timeManager();
     WindowWrapper& windowWrapper();
     ghoul::fontrendering::FontManager& fontManager();
     interaction::NavigationHandler& navigationHandler();
     interaction::KeyBindingManager& keyBindingManager();
+    properties::PropertyOwner& rootPropertyOwner();
     properties::PropertyOwner& globalPropertyOwner();
     scripting::ScriptEngine& scriptEngine();
     scripting::ScriptScheduler& scriptScheduler();
@@ -215,7 +214,6 @@ private:
     std::unique_ptr<NetworkEngine> _networkEngine;
     std::unique_ptr<ParallelConnection> _parallelConnection;
     std::unique_ptr<RenderEngine> _renderEngine;
-    std::unique_ptr<SettingsEngine> _settingsEngine;
     std::unique_ptr<SyncEngine> _syncEngine;
     std::unique_ptr<TimeManager> _timeManager;
     std::unique_ptr<WindowWrapper> _windowWrapper;
@@ -229,7 +227,8 @@ private:
     std::unique_ptr<VirtualPropertyManager> _virtualPropertyManager;
 
     // Others
-    std::unique_ptr<properties::PropertyOwner> _globalPropertyNamespace;
+    std::unique_ptr<properties::PropertyOwner> _rootPropertyOwner;
+    std::unique_ptr<properties::PropertyOwner> _globalPropertyOwner;
 
     std::unique_ptr<LoadingScreen> _loadingScreen;
 
diff --git a/include/openspace/engine/settingsengine.h b/include/openspace/engine/settingsengine.h
deleted file mode 100644
index d292a57947..0000000000
--- a/include/openspace/engine/settingsengine.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2018                                                               *
- *                                                                                       *
- * 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.                                         *
- ****************************************************************************************/
-
-#ifndef __OPENSPACE_CORE___SETTINGSENGINE___H__
-#define __OPENSPACE_CORE___SETTINGSENGINE___H__
-
-#include <openspace/properties/propertyowner.h>
-
-#include <openspace/properties/optionproperty.h>
-#include <openspace/properties/scalar/boolproperty.h>
-#include <openspace/properties/scalar/floatproperty.h>
-
-#include <vector>
-
-namespace openspace {
-
-class OpenSpaceModule;
-
-class SettingsEngine : public properties::PropertyOwner {
-public:
-    SettingsEngine();
-
-    void initialize();
-
-    void setModules(const std::vector<OpenSpaceModule*>& modules);
-
-private:
-    properties::OptionProperty _scenes;
-};
-
-} // namespace openspace
-
-#endif // __OPENSPACE_CORE___SETTINGSENGINE___H__
diff --git a/include/openspace/properties/numericalproperty.h b/include/openspace/properties/numericalproperty.h
index 12cec0e4e3..d342599fae 100644
--- a/include/openspace/properties/numericalproperty.h
+++ b/include/openspace/properties/numericalproperty.h
@@ -64,6 +64,15 @@ public:
 
     using TemplateProperty<T>::operator=;
 
+
+    void setInterpolationTarget(ghoul::any value) override;
+    void setLuaInterpolationTarget(lua_State* state) override;
+    void setStringInterpolationTarget(std::string value) override;
+    
+    void interpolateValue(float t,
+        ghoul::EasingFunc<float> easingFunc = nullptr) override;
+
+
 protected:
     static const std::string MinimumValueKey;
     static const std::string MaximumValueKey;
@@ -76,6 +85,9 @@ protected:
     T _maximumValue;
     T _stepping;
     float _exponent;
+
+    T _interpolationStart;
+    T _interpolationEnd;
 };
 
 } // namespace openspace::properties
diff --git a/include/openspace/properties/numericalproperty.inl b/include/openspace/properties/numericalproperty.inl
index edfbcddbbd..967c700300 100644
--- a/include/openspace/properties/numericalproperty.inl
+++ b/include/openspace/properties/numericalproperty.inl
@@ -395,4 +395,62 @@ std::string NumericalProperty<T>::generateAdditionalDescription() const {
     return result;
 }
 
+template <typename T>
+void NumericalProperty<T>::setInterpolationTarget(ghoul::any value) {
+    try {
+        T v = ghoul::any_cast<T>(std::move(value));
+
+        _interpolationStart = TemplateProperty<T>::_value;
+        _interpolationEnd = std::move(v);
+    }
+    catch (ghoul::bad_any_cast&) {
+        LERRORC(
+            "TemplateProperty",
+            fmt::format(
+                "Illegal cast from '{}' to '{}'",
+                value.type().name(),
+                typeid(T).name()
+            )
+        );
+    }
+}
+
+template <typename T>
+void NumericalProperty<T>::setLuaInterpolationTarget(lua_State* state) {
+    bool success = false;
+    T thisValue = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(
+        state,
+        success
+    );
+    if (success) {
+        _interpolationStart = TemplateProperty<T>::_value;
+        _interpolationEnd = std::move(thisValue);
+    }
+}
+
+template <typename T>
+void NumericalProperty<T>::setStringInterpolationTarget(std::string value) {
+    bool success = false;
+    T thisValue = PropertyDelegate<NumericalProperty<T>>::template fromString<T>(
+        value,
+        success
+    );
+    if (success) {
+        _interpolationStart = TemplateProperty<T>::_value;
+        _interpolationEnd = std::move(thisValue);
+    }
+}
+
+template <typename T>
+void NumericalProperty<T>::interpolateValue(float t,
+                                            ghoul::EasingFunc<float> easingFunction)
+{
+    if (easingFunction) {
+        t = easingFunction(t);
+    }
+    TemplateProperty<T>::setValue(static_cast<T>(
+        glm::mix(_interpolationStart, _interpolationEnd, t)
+    ));
+}
+
 } // namespace openspace::properties
diff --git a/include/openspace/properties/property.h b/include/openspace/properties/property.h
index e3e393a243..4031f506a0 100644
--- a/include/openspace/properties/property.h
+++ b/include/openspace/properties/property.h
@@ -28,6 +28,7 @@
 #include <openspace/properties/propertydelegate.h>
 
 #include <ghoul/misc/dictionary.h>
+#include <ghoul/misc/easing.h>
 
 #include <functional>
 #include <string>
@@ -364,6 +365,15 @@ public:
      */
     const ghoul::Dictionary& metaData() const;
 
+
+    /// Interpolation methods
+    virtual void setInterpolationTarget(ghoul::any value);
+    virtual void setLuaInterpolationTarget(lua_State* state);
+    virtual void setStringInterpolationTarget(std::string value);
+    
+    virtual void interpolateValue(float t,
+        ghoul::EasingFunc<float> easingFunction = nullptr);
+
 protected:
     static const char* IdentifierKey;
     static const char* NameKey;
diff --git a/include/openspace/properties/propertyowner.h b/include/openspace/properties/propertyowner.h
index a2c2430886..4bcfac0b75 100644
--- a/include/openspace/properties/propertyowner.h
+++ b/include/openspace/properties/propertyowner.h
@@ -25,6 +25,8 @@
 #ifndef __OPENSPACE_CORE___PROPERTYOWNER___H__
 #define __OPENSPACE_CORE___PROPERTYOWNER___H__
 
+#include <openspace/documentation/documentationgenerator.h>
+
 #include <map>
 #include <string>
 #include <vector>
@@ -47,7 +49,7 @@ class Property;
  * URI contains separators (<code>.</code>), the first name before the separator will be
  * used as a subOwner's name and the search will proceed recursively.
  */
-class PropertyOwner {
+class PropertyOwner : public DocumentationGenerator {
 public:
     /// The separator that is used while accessing the properties and/or sub-owners
     static const char URISeparator = '.';
@@ -238,6 +240,8 @@ public:
     void removeTag(const std::string& tag);
 
 private:
+    std::string generateJson() const override;
+
     /// The name of this PropertyOwner
     std::string _name;
     /// The description for this PropertyOwner
diff --git a/include/openspace/properties/templateproperty.inl b/include/openspace/properties/templateproperty.inl
index 3da6579016..fc9f6c59ca 100644
--- a/include/openspace/properties/templateproperty.inl
+++ b/include/openspace/properties/templateproperty.inl
@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/fmt.h>
 
 namespace openspace::properties {
 
@@ -202,8 +203,14 @@ void TemplateProperty<T>::set(ghoul::any value) {
         }
     }
     catch (ghoul::bad_any_cast&) {
-        LERRORC("TemplateProperty", "Illegal cast from '" << value.type().name()
-            << "' to '" << typeid(T).name() << "'");
+        LERRORC(
+            "TemplateProperty",
+            fmt::format(
+                "Illegal cast from '{}' to '{}'",
+                value.type().name(),
+                typeid(T).name()
+            )
+        );
     }
 }
 
diff --git a/include/openspace/rendering/dashboard.h b/include/openspace/rendering/dashboard.h
index 3f78c366d2..848f12513d 100644
--- a/include/openspace/rendering/dashboard.h
+++ b/include/openspace/rendering/dashboard.h
@@ -27,10 +27,9 @@
 
 #include <openspace/properties/propertyowner.h>
 
+#include <openspace/properties/scalar/boolproperty.h>
 #include <openspace/rendering/dashboarditem.h>
-
 #include <ghoul/glm.h>
-
 #include <memory>
 #include <vector>
 
@@ -59,6 +58,8 @@ public:
     static scripting::LuaLibrary luaLibrary();
 
 private:
+    properties::BoolProperty _isEnabled;
+
     std::vector<std::unique_ptr<DashboardItem>> _items;
 };
 
diff --git a/include/openspace/rendering/renderable.h b/include/openspace/rendering/renderable.h
index 2069bd23c3..575045be36 100644
--- a/include/openspace/rendering/renderable.h
+++ b/include/openspace/rendering/renderable.h
@@ -28,6 +28,7 @@
 #include <openspace/properties/propertyowner.h>
 
 #include <openspace/properties/scalar/boolproperty.h>
+#include <openspace/properties/scalar/floatproperty.h>
 
 namespace ghoul { class Dictionary; }
 namespace ghoul::opengl {
@@ -99,6 +100,9 @@ public:
 
 protected:
     properties::BoolProperty _enabled;
+    properties::FloatProperty _opacity;
+    
+    void registerUpdateRenderBinFromOpacity();
 
 private:
     RenderBin _renderBin;
diff --git a/include/openspace/scene/scene.h b/include/openspace/scene/scene.h
index da9dc23f44..dd1ec49d46 100644
--- a/include/openspace/scene/scene.h
+++ b/include/openspace/scene/scene.h
@@ -25,21 +25,21 @@
 #ifndef __OPENSPACE_CORE___SCENE___H__
 #define __OPENSPACE_CORE___SCENE___H__
 
-#include <openspace/documentation/documentationgenerator.h>
+#include <openspace/properties/propertyowner.h>
 
 #include <vector>
 #include <unordered_map>
 #include <set>
 #include <mutex>
 
-#include <openspace/scene/scenegraphnode.h>
 #include <openspace/scene/sceneinitializer.h>
+#include <openspace/scene/scenegraphnode.h>
 #include <openspace/scene/scenelicense.h>
 #include <openspace/scene/scenelicensewriter.h>
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/util/camera.h>
 #include <openspace/util/updatestructures.h>
-
+#include <ghoul/misc/easing.h>
 #include <ghoul/opengl/programobject.h>
 
 namespace ghoul { class Dictionary; }
@@ -50,9 +50,10 @@ namespace documentation { struct Documentation; }
 
 // Notifications:
 // SceneGraphFinishedLoading
-class Scene : public DocumentationGenerator {
+class Scene
+    : public properties::PropertyOwner
+{
 public:
-
     using UpdateDependencies = ghoul::Boolean;
 
     struct InvalidSceneError : ghoul::RuntimeError {
@@ -171,6 +172,47 @@ public:
      */
     bool isInitializing() const;
 
+    /**
+     * Adds an interpolation request for the passed \p prop that will run for
+     * \p durationSeconds seconds. Every time the #updateInterpolations method is called
+     * the Property will be notified that it has to update itself using the stored
+     * interpolation values. If an interpolation record already exists for the passed 
+     * \p prop, the previous record will be overwritten and the remaining time of the old
+     * interpolation is ignored.
+     *
+     * \param prop The property that should be called to update itself every frame until
+     *        \p durationSeconds seconds have passed
+     * \param durationSeconds The number of seconds that the interpolation will run for
+     *
+     * \pre \p prop must not be \c nullptr
+     * \pre \p durationSeconds must be positive and not 0
+     * \post A new interpolation record exists for \p that is not expired 
+     */
+    void addInterpolation(properties::Property* prop, float durationSeconds,
+        ghoul::EasingFunction easingFunction = ghoul::EasingFunction::Linear);
+
+    /**
+     * Removes the passed \p prop from the list of Property%s that are update each time
+     * the #updateInterpolations method is called
+     *
+     * \param prop The Property that should not longer be updated
+     *
+     * \pre \prop must not be nullptr
+     * \post No interpolation record exists for \p prop
+     */
+    void removeInterpolation(properties::Property* prop);
+
+    /**
+     * Informs all Property%s with active interpolations about applying a new update tick
+     * using the Property::interpolateValue method, passing a parameter \c t which is \c 0
+     * if no time has passed between the #addInterpolation method and \c 1 if an amount of
+     * time equal to the requested interpolation time has passed. The parameter \c t is
+     * updated with a resolution of 1 microsecond, which means that if this function is
+     * called twice within 1 microsecond, the passed parameter \c t might be the same for
+     * both calls
+     */
+    void updateInterpolations();
+
     /**
      * Returns the Lua library that contains all Lua functions available to change the
      * scene graph. The functions contained are
@@ -182,8 +224,6 @@ public:
     static scripting::LuaLibrary luaLibrary();
 
 private:
-    std::string generateJson() const override;
-
     /**
      * Update dependencies.
      */
@@ -204,6 +244,15 @@ private:
     std::mutex _programUpdateLock;
     std::set<ghoul::opengl::ProgramObject*> _programsToUpdate;
     std::vector<std::unique_ptr<ghoul::opengl::ProgramObject>> _programs;
+
+    struct InterpolationInfo {
+        properties::Property* prop;
+        std::chrono::time_point<std::chrono::steady_clock> beginTime;
+        float durationSeconds;
+        ghoul::EasingFunc<float> easingFunction;
+        bool isExpired = false;
+    };
+    std::vector<InterpolationInfo> _interpolationInfos;
 };
 
 } // namespace openspace
diff --git a/include/openspace/util/blockplaneintersectiongeometry.h b/include/openspace/util/blockplaneintersectiongeometry.h
index b494fff259..8f1c5bfd80 100644
--- a/include/openspace/util/blockplaneintersectiongeometry.h
+++ b/include/openspace/util/blockplaneintersectiongeometry.h
@@ -48,7 +48,7 @@ public:
 private:
     void updateVertices();
     std::vector<float> _vertices;
-    bool _initialized;
+    // bool _initialized;
     GLuint _vaoId;
     GLuint _vBufferId;
     glm::vec3 _size;
diff --git a/include/openspace/util/httprequest.h b/include/openspace/util/httprequest.h
index 9e97bd3c3c..76eb42baa8 100644
--- a/include/openspace/util/httprequest.h
+++ b/include/openspace/util/httprequest.h
@@ -229,6 +229,8 @@ public:
     HttpFileDownload(HttpFileDownload&& d) = default;
     virtual ~HttpFileDownload() = default;
 
+    const std::string& destination() const;
+
 protected:
     bool initDownload() override;
     bool deinitDownload() override;
diff --git a/modules/atmosphere/rendering/renderableatmosphere.cpp b/modules/atmosphere/rendering/renderableatmosphere.cpp
index 90579fb98a..ee67e21e41 100644
--- a/modules/atmosphere/rendering/renderableatmosphere.cpp
+++ b/modules/atmosphere/rendering/renderableatmosphere.cpp
@@ -331,9 +331,12 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                     sourceArray.emplace_back(sourceName, sourceRadius);
                 }
                 else {
-                    LWARNING("No Radius value expecified for Shadow Source Name "
-                        << sourceName << " from " << name
-                        << " planet.\nDisabling shadows for this planet.");
+                    LWARNING(fmt::format(
+                        "No Radius value expecified for Shadow Source Name '{}' from "
+                        "'{}' planet. Disabling shadows for this planet.",
+                        sourceName,
+                        name
+                    ));
                     disableShadows = true;
                     break;
                 }
@@ -357,9 +360,12 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                         casterArray.emplace_back(casterName, casterRadius);
                     }
                     else {
-                        LWARNING("No Radius value expecified for Shadow Caster Name "
-                            << casterName << " from " << name
-                            << " planet.\nDisabling shadows for this planet.");
+                        LWARNING(fmt::format(
+                            "No Radius value expecified for Shadow Caster Name '{}' from "
+                            "'{}' planet. Disabling shadows for this planet.",
+                            casterName,
+                            name
+                        ));
                         disableShadows = true;
                         break;
                     }
@@ -391,14 +397,20 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
     if (success) {
         if (!atmosphereDictionary.getValue(keyAtmosphereRadius, _atmosphereRadius)) {
             errorReadingAtmosphereData = true;
-            LWARNING("No Atmosphere Radius value expecified for Atmosphere Effects of "
-                << name << " planet.\nDisabling atmosphere effects for this planet.");
+            LWARNINGC(
+                name,
+                "No Atmosphere Radius value specified for Atmosphere Effects. "
+                "Disabling atmosphere effects for this planet."
+            );
         }
 
         if (!atmosphereDictionary.getValue(keyPlanetRadius, _atmospherePlanetRadius)) {
             errorReadingAtmosphereData = true;
-            LWARNING("No Planet Radius value expecified for Atmosphere Effects of "
-                << name << " planet.\nDisabling atmosphere effects for this planet.");
+            LWARNINGC(
+                name,
+                "No Planet Radius value expecified for Atmosphere Effects. "
+                "Disabling atmosphere effects for this planet."
+            );
         }
 
         if (!atmosphereDictionary.getValue(
@@ -406,10 +418,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                 _planetAverageGroundReflectance))
         {
             errorReadingAtmosphereData = true;
-            LWARNING(
-                "No Average Atmosphere Ground Reflectance value expecified for "
-                "Atmosphere Effects of " << name << " planet.\nDisabling atmosphere "
-                "effects for this planet."
+            LWARNINGC(
+                name,
+                "No Average Atmosphere Ground Reflectance value specified for "
+                "Atmosphere Effects. Disabling atmosphere effects for this planet."
             );
         }
 
@@ -418,10 +430,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                 _planetGroundRadianceEmittion))
         {
             errorReadingAtmosphereData = true;
-            LWARNING(
-                "No Ground Radiance Emitted percentage value expecified for Atmosphere "
-                "Effects of " << name << " planet.\nDisabling atmosphere effects for "
-                "this planet."
+            LWARNINGC(
+                name,
+                "No Ground Radiance Emitted percentage value specified for Atmosphere "
+                "Effects. Disabling atmosphere effects for this planet."
             );
         }
 
@@ -441,10 +453,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                 _rayleighScatteringCoeff))
             {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Rayleigh Scattering parameters expecified for Atmosphere Effects "
-                    "of " << name << " planet.\nDisabling atmosphere effects for this "
-                    "planet."
+                LWARNINGC(
+                    name,
+                    "No Rayleigh Scattering parameters specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
 
@@ -453,16 +465,20 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
                     _rayleighHeightScale))
             {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Rayleigh Height Scale value expecified for Atmosphere Effects of "
-                    << name << " planet.\nDisabling atmosphere effects for this planet."
+                LWARNINGC(
+                    name,
+                    "No Rayleigh Height Scale value specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
         }
         else {
             errorReadingAtmosphereData = true;
-            LWARNING("No Rayleigh parameters expecified for Atmosphere Effects of "
-                << name << " planet.\nDisabling atmosphere effects for this planet.");
+            LWARNINGC(
+                name,
+                "No Rayleigh parameters specified for Atmosphere Effects. "
+                "Disabling atmosphere effects for this planet."
+            );
         }
 
         ghoul::Dictionary ozoneDictionary;
@@ -489,41 +505,46 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
         if (success) {
             if (!mieDictionary.getValue(keyMieHeightScale, _mieHeightScale)) {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Mie Height Scale value expecified for Atmosphere Effects of "
-                    << name << " planet.\nDisabling atmosphere effects for this planet."
+                LWARNINGC(
+                    name,
+                    "No Mie Height Scale value specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
 
             if (!mieDictionary.getValue("Coefficients.Scattering", _mieScatteringCoeff)) {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Mie Scattering parameters expecified for Atmosphere Effects of "
-                    << name << " planet.\nDisabling atmosphere effects for this planet."
+                LWARNINGC(
+                    name,
+                    "No Mie Scattering parameters specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
 
             if (!mieDictionary.getValue("Coefficients.Extinction", _mieExtinctionCoeff)) {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Mie Extinction parameters expecified for Atmosphere Effects of "
-                    << name << " planet.\nDisabling atmosphere effects for this planet."
+                LWARNINGC(
+                    name,
+                    "No Mie Extinction parameters specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
 
             if (!mieDictionary.getValue(keyMiePhaseConstant, _miePhaseConstant)) {
                 errorReadingAtmosphereData = true;
-                LWARNING(
-                    "No Mie Phase Constant value expecified for Atmosphere Effects of "
-                    << name << " planet.\nDisabling atmosphere effects for this planet."
+                LWARNINGC(
+                    name,
+                    "No Mie Phase Constant value specified for Atmosphere Effects. "
+                    "Disabling atmosphere effects for this planet."
                 );
             }
         }
         else {
             errorReadingAtmosphereData = true;
-            LWARNING(
-                "No Mie parameters expecified for Atmosphere Effects of "
-                << name << " planet.\nDisabling atmosphere effects for this planet."
+            LWARNINGC(
+                name,
+                "No Mie parameters specified for Atmosphere Effects. "
+                "Disabling atmosphere effects for this planet."
             );
         }
 
@@ -531,7 +552,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
         success = atmosphereDictionary.getValue(keyImage, ImageDictionary);
         if (success) {
             if (ImageDictionary.getValue(keyToneMappingOp, _preCalculatedTexturesScale)) {
-                LDEBUG("Atmosphere Texture Scaled to " << _preCalculatedTexturesScale);
+                LDEBUG(fmt::format(
+                    "Atmosphere Texture Scaled to {}",
+                    _preCalculatedTexturesScale
+                ));
             }
         }
 
@@ -539,7 +563,10 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
         success = atmosphereDictionary.getValue(keyATMDebug, debugDictionary);
         if (success) {
             if (debugDictionary.getValue(keyTextureScale, _preCalculatedTexturesScale)) {
-                LDEBUG("Atmosphere Texture Scaled to " << _preCalculatedTexturesScale);
+                LDEBUG(fmt::format(
+                    "Atmosphere Texture Scaled to {}",
+                    _preCalculatedTexturesScale
+                ));
             }
 
             if (debugDictionary.getValue(keySaveTextures, _saveCalculationsToTexture)) {
diff --git a/modules/base/basemodule.cpp b/modules/base/basemodule.cpp
index 59b4ce4d86..2d39afc6bf 100644
--- a/modules/base/basemodule.cpp
+++ b/modules/base/basemodule.cpp
@@ -64,8 +64,6 @@
 #include <modules/base/scale/luascale.h>
 #include <modules/base/scale/staticscale.h>
 
-#include <ghoul/filesystem/filesystem>
-
 namespace openspace {
 
 BaseModule::BaseModule() : OpenSpaceModule(BaseModule::Name) {}
diff --git a/modules/base/dashboard/dashboarditemangle.cpp b/modules/base/dashboard/dashboarditemangle.cpp
index c850d050b7..6fa4b418df 100644
--- a/modules/base/dashboard/dashboarditemangle.cpp
+++ b/modules/base/dashboard/dashboarditemangle.cpp
@@ -33,6 +33,7 @@
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/util/camera.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
@@ -173,7 +174,7 @@ documentation::Documentation DashboardItemAngle::Documentation() {
 }
 
 DashboardItemAngle::DashboardItemAngle(ghoul::Dictionary dictionary)
-    : DashboardItem("Distance")
+    : DashboardItem("Angle")
     , _fontName(FontNameInfo, KeyFontMono)
     , _fontSize(FontSizeInfo, DefaultFontSize, 6.f, 144.f, 1.f)
     , _source{
diff --git a/modules/base/dashboard/dashboarditemdate.cpp b/modules/base/dashboard/dashboarditemdate.cpp
index b9cfe90f32..16401ec100 100644
--- a/modules/base/dashboard/dashboarditemdate.cpp
+++ b/modules/base/dashboard/dashboarditemdate.cpp
@@ -29,6 +29,7 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/util/timemanager.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/base/dashboard/dashboarditemdistance.cpp b/modules/base/dashboard/dashboarditemdistance.cpp
index 2ca2cf17ce..bba284a572 100644
--- a/modules/base/dashboard/dashboarditemdistance.cpp
+++ b/modules/base/dashboard/dashboarditemdistance.cpp
@@ -34,6 +34,7 @@
 #include <openspace/util/camera.h>
 #include <openspace/util/distanceconversion.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/base/dashboard/dashboarditemframerate.cpp b/modules/base/dashboard/dashboarditemframerate.cpp
index f1ffe46805..0bf6238a6b 100644
--- a/modules/base/dashboard/dashboarditemframerate.cpp
+++ b/modules/base/dashboard/dashboarditemframerate.cpp
@@ -29,6 +29,7 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/base/dashboard/dashboarditemmission.cpp b/modules/base/dashboard/dashboarditemmission.cpp
index 57a0a47e7a..331e3c92d9 100644
--- a/modules/base/dashboard/dashboarditemmission.cpp
+++ b/modules/base/dashboard/dashboarditemmission.cpp
@@ -31,6 +31,7 @@
 #include <openspace/mission/missionmanager.h>
 #include <openspace/util/timemanager.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/base/dashboard/dashboarditemparallelconnection.cpp b/modules/base/dashboard/dashboarditemparallelconnection.cpp
index 9053f659ec..b15025ce52 100644
--- a/modules/base/dashboard/dashboarditemparallelconnection.cpp
+++ b/modules/base/dashboard/dashboarditemparallelconnection.cpp
@@ -33,6 +33,7 @@
 #include <openspace/util/camera.h>
 #include <openspace/util/distanceconversion.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/base/dashboard/dashboarditemsimulationincrement.cpp b/modules/base/dashboard/dashboarditemsimulationincrement.cpp
index 0e56cadb3a..5606e26e6a 100644
--- a/modules/base/dashboard/dashboarditemsimulationincrement.cpp
+++ b/modules/base/dashboard/dashboarditemsimulationincrement.cpp
@@ -30,6 +30,7 @@
 #include <openspace/util/timeconversion.h>
 #include <openspace/util/timemanager.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
@@ -191,7 +192,7 @@ void DashboardItemSimulationIncrement::render(glm::vec2& penPosition) {
         double convertedT = convertTime(t, TimeUnit::Second, unit);
         deltaTime = { convertedT, nameForTimeUnit(unit, convertedT != 1.0) };
     }
-    
+
     penPosition.y -= _font->height();
     RenderFont(
         *_font,
diff --git a/modules/base/rendering/modelgeometry.cpp b/modules/base/rendering/modelgeometry.cpp
index 0ba95c2e7c..1ca0f16d75 100644
--- a/modules/base/rendering/modelgeometry.cpp
+++ b/modules/base/rendering/modelgeometry.cpp
@@ -29,6 +29,7 @@
 #include <openspace/util/factorymanager.h>
 
 #include <ghoul/filesystem/cachemanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/dictionary.h>
 #include <ghoul/misc/invariants.h>
@@ -208,7 +209,11 @@ bool ModelGeometry::loadObj(const std::string& filename) {
 
     const bool hasCachedFile = FileSys.fileExists(cachedFile);
     if (hasCachedFile) {
-        LINFO("Cached file '" << cachedFile << "' used for file '" << filename << "'");
+        LINFO(fmt::format(
+            "Cached file '{}' used for file '{}",
+            cachedFile,
+            filename
+        ));
 
         const bool success = loadCachedFile(cachedFile);
         if (success) {
@@ -221,12 +226,14 @@ bool ModelGeometry::loadObj(const std::string& filename) {
         // file for the next run
     }
     else {
-        LINFO(
-            "Cached file '" << cachedFile << "' for file '" << filename << "' not found"
-        );
+        LINFO(fmt::format(
+            "Cached file '{}' for file '{}' not found",
+            cachedFile,
+            filename
+        ));
     }
 
-    LINFO("Loading Model file '" << filename << "'");
+    LINFO(fmt::format("Loading Model file '{}'", filename));
     const bool modelSuccess = loadModel(filename);
 
     if (!modelSuccess) {
@@ -262,7 +269,7 @@ bool ModelGeometry::saveCachedFile(const std::string& filename) {
         return fileStream.good();
     }
     else {
-        LERROR("Error opening file '" << filename << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", filename));
         return false;
     }
 }
@@ -284,7 +291,10 @@ bool ModelGeometry::loadCachedFile(const std::string& filename) {
         fileStream.read(reinterpret_cast<char*>(&iSize), sizeof(int64_t));
 
         if (vSize == 0 || iSize == 0) {
-            LERROR("Error opening file '" << filename << "' for loading cache file");
+            LERROR(fmt::format(
+                "Error opening file '{}' for loading cache file",
+                filename
+            ));
             return false;
         }
 
@@ -300,7 +310,10 @@ bool ModelGeometry::loadCachedFile(const std::string& filename) {
         return fileStream.good();
     }
     else {
-        LERROR("Error opening file '" << filename << "' for loading cache file");
+        LERROR(fmt::format(
+            "Error opening file '{}' for loading cache file",
+            filename
+        ));
         return false;
     }
 }
diff --git a/modules/base/rendering/renderablemodel.cpp b/modules/base/rendering/renderablemodel.cpp
index 9f94d6a74f..bf30e43fb2 100644
--- a/modules/base/rendering/renderablemodel.cpp
+++ b/modules/base/rendering/renderablemodel.cpp
@@ -123,6 +123,10 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
         "RenderableModel"
     );
 
+    addProperty(_opacity);
+    registerUpdateRenderBinFromOpacity();
+
+
     if (dictionary.hasKey(KeyGeometry)) {
         std::string name = dictionary.value<std::string>(SceneGraphNode::KeyName);
         ghoul::Dictionary dict = dictionary.value<ghoul::Dictionary>(KeyGeometry);
@@ -163,6 +167,7 @@ void RenderableModel::initializeGL() {
         absPath("${MODULE_BASE}/shaders/model_fs.glsl")
     );
 
+    _uniformCache.opacity = _programObject->uniformLocation("opacity");
     _uniformCache.directionToSunViewSpace = _programObject->uniformLocation(
         "directionToSunViewSpace"
     );
@@ -176,6 +181,8 @@ void RenderableModel::initializeGL() {
         "performShading"
     );
     _uniformCache.texture = _programObject->uniformLocation("texture1");
+
+
     loadTexture();
 
     _geometry->initialize(this);
@@ -197,6 +204,8 @@ void RenderableModel::deinitializeGL() {
 void RenderableModel::render(const RenderData& data, RendererTasks&) {
     _programObject->activate();
 
+    _programObject->setUniform(_uniformCache.opacity, _opacity);
+
     // Model transform and view transform needs to be in double precision
     glm::dmat4 modelTransform =
         glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
@@ -244,6 +253,7 @@ void RenderableModel::update(const UpdateData&) {
     if (_programObject->isDirty()) {
         _programObject->rebuildFromFile();
 
+        _uniformCache.opacity = _programObject->uniformLocation("opacity");
         _uniformCache.directionToSunViewSpace = _programObject->uniformLocation(
             "directionToSunViewSpace"
         );
@@ -273,7 +283,7 @@ void RenderableModel::loadTexture() {
         if (_texture) {
             LDEBUGC(
                 "RenderableModel",
-                "Loaded texture from '" << absPath(_colorTexturePath) << "'"
+                fmt::format("Loaded texture from '{}'", absPath(_colorTexturePath))
             );
             _texture->uploadTexture();
             _texture->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
diff --git a/modules/base/rendering/renderablemodel.h b/modules/base/rendering/renderablemodel.h
index 433aa30b2a..37d41a86e5 100644
--- a/modules/base/rendering/renderablemodel.h
+++ b/modules/base/rendering/renderablemodel.h
@@ -74,8 +74,8 @@ private:
     properties::Mat3Property _modelTransform;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
-    UniformCache(directionToSunViewSpace, modelViewTransform, projectionTransform,
-        performShading, texture) _uniformCache;
+    UniformCache(opacity, directionToSunViewSpace, modelViewTransform,
+        projectionTransform, performShading, texture) _uniformCache;
 
     std::unique_ptr<ghoul::opengl::Texture> _texture;
 
diff --git a/modules/base/rendering/renderableplane.cpp b/modules/base/rendering/renderableplane.cpp
index ebbdbfdc18..91c9da3816 100644
--- a/modules/base/rendering/renderableplane.cpp
+++ b/modules/base/rendering/renderableplane.cpp
@@ -31,7 +31,7 @@
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/util/updatestructures.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/misc/defer.h>
 #include <ghoul/opengl/programobject.h>
@@ -111,6 +111,9 @@ RenderablePlane::RenderablePlane(const ghoul::Dictionary& dictionary)
         "RenderablePlane"
     );
 
+    addProperty(_opacity);
+    registerUpdateRenderBinFromOpacity();
+
     _size = static_cast<float>(dictionary.value<double>(SizeInfo.identifier));
 
     if (dictionary.hasKey(BillboardInfo.identifier)) {
@@ -185,6 +188,8 @@ void RenderablePlane::deinitializeGL() {
 void RenderablePlane::render(const RenderData& data, RendererTasks&) {
     _shader->activate();
 
+    _shader->setUniform("opacity", _opacity);
+
     // Model transform and view transform needs to be in double precision
     const glm::dmat4 rotationTransform = _billboard ?
         glm::inverse(glm::dmat4(data.camera.viewRotationMatrix())) :
diff --git a/modules/base/rendering/renderableplaneimagelocal.cpp b/modules/base/rendering/renderableplaneimagelocal.cpp
index 493cb2bd86..f70cafedca 100644
--- a/modules/base/rendering/renderableplaneimagelocal.cpp
+++ b/modules/base/rendering/renderableplaneimagelocal.cpp
@@ -96,7 +96,6 @@ void RenderablePlaneImageLocal::deinitializeGL() {
     RenderablePlane::deinitializeGL();
 }
 
-
 void RenderablePlaneImageLocal::bindTexture() {
     _texture->bind();
 }
@@ -118,7 +117,7 @@ void RenderablePlaneImageLocal::loadTexture() {
         if (texture) {
             LDEBUGC(
                 "RenderablePlane",
-                "Loaded texture from '" << absPath(_texturePath) << "'"
+                fmt::format("Loaded texture from '{}'", absPath(_texturePath))
             );
             texture->uploadTexture();
 
diff --git a/modules/base/rendering/renderableplaneimageonline.cpp b/modules/base/rendering/renderableplaneimageonline.cpp
index da432e7f13..e8c7b8cd84 100644
--- a/modules/base/rendering/renderableplaneimageonline.cpp
+++ b/modules/base/rendering/renderableplaneimageonline.cpp
@@ -62,7 +62,8 @@ documentation::Documentation RenderablePlaneImageOnline::Documentation() {
     };
 }
 
-RenderablePlaneImageOnline::RenderablePlaneImageOnline(const ghoul::Dictionary& dictionary)
+RenderablePlaneImageOnline::RenderablePlaneImageOnline(
+                                                      const ghoul::Dictionary& dictionary)
     : RenderablePlane(dictionary)
     , _texturePath(TextureInfo)
     , _texture(nullptr)
@@ -117,7 +118,7 @@ void RenderablePlaneImageOnline::update(const UpdateData&) {
             if (imageFile.corrupted) {
                 LERRORC(
                     "ScreenSpaceImageOnline",
-                    "Error loading image from URL '" << _texturePath << "'"
+                    fmt::format("Error loading image from URL '{}'", _texturePath)
                 );
                 return;
             }
diff --git a/modules/base/rendering/renderablesphere.cpp b/modules/base/rendering/renderablesphere.cpp
index 1b56dea202..e2dbe510b9 100644
--- a/modules/base/rendering/renderablesphere.cpp
+++ b/modules/base/rendering/renderablesphere.cpp
@@ -71,13 +71,6 @@ namespace {
         "This value specifies the radius of the sphere in meters."
     };
 
-    static const openspace::properties::Property::PropertyInfo TransparencyInfo = {
-        "Alpha",
-        "Transparency",
-        "This value determines the transparency of the sphere. If this value is set to "
-        "1, the sphere is completely opaque. At 0, the sphere is completely transparent."
-    };
-
     static const openspace::properties::Property::PropertyInfo FadeOutThreshouldInfo = {
         "FadeOutThreshould",
         "Fade-Out Threshould",
@@ -131,12 +124,6 @@ documentation::Documentation RenderableSphere::Documentation() {
                 Optional::Yes,
                 OrientationInfo.description
             },
-            {
-                TransparencyInfo.identifier,
-                new DoubleInRangeVerifier(0.0, 1.0),
-                Optional::Yes,
-                TransparencyInfo.description
-            },
             {
                 FadeOutThreshouldInfo.identifier,
                 new DoubleInRangeVerifier(0.0, 1.0),
@@ -166,7 +153,6 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
     , _orientation(OrientationInfo, properties::OptionProperty::DisplayType::Dropdown)
     , _size(SizeInfo, 1.f, 0.f, 1e35f)
     , _segments(SegmentsInfo, 8, 4, 1000)
-    , _transparency(TransparencyInfo, 1.f, 0.f, 1.f)
     , _disableFadeInDistance(DisableFadeInOuInfo, true)
     , _fadeOutThreshold(-1.0)
     , _fadeInThreshold(0.0)
@@ -181,6 +167,9 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
         "RenderableSphere"
     );
 
+    addProperty(_opacity);
+    registerUpdateRenderBinFromOpacity();
+
     _size = static_cast<float>(dictionary.value<double>(SizeInfo.identifier));
     _segments = static_cast<int>(dictionary.value<double>(SegmentsInfo.identifier));
     _texturePath = absPath(dictionary.value<std::string>(TextureInfo.identifier));
@@ -217,21 +206,6 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
     addProperty(_segments);
     _segments.onChange([this](){ _sphereIsDirty = true; });
 
-    _transparency.onChange([this](){
-        if (_transparency > 0.f && _transparency < 1.f) {
-            setRenderBin(Renderable::RenderBin::Transparent);
-        }
-        else {
-            setRenderBin(Renderable::RenderBin::Opaque);
-        }
-    });
-    if (dictionary.hasKey(TransparencyInfo.identifier)) {
-        _transparency = static_cast<float>(
-            dictionary.value<double>(TransparencyInfo.identifier)
-        );
-    }
-    addProperty(_transparency);
-
     addProperty(_texturePath);
     _texturePath.onChange([this]() { loadTexture(); });
 
@@ -252,7 +226,6 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
         _disableFadeInDistance.set(false);
         addProperty(_disableFadeInDistance);
     }
-
 }
 
 bool RenderableSphere::isReady() const {
@@ -272,6 +245,11 @@ void RenderableSphere::initializeGL() {
         absPath("${MODULE_BASE}/shaders/sphere_fs.glsl")
     );
 
+    _uniformCache.opacity = _shader->uniformLocation("opacity");
+    _uniformCache.viewProjection = _shader->uniformLocation("ViewProjection");
+    _uniformCache.modelTransform = _shader->uniformLocation("ModelTransform");
+    _uniformCache.texture = _shader->uniformLocation("texture1");
+
     loadTexture();
 }
 
@@ -294,12 +272,12 @@ void RenderableSphere::render(const RenderData& data, RendererTasks&) {
     _shader->activate();
     _shader->setIgnoreUniformLocationError(IgnoreError::Yes);
 
-    _shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-    _shader->setUniform("ModelTransform", transform);
+    _shader->setUniform(_uniformCache.viewProjection, data.camera.viewProjectionMatrix());
+    _shader->setUniform(_uniformCache.modelTransform, transform);
 
     setPscUniforms(*_shader.get(), data.camera, data.position);
 
-    float adjustedTransparency = _transparency;
+    float adjustedTransparency = _opacity;
 
     if (_fadeInThreshold > 0.0) {
         double distCamera = glm::length(data.camera.positionVec3());
@@ -323,16 +301,16 @@ void RenderableSphere::render(const RenderData& data, RendererTasks&) {
     }
 
     // Performance wise
-    if (adjustedTransparency < 0.01) {
+    if (adjustedTransparency < 0.01f) {
         return;
     }
 
-    _shader->setUniform("alpha", adjustedTransparency);
+    _shader->setUniform(_uniformCache.opacity, _opacity);
 
     ghoul::opengl::TextureUnit unit;
     unit.activate();
     _texture->bind();
-    _shader->setUniform("texture1", unit);
+    _shader->setUniform(_uniformCache.texture, unit);
 
     glEnable(GL_CULL_FACE);
     glCullFace(GL_BACK);
@@ -366,6 +344,11 @@ void RenderableSphere::render(const RenderData& data, RendererTasks&) {
 void RenderableSphere::update(const UpdateData&) {
     if (_shader->isDirty()) {
         _shader->rebuildFromFile();
+
+        _uniformCache.opacity = _shader->uniformLocation("opacity");
+        _uniformCache.viewProjection = _shader->uniformLocation("ViewProjection");
+        _uniformCache.modelTransform = _shader->uniformLocation("ModelTransform");
+        _uniformCache.texture = _shader->uniformLocation("texture1");
     }
 
     if (_sphereIsDirty) {
@@ -386,7 +369,7 @@ void RenderableSphere::loadTexture() {
         if (texture) {
             LDEBUGC(
                 "RenderableSphere",
-                "Loaded texture from '" << absPath(_texturePath) << "'"
+                fmt::format("Loaded texture from '{}'", absPath(_texturePath))
             );
             texture->uploadTexture();
 
diff --git a/modules/base/rendering/renderablesphere.h b/modules/base/rendering/renderablesphere.h
index 002954d332..f8fbf0984b 100644
--- a/modules/base/rendering/renderablesphere.h
+++ b/modules/base/rendering/renderablesphere.h
@@ -31,6 +31,7 @@
 #include <openspace/properties/optionproperty.h>
 #include <openspace/properties/scalar/intproperty.h>
 #include <openspace/properties/scalar/floatproperty.h>
+#include <ghoul/opengl/uniformcache.h>
 
 namespace ghoul::opengl {
     class ProgramObject;
@@ -68,8 +69,6 @@ private:
     properties::FloatProperty _size;
     properties::IntProperty _segments;
 
-    properties::FloatProperty _transparency;
-
     properties::BoolProperty _disableFadeInDistance;
 
     float _fadeOutThreshold;
@@ -80,6 +79,9 @@ private:
 
     std::unique_ptr<PowerScaledSphere> _sphere;
 
+    UniformCache(opacity, viewProjection, modelTransform, texture) _uniformCache;
+
+
     bool _sphereIsDirty;
 };
 
diff --git a/modules/base/rendering/renderablesphericalgrid.cpp b/modules/base/rendering/renderablesphericalgrid.cpp
index 1ffefbbabc..e56d8eb140 100644
--- a/modules/base/rendering/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/renderablesphericalgrid.cpp
@@ -137,6 +137,9 @@ RenderableSphericalGrid::RenderableSphericalGrid(const ghoul::Dictionary& dictio
         "RenderableSphericalGrid"
     );
 
+    addProperty(_opacity);
+    registerUpdateRenderBinFromOpacity();
+
     if (dictionary.hasKey(GridMatrixInfo.identifier)) {
         _gridMatrix = dictionary.value<glm::dmat4>(GridMatrixInfo.identifier);
     }
@@ -210,6 +213,8 @@ void RenderableSphericalGrid::deinitializeGL() {
 void RenderableSphericalGrid::render(const RenderData& data, RendererTasks&){
     _gridProgram->activate();
 
+    _gridProgram->setUniform("opacity", _opacity);
+
     glm::dmat4 modelTransform =
         glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
         glm::dmat4(data.modelTransform.rotation) *  // Spice rotation
diff --git a/modules/base/rendering/renderabletrail.cpp b/modules/base/rendering/renderabletrail.cpp
index 9301f7c939..5ee7b0a2be 100644
--- a/modules/base/rendering/renderabletrail.cpp
+++ b/modules/base/rendering/renderabletrail.cpp
@@ -169,6 +169,9 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
     , _renderingModes(RenderingModeInfo, properties::OptionProperty::DisplayType::Dropdown
     )
 {
+    addProperty(_opacity);
+    registerUpdateRenderBinFromOpacity();
+
     _translation = Translation::createFromDictionary(
         dictionary.value<ghoul::Dictionary>(KeyTranslation)
     );
@@ -226,6 +229,7 @@ void RenderableTrail::initializeGL() {
         absPath("${MODULE_BASE}/shaders/renderabletrail_fs.glsl")
     );
 
+    _uniformCache.opacity = _programObject->uniformLocation("opacity");
     _uniformCache.modelView = _programObject->uniformLocation("modelViewTransform");
     _uniformCache.projection = _programObject->uniformLocation("projectionTransform");
     _uniformCache.color = _programObject->uniformLocation("color");
@@ -255,6 +259,7 @@ bool RenderableTrail::isReady() const {
 
 void RenderableTrail::render(const RenderData& data, RendererTasks&) {
     _programObject->activate();
+    _programObject->setUniform(_uniformCache.opacity, _opacity);
 
     glm::dmat4 modelTransform =
         glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
diff --git a/modules/base/rendering/renderabletrail.h b/modules/base/rendering/renderabletrail.h
index 70ae56812f..62ea0d466d 100644
--- a/modules/base/rendering/renderabletrail.h
+++ b/modules/base/rendering/renderabletrail.h
@@ -160,8 +160,8 @@ private:
     /// Program object used to render the data stored in RenderInformation
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
-    UniformCache(modelView, projection, color, useLineFade, lineFade, vertexSorting,
-        idOffset, nVertices, stride, pointSize, renderPhase) _uniformCache;
+    UniformCache(opacity, modelView, projection, color, useLineFade, lineFade,
+        vertexSorting, idOffset, nVertices, stride, pointSize, renderPhase) _uniformCache;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderabletrailorbit.cpp b/modules/base/rendering/renderabletrailorbit.cpp
index a55f5b889c..455fde80a6 100644
--- a/modules/base/rendering/renderabletrailorbit.cpp
+++ b/modules/base/rendering/renderabletrailorbit.cpp
@@ -213,7 +213,8 @@ void RenderableTrailOrbit::update(const UpdateData& data) {
     // 3
     if (!report.permanentPointsNeedUpdate) {
         if (report.floatingPointNeedsUpdate) {
-            // If no other values have been touched, we only need to upload the floating value
+            // If no other values have been touched, we only need to upload the
+            // floating value
             glBufferSubData(
                 GL_ARRAY_BUFFER,
                 _primaryRenderInformation.first * sizeof(TrailVBOLayout),
diff --git a/modules/base/rendering/screenspacedashboard.cpp b/modules/base/rendering/screenspacedashboard.cpp
index df3bf45500..c6d2529e5c 100644
--- a/modules/base/rendering/screenspacedashboard.cpp
+++ b/modules/base/rendering/screenspacedashboard.cpp
@@ -94,7 +94,7 @@ int addDashboardItemToScreenSpace(lua_State* L) {
         }
 
         dash->dashboard().addDashboardItem(DashboardItem::createFromDictionary(d));
-        
+
         lua_settop(L, 0);
         return 0;
     }
diff --git a/modules/base/rendering/screenspaceimagelocal.cpp b/modules/base/rendering/screenspaceimagelocal.cpp
index 51e16c399a..c8e040ce1a 100644
--- a/modules/base/rendering/screenspaceimagelocal.cpp
+++ b/modules/base/rendering/screenspaceimagelocal.cpp
@@ -33,7 +33,7 @@
 
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/io/texture/texturereader.h>
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/opengl/textureconversion.h>
 
 namespace {
diff --git a/modules/base/rendering/screenspaceimageonline.cpp b/modules/base/rendering/screenspaceimageonline.cpp
index 0bc089b7e6..cad4a48541 100644
--- a/modules/base/rendering/screenspaceimageonline.cpp
+++ b/modules/base/rendering/screenspaceimageonline.cpp
@@ -31,9 +31,9 @@
 #include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/opengl/programobject.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/opengl/programobject.h>
 
 namespace {
     constexpr const char* KeyName = "Name";
@@ -124,7 +124,7 @@ void ScreenSpaceImageOnline::update() {
             if (imageFile.corrupted) {
                 LERRORC(
                     "ScreenSpaceImageOnline",
-                    "Error loading image from URL '" << _texturePath << "'"
+                    fmt::format("Error loading image from URL '{}'", _texturePath)
                 );
                 return;
             }
diff --git a/modules/base/rotation/fixedrotation.cpp b/modules/base/rotation/fixedrotation.cpp
index 8167eb86ed..fdcb009971 100644
--- a/modules/base/rotation/fixedrotation.cpp
+++ b/modules/base/rotation/fixedrotation.cpp
@@ -29,6 +29,7 @@
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/query/query.h>
 
+#include <ghoul/fmt.h>
 #include <ghoul/misc/assert.h>
 
 namespace {
@@ -550,8 +551,11 @@ glm::dmat3 FixedRotation::matrix(const Time&) const {
     {
         LWARNINGC(
             "FixedRotation",
-            "Dangerously collinear vectors detected: " <<
-            "x: " << x << "  y: " << y << "  z: " << z
+            fmt::format("Dangerously collinear vectors detected: x ({}) y ({}) z ({})",
+                x,
+                y,
+                z
+            )
         );
         return glm::dmat3();
     }
diff --git a/modules/base/rotation/luarotation.cpp b/modules/base/rotation/luarotation.cpp
index c900f0515d..5f46aa466e 100644
--- a/modules/base/rotation/luarotation.cpp
+++ b/modules/base/rotation/luarotation.cpp
@@ -105,7 +105,7 @@ glm::dmat3 LuaRotation::matrix(const Time& time) const {
     if (!isFunction) {
         LERRORC(
             "LuaRotation",
-            "Script '" << _luaScriptFile << "' does not have a function 'rotation'"
+            fmt::format("Script '{}' does nto have a function 'rotation'", _luaScriptFile)
         );
         return glm::dmat3(1.0);
     }
@@ -128,7 +128,7 @@ glm::dmat3 LuaRotation::matrix(const Time& time) const {
     if (success != 0) {
         LERRORC(
             "LuaScale",
-            "Error executing 'rotation': " << lua_tostring(_state, -1)
+            fmt::format("Error executing 'rotation': {}", lua_tostring(_state, -1))
         );
     }
 
diff --git a/modules/base/scale/luascale.cpp b/modules/base/scale/luascale.cpp
index 19baa0114a..12d919ee4f 100644
--- a/modules/base/scale/luascale.cpp
+++ b/modules/base/scale/luascale.cpp
@@ -96,7 +96,7 @@ double LuaScale::scaleValue(const Time& time) const {
     if (!isFunction) {
         LERRORC(
             "LuaScale",
-            "Script '" << _luaScriptFile << "' does not have a function 'scale'"
+            fmt::format("Script '{}' does not have a function 'scale'", _luaScriptFile)
         );
         return 0.0;
     }
@@ -119,7 +119,7 @@ double LuaScale::scaleValue(const Time& time) const {
     if (success != 0) {
         LERRORC(
             "LuaScale",
-            "Error executing 'scale': " << lua_tostring(_state, -1)
+            fmt::format("Error executing 'scale': {}", lua_tostring(_state, -1))
         );
     }
 
diff --git a/modules/base/shaders/grid_fs.glsl b/modules/base/shaders/grid_fs.glsl
index 51e0973d20..89dd564e57 100644
--- a/modules/base/shaders/grid_fs.glsl
+++ b/modules/base/shaders/grid_fs.glsl
@@ -29,10 +29,12 @@ in float vs_screenSpaceDepth;
 in vec4 vs_positionViewSpace;
 
 uniform vec4 gridColor;
+uniform float opacity;
 
 Fragment getFragment() {
     Fragment frag;
     frag.color      = gridColor;
+    frag.color.a    *= opacity;
     frag.depth      = vs_screenSpaceDepth;
     frag.gPosition  = vs_positionViewSpace;
     frag.gNormal    = vec4(0.0, 0.0, 0.0, 1.0);
diff --git a/modules/base/shaders/model_fs.glsl b/modules/base/shaders/model_fs.glsl
index ed24bf14c1..f84b508a0c 100644
--- a/modules/base/shaders/model_fs.glsl
+++ b/modules/base/shaders/model_fs.glsl
@@ -28,11 +28,11 @@ in vec2 vs_st;
 in vec3 vs_normalViewSpace;
 in vec4 vs_positionCameraSpace;
 in float vs_screenSpaceDepth;
-in vec3 vs_normalObjSpace;
 
 uniform bool performShading = true;
 uniform vec3 directionToSunViewSpace;
 uniform sampler2D texture1;
+uniform float opacity = 1.0;
 
 const vec3 SpecularAlbedo = vec3(1.0);
 
@@ -69,10 +69,10 @@ Fragment getFragment() {
         frag.color.rgb = diffuseAlbedo;
     }
 
-    frag.color.a    = 1.0;
+    frag.color.a    = opacity;
     frag.depth      = vs_screenSpaceDepth;
     frag.gPosition  = vs_positionCameraSpace;
-    frag.gNormal    = vec4(vs_normalObjSpace, 1.0);
+    frag.gNormal    = vec4(vs_normalViewSpace, 1.0);
 
 
     return frag;
diff --git a/modules/base/shaders/model_vs.glsl b/modules/base/shaders/model_vs.glsl
index 3a1be7e6e2..0c1c036c5d 100644
--- a/modules/base/shaders/model_vs.glsl
+++ b/modules/base/shaders/model_vs.glsl
@@ -34,7 +34,6 @@ out vec2 vs_st;
 out vec3 vs_normalViewSpace;
 out float vs_screenSpaceDepth;
 out vec4 vs_positionCameraSpace;
-out vec3 vs_normalObjSpace;
 
 uniform mat4 modelViewTransform;
 uniform mat4 projectionTransform;
diff --git a/modules/base/shaders/plane_fs.glsl b/modules/base/shaders/plane_fs.glsl
index d03102727a..20e48b82fd 100644
--- a/modules/base/shaders/plane_fs.glsl
+++ b/modules/base/shaders/plane_fs.glsl
@@ -31,6 +31,7 @@ in vec3 vs_gNormal;
 
 uniform sampler2D texture1;
 uniform bool additiveBlending;
+uniform float opacity = 1.0;
 
 
 Fragment getFragment() {
@@ -42,6 +43,7 @@ Fragment getFragment() {
         frag.color = texture(texture1, vec2(1 - vs_st.s, vs_st.t));
     }
 
+    frag.color.a *= opacity;
     if (frag.color.a == 0.0) {
         discard;
     }
diff --git a/modules/base/shaders/renderabletrail_fs.glsl b/modules/base/shaders/renderabletrail_fs.glsl
index 6e005164f0..979aa32445 100644
--- a/modules/base/shaders/renderabletrail_fs.glsl
+++ b/modules/base/shaders/renderabletrail_fs.glsl
@@ -30,6 +30,7 @@ in float fade;
 
 uniform vec3 color;
 uniform int renderPhase;
+uniform float opacity = 1.0;
 
 // Fragile! Keep in sync with RenderableTrail::render::RenderPhase 
 #define RenderPhaseLines 0
@@ -40,7 +41,7 @@ uniform int renderPhase;
 
 Fragment getFragment() {
     Fragment frag;
-    frag.color = vec4(color * fade, fade);
+    frag.color = vec4(color * fade, fade * opacity);
     frag.depth = vs_positionScreenSpace.w;
     frag.blend = BLEND_MODE_ADDITIVE;
 
diff --git a/modules/base/shaders/sphere_fs.glsl b/modules/base/shaders/sphere_fs.glsl
index 47488304a7..e536a60184 100644
--- a/modules/base/shaders/sphere_fs.glsl
+++ b/modules/base/shaders/sphere_fs.glsl
@@ -31,7 +31,7 @@ in vec4 vs_gPosition;
 
 uniform float time;
 uniform sampler2D texture1;
-uniform float alpha;
+uniform float opacity;
 
 
 Fragment getFragment() {
@@ -42,7 +42,7 @@ Fragment getFragment() {
     texCoord.t = 1 - texCoord.y;
 
     Fragment frag;
-    frag.color = texture(texture1, texCoord) * vec4(1.0, 1.0, 1.0, alpha);
+    frag.color = texture(texture1, texCoord) * vec4(1.0, 1.0, 1.0, opacity);
     frag.depth = pscDepth(position);
 
     // G-Buffer
diff --git a/modules/base/translation/luatranslation.cpp b/modules/base/translation/luatranslation.cpp
index 1e619aeef9..d4c60cc7d2 100644
--- a/modules/base/translation/luatranslation.cpp
+++ b/modules/base/translation/luatranslation.cpp
@@ -28,6 +28,7 @@
 #include <openspace/documentation/verifier.h>
 #include <openspace/util/updatestructures.h>
 
+#include <ghoul/fmt.h>
 #include <ghoul/lua/ghoul_lua.h>
 #include <ghoul/lua/lua_helper.h>
 #include <ghoul/filesystem/filesystem.h>
@@ -107,7 +108,10 @@ glm::dvec3 LuaTranslation::position(const Time& time) const {
     if (!isFunction) {
         LERRORC(
             "LuaScale",
-            "Script '" << _luaScriptFile << "' does not have a function 'translation'"
+            fmt::format(
+                "Script '{}' does not have a function 'translation'",
+                _luaScriptFile
+            )
         );
         return glm::dvec3(0.0);
     }
@@ -130,7 +134,10 @@ glm::dvec3 LuaTranslation::position(const Time& time) const {
     if (success != 0) {
         LERRORC(
             "LuaScale",
-            "Error executing 'translation': " << lua_tostring(_state, -1)
+            fmt::format(
+                "Error executing 'translation': {}",
+                lua_tostring(_state, -1)
+            )
         );
     }
 
diff --git a/modules/debugging/rendering/renderabledebugplane.cpp b/modules/debugging/rendering/renderabledebugplane.cpp
index 71020474c3..f7d884ce1d 100644
--- a/modules/debugging/rendering/renderabledebugplane.cpp
+++ b/modules/debugging/rendering/renderabledebugplane.cpp
@@ -33,7 +33,7 @@
 #include <openspace/rendering/renderengine.h>
 #include <modules/spacecraftinstruments/rendering/renderableplanetprojection.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/texture.h>
diff --git a/modules/digitaluniverse/digitaluniversemodule.cpp b/modules/digitaluniverse/digitaluniversemodule.cpp
index 472905b0a3..24b052a374 100644
--- a/modules/digitaluniverse/digitaluniversemodule.cpp
+++ b/modules/digitaluniverse/digitaluniversemodule.cpp
@@ -36,7 +36,7 @@
 #include <modules/digitaluniverse/rendering/renderableplanescloud.h>
 #include <modules/digitaluniverse/rendering/renderabledumeshes.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 
 namespace openspace {
 
diff --git a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
index efa840cffc..cfda8dbff7 100644
--- a/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
+++ b/modules/digitaluniverse/rendering/renderablebillboardscloud.cpp
@@ -30,7 +30,8 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/cachemanager.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/templatefactory.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
@@ -729,7 +730,7 @@ void RenderableBillboardsCloud::renderBillboards(const RenderData& data,
         "screenSize",
         glm::vec2(OsEng.renderEngine().renderingResolution())
     );
-    
+
     _program->setUniform(_uniformCache.modelViewProjection, projMatrix * modelViewMatrix);
     _program->setUniform(
         _uniformCache.cameraPos,
@@ -807,8 +808,6 @@ void RenderableBillboardsCloud::renderLabels(const RenderData& data,
                                              const glm::dvec3& orthoUp,
                                              float fadeInVariable)
 {
-    RenderEngine& renderEngine = OsEng.renderEngine();
-
     float scale = 0.0;
     switch (_unit) {
     case Meter:
@@ -993,11 +992,11 @@ void RenderableBillboardsCloud::update(const UpdateData&) {
 
         if (_vao == 0) {
             glGenVertexArrays(1, &_vao);
-            LDEBUG("Generating Vertex Array id '" << _vao << "'");
+            LDEBUG(fmt::format("Generating Vertex Array id '{}'", _vao));
         }
         if (_vbo == 0) {
             glGenBuffers(1, &_vbo);
-            LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
+            LDEBUG(fmt::format("Generating Vertex Buffer Object id '{}'", _vbo));
         }
 
         glBindVertexArray(_vao);
@@ -1062,7 +1061,10 @@ void RenderableBillboardsCloud::update(const UpdateData&) {
                 absPath(_spriteTexturePath)
             );
             if (_spriteTexture) {
-                LINFO("Loaded texture from '" << absPath(_spriteTexturePath) << "'");
+                LINFO(fmt::format(
+                    "Loaded texture from '{}'",
+                    absPath(_spriteTexturePath)
+                ));
                 _spriteTexture->uploadTexture();
             }
             _spriteTexture->setFilter(
@@ -1115,10 +1117,11 @@ bool RenderableBillboardsCloud::loadSpeckData() {
 
         bool hasCachedFile = FileSys.fileExists(cachedFile);
         if (hasCachedFile) {
-            LINFO(
-                "Cached file '" << cachedFile << "' used for Speck file '" <<
-                _file << "'"
-            );
+            LINFO(fmt::format(
+                "Cached file '{}' used for Speck file '{}'",
+                cachedFile,
+                _file
+            ));
 
             success = loadCachedFile(cachedFile);
             if (success) {
@@ -1131,9 +1134,9 @@ bool RenderableBillboardsCloud::loadSpeckData() {
             }
         }
         else {
-            LINFO("Cache for Speck file '" << _file << "' not found");
+            LINFO(fmt::format("Cache for Speck file '{}' not found", _file));
         }
-        LINFO("Loading Speck file '" << _file << "'");
+        LINFO(fmt::format("Loading Speck file '{}'", _file));
 
         success = readSpeckFile();
         if (!success) {
@@ -1159,10 +1162,11 @@ bool RenderableBillboardsCloud::loadLabelData() {
         }
         bool hasCachedFile = FileSys.fileExists(cachedFile);
         if (hasCachedFile) {
-            LINFO(
-                "Cached file '" << cachedFile << "' used for Label file '" <<
-                labelFile << "'"
-            );
+            LINFO(fmt::format(
+                "Cached file '{}' used for Label file '{}'",
+                cachedFile,
+                labelFile
+            ));
 
             success &= loadCachedFile(cachedFile);
             if (!success) {
@@ -1172,8 +1176,8 @@ bool RenderableBillboardsCloud::loadLabelData() {
             }
         }
         else {
-            LINFO("Cache for Label file '" << labelFile << "' not found");
-            LINFO("Loading Label file '" << labelFile << "'");
+            LINFO(fmt::format("Cache for Label file '{}' not found", labelFile));
+            LINFO(fmt::format("Loading Label file '{}'", labelFile));
 
             success &= readLabelFile();
             if (!success) {
@@ -1190,7 +1194,7 @@ bool RenderableBillboardsCloud::readSpeckFile() {
     std::string _file = _speckFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Speck file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Speck file '{}'", _file));
         return false;
     }
 
@@ -1280,7 +1284,7 @@ bool RenderableBillboardsCloud::readColorMapFile() {
     std::string _file = _colorMapFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Color Map file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Color Map file '{}'", _file));
         return false;
     }
 
@@ -1329,7 +1333,7 @@ bool RenderableBillboardsCloud::readLabelFile() {
     std::string _file = _labelFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Label file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Label file '{}'", _file));
         return false;
     }
 
@@ -1464,7 +1468,7 @@ bool RenderableBillboardsCloud::loadCachedFile(const std::string& file) {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for loading cache file");
+        LERROR(fmt::format("Error opening file '{}' for loading cache file", file));
         return false;
     }
 }
@@ -1516,7 +1520,7 @@ bool RenderableBillboardsCloud::saveCachedFile(const std::string& file) const {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", file));
         return false;
     }
 }
diff --git a/modules/digitaluniverse/rendering/renderabledumeshes.cpp b/modules/digitaluniverse/rendering/renderabledumeshes.cpp
index af0fe19bfb..6d6e4aaa77 100644
--- a/modules/digitaluniverse/rendering/renderabledumeshes.cpp
+++ b/modules/digitaluniverse/rendering/renderabledumeshes.cpp
@@ -30,7 +30,7 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/templatefactory.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
@@ -644,7 +644,7 @@ bool RenderableDUMeshes::loadData() {
         // else
         // {
         //     LINFO("Cache for Speck file '" << _file << "' not found");
-            LINFO("Loading Speck file '" << _file << "'");
+            LINFO(fmt::format("Loading Speck file '{}'", _file));
 
             success = readSpeckFile();
             if (!success) {
@@ -679,7 +679,7 @@ bool RenderableDUMeshes::loadData() {
         // }
         // else {
         //     LINFO("Cache for Label file '" << labelFile << "' not found");
-            LINFO("Loading Label file '" << labelFile << "'");
+            LINFO(fmt::format("Loading Label file '{}'", labelFile));
 
             success &= readLabelFile();
             if (!success) {
@@ -696,7 +696,7 @@ bool RenderableDUMeshes::readSpeckFile() {
     std::string _file = _speckFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Speck file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Speck file '{}'", _file));
         return false;
     }
 
@@ -820,7 +820,7 @@ bool RenderableDUMeshes::readLabelFile() {
     std::string _file = _labelFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Label file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Label file '{}'", _file));
         return false;
     }
 
@@ -933,7 +933,7 @@ bool RenderableDUMeshes::loadCachedFile(const std::string& file) {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for loading cache file");
+        LERROR(fmt::format("Error opening file '{}' for loading cache file", file));
         return false;
     }
 }
@@ -966,7 +966,7 @@ bool RenderableDUMeshes::saveCachedFile(const std::string& file) const {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", file));
         return false;
     }
 }
diff --git a/modules/digitaluniverse/rendering/renderableplanescloud.cpp b/modules/digitaluniverse/rendering/renderableplanescloud.cpp
index e5f3c8d358..70d59fd4b8 100644
--- a/modules/digitaluniverse/rendering/renderableplanescloud.cpp
+++ b/modules/digitaluniverse/rendering/renderableplanescloud.cpp
@@ -30,7 +30,7 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/templatefactory.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
@@ -869,7 +869,7 @@ bool RenderablePlanesCloud::loadData() {
         // else
         // {
         //     LINFO("Cache for Speck file '" << _file << "' not found");
-            LINFO("Loading Speck file '" << _file << "'");
+        LINFO(fmt::format("Loading Speck file '{}'", _file));
 
             success = readSpeckFile();
             if (!success) {
@@ -905,7 +905,7 @@ bool RenderablePlanesCloud::loadData() {
         // else
         // {
         //     LINFO("Cache for Label file '" << labelFile << "' not found");
-            LINFO("Loading Label file '" << labelFile << "'");
+            LINFO(fmt::format("Loading Label file '{}'", labelFile));
 
             success &= readLabelFile();
             if (!success) {
@@ -928,7 +928,7 @@ bool RenderablePlanesCloud::loadTextures() {
             if (p.second) {
                 LINFOC(
                     "RenderablePlanesCloud",
-                    "Loaded texture from '" << pair.second << "'"
+                    fmt::format("Loaded texture from '{}'", pair.second)
                 );
                 auto it = p.first;
                 it->second->uploadTexture();
@@ -946,7 +946,7 @@ bool RenderablePlanesCloud::readSpeckFile() {
     std::string _file = _speckFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Speck file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Speck file '{}'", _file));
         return false;
     }
 
@@ -1117,7 +1117,7 @@ bool RenderablePlanesCloud::readLabelFile() {
     std::string _file = _labelFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Label file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Label file '{}'", _file));
         return false;
     }
 
@@ -1228,7 +1228,7 @@ bool RenderablePlanesCloud::loadCachedFile(const std::string& file) {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for loading cache file");
+        LERROR(fmt::format("Error opening file '{}' for loading cache file", file));
         return false;
     }
 }
@@ -1261,7 +1261,7 @@ bool RenderablePlanesCloud::saveCachedFile(const std::string& file) const {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", file));
         return false;
     }
 }
diff --git a/modules/digitaluniverse/rendering/renderablepoints.cpp b/modules/digitaluniverse/rendering/renderablepoints.cpp
index 809e11e950..12f7351d60 100644
--- a/modules/digitaluniverse/rendering/renderablepoints.cpp
+++ b/modules/digitaluniverse/rendering/renderablepoints.cpp
@@ -30,7 +30,8 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/cachemanager.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/templatefactory.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
@@ -369,11 +370,9 @@ void RenderablePoints::update(const UpdateData&) {
 
         if (_vao == 0) {
             glGenVertexArrays(1, &_vao);
-            LDEBUG("Generating Vertex Array id '" << _vao << "'");
         }
         if (_vbo == 0) {
             glGenBuffers(1, &_vbo);
-            LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
         }
 
         glBindVertexArray(_vao);
@@ -436,7 +435,10 @@ void RenderablePoints::update(const UpdateData&) {
                 absPath(_spriteTexturePath)
             );
             if (_spriteTexture) {
-                LDEBUG("Loaded texture from '" << absPath(_spriteTexturePath) << "'");
+                LDEBUG(fmt::format(
+                    "Loaded texture from '{}'",
+                    absPath(_spriteTexturePath)
+                ));
                 _spriteTexture->uploadTexture();
             }
             _spriteTexture->setFilter(
@@ -462,9 +464,11 @@ bool RenderablePoints::loadData() {
 
     bool hasCachedFile = FileSys.fileExists(cachedFile);
     if (hasCachedFile) {
-        LINFO(
-            "Cached file '" << cachedFile << "' used for Speck file '" << _file << "'"
-        );
+        LINFO(fmt::format(
+            "Cached file '{}' used for Speck file '{}'",
+            cachedFile,
+            _file
+        ));
 
         bool success = loadCachedFile(cachedFile);
         if (success) {
@@ -480,9 +484,9 @@ bool RenderablePoints::loadData() {
         }
     }
     else {
-        LINFO("Cache for Speck file '" << _file << "' not found");
+        LINFO(fmt::format("Cache for Speck file '{}' not found", _file));
     }
-    LINFO("Loading Speck file '" << _file << "'");
+    LINFO(fmt::format("Loading Speck file '{}'", _file));
 
     bool success = readSpeckFile();
     if (!success) {
@@ -503,7 +507,7 @@ bool RenderablePoints::readSpeckFile() {
     std::string _file = _speckFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Speck file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Speck file '{}'", _file));
         return false;
     }
 
@@ -571,7 +575,7 @@ bool RenderablePoints::readColorMapFile() {
     std::string _file = _colorMapFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Color Map file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Color Map file '{}'", _file));
         return false;
     }
 
@@ -643,7 +647,10 @@ bool RenderablePoints::loadCachedFile(const std::string& file) {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for loading cache file");
+        LERROR(fmt::format(
+            "Error opening file '{}' for loading cache file",
+            file
+        ));
         return false;
     }
 }
@@ -676,7 +683,7 @@ bool RenderablePoints::saveCachedFile(const std::string& file) const {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", file));
         return false;
     }
 }
diff --git a/modules/fieldlines/rendering/renderablefieldlines.cpp b/modules/fieldlines/rendering/renderablefieldlines.cpp
index 6f4db47149..88dbd58b0b 100644
--- a/modules/fieldlines/rendering/renderablefieldlines.cpp
+++ b/modules/fieldlines/rendering/renderablefieldlines.cpp
@@ -136,20 +136,17 @@ RenderableFieldlines::RenderableFieldlines(const ghoul::Dictionary& dictionary)
 
     bool success = dictionary.getValue(keyVectorField, _vectorFieldInfo);
     if (!success) {
-        LERROR("Renderable does not contain a key for '" <<
-            keyVectorField << "'");
+        LERROR(fmt::format("Renderable does not contain a key for '{}'", keyVectorField));
     }
 
     success = dictionary.getValue(keyFieldlines, _fieldlineInfo);
     if (!success) {
-        LERROR("Renderable does not contain a key for '" <<
-            keyFieldlines << "'");
+        LERROR(fmt::format("Renderable does not contain a key for '{}'", keyFieldlines));
     }
 
     success = dictionary.getValue(keySeedPoints, _seedPointsInfo);
     if (!success) {
-        LERROR("Renderable does not contain a key for '" <<
-            keySeedPoints << "'");
+        LERROR(fmt::format("Renderable does not contain a key for '{}", keySeedPoints));
     }
 
     // @TODO a non-magic number perhaps ---abock
@@ -320,7 +317,7 @@ void RenderableFieldlines::update(const UpdateData&) {
                 fieldlines[j].end()
             );
         }
-        LDEBUG("Number of vertices : " << vertexData.size());
+        LDEBUG(fmt::format("Number of vertices: {}", vertexData.size()));
 
         if (_fieldlineVAO == 0) {
             glGenVertexArrays(1, &_fieldlineVAO);
@@ -358,7 +355,7 @@ void RenderableFieldlines::update(const UpdateData&) {
             GL_FLOAT,
             GL_FALSE,
             sizeof(LinePoint),
-            (void*)(sizeof(glm::vec3))
+            reinterpret_cast<void*>(sizeof(glm::vec3))
         );
 
         glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -383,13 +380,14 @@ void RenderableFieldlines::loadSeedPoints() {
 }
 
 void RenderableFieldlines::loadSeedPointsFromFile() {
-    LINFO("Reading seed points from file '" << _seedPointSourceFile.value() << "'");
+    LINFO(fmt::format("Reading seed points from '{}'", _seedPointSourceFile.value()));
 
     std::ifstream seedFile(_seedPointSourceFile);
     if (!seedFile.good())
-        LERROR(
-            "Could not open seed points file '" << _seedPointSourceFile.value() << "'"
-        );
+        LERROR(fmt::format(
+            "Could not open seed points file '{}'",
+            _seedPointSourceFile.value()
+        ));
     else {
         std::string line;
         glm::vec3 point;
@@ -419,8 +417,11 @@ std::vector<RenderableFieldlines::Line> RenderableFieldlines::generateFieldlines
     std::string type;
     bool success = _vectorFieldInfo.getValue(keyVectorFieldType, type);
     if (!success) {
-        LERROR(keyVectorField << " does not contain a '" <<
-            keyVectorFieldType << "' key");
+        LERROR(fmt::format(
+            "{} does not contain a '{}' key",
+            keyVectorField,
+            keyVectorFieldType
+        ));
         return {};
     }
 
@@ -428,8 +429,11 @@ std::vector<RenderableFieldlines::Line> RenderableFieldlines::generateFieldlines
         return generateFieldlinesVolumeKameleon();
     }
     else {
-        LERROR(keyVectorField << "." << keyVectorFieldType <<
-            " does not name a valid type");
+        LERROR(fmt::format(
+            "{}.{} does not name a valid type",
+            keyVectorField,
+            keyVectorFieldType
+        ));
         return {};
     }
 }
@@ -440,14 +444,14 @@ RenderableFieldlines::generateFieldlinesVolumeKameleon()
     std::string model;
     bool success = _vectorFieldInfo.getValue(keyVectorFieldVolumeModel, model);
     if (!success) {
-        LERROR(keyVectorField << " does not name a model");
+        LERROR(fmt::format("{} does not name a model", keyVectorField));
         return {};
     }
 
     std::string fileName;
     success = _vectorFieldInfo.getValue(keyVectorFieldFile, fileName);
     if (!success) {
-        LERROR(keyVectorField << " does not name a file");
+        LERROR(fmt::format("{} does not name a file", keyVectorField));
         return {};
     }
     fileName = absPath(fileName);
@@ -456,8 +460,12 @@ RenderableFieldlines::generateFieldlinesVolumeKameleon()
     if (model != vectorFieldKameleonModelBATSRUS) {
         //modelType = KameleonWrapper::Model::BATSRUS;
     //else {
-        LERROR(keyVectorField << "." << keyVectorFieldVolumeModel << " model '" <<
-            model << "' not supported");
+        LERROR(fmt::format(
+            "{}.{} model '{}' not supported",
+            keyVectorField,
+            keyVectorFieldVolumeModel,
+            model
+        ));
         return {};
     }
 
@@ -475,7 +483,7 @@ RenderableFieldlines::generateFieldlinesVolumeKameleon()
       (_vectorFieldInfo.value<std::string>(v1) == vectorFieldKameleonVariableLorentz);
 
     if (!threeVariables && !lorentzForce) {
-        LERROR(keyVectorField << " does not name variables");
+        LERROR(fmt::format("'{}' does not name variables", keyVectorField));
         return {};
     }
 
diff --git a/modules/fieldlinessequence/CMakeLists.txt b/modules/fieldlinessequence/CMakeLists.txt
index 97d9bd6559..c17e1937a8 100644
--- a/modules/fieldlinessequence/CMakeLists.txt
+++ b/modules/fieldlinessequence/CMakeLists.txt
@@ -34,7 +34,6 @@ source_group("Header Files" FILES ${HEADER_FILES})
 
 set(SOURCE_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderablefieldlinessequence.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderablefieldlinessequencesetup.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/util/fieldlinesstate.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/util/commons.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/util/kameleonfieldlinehelper.cpp
diff --git a/modules/fieldlinessequence/fieldlinessequencemodule.cpp b/modules/fieldlinessequence/fieldlinessequencemodule.cpp
index f1094fd14d..a9b75a07b7 100644
--- a/modules/fieldlinessequence/fieldlinessequencemodule.cpp
+++ b/modules/fieldlinessequence/fieldlinessequencemodule.cpp
@@ -24,19 +24,40 @@
 
 #include <modules/fieldlinessequence/fieldlinessequencemodule.h>
 
+#include <modules/fieldlinessequence/rendering/renderablefieldlinessequence.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderable.h>
 #include <openspace/util/factorymanager.h>
-
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/assert.h>
+#include <fstream>
 
-#include <modules/fieldlinessequence/rendering/renderablefieldlinessequence.h>
+namespace {
+    constexpr const char* DefaultTransferfunctionSource =
+R"(
+width 5
+lower 0.0
+upper 1.0
+mappingkey 0.0   0    0    0    255
+mappingkey 0.25  255  0    0    255
+mappingkey 0.5   255  140  0    255
+mappingkey 0.75  255  255  0    255
+mappingkey 1.0   255  255  255  255
+)";
+} // namespace
 
 namespace openspace {
 
+std::string FieldlinesSequenceModule::DefaultTransferFunctionFile = "";
+
 FieldlinesSequenceModule::FieldlinesSequenceModule()
-    : OpenSpaceModule("FieldlinesSequence")
-{}
+    : OpenSpaceModule(Name)
+{
+    DefaultTransferFunctionFile = absPath("${TEMPORARY}/default_transfer_function.txt");
+
+    std::ofstream file(DefaultTransferFunctionFile);
+    file << DefaultTransferfunctionSource;
+}
 
 void FieldlinesSequenceModule::internalInitialize(const ghoul::Dictionary&) {
     auto factory = FactoryManager::ref().factory<Renderable>();
diff --git a/modules/fieldlinessequence/fieldlinessequencemodule.h b/modules/fieldlinessequence/fieldlinessequencemodule.h
index f967b5d2a3..647a4d8b51 100644
--- a/modules/fieldlinessequence/fieldlinessequencemodule.h
+++ b/modules/fieldlinessequence/fieldlinessequencemodule.h
@@ -31,8 +31,12 @@ namespace openspace {
 
 class FieldlinesSequenceModule : public OpenSpaceModule {
 public:
+    constexpr static const char* Name = "FieldlinesSequence";
+
     FieldlinesSequenceModule();
 
+    static std::string DefaultTransferFunctionFile;
+
 private:
     void internalInitialize(const ghoul::Dictionary&) override;
 };
diff --git a/modules/fieldlinessequence/rendering/renderablefieldlinessequence.cpp b/modules/fieldlinessequence/rendering/renderablefieldlinessequence.cpp
index 0e65f536fd..68286100ec 100644
--- a/modules/fieldlinessequence/rendering/renderablefieldlinessequence.cpp
+++ b/modules/fieldlinessequence/rendering/renderablefieldlinessequence.cpp
@@ -24,25 +24,971 @@
 
 #include <modules/fieldlinessequence/rendering/renderablefieldlinessequence.h>
 
+#include <modules/fieldlinessequence/fieldlinessequencemodule.h>
+#include <modules/fieldlinessequence/util/kameleonfieldlinehelper.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
+#include <openspace/interaction/navigationhandler.h>
 #include <openspace/rendering/renderengine.h>
+#include <openspace/scene/scene.h>
+#include <openspace/scene/scenegraphnode.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/updatestructures.h>
-
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/textureunit.h>
+#include <fstream>
+#include <sstream>
 
 namespace {
-    std::string _loggerCat = "RenderableFieldlinesSequence";
+    constexpr const char* _loggerCat = "RenderableFieldlinesSequence";
 
     const GLuint VaPosition = 0; // MUST CORRESPOND TO THE SHADER PROGRAM
     const GLuint VaColor    = 1; // MUST CORRESPOND TO THE SHADER PROGRAM
     const GLuint VaMasking  = 2; // MUST CORRESPOND TO THE SHADER PROGRAM
+
+    // ----- KEYS POSSIBLE IN MODFILE. EXPECTED DATA TYPE OF VALUE IN [BRACKETS]  ----- //
+    // ---------------------------- MANDATORY MODFILE KEYS ---------------------------- //
+    // [STRING] "cdf", "json" or "osfls"
+    constexpr const char* KeyInputFileType = "InputFileType";
+    // [STRING] should be path to folder containing the input files
+    constexpr const char* KeySourceFolder = "SourceFolder";
+
+    // ---------------------- MANDATORY INPUT TYPE SPECIFIC KEYS ---------------------- //
+    // [STRING] Path to a .txt file containing seed points
+    constexpr const char* KeyCdfSeedPointFile = "SeedPointFile";
+    // [STRING] Currently supports: "batsrus", "enlil" & "pfss"
+    constexpr const char* KeyJsonSimulationModel = "SimulationModel";
+
+    // ----------------------- OPTIONAL INPUT TYPE SPECIFIC KEYS ---------------------- //
+    // [STRING ARRAY]
+    constexpr const char* KeyCdfExtraVariables = "ExtraVariables";
+    // [STRING]
+    constexpr const char* KeyCdfTracingVariable = "TracingVariable";
+    // [STRING]
+    constexpr const char* KeyJsonScalingFactor = "ScaleToMeters";
+    // [BOOLEAN] If value False => Load in initializing step and store in RAM
+    constexpr const char* KeyOslfsLoadAtRuntime = "LoadAtRuntime";
+
+    // ---------------------------- OPTIONAL MODFILE KEYS  ---------------------------- //
+    // [STRING ARRAY] Values should be paths to .txt files
+    constexpr const char* KeyColorTablePaths = "ColorTablePaths";
+    // [VEC2 ARRAY] Values should be entered as {X, Y}, where X & Y are numbers
+    constexpr const char* KeyColorTableRanges = "ColorTableRanges";
+    // [VEC2 ARRAY] Values should be entered as {X, Y}, where X & Y are numbers
+    constexpr const char* KeyMaskingRanges = "MaskingRanges";
+    // [STRING] Value should be path to folder where states are saved (JSON/CDF input
+    // => osfls output & oslfs input => JSON output)
+    constexpr const char* KeyOutputFolder = "OutputFolder";
+
+    // ------------- POSSIBLE STRING VALUES FOR CORRESPONDING MODFILE KEY ------------- //
+    constexpr const char* ValueInputFileTypeCdf = "cdf";
+    constexpr const char* ValueInputFileTypeJson = "json";
+    constexpr const char* ValueInputFileTypeOsfls = "osfls";
+
+    // --------------------------------- Property Info -------------------------------- //
+    static const openspace::properties::Property::PropertyInfo ColorMethodInfo = {
+        "colorMethod",
+        "Color Method",
+        "Color lines uniformly or using color tables based on extra quantities like, for "
+        "examples, temperature or particle density."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorQuantityInfo = {
+        "colorQuantity",
+        "Quantity to Color By",
+        "Quantity used to color lines if the 'By Quantity' color method is selected."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorQuantityMinInfo = {
+        "colorQuantityMin",
+        "ColorTable Min Value",
+        "Value to map to the lowest end of the color table."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorQuantityMaxInfo = {
+        "colorQuantityMax",
+        "ColorTable Max Value",
+        "Value to map to the highest end of the color table."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorTablePathInfo = {
+        "colorTablePath",
+        "Path to Color Table",
+        "Color Table/Transfer Function to use for 'By Quantity' coloring."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorUniformInfo = {
+        "uniform",
+        "Uniform Line Color",
+        "The uniform color of lines shown when 'Color Method' is set to 'Uniform'."
+    };
+    static const openspace::properties::Property::PropertyInfo ColorUseABlendingInfo = {
+        "aBlendingEnabled",
+        "Additive Blending",
+        "Activate/deactivate additive blending."
+    };
+    static const openspace::properties::Property::PropertyInfo DomainEnabledInfo = {
+        "domainEnabled",
+        "Domain Limits",
+        "Enable/Disable domain limits"
+    };
+    static const openspace::properties::Property::PropertyInfo DomainXInfo = {
+        "limitsX",
+        "X-limits",
+        "Valid range along the X-axis. [Min, Max]"
+    };
+    static const openspace::properties::Property::PropertyInfo DomainYInfo = {
+        "limitsY",
+        "Y-limits",
+        "Valid range along the Y-axis. [Min, Max]"
+    };
+    static const openspace::properties::Property::PropertyInfo DomainZInfo = {
+        "limitsZ",
+        "Z-limits",
+        "Valid range along the Z-axis. [Min, Max]"
+    };
+    static const openspace::properties::Property::PropertyInfo DomainRInfo = {
+        "limitsR",
+        "Radial limits",
+        "Valid radial range. [Min, Max]"
+    };
+    static const openspace::properties::Property::PropertyInfo FlowColorInfo = {
+        "color",
+        "Color",
+        "Color of particles."
+    };
+    static const openspace::properties::Property::PropertyInfo FlowEnabledInfo = {
+        "flowEnabled",
+        "Flow Direction",
+        "Toggles the rendering of moving particles along the lines. Can, for example, "
+        "illustrate magnetic flow."
+    };
+    static const openspace::properties::Property::PropertyInfo FlowReversedInfo = {
+        "reversed",
+        "Reversed Flow",
+        "Toggle to make the flow move in the opposite direction."
+    };
+    static const openspace::properties::Property::PropertyInfo FlowParticleSizeInfo = {
+        "particleSize",
+        "Particle Size",
+        "Size of the particles."
+    };
+    static const openspace::properties::Property::PropertyInfo FlowParticleSpacingInfo = {
+        "particleSpacing",
+        "Particle Spacing",
+        "Spacing inbetween particles."
+    };
+    static const openspace::properties::Property::PropertyInfo FlowSpeedInfo = {
+        "speed",
+        "Speed",
+        "Speed of the flow."
+    };
+    static const openspace::properties::Property::PropertyInfo MaskingEnabledInfo = {
+        "maskingEnabled",
+        "Masking",
+        "Enable/disable masking. Use masking to show lines where a given quantity is "
+        "within a given range, for example, if you only want to see where the "
+        "temperature is between 10 and 20 degrees. Also used for masking out line "
+        "topologies like solar wind & closed lines."
+    };
+    static const openspace::properties::Property::PropertyInfo MaskingMinInfo = {
+        "maskingMinLimit",
+        "Lower Limit",
+        "Lower limit of the valid masking range"
+    };
+    static const openspace::properties::Property::PropertyInfo MaskingMaxInfo = {
+        "maskingMaxLimit",
+        "Upper Limit",
+        "Upper limit of the valid masking range"
+    };
+    static const openspace::properties::Property::PropertyInfo MaskingQuantityInfo = {
+        "maskingQuantity",
+        "Quantity used for Masking",
+        "Quantity used for masking."
+    };
+    static const openspace::properties::Property::PropertyInfo OriginButtonInfo = {
+        "focusCameraOnParent",
+        "Focus Camera",
+        "Focus camera on parent."
+    };
+    static const openspace::properties::Property::PropertyInfo TimeJumpButtonInfo = {
+        "timeJumpToStart",
+        "Jump to Start Of Sequence",
+        "Performs a time jump to the start of the sequence."
+    };
+
+    enum class SourceFileType : int {
+        Cdf = 0,
+        Json,
+        Osfls,
+        Invalid
+    };
+
+    float stringToFloat(const std::string input, const float backupValue = 0.f) {
+        float tmp;
+        try {
+            tmp = std::stof(input);
+        }
+        catch (const std::invalid_argument& ia) {
+            LWARNING(fmt::format(
+                "Invalid argument: {}. '{}' is NOT a valid number", ia.what(), input
+            ));
+            return backupValue;
+        }
+        return tmp;
+    }
 } // namespace
 
 namespace openspace {
+using namespace properties;
 
-void RenderableFieldlinesSequence::deinitialize() {
+RenderableFieldlinesSequence::RenderableFieldlinesSequence(
+                                                      const ghoul::Dictionary& dictionary)
+    : Renderable(dictionary)
+    , _pColorGroup({ "Color" })
+    , _pColorMethod(ColorMethodInfo, OptionProperty::DisplayType::Radio)
+    , _pColorQuantity(ColorQuantityInfo, OptionProperty::DisplayType::Dropdown)
+    , _pColorQuantityMin(ColorQuantityMinInfo)
+    , _pColorQuantityMax(ColorQuantityMaxInfo)
+    , _pColorTablePath(ColorTablePathInfo)
+    , _pColorUniform(
+        ColorUniformInfo,
+        glm::vec4(0.75f, 0.5f, 0.0f, 0.5f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _pColorABlendEnabled(ColorUseABlendingInfo, true)
+    , _pDomainEnabled(DomainEnabledInfo, true)
+    , _pDomainGroup({ "Domain" })
+    , _pDomainX(DomainXInfo)
+    , _pDomainY(DomainYInfo)
+    , _pDomainZ(DomainZInfo)
+    , _pDomainR(DomainRInfo)
+    , _pFlowColor(
+        FlowColorInfo,
+        glm::vec4(0.8f, 0.7f, 0.0f, 0.6f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _pFlowEnabled(FlowEnabledInfo, true)
+    , _pFlowGroup({ "Flow" })
+    , _pFlowParticleSize(FlowParticleSizeInfo, 5, 0, 500)
+    , _pFlowParticleSpacing(FlowParticleSpacingInfo, 60, 0, 500)
+    , _pFlowReversed(FlowReversedInfo, false)
+    , _pFlowSpeed(FlowSpeedInfo, 20, 0, 1000)
+    , _pMaskingEnabled(MaskingEnabledInfo, false)
+    , _pMaskingGroup({ "Masking" })
+    , _pMaskingMin(MaskingMinInfo)
+    , _pMaskingMax(MaskingMaxInfo)
+    , _pMaskingQuantity(MaskingQuantityInfo, OptionProperty::DisplayType::Dropdown)
+    , _pFocusOnOriginBtn(OriginButtonInfo)
+    , _pJumpToStartBtn(TimeJumpButtonInfo)
+{
+    _dictionary = std::make_unique<ghoul::Dictionary>(dictionary);
+}
+
+void RenderableFieldlinesSequence::initializeGL() {
+    // EXTRACT MANDATORY INFORMATION FROM DICTIONARY
+    SourceFileType sourceFileType = SourceFileType::Invalid;
+    if (!extractMandatoryInfoFromDictionary(sourceFileType)) {
+        return;
+    }
+
+    // Set a default color table, just in case the (optional) user defined paths are
+    // corrupt or not provided!
+    _colorTablePaths.push_back(
+        FieldlinesSequenceModule::DefaultTransferFunctionFile
+    );
+    _transferFunction = std::make_unique<TransferFunction>(absPath(_colorTablePaths[0]));
+
+    // EXTRACT OPTIONAL INFORMATION FROM DICTIONARY
+    std::string outputFolderPath;
+    extractOptionalInfoFromDictionary(outputFolderPath);
+
+    // EXTRACT SOURCE FILE TYPE SPECIFIC INFOMRATION FROM DICTIONARY & GET STATES FROM
+    // SOURCE
+    switch (sourceFileType) {
+        case SourceFileType::Cdf:
+            if (!getStatesFromCdfFiles(outputFolderPath)) {
+                return;
+            }
+            break;
+        case SourceFileType::Json:
+            if (!loadJsonStatesIntoRAM(outputFolderPath)) {
+                return;
+            }
+            break;
+        case SourceFileType::Osfls:
+            extractOsflsInfoFromDictionary();
+            if (_loadingStatesDynamically) {
+                if (!prepareForOsflsStreaming()) {
+                    return;
+                }
+            }
+            else {
+                loadOsflsStatesIntoRAM(outputFolderPath);
+            }
+            break;
+        default:
+            return;
+    }
+
+    // dictionary is no longer needed as everything is extracted
+    _dictionary.reset();
+
+    // No need to store source paths in memory if they are already in RAM!
+    if (!_loadingStatesDynamically) {
+        _sourceFiles.clear();
+    }
+
+    // At this point there should be at least one state loaded into memory!
+    if (_states.size() == 0) {
+        LERROR("Wasn't able to extract any valid states from provided source files!");
+        return;
+    }
+
+    computeSequenceEndTime();
+    setModelDependentConstants();
+
+    setupProperties();
+
+    // Setup shader program
+    _shaderProgram = OsEng.renderEngine().buildRenderProgram(
+        "FieldlinesSequence",
+        absPath("${MODULE_FIELDLINESSEQUENCE}/shaders/fieldlinessequence_vs.glsl"),
+        absPath("${MODULE_FIELDLINESSEQUENCE}/shaders/fieldlinessequence_fs.glsl")
+    );
+
+    //------------------ Initialize OpenGL VBOs and VAOs-------------------------------//
+    glGenVertexArrays(1, &_vertexArrayObject);
+    glGenBuffers(1, &_vertexPositionBuffer);
+    glGenBuffers(1, &_vertexColorBuffer);
+    glGenBuffers(1, &_vertexMaskingBuffer);
+
+    // Needed for additive blending
+    setRenderBin(Renderable::RenderBin::Overlay);
+}
+
+/**
+ * Extracts the general information (from the lua modfile) that is mandatory for the class
+ * to function; such as the file type and the location of the source files.
+ * Returns false if it fails to extract mandatory information!
+ */
+bool RenderableFieldlinesSequence::extractMandatoryInfoFromDictionary(
+                                                           SourceFileType& sourceFileType)
+{
+
+    _dictionary->getValue(SceneGraphNode::KeyName, _name);
+
+    // ------------------- EXTRACT MANDATORY VALUES FROM DICTIONARY ------------------- //
+    std::string inputFileTypeString;
+    if (!_dictionary->getValue(KeyInputFileType, inputFileTypeString)) {
+        LERROR(fmt::format(
+            "{}: The field {} is missing", _name, KeyInputFileType
+        ));
+    }
+    else {
+        std::transform(
+            inputFileTypeString.begin(),
+            inputFileTypeString.end(),
+            inputFileTypeString.begin(),
+            [](char c) { return static_cast<char>(tolower(c)); }
+        );
+        // Verify that the input type is correct
+        if (inputFileTypeString == ValueInputFileTypeCdf) {
+            sourceFileType = SourceFileType::Cdf;
+        }
+        else if (inputFileTypeString == ValueInputFileTypeJson) {
+            sourceFileType = SourceFileType::Json;
+        }
+        else if (inputFileTypeString == ValueInputFileTypeOsfls) {
+            sourceFileType = SourceFileType::Osfls;
+        }
+        else {
+            LERROR(fmt::format(
+                "{}: {} is not a recognized {}",
+                _name, inputFileTypeString, KeyInputFileType
+            ));
+            sourceFileType = SourceFileType::Invalid;
+            return false;
+        }
+    }
+
+    std::string sourceFolderPath;
+    if (!_dictionary->getValue(KeySourceFolder, sourceFolderPath)) {
+        LERROR(fmt::format(
+            "{}: The field {} is missing", _name, KeySourceFolder
+        ));
+        return false;
+    }
+
+    // Ensure that the source folder exists and then extract
+    // the files with the same extension as <inputFileTypeString>
+    ghoul::filesystem::Directory sourceFolder(sourceFolderPath);
+    if (FileSys.directoryExists(sourceFolder)) {
+        // Extract all file paths from the provided folder
+        _sourceFiles = sourceFolder.readFiles(
+            ghoul::filesystem::Directory::Recursive::No,
+            ghoul::filesystem::Directory::Sort::Yes
+        );
+
+        // Remove all files that don't have <inputFileTypeString> as extension
+        _sourceFiles.erase(std::remove_if(_sourceFiles.begin(), _sourceFiles.end(),
+            [inputFileTypeString](std::string str) {
+            const size_t extLength = inputFileTypeString.length();
+            std::string sub = str.substr(str.length() - extLength, extLength);
+            std::transform(
+                sub.begin(),
+                sub.end(),
+                sub.begin(),
+                [](char c) { return static_cast<char>(::tolower(c)); }
+            );
+            return sub != inputFileTypeString;
+        }), _sourceFiles.end());
+        // Ensure that there are available and valid source files left
+        if (_sourceFiles.empty()) {
+            LERROR(fmt::format(
+                "{}: {} contains no {} files",
+                _name, sourceFolderPath, inputFileTypeString
+            ));
+            return false;
+        }
+    }
+    else {
+        LERROR(fmt::format(
+            "{}: FieldlinesSequence {} is not a valid directory", _name, sourceFolderPath
+        ));
+        return false;
+    }
+
+    return true;
+}
+
+void RenderableFieldlinesSequence::extractOptionalInfoFromDictionary(
+    std::string& outputFolderPath) {
+
+    // ------------------- EXTRACT OPTIONAL VALUES FROM DICTIONARY ------------------- //
+    if (_dictionary->getValue(KeyOutputFolder, outputFolderPath)) {
+        ghoul::filesystem::Directory outputFolder(outputFolderPath);
+        if (FileSys.directoryExists(outputFolder)) {
+            outputFolderPath = absPath(outputFolderPath);
+        }
+        else {
+            LERROR(fmt::format(
+                "{}: The specified output path: '{}', does not exist",
+                _name, outputFolderPath
+            ));
+            outputFolderPath = "";
+        }
+    }
+
+    ghoul::Dictionary colorTablesPathsDictionary;
+    if (_dictionary->getValue(KeyColorTablePaths, colorTablesPathsDictionary)) {
+        const size_t nProvidedPaths = colorTablesPathsDictionary.size();
+        if (nProvidedPaths > 0) {
+            // Clear the default! It is already specified in the transferFunction
+            _colorTablePaths.clear();
+            for (size_t i = 1; i <= nProvidedPaths; ++i) {
+                _colorTablePaths.push_back(
+                    colorTablesPathsDictionary.value<std::string>(std::to_string(i)));
+            }
+        }
+    }
+
+    ghoul::Dictionary colorTablesRangesDictionary;
+    if (_dictionary->getValue(KeyColorTableRanges, colorTablesRangesDictionary)) {
+        const size_t nProvidedRanges = colorTablesRangesDictionary.size();
+        for (size_t i = 1; i <= nProvidedRanges; ++i) {
+            _colorTableRanges.push_back(
+                colorTablesRangesDictionary.value<glm::vec2>(std::to_string(i)));
+        }
+    }
+    else {
+        _colorTableRanges.push_back(glm::vec2(0, 1));
+    }
+
+    ghoul::Dictionary maskingRangesDictionary;
+    if (_dictionary->getValue(KeyMaskingRanges, maskingRangesDictionary)) {
+        const size_t nProvidedRanges = maskingRangesDictionary.size();
+        for (size_t i = 1; i <= nProvidedRanges; ++i) {
+            _maskingRanges.push_back(
+                maskingRangesDictionary.value<glm::vec2>(std::to_string(i)));
+        }
+    }
+    else {
+        _maskingRanges.push_back(glm::vec2(-100000, 100000)); // Just some default values!
+    }
+}
+
+/**
+ * Returns false if it fails to extract mandatory information!
+ */
+bool RenderableFieldlinesSequence::extractJsonInfoFromDictionary(fls::Model& model) {
+    std::string modelStr;
+    if (_dictionary->getValue(KeyJsonSimulationModel, modelStr)) {
+        std::transform(
+            modelStr.begin(),
+            modelStr.end(),
+            modelStr.begin(),
+            [](char c) { return static_cast<char>(::tolower(c)); }
+        );
+        model = fls::stringToModel(modelStr);
+    }
+    else {
+        LERROR(fmt::format(
+            "{}: Must specify '{}'", _name, KeyJsonSimulationModel
+        ));
+        return false;
+    }
+
+    float scaleFactor;
+    if (_dictionary->getValue(KeyJsonScalingFactor, scaleFactor)) {
+        _scalingFactor = scaleFactor;
+    }
+    else {
+        LWARNING(fmt::format(
+            "{}: Does not provide scalingFactor. Assumes coordinates are in meters",
+            _name
+        ));
+    }
+    return true;
+}
+
+bool RenderableFieldlinesSequence::loadJsonStatesIntoRAM(const std::string& outputFolder)
+{
+    fls::Model model;
+    if (!extractJsonInfoFromDictionary(model)) {
+        return false;
+    }
+    // Load states into RAM!
+    for (std::string filePath : _sourceFiles) {
+        FieldlinesState newState;
+        bool loadedSuccessfully = newState.loadStateFromJson(filePath, model,
+            _scalingFactor);
+        if (loadedSuccessfully) {
+            addStateToSequence(newState);
+            if (!outputFolder.empty()) {
+                newState.saveStateToOsfls(outputFolder);
+            }
+        }
+    }
+    return true;
+}
+
+bool RenderableFieldlinesSequence::prepareForOsflsStreaming() {
+    extractTriggerTimesFromFileNames();
+    FieldlinesState newState;
+    if (!newState.loadStateFromOsfls(_sourceFiles[0])) {
+        LERROR("The provided .osfls files seem to be corrupt!");
+        return false;
+    }
+    _states.push_back(newState);
+    _nStates = _startTimes.size();
+    _activeStateIndex = 0;
+    return true;
+
+}
+
+void RenderableFieldlinesSequence::loadOsflsStatesIntoRAM(const std::string& outputFolder)
+{
+    // Load states from .osfls files into RAM!
+    for (const std::string& filePath : _sourceFiles) {
+        FieldlinesState newState;
+        if (newState.loadStateFromOsfls(filePath)) {
+            addStateToSequence(newState);
+            if (!outputFolder.empty()) {
+                ghoul::filesystem::File tmpFile(filePath);
+                newState.saveStateToJson(outputFolder + tmpFile.baseName());
+            }
+        }
+        else {
+            LWARNING(fmt::format("Failed to load state from: {}", filePath));
+        }
+    }
+}
+
+void RenderableFieldlinesSequence::extractOsflsInfoFromDictionary() {
+    bool shouldLoadInRealtime = false;
+    if (_dictionary->getValue(KeyOslfsLoadAtRuntime, shouldLoadInRealtime)) {
+        _loadingStatesDynamically = shouldLoadInRealtime;
+    }
+    else {
+        LWARNING(fmt::format(
+            "{}: {} is not specified. States will be stored in RAM",
+            _name, KeyOslfsLoadAtRuntime
+        ));
+    }
+}
+
+void RenderableFieldlinesSequence::setupProperties() {
+    bool hasExtras = _states[0].nExtraQuantities() > 0;
+
+    // -------------- Add non-grouped properties (enablers and buttons) -------------- //
+    addProperty(_pColorABlendEnabled);
+    addProperty(_pDomainEnabled);
+    addProperty(_pFlowEnabled);
+    if (hasExtras) {
+        addProperty(_pMaskingEnabled);
+    }
+    addProperty(_pFocusOnOriginBtn);
+    addProperty(_pJumpToStartBtn);
+
+    // ----------------------------- Add Property Groups ----------------------------- //
+    addPropertySubOwner(_pColorGroup);
+    addPropertySubOwner(_pDomainGroup);
+    addPropertySubOwner(_pFlowGroup);
+    if (hasExtras) {
+        addPropertySubOwner(_pMaskingGroup);
+    }
+
+    // ------------------------- Add Properties to the groups ------------------------- //
+    _pColorGroup.addProperty(_pColorUniform);
+    _pDomainGroup.addProperty(_pDomainX);
+    _pDomainGroup.addProperty(_pDomainY);
+    _pDomainGroup.addProperty(_pDomainZ);
+    _pDomainGroup.addProperty(_pDomainR);
+    _pFlowGroup.addProperty(_pFlowReversed);
+    _pFlowGroup.addProperty(_pFlowColor);
+    _pFlowGroup.addProperty(_pFlowParticleSize);
+    _pFlowGroup.addProperty(_pFlowParticleSpacing);
+    _pFlowGroup.addProperty(_pFlowSpeed);
+    if (hasExtras) {
+        _pColorGroup.addProperty(_pColorMethod);
+        _pColorGroup.addProperty(_pColorQuantity);
+        _pColorGroup.addProperty(_pColorQuantityMin);
+        _pColorGroup.addProperty(_pColorQuantityMax);
+        _pColorGroup.addProperty(_pColorTablePath);
+        _pMaskingGroup.addProperty(_pMaskingMin);
+        _pMaskingGroup.addProperty(_pMaskingMax);
+        _pMaskingGroup.addProperty(_pMaskingQuantity);
+
+        // --------------------- Add Options to OptionProperties --------------------- //
+        _pColorMethod.addOption(static_cast<int>(ColorMethod::Uniform), "Uniform");
+        _pColorMethod.addOption(static_cast<int>(ColorMethod::ByQuantity), "By Quantity");
+        // Add option for each extra quantity. Assumes there are just as many names to
+        // extra quantities as there are extra quantities. Also assume that all states in
+        // the given sequence have the same extra quantities! */
+        const size_t nExtraQuantities = _states[0].nExtraQuantities();
+        const std::vector<std::string>& extraNamesVec = _states[0].extraQuantityNames();
+        for (int i = 0; i < static_cast<int>(nExtraQuantities); ++i) {
+            _pColorQuantity.addOption(i, extraNamesVec[i]);
+            _pMaskingQuantity.addOption(i, extraNamesVec[i]);
+        }
+        // Each quantity should have its own color table and color table range
+        // no more, no less
+        _colorTablePaths.resize(nExtraQuantities, _colorTablePaths.back());
+        _colorTableRanges.resize(nExtraQuantities, _colorTableRanges.back());
+        _maskingRanges.resize(nExtraQuantities, _maskingRanges.back());
+    }
+
+    definePropertyCallbackFunctions();
+
+    if (hasExtras) {
+        // Set defaults
+        _pColorQuantity = 0;
+        _pColorQuantityMin = std::to_string(_colorTableRanges[0].x);
+        _pColorQuantityMax = std::to_string(_colorTableRanges[0].y);
+        _pColorTablePath = _colorTablePaths[0];
+
+        _pMaskingQuantity = 0;
+        _pMaskingMin = std::to_string(_maskingRanges[0].x);
+        _pMaskingMax = std::to_string(_maskingRanges[0].y);
+    }
+}
+
+void RenderableFieldlinesSequence::definePropertyCallbackFunctions() {
+    // Add Property Callback Functions
+    bool hasExtras = _states[0].nExtraQuantities() > 0;
+    if (hasExtras) {
+        _pColorQuantity.onChange([this] {
+            _shouldUpdateColorBuffer = true;
+            _pColorQuantityMin = std::to_string(_colorTableRanges[_pColorQuantity].x);
+            _pColorQuantityMax = std::to_string(_colorTableRanges[_pColorQuantity].y);
+            _pColorTablePath = _colorTablePaths[_pColorQuantity];
+        });
+
+        _pColorTablePath.onChange([this] {
+            _transferFunction->setPath(_pColorTablePath);
+            _colorTablePaths[_pColorQuantity] = _pColorTablePath;
+        });
+
+        _pColorQuantityMin.onChange([this] {
+            float f = stringToFloat(
+                _pColorQuantityMin,
+                _colorTableRanges[_pColorQuantity].x
+            );
+            _pColorQuantityMin = std::to_string(f);
+            _colorTableRanges[_pColorQuantity].x = f;
+        });
+
+        _pColorQuantityMax.onChange([this] {
+            float f = stringToFloat(
+                _pColorQuantityMax,
+                _colorTableRanges[_pColorQuantity].y
+            );
+            _pColorQuantityMax = std::to_string(f);
+            _colorTableRanges[_pColorQuantity].y = f;
+        });
+
+        _pMaskingQuantity.onChange([this] {
+            _shouldUpdateMaskingBuffer = true;
+            _pMaskingMin = std::to_string(_maskingRanges[_pMaskingQuantity].x);
+            _pMaskingMax = std::to_string(_maskingRanges[_pMaskingQuantity].y);
+        });
+
+        _pMaskingMin.onChange([this] {
+            float f = stringToFloat(_pMaskingMin, _maskingRanges[_pMaskingQuantity].x);
+            _pMaskingMin = std::to_string(f);
+            _maskingRanges[_pMaskingQuantity].x = f;
+        });
+
+        _pMaskingMax.onChange([this] {
+            float f = stringToFloat(_pMaskingMax, _maskingRanges[_pMaskingQuantity].y);
+            _pMaskingMax = std::to_string(f);
+            _maskingRanges[_pMaskingQuantity].y = f;
+        });
+    }
+
+    _pFocusOnOriginBtn.onChange([this] {
+        SceneGraphNode* node = OsEng.renderEngine().scene()->sceneGraphNode(_name);
+        if (!node) {
+            LWARNING(fmt::format(
+                "Could not find a node in scenegraph called '{}'", _name
+            ));
+            return;
+        }
+        OsEng.navigationHandler().setFocusNode(node->parent());
+        OsEng.navigationHandler().resetCameraDirection();
+    });
+
+    _pJumpToStartBtn.onChange([this] {
+        OsEng.timeManager().time().setTime(_startTimes[0]);
+    });
+}
+
+// Calculate expected end time.
+void RenderableFieldlinesSequence::computeSequenceEndTime() {
+    if (_nStates > 1) {
+        const double lastTriggerTime = _startTimes[_nStates - 1];
+        const double sequenceDuration = lastTriggerTime - _startTimes[0];
+        const double averageStateDuration = sequenceDuration /
+            (static_cast<double>(_nStates) - 1.0);
+        _sequenceEndTime = lastTriggerTime + averageStateDuration;
+    }
+    else {
+        // If there's just one state it should never disappear!
+        _sequenceEndTime = DBL_MAX;
+    }
+}
+
+void RenderableFieldlinesSequence::setModelDependentConstants() {
+    const fls::Model simulationModel = _states[0].model();
+    float limit = 100.f; // Just used as a default value.
+    switch (simulationModel) {
+    case fls::Model::Batsrus:
+        _scalingFactor = fls::ReToMeter;
+        limit = 300; // Should include a long magnetotail
+        break;
+    case fls::Model::Enlil:
+        _pFlowReversed = true;
+        _scalingFactor = fls::AuToMeter;
+        limit = 50; // Should include Plutos furthest distance from the Sun
+        break;
+    case fls::Model::Pfss:
+        _scalingFactor = fls::RsToMeter;
+        limit = 100; // Just a default value far away from the solar surface
+        break;
+    default:
+        break;
+    }
+    _pDomainX.setMinValue(glm::vec2(-limit));
+    _pDomainX.setMaxValue(glm::vec2(limit));
+
+    _pDomainY.setMinValue(glm::vec2(-limit));
+    _pDomainY.setMaxValue(glm::vec2(limit));
+
+    _pDomainZ.setMinValue(glm::vec2(-limit));
+    _pDomainZ.setMaxValue(glm::vec2(limit));
+
+    // Radial should range from 0 out to a corner of the cartesian box:
+    // sqrt(3) = 1.732..., 1.75 is a nice and round number
+    _pDomainR.setMinValue(glm::vec2(0));
+    _pDomainR.setMaxValue(glm::vec2(limit * 1.75f));
+
+    _pDomainX = glm::vec2(-limit, limit);
+    _pDomainY = glm::vec2(-limit, limit);
+    _pDomainZ = glm::vec2(-limit, limit);
+    _pDomainR = glm::vec2(0, limit * 1.5f);
+}
+
+// Extract J2000 time from file names
+// Requires files to be named as such: 'YYYY-MM-DDTHH-MM-SS-XXX.osfls'
+void RenderableFieldlinesSequence::extractTriggerTimesFromFileNames() {
+    // number of  characters in filename (excluding '.osfls')
+    const size_t filenameSize = 23;
+    // size(".osfls")
+    const size_t extSize = 6;
+
+    for (const std::string& filePath : _sourceFiles) {
+        const size_t strLength = filePath.size();
+        // Extract the filename from the path (without extension)
+        std::string timeString = filePath.substr(
+            strLength - filenameSize - extSize,
+            filenameSize - 1
+        );
+        // Ensure the separators are correct
+        timeString.replace(4, 1, "-");
+        timeString.replace(7, 1, "-");
+        timeString.replace(13, 1, ":");
+        timeString.replace(16, 1, ":");
+        timeString.replace(19, 1, ".");
+        const double triggerTime = Time::convertTime(timeString);
+        _startTimes.push_back(triggerTime);
+    }
+}
+
+void RenderableFieldlinesSequence::addStateToSequence(FieldlinesState& state) {
+    _states.push_back(state);
+    _startTimes.push_back(state.triggerTime());
+    _nStates++;
+}
+
+bool RenderableFieldlinesSequence::getStatesFromCdfFiles(const std::string& outputFolder)
+{
+    std::string seedFilePath;
+    std::string tracingVar;
+    std::vector<std::string> extraVars;
+    if (!extractCdfInfoFromDictionary(seedFilePath, tracingVar, extraVars)) {
+        return false;
+    }
+
+    std::vector<glm::vec3> seedPoints;
+    if (!extractSeedPointsFromFile(seedFilePath, seedPoints)) {
+        return false;
+    }
+
+    std::vector<std::string> extraMagVars;
+    extractMagnitudeVarsFromStrings(extraVars, extraMagVars);
+
+    // Load states into RAM!
+    for (const std::string& cdfPath : _sourceFiles) {
+
+        FieldlinesState newState;
+        bool isSuccessful = fls::convertCdfToFieldlinesState(newState, cdfPath,
+            seedPoints, tracingVar, extraVars, extraMagVars);
+
+        if (isSuccessful) {
+            addStateToSequence(newState);
+            if (!outputFolder.empty()) {
+                newState.saveStateToOsfls(outputFolder);
+            }
+        }
+    }
+    return true;
+}
+
+/*
+* Returns false if it fails to extract mandatory information!
+*/
+bool RenderableFieldlinesSequence::extractCdfInfoFromDictionary(std::string& seedFilePath,
+                                                                std::string& tracingVar,
+                                                      std::vector<std::string>& extraVars)
+{
+
+    if (_dictionary->getValue(KeyCdfSeedPointFile, seedFilePath)) {
+        ghoul::filesystem::File seedPointFile(seedFilePath);
+        if (FileSys.fileExists(seedPointFile)) {
+            seedFilePath = absPath(seedFilePath);
+        }
+        else {
+            LERROR(fmt::format(
+                "{}: The specified seed poitn file: '{}' does not exist",
+                _name, seedFilePath
+            ));
+            return false;
+        }
+    }
+    else {
+        LERROR(fmt::format("{}: Must specify '{}'", _name, KeyCdfSeedPointFile));
+        return false;
+    }
+
+    if (!_dictionary->getValue(KeyCdfTracingVariable, tracingVar)) {
+        tracingVar = "b"; //  Magnetic field variable as default
+        LWARNING(fmt::format("{}: No '{}', using default '{}'",
+            _name, KeyCdfTracingVariable, tracingVar
+        ));
+    }
+
+    ghoul::Dictionary extraQuantityNamesDictionary;
+    if (_dictionary->getValue(KeyCdfExtraVariables, extraQuantityNamesDictionary)) {
+        const size_t nProvidedExtras = extraQuantityNamesDictionary.size();
+        for (size_t i = 1; i <= nProvidedExtras; ++i) {
+            extraVars.push_back(
+                extraQuantityNamesDictionary.value<std::string>(std::to_string(i)));
+        }
+    }
+
+    return true;
+}
+
+bool RenderableFieldlinesSequence::extractSeedPointsFromFile(const std::string& path,
+                                                           std::vector<glm::vec3>& outVec)
+{
+
+    std::ifstream seedFile(FileSys.relativePath(path));
+    if (!seedFile.good()) {
+        LERROR(fmt::format("Could not open seed points file '{}'", path));
+        return false;
+    }
+
+    LDEBUG(fmt::format("Reading seed points from file '{}'", path));
+    std::string line;
+    while (std::getline(seedFile, line)) {
+        glm::vec3 point;
+        std::stringstream ss(line);
+        ss >> point.x;
+        ss >> point.y;
+        ss >> point.z;
+        outVec.push_back(std::move(point));
+    }
+
+    if (outVec.size() == 0) {
+        LERROR(fmt::format("Found no seed points in: {}", path));
+        return false;
+    }
+
+    return true;
+}
+
+void RenderableFieldlinesSequence::extractMagnitudeVarsFromStrings(
+                                                      std::vector<std::string>& extraVars,
+                                                   std::vector<std::string>& extraMagVars)
+{
+
+    for (int i = 0; i < static_cast<int>(extraVars.size()); i++) {
+        const std::string str = extraVars[i];
+        // Check if string is in the format specified for magnitude variables
+        if (str.substr(0, 2) == "|(" && str.substr(str.size() - 2, 2) == ")|") {
+            std::istringstream ss(str.substr(2, str.size() - 4));
+            std::string magVar;
+            size_t counter = 0;
+            while (std::getline(ss, magVar, ',')) {
+                magVar.erase(std::remove_if(magVar.begin(), magVar.end(), ::isspace),
+                    magVar.end());
+                extraMagVars.push_back(magVar);
+                counter++;
+                if (counter == 3) {
+                    break;
+                }
+            }
+            if (counter != 3 && counter > 0) {
+                extraMagVars.erase(extraMagVars.end() - counter, extraMagVars.end());
+            }
+            extraVars.erase(extraVars.begin() + i);
+            i--;
+        }
+    }
+}
+
+
+void RenderableFieldlinesSequence::deinitializeGL() {
     glDeleteVertexArrays(1, &_vertexArrayObject);
     _vertexArrayObject = 0;
 
@@ -62,13 +1008,18 @@ void RenderableFieldlinesSequence::deinitialize() {
     }
 
     // Stall main thread until thread that's loading states is done!
+    bool printedWarning = false;
     while (_isLoadingStateFromDisk) {
-        LWARNING("TRYING TO DESTROY CLASS WHEN A THREAD USING IT IS STILL ACTIVE");
+        if (!printedWarning) {
+            LWARNING("Trying to destroy class when an active thread is still using it");
+            printedWarning = true;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
     }
 }
 
 bool RenderableFieldlinesSequence::isReady() const {
-    return _isReady;
+    return _shaderProgram != nullptr;
 }
 
 void RenderableFieldlinesSequence::render(const RenderData& data, RendererTasks&) {
@@ -91,13 +1042,13 @@ void RenderableFieldlinesSequence::render(const RenderData& data, RendererTasks&
         _shaderProgram->setUniform("usingDomain",  _pDomainEnabled);
         _shaderProgram->setUniform("usingMasking", _pMaskingEnabled);
 
-        if (_pColorMethod == ColorMethod::ByQuantity) {
-                ghoul::opengl::TextureUnit textureUnit;
-                textureUnit.activate();
-                _transferFunction->bind(); // Calls update internally
-                _shaderProgram->setUniform("colorTable", textureUnit);
-                _shaderProgram->setUniform("colorTableRange",
-                                              _colorTableRanges[_pColorQuantity]);
+        if (_pColorMethod == static_cast<int>(ColorMethod::ByQuantity)) {
+            ghoul::opengl::TextureUnit textureUnit;
+            textureUnit.activate();
+            _transferFunction->bind(); // Calls update internally
+            _shaderProgram->setUniform("colorTable", textureUnit);
+            _shaderProgram->setUniform("colorTableRange",
+                                            _colorTableRanges[_pColorQuantity]);
         }
 
         if (_pMaskingEnabled) {
@@ -159,23 +1110,25 @@ void RenderableFieldlinesSequence::render(const RenderData& data, RendererTasks&
 }
 
 void RenderableFieldlinesSequence::update(const UpdateData& data) {
-    // This node shouldn't do anything if its been disabled from the gui!
-    if (!_enabled) {
-        return;
-    }
-
     if (_shaderProgram->isDirty()) {
         _shaderProgram->rebuildFromFile();
     }
 
     const double currentTime = data.time.j2000Seconds();
-    // Check if current time in OpenSpace is within sequence interval
-    if (isWithinSequenceInterval(currentTime)) {
-        const int nextIdx = _activeTriggerTimeIndex + 1;
-        if (_activeTriggerTimeIndex < 0                                       // true => Previous frame was not within the sequence interval
-            || currentTime < _startTimes[_activeTriggerTimeIndex]             // true => OpenSpace has stepped back    to a time represented by another state
-            || (nextIdx < _nStates && currentTime >= _startTimes[nextIdx])) { // true => OpenSpace has stepped forward to a time represented by another state
+    bool isInInterval = (currentTime >= _startTimes[0]) &&
+                        (currentTime < _sequenceEndTime);
 
+    // Check if current time in OpenSpace is within sequence interval
+    if (isInInterval) {
+        const size_t nextIdx = _activeTriggerTimeIndex + 1;
+        if (
+            // true => Previous frame was not within the sequence interval
+            _activeTriggerTimeIndex < 0
+            // true => We stepped back to a time represented by another state
+            || currentTime < _startTimes[_activeTriggerTimeIndex]
+            // true => We stepped forward to a time represented by another state
+            || (nextIdx < _nStates && currentTime >= _startTimes[nextIdx]))
+        {
             updateActiveTriggerTimeIndex(currentTime);
 
             if (_loadingStatesDynamically) {
@@ -194,13 +1147,13 @@ void RenderableFieldlinesSequence::update(const UpdateData& data) {
 
     if (_mustLoadNewStateFromDisk) {
         if (!_isLoadingStateFromDisk && !_newStateIsReady) {
-                _isLoadingStateFromDisk    = true;
-                _mustLoadNewStateFromDisk  = false;
-                const std::string filePath = _sourceFiles[_activeTriggerTimeIndex];
-                std::thread readBinaryThread([this, filePath] {
-                    this->readNewState(filePath);
-                });
-                readBinaryThread.detach();
+            _isLoadingStateFromDisk    = true;
+            _mustLoadNewStateFromDisk  = false;
+            std::string filePath = _sourceFiles[_activeTriggerTimeIndex];
+            std::thread readBinaryThread([this, f = std::move(filePath)] {
+                readNewState(f);
+            });
+            readBinaryThread.detach();
         }
     }
 
@@ -232,21 +1185,16 @@ void RenderableFieldlinesSequence::update(const UpdateData& data) {
     }
 }
 
-inline bool RenderableFieldlinesSequence::isWithinSequenceInterval(
-                                                           const double currentTime) const
-{
-    return (currentTime >= _startTimes[0]) && (currentTime < _sequenceEndTime);
-}
-
 // Assumes we already know that currentTime is within the sequence interval
-void RenderableFieldlinesSequence::updateActiveTriggerTimeIndex(const double currentTime)
-{
+void RenderableFieldlinesSequence::updateActiveTriggerTimeIndex(double currentTime) {
     auto iter = std::upper_bound(_startTimes.begin(), _startTimes.end(), currentTime);
     if (iter != _startTimes.end()) {
-        if ( iter != _startTimes.begin()) {
-            _activeTriggerTimeIndex =
-                    static_cast<int>(std::distance(_startTimes.begin(), iter)) - 1;
-        } else {
+        if (iter != _startTimes.begin()) {
+            _activeTriggerTimeIndex = static_cast<int>(
+                std::distance(_startTimes.begin(), iter)
+            ) - 1;
+        }
+        else {
             _activeTriggerTimeIndex = 0;
         }
     } else {
@@ -273,11 +1221,14 @@ void RenderableFieldlinesSequence::updateVertexPositionBuffer() {
     glBindVertexArray(_vertexArrayObject);
     glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer);
 
-    const std::vector<glm::vec3>& vertexPosVec =
-            _states[_activeStateIndex].vertexPositions();
+    const std::vector<glm::vec3>& vertPos = _states[_activeStateIndex].vertexPositions();
 
-    glBufferData(GL_ARRAY_BUFFER, vertexPosVec.size() * sizeof(glm::vec3),
-            &vertexPosVec.front(), GL_STATIC_DRAW);
+    glBufferData(
+        GL_ARRAY_BUFFER,
+        vertPos.size() * sizeof(glm::vec3),
+        vertPos.data(),
+        GL_STATIC_DRAW
+    );
 
     glEnableVertexAttribArray(VaPosition);
     glVertexAttribPointer(VaPosition, 3, GL_FLOAT, GL_FALSE, 0, 0);
@@ -290,12 +1241,17 @@ void RenderableFieldlinesSequence::updateVertexColorBuffer() {
     glBindBuffer(GL_ARRAY_BUFFER, _vertexColorBuffer);
 
     bool isSuccessful;
-    const std::vector<float>& quantityVec =
-            _states[_activeStateIndex].extraQuantity(_pColorQuantity, isSuccessful);
+    const std::vector<float>& quantities = _states[_activeStateIndex].extraQuantity(
+        _pColorQuantity, isSuccessful
+    );
 
     if (isSuccessful) {
-        glBufferData(GL_ARRAY_BUFFER, quantityVec.size() * sizeof(float),
-                &quantityVec.front(), GL_STATIC_DRAW);
+        glBufferData(
+            GL_ARRAY_BUFFER,
+            quantities.size() * sizeof(float),
+            quantities.data(),
+            GL_STATIC_DRAW
+        );
 
         glEnableVertexAttribArray(VaColor);
         glVertexAttribPointer(VaColor, 1, GL_FLOAT, GL_FALSE, 0, 0);
@@ -309,12 +1265,17 @@ void RenderableFieldlinesSequence::updateVertexMaskingBuffer() {
     glBindBuffer(GL_ARRAY_BUFFER, _vertexMaskingBuffer);
 
     bool isSuccessful;
-    const std::vector<float>& quantityVec =
-        _states[_activeStateIndex].extraQuantity(_pMaskingQuantity, isSuccessful);
+    const std::vector<float>& maskings = _states[_activeStateIndex].extraQuantity(
+        _pMaskingQuantity, isSuccessful
+    );
 
     if (isSuccessful) {
-        glBufferData(GL_ARRAY_BUFFER, quantityVec.size() * sizeof(float),
-            &quantityVec.front(), GL_STATIC_DRAW);
+        glBufferData(
+            GL_ARRAY_BUFFER,
+            maskings.size() * sizeof(float),
+            maskings.data(),
+            GL_STATIC_DRAW
+        );
 
         glEnableVertexAttribArray(VaMasking);
         glVertexAttribPointer(VaMasking, 1, GL_FLOAT, GL_FALSE, 0, 0);
diff --git a/modules/fieldlinessequence/rendering/renderablefieldlinessequence.h b/modules/fieldlinessequence/rendering/renderablefieldlinessequence.h
index f96c1aa218..54cca77b1b 100644
--- a/modules/fieldlinessequence/rendering/renderablefieldlinessequence.h
+++ b/modules/fieldlinessequence/rendering/renderablefieldlinessequence.h
@@ -27,21 +27,17 @@
 
 #include <openspace/rendering/renderable.h>
 
+#include <modules/fieldlinessequence/util/fieldlinesstate.h>
 #include <openspace/properties/optionproperty.h>
-#include <openspace/properties/scalar/intproperty.h>
 #include <openspace/properties/stringproperty.h>
 #include <openspace/properties/triggerproperty.h>
+#include <openspace/properties/scalar/intproperty.h>
 #include <openspace/properties/vector/vec2property.h>
 #include <openspace/properties/vector/vec4property.h>
 #include <openspace/rendering/transferfunction.h>
-
-#include <modules/fieldlinessequence/util/fieldlinesstate.h>
-
 #include <atomic>
 
-namespace {
-    enum class SourceFileType;
-}
+namespace { enum class SourceFileType; }
 
 namespace openspace {
 
@@ -49,17 +45,18 @@ class RenderableFieldlinesSequence : public Renderable {
 public:
     RenderableFieldlinesSequence(const ghoul::Dictionary& dictionary);
 
-    void initialize() override;
-    void deinitialize() override;
+    void initializeGL() override;
+    void deinitializeGL() override;
 
     bool isReady() const override;
 
     void render(const RenderData& data, RendererTasks& rendererTask) override;
     void update(const UpdateData& data) override;
+
 private:
     // ------------------------------------- ENUMS -------------------------------------//
     // Used to determine if lines should be colored UNIFORMLY or by an extraQuantity
-    enum ColorMethod : int {
+    enum class ColorMethod : int {
         Uniform = 0,
         ByQuantity
     };
@@ -71,8 +68,6 @@ private:
     // Used for 'runtime-states'. True when loading a new state from disk on another
     // thread.
     std::atomic<bool> _isLoadingStateFromDisk    { false};
-    // If initialization proved successful
-    bool              _isReady                   = false;
     // False => states are stored in RAM (using 'in-RAM-states'), True => states are
     // loaded from disk during runtime (using 'runtime-states')
     bool              _loadingStatesDynamically  = false;
@@ -123,7 +118,7 @@ private:
     std::unique_ptr<FieldlinesState>              _newState;
     std::unique_ptr<ghoul::opengl::ProgramObject> _shaderProgram;
     // Transfer function used to color lines when _pColorMethod is set to BY_QUANTITY
-    std::shared_ptr<TransferFunction>             _transferFunction;
+    std::unique_ptr<TransferFunction>             _transferFunction;
 
     // ------------------------------------ VECTORS ----------------------------------- //
     // Paths to color tables. One for each 'extraQuantity'
@@ -225,9 +220,8 @@ private:
     bool prepareForOsflsStreaming();
 
     // ------------------------- FUNCTIONS USED DURING RUNTIME ------------------------ //
-    inline bool isWithinSequenceInterval(const double currentTime) const;
     void readNewState(const std::string& filePath);
-    void updateActiveTriggerTimeIndex(const double currentTime);
+    void updateActiveTriggerTimeIndex(double currentTime);
     void updateVertexPositionBuffer();
     void updateVertexColorBuffer();
     void updateVertexMaskingBuffer();
diff --git a/modules/fieldlinessequence/rendering/renderablefieldlinessequencesetup.cpp b/modules/fieldlinessequence/rendering/renderablefieldlinessequencesetup.cpp
deleted file mode 100644
index f0a71a4481..0000000000
--- a/modules/fieldlinessequence/rendering/renderablefieldlinessequencesetup.cpp
+++ /dev/null
@@ -1,845 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2018                                                               *
- *                                                                                       *
- * 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 <modules/fieldlinessequence/rendering/renderablefieldlinessequence.h>
-
-#include <modules/fieldlinessequence/util/kameleonfieldlinehelper.h>
-
-#include <openspace/engine/openspaceengine.h>
-#include <openspace/interaction/navigationhandler.h>
-#include <openspace/scene/scene.h>
-#include <openspace/scene/scenegraphnode.h>
-#include <openspace/util/timemanager.h>
-
-#include <ghoul/filesystem/filesystem.h>
-#include <ghoul/opengl/programobject.h>
-
-#include <fstream>
-#include <sstream>
-
-namespace {
-    std::string _loggerCat = "RenderableFieldlinesSequence";
-
-    // ----- KEYS POSSIBLE IN MODFILE. EXPECTED DATA TYPE OF VALUE IN [BRACKETS]  ----- //
-    // ---------------------------- MANDATORY MODFILE KEYS ---------------------------- //
-    const char* KeyInputFileType        = "InputFileType";   // [STRING] "cdf", "json" or "osfls"
-    const char* KeySourceFolder         = "SourceFolder";    // [STRING] should be path to folder containing the input files
-
-    // ---------------------- MANDATORY INPUT TYPE SPECIFIC KEYS ---------------------- //
-    const char* KeyCdfSeedPointFile     = "SeedPointFile";   // [STRING] Path to a .txt file containing seed points
-    const char* KeyJsonSimulationModel  = "SimulationModel"; // [STRING] Currently supports: "batsrus", "enlil" & "pfss"
-
-    // ----------------------- OPTIONAL INPUT TYPE SPECIFIC KEYS ---------------------- //
-    const char* KeyCdfExtraVariables    = "ExtraVariables";  // [STRING ARRAY]
-    const char* KeyCdfTracingVariable   = "TracingVariable"; // [STRING]
-    const char* KeyJsonScalingFactor    = "ScaleToMeters";   // [STRING]
-    const char* KeyOslfsLoadAtRuntime   = "LoadAtRuntime";   // [BOOLEAN] If value False => Load in initializing step and store in RAM
-
-    // ---------------------------- OPTIONAL MODFILE KEYS  ---------------------------- //
-    const char* KeyColorTablePaths      = "ColorTablePaths"; // [STRING ARRAY] Values should be paths to .txt files
-    const char* KeyColorTableRanges     = "ColorTableRanges";// [VEC2 ARRAY] Values should be entered as {X, Y}, where X & Y are numbers
-    const char* KeyMaskingRanges        = "MaskingRanges";   // [VEC2 ARRAY] Values should be entered as {X, Y}, where X & Y are numbers
-    const char* KeyOutputFolder         = "OutputFolder";    // [STRING] Value should be path to folder where states are saved (JSON/CDF input => osfls output & oslfs input => JSON output)
-
-    // ------------- POSSIBLE STRING VALUES FOR CORRESPONDING MODFILE KEY ------------- //
-    const char* ValueInputFileTypeCdf   = "cdf";
-    const char* ValueInputFileTypeJson  = "json";
-    const char* ValueInputFileTypeOsfls = "osfls";
-
-    // --------------------------------- Property Info -------------------------------- //
-    static const openspace::properties::Property::PropertyInfo ColorMethodInfo = {
-        "colorMethod", "Color Method", "Color lines uniformly or using color tables based on extra quantities like e.g. temperature or particle density."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorQuantityInfo = {
-        "colorQuantity", "Quantity to Color By", "Quantity used to color lines if the \"By Quantity\" color method is selected."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorQuantityMinInfo = {
-        "colorQuantityMin", "ColorTable Min Value", "Value to map to the lowest end of the color table."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorQuantityMaxInfo = {
-        "colorQuantityMax", "ColorTable Max Value", "Value to map to the highest end of the color table."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorTablePathInfo = {
-        "colorTablePath", "Path to Color Table", "Color Table/Transfer Function to use for \"By Quantity\" coloring."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorUniformInfo = {
-        "uniform", "Uniform Line Color", "The uniform color of lines shown when \"Color Method\" is set to \"Uniform\"."
-    };
-    static const openspace::properties::Property::PropertyInfo ColorUseABlendingInfo = {
-        "aBlendingEnabled", "Additive Blending", "Activate/deactivate additive blending."
-    };
-    static const openspace::properties::Property::PropertyInfo DomainEnabledInfo = {
-        "domainEnabled", "Domain Limits", "Enable/Disable domain limits"
-    };
-    static const openspace::properties::Property::PropertyInfo DomainXInfo = {
-        "limitsX", "X-limits", "Valid range along the X-axis. [Min, Max]"
-    };
-    static const openspace::properties::Property::PropertyInfo DomainYInfo = {
-        "limitsY", "Y-limits", "Valid range along the Y-axis. [Min, Max]"
-    };
-    static const openspace::properties::Property::PropertyInfo DomainZInfo = {
-        "limitsZ", "Z-limits", "Valid range along the Z-axis. [Min, Max]"
-    };
-    static const openspace::properties::Property::PropertyInfo DomainRInfo = {
-        "limitsR", "Radial limits", "Valid radial range. [Min, Max]"
-    };
-    static const openspace::properties::Property::PropertyInfo FlowColorInfo = {
-        "color", "Color", "Color of particles."
-    };
-    static const openspace::properties::Property::PropertyInfo FlowEnabledInfo = {
-        "flowEnabled", "Flow Direction",
-        "Toggles the rendering of moving particles along the lines. Can e.g. illustrate magnetic flow."
-    };
-    static const openspace::properties::Property::PropertyInfo FlowReversedInfo = {
-        "reversed", "Reversed Flow", "Toggle to make the flow move in the opposite direction."
-    };
-    static const openspace::properties::Property::PropertyInfo FlowParticleSizeInfo = {
-        "particleSize", "Particle Size", "Size of the particles."
-    };
-    static const openspace::properties::Property::PropertyInfo FlowParticleSpacingInfo = {
-        "particleSpacing", "Particle Spacing", "Spacing inbetween particles."
-    };
-    static const openspace::properties::Property::PropertyInfo FlowSpeedInfo = {
-        "speed", "Speed", "Speed of the flow."
-    };
-    static const openspace::properties::Property::PropertyInfo MaskingEnabledInfo = {
-        "maskingEnabled", "Masking",
-        "Enable/disable masking. Use masking to show lines where a given quantity is within a given range, e.g. if you only want to see where the temperature is between 10 and 20 degrees. Also used for masking out line topologies like solar wind & closed lines."
-    };
-    static const openspace::properties::Property::PropertyInfo MaskingMinInfo = {
-        "maskingMinLimit", "Lower Limit", "Lower limit of the valid masking range"
-    };
-    static const openspace::properties::Property::PropertyInfo MaskingMaxInfo = {
-        "maskingMaxLimit", "Upper Limit", "Upper limit of the valid masking range"
-    };
-    static const openspace::properties::Property::PropertyInfo MaskingQuantityInfo = {
-        "maskingQuantity", "Quantity used for Masking", "Quantity used for masking."
-    };
-    static const openspace::properties::Property::PropertyInfo OriginButtonInfo = {
-        "focusCameraOnParent", "Focus Camera", "Focus camera on parent."
-    };
-    static const openspace::properties::Property::PropertyInfo TimeJumpButtonInfo = {
-        "timeJumpToStart", "Jump to Start Of Sequence", "Performs a time jump to the start of the sequence."
-    };
-
-    enum class SourceFileType : int {
-        Cdf = 0,
-        Json,
-        Osfls,
-        Invalid
-    };
-
-    float stringToFloat(const std::string input, const float backupValue = 0.f) {
-        float tmp;
-        try {
-            tmp = std::stof(input);
-        } catch (const std::invalid_argument& ia) {
-            LWARNING("Invalid argument: " << ia.what() << ". '" << input <<
-                "' is NOT a valid number!");
-            return backupValue;
-        }
-        return tmp;
-    }
-} // namespace
-
-namespace openspace {
-
-RenderableFieldlinesSequence::RenderableFieldlinesSequence(const ghoul::Dictionary& dictionary)
-    : Renderable(dictionary),
-      _pColorGroup({ "Color" }),
-      _pColorMethod(ColorMethodInfo, properties::OptionProperty::DisplayType::Radio),
-      _pColorQuantity(ColorQuantityInfo, properties::OptionProperty::DisplayType::Dropdown),
-      _pColorQuantityMin(ColorQuantityMinInfo),
-      _pColorQuantityMax(ColorQuantityMaxInfo),
-      _pColorTablePath(ColorTablePathInfo),
-      _pColorUniform(ColorUniformInfo, glm::vec4(0.75f, 0.5f, 0.0f, 0.5f),
-                                       glm::vec4(0.f), glm::vec4(1.f)),
-      _pColorABlendEnabled(ColorUseABlendingInfo, true),
-      _pDomainEnabled(DomainEnabledInfo, true),
-      _pDomainGroup({ "Domain" }),
-      _pDomainX(DomainXInfo),
-      _pDomainY(DomainYInfo),
-      _pDomainZ(DomainZInfo),
-      _pDomainR(DomainRInfo),
-      _pFlowColor(FlowColorInfo, glm::vec4(0.8f, 0.7f, 0.0f, 0.6f),
-                                 glm::vec4(0.f), glm::vec4(1.f)),
-      _pFlowEnabled(FlowEnabledInfo, true),
-      _pFlowGroup({ "Flow" }),
-      _pFlowParticleSize(FlowParticleSizeInfo, 5, 0, 500),
-      _pFlowParticleSpacing(FlowParticleSpacingInfo, 60, 0, 500),
-      _pFlowReversed(FlowReversedInfo, false),
-      _pFlowSpeed(FlowSpeedInfo, 20, 0, 1000),
-      _pMaskingEnabled(MaskingEnabledInfo, false),
-      _pMaskingGroup({ "Masking" }),
-      _pMaskingMin(MaskingMinInfo),
-      _pMaskingMax(MaskingMaxInfo),
-      _pMaskingQuantity(MaskingQuantityInfo, properties::OptionProperty::DisplayType::Dropdown),
-      _pFocusOnOriginBtn(OriginButtonInfo),
-      _pJumpToStartBtn(TimeJumpButtonInfo) {
-
-    _dictionary = std::make_unique<ghoul::Dictionary>(dictionary);
-}
-
-void RenderableFieldlinesSequence::initialize() {
-    LINFO("RenderableFieldlinesSequence::initialize()");
-
-    // EXTRACT MANDATORY INFORMATION FROM DICTIONARY
-    SourceFileType sourceFileType = SourceFileType::Invalid;
-    if (!extractMandatoryInfoFromDictionary(sourceFileType)) {
-        return;
-    }
-
-    // Set a default color table, just in case the (optional) user defined paths are corrupt/not provided!
-    _colorTablePaths.push_back("${DATA}/scene/fieldlinessequence/colortables/kroyw.txt");
-    _transferFunction = std::make_shared<TransferFunction>(absPath(_colorTablePaths[0]));
-
-    // EXTRACT OPTIONAL INFORMATION FROM DICTIONARY
-    std::string outputFolderPath;
-    extractOptionalInfoFromDictionary(outputFolderPath);
-
-    // EXTRACT SOURCE FILE TYPE SPECIFIC INFOMRATION FROM DICTIONARY & GET STATES FROM SOURCE
-    switch (sourceFileType) {
-        case SourceFileType::Cdf:
-            if (!getStatesFromCdfFiles(outputFolderPath)) {
-                return;
-            }
-            break;
-        case SourceFileType::Json:
-            if (!loadJsonStatesIntoRAM(outputFolderPath)) {
-                return;
-            }
-            break;
-        case SourceFileType::Osfls:
-            extractOsflsInfoFromDictionary();
-            if (_loadingStatesDynamically) {
-                if (!prepareForOsflsStreaming()) {
-                    return;
-                }
-            } else {
-                loadOsflsStatesIntoRAM(outputFolderPath);
-            }
-            break;
-        default:
-            return;
-    }
-
-    // dictionary is no longer needed as everything is extracted
-    _dictionary.reset();
-
-    // No need to store source paths in memory if they are already in RAM!
-    if (!_loadingStatesDynamically) {
-        _sourceFiles.clear();
-    }
-
-    // At this point there should be at least one state loaded into memory!
-    if (_states.size() == 0) {
-        LERROR("Wasn't able to extract any valid states from provided source files!");
-        return;
-    }
-
-    computeSequenceEndTime();
-    setModelDependentConstants();
-
-    setupProperties();
-
-    // Setup shader program
-    _shaderProgram = OsEng.renderEngine().buildRenderProgram(
-        "FieldlinesSequence",
-        absPath("${MODULE_FIELDLINESSEQUENCE}/shaders/fieldlinessequence_vs.glsl"),
-        absPath("${MODULE_FIELDLINESSEQUENCE}/shaders/fieldlinessequence_fs.glsl")
-    );
-
-    if (!_shaderProgram) {
-        LERROR("Shader program failed initialization!");
-        sourceFileType = SourceFileType::Invalid;
-    }
-
-    //------------------ Initialize OpenGL VBOs and VAOs-------------------------------//
-    glGenVertexArrays(1, &_vertexArrayObject);
-    glGenBuffers(1, &_vertexPositionBuffer);
-    glGenBuffers(1, &_vertexColorBuffer);
-    glGenBuffers(1, &_vertexMaskingBuffer);
-
-    // Needed for additive blending
-    setRenderBin(Renderable::RenderBin::Overlay);
-
-    _isReady = true;
-}
-
-/**
- * Extracts the general information (from the lua modfile) that is mandatory for the class
- * to function; such as the file type and the location of the source files.
- * Returns false if it fails to extract mandatory information!
- */
-bool RenderableFieldlinesSequence::extractMandatoryInfoFromDictionary(
-        SourceFileType& sourceFileType) {
-
-    _dictionary->getValue(SceneGraphNode::KeyName, _name);
-
-    // ------------------- EXTRACT MANDATORY VALUES FROM DICTIONARY ------------------- //
-    std::string inputFileTypeString;
-    if (!_dictionary->getValue(KeyInputFileType, inputFileTypeString)) {
-        LERROR(_name << ": The field " << std::string(KeyInputFileType) << " is missing!");
-        return false;
-    } else {
-        std::transform(
-            inputFileTypeString.begin(),
-            inputFileTypeString.end(),
-            inputFileTypeString.begin(),
-            [](char c) { return static_cast<char>(tolower(c)); }
-        );
-        // Verify that the input type is correct
-        if (inputFileTypeString == ValueInputFileTypeCdf) {
-            sourceFileType = SourceFileType::Cdf;
-        } else if (inputFileTypeString == ValueInputFileTypeJson) {
-            sourceFileType = SourceFileType::Json;
-        } else if (inputFileTypeString == ValueInputFileTypeOsfls) {
-            sourceFileType = SourceFileType::Osfls;
-        } else {
-            LERROR(_name << ": " << inputFileTypeString << " is not a recognised "
-                << KeyInputFileType);
-            sourceFileType = SourceFileType::Invalid;
-            return false;
-        }
-    }
-
-    std::string sourceFolderPath;
-    if (!_dictionary->getValue(KeySourceFolder, sourceFolderPath)) {
-        LERROR(_name << ": The field " << std::string(KeySourceFolder) << " is missing!");
-        return false;
-    }
-
-    // Ensure that the source folder exists and then extract
-    // the files with the same extension as <inputFileTypeString>
-    ghoul::filesystem::Directory sourceFolder(sourceFolderPath);
-    if (FileSys.directoryExists(sourceFolder)) {
-        // Extract all file paths from the provided folder (Non-recursively! Sorted!)
-        _sourceFiles = sourceFolder.readFiles(ghoul::Boolean::No, ghoul::Boolean::Yes);
-
-        // Remove all files that don't have <inputFileTypeString> as extension
-        _sourceFiles.erase(std::remove_if(_sourceFiles.begin(), _sourceFiles.end(),
-                [inputFileTypeString](std::string str) {
-                    const size_t extLength = inputFileTypeString.length();
-                    std::string sub = str.substr(str.length() - extLength, extLength);
-                    std::transform(
-                        sub.begin(),
-                        sub.end(),
-                        sub.begin(),
-                        [](char c) { return static_cast<char>(::tolower(c)); }
-                    );
-                    return sub != inputFileTypeString;
-                }), _sourceFiles.end());
-        // Ensure that there are available and valid source files left
-        if (_sourceFiles.empty()) {
-            LERROR(_name << ": " << sourceFolderPath << " contains no ." << inputFileTypeString
-                << " files!");
-            return false;
-        }
-    } else {
-        LERROR(_name << ": FieldlinesSequence" << sourceFolderPath
-            << " is not a valid directory!");
-        return false;
-    }
-
-    return true;
-}
-
-void RenderableFieldlinesSequence::extractOptionalInfoFromDictionary(
-        std::string& outputFolderPath) {
-
-    // ------------------- EXTRACT OPTIONAL VALUES FROM DICTIONARY ------------------- //
-    if (_dictionary->getValue(KeyOutputFolder, outputFolderPath)) {
-        ghoul::filesystem::Directory outputFolder(outputFolderPath);
-        if (FileSys.directoryExists(outputFolder)) {
-            outputFolderPath = absPath(outputFolderPath);
-        } else {
-            LERROR(_name << ": The specified output path: '" << outputFolderPath << "', does not exist!");
-            outputFolderPath = "";
-        }
-    }
-
-    ghoul::Dictionary colorTablesPathsDictionary;
-    if (_dictionary->getValue(KeyColorTablePaths, colorTablesPathsDictionary)) {
-        const size_t nProvidedPaths = colorTablesPathsDictionary.size();
-        if (nProvidedPaths > 0) {
-            // Clear the default! It is already specified in the transferFunction
-            _colorTablePaths.clear();
-            for (size_t i = 1; i <= nProvidedPaths; ++i) {
-                _colorTablePaths.push_back(
-                        colorTablesPathsDictionary.value<std::string>(std::to_string(i)));
-            }
-        }
-    }
-
-    ghoul::Dictionary colorTablesRangesDictionary;
-    if (_dictionary->getValue(KeyColorTableRanges, colorTablesRangesDictionary)) {
-        const size_t nProvidedRanges = colorTablesRangesDictionary.size();
-        for (size_t i = 1; i <= nProvidedRanges; ++i) {
-            _colorTableRanges.push_back(
-                    colorTablesRangesDictionary.value<glm::vec2>(std::to_string(i)));
-        }
-    } else {
-        _colorTableRanges.push_back(glm::vec2(0, 1));
-    }
-
-    ghoul::Dictionary maskingRangesDictionary;
-    if (_dictionary->getValue(KeyMaskingRanges, maskingRangesDictionary)) {
-        const size_t nProvidedRanges = maskingRangesDictionary.size();
-        for (size_t i = 1; i <= nProvidedRanges; ++i) {
-            _maskingRanges.push_back(
-                    maskingRangesDictionary.value<glm::vec2>(std::to_string(i)));
-        }
-    } else {
-        _maskingRanges.push_back(glm::vec2(-100000, 100000)); // Just some default values!
-    }
-}
-
-/**
- * Returns false if it fails to extract mandatory information!
- */
-bool RenderableFieldlinesSequence::extractJsonInfoFromDictionary(fls::Model& model) {
-    std::string modelStr;
-    if (_dictionary->getValue(KeyJsonSimulationModel, modelStr)) {
-        std::transform(
-            modelStr.begin(),
-            modelStr.end(),
-            modelStr.begin(),
-            [](char c) { return static_cast<char>(::tolower(c)); }
-        );
-        model = fls::stringToModel(modelStr);
-    } else {
-        LERROR(_name << ": Must specify '" << KeyJsonSimulationModel << "'");
-        return false;
-    }
-
-    float scaleFactor;
-    if (_dictionary->getValue(KeyJsonScalingFactor, scaleFactor)) {
-        _scalingFactor = scaleFactor;
-    } else {
-        LWARNING(_name << ": Does not provide scalingFactor! " <<
-                 "Assumes coordinates are already expressed in meters!");
-    }
-    return true;
-}
-
-bool RenderableFieldlinesSequence::loadJsonStatesIntoRAM(const std::string& outputFolder) {
-    fls::Model model;
-    if (!extractJsonInfoFromDictionary(model)) {
-        return false;
-    }
-    // Load states into RAM!
-    for (std::string filePath : _sourceFiles) {
-        FieldlinesState newState;
-        bool loadedSuccessfully = newState.loadStateFromJson(filePath, model,
-                                                             _scalingFactor);
-        if (loadedSuccessfully) {
-            addStateToSequence(newState);
-            if (!outputFolder.empty()) {
-                newState.saveStateToOsfls(outputFolder);
-            }
-        }
-    }
-    return true;
-}
-
-bool RenderableFieldlinesSequence::prepareForOsflsStreaming() {
-    extractTriggerTimesFromFileNames();
-    FieldlinesState newState;
-    if (!newState.loadStateFromOsfls(_sourceFiles[0])) {
-        LERROR("The provided .osfls files seem to be corrupt!");
-        return false;
-    }
-    _states.push_back(newState);
-    _nStates = _startTimes.size();
-    _activeStateIndex = 0;
-    return true;
-
-}
-
-void RenderableFieldlinesSequence::loadOsflsStatesIntoRAM(const std::string& outputFolder) {
-    // Load states from .osfls files into RAM!
-    for (const std::string filePath : _sourceFiles) {
-        FieldlinesState newState;
-        if (newState.loadStateFromOsfls(filePath)) {
-            addStateToSequence(newState);
-            if (!outputFolder.empty()) {
-                ghoul::filesystem::File tmpFile(filePath);
-                newState.saveStateToJson(outputFolder + tmpFile.baseName());
-            }
-        } else {
-            LWARNING("Failed to load state from: " << filePath);
-        }
-    }
-}
-
-void RenderableFieldlinesSequence::extractOsflsInfoFromDictionary() {
-    bool shouldLoadInRealtime = false;
-    if (_dictionary->getValue(KeyOslfsLoadAtRuntime, shouldLoadInRealtime)) {
-        _loadingStatesDynamically = shouldLoadInRealtime;
-    } else {
-        LWARNING(_name << ": " << KeyOslfsLoadAtRuntime <<
-            " isn't specified! States will be stored in RAM!");
-    }
-}
-
-void RenderableFieldlinesSequence::setupProperties() {
-    bool hasExtras = _states[0].nExtraQuantities() > 0;
-
-    // -------------- Add non-grouped properties (enablers and buttons) -------------- //
-    addProperty(_pColorABlendEnabled);
-    addProperty(_pDomainEnabled);
-    addProperty(_pFlowEnabled);
-    if (hasExtras) { addProperty(_pMaskingEnabled); }
-    addProperty(_pFocusOnOriginBtn);
-    addProperty(_pJumpToStartBtn);
-
-    // ----------------------------- Add Property Groups ----------------------------- //
-    addPropertySubOwner(_pColorGroup);
-    addPropertySubOwner(_pDomainGroup);
-    addPropertySubOwner(_pFlowGroup);
-    if (hasExtras) { addPropertySubOwner(_pMaskingGroup); }
-
-    // ------------------------- Add Properties to the groups ------------------------- //
-    _pColorGroup.addProperty(_pColorUniform);
-    _pDomainGroup.addProperty(_pDomainX);
-    _pDomainGroup.addProperty(_pDomainY);
-    _pDomainGroup.addProperty(_pDomainZ);
-    _pDomainGroup.addProperty(_pDomainR);
-    _pFlowGroup.addProperty(_pFlowReversed);
-    _pFlowGroup.addProperty(_pFlowColor);
-    _pFlowGroup.addProperty(_pFlowParticleSize);
-    _pFlowGroup.addProperty(_pFlowParticleSpacing);
-    _pFlowGroup.addProperty(_pFlowSpeed);
-    if (hasExtras) {
-        _pColorGroup.addProperty(_pColorMethod);
-        _pColorGroup.addProperty(_pColorQuantity);
-        _pColorGroup.addProperty(_pColorQuantityMin);
-        _pColorGroup.addProperty(_pColorQuantityMax);
-        _pColorGroup.addProperty(_pColorTablePath);
-        _pMaskingGroup.addProperty(_pMaskingMin);
-        _pMaskingGroup.addProperty(_pMaskingMax);
-        _pMaskingGroup.addProperty(_pMaskingQuantity);
-
-        // --------------------- Add Options to OptionProperties --------------------- //
-        _pColorMethod.addOption(ColorMethod::Uniform, "Uniform");
-        _pColorMethod.addOption(ColorMethod::ByQuantity, "By Quantity");
-        // Add option for each extra quantity. Assumes there are just as many names to
-        // extra quantities as there are extra quantities. Also assume that all states in
-        // the given sequence have the same extra quantities! */
-        const size_t nExtraQuantities = _states[0].nExtraQuantities();
-        const std::vector<std::string>& extraNamesVec = _states[0].extraQuantityNames();
-        for (int i = 0; i < nExtraQuantities; ++i) {
-            _pColorQuantity.addOption(i, extraNamesVec[i]);
-            _pMaskingQuantity.addOption(i, extraNamesVec[i]);
-        }
-        // Each quantity should have its own color table and color table range, no more, no less
-        _colorTablePaths.resize(nExtraQuantities, _colorTablePaths.back());
-        _colorTableRanges.resize(nExtraQuantities, _colorTableRanges.back());
-        _maskingRanges.resize(nExtraQuantities, _maskingRanges.back());
-    }
-
-    definePropertyCallbackFunctions();
-
-    if (hasExtras) {
-        // Set defaults
-        _pColorQuantity = 0;
-        _pColorQuantityMin = std::to_string(_colorTableRanges[0].x);
-        _pColorQuantityMax = std::to_string(_colorTableRanges[0].y);
-        _pColorTablePath = _colorTablePaths[0];
-
-        _pMaskingQuantity = 0;
-        _pMaskingMin = std::to_string(_maskingRanges[0].x);
-        _pMaskingMax = std::to_string(_maskingRanges[0].y);
-    }
-}
-
-void RenderableFieldlinesSequence::definePropertyCallbackFunctions() {
-    // Add Property Callback Functions
-    bool hasExtras = _states[0].nExtraQuantities() > 0;
-    if (hasExtras) {
-        _pColorQuantity.onChange([this] {
-            _shouldUpdateColorBuffer = true;
-            _pColorQuantityMin = std::to_string(_colorTableRanges[_pColorQuantity].x);
-            _pColorQuantityMax = std::to_string(_colorTableRanges[_pColorQuantity].y);
-            _pColorTablePath = _colorTablePaths[_pColorQuantity];
-        });
-
-        _pColorTablePath.onChange([this] {
-            _transferFunction->setPath(_pColorTablePath);
-            _colorTablePaths[_pColorQuantity] = _pColorTablePath;
-        });
-
-        _pColorQuantityMin.onChange([this] {
-            float f = stringToFloat(_pColorQuantityMin, _colorTableRanges[_pColorQuantity].x);
-            _pColorQuantityMin = std::to_string(f);
-            _colorTableRanges[_pColorQuantity].x = f;
-        });
-
-        _pColorQuantityMax.onChange([this] {
-            float f = stringToFloat(_pColorQuantityMax, _colorTableRanges[_pColorQuantity].y);
-            _pColorQuantityMax = std::to_string(f);
-            _colorTableRanges[_pColorQuantity].y = f;
-        });
-
-        _pMaskingQuantity.onChange([this] {
-            _shouldUpdateMaskingBuffer = true;
-            _pMaskingMin = std::to_string(_maskingRanges[_pMaskingQuantity].x);
-            _pMaskingMax = std::to_string(_maskingRanges[_pMaskingQuantity].y);
-        });
-
-        _pMaskingMin.onChange([this] {
-            float f = stringToFloat(_pMaskingMin, _maskingRanges[_pMaskingQuantity].x);
-            _pMaskingMin = std::to_string(f);
-            _maskingRanges[_pMaskingQuantity].x = f;
-        });
-
-        _pMaskingMax.onChange([this] {
-            float f = stringToFloat(_pMaskingMax, _maskingRanges[_pMaskingQuantity].y);
-            _pMaskingMax = std::to_string(f);
-            _maskingRanges[_pMaskingQuantity].y = f;
-        });
-    }
-
-    _pFocusOnOriginBtn.onChange([this] {
-        SceneGraphNode* node = OsEng.renderEngine().scene()->sceneGraphNode(_name);
-        if (!node) {
-            LWARNING("Could not find a node in scenegraph called '" << _name << "'");
-            return;
-        }
-        OsEng.navigationHandler().setFocusNode(node->parent());
-        OsEng.navigationHandler().resetCameraDirection();
-    });
-
-    _pJumpToStartBtn.onChange([this] {
-        OsEng.timeManager().time().setTime(_startTimes[0]);
-    });
-}
-
-// Calculate expected end time.
-void RenderableFieldlinesSequence::computeSequenceEndTime() {
-    if (_nStates > 1) {
-        const double lastTriggerTime      = _startTimes[_nStates - 1];
-        const double sequenceDuration     = lastTriggerTime - _startTimes[0];
-        const double averageStateDuration = sequenceDuration /
-                                            (static_cast<double>(_nStates) - 1.0);
-        _sequenceEndTime = lastTriggerTime + averageStateDuration;
-    } else {
-        // If there's just one state it should never disappear!
-        _sequenceEndTime = DBL_MAX;
-    }
-}
-
-void RenderableFieldlinesSequence::setModelDependentConstants() {
-    const fls::Model simulationModel = _states[0].model();
-    float limit = 100.f; // Just used as a default value.
-    switch (simulationModel) {
-        case fls::Model::Batsrus:
-            _scalingFactor = fls::ReToMeter;
-            limit = 300; // Should include a long magnetotail
-            break;
-        case fls::Model::Enlil:
-            _pFlowReversed = true;
-            _scalingFactor = fls::AuToMeter;
-            limit = 50; // Should include Plutos furthest distance from the Sun
-            break;
-        case fls::Model::Pfss:
-            _scalingFactor = fls::RsToMeter;
-            limit = 100; // Just a default value far away from the solar surface
-            break;
-        default:
-            break;
-    }
-    _pDomainX.setMinValue(glm::vec2(-limit)); _pDomainX.setMaxValue(glm::vec2(limit));
-    _pDomainY.setMinValue(glm::vec2(-limit)); _pDomainY.setMaxValue(glm::vec2(limit));
-    _pDomainZ.setMinValue(glm::vec2(-limit)); _pDomainZ.setMaxValue(glm::vec2(limit));
-    // Radial should range from 0 out to a corner of the cartesian box: sqrt(3) = 1.732..., 1.75 is a nice and round number
-    _pDomainR.setMinValue(glm::vec2(0));      _pDomainR.setMaxValue(glm::vec2(limit*1.75f));
-
-    _pDomainX = glm::vec2(-limit, limit);
-    _pDomainY = glm::vec2(-limit, limit);
-    _pDomainZ = glm::vec2(-limit, limit);
-    _pDomainR = glm::vec2(0, limit * 1.5f);
-}
-
-// Extract J2000 time from file names
-// Requires files to be named as such: 'YYYY-MM-DDTHH-MM-SS-XXX.osfls'
-void RenderableFieldlinesSequence::extractTriggerTimesFromFileNames() {
-    const size_t filenameSize = 23; // number of  characters in filename (excluding '.osfls')
-    const size_t extSize = 6;  // size(".osfls")
-
-    for (const std::string& filePath : _sourceFiles) {
-        const size_t strLength = filePath.size();
-        // Extract the filename from the path (without extension)
-        std::string timeString = filePath.substr(strLength - filenameSize - extSize,
-                                                 filenameSize - 1);
-        // Ensure the separators are correct
-        timeString.replace(4, 1, "-");
-        timeString.replace(7, 1, "-");
-        timeString.replace(13, 1, ":");
-        timeString.replace(16, 1, ":");
-        timeString.replace(19, 1, ".");
-        const double triggerTime = Time::convertTime(timeString);
-        _startTimes.push_back(triggerTime);
-    }
-}
-
-void RenderableFieldlinesSequence::addStateToSequence(FieldlinesState& state) {
-    _states.push_back(state);
-    _startTimes.push_back(state.triggerTime());
-    _nStates++;
-}
-
-bool RenderableFieldlinesSequence::getStatesFromCdfFiles(const std::string& outputFolder) {
-
-    std::string seedFilePath;
-    std::string tracingVar;
-    std::vector<std::string> extraVars;
-    if (!extractCdfInfoFromDictionary(seedFilePath, tracingVar, extraVars)) {
-        return false;
-    }
-
-    std::vector<glm::vec3> seedPoints;
-    if (!extractSeedPointsFromFile(seedFilePath, seedPoints)) {
-        return false;
-    }
-
-    std::vector<std::string> extraMagVars;
-    extractMagnitudeVarsFromStrings(extraVars, extraMagVars);
-
-    // Load states into RAM!
-    for (std::string cdfPath : _sourceFiles) {
-
-        FieldlinesState newState;
-        bool isSuccessful = fls::convertCdfToFieldlinesState(newState, cdfPath,
-                seedPoints, tracingVar, extraVars, extraMagVars);
-
-        if (isSuccessful) {
-            addStateToSequence(newState);
-            if (!outputFolder.empty()) {
-                newState.saveStateToOsfls(outputFolder);
-            }
-        }
-    }
-    return true;
-}
-
-/*
- * Returns false if it fails to extract mandatory information!
- */
-bool RenderableFieldlinesSequence::extractCdfInfoFromDictionary(
-        std::string& seedFilePath,
-        std::string& tracingVar,
-        std::vector<std::string>& extraVars) {
-
-    if (_dictionary->getValue(KeyCdfSeedPointFile, seedFilePath)) {
-        ghoul::filesystem::File seedPointFile(seedFilePath);
-        if (FileSys.fileExists(seedPointFile)) {
-            seedFilePath = absPath(seedFilePath);
-        } else {
-            LERROR(_name << ": The specified seed point file: '" << seedFilePath
-                         << "', does not exist!");
-            return false;
-        }
-    } else {
-        LERROR(_name << ": Must specify '" << KeyCdfSeedPointFile << "'");
-        return false;
-    }
-
-    if (!_dictionary->getValue(KeyCdfTracingVariable, tracingVar)) {
-        tracingVar = "b"; //  Magnetic field variable as default
-        LWARNING(_name << ": No '" << KeyCdfTracingVariable << "', using default: "
-                       << tracingVar);
-    }
-
-    ghoul::Dictionary extraQuantityNamesDictionary;
-    if (_dictionary->getValue(KeyCdfExtraVariables, extraQuantityNamesDictionary)) {
-        const size_t nProvidedExtras = extraQuantityNamesDictionary.size();
-        for (size_t i = 1; i <= nProvidedExtras; ++i) {
-            extraVars.push_back(
-                    extraQuantityNamesDictionary.value<std::string>(std::to_string(i)));
-        }
-    }
-
-    return true;
-}
-
-bool RenderableFieldlinesSequence::extractSeedPointsFromFile(
-            const std::string& path,
-            std::vector<glm::vec3>& outVec) {
-
-    std::ifstream seedFile(FileSys.relativePath(path));
-    if (!seedFile.good()) {
-        LERROR("Could not open seed points file '" << path << "'");
-        return false;
-    }
-
-    LDEBUG("Reading seed points from file '" << path << "'");
-    std::string line;
-    while (std::getline(seedFile, line)) {
-        glm::vec3 point;
-        std::stringstream ss(line);
-        ss >> point.x;
-        ss >> point.y;
-        ss >> point.z;
-        outVec.push_back(std::move(point));
-    }
-
-    if (outVec.size() == 0) {
-        LERROR("Found no seed points in: " << path);
-        return false;
-    }
-
-    return true;
-}
-
-void RenderableFieldlinesSequence::extractMagnitudeVarsFromStrings(
-        std::vector<std::string>& extraVars,
-        std::vector<std::string>& extraMagVars) {
-
-    for (int i = 0; i < extraVars.size(); i++) {
-        const std::string str = extraVars[i];
-        // Check if string is in the format specified for magnitude variables
-        if (str.substr(0, 2) == "|(" && str.substr(str.size() - 2, 2) == ")|") {
-            std::istringstream ss(str.substr(2, str.size() - 4));
-            std::string magVar;
-            size_t counter = 0;
-            while(std::getline(ss, magVar, ',')) {
-                magVar.erase(std::remove_if(magVar.begin(), magVar.end(), ::isspace),
-                        magVar.end());
-                extraMagVars.push_back(magVar);
-                counter++;
-                if (counter == 3) {
-                    break;
-                }
-            }
-            if (counter != 3 && counter > 0) {
-                extraMagVars.erase(extraMagVars.end() - counter, extraMagVars.end());
-            }
-            extraVars.erase(extraVars.begin() + i);
-            i--;
-        }
-    }
-}
-
-} // namespace openspace
diff --git a/modules/fieldlinessequence/shaders/fieldlinessequence_vs.glsl b/modules/fieldlinessequence/shaders/fieldlinessequence_vs.glsl
index d7976413db..ee93ca17a3 100644
--- a/modules/fieldlinessequence/shaders/fieldlinessequence_vs.glsl
+++ b/modules/fieldlinessequence/shaders/fieldlinessequence_vs.glsl
@@ -67,14 +67,14 @@ out float vs_depth;
 
 vec4 getTransferFunctionColor() {
     // Remap the color scalar to a [0,1] range
-    const float lookUpVal = (in_color_scalar - colorTableRange.x) /
+    float lookUpVal = (in_color_scalar - colorTableRange.x) /
                             (colorTableRange.y - colorTableRange.x);
     return texture(colorTable, lookUpVal);
 }
 
 bool isPartOfParticle(const double time, const int vertexId, const int particleSize,
                       const int particleSpeed, const int particleSpacing) {
-    const int modulusResult = int(double(particleSpeed) * time + vertexId) % particleSpacing;
+    int modulusResult = int(double(particleSpeed) * time + vertexId) % particleSpacing;
     return modulusResult > 0 && modulusResult <= particleSize;
 }
 
@@ -88,7 +88,7 @@ void main() {
     }
 
     if (usingDomain && hasColor) {
-        const float radius = length(in_position);
+        float radius = length(in_position);
 
         if (in_position.x < domainLimX.x || in_position.x > domainLimX.y ||
             in_position.y < domainLimY.x || in_position.y > domainLimY.y ||
@@ -100,7 +100,7 @@ void main() {
     }
 
     if (hasColor) {
-        const bool isParticle = usingParticles && isPartOfParticle(time, gl_VertexID,
+        bool isParticle = usingParticles && isPartOfParticle(time, gl_VertexID,
                                                                     particleSize,
                                                                     particleSpeed,
                                                                     particleSpacing);
@@ -112,7 +112,7 @@ void main() {
         }
 
         if (colorMethod == colorByQuantity) {
-            const vec4 quantityColor = getTransferFunctionColor();
+            vec4 quantityColor = getTransferFunctionColor();
             vs_color = vec4(quantityColor.xyz, vs_color.a * quantityColor.a);
         }
     } else {
diff --git a/modules/fieldlinessequence/util/commons.cpp b/modules/fieldlinessequence/util/commons.cpp
index 4b2f795356..48bce4d610 100644
--- a/modules/fieldlinessequence/util/commons.cpp
+++ b/modules/fieldlinessequence/util/commons.cpp
@@ -24,10 +24,9 @@
 
 #include <modules/fieldlinessequence/util/commons.h>
 
-namespace openspace {
-namespace fls {
+namespace openspace::fls {
 
-Model stringToModel(const std::string s) {
+Model stringToModel(const std::string& s) {
     if (s == "batsrus") {
         return Model::Batsrus;
     } else if (s == "enlil") {
@@ -38,5 +37,4 @@ Model stringToModel(const std::string s) {
     return Model::Invalid;
 }
 
-} // namespace fls
-} // namespace openspace
+} // namespace openspace::fls
diff --git a/modules/fieldlinessequence/util/commons.h b/modules/fieldlinessequence/util/commons.h
index 4ab83825eb..9fde3fe9cc 100644
--- a/modules/fieldlinessequence/util/commons.h
+++ b/modules/fieldlinessequence/util/commons.h
@@ -27,23 +27,21 @@
 
 #include <string>
 
-namespace openspace {
-namespace fls { // (F)ield(L)ines(S)equence
+namespace openspace::fls { // (F)ield(L)ines(S)equence
 
-enum Model : int {
+enum class Model : int {
     Batsrus = 0,
     Enlil,
     Pfss,
     Invalid
 };
 
-Model stringToModel(const std::string s);
+Model stringToModel(const std::string& s);
 
-const float AuToMeter = 149597870700.f;  // Astronomical Units
-const float ReToMeter = 6371000.f;       // Earth radius
-const float RsToMeter = 695700000.f;     // Sun radius
+constexpr const float AuToMeter = 149597870700.f;  // Astronomical Units
+constexpr const float ReToMeter = 6371000.f;       // Earth radius
+constexpr const float RsToMeter = 695700000.f;     // Sun radius
 
-} // namespace fls
-} // namespace openspace
+} // namespace openspace::fls
 
 #endif // __OPENSPACE_MODULE_FIELDLINESSEQUENCE___COMMONS___H__
diff --git a/modules/fieldlinessequence/util/fieldlinesstate.cpp b/modules/fieldlinessequence/util/fieldlinesstate.cpp
index e089a719ea..92262b454e 100644
--- a/modules/fieldlinessequence/util/fieldlinesstate.cpp
+++ b/modules/fieldlinessequence/util/fieldlinesstate.cpp
@@ -24,12 +24,10 @@
 
 #include <modules/fieldlinessequence/util/fieldlinesstate.h>
 
-#include <ext/json/json.hpp>
-
 #include <openspace/util/time.h>
-
+#include <ghoul/fmt.h>
 #include <ghoul/logging/logmanager.h>
-
+#include <ext/json/json.hpp>
 #include <fstream>
 
 namespace {
@@ -41,11 +39,11 @@ namespace {
 namespace openspace {
 
 /**
-* Converts all glm::vec3 in _vertexPositions from spherical (radius, latitude, longitude)
-* coordinates into cartesian coordinates. The longitude and latitude coordinates are
-* expected to be in degrees. scale is an optional scaling factor.
-*/
-void FieldlinesState::convertLatLonToCartesian(const float scale /* = 1.f */) {
+ * Converts all glm::vec3 in _vertexPositions from spherical (radius, latitude, longitude)
+ * coordinates into cartesian coordinates. The longitude and latitude coordinates are
+ * expected to be in degrees. scale is an optional scaling factor.
+ */
+void FieldlinesState::convertLatLonToCartesian(float scale /* = 1.f */) {
     for (glm::vec3& p : _vertexPositions) {
 
         const float r = p.x * scale;
@@ -57,7 +55,7 @@ void FieldlinesState::convertLatLonToCartesian(const float scale /* = 1.f */) {
     }
 }
 
-void FieldlinesState::scalePositions(const float scale) {
+void FieldlinesState::scalePositions(float scale) {
     for (glm::vec3& p : _vertexPositions) {
         p *= scale;
     }
@@ -66,21 +64,20 @@ void FieldlinesState::scalePositions(const float scale) {
 bool FieldlinesState::loadStateFromOsfls(const std::string& pathToOsflsFile) {
     std::ifstream ifs(pathToOsflsFile, std::ifstream::binary);
     if (!ifs.is_open()) {
-        LERRORC("FieldlinesState", "Couldn't open file: " + pathToOsflsFile);
+        LERROR("Couldn't open file: " + pathToOsflsFile);
         return false;
     }
 
     int binFileVersion;
-    ifs.read( reinterpret_cast<char*>(&binFileVersion), sizeof(int));
+    ifs.read(reinterpret_cast<char*>(&binFileVersion), sizeof(int));
 
     switch (binFileVersion) {
-        case 0 : {
-                // No need to put everything in this scope now, as only version 0 exists!
-            }
+        case 0:
+            // No need to put everything in this scope now, as only version 0 exists!
             break;
-        default :
-             LERRORC("FieldlinesState","VERSION OF BINARY FILE WAS NOT RECOGNISED!");
-             return false;
+        default:
+            LERROR("VERSION OF BINARY FILE WAS NOT RECOGNIZED!");
+            return false;
     }
 
     // Define tmp variables to store meta data in
@@ -90,35 +87,32 @@ bool FieldlinesState::loadStateFromOsfls(const std::string& pathToOsflsFile) {
     size_t byteSizeAllNames;
 
     // Read single value variables
-    ifs.read( reinterpret_cast<char*>(&_triggerTime),     sizeof(double));
-    ifs.read( reinterpret_cast<char*>(&_model),           sizeof(int));
-    ifs.read( reinterpret_cast<char*>(&_isMorphable),     sizeof(bool));
-    ifs.read( reinterpret_cast<char*>(&nLines),           sizeof(size_t));
-    ifs.read( reinterpret_cast<char*>(&nPoints),          sizeof(size_t));
-    ifs.read( reinterpret_cast<char*>(&nExtras),          sizeof(size_t));
-    ifs.read( reinterpret_cast<char*>(&byteSizeAllNames), sizeof(size_t));
+    ifs.read(reinterpret_cast<char*>(&_triggerTime), sizeof(double));
+    ifs.read(reinterpret_cast<char*>(&_model), sizeof(int32_t));
+    ifs.read(reinterpret_cast<char*>(&_isMorphable), sizeof(bool));
+    ifs.read(reinterpret_cast<char*>(&nLines), sizeof(uint64_t));
+    ifs.read(reinterpret_cast<char*>(&nPoints), sizeof(uint64_t));
+    ifs.read(reinterpret_cast<char*>(&nExtras), sizeof(uint64_t));
+    ifs.read(reinterpret_cast<char*>(&byteSizeAllNames), sizeof(uint64_t));
 
-    // RESERVE/RESIZE vectors
-    // TODO: Do this without initializing values? Resize is slower than just using
-    // reserve, due to initialization of all values
     _lineStart.resize(nLines);
     _lineCount.resize(nLines);
     _vertexPositions.resize(nPoints);
     _extraQuantities.resize(nExtras);
-    _extraQuantityNames.reserve(nExtras);
+    _extraQuantityNames.resize(nExtras);
 
     // Read vertex position data
-    ifs.read( reinterpret_cast<char*>(_lineStart.data()),       sizeof(GLint) * nLines);
-    ifs.read( reinterpret_cast<char*>(_lineCount.data()),       sizeof(GLsizei) * nLines);
+    ifs.read(reinterpret_cast<char*>(_lineStart.data()), sizeof(int32_t) * nLines);
+    ifs.read(reinterpret_cast<char*>(_lineCount.data()), sizeof(uint32_t) * nLines);
     ifs.read(
         reinterpret_cast<char*>(_vertexPositions.data()),
-        sizeof(glm::vec3) * nPoints
+        3 * sizeof(float) * nPoints
     );
 
     // Read all extra quantities
     for (std::vector<float>& vec : _extraQuantities) {
         vec.resize(nPoints);
-        ifs.read( reinterpret_cast<char*>(vec.data()), sizeof(float) * nPoints);
+        ifs.read(reinterpret_cast<char*>(vec.data()), sizeof(float) * nPoints);
     }
 
     // Read all extra quantities' names. Stored as multiple c-strings
@@ -134,21 +128,22 @@ bool FieldlinesState::loadStateFromOsfls(const std::string& pathToOsflsFile) {
         endOfVarName -= offset;
         std::string varName = allNamesInOne.substr(offset, endOfVarName);
         offset += varName.size() + 1;
-        _extraQuantityNames.push_back(varName);
+        _extraQuantityNames[i] = varName;
     }
 
     return true;
 }
 
 bool FieldlinesState::loadStateFromJson(const std::string& pathToJsonFile,
-                                        const fls::Model Model,
-                                        const float coordToMeters = 1.f) {
+                                        fls::Model Model,
+                                        float coordToMeters = 1.f)
+{
 
     // --------------------- ENSURE FILE IS VALID, THEN PARSE IT --------------------- //
     std::ifstream ifs(pathToJsonFile);
 
     if (!ifs.is_open()) {
-        LERROR("FAILED TO OPEN FILE: " << pathToJsonFile);
+        LERROR(fmt::format("FAILED TO OPEN FILE: {}", pathToJsonFile));
         return false;
     }
 
@@ -158,15 +153,16 @@ bool FieldlinesState::loadStateFromJson(const std::string& pathToJsonFile,
 
     _model = Model;
 
-    const std::string sData  = "data";
-    const std::string sTrace = "trace";
+    const char* sData  = "data";
+    const char* sTrace = "trace";
 
     // ----- EXTRACT THE EXTRA QUANTITY NAMES & TRIGGER TIME (same for all lines) ----- //
     {
-        const json jTmp = *jFile.begin(); // First field line in the file
-        _triggerTime = Time::convertTime(jTmp["time"]);
+        const char* sTime = "time";
+        const json& jTmp = *(jFile.begin()); // First field line in the file
+        _triggerTime = Time::convertTime(jTmp[sTime]);
 
-        const std::string sColumns = "columns";
+        const char* sColumns = "columns";
         auto variableNameVec = jTmp[sTrace][sColumns];
         const size_t nVariables = variableNameVec.size();
         const size_t nPosComponents = 3; // x,y,z
@@ -179,7 +175,7 @@ bool FieldlinesState::loadStateFromJson(const std::string& pathToJsonFile,
             return false;
         }
 
-        for (size_t i = nPosComponents ; i < nVariables ; i++) {
+        for (size_t i = nPosComponents ; i < nVariables ; ++i) {
             _extraQuantityNames.push_back(variableNameVec[i]);
         }
     }
@@ -192,17 +188,23 @@ bool FieldlinesState::loadStateFromJson(const std::string& pathToJsonFile,
     for (json::iterator lineIter = jFile.begin(); lineIter != jFile.end(); ++lineIter) {
         // The 'data' field in the 'trace' variable contains all vertex positions and the
         // extra quantities. Each element is an array related to one vertex point.
-        const std::vector<std::vector<float>> jData = (*lineIter)[sTrace][sData];
+        const std::vector<std::vector<float>>& jData = (*lineIter)[sTrace][sData];
         const size_t nPoints = jData.size();
 
         for (size_t j = 0; j < nPoints; ++j) {
             const std::vector<float>& variables = jData[j];
 
             // Expects the x, y and z variables to be stored first!
-            const size_t xIdx = 0, yIdx = 1, zIdx = 2;
-            _vertexPositions.push_back(coordToMeters * glm::vec3(variables[xIdx],
-                                                                 variables[yIdx],
-                                                                 variables[zIdx]));
+            const size_t xIdx = 0;
+            const size_t yIdx = 1;
+            const size_t zIdx = 2;
+            _vertexPositions.push_back(
+                coordToMeters * glm::vec3(
+                    variables[xIdx],
+                    variables[yIdx],
+                    variables[zIdx]
+                )
+            );
 
             // Add the extra quantites. Stored in the same array as the x,y,z variables.
             // Hence index of the first extra quantity = 3
@@ -249,17 +251,19 @@ void FieldlinesState::saveStateToOsfls(const std::string& absPath) {
     pathSafeTimeString.replace(13, 1, "-");
     pathSafeTimeString.replace(16, 1, "-");
     pathSafeTimeString.replace(19, 1, "-");
-    const std::string fileName = pathSafeTimeString + ".osfls";
+    std::string fileName = pathSafeTimeString + ".osfls";
 
     std::ofstream ofs(absPath + fileName, std::ofstream::binary | std::ofstream::trunc);
     if (!ofs.is_open()) {
-        LERROR("Failed to save state to binary file: " << absPath << fileName);
+        LERROR(fmt::format(
+            "Failed to save state to binary file: {}{}", absPath, fileName
+        ));
         return;
     }
 
     // --------- Add each string of _extraQuantityNames into one long string --------- //
     std::string allExtraQuantityNamesInOne = "";
-    for (std::string str : _extraQuantityNames) {
+    for (const std::string& str : _extraQuantityNames) {
         allExtraQuantityNamesInOne += str + '\0'; // Add null char '\0' for easier reading
     }
 
@@ -270,30 +274,30 @@ void FieldlinesState::saveStateToOsfls(const std::string& absPath) {
 
     //----------------------------- WRITE EVERYTHING TO FILE -----------------------------
     // VERSION OF BINARY FIELDLINES STATE FILE - IN CASE STRUCTURE CHANGES IN THE FUTURE
-    ofs.write( (char*)(&CurrentVersion), sizeof( int ) );
+    ofs.write(reinterpret_cast<const char*>(&CurrentVersion), sizeof(int));
 
     //-------------------- WRITE META DATA FOR STATE --------------------------------
-    ofs.write(reinterpret_cast<char*>(&_triggerTime), sizeof( _triggerTime ));
-    ofs.write(reinterpret_cast<char*>(&_model),       sizeof( int ));
-    ofs.write(reinterpret_cast<char*>(&_isMorphable), sizeof( bool ));
+    ofs.write(reinterpret_cast<const char*>(&_triggerTime), sizeof(_triggerTime));
+    ofs.write(reinterpret_cast<const char*>(&_model), sizeof(int32_t));
+    ofs.write(reinterpret_cast<const char*>(&_isMorphable), sizeof(bool));
 
-    ofs.write(reinterpret_cast<const char*>(&nLines),       sizeof( size_t ));
-    ofs.write(reinterpret_cast<const char*>(&nPoints),      sizeof( size_t ));
-    ofs.write(reinterpret_cast<const char*>(&nExtras),      sizeof( size_t ));
-    ofs.write(reinterpret_cast<const char*>(&nStringBytes), sizeof( size_t ));
+    ofs.write(reinterpret_cast<const char*>(&nLines), sizeof(uint64_t));
+    ofs.write(reinterpret_cast<const char*>(&nPoints), sizeof(uint64_t));
+    ofs.write(reinterpret_cast<const char*>(&nExtras), sizeof(uint64_t));
+    ofs.write(reinterpret_cast<const char*>(&nStringBytes), sizeof(uint64_t));
 
     //---------------------- WRITE ALL ARRAYS OF DATA --------------------------------
-    ofs.write(reinterpret_cast<char*>(_lineStart.data()),       sizeof(GLint) * nLines);
-    ofs.write(reinterpret_cast<char*>(_lineCount.data()),       sizeof(GLsizei) * nLines);
+    ofs.write(reinterpret_cast<char*>(_lineStart.data()), sizeof(int32_t) * nLines);
+    ofs.write(reinterpret_cast<char*>(_lineCount.data()), sizeof(uint32_t) * nLines);
     ofs.write(
         reinterpret_cast<char*>(_vertexPositions.data()),
-        sizeof(glm::vec3) * nPoints
+        3 * sizeof(float) * nPoints
     );
     // Write the data for each vector in _extraQuantities
     for (std::vector<float>& vec : _extraQuantities) {
-        ofs.write( reinterpret_cast<char*>(vec.data()),  sizeof(float) * nPoints);
+        ofs.write(reinterpret_cast<char*>(vec.data()), sizeof(float) * nPoints);
     }
-    ofs.write( allExtraQuantityNamesInOne.c_str(), nStringBytes);
+    ofs.write(allExtraQuantityNamesInOne.c_str(), nStringBytes);
 }
 
 // TODO: This should probably be rewritten, but this is the way the files were structured
@@ -322,16 +326,18 @@ void FieldlinesState::saveStateToOsfls(const std::string& absPath) {
 // }
 void FieldlinesState::saveStateToJson(const std::string& absPath) {
     // Create the file
-    const std::string ext = ".json";
+    const char* ext = ".json";
     std::ofstream ofs(absPath + ext, std::ofstream::trunc);
     if (!ofs.is_open()) {
-        LERROR("Failed to save state to json file at location: " << absPath << ext);
+        LERROR(fmt::format(
+            "Failed to save state to json file at location: {}{}", absPath, ext
+        ));
         return;
     }
-    LINFO("Saving fieldline state to: " << absPath << ext );
+    LINFO(fmt::format("Saving fieldline state to: {}{}", absPath, ext));
 
-    json jColumns = {"x", "y", "z"};
-    for (std::string s : _extraQuantityNames) {
+    json jColumns = { "x", "y", "z" };
+    for (const std::string& s : _extraQuantityNames) {
         jColumns.push_back(s);
     }
 
@@ -339,27 +345,27 @@ void FieldlinesState::saveStateToJson(const std::string& absPath) {
 
     const std::string timeStr = Time(_triggerTime).ISO8601();
     const size_t nLines       = _lineStart.size();
-    const size_t nPoints      = _vertexPositions.size();
+    // const size_t nPoints      = _vertexPositions.size();
     const size_t nExtras      = _extraQuantities.size();
 
     size_t pointIndex = 0;
-    for (size_t lineIndex = 0; lineIndex < nLines; lineIndex++) {
+    for (size_t lineIndex = 0; lineIndex < nLines; ++lineIndex) {
         json jData = json::array();
-        for (size_t i = 0; i < _lineCount[lineIndex]; i++, pointIndex++) {
+        for (GLsizei i = 0; i < _lineCount[lineIndex]; i++, ++pointIndex) {
             const glm::vec3 pos = _vertexPositions[pointIndex];
             json jDataElement = {pos.x, pos.y, pos.z};
 
-            for (size_t extraIndex = 0; extraIndex < nExtras; extraIndex++) {
+            for (size_t extraIndex = 0; extraIndex < nExtras; ++extraIndex) {
                 jDataElement.push_back(_extraQuantities[extraIndex][pointIndex]);
             }
             jData.push_back(jDataElement);
         }
 
         jFile[std::to_string(lineIndex)] = {
-            {"time", timeStr},
-            {"trace", {
-                {"columns", jColumns},
-                {"data", jData}
+            { "time", timeStr },
+            { "trace", {
+                { "columns", jColumns },
+                { "data", jData }
             }}
         };
     }
@@ -368,21 +374,22 @@ void FieldlinesState::saveStateToJson(const std::string& absPath) {
     const int indentationSpaces = 2;
     ofs << std::setw(indentationSpaces) << jFile << std::endl;
 
-    LINFO("Saved fieldline state to: " << absPath << ext );
+    LINFO(fmt::format("Saved fieldline state to: {}{}", absPath, ext));
 }
 
 // Returns one of the extra quantity vectors, _extraQuantities[index].
 // If index is out of scope an empty vector is returned and the referenced bool is false.
-std::vector<float> FieldlinesState::extraQuantity(const size_t index,
-                                                          bool& isSuccessful) const {
+std::vector<float> FieldlinesState::extraQuantity(size_t index, bool& isSuccessful) const
+{
     if (index < _extraQuantities.size()) {
         isSuccessful = true;
         return _extraQuantities[index];
     }
-    LERROR("Provided Index was out of scope!");
-    isSuccessful = false;
-    // return empty vector which goes out of scope hence unusable!
-    return std::vector<float>();
+    else {
+        isSuccessful = false;
+        LERROR("Provided Index was out of scope!");
+        return {};
+    }
 }
 
 // Moves the points in @param line over to _vertexPositions and updates
@@ -402,9 +409,8 @@ void FieldlinesState::addLine(std::vector<glm::vec3>& line) {
     line.clear();
 }
 
-void FieldlinesState::setExtraQuantityNames(std::vector<std::string>& names) {
+void FieldlinesState::setExtraQuantityNames(std::vector<std::string> names) {
     _extraQuantityNames = std::move(names);
-    names.clear();
     _extraQuantities.resize(_extraQuantityNames.size());
 }
 
diff --git a/modules/fieldlinessequence/util/fieldlinesstate.h b/modules/fieldlinessequence/util/fieldlinesstate.h
index e2b2fabf6d..94a0404d0b 100644
--- a/modules/fieldlinessequence/util/fieldlinesstate.h
+++ b/modules/fieldlinessequence/util/fieldlinesstate.h
@@ -27,48 +27,41 @@
 
 #include <modules/fieldlinessequence/util/commons.h>
 
-#include <ghoul/opengl/ghoul_gl.h>
 #include <ghoul/glm.h>
-
+#include <ghoul/opengl/ghoul_gl.h>
 #include <string>
 #include <vector>
 
-#ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
-namespace ccmc {
-    class Kameleon;
-}
-#endif // OPENSPACE_MODULE_KAMELEON_ENABLED
-
 namespace openspace {
 
 class FieldlinesState {
 public:
-    void convertLatLonToCartesian(const float scale = 1.f);
-    void scalePositions(const float scale);
+    void convertLatLonToCartesian(float scale = 1.f);
+    void scalePositions(float scale);
 
     bool loadStateFromOsfls(const std::string& pathToOsflsFile);
     void saveStateToOsfls(const std::string& pathToOsflsFile);
 
-    bool loadStateFromJson(const std::string& pathToJsonFile,
-                           const fls::Model model, const float coordToMeters);
+    bool loadStateFromJson(const std::string& pathToJsonFile, fls::Model model,
+        float coordToMeters);
     void saveStateToJson(const std::string& pathToJsonFile);
 
-    // ----------------------------------- GETTERS ----------------------------------- //
-    const std::vector<std::vector<float>>& extraQuantities()    const;
-    const std::vector<std::string>&        extraQuantityNames() const;
-    const std::vector<GLsizei>&            lineCount()          const;
-    const std::vector<GLint>&              lineStart()          const;
-    fls::Model                             model()              const;
-    size_t                                 nExtraQuantities()   const;
-    double                                 triggerTime()        const;
-    const std::vector<glm::vec3>&          vertexPositions()    const;
+    const std::vector<std::vector<float>>& extraQuantities() const;
+    const std::vector<std::string>& extraQuantityNames() const;
+    const std::vector<GLsizei>& lineCount() const;
+    const std::vector<GLint>& lineStart() const;
 
-    // Special getter. Returns extraQuantities[INDEX].
-    std::vector<float> extraQuantity(const size_t INDEX, bool& isSuccesful) const;
+    fls::Model model() const;
+    size_t nExtraQuantities() const;
+    double triggerTime() const;
+    const std::vector<glm::vec3>& vertexPositions() const;
 
-    void setModel(const fls::Model m)   { _model = m; }
-    void setTriggerTime(const double t) { _triggerTime = t; }
-    void setExtraQuantityNames(std::vector<std::string>& names);
+    // Special getter. Returns extraQuantities[index].
+    std::vector<float> extraQuantity(size_t index, bool& isSuccesful) const;
+
+    void setModel(fls::Model m) { _model = m; }
+    void setTriggerTime(double t) { _triggerTime = t; }
+    void setExtraQuantityNames(std::vector<std::string> names);
 
     void addLine(std::vector<glm::vec3>& line);
     void appendToExtra(size_t idx, float val) { _extraQuantities[idx].push_back(val); }
diff --git a/modules/fieldlinessequence/util/kameleonfieldlinehelper.cpp b/modules/fieldlinessequence/util/kameleonfieldlinehelper.cpp
index c08326e293..81ae066664 100644
--- a/modules/fieldlinessequence/util/kameleonfieldlinehelper.cpp
+++ b/modules/fieldlinessequence/util/kameleonfieldlinehelper.cpp
@@ -26,6 +26,9 @@
 
 #include <modules/fieldlinessequence/util/commons.h>
 #include <modules/fieldlinessequence/util/fieldlinesstate.h>
+#include <ghoul/fmt.h>
+#include <ghoul/logging/logmanager.h>
+#include <memory>
 
 #ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
 
@@ -45,68 +48,63 @@
 
 #endif // OPENSPACE_MODULE_KAMELEON_ENABLED
 
-#include <ghoul/logging/logmanager.h>
-
-#include <memory>
 
 namespace {
-    std::string _loggerCat = "FieldlinesSequence[ Kameleon ]";
+    constexpr const char* _loggerCat = "FieldlinesSequence[ Kameleon ]";
 
-    const std::string TAsPOverRho = "T = p/rho";
-    const std::string JParallelB  = "Current: mag(J||B)";
+    constexpr const char* TAsPOverRho = "T = p/rho";
+    constexpr const char* JParallelB  = "Current: mag(J||B)";
     // [nPa]/[amu/cm^3] * ToKelvin => Temperature in Kelvin
-    const float ToKelvin = 72429735.6984f;
-}
+    constexpr const float ToKelvin = 72429735.6984f;
+} // namespace
 
-namespace openspace {
-namespace fls {
+namespace openspace::fls {
 
 // -------------------- DECLARE FUNCTIONS USED (ONLY) IN THIS FILE -------------------- //
 #ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
     bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& seeds,
-                         const std::string tracingVar, FieldlinesState& state);
+        const std::string tracingVar, FieldlinesState& state);
     void addExtraQuantities(ccmc::Kameleon* kameleon,
-                            std::vector<std::string>& extraScalarVars,
-                            std::vector<std::string>& extraMagVars,
-                            FieldlinesState& state);
+        std::vector<std::string>& extraScalarVars, std::vector<std::string>& extraMagVars,
+        FieldlinesState& state);
     void prepareStateAndKameleonForExtras(ccmc::Kameleon* kameleon,
-                                          std::vector<std::string>& extraScalarVars,
-                                          std::vector<std::string>& extraMagVars,
-                                          FieldlinesState& state);
+        std::vector<std::string>& extraScalarVars, std::vector<std::string>& extraMagVars,
+        FieldlinesState& state);
 #endif // OPENSPACE_MODULE_KAMELEON_ENABLED
-// ----------------------------------------------------------------------------------- //
+// ------------------------------------------------------------------------------------ //
 
 /** Traces field lines from the provided cdf file using kameleon and stores the data in
  * the provided FieldlinesState.
- * Returns `false` if it fails to create a valid state. Requires the kameleon module to be
- * activated!
- * @param state, FieldlineState which should hold the extracted data
- * @param cdfPath, std::string of the absolute path to a .cdf file
- * @param seedPoints, vector of seed points from which to trace field lines
- * @param tracingVar, which quantity to trace lines from. Typically "b" for magnetic field
+ * Returns `false` if it fails to create a valid state. Requires the kameleon module to
+ * be activated!
+ * \param state, FieldlineState which should hold the extracted data
+ * \param cdfPath, std::string of the absolute path to a .cdf file
+ * \param seedPoints, vector of seed points from which to trace field lines
+ * \param tracingVar, which quantity to trace lines from. Typically "b" for magnetic field
  *        lines and "u" for velocity flow lines
- * @param extraVars, extra scalar quantities to be stored in the FieldlinesState; e.g. "T"
+ * \param extraVars, extra scalar quantities to be stored in the FieldlinesState; e.g. "T"
  *        for temperature, "rho" for density or "P" for pressure
- * @param extraMagVars, variables which should be used for extracting magnitudes, must be
+ * \param extraMagVars, variables which should be used for extracting magnitudes, must be
  *        a multiple of 3; e.g. "ux", "uy" & "uz" to get the magnitude of the velocity
  *        vector at each line vertex
  */
-bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string cdfPath,
+bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string& cdfPath,
                                  const std::vector<glm::vec3>& seedPoints,
-                                 const std::string tracingVar,
+                                 std::string tracingVar,
                                  std::vector<std::string>& extraVars,
-                                 std::vector<std::string>& extraMagVars) {
+                                 std::vector<std::string>& extraMagVars)
+{
 
 #ifndef OPENSPACE_MODULE_KAMELEON_ENABLED
-
     LERROR("CDF inputs provided but Kameleon module is deactivated!");
     return false;
 
 #else // OPENSPACE_MODULE_KAMELEON_ENABLED
 
     // Create Kameleon object and open CDF file!
-    std::unique_ptr<ccmc::Kameleon> kameleon =
-            kameleonHelper::createKameleonObject(cdfPath);
+    std::unique_ptr<ccmc::Kameleon> kameleon = kameleonHelper::createKameleonObject(
+        cdfPath
+    );
 
     state.setModel(fls::stringToModel(kameleon->getModelName()));
     state.setTriggerTime(kameleonHelper::getTime(kameleon.get()));
@@ -117,10 +115,10 @@ bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string cdfPa
         // the extraQuantites, as the iterpolator needs the unaltered positions
         addExtraQuantities(kameleon.get(), extraVars, extraMagVars, state);
         switch (state.model()) {
-            case fls::Batsrus:
+            case fls::Model::Batsrus:
                 state.scalePositions(fls::ReToMeter);
                 break;
-            case fls::Enlil :
+            case fls::Model::Enlil:
                 state.convertLatLonToCartesian(fls::AuToMeter);
                 break;
             default:
@@ -147,28 +145,30 @@ bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& see
     float innerBoundaryLimit;
 
     switch (state.model()) {
-        case fls::Model::Batsrus :
+        case fls::Model::Batsrus:
             innerBoundaryLimit = 2.5f;  // TODO specify in Lua?
             break;
-        case fls::Model::Enlil :
+        case fls::Model::Enlil:
             innerBoundaryLimit = 0.11f; // TODO specify in Lua?
             break;
         default:
-            LERROR("OpenSpace's fieldlines sequence currently only supports CDFs from the"
-                    << " BATSRUS and ENLIL models!");
+            LERROR(
+                "OpenSpace's fieldlines sequence currently only supports CDFs from the "
+                "BATSRUS and ENLIL models!"
+            );
             return false;
     }
 
     // ---------------------------- LOAD TRACING VARIABLE ---------------------------- //
     if (!kameleon->loadVariable(tracingVar)) {
-        LERROR("FAILED TO LOAD TRACING VARIABLE: " + tracingVar);
+        LERROR("Failed to load tracing variable: " + tracingVar);
         return false;
     }
 
-    bool isSuccesful = false;
-    LINFO("TRACING FIELD LINES!");
+    bool success = false;
+    LINFO("Tracing field lines!");
     // LOOP THROUGH THE SEED POINTS, TRACE LINES, CONVERT POINTS TO glm::vec3 AND STORE //
-    for (glm::vec3 seed : seedPoints) {
+    for (const glm::vec3& seed : seedPoints) {
         //--------------------------------------------------------------------------//
         // We have to create a new tracer (or actually a new interpolator) for each //
         // new line, otherwise some issues occur                                    //
@@ -177,9 +177,12 @@ bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& see
                 std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
         ccmc::Tracer tracer(kameleon, interpolator.get());
         tracer.setInnerBoundary(innerBoundaryLimit); // TODO specify in Lua?
-        ccmc::Fieldline ccmcFieldline = tracer.bidirectionalTrace(tracingVar, seed.x,
-                                                                              seed.y,
-                                                                              seed.z);
+        ccmc::Fieldline ccmcFieldline = tracer.bidirectionalTrace(
+            tracingVar,
+            seed.x,
+            seed.y,
+            seed.z
+        );
         const std::vector<ccmc::Point3f>& positions = ccmcFieldline.getPositions();
 
         const size_t nLinePoints = positions.size();
@@ -190,17 +193,17 @@ bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& see
             vertices.emplace_back(p.component1, p.component2, p.component3);
         }
         state.addLine(vertices);
-        isSuccesful = (nLinePoints > 0) ? true : isSuccesful;
+        success = (nLinePoints > 0) ? true : success;
     }
 
-    return isSuccesful;
+    return success;
 }
 #endif // OPENSPACE_MODULE_KAMELEON_ENABLED
 
 /**
  * Loops through state's _vertexPositions and extracts corresponding 'extraQuantities'
  * from the kameleon object using a ccmc::interpolator.
- * Note that the positions MUST be unaltered (NOT scaled NOR converted to different
+ * Note that the positions MUST be unaltered (NOT scaled NOR converted to a different
  * coordinate system)!
  *
  * @param kameleon raw pointer to an already opened Kameleon object
@@ -215,7 +218,9 @@ bool addLinesToState(ccmc::Kameleon* kameleon, const std::vector<glm::vec3>& see
 #ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
 void addExtraQuantities(ccmc::Kameleon* kameleon,
                         std::vector<std::string>& extraScalarVars,
-                        std::vector<std::string>& extraMagVars, FieldlinesState& state) {
+                        std::vector<std::string>& extraMagVars,
+                        FieldlinesState& state)
+{
 
     prepareStateAndKameleonForExtras(kameleon, extraScalarVars, extraMagVars, state);
 
@@ -226,7 +231,7 @@ void addExtraQuantities(ccmc::Kameleon* kameleon,
             std::make_unique<ccmc::KameleonInterpolator>(kameleon->model);
 
     // ------ Extract all the extraQuantities from kameleon and store in state! ------ //
-    for (const glm::vec3 p : state.vertexPositions()) {
+    for (const glm::vec3& p : state.vertexPositions()) {
         // Load the scalars!
         for (size_t i = 0; i < nXtraScalars; i++) {
             float val;
@@ -286,27 +291,30 @@ void addExtraQuantities(ccmc::Kameleon* kameleon,
 void prepareStateAndKameleonForExtras(ccmc::Kameleon* kameleon,
                                       std::vector<std::string>& extraScalarVars,
                                       std::vector<std::string>& extraMagVars,
-                                      FieldlinesState& state) {
+                                      FieldlinesState& state)
+{
     std::vector<std::string> extraQuantityNames;
     fls::Model model = fls::stringToModel(kameleon->getModelName());
 
     // Load the existing SCALAR variables into kameleon.
     // Remove non-existing variables from vector
-    for (int i = 0; i < extraScalarVars.size(); i++) {
+    for (int i = 0; i < static_cast<int>(extraScalarVars.size()); ++i) {
         std::string& str = extraScalarVars[i];
-        bool isSuccesful = kameleon->doesVariableExist(str) &&
-                           kameleon->loadVariable(str);
-        if (!isSuccesful &&
-                (model == fls::Model::Batsrus && (str == TAsPOverRho || str == "T" ))) {
+        bool success = kameleon->doesVariableExist(str) && kameleon->loadVariable(str);
+        if (!success &&
+            (model == fls::Model::Batsrus && (str == TAsPOverRho || str == "T" )))
+        {
             LDEBUG("BATSRUS doesn't contain variable T for temperature. Trying to "
-                   << "calculate it using the ideal gas law: T = pressure/density");
+                   "calculate it using the ideal gas law: T = pressure/density");
             const std::string p = "p", r = "rho";
-            isSuccesful = kameleon->doesVariableExist(p) && kameleon->loadVariable(p)
-                       && kameleon->doesVariableExist(r) && kameleon->loadVariable(r);
+            success = kameleon->doesVariableExist(p) && kameleon->loadVariable(p) &&
+                      kameleon->doesVariableExist(r) && kameleon->loadVariable(r);
             str = TAsPOverRho;
         }
-        if (!isSuccesful) {
-            LWARNING("FAILED TO LOAD EXTRA VARIABLE: '" << str << "'. Ignoring it!");
+        if (!success) {
+            LWARNING(fmt::format(
+                "Failed to load extra variable: '{}'. Ignoring", str
+            ));
             extraScalarVars.erase(extraScalarVars.begin() + i);
             --i;
         } else {
@@ -317,23 +325,24 @@ void prepareStateAndKameleonForExtras(ccmc::Kameleon* kameleon,
     // Load the existing magnitude variables (should be provided in multiple of 3)
     // into kameleon. Remove non-existing variables from vector
     if (extraMagVars.size() % 3 == 0) {
-        for (int i = 0; i < static_cast<int>(extraMagVars.size()); i += 3) {
-            std::string s1 = extraMagVars[i];
-            std::string s2 = extraMagVars[i+1];
-            std::string s3 = extraMagVars[i+2];
-            bool isSuccesful = kameleon->doesVariableExist(s1) &&
+        for (size_t i = 0; i < extraMagVars.size(); i += 3) {
+            const std::string& s1 = extraMagVars[i];
+            const std::string& s2 = extraMagVars[i+1];
+            const std::string& s3 = extraMagVars[i+2];
+            bool success = kameleon->doesVariableExist(s1) &&
                                kameleon->doesVariableExist(s2) &&
                                kameleon->doesVariableExist(s3) &&
                                kameleon->loadVariable(s1) &&
                                kameleon->loadVariable(s2) &&
                                kameleon->loadVariable(s3);
             std::string name = "Magnitude of (" + s1 + ", "+ s2 + ", "+ s3 + ")";
-            if (isSuccesful && model == fls::Model::Batsrus && s1 == "jx" && s2 == "jy"
-                    && s3 == "jz") {
+            if (success && model == fls::Model::Batsrus &&
+                s1 == "jx" && s2 == "jy" && s3 == "jz")
+            {
                 // CCMC isn't really interested in the magnitude of current, but by the
                 // magnitude of the part of the current's vector that is parallel to the
                 // magnetic field => ensure that the magnetic variables are loaded
-                isSuccesful =  kameleon->doesVariableExist("bx") &&
+                success =  kameleon->doesVariableExist("bx") &&
                                kameleon->doesVariableExist("by") &&
                                kameleon->doesVariableExist("bz") &&
                                kameleon->loadVariable("bx") &&
@@ -341,29 +350,32 @@ void prepareStateAndKameleonForExtras(ccmc::Kameleon* kameleon,
                                kameleon->loadVariable("bz");
                 name = JParallelB;
             }
-            if (!isSuccesful) {
-                LWARNING("FAILED TO LOAD AT LEAST ONE OF THE MAGNITUDE VARIABLES: "
-                        << s1 << ", " << s2 <<  " & " << s3
-                        << ". Removing ability to store corresponding magnitude!");
+            if (!success) {
+                LWARNING(fmt::format(
+                    "Failed to load at least one of the magnitude variables: {}, {}, {} "
+                    "& {}. Removing ability to store corresponding magnitude",
+                    s1, s2, s3
+                ));
                 extraMagVars.erase(
                     extraMagVars.begin() + i,
                     extraMagVars.begin() + i + 3
                 );
                 i -= 3;
             } else {
-                extraQuantityNames.push_back(name);
+                extraQuantityNames.push_back(std::move(name));
             }
         }
     } else {
         // WRONG NUMBER OF MAGNITUDE VARIABLES.. REMOVE ALL!
         extraMagVars.clear();
-        LWARNING("Wrong number of variables provided for storing magnitudes. "
-                << "Expects multiple of 3 but " << extraMagVars.size()
-                << " are provided");
+        LWARNING(fmt::format(
+            "Wrong number of variables provided for storing magnitudes. Expects multiple "
+            "of 3 but {} are provided",
+            extraMagVars.size()
+        ));
     }
-    state.setExtraQuantityNames(extraQuantityNames);
+    state.setExtraQuantityNames(std::move(extraQuantityNames));
 }
 #endif // OPENSPACE_MODULE_KAMELEON_ENABLED
 
-} // namespace fls
-} // namespace openspace
+} // namespace openspace::fls
diff --git a/modules/fieldlinessequence/util/kameleonfieldlinehelper.h b/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
index d769f28aab..eb0bfaed14 100644
--- a/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
+++ b/modules/fieldlinessequence/util/kameleonfieldlinehelper.h
@@ -26,7 +26,6 @@
 #define __OPENSPACE_MODULE_FIELDLINESSEQUENCE___KAMELEONFIELDLINEHELPER___H__
 
 #include <ghoul/glm.h>
-
 #include <string>
 #include <vector>
 
@@ -36,11 +35,9 @@ class FieldlinesState;
 
 namespace fls {
 
-bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string cdfPath,
-                                 const std::vector<glm::vec3>& seedPoints,
-                                 const std::string tracingVar,
-                                 std::vector<std::string>& extraVars,
-                                 std::vector<std::string>& extraMagVars);
+bool convertCdfToFieldlinesState(FieldlinesState& state, const std::string& cdfPath,
+    const std::vector<glm::vec3>& seedPoints, std::string tracingVar,
+    std::vector<std::string>& extraVars, std::vector<std::string>& extraMagVars);
 
 } // namespace fls
 } // namespace openspace
diff --git a/modules/galaxy/tasks/milkywayconversiontask.cpp b/modules/galaxy/tasks/milkywayconversiontask.cpp
index 5f3b11139c..ae0e1fb401 100644
--- a/modules/galaxy/tasks/milkywayconversiontask.cpp
+++ b/modules/galaxy/tasks/milkywayconversiontask.cpp
@@ -85,7 +85,7 @@ void MilkywayConversionTask::perform(const Task::ProgressCallback& progressCallb
     using namespace openspace::volume;
 
     std::vector<std::string> filenames;
-    for (int i = 0; i < _inNSlices; i++) {
+    for (size_t i = 0; i < _inNSlices; i++) {
         filenames.push_back(
             _inFilenamePrefix + std::to_string(i + _inFirstIndex) + _inFilenameSuffix
         );
diff --git a/modules/globebrowsing/globebrowsingmodule.cpp b/modules/globebrowsing/globebrowsingmodule.cpp
index f106725005..412667d56e 100644
--- a/modules/globebrowsing/globebrowsingmodule.cpp
+++ b/modules/globebrowsing/globebrowsingmodule.cpp
@@ -272,6 +272,14 @@ scripting::LuaLibrary GlobeBrowsingModule::luaLibrary() const {
             "getGeoPosition",
             &globebrowsing::luascriptfunctions::getGeoPosition,
             {},
+            "name, latitude, longitude, altitude",
+            "Returns the specified surface position on the globe as three floating point "
+            "values"
+        },
+        {
+            "getGeoPositionForCamera",
+            &globebrowsing::luascriptfunctions::getGeoPositionForCamera,
+            {},
             "void",
             "Get geographic coordinates of the camera poosition in latitude, "
             "longitude, and altitude"
@@ -348,6 +356,28 @@ void GlobeBrowsingModule::goToGeo(double latitude, double longitude,
     );
 }
 
+glm::vec3 GlobeBrowsingModule::cartesianCoordinatesFromGeo(
+                                                    globebrowsing::RenderableGlobe& globe,
+                                       double latitude, double longitude, double altitude)
+{
+    using namespace globebrowsing;
+
+    Geodetic3 pos = {
+        {
+            Angle<double>::fromDegrees(latitude).asRadians(),
+            Angle<double>::fromDegrees(longitude).asRadians()
+        },
+        altitude
+    };
+
+    glm::dvec3 positionModelSpace = globe.ellipsoid().cartesianPosition(pos);
+    //glm::dmat4 modelTransform = globe.modelTransform();
+    //glm::dvec3 positionWorldSpace = glm::dvec3(modelTransform *
+        //glm::dvec4(positionModelSpace, 1.0));
+
+    return glm::vec3(positionModelSpace);
+}
+
 void GlobeBrowsingModule::goToChunk(Camera& camera, globebrowsing::TileIndex ti,
                                     glm::vec2 uv, bool resetCameraDirection)
 {
@@ -362,8 +392,9 @@ void GlobeBrowsingModule::goToChunk(Camera& camera, globebrowsing::TileIndex ti,
     // Camera position in model space
     glm::dvec3 camPos = camera.positionVec3();
     glm::dmat4 inverseModelTransform = globe->inverseModelTransform();
-    glm::dvec3 cameraPositionModelSpace =
-    glm::dvec3(inverseModelTransform * glm::dvec4(camPos, 1));
+    glm::dvec3 cameraPositionModelSpace = glm::dvec3(
+        inverseModelTransform * glm::dvec4(camPos, 1)
+    );
 
     GeodeticPatch patch(ti);
     Geodetic2 corner = patch.getCorner(SOUTH_WEST);
diff --git a/modules/globebrowsing/globebrowsingmodule.h b/modules/globebrowsing/globebrowsingmodule.h
index aaf588032e..fcb3aacdf7 100644
--- a/modules/globebrowsing/globebrowsingmodule.h
+++ b/modules/globebrowsing/globebrowsingmodule.h
@@ -53,6 +53,9 @@ public:
     void goToGeo(double latitude, double longitude);
     void goToGeo(double latitude, double longitude, double altitude);
 
+    glm::vec3 cartesianCoordinatesFromGeo(globebrowsing::RenderableGlobe& globe,
+        double latitude, double longitude, double altitude);
+
     globebrowsing::cache::MemoryAwareTileCache* tileCache();
     scripting::LuaLibrary luaLibrary() const override;
     globebrowsing::RenderableGlobe* castFocusNodeRenderableToGlobe();
diff --git a/modules/globebrowsing/globebrowsingmodule_lua.inl b/modules/globebrowsing/globebrowsingmodule_lua.inl
index c35807d5c8..748e91026f 100644
--- a/modules/globebrowsing/globebrowsingmodule_lua.inl
+++ b/modules/globebrowsing/globebrowsingmodule_lua.inl
@@ -34,6 +34,7 @@
 #include <openspace/rendering/renderable.h>
 #include <openspace/scene/scene.h>
 #include <openspace/scene/scenegraphnode.h>
+#include <openspace/query/query.h>
 
 namespace openspace::globebrowsing::luascriptfunctions {
 
@@ -154,7 +155,7 @@ int goToChunk(lua_State* L) {
 
 int goToGeo(lua_State* L) {
     int nArguments = ghoul::lua::checkArgumentsAndThrow(L, 2, 3, "lua::goToGeo");
-    
+
     using ghoul::lua::luaTypeToString;
 
     double latitude = lua_tonumber(L, 1);
@@ -175,7 +176,40 @@ int goToGeo(lua_State* L) {
 }
 
 int getGeoPosition(lua_State* L) {
-    ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::getGeoPosition");
+    ghoul::lua::checkArgumentsAndThrow(L, 4, "lua::getGeoPosition");
+
+    std::string name = luaL_checkstring(L, 1);
+    double latitude = lua_tonumber(L, 2);
+    double longitude = lua_tonumber(L, 3);
+    double altitude = lua_tonumber(L, 4);
+
+    lua_settop(L, 0);
+    ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
+
+    SceneGraphNode* n = sceneGraphNode(name);
+    Renderable* r = n->renderable();
+    RenderableGlobe* g = dynamic_cast<RenderableGlobe*>(r);
+    if (!g) {
+        return luaL_error(L, "Name must be a RenderableGlobe");
+    }
+
+
+    GlobeBrowsingModule& mod = *(OsEng.moduleEngine().module<GlobeBrowsingModule>());
+    glm::vec3 pos = mod.cartesianCoordinatesFromGeo(
+        *g,
+        latitude,
+        longitude,
+        altitude
+    );
+
+    lua_pushnumber(L, pos.x);
+    lua_pushnumber(L, pos.y);
+    lua_pushnumber(L, pos.z);
+    return 3;
+}
+
+int getGeoPositionForCamera(lua_State* L) {
+    ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::getGeoPositionForCamera");
 
     GlobeBrowsingModule* module = OsEng.moduleEngine().module<GlobeBrowsingModule>();
     RenderableGlobe* globe = module->castFocusNodeRenderableToGlobe();
diff --git a/modules/globebrowsing/globes/renderableglobe.cpp b/modules/globebrowsing/globes/renderableglobe.cpp
index de951c7da5..c5c12717e0 100644
--- a/modules/globebrowsing/globes/renderableglobe.cpp
+++ b/modules/globebrowsing/globes/renderableglobe.cpp
@@ -220,6 +220,10 @@ RenderableGlobe::RenderableGlobe(const ghoul::Dictionary& dictionary)
     dictionary.getValue(keySegmentsPerPatch, patchSegmentsd);
     int patchSegments = static_cast<int>(patchSegmentsd);
 
+    if (dictionary.hasValue<bool>("PerformShading")) {
+        _generalProperties.performShading = dictionary.value<bool>("PerformShading");
+    }
+
     // Init layer manager
     ghoul::Dictionary layersDictionary;
     if (!dictionary.getValue(keyLayers, layersDictionary)) {
diff --git a/modules/globebrowsing/tile/rawtiledatareader/gdalwrapper.cpp b/modules/globebrowsing/tile/rawtiledatareader/gdalwrapper.cpp
index 47e7b8bba0..b4c139a39b 100644
--- a/modules/globebrowsing/tile/rawtiledatareader/gdalwrapper.cpp
+++ b/modules/globebrowsing/tile/rawtiledatareader/gdalwrapper.cpp
@@ -65,14 +65,14 @@ namespace {
 
 namespace openspace::globebrowsing {
 
-void gdalErrorHandler(CPLErr eErrClass, int, const char *msg) {
+void gdalErrorHandler(CPLErr eErrClass, int, const char* msg) {
     if (GdalWrapper::ref().logGdalErrors()) {
         switch (eErrClass) {
             case CE_None: break;
-            case CE_Debug:    LDEBUG  ("GDAL " << msg); break;
-            case CE_Warning:  LWARNING("GDAL " << msg); break;
-            case CE_Failure:  LERROR  ("GDAL " << msg); break;
-            case CE_Fatal:    LFATAL  ("GDAL " << msg); break;
+            case CE_Debug:    LDEBUGC  ("GDAL", msg); break;
+            case CE_Warning:  LWARNINGC("GDAL", msg); break;
+            case CE_Failure:  LERRORC  ("GDAL", msg); break;
+            case CE_Fatal:    LFATALC  ("GDAL", msg); break;
         }
     }
 }
@@ -188,12 +188,12 @@ void GdalWrapper::setGdalProxyConfiguration() {
         if (success) {
             std::string proxy = proxyAddress + ":" + proxyPort;
             CPLSetConfigOption("GDAL_HTTP_PROXY", proxy.c_str());
-            LDEBUG("Using proxy server " << proxy);
+            LDEBUG(fmt::format("Using proxy server {}", proxy));
             if (userAndPassword) {
                 std::string proxyUserPwd = proxyUser + ":" + proxyPassword;
                 CPLSetConfigOption("GDAL_HTTP_PROXYUSERPWD", proxyUserPwd.c_str());
                 CPLSetConfigOption("GDAL_HTTP_PROXYAUTH", proxyAuthString.c_str());
-                LDEBUG("Using authentication method: " << proxyAuthString);
+                LDEBUG(fmt::format("Using authentication method: {}", proxyAuthString));
             }
         } else {
             LERROR("Invalid proxy settings for GDAL");
diff --git a/modules/globebrowsing/tile/rawtiledatareader/tiledatatype.cpp b/modules/globebrowsing/tile/rawtiledatareader/tiledatatype.cpp
index 214423b89d..7692320135 100644
--- a/modules/globebrowsing/tile/rawtiledatareader/tiledatatype.cpp
+++ b/modules/globebrowsing/tile/rawtiledatareader/tiledatatype.cpp
@@ -47,7 +47,8 @@
 #include <modules/globebrowsing/geometry/angle.h>
 
 #include <float.h>
-
+#include <ghoul/fmt.h>
+#include <fmt/ostream.h>
 #include <sstream>
 #include <algorithm>
 
@@ -151,7 +152,7 @@ TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType) {
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -180,7 +181,7 @@ TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType) {
                     format.glFormat = GL_RED;
                     break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -210,7 +211,7 @@ TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType) {
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -240,12 +241,15 @@ TextureFormat getTextureFormat(int rasterCount, GDALDataType gdalType) {
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
         default:
-            LERROR("Unknown number of channels for OpenGL texture: " << rasterCount);
+            LERROR(fmt::format(
+                "Unknown number of channels for OpenGL texture: {}",
+                rasterCount
+            ));
             throw ghoul::MissingCaseException();
     }
     return format;
@@ -281,7 +285,7 @@ TextureFormat getTextureFormatOptimized(int rasterCount, GDALDataType gdalType)
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -310,7 +314,7 @@ TextureFormat getTextureFormatOptimized(int rasterCount, GDALDataType gdalType)
                     format.glFormat = GL_RED;
                     break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -340,7 +344,7 @@ TextureFormat getTextureFormatOptimized(int rasterCount, GDALDataType gdalType)
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
@@ -370,12 +374,12 @@ TextureFormat getTextureFormatOptimized(int rasterCount, GDALDataType gdalType)
                 //    format.glFormat = GL_RED;
                 //    break;
                 default:
-                    LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+                    LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
                     throw ghoul::MissingCaseException();
             }
             break;
         default:
-            LERROR("Unknown number of channels for OpenGL texture: " << rasterCount);
+            LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
             throw ghoul::MissingCaseException();
     }
     return format;
@@ -398,7 +402,7 @@ GLenum getOpenGLDataType(GDALDataType gdalType) {
         case GDT_Float64:
             return GL_DOUBLE;
         default:
-            LERROR("GDAL data type unknown to OpenGL: " << gdalType);
+            LERROR(fmt::format("GDAL data type unknown to OpenGL: {}", gdalType));
             throw ghoul::MissingCaseException();
     }
 }
@@ -420,7 +424,7 @@ GDALDataType getGdalDataType(GLenum glType) {
         case GL_DOUBLE:
             return GDT_Float64;
         default:
-            LERROR("OpenGL data type unknown to GDAL: " << glType);
+            LERROR(fmt::format("OpenGL data type unknown to GDAL: {}", glType));
             throw ghoul::MissingCaseException();
     }
 }
@@ -441,7 +445,7 @@ size_t numberOfRasters(ghoul::opengl::Texture::Format format) {
             return 4;
         default: {
             ghoul_assert(false, "Unknown format");
-            return 0;
+            throw ghoul::MissingCaseException();
         }
     }
 }
@@ -526,7 +530,7 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_R16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         case ghoul::opengl::Texture::Format::RG:
@@ -545,7 +549,7 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_RG16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         case ghoul::opengl::Texture::Format::RGB:
@@ -564,7 +568,7 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_RGB16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         case ghoul::opengl::Texture::Format::RGBA:
@@ -583,7 +587,7 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_RGBA16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         case ghoul::opengl::Texture::Format::BGR:
@@ -602,7 +606,7 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_RGB16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         case ghoul::opengl::Texture::Format::BGRA:
@@ -621,16 +625,16 @@ GLenum glTextureFormat(GLenum glType, ghoul::opengl::Texture::Format format) {
                     return GL_RGBA16F;
                 default:
                     ghoul_assert(false, "glType data type unknown");
-                    LERROR("glType data type unknown: " << glType);
+                    LERROR(fmt::format("glType data type unknown: {}", glType));
                     throw ghoul::MissingCaseException();
             }
         default:
-            LERROR(
-                "Unknown format for OpenGL texture: " <<
+            LERROR(fmt::format(
+                "Unknown format for OpenGL texture: {}",
                 static_cast<std::underlying_type_t<ghoul::opengl::Texture::Format>>(
                     format
                 )
-            );
+            ));
             throw ghoul::MissingCaseException();
     }
 }
diff --git a/modules/globebrowsing/tile/tileprovider/defaulttileprovider.cpp b/modules/globebrowsing/tile/tileprovider/defaulttileprovider.cpp
index eaa31ba04c..e854cc39fc 100644
--- a/modules/globebrowsing/tile/tileprovider/defaulttileprovider.cpp
+++ b/modules/globebrowsing/tile/tileprovider/defaulttileprovider.cpp
@@ -39,7 +39,7 @@
 #include <openspace/engine/moduleengine.h>
 
 #include <ghoul/logging/logmanager.h>
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/dictionary.h>
 #include <ghoul/opengl/texture.h>
 
@@ -92,7 +92,7 @@ DefaultTileProvider::DefaultTileProvider(const ghoul::Dictionary& dictionary)
     double pixelSize = 0.0;
     int tilePixelSize = 0;
     if (dictionary.getValue<double>(KeyTilePixelSize, pixelSize)) {
-        LDEBUG("Default pixel size overridden: " << pixelSize);
+        LDEBUG(fmt::format("Default pixel size overridden: {}", pixelSize));
         tilePixelSize = static_cast<int>(pixelSize);
     }
 
@@ -106,7 +106,10 @@ DefaultTileProvider::DefaultTileProvider(const ghoul::Dictionary& dictionary)
     _performPreProcessing =
         LayerManager::shouldPerformPreProcessingOnLayergroup(_layerGroupID);
     if (dictionary.getValue<bool>(KeyPerformPreProcessing, _performPreProcessing)) {
-        LDEBUG("Default PerformPreProcessing overridden: " << _performPreProcessing);
+        LDEBUG(fmt::format(
+            "Default PerformPreProcessing overridden: {}",
+            _performPreProcessing
+        ));
     }
 
     if (dictionary.hasKeyAndValue<double>(KeyPreCacheLevel)) {
@@ -241,7 +244,11 @@ void DefaultTileProvider::initAsyncTileDataReader(TileTextureInitData initData)
 
     // Tiles are only available for levels 2 and higher.
     if (_preCacheLevel >= 2) {
-        LDEBUG("Precaching '" << _filePath << "' with level '" << _preCacheLevel << "'");
+        LDEBUG(fmt::format(
+            "Precaching '{}' with level '{}'",
+            _filePath.value(),
+            _preCacheLevel
+        ));
         for (int level = 0; level <= _preCacheLevel; ++level) {
             for (int x = 0; x <= level * 2; ++x) {
                 for (int y = 0; y <= level; ++y) {
diff --git a/modules/globebrowsing/tile/tileprovider/temporaltileprovider.cpp b/modules/globebrowsing/tile/tileprovider/temporaltileprovider.cpp
index 2f5092b084..7b74752ed6 100644
--- a/modules/globebrowsing/tile/tileprovider/temporaltileprovider.cpp
+++ b/modules/globebrowsing/tile/tileprovider/temporaltileprovider.cpp
@@ -28,11 +28,12 @@
 
 #include <modules/globebrowsing/tile/tileprovider/defaulttileprovider.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/file.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 
 #include "cpl_minixml.h"
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 #include <fstream>
 
 namespace {
@@ -105,7 +106,7 @@ bool TemporalTileProvider::initialize() {
     bool success = TileProvider::initialize();
 
     if (!_preCacheTimes.empty()) {
-        LINFO("Preloading: " << _filePath.value());
+        LINFO(fmt::format("Preloading: {}", _filePath.value()));
         for (const Time& t : _preCacheTimes) {
             getTileProvider(t);
         }
diff --git a/modules/imgui/imguimodule.cpp b/modules/imgui/imguimodule.cpp
index 2bebd14f48..0a17c7da73 100644
--- a/modules/imgui/imguimodule.cpp
+++ b/modules/imgui/imguimodule.cpp
@@ -27,9 +27,9 @@
 #include <modules/imgui/include/gui.h>
 
 #include <openspace/engine/openspaceengine.h>
-#include <openspace/engine/settingsengine.h>
 #include <openspace/engine/virtualpropertymanager.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
+#include <openspace/engine/moduleengine.h>
 #include <openspace/interaction/navigationhandler.h>
 #include <openspace/interaction/luaconsole.h>
 #include <openspace/network/parallelconnection.h>
@@ -67,7 +67,6 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
                 []() {
                     std::vector<properties::PropertyOwner*> res = {
                         &(OsEng.windowWrapper()),
-                        &(OsEng.settingsEngine()),
                         &(OsEng.navigationHandler()),
                         &(OsEng.renderEngine()),
                         &(OsEng.parallelConnection()),
@@ -86,7 +85,15 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
                 }
             );
 
-            gui._property.setSource(
+            gui._moduleProperty.setSource(
+                []() {
+                    std::vector<properties::PropertyOwner*> v;
+                    v.push_back(&(OsEng.moduleEngine()));
+                    return v;
+                }
+            );
+
+            gui._sceneProperty.setSource(
                 []() {
                     const Scene* scene = OsEng.renderEngine().scene();
                     const std::vector<SceneGraphNode*>& nodes = scene ?
@@ -197,7 +204,7 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
         [&](Key key, KeyModifier mod, KeyAction action) -> bool {
             // A list of all the windows that can show up by themselves
             if (gui.isEnabled() || gui._performance.isEnabled() ||
-                gui._property.isEnabled())
+                gui._sceneProperty.isEnabled())
             {
                 return gui.keyCallback(key, mod, action);
             }
@@ -211,7 +218,7 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
         [&](unsigned int codepoint, KeyModifier modifier) -> bool {
             // A list of all the windows that can show up by themselves
             if (gui.isEnabled() || gui._performance.isEnabled() ||
-                gui._property.isEnabled())
+                gui._sceneProperty.isEnabled())
             {
                 return gui.charCallback(codepoint, modifier);
             }
@@ -225,7 +232,7 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
         [&](MouseButton button, MouseAction action) -> bool {
             // A list of all the windows that can show up by themselves
             if (gui.isEnabled() || gui._performance.isEnabled() ||
-                gui._property.isEnabled())
+                gui._sceneProperty.isEnabled())
             {
                 return gui.mouseButtonCallback(button, action);
             }
@@ -239,7 +246,7 @@ ImGUIModule::ImGUIModule() : OpenSpaceModule(Name) {
         [&](double, double posY) -> bool {
             // A list of all the windows that can show up by themselves
             if (gui.isEnabled() || gui._performance.isEnabled() ||
-                gui._property.isEnabled())
+                gui._sceneProperty.isEnabled())
             {
                 return gui.mouseWheelCallback(posY);
             }
diff --git a/modules/imgui/include/gui.h b/modules/imgui/include/gui.h
index 57a87eb682..f4646ec0ef 100644
--- a/modules/imgui/include/gui.h
+++ b/modules/imgui/include/gui.h
@@ -75,9 +75,12 @@ public:
     GuiGlobeBrowsingComponent _globeBrowsing;
 #endif //  GLOBEBROWSING_USE_GDAL
     GuiPerformanceComponent _performance;
+
     GuiPropertyComponent _globalProperty;
-    GuiPropertyComponent _property;
+    GuiPropertyComponent _sceneProperty;
     GuiPropertyComponent _screenSpaceProperty;
+    GuiPropertyComponent _moduleProperty;
+
     GuiPropertyComponent _virtualProperty;
     GuiSpaceTimeComponent _spaceTime;
     GuiMissionComponent _mission;
diff --git a/modules/imgui/include/guispacetimecomponent.h b/modules/imgui/include/guispacetimecomponent.h
index 41dbc556eb..0a162c85f5 100644
--- a/modules/imgui/include/guispacetimecomponent.h
+++ b/modules/imgui/include/guispacetimecomponent.h
@@ -49,10 +49,6 @@ private:
     bool _firstFrame;
 
     std::string _timeUnits;
-
-
-    //properties::FloatProperty _minMaxDeltaTime;
-    //float _localMinMaxDeltatime; // We don't want the default display inside the component
 };
 
 } // namespace openspace::gui
diff --git a/modules/imgui/src/gui.cpp b/modules/imgui/src/gui.cpp
index 68802dc108..a6c4995949 100644
--- a/modules/imgui/src/gui.cpp
+++ b/modules/imgui/src/gui.cpp
@@ -51,7 +51,7 @@ const char* configurationFile = "imgui.ini";
 //const char* GuiFont = "${FONTS}/ubuntu/Ubuntu-Regular.ttf";
 const char* GuiFont = "${FONTS}/arimo/Arimo-Regular.ttf";
 const float FontSize = 14.f;
-const ImVec2 size = ImVec2(500, 500);
+const ImVec2 Size = ImVec2(500, 500);
 
 //GLuint fontTex = 0;
 // A VBO max size of 0 will cause a lazy instantiation of the buffer
@@ -222,7 +222,7 @@ static void RenderDrawLists(ImDrawData* drawData) {
 
 void addScreenSpaceRenderableLocal(std::string texturePath) {
     if (!FileSys.fileExists(absPath(texturePath))) {
-        LWARNING("Could not find image '" << texturePath << "'");
+        LWARNING(fmt::format("Could not find image '{}'", texturePath));
         return;
     }
 
@@ -280,12 +280,13 @@ void CaptionText(const char* text) {
 
 GUI::GUI()
     : GuiComponent("Main")
-    , _globalProperty("Global")
-    , _property(
-        "Properties",
+    , _globalProperty("Global Properties")
+    , _sceneProperty(
+        "Scene Properties",
         GuiPropertyComponent::UseTreeLayout::Yes
     )
     , _screenSpaceProperty("ScreenSpace Properties")
+    , _moduleProperty("Module Properties")
     , _virtualProperty("Virtual Properties")
     , _featuredProperties("Featured Properties", GuiPropertyComponent::UseTreeLayout::No)
     , _showInternals(false)
@@ -297,7 +298,8 @@ GUI::GUI()
     addPropertySubOwner(_help);
     addPropertySubOwner(_performance);
     addPropertySubOwner(_globalProperty);
-    addPropertySubOwner(_property);
+    addPropertySubOwner(_moduleProperty);
+    addPropertySubOwner(_sceneProperty);
     addPropertySubOwner(_screenSpaceProperty);
     _featuredProperties.setEnabled(true);
     addPropertySubOwner(_featuredProperties);
@@ -323,7 +325,8 @@ GUI::GUI()
 #endif // GLOBEBROWSING_USE_GDAL
             _performance.setShowHelpTooltip(_showHelpText);
             _globalProperty.setShowHelpTooltip(_showHelpText);
-            _property.setShowHelpTooltip(_showHelpText);
+            _moduleProperty.setShowHelpTooltip(_showHelpText);
+            _sceneProperty.setShowHelpTooltip(_showHelpText);
             _screenSpaceProperty.setShowHelpTooltip(_showHelpText);
             _virtualProperty.setShowHelpTooltip(_showHelpText);
             _spaceTime.setShowHelpTooltip(_showHelpText);
@@ -348,7 +351,8 @@ GUI::GUI()
 #endif // GLOBEBROWSING_USE_GDAL
             _performance.setShowHelpTooltipDelay(_helpTextDelay);
             _globalProperty.setShowHelpTooltipDelay(_helpTextDelay);
-            _property.setShowHelpTooltipDelay(_helpTextDelay);
+            _moduleProperty.setShowHelpTooltipDelay(_helpTextDelay);
+            _sceneProperty.setShowHelpTooltipDelay(_helpTextDelay);
             _screenSpaceProperty.setShowHelpTooltipDelay(_helpTextDelay);
             _virtualProperty.setShowHelpTooltipDelay(_helpTextDelay);
             _spaceTime.setShowHelpTooltipDelay(_helpTextDelay);
@@ -479,12 +483,14 @@ void GUI::initialize() {
         style.Colors[ImGuiCol_TextSelectedBg] = ImVec4(0.44f, 0.63f, 1.00f, 0.35f);
         style.Colors[ImGuiCol_ModalWindowDarkening] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
     }
-    _property.initialize();
-    _property.setHasRegularProperties(true);
+    _sceneProperty.initialize();
+    _sceneProperty.setHasRegularProperties(true);
     _screenSpaceProperty.initialize();
     _screenSpaceProperty.setHasRegularProperties(true);
     _globalProperty.initialize();
     _globalProperty.setHasRegularProperties(true);
+    _moduleProperty.initialize();
+    _moduleProperty.setHasRegularProperties(true);
     _featuredProperties.initialize();
     _featuredProperties.setHasRegularProperties(true);
     _virtualProperty.initialize();
@@ -518,6 +524,7 @@ void GUI::deinitialize() {
     _help.deinitialize();
     _performance.deinitialize();
     _globalProperty.deinitialize();
+    _moduleProperty.deinitialize();
     _featuredProperties.deinitialize();
     _screenSpaceProperty.deinitialize();
     _virtualProperty.deinitialize();
@@ -526,7 +533,7 @@ void GUI::deinitialize() {
 #ifdef GLOBEBROWSING_USE_GDAL
     _globeBrowsing.deinitialize();
 #endif // GLOBEBROWSING_USE_GDAL
-    _property.deinitialize();
+    _sceneProperty.deinitialize();
 
     delete iniFileBuffer;
 }
@@ -614,9 +621,10 @@ void GUI::initializeGL() {
     glBindVertexArray(0);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 
-    _property.initializeGL();
+    _sceneProperty.initializeGL();
     _screenSpaceProperty.initializeGL();
     _globalProperty.initializeGL();
+    _moduleProperty.initializeGL();
     _featuredProperties.initializeGL();
     _performance.initializeGL();
     _help.initializeGL();
@@ -656,13 +664,14 @@ void GUI::deinitializeGL() {
     _performance.deinitializeGL();
     _featuredProperties.deinitializeGL();
     _globalProperty.deinitializeGL();
+    _moduleProperty.deinitializeGL();
     _screenSpaceProperty.deinitializeGL();
 #ifdef GLOBEBROWSING_USE_GDAL
     _globeBrowsing.deinitializeGL();
 #endif // GLOBEBROWSING_USE_GDAL
     _filePath.deinitializeGL();
     _asset.deinitializeGL();
-    _property.deinitializeGL();
+    _sceneProperty.deinitializeGL();
 }
 
 void GUI::startFrame(float deltaTime, const glm::vec2& windowSize,
@@ -709,8 +718,11 @@ void GUI::endFrame() {
         if (_globalProperty.isEnabled()) {
             _globalProperty.render();
         }
-        if (_property.isEnabled()) {
-            _property.render();
+        if (_moduleProperty.isEnabled()) {
+            _moduleProperty.render();
+        }
+        if (_sceneProperty.isEnabled()) {
+            _sceneProperty.render();
         }
         if (_screenSpaceProperty.isEnabled()) {
             _screenSpaceProperty.render();
@@ -832,9 +844,9 @@ void GUI::render() {
 
     _isCollapsed = ImGui::IsWindowCollapsed();
 
-    bool property = _property.isEnabled();
-    ImGui::Checkbox("Scene Graph Properties", &property);
-    _property.setEnabled(property);
+    bool sceneProperty = _sceneProperty.isEnabled();
+    ImGui::Checkbox("Scene Graph Properties", &sceneProperty);
+    _sceneProperty.setEnabled(sceneProperty);
 
     bool screenSpaceProperty = _screenSpaceProperty.isEnabled();
     ImGui::Checkbox("ScreenSpace Properties", &screenSpaceProperty);
@@ -848,6 +860,10 @@ void GUI::render() {
     ImGui::Checkbox("Global Properties", &globalProperty);
     _globalProperty.setEnabled(globalProperty);
 
+    bool moduleProperty = _moduleProperty.isEnabled();
+    ImGui::Checkbox("Module Properties", &moduleProperty);
+    _moduleProperty.setEnabled(moduleProperty);
+
     bool spacetime = _spaceTime.isEnabled();
     ImGui::Checkbox("Space/Time", &spacetime);
     _spaceTime.setEnabled(spacetime);
@@ -961,7 +977,8 @@ void GUI::renderAndUpdatePropertyVisibility() {
 
     _currentVisibility = static_cast<V>(t);
     _globalProperty.setVisibility(_currentVisibility);
-    _property.setVisibility(_currentVisibility);
+    _moduleProperty.setVisibility(_currentVisibility);
+    _sceneProperty.setVisibility(_currentVisibility);
     _screenSpaceProperty.setVisibility(_currentVisibility);
     _virtualProperty.setVisibility(_currentVisibility);
     _featuredProperties.setVisibility(_currentVisibility);
diff --git a/modules/imgui/src/guiglobebrowsingcomponent.cpp b/modules/imgui/src/guiglobebrowsingcomponent.cpp
index b752529318..27bdbdfe25 100644
--- a/modules/imgui/src/guiglobebrowsingcomponent.cpp
+++ b/modules/imgui/src/guiglobebrowsingcomponent.cpp
@@ -42,7 +42,7 @@
 #include <ghoul/lua/ghoul_lua.h>
 #include <ghoul/misc/defer.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include <numeric>
 
@@ -242,7 +242,7 @@ void GuiGlobeBrowsingComponent::render() {
     if (cap.empty()) {
         LWARNINGC(
             "GlobeBrowsingGUI",
-            "Unknown server: '" << _currentServer << "'"
+            fmt::format("Unknown server: '{}'", _currentServer)
         );
     }
 
diff --git a/modules/imgui/src/guihelpcomponent.cpp b/modules/imgui/src/guihelpcomponent.cpp
index 0512580caf..e06af1b62e 100644
--- a/modules/imgui/src/guihelpcomponent.cpp
+++ b/modules/imgui/src/guihelpcomponent.cpp
@@ -27,7 +27,7 @@
 #include <modules/imgui/include/imgui_include.h>
 
 namespace {
-    const ImVec2 size = ImVec2(350, 500);
+    const ImVec2 Size = ImVec2(350, 500);
 } // namespace
 
 namespace openspace::gui {
@@ -40,7 +40,7 @@ void GuiHelpComponent::render() {
     ImGui::SetNextWindowCollapsed(_isCollapsed);
 
     bool v = _isEnabled;
-    ImGui::Begin("Help", &v, size, 0.5f);
+    ImGui::Begin("Help", &v, Size, 0.5f);
     _isEnabled = v;
     _isCollapsed = ImGui::IsWindowCollapsed();
     ImGui::ShowUserGuide();
diff --git a/modules/imgui/src/guiiswacomponent.cpp b/modules/imgui/src/guiiswacomponent.cpp
index 661382cbb1..ef16b3eae1 100644
--- a/modules/imgui/src/guiiswacomponent.cpp
+++ b/modules/imgui/src/guiiswacomponent.cpp
@@ -33,7 +33,7 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/scripting/scriptengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 
 #include <modules/iswa/ext/json.h>
 
diff --git a/modules/imgui/src/guiparallelcomponent.cpp b/modules/imgui/src/guiparallelcomponent.cpp
index e59c591dbd..01fca59684 100644
--- a/modules/imgui/src/guiparallelcomponent.cpp
+++ b/modules/imgui/src/guiparallelcomponent.cpp
@@ -32,7 +32,7 @@
 #include <openspace/network/parallelconnection.h>
 #include <openspace/network/messagestructures.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include <algorithm>
 #include <numeric>
diff --git a/modules/imgui/src/guiperformancecomponent.cpp b/modules/imgui/src/guiperformancecomponent.cpp
index 9475b1b861..e954958bf1 100644
--- a/modules/imgui/src/guiperformancecomponent.cpp
+++ b/modules/imgui/src/guiperformancecomponent.cpp
@@ -33,7 +33,7 @@
 
 #include <ghoul/misc/sharedmemory.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include <algorithm>
 #include <numeric>
diff --git a/modules/imgui/src/guipropertycomponent.cpp b/modules/imgui/src/guipropertycomponent.cpp
index aab8911c48..174796859b 100644
--- a/modules/imgui/src/guipropertycomponent.cpp
+++ b/modules/imgui/src/guipropertycomponent.cpp
@@ -35,7 +35,7 @@
 #include <algorithm>
 
 namespace {
-    const ImVec2 size = ImVec2(350, 500);
+    const ImVec2 Size = ImVec2(350, 500);
 
     static const openspace::properties::Property::PropertyInfo UseTreeInfo = {
         "TreeLayout",
@@ -98,8 +98,8 @@ namespace {
             node.children.begin(),
             node.children.end(),
             [p = *path.begin()](const std::unique_ptr<TreeNode>& c) {
-            return c.get()->path == p;
-        }
+                return c.get()->path == p;
+            }
         );
 
         TreeNode* n;
@@ -112,7 +112,6 @@ namespace {
             std::unique_ptr<TreeNode> newNode = std::make_unique<TreeNode>(*path.begin());
             n = newNode.get();
             node.children.push_back(std::move(newNode));
-
         }
 
         // Recurse into the tree and chop off the first path
@@ -252,7 +251,7 @@ void GuiPropertyComponent::render() {
     ImGui::SetNextWindowCollapsed(_isCollapsed);
 
     bool v = _isEnabled;
-    ImGui::Begin(name().c_str(), &v, size, 0.75f);
+    ImGui::Begin(name().c_str(), &v, Size, 0.75f);
     _isEnabled = v;
 
     _isCollapsed = ImGui::IsWindowCollapsed();
@@ -317,8 +316,8 @@ void GuiPropertyComponent::render() {
 
                     if (lhsIt != ordering.end() && rhsIt != ordering.end()) {
                         if (lhsToken[1] != rhsToken[1]) {
-                            // If both top-level groups are in the ordering list, the order
-                            // of the iterators gives us the order of the groups
+                            // If both top-level groups are in the ordering list, the
+                            // order of the iterators gives us the order of the groups
                             return lhsIt < rhsIt;
                         }
                         else {
diff --git a/modules/iswa/rendering/datacygnet.cpp b/modules/iswa/rendering/datacygnet.cpp
index 696a38649a..5b9618c03a 100644
--- a/modules/iswa/rendering/datacygnet.cpp
+++ b/modules/iswa/rendering/datacygnet.cpp
@@ -106,13 +106,14 @@ DataCygnet::DataCygnet(const ghoul::Dictionary& dictionary)
     registerProperties();
 }
 
-DataCygnet::~DataCygnet(){}
+DataCygnet::~DataCygnet() {}
 
-bool DataCygnet::updateTexture(){
+bool DataCygnet::updateTexture() {
     std::vector<float*> data = textureData();
 
-    if(data.empty())
+    if (data.empty()) {
         return false;
+    }
 
     bool texturesReady = false;
     std::vector<int> selectedOptions = _dataOptions.value();
@@ -148,16 +149,17 @@ bool DataCygnet::updateTexture(){
     return texturesReady;
 }
 
-bool DataCygnet::downloadTextureResource(double timestamp){
-    if(_futureObject.valid())
+bool DataCygnet::downloadTextureResource(double timestamp) {
+    if (_futureObject.valid()) {
         return false;
+    }
 
     std::future<DownloadManager::MemoryFile> future = IswaManager::ref().fetchDataCygnet(
         _data->id,
         timestamp
     );
 
-    if(future.valid()){
+    if (future.valid()) {
         _futureObject = std::move(future);
         return true;
     }
@@ -168,8 +170,9 @@ bool DataCygnet::downloadTextureResource(double timestamp){
 bool DataCygnet::updateTextureResource(){
     DownloadManager::MemoryFile dataFile = _futureObject.get();
 
-     if(dataFile.corrupted)
+     if (dataFile.corrupted) {
         return false;
+    }
 
     _dataBuffer = std::string(dataFile.buffer, dataFile.size);
     delete[] dataFile.buffer;
@@ -197,8 +200,8 @@ void DataCygnet::setTextureUniforms(){
     // Set Textures
     ghoul::opengl::TextureUnit txUnits[MAX_TEXTURES];
     int j = 0;
-    for(int option : selectedOptions){
-        if(_textures[option]){
+    for (int option : selectedOptions) {
+        if (_textures[option]) {
             txUnits[j].activate();
             _textures[option]->bind();
             _shader->setUniform(
@@ -207,7 +210,9 @@ void DataCygnet::setTextureUniforms(){
             );
 
             j++;
-            if(j >= MAX_TEXTURES) break;
+            if (j >= MAX_TEXTURES) {
+                break;
+            }
         }
     }
 
@@ -220,17 +225,16 @@ void DataCygnet::setTextureUniforms(){
     ghoul::opengl::TextureUnit tfUnits[MAX_TEXTURES];
     j = 0;
 
-    if((activeTransferfunctions == 1)){
+    if (activeTransferfunctions == 1) {
         tfUnits[0].activate();
         _transferFunctions[0]->bind();
         _shader->setUniform(
             "transferFunctions[0]",
             tfUnits[0]
         );
-    }else{
-        for(int option : selectedOptions){
-
-            if(_transferFunctions[option]){
+    } else {
+        for (int option : selectedOptions) {
+            if (_transferFunctions[option]) {
                 tfUnits[j].activate();
                 _transferFunctions[option]->bind();
                 _shader->setUniform(
@@ -248,7 +252,6 @@ void DataCygnet::setTextureUniforms(){
     _shader->setUniform("numTextures", activeTextures);
 }
 
-
 void DataCygnet::readTransferFunctions(std::string tfPath){
     std::string line;
     std::ifstream tfFile(absPath(tfPath));
@@ -280,7 +283,7 @@ void DataCygnet::fillOptions(std::string& source) {
         _textureDimensions
     );
 
-    for (int i = 0; i < options.size(); i++) {
+    for (int i = 0; i < static_cast<int>(options.size()); i++) {
         _dataOptions.addOption({i, options[i]});
         _textures.push_back(nullptr);
     }
@@ -297,43 +300,45 @@ void DataCygnet::fillOptions(std::string& source) {
     }
 }
 
-void DataCygnet::setPropertyCallbacks(){
-    _normValues.onChange([this](){
+void DataCygnet::setPropertyCallbacks() {
+    _normValues.onChange([this]() {
         _dataProcessor->normValues(_normValues.value());
         updateTexture();
     });
 
-    _useLog.onChange([this](){
+    _useLog.onChange([this]() {
         _dataProcessor->useLog(_useLog.value());
         updateTexture();
     });
 
-    _useHistogram.onChange([this](){
+    _useHistogram.onChange([this]() {
         _dataProcessor->useHistogram(_useHistogram.value());
         updateTexture();
-        if(_autoFilter.value())
+        if (_autoFilter.value()) {
             _backgroundValues.setValue(_dataProcessor->filterValues());
+        }
     });
 
-    _dataOptions.onChange([this](){
-        if(_dataOptions.value().size() > MAX_TEXTURES)
+    _dataOptions.onChange([this]() {
+        if (_dataOptions.value().size() > MAX_TEXTURES) {
             LWARNING("Too many options chosen, max is " + std::to_string(MAX_TEXTURES));
+        }
         updateTexture();
     });
 
-    _transferFunctionsFile.onChange([this](){
+    _transferFunctionsFile.onChange([this]() {
         readTransferFunctions(_transferFunctionsFile.value());
     });
 }
 
-void DataCygnet::subscribeToGroup(){
+void DataCygnet::subscribeToGroup() {
     auto groupEvent = _group->groupEvent();
 
     groupEvent->subscribe(name(), "dataOptionsChanged", [&](ghoul::Dictionary dict){
         LDEBUG(name() + " Event dataOptionsChanged");
         std::vector<int> values;
         bool success = dict.getValue<std::vector<int> >("dataOptions", values);
-        if(success){
+        if (success) {
             _dataOptions.setValue(values);
         }
     });
@@ -342,7 +347,7 @@ void DataCygnet::subscribeToGroup(){
         LDEBUG(name() + " Event normValuesChanged");
         glm::vec2 values;
         bool success = dict.getValue("normValues", values);
-        if(success){
+        if (success) {
             _normValues.setValue(values);
         }
     });
@@ -351,7 +356,7 @@ void DataCygnet::subscribeToGroup(){
         LDEBUG(name() + " Event backgroundValuesChanged");
         glm::vec2 values;
         bool success = dict.getValue("backgroundValues", values);
-        if(success){
+        if (success) {
             _backgroundValues.setValue(values);
         }
     });
@@ -377,13 +382,13 @@ void DataCygnet::subscribeToGroup(){
         _autoFilter.setValue(dict.value<bool>("autoFilter"));
     });
 
-    groupEvent->subscribe(name(), "updateGroup", [&](ghoul::Dictionary dict) {
+    groupEvent->subscribe(name(), "updateGroup", [&](ghoul::Dictionary) {
         LDEBUG(name() + " Event updateGroup");
-        if(_autoFilter.value())
+        if (_autoFilter.value()) {
             _backgroundValues.setValue(_dataProcessor->filterValues());
+        }
         updateTexture();
     });
-
 }
 
 } //namespace openspace
diff --git a/modules/iswa/rendering/datasphere.cpp b/modules/iswa/rendering/datasphere.cpp
index 8b7f3a91f3..6aa0d1e378 100644
--- a/modules/iswa/rendering/datasphere.cpp
+++ b/modules/iswa/rendering/datasphere.cpp
@@ -33,10 +33,6 @@
 #include <math.h>
 #endif
 
-namespace {
-    constexpr const char* _loggerCat = "DataSphere";
-} // namespace
-
 namespace openspace {
 
 DataSphere::DataSphere(const ghoul::Dictionary& dictionary)
@@ -58,7 +54,11 @@ void DataSphere::initialize() {
     IswaCygnet::initialize();
 
     //rotate 90 degrees because of the texture coordinates in PowerScaledSphere
-    _rotation = glm::rotate(_rotation, (float)M_PI_2, glm::vec3(1.0, 0.0, 0.0));
+    _rotation = glm::rotate(
+        _rotation,
+        static_cast<float>(M_PI_2),
+        glm::vec3(1.0, 0.0, 0.0)
+    );
 
     if (_group) {
         _dataProcessor = _group->dataProcessor();
diff --git a/modules/iswa/rendering/iswacygnet.cpp b/modules/iswa/rendering/iswacygnet.cpp
index 8aed4c1d4c..3d3c9379f2 100644
--- a/modules/iswa/rendering/iswacygnet.cpp
+++ b/modules/iswa/rendering/iswacygnet.cpp
@@ -53,8 +53,8 @@ namespace openspace {
 
 IswaCygnet::IswaCygnet(const ghoul::Dictionary& dictionary)
     : Renderable(dictionary)
-    , _delete(DeleteInfo)
     , _alpha(AlphaInfo, 0.9f, 0.f, 1.f)
+    , _delete(DeleteInfo)
     , _shader(nullptr)
     , _group(nullptr)
     , _textureDirty(false)
diff --git a/modules/iswa/rendering/iswacygnet.h b/modules/iswa/rendering/iswacygnet.h
index 238dae34b3..a4fe36bba7 100644
--- a/modules/iswa/rendering/iswacygnet.h
+++ b/modules/iswa/rendering/iswacygnet.h
@@ -147,6 +147,7 @@ protected:
     std::string _programName;
 
     glm::mat4 _rotation; //to rotate objects with fliped texture coordniates
+
 private:
     bool destroyShader();
     glm::dmat3 _stateMatrix;
diff --git a/modules/iswa/rendering/iswakameleongroup.cpp b/modules/iswa/rendering/iswakameleongroup.cpp
index bead33c92b..7b9ebd6b0f 100644
--- a/modules/iswa/rendering/iswakameleongroup.cpp
+++ b/modules/iswa/rendering/iswakameleongroup.cpp
@@ -111,12 +111,12 @@ void IswaKameleonGroup::registerProperties() {
 }
 
 void IswaKameleonGroup::readFieldlinePaths(std::string indexFile) {
-    LINFO("Reading seed points paths from file '" << indexFile << "'");
+    LINFO(fmt::format("Reading seed points paths from file '{}'", indexFile));
 
     // Read the index file from disk
     std::ifstream seedFile(indexFile);
     if (!seedFile.good())
-        LERROR("Could not open seed points file '" << indexFile << "'");
+        LERROR(fmt::format("Could not open seed points file '{}'", indexFile));
     else {
         std::string line;
         std::string fileContent;
diff --git a/modules/iswa/rendering/kameleonplane.cpp b/modules/iswa/rendering/kameleonplane.cpp
index 71cfce85d0..a9d93613d9 100644
--- a/modules/iswa/rendering/kameleonplane.cpp
+++ b/modules/iswa/rendering/kameleonplane.cpp
@@ -25,15 +25,19 @@
 #include <fstream>
 #include <modules/iswa/rendering/kameleonplane.h>
 #include <modules/iswa/util/dataprocessorkameleon.h>
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 
-#ifdef __GNUC__
+#ifdef __clang__
+#elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
 #endif // __GNUC__
 
 #include <modules/iswa/ext/json.h>
-#ifdef __GNUC__
+
+#ifdef __clang__
+
+#elif defined(__GNUC__)
 #pragma GCC diagnostic pop
 #endif // __GNUC__
 
@@ -318,7 +322,7 @@ void KameleonPlane::updateFieldlineSeeds() {
 }
 
 void KameleonPlane::readFieldlinePaths(std::string indexFile) {
-    LINFO("Reading seed points paths from file '" << indexFile << "'");
+    LINFO(fmt::format("Reading seed points paths from file '{}'", indexFile));
     if (_group) {
         std::dynamic_pointer_cast<IswaKameleonGroup>(_group)->setFieldlineInfo(
             indexFile,
@@ -330,7 +334,7 @@ void KameleonPlane::readFieldlinePaths(std::string indexFile) {
     // Read the index file from disk
     std::ifstream seedFile(indexFile);
     if (!seedFile.good()) {
-        LERROR("Could not open seed points file '" << indexFile << "'");
+        LERROR(fmt::format("Could not open seed points file '{}'", indexFile));
     }
     else {
         try {
diff --git a/modules/iswa/rendering/screenspacecygnet.cpp b/modules/iswa/rendering/screenspacecygnet.cpp
index 0a6eb6bc35..2a2d831ff8 100644
--- a/modules/iswa/rendering/screenspacecygnet.cpp
+++ b/modules/iswa/rendering/screenspacecygnet.cpp
@@ -24,7 +24,7 @@
 
 #include <modules/iswa/rendering/screenspacecygnet.h>
 #include <ghoul/io/texture/texturereader.h>
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <openspace/util/time.h>
 #include <modules/iswa/util/iswamanager.h>
 #include <openspace/engine/openspaceengine.h>
diff --git a/modules/iswa/rendering/texturecygnet.cpp b/modules/iswa/rendering/texturecygnet.cpp
index 620a46d164..20cb22317e 100644
--- a/modules/iswa/rendering/texturecygnet.cpp
+++ b/modules/iswa/rendering/texturecygnet.cpp
@@ -48,7 +48,9 @@ bool TextureCygnet::updateTexture() {
     );
 
     if (texture) {
-        LDEBUG("Loaded texture from image iswa cygnet with id: '" << _data->id << "'");
+        LDEBUG(fmt::format(
+            "Loaded texture from image iswa cygnet with id: '{}'", _data->id
+        ));
         texture->uploadTexture();
         // Textures of planets looks much smoother with AnisotropicMipMap
         texture->setFilter(ghoul::opengl::Texture::FilterMode::LinearMipMap);
diff --git a/modules/iswa/rendering/textureplane.cpp b/modules/iswa/rendering/textureplane.cpp
index 9c3a925666..b12464f100 100644
--- a/modules/iswa/rendering/textureplane.cpp
+++ b/modules/iswa/rendering/textureplane.cpp
@@ -28,10 +28,6 @@
 #include <ghoul/opengl/textureunit.h>
 #include <ghoul/opengl/programobject.h>
 
-namespace {
-    constexpr const char* _loggerCat = "TexturePlane";
-} // namespace
-
 namespace openspace {
 
 TexturePlane::TexturePlane(const ghoul::Dictionary& dictionary)
diff --git a/modules/iswa/util/dataprocessor.cpp b/modules/iswa/util/dataprocessor.cpp
index b01334e895..65d2c45b2e 100644
--- a/modules/iswa/util/dataprocessor.cpp
+++ b/modules/iswa/util/dataprocessor.cpp
@@ -27,10 +27,6 @@
 
 #include <fstream>
 
-namespace {
-    constexpr const char* _loggerCat = "DataProcessor";
-} // namespace
-
 namespace openspace {
 
 DataProcessor::DataProcessor()
diff --git a/modules/iswa/util/dataprocessorjson.cpp b/modules/iswa/util/dataprocessorjson.cpp
index 37a3ac5a56..c2616c85d0 100644
--- a/modules/iswa/util/dataprocessorjson.cpp
+++ b/modules/iswa/util/dataprocessorjson.cpp
@@ -85,7 +85,7 @@ void DataProcessorJson::addDataValues(std::string data,
             json row = variables[options[i].description];
 //            int rowsize = row.size();
 
-            for(int y=0; y<row.size(); y++){
+            for(size_t y = 0; y < row.size(); ++y) {
                 json col = row.at(y);
                 int colsize = static_cast<int>(col.size());
 
diff --git a/modules/iswa/util/dataprocessorkameleon.cpp b/modules/iswa/util/dataprocessorkameleon.cpp
index 6117417201..2c2a6e5738 100644
--- a/modules/iswa/util/dataprocessorkameleon.cpp
+++ b/modules/iswa/util/dataprocessorkameleon.cpp
@@ -24,13 +24,10 @@
 
 #include <modules/iswa/util/dataprocessorkameleon.h>
 //#include <algorithm>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/glm.h>
 
-namespace {
-    constexpr const char* _loggerCat = "DataProcessorKameleon";
-} // namespace
-
 namespace openspace {
 
 DataProcessorKameleon::DataProcessorKameleon()
@@ -164,10 +161,12 @@ void DataProcessorKameleon::dimensions(glm::size3_t dimensions) {
     _dimensions = dimensions;
 }
 
-void DataProcessorKameleon::initializeKameleonWrapper(std::string path){
+void DataProcessorKameleon::initializeKameleonWrapper(std::string path) {
     const std::string& extension = ghoul::filesystem::File(absPath(path)).fileExtension();
-    if(FileSys.fileExists(absPath(path)) && extension == "cdf"){
-        if(_kw) _kw->close();
+    if (FileSys.fileExists(absPath(path)) && extension == "cdf") {
+        if (_kw) {
+            _kw->close();
+        }
 
         _kwPath = path;
         _kw = std::make_shared<KameleonWrapper>(absPath(_kwPath));
diff --git a/modules/iswa/util/iswamanager.cpp b/modules/iswa/util/iswamanager.cpp
index 135a1b57d2..7bd07d484d 100644
--- a/modules/iswa/util/iswamanager.cpp
+++ b/modules/iswa/util/iswamanager.cpp
@@ -38,7 +38,7 @@
 #include <fstream>
 #include <algorithm>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <modules/kameleon/include/kameleonwrapper.h>
 #include <openspace/scene/scene.h>
 #include <openspace/util/spicemanager.h>
@@ -51,8 +51,8 @@
 
 #ifdef __clang__
 #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wuseless-cast"
-#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+// #pragma clang diagnostic ignored "-Wuseless-cast"
+// #pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
 #elif (defined __GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wuseless-cast"
@@ -661,7 +661,7 @@ void IswaManager::fillCygnetInfo(std::string jsonString) {
 
         for (auto list : lists) {
             json jsonList = j[list];
-            for (int i=0; i<jsonList.size(); i++) {
+            for (size_t i = 0; i < jsonList.size(); ++i) {
                 json jCygnet = jsonList.at(i);
 
                 std::string name = jCygnet["cygnetDisplayTitle"];
@@ -689,7 +689,7 @@ void IswaManager::addCdfFiles(std::string cdfpath) {
 
         if (jsonFile.is_open()) {
             json cdfGroups = json::parse(jsonFile);
-            for(int i=0; i<cdfGroups.size(); i++){
+            for(size_t i = 0; i < cdfGroups.size(); ++i) {
                 json cdfGroup = cdfGroups.at(i);
 
                 std::string groupName = cdfGroup["group"];
diff --git a/modules/kameleon/src/kameleonhelper.cpp b/modules/kameleon/src/kameleonhelper.cpp
index 0a6d9a697b..fe752b0d2d 100644
--- a/modules/kameleon/src/kameleonhelper.cpp
+++ b/modules/kameleon/src/kameleonhelper.cpp
@@ -39,7 +39,7 @@
 #endif // _MSC_VER
 
 #include <ghoul/logging/logmanager.h>
-
+#include <ghoul/fmt.h>
 
 namespace {
     std::string _loggerCat = "KameleonHelper";
@@ -57,14 +57,17 @@ std::unique_ptr<ccmc::Kameleon> createKameleonObject(const std::string& cdfFileP
 
     // ---------------------------- CREATE KAMELEON OBJECT ---------------------------- //
     std::unique_ptr<ccmc::Kameleon> kameleon = std::make_unique<ccmc::Kameleon>();
-    LDEBUG("\tOpening the cdf file: " << cdfFilePath);
+    LDEBUG(fmt::format("\tOpening the cdf file: {}", cdfFilePath));
     long kamStatus = kameleon->open(cdfFilePath);
 
     if (kamStatus != ccmc::FileReader::OK) {
-        LERROR("Failed to create a Kameleon Object from file: " << cdfFilePath);
+        LERROR(fmt::format(
+            "Failed to create a Kameleon Object from file: {}",
+            cdfFilePath
+        ));
        return nullptr;
     }
-    LDEBUG("\tSuccessfully opened : " << cdfFilePath);
+    LDEBUG(fmt::format("\tSuccessfully opened: {}", cdfFilePath));
     return kameleon;
 }
 
@@ -108,7 +111,7 @@ double getTime(ccmc::Kameleon* kameleon) {
                     case 17: // YYYY-MM-DDTHH:MM:      =>       YYYY-MM-DDTHH:MM:SS
                         seqStartStr += "00";
                         [[fallthrough]];
-                        // case 19 : // YYYY-MM-DDTHH:MM:SS    =>    YYYY-MM-DDTHH:MM:SS.000
+                    // case 19 : // YYYY-MM-DDTHH:MM:SS    =>    YYYY-MM-DDTHH:MM:SS.000
                     //     seqStartStr += ".000";
                     // case 23 : // YYYY-MM-DDTHH:MM:SS.   =>    YYYY-MM-DDTHH:MM:SS.000Z
                     //     seqStartStr += "Z";
@@ -123,8 +126,10 @@ double getTime(ccmc::Kameleon* kameleon) {
             seqStartStr =
                     kameleon->getGlobalAttribute("tim_crstart_cal").getAttributeString();
         } else {
-            LWARNING("No starting time attribute could be found in the .cdf file.\n\t" <<
-                    "Starting time is set to 01.JAN.2000 12:00.");
+            LWARNING(
+                "No starting time attribute could be found in the .cdf file. Starting "
+                "time is set to 01.JAN.2000 12:00."
+            );
             seqStartDbl = 0.0;
         }
 
@@ -137,7 +142,7 @@ double getTime(ccmc::Kameleon* kameleon) {
                     Time::convertTime(
                             seqStartStr.substr(0, seqStartStr.length() - 2));
         } else {
-            LWARNING("No starting time attribute could be found in the .cdf file.\n\t" <<
+            LWARNING("No starting time attribute could be found in the .cdf file."
                 "Starting time is set to 01.JAN.2000 12:00.");
             seqStartDbl = 0.0;
         }
@@ -154,7 +159,7 @@ double getTime(ccmc::Kameleon* kameleon) {
                             "time_physical_time").getAttributeFloat());
         } else {
             stateStartOffset = 0.0;
-            LWARNING("No time offset attribute could be found in the .cdf file.\n\t" <<
+            LWARNING("No time offset attribute could be found in the .cdf file."
                      "The current state starts the same time as the sequence!");
         }
 
diff --git a/modules/kameleon/src/kameleonwrapper.cpp b/modules/kameleon/src/kameleonwrapper.cpp
index 21ffb7a5f8..621a6c45ae 100644
--- a/modules/kameleon/src/kameleonwrapper.cpp
+++ b/modules/kameleon/src/kameleonwrapper.cpp
@@ -26,6 +26,7 @@
 //#include <openspace/util/progressbar.h>
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 
 #ifdef WIN32
@@ -44,12 +45,15 @@
 #pragma warning (pop)
 #endif // WIN32
 
+#ifdef WIN32
 #define _USE_MATH_DEFINES
+#endif // WIN32
 #include <math.h>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <iomanip>
+#include <ghoul/fmt.h>
 
 #include <glm/gtx/rotate_vector.hpp>
 
@@ -127,9 +131,9 @@ bool KameleonWrapper::open(const std::string& filename) {
         _gridType = getGridType(_xCoordVar, _yCoordVar, _zCoordVar);
         _type = getModelType();
 
-        LDEBUG("x:" << _xCoordVar);
-        LDEBUG("y:" << _yCoordVar);
-        LDEBUG("z:" << _zCoordVar);
+        LDEBUG(fmt::format("x: {}", _xCoordVar));
+        LDEBUG(fmt::format("y: {}", _yCoordVar));
+        LDEBUG(fmt::format("z: {}", _zCoordVar));
 
         _xMin =
             _model->getVariableAttribute(_xCoordVar, "actual_min").getAttributeFloat();
@@ -165,18 +169,18 @@ bool KameleonWrapper::open(const std::string& filename) {
         _zValidMax =
             _model->getVariableAttribute(_zCoordVar, "valid_max").getAttributeFloat();
 
-        LDEBUG("_xMin: " << _xMin);
-        LDEBUG("_xMax: " << _xMax);
-        LDEBUG("_yMin: " << _yMin);
-        LDEBUG("_yMax: " << _yMax);
-        LDEBUG("_zMin: " << _zMin);
-        LDEBUG("_zMax: " << _zMax);
-        LDEBUG("_xValidMin: " << _xValidMin);
-        LDEBUG("_xValidMax: " << _xValidMax);
-        LDEBUG("_yValidMin: " << _yValidMin);
-        LDEBUG("_yValidMax: " << _yValidMax);
-        LDEBUG("_zValidMin: " << _zValidMin);
-        LDEBUG("_zValidMax: " << _zValidMax);
+        LDEBUG(fmt::format("_xMin: {}", _xMin));
+        LDEBUG(fmt::format("_xMax: {}", _xMax));
+        LDEBUG(fmt::format("_yMin: {}", _yMin));
+        LDEBUG(fmt::format("_yMax: {}", _yMax));
+        LDEBUG(fmt::format("_zMin: {}", _zMin));
+        LDEBUG(fmt::format("_zMax: {}", _zMax));
+        LDEBUG(fmt::format("_xValidMin: {}", _xValidMin));
+        LDEBUG(fmt::format("_xValidMax: {}", _xValidMax));
+        LDEBUG(fmt::format("_yValidMin: {}", _yValidMin));
+        LDEBUG(fmt::format("_yValidMax: {}", _yValidMax));
+        LDEBUG(fmt::format("_zValidMin: {}", _zValidMin));
+        LDEBUG(fmt::format("_zValidMax: {}", _zValidMax));
 
         return true;
     }
@@ -203,7 +207,7 @@ float* KameleonWrapper::getUniformSampledValues(
     const glm::size3_t& outDimensions)
 {
     ghoul_assert(_model && _interpolator, "Model and interpolator must exist");
-    LINFO("Loading variable " << var << " from CDF data with a uniform sampling");
+    LINFO(fmt::format("Loading variable {} from CDF data with a uniform sampling", var));
 
     unsigned int size = static_cast<unsigned int>(
         outDimensions.x * outDimensions.y * outDimensions.z
@@ -218,8 +222,8 @@ float* KameleonWrapper::getUniformSampledValues(
     double stepY = (_yMax-_yMin)/(static_cast<double>(outDimensions.y));
     double stepZ = (_zMax-_zMin)/(static_cast<double>(outDimensions.z));
 
-    LDEBUG(var << "Min: " << varMin);
-    LDEBUG(var << "Max: " << varMax);
+    LDEBUG(fmt::format("{} Min: {}", var, varMin));
+    LDEBUG(fmt::format("{} Max: {}", var, varMax));
 
     // HISTOGRAM
     const int bins = 200;
@@ -348,7 +352,7 @@ float* KameleonWrapper::getUniformSampledValues(
             // LDEBUG("====================");
             break;
         }
-        LDEBUG("histogram[" << i << "]: " << histogram[i]);
+        LDEBUG(fmt::format("histogram[{}]: {}", i, histogram[i]));
     }
 
     double dist = varMax - varMin;
@@ -362,10 +366,10 @@ float* KameleonWrapper::getUniformSampledValues(
 
         data[i] = static_cast<float>(glm::clamp(normalizedVal, 0.0, 1.0));
         if(data[i] < 0.0) {
-            LERROR("Datapoint " << i << " less than 0");
+            LERROR(fmt::format("Datapoint {} less than 0", i));
         }
         if(data[i] > 1.0) {
-            LERROR("Datapoint " << i << " more than 1");
+            LERROR(fmt::format("Datapoint {} more than 1", i));
         }
     }
 
@@ -384,7 +388,10 @@ float* KameleonWrapper::getUniformSliceValues(const std::string& var,
                                               const float& slice)
 {
     ghoul_assert(_model && _interpolator, "Model and interpolator must exist");
-    LINFO("Loading variable " << var << " from CDF data with a uniform sampling");
+    LINFO(fmt::format(
+        "Loading variable {} from CDF data with a uniform sampling",
+        var
+    ));
 
     unsigned int size = static_cast<unsigned int>(
         outDimensions.x * outDimensions.y * outDimensions.z
@@ -409,8 +416,8 @@ float* KameleonWrapper::getUniformSliceValues(const std::string& var,
     double yDim = (!ySlice)? outDimensions.y-1 : 1.0;
     double zDim = (!zSlice)? outDimensions.z-1 : 1.0;
 
-    LDEBUG(var << "Min: " << varMin);
-    LDEBUG(var << "Max: " << varMax);
+    LDEBUG(fmt::format("{} min: {}", var, varMin));
+    LDEBUG(fmt::format("{} max: {}", var, varMax));
 
     //double maxValue = 0.0;
     //double minValue = std::numeric_limits<double>::max();
@@ -513,10 +520,13 @@ float* KameleonWrapper::getUniformSampledVectorValues(const std::string& xVar,
                                                       const glm::size3_t& outDimensions)
 {
     ghoul_assert(_model && _interpolator, "Model and interpolator must exist");
-    LINFO(
-        "Loading variables " << xVar << " " << yVar << " " << zVar <<
-        " from CDF data with a uniform sampling"
-    );
+
+    LINFO(fmt::format(
+        "loading variables {} {} {} from CDF data with a uniform sampling",
+        xVar,
+        yVar,
+        zVar
+    ));
 
     int channels = 4;
     unsigned int size = static_cast<unsigned int>(
@@ -590,10 +600,13 @@ KameleonWrapper::Fieldlines KameleonWrapper::getClassifiedFieldLines(
     float stepSize )
 {
     ghoul_assert(_model && _interpolator, "Model and interpolator must exist");
-    LINFO(
-        "Creating " << seedPoints.size() << " fieldlines from variables " <<
-        xVar << " " << yVar << " " << zVar
-    );
+    LINFO(fmt::format(
+        "Creating {} fieldlines from variables {} {} {}",
+        seedPoints.size(),
+        xVar,
+        yVar,
+        zVar
+    ));
 
     std::vector<glm::vec3> fLine, bLine;
     std::vector<std::vector<LinePoint> > fieldLines;
@@ -647,10 +660,13 @@ KameleonWrapper::Fieldlines KameleonWrapper::getFieldLines(const std::string& xV
     const std::vector<glm::vec3>& seedPoints, float stepSize, const glm::vec4& color)
 {
     ghoul_assert(_model && _interpolator, "Model and interpolator must exist");
-    LINFO(
-        "Creating " << seedPoints.size() << " fieldlines from variables " <<
-        xVar << " " << yVar << " " << zVar
-    );
+    LINFO(fmt::format(
+        "Creating {} fieldlines from variables {} {} {}",
+        seedPoints.size(),
+        xVar,
+        yVar,
+        zVar
+    ));
 
     std::vector<glm::vec3> fLine, bLine;
     Fieldlines fieldLines;
@@ -698,7 +714,7 @@ KameleonWrapper::Fieldlines KameleonWrapper::getFieldLines(const std::string& xV
 KameleonWrapper::Fieldlines KameleonWrapper::getLorentzTrajectories(
     const std::vector<glm::vec3>& seedPoints,const glm::vec4& /*color*/, float stepsize)
 {
-    LINFO("Creating " << seedPoints.size() << " Lorentz force trajectories");
+    LINFO(fmt::format("Creating {} Lorentz force trajectories", seedPoints.size()));
 
     Fieldlines trajectories;
     std::vector<glm::vec3> plusTraj, minusTraj;
@@ -926,7 +942,7 @@ KameleonWrapper::TraceLine KameleonWrapper::traceCartesianFieldline(
 
         ++numSteps;
         if (numSteps > maxSteps) {
-            LDEBUG("Max number of steps taken (" << maxSteps <<")");
+            LDEBUG(fmt::format("Max number of steps taken ({})", maxSteps));
             break;
         }
     }
@@ -1031,7 +1047,7 @@ KameleonWrapper::TraceLine KameleonWrapper::traceLorentzTrajectory(
 
         ++numSteps;
         if (numSteps > maxSteps) {
-            LDEBUG("Max number of steps taken (" << maxSteps <<")");
+            LDEBUG(fmt::format("Max number of steps taken ({})", maxSteps));
             break;
         }
     }
diff --git a/modules/kameleonvolume/kameleonvolumereader.cpp b/modules/kameleonvolume/kameleonvolumereader.cpp
index 467823911c..016d72cd53 100644
--- a/modules/kameleonvolume/kameleonvolumereader.cpp
+++ b/modules/kameleonvolume/kameleonvolumereader.cpp
@@ -24,6 +24,7 @@
 
 #include <modules/kameleonvolume/kameleonvolumereader.h>
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 
 #ifdef WIN32
@@ -43,6 +44,8 @@
 #pragma warning (pop)
 #endif // WIN32
 
+#include <ghoul/fmt.h>
+
 namespace {
     constexpr const char* _loggerCat = "KameleonVolumeReader";
 } // namespace
@@ -54,15 +57,14 @@ KameleonVolumeReader::KameleonVolumeReader(const std::string& path)
     : _path(path)
 {
     if (!FileSys.fileExists(path)) {
-        LERROR(_path << " does not exist");
+        LERROR(fmt::format("'{}' does not exist", _path));
         throw ghoul::FileNotFoundError(_path);
     }
 
     long status = _kameleon.open(_path);
     if (status != ccmc::FileReader::OK) {
-        LERROR("Failed to open file " << _path << " with Kameleon");
+        LERROR(fmt::format("Failed to open file '{}' with Kameleon", _path));
         throw ghoul::RuntimeError("Failed to open file: " + _path + " with Kameleon");
-        return;
     }
 
     _model = _kameleon.model;
diff --git a/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp b/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
index a633d27241..91ee83a814 100644
--- a/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
+++ b/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
@@ -132,8 +132,7 @@ namespace {
     };
 } // namespace
 
-namespace openspace {
-namespace kameleonvolume {
+namespace openspace::kameleonvolume {
 
 RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dictionary)
     : Renderable(dictionary)
@@ -182,7 +181,7 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
     if (dictionary.getValue(KeySource, sourcePath)) {
         _sourcePath = absPath(sourcePath);
     }
-    
+
     std::string variable;
     if (dictionary.getValue(KeyVariable, variable)) {
         _variable = variable;
@@ -256,12 +255,12 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
         }
     }
 }
-    
+
 RenderableKameleonVolume::~RenderableKameleonVolume() {}
 
 void RenderableKameleonVolume::initializeGL() {
     load();
-    
+
     _volumeTexture->uploadTexture();
     _transferFunction->update();
 
@@ -323,7 +322,7 @@ void RenderableKameleonVolume::initializeGL() {
 void RenderableKameleonVolume::updateRaycasterModelTransform() {
     glm::vec3 lowerBoundingBoxBound = _domainScale.value() * _lowerDomainBound.value();
     glm::vec3 upperBoundingBoxBound = _domainScale.value() * _upperDomainBound.value();
-    
+
     glm::vec3 scale = upperBoundingBoxBound - lowerBoundingBoxBound;
     glm::vec3 translation = (lowerBoundingBoxBound + upperBoundingBoxBound) * 0.5f;
 
@@ -332,14 +331,13 @@ void RenderableKameleonVolume::updateRaycasterModelTransform() {
     _raycaster->setModelTransform(modelTransform);
 }
 
-
 bool RenderableKameleonVolume::cachingEnabled() {
     return _cache;
 }
 
 void RenderableKameleonVolume::load() {
     if (!FileSys.fileExists(ghoul::filesystem::File(_sourcePath))) {
-        LERROR("File " << _sourcePath << " does not exist.");
+        LERROR(fmt::format("File '{}' does not exist.", _sourcePath.value()));
         return;
     }
     if (!cachingEnabled()) {
@@ -399,7 +397,7 @@ void RenderableKameleonVolume::loadCdf(const std::string& path) {
     }
 
     std::vector<std::string> variables = reader.gridVariableNames();
-   
+
     if (variables.size() == 3 && _autoDomainBounds) {
         _lowerDomainBound = glm::vec3(
             reader.minValue(variables[0]),
@@ -459,18 +457,18 @@ void RenderableKameleonVolume::storeRaw(const std::string& path) {
     volume::RawVolumeWriter<float> writer(path);
     writer.write(*_rawVolume);
 }
-    
+
 void RenderableKameleonVolume::deinitializeGL() {
     if (_raycaster) {
         OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
         _raycaster = nullptr;
     }
 }
-    
+
 bool RenderableKameleonVolume::isReady() const {
     return true;
 }
-    
+
 void RenderableKameleonVolume::update(const UpdateData&) {
     if (_raycaster) {
         _raycaster->setStepSize(_stepSize);
@@ -480,6 +478,5 @@ void RenderableKameleonVolume::update(const UpdateData&) {
 void RenderableKameleonVolume::render(const RenderData& data, RendererTasks& tasks) {
     tasks.raycasterTasks.push_back({ _raycaster.get(), data });
 }
-       
-}
-}
+
+}  // openspace::kameleonvolume
diff --git a/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp
index a545b9ef4b..e8784bc31e 100644
--- a/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp
+++ b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp
@@ -49,8 +49,6 @@ namespace {
 
     constexpr const char* KeyMinValue = "MinValue";
     constexpr const char* KeyMaxValue = "MaxValue";
-
-    constexpr const char* _loggerCat = "KameleonVolumeToRawTask";
 } // namespace
 
 namespace openspace {
diff --git a/modules/multiresvolume/rendering/atlasmanager.cpp b/modules/multiresvolume/rendering/atlasmanager.cpp
index a2675df9cb..945d638acd 100644
--- a/modules/multiresvolume/rendering/atlasmanager.cpp
+++ b/modules/multiresvolume/rendering/atlasmanager.cpp
@@ -140,7 +140,7 @@ void AtlasManager::updateAtlas(BUFFER_INDEX bufferIndex, std::vector<int>& brick
     glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-    for (int i = 0; i < nBrickIndices; i++) {
+    for (size_t i = 0; i < nBrickIndices; i++) {
         _atlasMap[i] = _brickMap[brickIndices[i]];
     }
 
diff --git a/modules/multiresvolume/rendering/brickmanager.cpp b/modules/multiresvolume/rendering/brickmanager.cpp
index 4c064aa807..9eda8ba072 100644
--- a/modules/multiresvolume/rendering/brickmanager.cpp
+++ b/modules/multiresvolume/rendering/brickmanager.cpp
@@ -30,6 +30,7 @@
 
 #include <iostream>
 #include <fstream>
+#include <ghoul/fmt.h>
 
 namespace {
     constexpr const char* _loggerCat = "BrickManager";
@@ -68,20 +69,29 @@ bool BrickManager::readHeader() {
 
     _header = _tsp->header();
 
-    LDEBUG("Grid type: " << _header.gridType_);
-    LDEBUG("Original num timesteps: " << _header.numOrigTimesteps_);
-    LDEBUG("Num timesteps: " << _header.numTimesteps_);
-    LDEBUG("Brick dims: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
-    LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
-    LDEBUG("");
+    LDEBUG(fmt::format("Grid type: {}", _header.gridType_));
+    LDEBUG(fmt::format("Original num timesteps: {}", _header.numOrigTimesteps_));
+    LDEBUG(fmt::format("Num timesteps: {}", _header.numTimesteps_));
+    LDEBUG(fmt::format(
+        "Brick dims: {} {} {}",
+        _header.xBrickDim_,
+        _header.yBrickDim_,
+        _header.zBrickDim_
+    ));
+    LDEBUG(fmt::format(
+        "Num bricks: {} {} {}",
+        _header.xNumBricks_,
+        _header.yNumBricks_,
+        _header.zNumBricks_
+    ));
 
     brickDim_ = _header.xBrickDim_;
     numBricks_ = _header.xNumBricks_;
     paddedBrickDim_ = brickDim_ + paddingWidth_ * 2;
     atlasDim_ = paddedBrickDim_*numBricks_;
 
-    LDEBUG("Padded brick dim: " << paddedBrickDim_);
-    LDEBUG("Atlas dim: " << atlasDim_);
+    LDEBUG(fmt::format("Padded brick dim: {}", paddedBrickDim_));
+    LDEBUG(fmt::format("Atlas dim: {}", atlasDim_));
 
     numBrickVals_ = paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
     // Number of bricks per frame
@@ -92,11 +102,11 @@ bool BrickManager::readHeader() {
     unsigned int numOTNodes = static_cast<unsigned int>((pow(8, numOTLevels) - 1) / 7);
     unsigned int numBSTNodes = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
     numBricksTree_ = numOTNodes * numBSTNodes;
-    LDEBUG("Num OT levels: " << numOTLevels);
-    LDEBUG("Num OT nodes: " << numOTNodes);
-    LDEBUG("Num BST nodes: " << numBSTNodes);
-    LDEBUG("Num bricks in tree: " << numBricksTree_);
-    LDEBUG("Num values per brick: " << numBrickVals_);
+    LDEBUG(fmt::format("Num OT levels: {}", numOTLevels));
+    LDEBUG(fmt::format("Num OT nodes: {}", numOTNodes));
+    LDEBUG(fmt::format("Num BST nodes: {}", numBSTNodes));
+    LDEBUG(fmt::format("Num bricks in tree: {}", numBricksTree_));
+    LDEBUG(fmt::format("Num values per brick: {}", numBrickVals_));
 
     brickSize_ = sizeof(float)*numBrickVals_;
     volumeSize_ = brickSize_*numBricksFrame_;
@@ -110,8 +120,8 @@ bool BrickManager::readHeader() {
 
     if (fileSize != calcFileSize) {
         LERROR("Sizes don't match");
-        LERROR("calculated file size: " << calcFileSize);
-        LERROR("file size: " << fileSize);
+        LERROR(fmt::format("Calculated file size: {}", calcFileSize));
+        LERROR(fmt::format("File size: {}", fileSize));
         return false;
     }
 
diff --git a/modules/multiresvolume/rendering/errorhistogrammanager.cpp b/modules/multiresvolume/rendering/errorhistogrammanager.cpp
index c44fbd8380..6e2c8384d5 100644
--- a/modules/multiresvolume/rendering/errorhistogrammanager.cpp
+++ b/modules/multiresvolume/rendering/errorhistogrammanager.cpp
@@ -33,6 +33,7 @@
 #include <openspace/util/progressbar.h>
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/fmt.h>
 
 namespace {
     constexpr const char* _loggerCat = "ErrorHistogramManager";
@@ -62,7 +63,7 @@ bool ErrorHistogramManager::buildHistograms(int numBins) {
 
     _numInnerNodes = _tsp->numTotalNodes() - numOtLeaves * numBstLeaves;
     _histograms = std::vector<Histogram>(_numInnerNodes);
-    LINFO("Build " << _numInnerNodes << " histograms with " << numBins << " bins each");
+    LINFO(fmt::format("Build {} histograms with {} bins each", _numInnerNodes, numBins));
 
     // All TSP Leaves
     int numOtNodes = _tsp->numOTNodes();
diff --git a/modules/multiresvolume/rendering/histogrammanager.cpp b/modules/multiresvolume/rendering/histogrammanager.cpp
index 40a75fc836..14512c7ec4 100644
--- a/modules/multiresvolume/rendering/histogrammanager.cpp
+++ b/modules/multiresvolume/rendering/histogrammanager.cpp
@@ -22,17 +22,13 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
+#include <modules/multiresvolume/rendering/histogrammanager.h>
+
+#include <openspace/util/histogram.h>
+#include <cassert>
 #include <float.h>
 #include <math.h>
 #include <string.h>
-#include <cassert>
-
-#include <modules/multiresvolume/rendering/histogrammanager.h>
-#include <openspace/util/histogram.h>
-
-namespace {
-    constexpr const char* _loggerCat = "HistogramManager";
-} // namespace
 
 namespace openspace {
 
@@ -173,11 +169,11 @@ bool HistogramManager::saveToFile(const std::string& filename) {
     file.write(reinterpret_cast<char*>(&_minBin), sizeof(float));
     file.write(reinterpret_cast<char*>(&_maxBin), sizeof(float));
 
-    int nFloats = numHistograms * _numBins;
+    size_t nFloats = numHistograms * _numBins;
     float* histogramData = new float[nFloats];
 
     for (size_t i = 0; i < numHistograms; ++i) {
-        int offset = i*_numBins;
+        size_t offset = i*_numBins;
         memcpy(&histogramData[offset], _histograms[i].data(), sizeof(float) * _numBins);
     }
 
diff --git a/modules/multiresvolume/rendering/localerrorhistogrammanager.cpp b/modules/multiresvolume/rendering/localerrorhistogrammanager.cpp
index 273ad34532..a00ee06670 100644
--- a/modules/multiresvolume/rendering/localerrorhistogrammanager.cpp
+++ b/modules/multiresvolume/rendering/localerrorhistogrammanager.cpp
@@ -33,6 +33,7 @@
 #include <openspace/util/progressbar.h>
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/fmt.h>
 
 namespace {
     constexpr const char* _loggerCat = "LocalErrorHistogramManager";
@@ -45,7 +46,7 @@ LocalErrorHistogramManager::LocalErrorHistogramManager(TSP* tsp) : _tsp(tsp) {}
 LocalErrorHistogramManager::~LocalErrorHistogramManager() {}
 
 bool LocalErrorHistogramManager::buildHistograms(int numBins) {
-    LINFO("Build histograms with " << numBins << " bins each");
+    LINFO(fmt::format("Build histograms with {} bins each", numBins));
     _numBins = numBins;
 
     _file = &(_tsp->file());
@@ -133,7 +134,12 @@ bool LocalErrorHistogramManager::buildFromOctreeChild(unsigned int bstOffset, un
             if (it != _voxelCache.end()) {
                 childValues = it->second;
             } else {
-                LERROR("Child " << childIndex << " visited without cache, " << bstOffset << ", " << octreeOffset);
+                LERROR(fmt::format(
+                    "Child {} visited without cache, {}, {}",
+                    childIndex,
+                    bstOffset,
+                    octreeOffset
+                ));
                 return false;
             }
         }
@@ -147,7 +153,7 @@ bool LocalErrorHistogramManager::buildFromOctreeChild(unsigned int bstOffset, un
             if (it != _voxelCache.end()) {
                 parentValues = it->second;
             } else {
-                LERROR("Parent " << parentIndex << " visited without cache");
+                LERROR(fmt::format("Parent {} visited without cache", parentIndex));
                 return false;
             }
         }
@@ -218,7 +224,7 @@ bool LocalErrorHistogramManager::buildFromBstChild(unsigned int bstOffset, unsig
             if (it != _voxelCache.end()) {
                 childValues = it->second;
             } else {
-                LERROR("Child " << childIndex << " visited without cache");
+                LERROR(fmt::format("Child {} visited without cache", childIndex));
                 return false;
             }
         }
@@ -232,7 +238,7 @@ bool LocalErrorHistogramManager::buildFromBstChild(unsigned int bstOffset, unsig
             if (it != _voxelCache.end()) {
                 parentValues = it->second;
             } else {
-                LERROR("Parent " << parentIndex << " visited without cache");
+                LERROR(fmt::format("Parent {} visited without cache", parentIndex));
                 return false;
             }
         }
diff --git a/modules/multiresvolume/rendering/localtfbrickselector.cpp b/modules/multiresvolume/rendering/localtfbrickselector.cpp
index 11b458abe1..3f3ff53d10 100644
--- a/modules/multiresvolume/rendering/localtfbrickselector.cpp
+++ b/modules/multiresvolume/rendering/localtfbrickselector.cpp
@@ -30,10 +30,6 @@
 #include <algorithm>
 #include <cassert>
 
-namespace {
-    constexpr const char* _loggerCat = "LocalTfBrickSelector";
-} // namespace
-
 namespace openspace {
 
 LocalTfBrickSelector::LocalTfBrickSelector(TSP* tsp, LocalErrorHistogramManager* hm,
@@ -355,7 +351,7 @@ bool LocalTfBrickSelector::calculateBrickErrors() {
                 brickIndex
             );
             float error = 0;
-            for (int i = 0; i < gradients.size(); i++) {
+            for (size_t i = 0; i < gradients.size(); i++) {
                 float x = (i + 0.5f) / tfWidth;
                 float sample = histogram->interpolate(x);
                 ghoul_assert(sample >= 0, "@MISSING");
@@ -372,7 +368,7 @@ bool LocalTfBrickSelector::calculateBrickErrors() {
                 brickIndex
             );
             float error = 0;
-            for (int i = 0; i < gradients.size(); i++) {
+            for (size_t i = 0; i < gradients.size(); i++) {
                 float x = (i + 0.5f) / tfWidth;
                 float sample = histogram->interpolate(x);
                 ghoul_assert(sample >= 0, "@MISSING");
diff --git a/modules/multiresvolume/rendering/multiresvolumeraycaster.cpp b/modules/multiresvolume/rendering/multiresvolumeraycaster.cpp
index fd45e52ecd..e409f25451 100644
--- a/modules/multiresvolume/rendering/multiresvolumeraycaster.cpp
+++ b/modules/multiresvolume/rendering/multiresvolumeraycaster.cpp
@@ -48,10 +48,10 @@ namespace openspace {
 MultiresVolumeRaycaster::MultiresVolumeRaycaster(std::shared_ptr<TSP> tsp,
                                                std::shared_ptr<AtlasManager> atlasManager,
                                        std::shared_ptr<TransferFunction> transferFunction)
-    : _tsp(tsp)
+    : _boundingBox(glm::vec3(1.0))
+    , _tsp(tsp)
     , _atlasManager(atlasManager)
     , _transferFunction(transferFunction)
-    , _boundingBox(glm::vec3(1.0))
 {}
 
 MultiresVolumeRaycaster::~MultiresVolumeRaycaster() {}
diff --git a/modules/multiresvolume/rendering/multiresvolumeraycaster.h b/modules/multiresvolume/rendering/multiresvolumeraycaster.h
index 0df134ae2f..27b0263aef 100644
--- a/modules/multiresvolume/rendering/multiresvolumeraycaster.h
+++ b/modules/multiresvolume/rendering/multiresvolumeraycaster.h
@@ -77,11 +77,11 @@ public:
     void setModelTransform(glm::mat4 transform);
     //void setTime(double time);
     void setStepSizeCoefficient(float coefficient);
+
 private:
     BoxGeometry _boundingBox;
     glm::mat4 _modelTransform;
     float _stepSizeCoefficient;
-    double _time;
 
     std::shared_ptr<TSP> _tsp;
     std::shared_ptr<AtlasManager> _atlasManager;
diff --git a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
index 0582898d23..2c4defa9fe 100644
--- a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
+++ b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
@@ -194,7 +194,11 @@ RenderableMultiresVolume::RenderableMultiresVolume (const ghoul::Dictionary& dic
     _filename = "";
     bool success = dictionary.getValue(KeyDataSource, _filename);
     if (!success) {
-        LERROR("Node '" << name << "' did not contain a valid '" <<  KeyDataSource << "'");
+        LERROR(fmt::format(
+            "Node '{}' did not contain a valid '{}'",
+            name,
+            KeyDataSource
+        ));
         return;
     }
     _filename = absPath(_filename);
@@ -241,7 +245,11 @@ RenderableMultiresVolume::RenderableMultiresVolume (const ghoul::Dictionary& dic
         _loop = false;
     } else {
     _loop = true;
-        LWARNING("Node " << name << " does not provide valid time information. Viewing one image per frame.");
+        LWARNING(fmt::format(
+            "Node '{}' does not provide valid time information. Viewing one image per "
+            "frame.",
+            name
+        ));
     }
 
 
@@ -249,8 +257,11 @@ RenderableMultiresVolume::RenderableMultiresVolume (const ghoul::Dictionary& dic
     _transferFunctionPath = "";
     success = dictionary.getValue(KeyTransferFunction, _transferFunctionPath);
     if (!success) {
-        LERROR("Node '" << name << "' did not contain a valid '" <<
-            KeyTransferFunction << "'");
+        LERROR(fmt::format(
+            "Node '{}' did not contain a valid '{}'",
+            name,
+            KeyTransferFunction
+        ));
         return;
     }
     _transferFunctionPath = absPath(_transferFunctionPath);
@@ -505,18 +516,24 @@ bool RenderableMultiresVolume::initializeSelector() {
                 if (cacheFile.is_open()) {
                     // Read histograms from cache.
                     cacheFile.close();
-                    LINFO("Loading histograms from cache: " << cacheFilename);
+                    LINFO(fmt::format(
+                        "Loading histograms from cache: {}",
+                        cacheFilename
+                    ));
                     success &= _errorHistogramManager->loadFromFile(cacheFilename);
                 } else if (_errorHistogramsPath != "") {
                     // Read histograms from scene data.
-                    LINFO("Loading histograms from scene data: " << _errorHistogramsPath);
+                    LINFO(fmt::format(
+                        "Loading histograms from scene data: {}",
+                        _errorHistogramsPath
+                    ));
                     success &= _errorHistogramManager->loadFromFile(_errorHistogramsPath);
                 } else {
                     // Build histograms from tsp file.
-                    LWARNING("Failed to open " << cacheFilename);
+                    LWARNING(fmt::format("Failed to open {}", cacheFilename));
                     success &= _errorHistogramManager->buildHistograms(nHistograms);
                     if (success) {
-                        LINFO("Writing cache to " << cacheFilename);
+                        LINFO(fmt::format("Writing cache to {}", cacheFilename));
                         _errorHistogramManager->saveToFile(cacheFilename);
                     }
                 }
@@ -536,17 +553,17 @@ bool RenderableMultiresVolume::initializeSelector() {
                 if (cacheFile.is_open()) {
                     // Read histograms from cache.
                     cacheFile.close();
-                    LINFO("Loading histograms from " << cacheFilename);
+                    LINFO(fmt::format("Loading histograms from {}", cacheFilename));
                     success &= _histogramManager->loadFromFile(cacheFilename);
                 } else {
                     // Build histograms from tsp file.
-                    LWARNING("Failed to open " << cacheFilename);
+                    LWARNING(fmt::format("Failed to open '{}'", cacheFilename));
                     success &= _histogramManager->buildHistograms(
                         _tsp.get(),
                         nHistograms
                     );
                     if (success) {
-                        LINFO("Writing cache to " << cacheFilename);
+                        LINFO(fmt::format("Writing cache to {}", cacheFilename));
                         _histogramManager->saveToFile(cacheFilename);
                     }
                 }
@@ -566,14 +583,14 @@ bool RenderableMultiresVolume::initializeSelector() {
                 if (cacheFile.is_open()) {
                     // Read histograms from cache.
                     cacheFile.close();
-                    LINFO("Loading histograms from " << cacheFilename);
+                    LINFO(fmt::format("Loading histograms from {}", cacheFilename));
                     success &= _localErrorHistogramManager->loadFromFile(cacheFilename);
                 } else {
                     // Build histograms from tsp file.
-                    LWARNING("Failed to open " << cacheFilename);
+                    LWARNING(fmt::format("Failed to open {}", cacheFilename));
                     success &= _localErrorHistogramManager->buildHistograms(nHistograms);
                     if (success) {
-                        LINFO("Writing cache to " << cacheFilename);
+                        LINFO(fmt::format("Writing cache to {}", cacheFilename));
                         _localErrorHistogramManager->saveToFile(cacheFilename);
                     }
                 }
diff --git a/modules/multiresvolume/rendering/shenbrickselector.cpp b/modules/multiresvolume/rendering/shenbrickselector.cpp
index 5dfabb71b8..366409b9e2 100644
--- a/modules/multiresvolume/rendering/shenbrickselector.cpp
+++ b/modules/multiresvolume/rendering/shenbrickselector.cpp
@@ -24,10 +24,6 @@
 
 #include <modules/multiresvolume/rendering/shenbrickselector.h>
 
-namespace {
-    constexpr const char* _loggerCat = "ShenBrickSelector";
-} // namespace
-
 namespace openspace {
 
 ShenBrickSelector::ShenBrickSelector(TSP* tsp, float spatialTolerance, float temporalTolerance)
diff --git a/modules/multiresvolume/rendering/simpletfbrickselector.cpp b/modules/multiresvolume/rendering/simpletfbrickselector.cpp
index faf1e4ad46..e1a64d0810 100644
--- a/modules/multiresvolume/rendering/simpletfbrickselector.cpp
+++ b/modules/multiresvolume/rendering/simpletfbrickselector.cpp
@@ -307,7 +307,7 @@ bool SimpleTfBrickSelector::calculateBrickImportances() {
         }
 
         float dotProduct = 0;
-        for (int i = 0; i < tf->width(); i++) {
+        for (size_t i = 0; i < tf->width(); i++) {
             float x = static_cast<float>(i) / static_cast<float>(tfWidth);
             float sample = histogram->interpolate(x);
 
diff --git a/modules/multiresvolume/rendering/tfbrickselector.cpp b/modules/multiresvolume/rendering/tfbrickselector.cpp
index 34b691ba23..e4daac6e62 100644
--- a/modules/multiresvolume/rendering/tfbrickselector.cpp
+++ b/modules/multiresvolume/rendering/tfbrickselector.cpp
@@ -30,10 +30,6 @@
 #include <algorithm>
 #include <cassert>
 
-namespace {
-    constexpr const char* _loggerCat = "TfBrickSelector";
-} // namespace
-
 namespace openspace {
 
 TfBrickSelector::TfBrickSelector(TSP* tsp, ErrorHistogramManager* hm,
@@ -364,7 +360,7 @@ bool TfBrickSelector::calculateBrickErrors() {
         } else {
             const Histogram* histogram = _histogramManager->getHistogram(brickIndex);
             float error = 0;
-            for (int i = 0; i < gradients.size(); i++) {
+            for (size_t i = 0; i < gradients.size(); i++) {
                 float x = (i + 0.5f) / tfWidth;
                 float sample = histogram->interpolate(x);
                 ghoul_assert(sample >= 0, "@MISSING");
diff --git a/modules/multiresvolume/rendering/tsp.cpp b/modules/multiresvolume/rendering/tsp.cpp
index f1ef5c2a53..76e1e9402f 100644
--- a/modules/multiresvolume/rendering/tsp.cpp
+++ b/modules/multiresvolume/rendering/tsp.cpp
@@ -24,12 +24,14 @@
 
 #include <modules/multiresvolume/rendering/tsp.h>
 
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/cachemanager.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/glm.h>
 
 #include <algorithm>
+#include <ghoul/fmt.h>
 #include <math.h>
 #include <queue>
 
@@ -119,9 +121,19 @@ bool TSP::readHeader() {
     file.read(reinterpret_cast<char*>(&zNumBricks_),        sizeof(unsigned int));
     */
 
-    LDEBUG("Grid type: " << _header.gridType_);
-    LDEBUG("Brick dimensions: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
-    LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
+    LDEBUG(fmt::format("Grid type: {}", _header.gridType_));
+    LDEBUG(fmt::format(
+        "Brick dimensions: {} {} {}",
+        _header.xBrickDim_,
+        _header.yBrickDim_,
+        _header.zBrickDim_
+    ));
+    LDEBUG(fmt::format(
+        "Num bricks: {} {} {}",
+        _header.xNumBricks_,
+        _header.yNumBricks_,
+        _header.zNumBricks_
+    ));
 
     paddedBrickDim_ = _header.xBrickDim_ + 2 * paddingWidth_;
     // TODO support dimensions of different size
@@ -131,21 +143,20 @@ bool TSP::readHeader() {
     numBSTNodes_ = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
     numTotalNodes_ = numOTNodes_ * numBSTNodes_;
 
-    LDEBUG("Num OT levels: " << numOTLevels_);
-    LDEBUG("Num OT nodes: " << numOTNodes_);
-    LDEBUG("Num BST levels: " << numBSTLevels_);
-    LDEBUG("Num BST nodes: " << numBSTNodes_);
-    LDEBUG("NUm total nodes: " << numTotalNodes_);
+    LDEBUG(fmt::format("Num OT levels: {}", numOTLevels_));
+    LDEBUG(fmt::format("Num OT nodes: {}", numOTNodes_));
+    LDEBUG(fmt::format("Num BST levels: {}", numBSTLevels_));
+    LDEBUG(fmt::format("Num BST nodes: {}", numBSTNodes_));
+    LDEBUG(fmt::format("Num total nodes: {}", numTotalNodes_));
 
     // Allocate space for TSP structure
     data_.resize(numTotalNodes_*NUM_DATA);
-    LDEBUG("data size: " << data_.size());
+    LDEBUG(fmt::format("Data size: {}",  data_.size()));
 
     return true;
 }
 
 bool TSP::construct() {
-
     LDEBUG("Constructing TSP tree");
 
     // Loop over the OTs (one per BST node)
@@ -412,9 +423,9 @@ bool TSP::calculateSpatialError() {
     maxSpatialError_ = maxNorm;
     medianSpatialError_ = medNorm;
 
-    LDEBUG("Min normalized spatial std dev: " << minNorm);
-    LDEBUG("Max normalized spatial std dev: " << maxNorm);
-    LDEBUG("Median normalized spatial std dev: " << medNorm);
+    LDEBUG(fmt::format("Min normalized spatial std dev: {}", minNorm));
+    LDEBUG(fmt::format("Max normalized spatial std dev: {}", maxNorm));
+    LDEBUG(fmt::format("Median normalized spatial std dev: {}", medNorm));
 
     return true;
 }
@@ -537,16 +548,14 @@ bool TSP::calculateTemporalError() {
     maxTemporalError_ = maxNorm;
     medianTemporalError_ = medNorm;
 
-    LDEBUG("Min normalized temporal std dev: " << minNorm);
-    LDEBUG("Max normalized temporal std dev: " << maxNorm);
-    LDEBUG("Median normalized temporal std dev: " << medNorm);
+    LDEBUG(fmt::format("Min normalized temporal std dev: {}", minNorm));
+    LDEBUG(fmt::format("Max normalized temporal std dev: {}", maxNorm));
+    LDEBUG(fmt::format("Median normalized temporal std dev: {}", medNorm));
 
     return true;
 }
 
-
 bool TSP::readCache() {
-
     if (!FileSys.cacheManager())
         return false;
 
@@ -556,7 +565,7 @@ bool TSP::readCache() {
 
     std::ifstream file(cacheFilename, std::ios::in | std::ios::binary);
     if (!file.is_open()) {
-        LWARNING("Failed to open " << cacheFilename);
+        LWARNING(fmt::format("Failed to open {}", cacheFilename));
         return false;
     }
 
@@ -572,18 +581,17 @@ bool TSP::readCache() {
     file.close();
 
     LDEBUG("Cached errors:");
-    LDEBUG("Min spatial error: " << minSpatialError_);
-    LDEBUG("Max spatial error: " << maxSpatialError_);
-    LDEBUG("Median spatial error: " << medianSpatialError_);
-    LDEBUG("Min temporal error: " << minTemporalError_);
-    LDEBUG("Max temporal error: " << maxTemporalError_);
-    LDEBUG("Median temporal error: " << medianTemporalError_);
+    LDEBUG(fmt::format("Min spatial error: {}", minSpatialError_));
+    LDEBUG(fmt::format("Max spatial error: {}", maxSpatialError_));
+    LDEBUG(fmt::format("Median spatial error: {}", medianSpatialError_));
+    LDEBUG(fmt::format("Min temporal error: {}", minTemporalError_));
+    LDEBUG(fmt::format("Max temporal error: {}", maxTemporalError_));
+    LDEBUG(fmt::format("Median temporal error: {}", medianTemporalError_));
 
     return true;
 }
 
 bool TSP::writeCache() {
-
     if (!FileSys.cacheManager())
         return false;
 
@@ -593,10 +601,10 @@ bool TSP::writeCache() {
 
     std::ofstream file(cacheFilename, std::ios::out | std::ios::binary);
     if (!file.is_open()) {
-        LWARNING("Failed to open " << cacheFilename);
+        LWARNING(fmt::format("Failed to open {}", cacheFilename));
         return false;
     }
-    LINFO("Writing cache to " << cacheFilename);
+    LINFO(fmt::format("Writing cache to {}", cacheFilename));
 
 
     file.write(reinterpret_cast<char*>(&minSpatialError_), sizeof(float));
diff --git a/modules/space/rendering/renderableconstellationbounds.cpp b/modules/space/rendering/renderableconstellationbounds.cpp
index 6807553a27..1c8898d62a 100644
--- a/modules/space/rendering/renderableconstellationbounds.cpp
+++ b/modules/space/rendering/renderableconstellationbounds.cpp
@@ -179,7 +179,7 @@ RenderableConstellationBounds::RenderableConstellationBounds(
                 // The user has specified a constellation name that doesn't exist
                 LWARNINGC(
                     "RenderableConstellationBounds",
-                    "Option '" << s << "' not found in list of constellations"
+                    fmt::format("Option '{}' not found in list of constellations", s)
                 );
             }
             else {
@@ -202,7 +202,6 @@ void RenderableConstellationBounds::initializeGL() {
         absPath("${MODULE_SPACE}/shaders/constellationbounds_fs.glsl")
     );
 
-
     glGenVertexArrays(1, &_vao);
     glBindVertexArray(_vao);
 
@@ -311,7 +310,11 @@ bool RenderableConstellationBounds::loadVertexFile() {
             // means that the line was incomplete, so there was an error
             LERRORC(
                 "RenderableConstellationBounds",
-                "Error reading file '" << fileName << "' at line #" << currentLineNumber
+                fmt::format(
+                    "Error reading file '{}' at line #{}",
+                    fileName,
+                    currentLineNumber
+                )
             );
             break;
         }
@@ -393,7 +396,7 @@ bool RenderableConstellationBounds::loadConstellationFile() {
         if (it == _constellationBounds.end()) {
             LERRORC(
                 "RenderableConstellationBounds",
-                "Could not find constellation '" << abbreviation << "' in list"
+                fmt::format("Could not find constellation '{}' in list", abbreviation)
             );
             return false;
         }
diff --git a/modules/space/rendering/renderableplanet.cpp b/modules/space/rendering/renderableplanet.cpp
index c1c6ddd5f6..9d78fee550 100644
--- a/modules/space/rendering/renderableplanet.cpp
+++ b/modules/space/rendering/renderableplanet.cpp
@@ -51,6 +51,7 @@
 #include <math.h>
 
 namespace {
+    constexpr const char* KeyBody         = "Body";
     constexpr const char* KeyGeometry     = "Geometry";
     constexpr const char* KeyRadius       = "Radius";
     constexpr const char* _loggerCat      = "RenderablePlanet";
@@ -118,7 +119,15 @@ documentation::Documentation RenderablePlanet::Documentation() {
                 new DoubleVerifier,
                 Optional::Yes,
                 "Specifies the radius of the planet. If this value is not specified, it "
-                "will try to query the SPICE library for radius values."
+                "will try to query the SPICE library for radius values using the body "
+                "key."
+            },
+            {
+                KeyBody,
+                new StringVerifier,
+                Optional::Yes,
+                "If that radius is not specified, this name is used to query the SPICE "
+                "library for the radius values."
             },
             {
                 ColorTextureInfo.identifier,
@@ -178,11 +187,6 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
     , _shadowEnabled(false)
     , _time(0.f)
 {
-    ghoul_precondition(
-        dictionary.hasKeyAndValue<std::string>(SceneGraphNode::KeyName),
-        "RenderablePlanet needs the name to be specified"
-    );
-
     documentation::testSpecificationAndThrow(
         Documentation(),
         dictionary,
@@ -197,19 +201,32 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
         // If the user specified a radius, we want to use this
         _planetRadius = static_cast<float>(dictionary.value<double>(KeyRadius));
     }
-    else if (SpiceManager::ref().hasValue(name, "RADII") ) {
+    else {
+        if (!dictionary.hasKey(KeyBody)) {
+            documentation::TestResult res;
+            res.success = false;
+            documentation::TestResult::Offense offense = {
+                fmt::format("{} or {}", KeyRadius, KeyBody),
+                documentation::TestResult::Offense::Reason::MissingKey
+            };
+            res.offenses.push_back(std::move(offense));
+            throw documentation::SpecificationError(
+                std::move(res),
+                std::move("RenderablePlanet")
+            );
+        }
+
+        const std::string body = dictionary.value<std::string>(KeyBody);
+
         // If the user didn't specfify a radius, but Spice has a radius, we can use this
         glm::dvec3 radius;
-        SpiceManager::ref().getValue(name, "RADII", radius);
+        SpiceManager::ref().getValue(body, "RADII", radius);
         radius *= 1000.0; // Spice gives radii in KM.
         std::swap(radius[1], radius[2]); // z is equivalent to y in our coordinate system
         geomDict.setValue(KeyRadius, radius);
 
         _planetRadius = static_cast<float>((radius.x + radius.y + radius.z) / 3.0);
     }
-    else {
-        LERRORC("RenderablePlanet", "Missing radius specification");
-    }
 
     _geometry = planetgeometry::PlanetGeometry::createFromDictionary(geomDict);
 
@@ -278,11 +295,12 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
                     sourceArray.emplace_back(sourceName, sourceRadius);
                 }
                 else {
-                    LWARNING(
-                        "No Radius value expecified for Shadow Source Name "
-                        << sourceName << " from " << name
-                        << " planet.\nDisabling shadows for this planet."
-                    );
+                    LWARNING(fmt::format(
+                        "No Radius value specified for Shadow Source Name '{}' from "
+                        "'{}' planet. Disabling shadows for this planet",
+                        sourceName,
+                        name
+                    ));
                     disableShadows = true;
                     break;
                 }
@@ -306,9 +324,12 @@ RenderablePlanet::RenderablePlanet(const ghoul::Dictionary& dictionary)
                         casterArray.emplace_back(casterName, casterRadius);
                     }
                     else {
-                        LWARNING("No Radius value expecified for Shadow Caster Name "
-                            << casterName << " from " << name
-                            << " planet.\nDisabling shadows for this planet.");
+                        LWARNING(fmt::format(
+                            "No Radius value expecified for Shadow Caster Name '{}' from "
+                            "'{}' planet. Disabling shadows for this planet.",
+                            casterName,
+                            name
+                        ));
                         disableShadows = true;
                         break;
                     }
@@ -626,7 +647,7 @@ void RenderablePlanet::loadTexture() {
                 _texture->setSwizzleMask({ GL_RED, GL_RED, GL_RED, GL_RED });
             }
 
-            LDEBUG("Loaded texture from '" << _colorTexturePath << "'");
+            LDEBUG(fmt::format("Loaded texture from '{}'", _colorTexturePath.value()));
             _texture->uploadTexture();
 
             // Textures of planets looks much smoother with AnisotropicMipMap rather than
@@ -644,9 +665,14 @@ void RenderablePlanet::loadTexture() {
                 absPath(_nightTexturePath)
             );
             if (_nightTexture) {
-                LDEBUG("Loaded texture from '" << _nightTexturePath << "'");
+                LDEBUG(fmt::format(
+                    "Loaded texture from '{}'",
+                    _nightTexturePath.value()
+                ));
                 _nightTexture->uploadTexture();
-                _nightTexture->setFilter(ghoul::opengl::Texture::FilterMode::LinearMipMap);
+                _nightTexture->setFilter(
+                    ghoul::opengl::Texture::FilterMode::LinearMipMap
+                );
                 //_nightTexture->setFilter(
                 //    ghoul::opengl::Texture::FilterMode::AnisotropicMipMap
                 //);
@@ -661,7 +687,10 @@ void RenderablePlanet::loadTexture() {
                 absPath(_heightMapTexturePath)
             );
             if (_heightMapTexture) {
-                LDEBUG("Loaded texture from '" << _heightMapTexturePath << "'");
+                LDEBUG(fmt::format(
+                    "Loaded texture from '{}'",
+                    _heightMapTexturePath.value()
+                ));
                 _heightMapTexture->uploadTexture();
                 _heightMapTexture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
                 //_nightTexture->setFilter(
diff --git a/modules/space/rendering/renderablerings.cpp b/modules/space/rendering/renderablerings.cpp
index 1c33839775..4046515226 100644
--- a/modules/space/rendering/renderablerings.cpp
+++ b/modules/space/rendering/renderablerings.cpp
@@ -31,7 +31,7 @@
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/scene/scene.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/texture.h>
@@ -295,7 +295,7 @@ void RenderableRings::loadTexture() {
         if (texture) {
             LDEBUGC(
                 "RenderableRings",
-                "Loaded texture from '" << absPath(_texturePath) << "'"
+                fmt::format("Loaded texture from '{}'", absPath(_texturePath))
             );
             _texture = std::move(texture);
 
diff --git a/modules/space/rendering/renderablestars.cpp b/modules/space/rendering/renderablestars.cpp
index 5823510146..36b25de8da 100644
--- a/modules/space/rendering/renderablestars.cpp
+++ b/modules/space/rendering/renderablestars.cpp
@@ -30,7 +30,8 @@
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/cachemanager.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/templatefactory.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
@@ -381,11 +382,9 @@ void RenderableStars::update(const UpdateData&) {
 
         if (_vao == 0) {
             glGenVertexArrays(1, &_vao);
-            LDEBUG("Generating Vertex Array id '" << _vao << "'");
         }
         if (_vbo == 0) {
             glGenBuffers(1, &_vbo);
-            LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
         }
         glBindVertexArray(_vao);
         glBindBuffer(GL_ARRAY_BUFFER, _vbo);
@@ -506,9 +505,10 @@ void RenderableStars::update(const UpdateData&) {
             );
 
             if (_pointSpreadFunctionTexture) {
-                LDEBUG("Loaded texture from '" <<
-                    absPath(_pointSpreadFunctionTexturePath) << "'"
-               );
+                LDEBUG(fmt::format(
+                    "Loaded texture from '{}'",
+                    absPath(_pointSpreadFunctionTexturePath)
+                ));
                 _pointSpreadFunctionTexture->uploadTexture();
             }
             _pointSpreadFunctionTexture->setFilter(
@@ -535,7 +535,10 @@ void RenderableStars::update(const UpdateData&) {
                 absPath(_colorTexturePath)
             );
             if (_colorTexture) {
-                LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
+                LDEBUG(fmt::format(
+                    "Loaded texture from '{}'",
+                    absPath(_colorTexturePath)
+                ));
                 _colorTexture->uploadTexture();
             }
 
@@ -574,7 +577,11 @@ bool RenderableStars::loadData() {
 
     bool hasCachedFile = FileSys.fileExists(cachedFile);
     if (hasCachedFile) {
-        LINFO("Cached file '" << cachedFile << "' used for Speck file '" << _file << "'");
+        LINFO(fmt::format(
+            "Cached file '{}' used for Speck file '{}'",
+            cachedFile,
+            _file
+        ));
 
         bool success = loadCachedFile(cachedFile);
         if (success) {
@@ -587,9 +594,9 @@ bool RenderableStars::loadData() {
         }
     }
     else {
-        LINFO("Cache for Speck file '" << _file << "' not found");
+        LINFO(fmt::format("Cache for Speck file '{}' not found", _file));
     }
-    LINFO("Loading Speck file '" << _file << "'");
+    LINFO(fmt::format("Loading Speck file '{}'", _file));
 
     bool success = readSpeckFile();
     if (!success) {
@@ -606,7 +613,7 @@ bool RenderableStars::readSpeckFile() {
     std::string _file = _speckFile;
     std::ifstream file(_file);
     if (!file.good()) {
-        LERROR("Failed to open Speck file '" << _file << "'");
+        LERROR(fmt::format("Failed to open Speck file '{}'", _file));
         return false;
     }
 
@@ -699,7 +706,7 @@ bool RenderableStars::loadCachedFile(const std::string& file) {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for loading cache file");
+        LERROR(fmt::format("Error opening file '{}' for loading cache file", file));
         return false;
     }
 }
@@ -727,7 +734,7 @@ bool RenderableStars::saveCachedFile(const std::string& file) const {
         return success;
     }
     else {
-        LERROR("Error opening file '" << file << "' for save cache file");
+        LERROR(fmt::format("Error opening file '{}' for save cache file", file));
         return false;
     }
 }
diff --git a/modules/space/translation/spicetranslation.cpp b/modules/space/translation/spicetranslation.cpp
index 43b7b87e4e..488659023e 100644
--- a/modules/space/translation/spicetranslation.cpp
+++ b/modules/space/translation/spicetranslation.cpp
@@ -29,7 +29,7 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/time.h>
 #include <openspace/util/updatestructures.h>
-
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 
 namespace {
diff --git a/modules/space/translation/tletranslation.cpp b/modules/space/translation/tletranslation.cpp
index 7399461663..19b4e1bfa8 100644
--- a/modules/space/translation/tletranslation.cpp
+++ b/modules/space/translation/tletranslation.cpp
@@ -25,6 +25,7 @@
 #include <modules/space/translation/tletranslation.h>
 
 #include <openspace/documentation/verifier.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/assert.h>
 
diff --git a/modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp b/modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp
index 69ca566143..ea96ec80f0 100644
--- a/modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp
+++ b/modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp
@@ -35,6 +35,7 @@
 #include <openspace/util/timeconversion.h>
 #include <openspace/util/timemanager.h>
 
+#include <ghoul/font/font.h>
 #include <ghoul/font/fontmanager.h>
 #include <ghoul/font/fontrenderer.h>
 
diff --git a/modules/spacecraftinstruments/rendering/renderablefov.cpp b/modules/spacecraftinstruments/rendering/renderablefov.cpp
index eff9c2f308..e519bbcad6 100644
--- a/modules/spacecraftinstruments/rendering/renderablefov.cpp
+++ b/modules/spacecraftinstruments/rendering/renderablefov.cpp
@@ -56,7 +56,7 @@ namespace {
     constexpr const char* KeyBoundsSimplification = "SimplifyBounds";
 
     const int InterpolationSteps = 5;
-    
+
     const double Epsilon = 1e-4;
 
     static const openspace::properties::Property::PropertyInfo LineWidthInfo = {
@@ -360,7 +360,7 @@ void RenderableFov::initializeGL() {
             "RenderableFov"
         );
     }
-    
+
     if (_simplifyBounds) {
         const size_t sizeBefore = res.bounds.size();
         for (size_t i = 1; i < res.bounds.size() - 1; ++i) {
@@ -384,7 +384,10 @@ void RenderableFov::initializeGL() {
         }
         const size_t sizeAfter = res.bounds.size();
 
-        LINFOC(_instrument.name, "Simplified from " << sizeBefore << " to " << sizeAfter);
+        LINFOC(
+            _instrument.name,
+            fmt::format("Simplified from {} to {}", sizeBefore, sizeAfter)
+        );
     }
 
 
diff --git a/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp b/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
index b95ffebffa..b4b584bd01 100644
--- a/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderablemodelprojection.cpp
@@ -225,7 +225,9 @@ void RenderableModelProjection::initializeGL() {
     _fboUniformCache.ProjectorMatrix = _fboProgramObject->uniformLocation(
         "ProjectorMatrix"
     );
-    _fboUniformCache.ModelTransform = _fboProgramObject->uniformLocation("ModelTransform");
+    _fboUniformCache.ModelTransform = _fboProgramObject->uniformLocation(
+        "ModelTransform"
+    );
     _fboUniformCache.boresight = _fboProgramObject->uniformLocation("boresight");
 
 
@@ -547,7 +549,7 @@ bool RenderableModelProjection::loadTextures() {
             absPath(_colorTexturePath)
         );
         if (_baseTexture) {
-            LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
+            LDEBUG(fmt::format("Loaded texture from '{}'", absPath(_colorTexturePath)));
             _baseTexture->uploadTexture();
             _baseTexture->setFilter(ghoul::opengl::Texture::FilterMode::LinearMipMap);
         }
diff --git a/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp b/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
index 2951dcd22f..d5ffe15f1f 100644
--- a/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp
@@ -34,7 +34,7 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/updatestructures.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/texture.h>
diff --git a/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp b/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
index 494491dbc3..ae5f31066c 100644
--- a/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
+++ b/modules/spacecraftinstruments/rendering/renderableplanetprojection.cpp
@@ -604,7 +604,10 @@ void RenderablePlanetProjection::render(const RenderData& data, RendererTasks&)
 
     glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
 
-    _programObject->setUniform(_mainUniformCache.modelTransform, glm::mat4(modelTransform));
+    _programObject->setUniform(
+        _mainUniformCache.modelTransform,
+        glm::mat4(modelTransform)
+    );
     _programObject->setUniform(_mainUniformCache
         .modelViewProjectionTransform,
         data.camera.projectionMatrix() * glm::mat4(modelViewTransform)
diff --git a/modules/spacecraftinstruments/util/hongkangparser.cpp b/modules/spacecraftinstruments/util/hongkangparser.cpp
index 320ce7689f..cb6dcc4e1b 100644
--- a/modules/spacecraftinstruments/util/hongkangparser.cpp
+++ b/modules/spacecraftinstruments/util/hongkangparser.cpp
@@ -31,6 +31,7 @@
 
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/dictionary.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 
 #include <fstream>
diff --git a/modules/spacecraftinstruments/util/imagesequencer.h b/modules/spacecraftinstruments/util/imagesequencer.h
index d953622a6e..3af08edc51 100644
--- a/modules/spacecraftinstruments/util/imagesequencer.h
+++ b/modules/spacecraftinstruments/util/imagesequencer.h
@@ -125,7 +125,7 @@ public:
      * makes the request. If an instance is not registered in the class then the singleton
      * returns false and no projections will occur.
      */
-    bool getImagePaths(std::vector<Image>& captures, std::string projectee, 
+    bool getImagePaths(std::vector<Image>& captures, std::string projectee,
         std::string instrumentRequest, double sinceTime);
 
     /*
diff --git a/modules/spacecraftinstruments/util/instrumenttimesparser.cpp b/modules/spacecraftinstruments/util/instrumenttimesparser.cpp
index 7241691880..c67b15d7d3 100644
--- a/modules/spacecraftinstruments/util/instrumenttimesparser.cpp
+++ b/modules/spacecraftinstruments/util/instrumenttimesparser.cpp
@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>
 #include <openspace/util/time.h>
@@ -40,6 +41,7 @@
 
 #include <ghoul/misc/dictionary.h>
 
+#include <ghoul/fmt.h>
 #include <map>
 #include <string>
 #include <vector>
@@ -97,7 +99,7 @@ bool InstrumentTimesParser::create() {
     using RawPath = ghoul::filesystem::Directory::RawPath;
     ghoul::filesystem::Directory sequenceDir(_fileName, RawPath::Yes);
     if (!FileSys.directoryExists(sequenceDir)) {
-        LERROR("Could not load Label Directory '" << sequenceDir.path() << "'");
+        LERROR(fmt::format("Could not load Label Directory '{}'", sequenceDir.path()));
         return false;
     }
 
@@ -110,7 +112,7 @@ bool InstrumentTimesParser::create() {
             );
 
             if (!FileSys.fileExists(filepath)) {
-                LERROR("Unable to read file " << filepath << ". Skipping file.");
+                LERROR(fmt::format("Unable to read file '{}'. Skipping file", filepath));
                 continue;
             }
 
diff --git a/modules/spacecraftinstruments/util/labelparser.cpp b/modules/spacecraftinstruments/util/labelparser.cpp
index 95939fa481..298568927e 100644
--- a/modules/spacecraftinstruments/util/labelparser.cpp
+++ b/modules/spacecraftinstruments/util/labelparser.cpp
@@ -30,11 +30,13 @@
 #include <openspace/util/time.h>
 
 #include <ghoul/filesystem/directory.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/dictionary.h>
 
+#include <ghoul/fmt.h>
 #include <fstream>
 #include <iterator>
 #include <iomanip>
@@ -159,7 +161,7 @@ bool LabelParser::create() {
     using RawPath = ghoul::filesystem::Directory::RawPath;
     ghoul::filesystem::Directory sequenceDir(_fileName, RawPath::Yes);
     if (!FileSys.directoryExists(sequenceDir)) {
-        LERROR("Could not load Label Directory '" << sequenceDir.path() << "'");
+        LERROR(fmt::format("Could not load Label Directory '{}'", sequenceDir.path()));
         return false;
     }
     using Recursive = ghoul::filesystem::Directory::Recursive;
@@ -173,10 +175,10 @@ bool LabelParser::create() {
                 if (extension == "lbl" || extension == "LBL") { // discovered header file
                     std::ifstream file(currentFile.path());
 
-                    if (!file.good()){
-                        LERROR(
-                            "Failed to open label file '" << currentFile.path() << "'"
-                        );
+                    if (!file.good()) {
+                        LERROR(fmt::format(
+                            "Failed to open label file '{}'", currentFile.path()
+                        ));
                         return false;
                     }
 
diff --git a/modules/spacecraftinstruments/util/projectioncomponent.cpp b/modules/spacecraftinstruments/util/projectioncomponent.cpp
index a33775728f..e248838cbe 100644
--- a/modules/spacecraftinstruments/util/projectioncomponent.cpp
+++ b/modules/spacecraftinstruments/util/projectioncomponent.cpp
@@ -153,7 +153,8 @@ documentation::Documentation ProjectionComponent::Documentation() {
             {
                 keySequenceType,
                 new StringInListVerifier(
-                    { sequenceTypeImage, sequenceTypePlaybook, sequenceTypeHybrid }
+                    { sequenceTypeImage, sequenceTypePlaybook, sequenceTypeHybrid,
+                      sequenceTypeInstrumentTimes }
                 ),
                 Optional::Yes,
                 "This value determines which type of sequencer is used for generating "
@@ -482,7 +483,7 @@ void ProjectionComponent::imageProjectBegin() {
     glGetIntegerv(GL_FRAMEBUFFER_BINDING, &_defaultFBO);
 
     if (_textureSizeDirty) {
-        LDEBUG("Changing texture size to " << std::to_string(_textureSize));
+        LDEBUG(fmt::format("Changing texture size to {}", std::to_string(_textureSize)));
 
         // If the texture size has changed, we have to allocate new memory and copy
         // the image texture to the new target
@@ -513,10 +514,11 @@ void ProjectionComponent::imageProjectBegin() {
 
             GLenum status = glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
             if (!FramebufferObject::errorChecking(status).empty()) {
-                LERROR(
-                    "Read Buffer (" << msg << "): " <<
+                LERROR(fmt::format(
+                    "Read Buffer ({}): {}",
+                    msg,
                     FramebufferObject::errorChecking(status)
-                );
+                ));
             }
 
             glFramebufferTexture(
@@ -528,10 +530,11 @@ void ProjectionComponent::imageProjectBegin() {
 
             status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
             if (!FramebufferObject::errorChecking(status).empty()) {
-                LERROR(
-                    "Draw Buffer (" << msg << "): " <<
+                LERROR(fmt::format(
+                    "Draw Buffer ({}): {}",
+                    msg,
                     FramebufferObject::errorChecking(status)
-                );
+                ));
             }
 
             glBlitFramebuffer(
@@ -554,10 +557,11 @@ void ProjectionComponent::imageProjectBegin() {
 
             GLenum status = glCheckFramebufferStatus(GL_READ_FRAMEBUFFER);
             if (!FramebufferObject::errorChecking(status).empty()) {
-                LERROR(
-                    "Read Buffer (" << msg << "): " <<
+                LERROR(fmt::format(
+                    "Read Buffer ({}): {}",
+                    msg,
                     FramebufferObject::errorChecking(status)
-                );
+                ));
             }
 
             glFramebufferTexture(
@@ -569,10 +573,11 @@ void ProjectionComponent::imageProjectBegin() {
 
             status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
             if (!FramebufferObject::errorChecking(status).empty()) {
-                LERROR(
-                    "Draw Buffer (" << msg << "): " <<
+                LERROR(fmt::format(
+                    "Draw Buffer ({}): {}",
+                    msg,
                     FramebufferObject::errorChecking(status)
-                );
+                ));
             }
 
             glBlitFramebuffer(
@@ -985,9 +990,8 @@ std::shared_ptr<ghoul::opengl::Texture> ProjectionComponent::loadProjectionTextu
 }
 
 bool ProjectionComponent::generateProjectionLayerTexture(const ivec2& size) {
-    LINFO(
-        "Creating projection texture of size '" << size.x << ", " << size.y << "'"
-    );
+    LINFO(fmt::format("Creating projection texture of size '{}, {}'", size.x, size.y));
+
     using namespace ghoul::opengl;
     _projectionTexture = std::make_unique<Texture>(
         glm::uvec3(size, 1),
@@ -1033,9 +1037,7 @@ bool ProjectionComponent::generateProjectionLayerTexture(const ivec2& size) {
 }
 
 bool ProjectionComponent::generateDepthTexture(const ivec2& size) {
-    LINFO(
-        "Creating depth texture of size '" << size.x << ", " << size.y << "'"
-        );
+    LINFO(fmt::format("Creating depth texture of size '{}, {}'", size.x, size.y));
 
     _shadowing.texture = std::make_unique<ghoul::opengl::Texture>(
         glm::uvec3(size, 1),
diff --git a/modules/spout/renderableplanespout.cpp b/modules/spout/renderableplanespout.cpp
index 0447ea749f..5e82dda7a4 100644
--- a/modules/spout/renderableplanespout.cpp
+++ b/modules/spout/renderableplanespout.cpp
@@ -29,12 +29,14 @@
 #include <openspace/documentation/documentation.h>
 #include <openspace/documentation/verifier.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/defer.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/texture.h>
 
 namespace {
+    constexpr const char* LoggerCat = "ScreenSpaceSpout";
+
     const char* KeyName = "Name";
 
     static const openspace::properties::Property::PropertyInfo NameInfo = {
@@ -51,7 +53,7 @@ namespace {
         "selected, its value is stored in the 'SpoutName' property, overwriting its "
         "previous value."
     };
-    
+
     static const openspace::properties::Property::PropertyInfo UpdateInfo = {
         "UpdateSelection",
         "Update Selection",
@@ -118,7 +120,7 @@ RenderablePlaneSpout::RenderablePlaneSpout(const ghoul::Dictionary& dictionary)
     }
 
     _spoutName.onChange([this]() {
-        _isSpoutDirty = true; 
+        _isSpoutDirty = true;
         _isErrorMessageDisplayed = false;
 
         _receiver->SetActiveSender(_spoutName.value().c_str());
@@ -204,8 +206,8 @@ void RenderablePlaneSpout::update(const UpdateData& data) {
 
         if (!createSuccess) {
             LWARNINGC(
-                "ScreenSpaceSpout",
-                "Could not create receiver for " << _currentSenderName
+                LoggerCat,
+                fmt::format("Could not create receiver for {}", _currentSenderName)
             );
             return;
         }
@@ -213,7 +215,7 @@ void RenderablePlaneSpout::update(const UpdateData& data) {
 
     unsigned int width;
     unsigned int height;
-    
+
     bool receiveSuccess = _receiver->ReceiveTexture(
         _currentSenderName,
         width,
@@ -222,8 +224,8 @@ void RenderablePlaneSpout::update(const UpdateData& data) {
 
     if (!receiveSuccess && !_isErrorMessageDisplayed) {
         LWARNINGC(
-            "ScreenSpaceSpout",
-            "Could not receive texture for " << _currentSenderName
+            LoggerCat,
+            fmt::format("Could not receive texture for {}", _currentSenderName)
         );
         _isErrorMessageDisplayed = true;
     }
diff --git a/modules/spout/renderableplanespout.h b/modules/spout/renderableplanespout.h
index fb9809af67..0af9de3b71 100644
--- a/modules/spout/renderableplanespout.h
+++ b/modules/spout/renderableplanespout.h
@@ -69,6 +69,6 @@ private:
 
 } // namespace openspace
 
-#endif // __OPENSPACE_MODULE_SPOUT___RENDERABLEPLANESPOUT___H__
-
 #endif // WIN32
+
+#endif // __OPENSPACE_MODULE_SPOUT___RENDERABLEPLANESPOUT___H__
diff --git a/modules/spout/screenspacespout.cpp b/modules/spout/screenspacespout.cpp
index 2b913088fa..c515b2b7ce 100644
--- a/modules/spout/screenspacespout.cpp
+++ b/modules/spout/screenspacespout.cpp
@@ -48,7 +48,7 @@ namespace {
         "selected, its value is stored in the 'SpoutName' property, overwriting its "
         "previous value."
     };
-    
+
     static const openspace::properties::Property::PropertyInfo UpdateInfo = {
         "UpdateSelection",
         "Update Selection",
@@ -115,7 +115,7 @@ ScreenSpaceSpout::ScreenSpaceSpout(const ghoul::Dictionary& dictionary)
     }
 
     _spoutName.onChange([this]() {
-        _isSpoutDirty = true; 
+        _isSpoutDirty = true;
         _isErrorMessageDisplayed = false;
 
         _receiver->SetActiveSender(_spoutName.value().c_str());
@@ -206,7 +206,7 @@ void ScreenSpaceSpout::update() {
         if (!createSuccess) {
             LWARNINGC(
                 "ScreenSpaceSpout",
-                "Could not create receiver for " << _currentSenderName
+                fmt::format("Could not create receiver for {}", _currentSenderName)
             );
             return;
         }
@@ -214,7 +214,7 @@ void ScreenSpaceSpout::update() {
 
     unsigned int width;
     unsigned int height;
-    
+
     bool receiveSuccess = _receiver->ReceiveTexture(
         _currentSenderName,
         width,
@@ -224,7 +224,7 @@ void ScreenSpaceSpout::update() {
     if (!receiveSuccess && !_isErrorMessageDisplayed) {
         LWARNINGC(
             "ScreenSpaceSpout",
-            "Could not receive texture for " << _currentSenderName
+            fmt::format("Could not receive texture for {}", _currentSenderName)
         );
         _isErrorMessageDisplayed = true;
     }
diff --git a/modules/spout/screenspacespout.h b/modules/spout/screenspacespout.h
index b3dc16f28c..2cf3f480fb 100644
--- a/modules/spout/screenspacespout.h
+++ b/modules/spout/screenspacespout.h
@@ -69,6 +69,6 @@ private:
 
 } // namespace openspace
 
-#endif // __OPENSPACE_MODULE_SPOUT___SCREENSPACESPOUT___H__
-
 #endif // WIN32
+
+#endif // __OPENSPACE_MODULE_SPOUT___SCREENSPACESPOUT___H__
diff --git a/modules/sync/syncs/httpsynchronization.cpp b/modules/sync/syncs/httpsynchronization.cpp
index 93ac3f24e2..b709f2a7ca 100644
--- a/modules/sync/syncs/httpsynchronization.cpp
+++ b/modules/sync/syncs/httpsynchronization.cpp
@@ -22,27 +22,27 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#include "httpsynchronization.h"
+#include <modules/sync/syncs/httpsynchronization.h>
 
 #include <modules/sync/syncmodule.h>
-
+#include <openspace/documentation/verifier.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/moduleengine.h>
 #include <openspace/util/httprequest.h>
-
-#include <ghoul/logging/logmanager.h>
 #include <ghoul/filesystem/filesystem.h>
-#include <openspace/documentation/verifier.h>
-
-#include <sstream>
+#include <ghoul/logging/logmanager.h>
+#include <cstdio>
 #include <fstream>
 #include <numeric>
 #include <memory>
+#include <sstream>
 
 namespace {
     constexpr const char* KeyIdentifier = "Identifier";
     constexpr const char* KeyVersion = "Version";
 
+    constexpr const char* TempSuffix = ".tmp";
+
     constexpr const char* QueryKeyIdentifier = "identifier";
     constexpr const char* QueryKeyFileVersion = "file_version";
     constexpr const char* QueryKeyApplicationVersion = "application_version";
@@ -214,8 +214,8 @@ bool HttpSynchronization::trySyncFromUrl(std::string listUrl) {
         std::string filename = line.substr(lastSlash + 1);
 
         std::string fileDestination = directory() +
-        ghoul::filesystem::FileSystem::PathSeparator +
-        filename;
+            ghoul::filesystem::FileSystem::PathSeparator +
+            filename + TempSuffix;
 
         downloads.push_back(std::make_unique<AsyncHttpFileDownload>(
             line, fileDestination, HttpFileDownload::Overwrite::Yes));
@@ -256,7 +256,31 @@ bool HttpSynchronization::trySyncFromUrl(std::string listUrl) {
     bool failed = false;
     for (std::unique_ptr<AsyncHttpFileDownload>& d : downloads) {
         d->wait();
-        if (!d->hasSucceeded()) {
+        if (d->hasSucceeded()) {
+            // If we are forcing the override, we download to a temporary file
+            // first, so when we are done here, we need to rename the file to the
+            // original name
+
+            const std::string& tempName = d->destination();
+            std::string originalName = tempName.substr(
+                0,
+                tempName.size() - strlen(TempSuffix)
+            );
+
+            FileSys.deleteFile(originalName);
+            int success = rename(tempName.c_str(), originalName.c_str());
+            if (success != 0) {
+                LERRORC(
+                    "URLSynchronization",
+                    fmt::format(
+                        "Error renaming file {} to {}", tempName, originalName
+                    )
+                );
+
+                failed = true;
+            }
+        }
+        else {
             failed = true;
         }
     }
diff --git a/modules/sync/syncs/torrentsynchronization.cpp b/modules/sync/syncs/torrentsynchronization.cpp
index c2de5b0333..bd16bb8e9c 100644
--- a/modules/sync/syncs/torrentsynchronization.cpp
+++ b/modules/sync/syncs/torrentsynchronization.cpp
@@ -32,6 +32,7 @@
 
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 
 #include <fstream>
@@ -166,9 +167,9 @@ bool TorrentSynchronization::hasSyncFile() {
 void TorrentSynchronization::createSyncFile() {
     std::string directoryName = directory();
     std::string filepath = directoryName + ".ossync";
-    
+
     FileSys.createDirectory(directoryName, ghoul::filesystem::Directory::Recursive::Yes);
-    
+
     std::ofstream syncFile(filepath, std::ofstream::out);
     syncFile << "Synchronized";
     syncFile.close();
diff --git a/modules/sync/syncs/urlsynchronization.cpp b/modules/sync/syncs/urlsynchronization.cpp
index d261ae1119..11ee8b6e21 100644
--- a/modules/sync/syncs/urlsynchronization.cpp
+++ b/modules/sync/syncs/urlsynchronization.cpp
@@ -35,10 +35,14 @@
 #include <fstream>
 #include <numeric>
 #include <memory>
+#include <cstdio>
 
 namespace {
     constexpr const char* KeyUrl = "Url";
     constexpr const char* KeyIdentifier = "Identifier";
+    constexpr const char* KeyOverride = "Override";
+
+    constexpr const char* TempSuffix = ".tmp";
 } // namespace
 
 namespace openspace {
@@ -63,6 +67,16 @@ documentation::Documentation UrlSynchronization::Documentation() {
                 "This optional identifier will be part of the used folder structure and, "
                 "if provided, can be used to manually find the downloaded folder in the "
                 "synchronization folder."
+            },
+            {
+                KeyOverride,
+                new BoolVerifier,
+                Optional::Yes,
+                "If this value is set to 'true' and it is not overwritten by the global "
+                "settings, the file(s) pointed to by this URLSynchronization will always "
+                "be downloaded, thus overwriting the local files. This is useful for "
+                "files that are updated regularly remotely and should be fetch at every "
+                "startup."
             }
         }
     };
@@ -101,6 +115,10 @@ UrlSynchronization::UrlSynchronization(const ghoul::Dictionary& dict,
     else {
         _identifier = std::to_string(hash);
     }
+
+    if (dict.hasValue<bool>(KeyOverride)) {
+        _forceOverride = dict.value<bool>(KeyOverride);
+    }
 }
 
 UrlSynchronization::~UrlSynchronization() {
@@ -116,7 +134,7 @@ void UrlSynchronization::start() {
     }
     begin();
 
-    if (hasSyncFile()) {
+    if (hasSyncFile() && !_forceOverride) {
         resolve();
         return;
     }
@@ -134,7 +152,7 @@ void UrlSynchronization::start() {
 
             std::string fileDestination = directory() +
                 ghoul::filesystem::FileSystem::PathSeparator +
-                filename;
+                filename += TempSuffix;
 
             std::unique_ptr<AsyncHttpFileDownload> download =
                 std::make_unique<AsyncHttpFileDownload>(
@@ -174,7 +192,6 @@ void UrlSynchronization::start() {
             HttpRequest::RequestOptions opt;
             opt.requestTimeoutSeconds = 0;
             fileDownload->start(opt);
-
         }
 
         startedAllDownloads = true;
@@ -182,7 +199,31 @@ void UrlSynchronization::start() {
         bool failed = false;
         for (std::unique_ptr<AsyncHttpFileDownload>& d : downloads) {
             d->wait();
-            if (!d->hasSucceeded()) {
+            if (d->hasSucceeded()) {
+                // If we are forcing the override, we download to a temporary file first,
+                // so when we are done here, we need to rename the file to the original
+                // name
+                
+                const std::string& tempName = d->destination();
+                std::string originalName = tempName.substr(
+                    0,
+                    tempName.size() - strlen(TempSuffix)
+                );
+
+                FileSys.deleteFile(originalName);
+                int success = rename(tempName.c_str(), originalName.c_str());
+                if (success != 0) {
+                    LERRORC(
+                        "URLSynchronization",
+                        fmt::format(
+                            "Error renaming file {} to {}", tempName, originalName
+                        )
+                    );
+
+                    failed = true;
+                }
+            }
+            else {
                 failed = true;
             }
         }
@@ -191,7 +232,7 @@ void UrlSynchronization::start() {
             createSyncFile();
         }
         else {
-            for (auto& d : downloads) {
+            for (std::unique_ptr<AsyncHttpFileDownload>& d : downloads) {
                 d->cancel();
             }
         }
diff --git a/modules/sync/syncs/urlsynchronization.h b/modules/sync/syncs/urlsynchronization.h
index 639fa1b1d3..5e7c458ea3 100644
--- a/modules/sync/syncs/urlsynchronization.h
+++ b/modules/sync/syncs/urlsynchronization.h
@@ -55,6 +55,7 @@ private:
     std::string directory() override;
 
     std::vector<std::string> _urls;
+    bool _forceOverride = false;
     std::string _synchronizationRoot;
     std::string _identifier;
 
diff --git a/modules/sync/tasks/syncassettask.cpp b/modules/sync/tasks/syncassettask.cpp
index e79c0142d1..31afbe9fca 100644
--- a/modules/sync/tasks/syncassettask.cpp
+++ b/modules/sync/tasks/syncassettask.cpp
@@ -139,10 +139,10 @@ void SyncAssetTask::RequestListener::assetStateChanged(std::shared_ptr<Asset> as
     Asset::State state)
 {
     if (state == Asset::State::LoadingFailed) {
-        LERROR("Failed to load asset " << asset->id());
+        LERROR(fmt::format("Failed to load asset: {}", asset->id()));
     }
     if (state == Asset::State::SyncRejected) {
-        LERROR("Failed to sync asset " << asset->id());
+        LERROR(fmt::format("Failed to sync asset: {}", asset->id()));
     }
 }
 
diff --git a/modules/sync/torrentclient.cpp b/modules/sync/torrentclient.cpp
index 1513fb1728..4a53c05281 100644
--- a/modules/sync/torrentclient.cpp
+++ b/modules/sync/torrentclient.cpp
@@ -46,6 +46,8 @@
 #pragma warning (pop)
 #endif // _MSC_VER
 
+#include <ghoul/fmt.h>
+
 #endif // SYNC_USE_LIBTORRENT
 
 namespace {
@@ -83,7 +85,7 @@ void TorrentClient::initialize() {
     settings.set_int(libtorrent::settings_pack::active_downloads, -1);
     settings.set_int(libtorrent::settings_pack::active_seeds, -1);
     settings.set_int(libtorrent::settings_pack::active_limit, 30);
-    
+
     settings.set_str(
         libtorrent::settings_pack::dht_bootstrap_nodes,
         "router.utorrent.com,dht.transmissionbt.com,router.bittorrent.com,\
@@ -144,7 +146,7 @@ void TorrentClient::deinitialize() {
 void TorrentClient::pollAlerts() {
 #ifdef SYNC_USE_LIBTORRENT
     // Libtorrent does not seem to reliably generate alerts for all added torrents.
-    // To make sure that the program does not keep waiting for already finished 
+    // To make sure that the program does not keep waiting for already finished
     // downsloads, we go through the whole list of torrents when polling.
     // However, in theory, the commented code below should be more efficient:
     /*
@@ -189,11 +191,11 @@ TorrentClient::TorrentId TorrentClient::addTorrentFile(const std::string& torren
     p.save_path = destination;
     p.ti = std::make_shared<libtorrent::torrent_info>(torrentFile, ec);
     if (ec) {
-        LERROR(torrentFile << ": " << ec.message());
+        LERROR(fmt::format("{}: {}", torrentFile, ec.message()));
     }
     libtorrent::torrent_handle h = _session.add_torrent(p, ec);
     if (ec) {
-        LERROR(torrentFile << ": " << ec.message());
+        LERROR(fmt::format("{}: {}", torrentFile, ec.message()));
     }
 
     TorrentId id = h.id();
@@ -219,13 +221,13 @@ TorrentClient::TorrentId TorrentClient::addMagnetLink(const std::string& magnetL
     libtorrent::error_code ec;
     libtorrent::add_torrent_params p = libtorrent::parse_magnet_uri(magnetLink, ec);
     if (ec) {
-        LERROR(magnetLink << ": " << ec.message());
+        LERROR(fmt::format("{}: {}", magnetLink, ec.message()));
     }
     p.save_path = destination;
     p.storage_mode = libtorrent::storage_mode_allocate;
     libtorrent::torrent_handle h = _session.add_torrent(p, ec);
     if (ec) {
-        LERROR(magnetLink << ": " << ec.message());
+        LERROR(fmt::format("{}: {}", magnetLink, ec.message()));
     }
 
     TorrentId id = h.id();
diff --git a/modules/sync/torrentclient.h b/modules/sync/torrentclient.h
index 10568da4b9..2aa16effbf 100644
--- a/modules/sync/torrentclient.h
+++ b/modules/sync/torrentclient.h
@@ -97,7 +97,7 @@ public:
         TorrentProgressCallback cb);
 
     void removeTorrent(TorrentId id);
-    
+
 private:
     struct Torrent {
         TorrentId id;
diff --git a/modules/touch/include/touchinteraction.h b/modules/touch/include/touchinteraction.h
index f4a94502df..708c48b5ed 100644
--- a/modules/touch/include/touchinteraction.h
+++ b/modules/touch/include/touchinteraction.h
@@ -62,7 +62,7 @@ public:
     // Stores the selected node, the cursor ID as well as the surface coordinates the
     // cursor touched
     struct SelectedBody {
-        int id;
+        long id;
         SceneGraphNode* node;
         glm::dvec3 coordinates;
     };
diff --git a/modules/touch/include/tuioear.h b/modules/touch/include/tuioear.h
index 93c85275a9..8eb738fc92 100644
--- a/modules/touch/include/tuioear.h
+++ b/modules/touch/include/tuioear.h
@@ -25,11 +25,17 @@
 #ifndef __OPENSPACE_MODULE_TOUCH___TUIO_EAR___H__
 #define __OPENSPACE_MODULE_TOUCH___TUIO_EAR___H__
 
+// -Wold-style-cast
 #if (defined(__GNUC__) && !defined(__clang__))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif // defined(__GNUC__) && !defined(__clang__)
 
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#endif // __clang__
+
 #include <modules/touch/ext/libTUIO11/TUIO/TuioListener.h>
 #include <modules/touch/ext/libTUIO11/TUIO/TuioClient.h>
 #include <modules/touch/ext/libTUIO11/TUIO/UdpReceiver.h>
@@ -38,6 +44,9 @@
 #if (defined(__GNUC__) && !defined(__clang__))
 #pragma GCC diagnostic pop
 #endif // defined(__GNUC__) && !defined(__clang__)
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif // __clang__
 
 #include <ghoul/glm.h>
 
@@ -107,7 +116,7 @@ class TuioEar : public TUIO::TuioListener {
         /**
         * A list that tracks all of the cursor ID's that got removed since last frame
         */
-        std::vector<int> _removeList;
+        std::vector<long> _removeList;
 };
 
 #endif // __OPENSPACE_MODULE_TOUCH___TUIO_EAR___H__
diff --git a/modules/touch/src/touchinteraction.cpp b/modules/touch/src/touchinteraction.cpp
index d57429921c..3e83cc71d1 100644
--- a/modules/touch/src/touchinteraction.cpp
+++ b/modules/touch/src/touchinteraction.cpp
@@ -46,6 +46,7 @@
 #endif
 
 #include <cmath>
+#include <ghoul/fmt.h>
 #include <functional>
 #include <fstream>
 
@@ -256,18 +257,18 @@ TouchInteraction::TouchInteraction()
 
     _origin.onChange([this]() {
         SceneGraphNode* node = sceneGraphNode(_origin.value());
-        if (!node) {
-            LWARNING(
-                "Could not find a node in scenegraph called '" << _origin.value() << "'"
-            );
-            return;
+        if (node) {
+            setFocusNode(node);
+        }
+        else {
+            LWARNING(fmt::format(
+                "Could not find a node in scenegraph called '{}'", _origin.value()
+            ));
         }
-        setFocusNode(node);
     });
 
     levmarq_init(&_lmstat);
 
-
     _time.initSession();
 }
 
@@ -319,12 +320,12 @@ bool TouchInteraction::guiMode(const std::vector<TuioCursor>& list) {
         _guiON = !_guiON;
         module.gui.setEnabled(_guiON);
 
-        std::string mode = (_guiON) ? "" : "de";
-        LINFO(
-            "GUI mode is " << mode << "activated. Inside box by: (" <<
-            static_cast<int>(100 * (pos.x / _guiButton.value().x)) << "%, " <<
-            static_cast<int>(100 * (pos.y / _guiButton.value().y)) << "%)\n"
-        );
+        LINFO(fmt::format(
+            "GUI mode is {}. Inside box by: ({}%, {}%)",
+            _guiON ? "activated" : "deactivated",
+            static_cast<int>(100 * (pos.x / _guiButton.value().x)),
+            static_cast<int>(100 * (pos.y / _guiButton.value().y))
+        ));
     }
     else if (_guiON) {
         module.touchInput = { _guiON, pos, 1 }; // emulate touch input as a mouse
@@ -616,9 +617,9 @@ void TouchInteraction::findSelectedNode(const std::vector<TuioCursor>& list) {
             glm::dvec4(xCo, yCo, -1.0, 1.0));
         glm::dvec3 raytrace = glm::normalize(cursorInWorldSpace);
 
-        int id = c.getSessionID();
+        long id = c.getSessionID();
 
-       for (SceneGraphNode* node : selectableNodes) {
+        for (SceneGraphNode* node : selectableNodes) {
             double boundingSphere = node->boundingSphere();
             glm::dvec3 camToSelectable = node->worldPosition() - camPos;
             double dist = length(glm::cross(cursorInWorldSpace, camToSelectable)) /
@@ -754,7 +755,7 @@ int TouchInteraction::interpretInteraction(const std::vector<TuioCursor>& list,
     }
     // find the slowest moving finger - used in roll interpretation
     double minDiff = 1000;
-    int id = 0;
+    long id = 0;
     for (const TuioCursor& c : list) {
         TuioPoint itPoint = std::find_if(
             lastProcessed.begin(),
diff --git a/modules/touch/src/tuioear.cpp b/modules/touch/src/tuioear.cpp
index 79eb78f8c6..2ae6d54c2c 100644
--- a/modules/touch/src/tuioear.cpp
+++ b/modules/touch/src/tuioear.cpp
@@ -25,7 +25,6 @@
 #include <modules/touch/include/tuioear.h>
 
 #include <openspace/engine/openspaceengine.h>
-#include <openspace/engine/settingsengine.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/interaction/navigationhandler.h>
 #include <openspace/rendering/renderengine.h>
@@ -46,11 +45,11 @@ void TuioEar::addTuioCursor(TuioCursor* tcur) {
     _tap = false;
     // find same id in _list if it exists in _removeList (new input with same ID as a
     // previously stored)
-    int i = tcur->getSessionID();
-    std::vector<int>::iterator foundID = std::find_if(
+    long i = tcur->getSessionID();
+    std::vector<long>::iterator foundID = std::find_if(
         _removeList.begin(),
         _removeList.end(),
-        [&i](int id) { return id == i; });
+        [&i](long id) { return id == i; });
 
     // if found, remove id from _removeList and update, otherwise add new id to list
     if (foundID != _removeList.end()) {
@@ -58,8 +57,9 @@ void TuioEar::addTuioCursor(TuioCursor* tcur) {
             _list.begin(),
             _list.end(),
             [&i](const TuioCursor& cursor) {
-            return cursor.getSessionID() == i;
-        })->update(tcur);
+                return cursor.getSessionID() == i;
+            }
+        )->update(tcur);
         _removeList.erase(foundID);
     }
     else {
@@ -71,13 +71,14 @@ void TuioEar::addTuioCursor(TuioCursor* tcur) {
 void TuioEar::updateTuioCursor(TuioCursor* tcur) {
     _mx.lock();
     _tap = false;
-    int i = tcur->getSessionID();
+    long i = tcur->getSessionID();
     std::find_if(
         _list.begin(),
         _list.end(),
         [&i](const TuioCursor& cursor) {
             return cursor.getSessionID() == i;
-    })->update(tcur);
+        }
+    )->update(tcur);
     _mx.unlock();
 }
 
@@ -140,15 +141,16 @@ void TuioEar::clearInput() {
             _list.begin(),
             _list.end(),
             [this](const TuioCursor& cursor) {
-        return std::find_if(
-            _removeList.begin(),
-            _removeList.end(),
-            [&cursor](int id) {
-            return cursor.getSessionID() == id;
-        }
-        ) != _removeList.end();
-    }),
-    _list.end()
+                return std::find_if(
+                    _removeList.begin(),
+                    _removeList.end(),
+                    [&cursor](long id) {
+                        return cursor.getSessionID() == id;
+                    }
+                ) != _removeList.end();
+            }
+        ),
+        _list.end()
     );
     _removeList.clear();
     _mx.unlock();
diff --git a/modules/touch/touchmodule.cpp b/modules/touch/touchmodule.cpp
index 20723e0a70..bae93f2a40 100644
--- a/modules/touch/touchmodule.cpp
+++ b/modules/touch/touchmodule.cpp
@@ -25,7 +25,6 @@
 #include <modules/touch/touchmodule.h>
 
 #include <openspace/engine/openspaceengine.h>
-#include <openspace/engine/settingsengine.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/interaction/navigationhandler.h>
 #include <openspace/rendering/renderengine.h>
diff --git a/modules/volume/rendering/renderabletimevaryingvolume.cpp b/modules/volume/rendering/renderabletimevaryingvolume.cpp
index ea48521273..6cba240b7b 100644
--- a/modules/volume/rendering/renderabletimevaryingvolume.cpp
+++ b/modules/volume/rendering/renderabletimevaryingvolume.cpp
@@ -23,9 +23,9 @@
  ****************************************************************************************/
 
 #include <modules/volume/rendering/renderabletimevaryingvolume.h>
+
 #include <modules/volume/rawvolumereader.h>
 #include <modules/volume/rawvolume.h>
-
 #include <openspace/rendering/renderable.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderengine.h>
@@ -34,13 +34,12 @@
 #include <openspace/documentation/verifier.h>
 #include <openspace/util/timemanager.h>
 #include <openspace/util/time.h>
-
 #include <ghoul/glm.h>
 #include <ghoul/opengl/ghoul_gl.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/cachemanager.h>
 #include <ghoul/logging/logmanager.h>
-
+#include <ghoul/fmt.h>
 #include <glm/gtc/matrix_transform.hpp>
 
 namespace {
@@ -222,7 +221,7 @@ void RenderableTimeVaryingVolume::initializeGL() {
     ghoul::filesystem::Directory sequenceDir(_sourceDirectory, RawPath::Yes);
 
     if (!FileSys.directoryExists(sequenceDir)) {
-        LERROR("Could not load sequence directory '" << sequenceDir.path() << "'");
+        LERROR(fmt::format("Could not load sequence directory '{}'", sequenceDir.path()));
         return;
     }
 
@@ -340,16 +339,11 @@ void RenderableTimeVaryingVolume::initializeGL() {
 
 void RenderableTimeVaryingVolume::loadTimestepMetadata(const std::string& path) {
     ghoul::Dictionary dictionary = ghoul::lua::loadDictionaryFromFile(path);
-    try {
-        documentation::testSpecificationAndThrow(
-            TimestepDocumentation(),
-            dictionary,
-            "TimeVaryingVolumeTimestep"
-        );
-    } catch (const documentation::SpecificationError& e) {
-        LERROR(e.message << e.component);
-        return;
-    }
+    documentation::testSpecificationAndThrow(
+        TimestepDocumentation(),
+        dictionary,
+        "TimeVaryingVolumeTimestep"
+    );
 
     Timestep t;
     t.baseName = ghoul::filesystem::File(path).baseName();
diff --git a/openspace.cfg b/openspace.cfg
index 03d39ffdc5..f71fa86c58 100644
--- a/openspace.cfg
+++ b/openspace.cfg
@@ -87,6 +87,7 @@ return {
 
     LuaDocumentation = "${DOCUMENTATION}/LuaScripting.html",
     PropertyDocumentation = "${DOCUMENTATION}/Properties.html",
+    ScenePropertyDocumentation = "${DOCUMENTATION}/SceneProperties.html",
     KeyboardShortcuts = "${DOCUMENTATION}/KeyboardMapping.html",
     Documentation = "${DOCUMENTATION}/Documentation.html",
     FactoryDocumentation = "${DOCUMENTATION}/FactoryDocumentation.html",
diff --git a/scripts/common.lua b/scripts/common.lua
deleted file mode 100644
index 963cf1efef..0000000000
--- a/scripts/common.lua
+++ /dev/null
@@ -1,54 +0,0 @@
-helper = {}
-helper.property = {}
-
--- Function that returns the string that inverts the fully qualified boolean property 'property'
-helper.property.invert = function(prop)
-    local escaped_property = "'" .. prop .. "'"
-    return "openspace.setPropertyValue(" .. escaped_property .. ", not openspace.getPropertyValue(" .. escaped_property .. "));"
-end
-
--- Function that returns the string that increments the 'property' by the 'value'
-helper.property.increment = function(prop, value)
-    local v = value or 1
-    local escaped_property = "'" .. prop .. "'"
-    return "openspace.setPropertyValue(" .. escaped_property .. ", openspace.getPropertyValue(" .. escaped_property .. ") + " .. v .. ");"
-end
-
--- Function that returns the string that decrements the 'property' by the 'value'
-helper.property.decrement = function(prop, value)
-    return helper.property.increment(prop, -value)
-end
-
-
-
-helper.renderable = {}
-
--- Function that returns the string that enables/disables the renderable 'renderable'
-helper.renderable.toggle = function(renderable)
-    return helper.property.invert(renderable .. ".renderable.Enabled")
-end
-
--- Function that returns the string that sets the enabled property of <renderable> to <enabled>
-helper.renderable.setEnabled = function(renderable, enabled)
-    return "openspace.setPropertyValue('" .. renderable .. ".renderable.Enabled', " .. (enabled and "true" or "false") .. ");";
-end
-
-helper.scheduledScript = {}
-helper.scheduledScript.reversible = {}
-
--- Function that returns a lua table specifying a reversible ScheduledScript for 
--- setting the enabled property of <renderable> to <enabled> at time <time>.
-helper.scheduledScript.reversible.setEnabled = function(time, renderable, enabled)
-    return {
-        Time = time,
-        ForwardScript = helper.renderable.setEnabled(renderable, enabled),
-        BackwardScript = helper.renderable.setEnabled(renderable, not enabled)
-    }
-end
-
-helper.scheduledScript.setEnabled = function(time, renderable, enabled)
-    return {
-        Time = time,
-        ForwardScript = helper.renderable.setEnabled(renderable, enabled)
-    }
-end
\ No newline at end of file
diff --git a/scripts/core_scripts.lua b/scripts/core_scripts.lua
index 6467fbfefd..8c9ee568ae 100644
--- a/scripts/core_scripts.lua
+++ b/scripts/core_scripts.lua
@@ -76,7 +76,7 @@ end
 
 openspace.setDefaultGuiSorting = function()
     openspace.setPropertyValueSingle(
-        'Global Properties.ImGUI.Main.Properties.Ordering',
+        'Modules.ImGUI.Main.Scene Properties.Ordering',
         {
             "Solar System", "Milky Way", "Universe", "Other"
         }
diff --git a/shaders/fragment.glsl b/shaders/fragment.glsl
index 50fc9ca5dc..97755f6734 100644
--- a/shaders/fragment.glsl
+++ b/shaders/fragment.glsl
@@ -37,4 +37,4 @@ struct Fragment {
     bool forceFboRendering;
 };
 
-#endif    
+#endif
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 58dde2a0ea..db11c83533 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -38,7 +38,6 @@ set(OPENSPACE_SOURCE
     ${OPENSPACE_BASE_DIR}/src/engine/moduleengine.cpp
     ${OPENSPACE_BASE_DIR}/src/engine/moduleengine_lua.inl
     ${OPENSPACE_BASE_DIR}/src/engine/openspaceengine.cpp
-    ${OPENSPACE_BASE_DIR}/src/engine/settingsengine.cpp
     ${OPENSPACE_BASE_DIR}/src/engine/syncengine.cpp
     ${OPENSPACE_BASE_DIR}/src/engine/virtualpropertymanager.cpp
     ${OPENSPACE_BASE_DIR}/src/engine/wrapper/sgctwindowwrapper.cpp
@@ -203,7 +202,6 @@ set(OPENSPACE_HEADER
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/logfactory.h
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/moduleengine.h
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/openspaceengine.h
-    ${OPENSPACE_BASE_DIR}/include/openspace/engine/settingsengine.h
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/syncengine.h
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/virtualpropertymanager.h
     ${OPENSPACE_BASE_DIR}/include/openspace/engine/wrapper/sgctwindowwrapper.h
diff --git a/src/documentation/documentationengine.cpp b/src/documentation/documentationengine.cpp
index a8688dd3dc..3a68648e32 100644
--- a/src/documentation/documentationengine.cpp
+++ b/src/documentation/documentationengine.cpp
@@ -36,7 +36,7 @@
 #include <sstream>
 #include <streambuf>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 namespace {
     const char* MainTemplateFilename = "${WEB}/documentation/main.hbs";
@@ -282,18 +282,7 @@ std::string DocumentationEngine::generateJson() const {
 
     json << "]";
 
-    std::string jsonString = "";
-    for (const char& c : json.str()) {
-        switch (c) {
-            case '\'':
-                jsonString += "\\'";
-                break;
-            default:
-                jsonString += c;
-        }
-    }
-
-    return jsonString;
+    return json.str();
 }
 
 void DocumentationEngine::addDocumentation(Documentation doc) {
diff --git a/src/documentation/documentationgenerator.cpp b/src/documentation/documentationgenerator.cpp
index 28a7dac2f1..f756068c80 100644
--- a/src/documentation/documentationgenerator.cpp
+++ b/src/documentation/documentationgenerator.cpp
@@ -36,6 +36,7 @@
 
 namespace {
     const char* HandlebarsFilename = "${WEB}/common/handlebars-v4.0.5.js";
+    const char* BaseLibraryFilename = "${WEB}/common/base.js";
     const char* BootstrapFilename = "${WEB}/common/bootstrap.min.css";
     const char* CssFilename = "${WEB}/common/style.css";
 } // namespace
@@ -70,6 +71,14 @@ void DocumentationGenerator::writeDocumentation(const std::string& filename) {
         std::istreambuf_iterator<char>()
     );
 
+    std::ifstream baseLibarayInput;
+    baseLibarayInput.exceptions(~std::ofstream::goodbit);
+    baseLibarayInput.open(absPath(BaseLibraryFilename));
+    const std::string baseLibraryContent = std::string(
+        std::istreambuf_iterator<char>(baseLibarayInput),
+        std::istreambuf_iterator<char>()
+    );
+
     std::ifstream jsInput;
     jsInput.exceptions(~std::ofstream::goodbit);
     jsInput.open(absPath(_javascriptFile));
@@ -120,6 +129,8 @@ void DocumentationGenerator::writeDocumentation(const std::string& filename) {
                    << "</script>"                                                 << '\n';
     }
 
+    const std::string DataId = "data";
+
     const std::string Version =
         "[" +
         std::to_string(OPENSPACE_VERSION_MAJOR) + "," +
@@ -127,11 +138,19 @@ void DocumentationGenerator::writeDocumentation(const std::string& filename) {
         std::to_string(OPENSPACE_VERSION_PATCH) +
         "]";
 
+    file
+        << "\t" << "<script id=\"" << DataId
+        << "\" type=\"text/application/json\">" << '\n'
+        << json << '\n'
+        << "\t" << "</script>" << '\n';
+
+
     file
          << "\t"   << "<script>"                                                  << '\n'
-         << "\t\t" << "var " << _jsonName << " = JSON.parse('" << json << "');"   << '\n'
+         << "\t\t" << "var " << _jsonName << " = parseJson('" << DataId << "');"  << '\n'
          << "\t\t" << "var version = " << Version << ";"                          << '\n'
          << "\t\t" << handlebarsContent                                           << '\n'
+         << "\t\t" << baseLibraryContent                                          << '\n'
          << "\t\t" << jsContent                                                   << '\n'
          << "\t"   << "</script>"                                                 << '\n'
          << "\t"   << "<style type=\"text/css\">"                                 << '\n'
@@ -150,21 +169,19 @@ std::string escapedJson(const std::string& text) {
     for (const char& c : text) {
         switch (c) {
         case '\t':
-            jsonString += "\\t";
+            jsonString += "\\t"; // Replace tab with \t.
             break;
         case '"':
-            // The " character has to be double escaped as JSON.parse will remove a single
-            // escape character, thus leaving only " behind that breaks the string
-            jsonString += "\\\\\"";
+            jsonString += "\\\""; // Replace " with \".
             break;
         case '\\':
-            jsonString += "\\\\";
+            jsonString += "\\\\"; // Replace \ with \\.
             break;
         case '\n':
-            jsonString += "\\\\n";
+            jsonString += "\\\\n"; // Replace newline with \n.
             break;
         case '\r':
-            jsonString += "\\r";
+            jsonString += "\\r"; // Replace carriage return with \r.
             break;
         default:
             jsonString += c;
diff --git a/src/engine/configurationmanager.cpp b/src/engine/configurationmanager.cpp
index cb4fee908d..6f62e808d7 100644
--- a/src/engine/configurationmanager.cpp
+++ b/src/engine/configurationmanager.cpp
@@ -26,6 +26,8 @@
 
 #include <openspace/documentation/documentation.h>
 
+#include <ghoul/fmt.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/lua/lua_helper.h>
@@ -45,78 +47,80 @@ namespace {
 
 namespace openspace {
 
-const string ConfigurationManager::KeyPaths = "Paths";
-const string ConfigurationManager::KeyCache = "CACHE";
-const string ConfigurationManager::KeyFonts = "Fonts";
-const string ConfigurationManager::KeyConfigSgct = "SGCTConfig";
-const string ConfigurationManager::KeyGlobalCustomizationScripts =
-    "GlobalCustomizationScripts";
+// static constexpr const char* ConfigurationManager::KeyPaths = "Paths";
+// const string ConfigurationManager::KeyCache = "CACHE";
+// const string ConfigurationManager::KeyFonts = "Fonts";
+// const string ConfigurationManager::KeyConfigSgct = "SGCTConfig";
+// const string ConfigurationManager::KeyGlobalCustomizationScripts =
+    // "GlobalCustomizationScripts";
 
-const string ConfigurationManager::PartType = "Type";
-const string ConfigurationManager::PartFile = "File";
+// const string ConfigurationManager::PartType = "Type";
+// const string ConfigurationManager::PartFile = "File";
 
-const string ConfigurationManager::KeyLuaDocumentation = "LuaDocumentation";
-const string ConfigurationManager::KeyScriptLog = "ScriptLog";
-const string ConfigurationManager::KeyPropertyDocumentation = "PropertyDocumentation";
-const string ConfigurationManager::KeyKeyboardShortcuts = "KeyboardShortcuts";
-const string ConfigurationManager::KeyDocumentation = "Documentation";
-const string ConfigurationManager::KeyFactoryDocumentation = "FactoryDocumentation";
+// const string ConfigurationManager::KeyLuaDocumentation = "LuaDocumentation";
+// const string ConfigurationManager::KeyScriptLog = "ScriptLog";
+// const string ConfigurationManager::KeyPropertyDocumentation = "PropertyDocumentation";
+// const string ConfigurationManager::KeyScenePropertyDocumentation =
+                                                             // "ScenePropertyDocumentation";
+// const string ConfigurationManager::KeyKeyboardShortcuts = "KeyboardShortcuts";
+// const string ConfigurationManager::KeyDocumentation = "Documentation";
+// const string ConfigurationManager::KeyFactoryDocumentation = "FactoryDocumentation";
 
-const string ConfigurationManager::KeyConfigAsset = "Asset";
-const string ConfigurationManager::KeySceneLicenseDocumentation = "LicenseDocumentation";
+// const string ConfigurationManager::KeyConfigAsset = "Asset";
+// const string ConfigurationManager::KeySceneLicenseDocumentation = "LicenseDocumentation";
 
-const string ConfigurationManager::KeyLogging = "Logging";
-const string ConfigurationManager::PartLogDir = "LogDir";
-const string ConfigurationManager::PartLogLevel = "LogLevel";
-const string ConfigurationManager::PartImmediateFlush = "ImmediateFlush";
-const string ConfigurationManager::PartLogPerformancePrefix = "PerformancePrefix";
+// const string ConfigurationManager::KeyLogging = "Logging";
+// const string ConfigurationManager::PartLogDir = "LogDir";
+// const string ConfigurationManager::PartLogLevel = "LogLevel";
+// const string ConfigurationManager::PartImmediateFlush = "ImmediateFlush";
+// const string ConfigurationManager::PartLogPerformancePrefix = "PerformancePrefix";
 
-const string ConfigurationManager::PartLogs = "Logs";
-const string ConfigurationManager::PartAppend = "Append";
-const string ConfigurationManager::PartCapabilitiesVerbosity = "CapabilitiesVerbosity";
+// const string ConfigurationManager::PartLogs = "Logs";
+// const string ConfigurationManager::PartAppend = "Append";
+// const string ConfigurationManager::PartCapabilitiesVerbosity = "CapabilitiesVerbosity";
 
-const string ConfigurationManager::KeyLauncher = "Launcher";
+// const string ConfigurationManager::KeyLauncher = "Launcher";
 
-const string ConfigurationManager::KeyCapabilitiesVerbosity =
-    KeyLogging + "." + PartCapabilitiesVerbosity;
+// const string ConfigurationManager::KeyCapabilitiesVerbosity =
+    // KeyLogging + "." + PartCapabilitiesVerbosity;
 
-const string ConfigurationManager::KeyShutdownCountdown = "ShutdownCountdown";
-const string ConfigurationManager::KeyDisableMasterRendering = "DisableRenderingOnMaster";
-const string ConfigurationManager::KeyDisableSceneOnMaster = "DisableSceneOnMaster";
-const string ConfigurationManager::KeyPerSceneCache = "PerSceneCache";
-const string ConfigurationManager::KeyRenderingMethod = "RenderingMethod";
+// const string ConfigurationManager::KeyShutdownCountdown = "ShutdownCountdown";
+// const string ConfigurationManager::KeyDisableMasterRendering = "DisableRenderingOnMaster";
+// const string ConfigurationManager::KeyDisableSceneOnMaster = "DisableSceneOnMaster";
+// const string ConfigurationManager::KeyPerSceneCache = "PerSceneCache";
+// const string ConfigurationManager::KeyRenderingMethod = "RenderingMethod";
 
-const string ConfigurationManager::KeyOnScreenTextScaling = "OnScreenTextScaling";
+// const string ConfigurationManager::KeyOnScreenTextScaling = "OnScreenTextScaling";
 
-const string ConfigurationManager::KeyHttpProxy = "HttpProxy";
-const string ConfigurationManager::PartHttpProxyAddress = "Address";
-const string ConfigurationManager::PartHttpProxyPort = "Port";
-const string ConfigurationManager::PartHttpProxyAuthentication = "Authentication";
-const string ConfigurationManager::PartHttpProxyUser = "User";
-const string ConfigurationManager::PartHttpProxyPassword = "Password";
+// const string ConfigurationManager::KeyHttpProxy = "HttpProxy";
+// const string ConfigurationManager::PartHttpProxyAddress = "Address";
+// const string ConfigurationManager::PartHttpProxyPort = "Port";
+// const string ConfigurationManager::PartHttpProxyAuthentication = "Authentication";
+// const string ConfigurationManager::PartHttpProxyUser = "User";
+// const string ConfigurationManager::PartHttpProxyPassword = "Password";
 
-const string ConfigurationManager::KeyOpenGLDebugContext = "OpenGLDebugContext";
-const string ConfigurationManager::PartActivate = "Activate";
-const string ConfigurationManager::PartSynchronous = "Synchronous";
-const string ConfigurationManager::PartFilterIdentifier = "FilterIdentifier";
-const string ConfigurationManager::PartFilterIdentifierSource = "Source";
-const string ConfigurationManager::PartFilterIdentifierType = "Type";
-const string ConfigurationManager::PartFilterIdentifierIdentifier = "Identifier";
-const string ConfigurationManager::PartFilterSeverity = "PartFilterSeverity";
-const string ConfigurationManager::KeyCheckOpenGLState = "CheckOpenGLState";
-const string ConfigurationManager::KeyLogEachOpenGLCall = "LogEachOpenGLCall";
+// const string ConfigurationManager::KeyOpenGLDebugContext = "OpenGLDebugContext";
+// const string ConfigurationManager::PartActivate = "Activate";
+// const string ConfigurationManager::PartSynchronous = "Synchronous";
+// const string ConfigurationManager::PartFilterIdentifier = "FilterIdentifier";
+// const string ConfigurationManager::PartFilterIdentifierSource = "Source";
+// const string ConfigurationManager::PartFilterIdentifierType = "Type";
+// const string ConfigurationManager::PartFilterIdentifierIdentifier = "Identifier";
+// const string ConfigurationManager::PartFilterSeverity = "PartFilterSeverity";
+// const string ConfigurationManager::KeyCheckOpenGLState = "CheckOpenGLState";
+// const string ConfigurationManager::KeyLogEachOpenGLCall = "LogEachOpenGLCall";
 
-const string ConfigurationManager::KeyUseMultithreadedInitialization =
-    "UseMultithreadedInitialization";
+// const string ConfigurationManager::KeyUseMultithreadedInitialization =
+    // "UseMultithreadedInitialization";
 
-const string ConfigurationManager::KeyLoadingScreen = "LoadingScreen";
-const string ConfigurationManager::PartShowMessage = "ShowMessage";
-const string ConfigurationManager::PartShowNodeNames = "ShowNodeNames";
-const string ConfigurationManager::PartShowProgressbar = "ShowProgressbar";
+// const string ConfigurationManager::KeyLoadingScreen = "LoadingScreen";
+// const string ConfigurationManager::PartShowMessage = "ShowMessage";
+// const string ConfigurationManager::PartShowNodeNames = "ShowNodeNames";
+// const string ConfigurationManager::PartShowProgressbar = "ShowProgressbar";
 
-const string ConfigurationManager::KeyScreenshotUseDate = "ScreenshotUseDate";
+// const string ConfigurationManager::KeyScreenshotUseDate = "ScreenshotUseDate";
 
-const string ConfigurationManager::KeyModuleConfigurations = "ModuleConfigurations";
+// const string ConfigurationManager::KeyModuleConfigurations = "ModuleConfigurations";
 
 string ConfigurationManager::findConfiguration(const string& filename) {
     using ghoul::filesystem::Directory;
@@ -187,11 +191,16 @@ void ConfigurationManager::loadFromFile(const string& filename) {
         std::string p = dictionary.value<std::string>(key);
         std::string fullKey =
             FileSystem::TokenOpeningBraces + key + FileSystem::TokenClosingBraces;
-        LDEBUGC("ConfigurationManager", "Registering path " << fullKey << ": " << p);
+        LDEBUGC("ConfigurationManager",
+            fmt::format("Registering path {}: {}", fullKey, p)
+        );
 
         bool override = (basePathToken == fullKey);
         if (override) {
-            LINFOC("ConfigurationManager", "Overriding base path with '" << p << "'");
+            LINFOC(
+                "ConfigurationManager",
+                fmt::format("Overriding base path with '{}'", p)
+            );
         }
 
         using Override = ghoul::filesystem::FileSystem::Override;
diff --git a/src/engine/configurationmanager_doc.inl b/src/engine/configurationmanager_doc.inl
index 26ecaba00b..72e02dd8f5 100644
--- a/src/engine/configurationmanager_doc.inl
+++ b/src/engine/configurationmanager_doc.inl
@@ -69,7 +69,8 @@ documentation::Documentation ConfigurationManager::Documentation() {
             "in all other configuration files or scripts."
         },
         {
-            ConfigurationManager::KeyPaths + '.' + ConfigurationManager::KeyCache,
+            
+            ConfigurationManager::KeyCachePath,
             new StringVerifier,
             Optional::No,
             "The path to be used as a cache folder. If per scene caching is enabled, the "
diff --git a/src/engine/downloadmanager.cpp b/src/engine/downloadmanager.cpp
index 784d3ca8ad..d594a0218d 100644
--- a/src/engine/downloadmanager.cpp
+++ b/src/engine/downloadmanager.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/engine/downloadmanager.h>
 
+#include <ghoul/fmt.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/assert.h>
@@ -239,7 +240,7 @@ std::future<DownloadManager::MemoryFile> DownloadManager::fetchFile(
     const std::string& url,
     SuccessCallback successCallback, ErrorCallback errorCallback)
 {
-    LDEBUG("Start downloading file: '" << url << "' into memory");
+    LDEBUG(fmt::format("Start downloading file: '{}' into memory", url));
 
     auto downloadFunction = [url, successCallback, errorCallback]() {
         DownloadManager::MemoryFile file;
@@ -284,7 +285,7 @@ std::future<DownloadManager::MemoryFile> DownloadManager::fetchFile(
             if (errorCallback) {
                 errorCallback(err);
             } else {
-                LWARNING("Error downloading '" << url << "': " << err);
+                LWARNING(fmt::format("Error downloading '{}': {}", url, err));
             }
             curl_easy_cleanup(curl);
             // Throw an error and use try-catch around call to future.get()
diff --git a/src/engine/moduleengine.cpp b/src/engine/moduleengine.cpp
index d806a69f0e..f0f7f0223e 100644
--- a/src/engine/moduleengine.cpp
+++ b/src/engine/moduleengine.cpp
@@ -42,6 +42,10 @@ namespace {
 
 namespace openspace {
 
+ModuleEngine::ModuleEngine()
+    : properties::PropertyOwner({"Modules"})
+{}
+
 void ModuleEngine::initialize(const ghoul::Dictionary& moduleConfigurations) {
     for (OpenSpaceModule* m : AllModules()) {
         const std::string name = m->name();
@@ -56,7 +60,7 @@ void ModuleEngine::initialize(const ghoul::Dictionary& moduleConfigurations) {
 void ModuleEngine::deinitialize() {
     LDEBUG("Deinitializing modules");
     for (auto& m : _modules) {
-        LDEBUG("Deinitializing module '" << m->name() << "'");
+        LDEBUG(fmt::format("Deinitializing module '{}'", m->name()));
         m->deinitialize();
     }
     _modules.clear();
@@ -82,9 +86,10 @@ void ModuleEngine::registerModule(std::unique_ptr<OpenSpaceModule> m,
         );
     }
 
-    LDEBUG("Registering module '" << m->name() << "'");
+    LDEBUG(fmt::format("Registering module '{}'", m->name()));
     m->initialize(this, configuration);
-    LDEBUG("Registered module '" << m->name() << "'");
+    addPropertySubOwner(m.get());
+    LDEBUG(fmt::format("Registered module '{}'", m->name()));
     _modules.push_back(std::move(m));
 }
 
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index 6fd7fa6c33..639ff3fe16 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -32,7 +32,6 @@
 #include <openspace/engine/downloadmanager.h>
 #include <openspace/engine/logfactory.h>
 #include <openspace/engine/moduleengine.h>
-#include <openspace/engine/settingsengine.h>
 #include <openspace/engine/syncengine.h>
 #include <openspace/engine/virtualpropertymanager.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
@@ -81,7 +80,10 @@
 #include <ghoul/logging/visualstudiooutputlog.h>
 #include <ghoul/misc/defer.h>
 #include <ghoul/opengl/debugcontext.h>
-#include <ghoul/systemcapabilities/systemcapabilities>
+#include <ghoul/opengl/texture.h>
+#include <ghoul/systemcapabilities/systemcapabilities.h>
+#include <ghoul/systemcapabilities/generalcapabilitiescomponent.h>
+#include <ghoul/systemcapabilities/openglcapabilitiescomponent.h>
 
 #include <glbinding/callbacks.h>
 
@@ -157,7 +159,6 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     , _networkEngine(new NetworkEngine)
     , _parallelConnection(new ParallelConnection)
     , _renderEngine(new RenderEngine)
-    , _settingsEngine(new SettingsEngine)
     , _syncEngine(std::make_unique<SyncEngine>(4096))
     , _timeManager(new TimeManager)
     , _windowWrapper(std::move(windowWrapper))
@@ -169,7 +170,7 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     , _scriptEngine(new scripting::ScriptEngine)
     , _scriptScheduler(new scripting::ScriptScheduler)
     , _virtualPropertyManager(new VirtualPropertyManager)
-    , _globalPropertyNamespace(new properties::PropertyOwner({ "" }))
+    , _rootPropertyOwner(new properties::PropertyOwner({ "" }))
     , _loadingScreen(nullptr)
     , _versionInformation{
         properties::StringProperty(VersionInfo, OPENSPACE_VERSION_STRING_FULL),
@@ -180,24 +181,24 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     , _shutdown({false, 0.f, 0.f})
     , _isFirstRenderingFirstFrame(true)
 {
-    _navigationHandler->setPropertyOwner(_globalPropertyNamespace.get());
+    _rootPropertyOwner->addPropertySubOwner(_moduleEngine.get());
 
+    _navigationHandler->setPropertyOwner(_rootPropertyOwner.get());
     // New property subowners also have to be added to the ImGuiModule callback!
-    _globalPropertyNamespace->addPropertySubOwner(_navigationHandler.get());
-    _globalPropertyNamespace->addPropertySubOwner(_settingsEngine.get());
-    _globalPropertyNamespace->addPropertySubOwner(_renderEngine.get());
-    if (_windowWrapper) {
-        _globalPropertyNamespace->addPropertySubOwner(_windowWrapper.get());
-    }
-    _globalPropertyNamespace->addPropertySubOwner(_parallelConnection.get());
-    _globalPropertyNamespace->addPropertySubOwner(_console.get());
-    _globalPropertyNamespace->addPropertySubOwner(_dashboard.get());
+    _rootPropertyOwner->addPropertySubOwner(_navigationHandler.get());
 
+    _rootPropertyOwner->addPropertySubOwner(_renderEngine.get());
+    if (_windowWrapper) {
+        _rootPropertyOwner->addPropertySubOwner(_windowWrapper.get());
+    }
+    _rootPropertyOwner->addPropertySubOwner(_parallelConnection.get());
+    _rootPropertyOwner->addPropertySubOwner(_console.get());
+    _rootPropertyOwner->addPropertySubOwner(_dashboard.get());
 
     _versionInformation.versionString.setReadOnly(true);
-    _globalPropertyNamespace->addProperty(_versionInformation.versionString);
+    _rootPropertyOwner->addProperty(_versionInformation.versionString);
     _versionInformation.sourceControlInformation.setReadOnly(true);
-    _globalPropertyNamespace->addProperty(_versionInformation.sourceControlInformation);
+    _rootPropertyOwner->addProperty(_versionInformation.sourceControlInformation);
 
     FactoryManager::initialize();
     FactoryManager::ref().addFactory(
@@ -315,7 +316,7 @@ void OpenSpaceEngine::create(int argc, char** argv,
             "Configuration file '" + configurationFilePath + "'"
         );
     }
-    LINFO("Configuration Path: '" << configurationFilePath << "'");
+    LINFO(fmt::format("Configuration Path: '{}'", configurationFilePath));
 
     // Loading configuration from disk
     LDEBUG("Loading configuration from disk");
@@ -323,7 +324,9 @@ void OpenSpaceEngine::create(int argc, char** argv,
         _engine->configurationManager().loadFromFile(configurationFilePath);
     }
     catch (const documentation::SpecificationError& e) {
-        LFATAL("Loading of configuration file '" << configurationFilePath << "' failed");
+        LFATAL(fmt::format(
+            "Loading of configuration file '{}' failed", configurationFilePath
+        ));
         for (const documentation::TestResult::Offense& o : e.result.offenses) {
             LERRORC(o.offender, std::to_string(o.reason));
         }
@@ -333,7 +336,9 @@ void OpenSpaceEngine::create(int argc, char** argv,
         throw;
     }
     catch (const ghoul::RuntimeError& e) {
-        LFATAL("Loading of configuration file '" << configurationFilePath << "' failed");
+        LFATAL(fmt::format(
+            "Loading of configuration file '{}' failed", configurationFilePath
+        ));
         LFATALC(e.component, e.message);
         throw;
     }
@@ -354,8 +359,8 @@ void OpenSpaceEngine::create(int argc, char** argv,
             cacheFolder += "-" + ghoul::filesystem::File(scene).baseName();
         }
 
-        LINFO("Old cache: " << absPath("${CACHE}"));
-        LINFO("New cache: " << cacheFolder);
+        LINFO(fmt::format("Old cache: {}", absPath("${CACHE}")));
+        LINFO(fmt::format("New cache: {}", cacheFolder));
         FileSys.registerPathToken(
             "${CACHE}",
             cacheFolder,
@@ -417,8 +422,10 @@ void OpenSpaceEngine::create(int argc, char** argv,
         ConfigurationManager::KeyConfigSgct, sgctConfigurationPath);
 
     if (!commandlineArgumentPlaceholders.sgctConfigurationName.empty()) {
-        LDEBUG("Overwriting SGCT configuration file with commandline argument: " <<
-            commandlineArgumentPlaceholders.sgctConfigurationName);
+        LDEBUG(fmt::format(
+            "Overwriting SGCT configuration file with commandline argument: {}",
+            commandlineArgumentPlaceholders.sgctConfigurationName
+        ));
         sgctConfigurationPath = commandlineArgumentPlaceholders.sgctConfigurationName;
     }
 
@@ -522,7 +529,7 @@ void OpenSpaceEngine::initialize() {
     // Check the required OpenGL versions of the registered modules
     ghoul::systemcapabilities::Version version =
         _engine->_moduleEngine->requiredOpenGLVersion();
-    LINFO("Required OpenGL version: " << std::to_string(version));
+    LINFO(fmt::format("Required OpenGL version: {}", std::to_string(version)));
 
     if (OpenGLCap.openGLVersion() < version) {
         throw ghoul::RuntimeError(
@@ -566,10 +573,6 @@ void OpenSpaceEngine::initialize() {
         );
     }
 
-    // Initialize the SettingsEngine
-    _settingsEngine->initialize();
-    _settingsEngine->setModules(_moduleEngine->modules());
-
     // Initialize the NavigationHandler
     _navigationHandler->initialize();
 
@@ -600,26 +603,21 @@ void OpenSpaceEngine::scheduleLoadSingleAsset(std::string assetPath) {
 
 std::unique_ptr<LoadingScreen> OpenSpaceEngine::createLoadingScreen() {
     bool showMessage = true;
-    std::string kMessage =
-        ConfigurationManager::KeyLoadingScreen + "." +
-        ConfigurationManager::PartShowMessage;
+    constexpr const char* kMessage = ConfigurationManager::KeyLoadingScreenShowMessage;
     if (configurationManager().hasKey(kMessage)) {
         showMessage = configurationManager().value<bool>(kMessage);
     }
 
     bool showNodeNames = true;
-    std::string kNames =
-        ConfigurationManager::KeyLoadingScreen + "." +
-        ConfigurationManager::PartShowNodeNames;
+    constexpr const char* kNames = ConfigurationManager::KeyLoadingScreenShowNodeNames;
 
     if (configurationManager().hasKey(kNames)) {
         showNodeNames = configurationManager().value<bool>(kNames);
     }
 
     bool showProgressbar = true;
-    std::string kProgress =
-        ConfigurationManager::KeyLoadingScreen + "." +
-        ConfigurationManager::PartShowProgressbar;
+    constexpr const char* kProgress =
+                                    ConfigurationManager::KeyLoadingScreenShowProgressbar;
 
     if (configurationManager().hasKey(kProgress)) {
         showProgressbar = configurationManager().value<bool>(kProgress);
@@ -651,6 +649,7 @@ void OpenSpaceEngine::loadSingleAsset(const std::string& assetPath) {
         _renderEngine->setCamera(nullptr);
         _navigationHandler->setCamera(nullptr);
         _scene->clear();
+        _rootPropertyOwner->removePropertySubOwner(_scene.get());
     }
 
     bool multiThreadedInitialization = configurationManager().hasKeyAndValue<bool>(
@@ -669,6 +668,7 @@ void OpenSpaceEngine::loadSingleAsset(const std::string& assetPath) {
     }
 
     _scene = std::make_unique<Scene>(std::move(sceneInitializer));
+    _rootPropertyOwner->addPropertySubOwner(_scene.get());
     _scene->setCamera(std::make_unique<Camera>());
     Camera* camera = _scene->camera();
     camera->setParent(_scene->root());
@@ -858,14 +858,14 @@ void OpenSpaceEngine::runGlobalCustomizationScripts() {
 
             if (FileSys.fileExists(script)) {
                 try {
-                    LINFO("Running global customization script: " << script);
+                    LINFO(fmt::format("Running global customization script: {}", script));
                     ghoul::lua::runScriptFile(state, script);
                 } catch (ghoul::RuntimeError& e) {
                     LERRORC(e.component, e.message);
                 }
             }
             else {
-                LDEBUG("Ignoring non-existing script file: " << script);
+                LDEBUG(fmt::format("Ignoring non-existing script file: {}", script));
             }
         }
     }
@@ -881,15 +881,15 @@ void OpenSpaceEngine::loadFonts() {
         std::string font = absPath(fonts.value<std::string>(key));
 
         if (!FileSys.fileExists(font)) {
-            LERROR("Could not find font '" << font << "'");
+            LERROR(fmt::format("Could not find font '{}'", font));
             continue;
         }
 
-        LDEBUG("Registering font '" << font << "' with key '" << key << "'");
+        LDEBUG(fmt::format("Registering font '{}' with key '{}'", font, key));
         bool success = _fontManager->registerFontPath(key, font);
 
         if (!success) {
-            LERROR("Error registering font '" << font << "' with key '" << key << "'");
+            LERROR(fmt::format("Error registering font '{}' with key '{}'", font, key));
         }
     }
 
@@ -912,12 +912,10 @@ void OpenSpaceEngine::loadFonts() {
 }
 
 void OpenSpaceEngine::configureLogging(bool consoleLog) {
-    const std::string KeyLogLevel =
-        ConfigurationManager::KeyLogging + '.' + ConfigurationManager::PartLogLevel;
-    const std::string KeyLogImmediateFlush =
-        ConfigurationManager::KeyLogging + '.' + ConfigurationManager::PartImmediateFlush;
-    const std::string KeyLogs =
-        ConfigurationManager::KeyLogging + '.' + ConfigurationManager::PartLogs;
+    constexpr const char* KeyLogLevel = ConfigurationManager::KeyLoggingLogLevel;
+    constexpr const char* KeyLogImmediateFlush =
+                                           ConfigurationManager::KeyLoggingImmediateFlush;
+    constexpr const char* KeyLogs = ConfigurationManager::KeyLoggingLogs;
 
     if (configurationManager().hasKeyAndValue<std::string>(KeyLogLevel)) {
         std::string logLevel = "Info";
@@ -993,8 +991,19 @@ void OpenSpaceEngine::writeSceneDocumentation() {
     }
 
     // If a PropertyDocumentationFile was specified, generate it now.
-    if (configurationManager().hasKey(ConfigurationManager::KeyPropertyDocumentation)) {
+    if (configurationManager().hasKey(
+            ConfigurationManager::KeyScenePropertyDocumentation
+        ))
+    {
         _scene->writeDocumentation(
+            absPath(configurationManager().value<std::string>(
+                ConfigurationManager::KeyScenePropertyDocumentation
+                ))
+        );
+    }
+
+    if (configurationManager().hasKey(ConfigurationManager::KeyPropertyDocumentation)) {
+        _rootPropertyOwner->writeDocumentation(
             absPath(configurationManager().value<std::string>(
                 ConfigurationManager::KeyPropertyDocumentation
                 ))
@@ -1141,38 +1150,40 @@ void OpenSpaceEngine::initializeGL() {
                     case GL_INVALID_ENUM:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Function " << f.toString() << ": GL_INVALID_ENUM"
+                            fmt::format("Function {}: GL_INVALID_ENUM", f.toString())
                         );
                         break;
                     case GL_INVALID_VALUE:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Function " << f.toString() << ": GL_INVALID_VALUE"
+                            fmt::format("Function {}: GL_INVALID_VALUE", f.toString())
                         );
                         break;
                     case GL_INVALID_OPERATION:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Function " << f.toString() << ": GL_INVALID_OPERATION"
+                            fmt::format("Function {}: GL_INVALID_OPERATION", f.toString())
                         );
                         break;
                     case GL_INVALID_FRAMEBUFFER_OPERATION:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Function " << f.toString() <<
-                                ": GL_INVALID_FRAMEBUFFER_OPERATION"
+                            fmt::format(
+                                "Function {}: GL_INVALID_FRAMEBUFFER_OPERATION",
+                                f.toString()
+                            )
                         );
                         break;
                     case GL_OUT_OF_MEMORY:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Function " << f.toString() << ": GL_OUT_OF_MEMORY"
+                            fmt::format("Function {}: GL_OUT_OF_MEMORY", f.toString())
                         );
                         break;
                     default:
                         LERRORC(
                             "OpenGL Invalid State",
-                            "Unknown error code: " << std::hex << error
+                            fmt::format("Unknown error code: {0:x}", error)
                         );
                 }
             });
@@ -1189,19 +1200,22 @@ void OpenSpaceEngine::initializeGL() {
             setCallbackMask(CallbackMask::After | CallbackMask::ParametersAndReturnValue);
             glbinding::setAfterCallback([](const glbinding::FunctionCall& call) {
                 std::string arguments = std::accumulate(
-                        call.parameters.begin(),
-                        call.parameters.end(),
-                        std::string("("),
-                        [](std::string a, AbstractValue* v) {
-                            return a + ", " + v->asString();
-                        }
+                    call.parameters.begin(),
+                    call.parameters.end(),
+                    std::string("("),
+                    [](std::string a, AbstractValue* v) {
+                        return a + ", " + v->asString();
+                    }
                 );
 
                 std::string returnValue = call.returnValue ?
                     " -> " + call.returnValue->asString() :
                     "";
 
-                LTRACEC("OpenGL", call.function->name() << arguments << returnValue);
+                LTRACEC(
+                    "OpenGL",
+                    call.function->name() + arguments + returnValue
+                );
             });
         }
     }
@@ -1232,7 +1246,7 @@ void OpenSpaceEngine::preSynchronization() {
     FileSys.triggerFilesystemEvents();
 
     if (_hasScheduledAssetLoading) {
-        LINFO("Loading asset: " << _scheduledAssetPathToLoad);
+        LINFO(fmt::format("Loading asset: {}", _scheduledAssetPathToLoad));
         loadSingleAsset(_scheduledAssetPathToLoad);
         _hasScheduledAssetLoading = false;
         _scheduledAssetPathToLoad = "";
@@ -1284,7 +1298,7 @@ void OpenSpaceEngine::postSynchronizationPreDraw() {
         perf = std::make_unique<performance::PerformanceMeasurement>(
             "OpenSpaceEngine::postSynchronizationPreDraw",
             OsEng.renderEngine().performanceManager()
-            );
+        );
     }
 
     bool master = _windowWrapper->isMaster();
@@ -1325,13 +1339,13 @@ void OpenSpaceEngine::postSynchronizationPreDraw() {
     int fatalCounter = LogMgr.messageCounter(LogLevel::Fatal);
 
     if (warningCounter > 0) {
-        LWARNINGC("Logging", "Number of Warnings raised: " << warningCounter);
+        LWARNINGC("Logging", fmt::format("Number of Warnings: {}", warningCounter));
     }
     if (errorCounter > 0) {
-        LWARNINGC("Logging", "Number of Errors raised: " << errorCounter);
+        LWARNINGC("Logging", fmt::format("Number of Errors: {}", errorCounter));
     }
     if (fatalCounter > 0) {
-        LWARNINGC("Logging", "Number of Fatals raised: " << fatalCounter);
+        LWARNINGC("Logging", fmt::format("Number of Fatals: {}", fatalCounter));
     }
 
     LogMgr.resetMessageCounters();
@@ -1541,8 +1555,8 @@ scripting::LuaLibrary OpenSpaceEngine::luaLibrary() {
                 "addVirtualProperty",
                 &luascriptfunctions::addVirtualProperty,
                 {},
-                "type, name, identifier, description,"
-                "[value, minimumValue, maximumValue]",
+                "type, name, identifier,"
+                "[description, value, minimumValue, maximumValue]",
                 "Adds a virtual property that will set a group of properties"
             },
             {
@@ -1687,11 +1701,6 @@ RenderEngine& OpenSpaceEngine::renderEngine() {
     return *_renderEngine;
 }
 
-SettingsEngine& OpenSpaceEngine::settingsEngine() {
-    ghoul_assert(_settingsEngine, "Settings Engine must not be nullptr");
-    return *_settingsEngine;
-}
-
 TimeManager& OpenSpaceEngine::timeManager() {
     ghoul_assert(_timeManager, "Download Manager must not be nullptr");
     return *_timeManager;
@@ -1727,12 +1736,12 @@ interaction::KeyBindingManager& OpenSpaceEngine::keyBindingManager() {
     return *_keyBindingManager;
 }
 
-properties::PropertyOwner& OpenSpaceEngine::globalPropertyOwner() {
+properties::PropertyOwner& OpenSpaceEngine::rootPropertyOwner() {
     ghoul_assert(
-        _globalPropertyNamespace,
-        "Global Property Namespace must not be nullptr"
-    );
-    return *_globalPropertyNamespace;
+                 _rootPropertyOwner,
+                 "Root Property Namespace must not be nullptr"
+                 );
+    return *_rootPropertyOwner;
 }
 
 VirtualPropertyManager& OpenSpaceEngine::virtualPropertyManager() {
diff --git a/src/engine/openspaceengine_lua.inl b/src/engine/openspaceengine_lua.inl
index 276b5f2afb..081e4be3cc 100644
--- a/src/engine/openspaceengine_lua.inl
+++ b/src/engine/openspaceengine_lua.inl
@@ -141,7 +141,15 @@ int removeVirtualProperty(lua_State* L) {
     const std::string name = lua_tostring(L, -1);
     lua_settop(L, 0);
     properties::Property* p = OsEng.virtualPropertyManager().property(name);
-    OsEng.virtualPropertyManager().removeProperty(p);
+    if (p) {
+        OsEng.virtualPropertyManager().removeProperty(p);
+    }
+    else {
+        LWARNINGC(
+            "removeVirtualProperty",
+            fmt::format("Virtual Property with name {} did not exist", name)
+        );
+    }
     ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
     return 0;
 }
@@ -233,7 +241,7 @@ int downloadFile(lua_State* L) {
     lua_settop(L, 0);
 
     const std::string _loggerCat = "OpenSpaceEngine";
-    LINFO("Downloading file from " << uri);
+    LINFO(fmt::format("Downloading file from {}", uri));
     DownloadManager dm = openspace::DownloadManager(false);
     std::shared_ptr<openspace::DownloadManager::FileFuture> future =
         dm.downloadFile(uri, absPath("${SCENE}/" + savePath), true, true, 5);
diff --git a/src/engine/settingsengine.cpp b/src/engine/settingsengine.cpp
deleted file mode 100644
index b2597c0ada..0000000000
--- a/src/engine/settingsengine.cpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2018                                                               *
- *                                                                                       *
- * 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 <openspace/engine/settingsengine.h>
-
-#include <openspace/engine/openspaceengine.h>
-#include <openspace/engine/configurationmanager.h>
-#include <openspace/engine/wrapper/windowwrapper.h>
-#include <openspace/util/openspacemodule.h>
-#include <openspace/util/spicemanager.h>
-#include <openspace/scene/scene.h>
-
-
-#include <ghoul/ghoul.h>
-#include <ghoul/filesystem/filesystem.h>
-#include <ghoul/logging/logmanager.h>
-
-#include <string>
-
-namespace {
-    static const openspace::properties::Property::PropertyInfo SceneInfo = {
-        "Scenes",
-        "Current Scene",
-        "Specifies the currently loaded scene. If this value is changed it will cause "
-        "the current scene to be unloaded and the newly selected scene to be loaded"
-    };
-
-} // namespace
-
-namespace openspace {
-
-SettingsEngine::SettingsEngine()
-    : properties::PropertyOwner({ "Global Properties" })
-    , _scenes(SceneInfo, properties::OptionProperty::DisplayType::Dropdown)
-{
-    addProperty(_scenes);
-}
-
-void SettingsEngine::initialize() {
-    // Load all matching files in the Scene
-    // TODO: match regex with either with new ghoul readFiles or local code
-    const std::string sceneDir = "${ASSETS}";
-    const std::vector<std::string> scenes =
-        ghoul::filesystem::Directory(sceneDir).readFiles();
-    const size_t nScenes = scenes.size();
-
-    for (std::size_t i = 0; i < nScenes; ++i) {
-        const std::size_t found = scenes[i].find_last_of("/\\");
-        _scenes.addOption(static_cast<int>(i), scenes[i].substr(found + 1));
-    }
-    _scenes.addOption(static_cast<int>(scenes.size()), "None");
-
-    // Set interaction to change ConfigurationManager and schedule the load
-    _scenes.onChange([this, nScenes, sceneDir]() {
-        if (_scenes == static_cast<int>(nScenes)) {
-            OsEng.scheduleLoadSingleAsset("");
-        } else {
-            std::string sceneFile = _scenes.getDescriptionByValue(_scenes);
-            OsEng.configurationManager().setValue(
-                ConfigurationManager::KeyConfigAsset, sceneFile);
-            OsEng.scheduleLoadSingleAsset(sceneDir + "/" + sceneFile);
-        }
-    }
-    );
-}
-
-void SettingsEngine::setModules(const std::vector<OpenSpaceModule*>& modules) {
-    for (OpenSpaceModule* m : modules) {
-        addPropertySubOwner(m);
-    }
-}
-
-}  // namespace openspace
diff --git a/src/interaction/keybindingmanager.cpp b/src/interaction/keybindingmanager.cpp
index 9c2827334f..b0b0cecb0a 100644
--- a/src/interaction/keybindingmanager.cpp
+++ b/src/interaction/keybindingmanager.cpp
@@ -159,7 +159,7 @@ std::string KeyBindingManager::generateJson() const {
         first = false;
         json << "{";
         json << "\"key\": \"" << std::to_string(p.first) << "\",";
-        json << "\"script\": \"" << p.second.command << "\",";
+        json << "\"script\": \"" << escapedJson(p.second.command) << "\",";
         json << "\"remoteScripting\": "
              << (p.second.synchronization ? "true," : "false,");
         json << "\"documentation\": \"" << escapedJson(p.second.documentation) << "\"";
@@ -167,16 +167,7 @@ std::string KeyBindingManager::generateJson() const {
     }
     json << "]";
 
-    std::string jsonString = "";
-    for (const char& c : json.str()) {
-        if (c == '\'') {
-            jsonString += "\\'";
-        } else {
-            jsonString += c;
-        }
-    }
-
-    return jsonString;
+    return json.str();
 }
 
 scripting::LuaLibrary KeyBindingManager::luaLibrary() {
diff --git a/src/interaction/keybindingmanager_lua.inl b/src/interaction/keybindingmanager_lua.inl
index 6dfece8285..38bdb9b17b 100644
--- a/src/interaction/keybindingmanager_lua.inl
+++ b/src/interaction/keybindingmanager_lua.inl
@@ -50,7 +50,7 @@ int bindKey(lua_State* L) {
     openspace::KeyWithModifier iKey = openspace::stringToKey(key);
 
     if (iKey.key == openspace::Key::Unknown) {
-        LERRORC("lua.bindKey", "Could not find key '"<< key << "'");
+        LERRORC("lua.bindKey", fmt::format("Could not find key '{}'", key));
         return 0;
     }
 
@@ -96,7 +96,7 @@ int bindKeyLocal(lua_State* L) {
     openspace::KeyWithModifier iKey = openspace::stringToKey(key);
 
     if (iKey.key == openspace::Key::Unknown) {
-        LERRORC("lua.bindKey", "Could not find key '" << key << "'");
+        LERRORC("lua.bindKey", fmt::format("Could not find key '{}'", key));
         return 0;
     }
 
diff --git a/src/interaction/luaconsole.cpp b/src/interaction/luaconsole.cpp
index 180ef6ba37..50c232c23d 100644
--- a/src/interaction/luaconsole.cpp
+++ b/src/interaction/luaconsole.cpp
@@ -198,7 +198,7 @@ void LuaConsole::initialize() {
             if (version != CurrentVersion) {
                 LWARNINGC(
                     "LuaConsole",
-                    "Outdated console history version: " << version
+                    fmt::format("Outdated console history version: {}", version)
                 );
             }
             else {
diff --git a/src/interaction/navigationhandler.cpp b/src/interaction/navigationhandler.cpp
index dbe74a635c..59e5298af6 100644
--- a/src/interaction/navigationhandler.cpp
+++ b/src/interaction/navigationhandler.cpp
@@ -32,6 +32,7 @@
 #include <openspace/util/time.h>
 #include <openspace/util/keys.h>
 
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/dictionary.h>
@@ -80,9 +81,9 @@ NavigationHandler::NavigationHandler()
 
         SceneGraphNode* node = sceneGraphNode(_origin.value());
         if (!node) {
-            LWARNING(
-                "Could not find a node in scenegraph called '" << _origin.value() << "'"
-            );
+            LWARNING(fmt::format(
+                "Could not find a node in scenegraph called '{}'", _origin.value()
+            ));
             return;
         }
         setFocusNode(node);
@@ -248,7 +249,7 @@ ghoul::Dictionary NavigationHandler::getCameraStateDictionary() {
 void NavigationHandler::saveCameraStateToFile(const std::string& filepath) {
     if (!filepath.empty()) {
         std::string fullpath = absPath(filepath);
-        LINFO("Saving camera position: " << filepath);
+        LINFO(fmt::format("Saving camera position: {}", filepath));
 
         ghoul::Dictionary cameraDict = getCameraStateDictionary();
 
@@ -279,7 +280,7 @@ void NavigationHandler::saveCameraStateToFile(const std::string& filepath) {
 }
 
 void NavigationHandler::restoreCameraStateFromFile(const std::string& filepath) {
-    LINFO("Reading camera state from file: " << filepath);
+    LINFO(fmt::format("Reading camera state from file: {}", filepath));
     if (!FileSys.fileExists(filepath))
         throw ghoul::FileNotFoundError(filepath, "CameraFilePath");
 
diff --git a/src/interaction/navigationhandler_lua.inl b/src/interaction/navigationhandler_lua.inl
index 9839d56fe1..8ad65f406e 100644
--- a/src/interaction/navigationhandler_lua.inl
+++ b/src/interaction/navigationhandler_lua.inl
@@ -79,7 +79,7 @@ int saveCameraStateToFile(lua_State* L) {
 
 int resetCameraDirection(lua_State* L) {
     ghoul::lua::checkArgumentsAndThrow(L, 0, "lua::resetCameraDirection");
-    
+
     using ghoul::lua::luaTypeToString;
 
     OsEng.navigationHandler().resetCameraDirection();
diff --git a/src/interaction/touchbar.mm b/src/interaction/touchbar.mm
index 32802d4bf9..13603d2247 100644
--- a/src/interaction/touchbar.mm
+++ b/src/interaction/touchbar.mm
@@ -191,14 +191,14 @@ NSArray* focusIdentifiers;
         (void)sender;
         OsEng.scriptEngine().queueScript(
             "local b = openspace.getPropertyValue(\
-                'Global Properties.ImGUI.Main.Enabled'\
+                'Modules.ImGUI.Main.Enabled'\
             );\
             openspace.setPropertyValueSingle(\
-                'Global Properties.ImGUI.Main.Enabled',\
+                'Modules.ImGUI.Main.Enabled',\
                 not b\
             );\
             openspace.setPropertyValueSingle(\
-                'Global Properties.ImGUI.Main.IsHidden',\
+                'Modules.ImGUI.Main.IsHidden',\
                 b\
             );",
             openspace::scripting::ScriptEngine::RemoteScripting::No
@@ -209,32 +209,32 @@ NSArray* focusIdentifiers;
         // Remove unused variable warning
         (void)sender;
         OsEng.scriptEngine().queueScript(
-"local b = openspace.getPropertyValue('Global Properties.ImGUI.Main.Properties.Enabled');\n\
-local c = openspace.getPropertyValue('Global Properties.ImGUI.Main.IsHidden');\n\
-openspace.setPropertyValue('Global Properties.ImGUI.*.Enabled', false);\n\
+"local b = openspace.getPropertyValue('Modules.ImGUI.Main.Properties.Enabled');\n\
+local c = openspace.getPropertyValue('Modules.ImGUI.Main.IsHidden');\n\
+openspace.setPropertyValue('Modules.ImGUI.*.Enabled', false);\n\
 if b and c then\n\
     -- This can happen if the main properties window is enabled, the main gui\n\
     -- is enabled and then closed again. So the main properties window is\n\
     -- enabled, but also all windows are hidden\n\
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', false);\n\
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.IsHidden', false);\n\
     openspace.setPropertyValueSingle(\n\
-        'Global Properties.ImGUI.Main.Properties.Enabled',\n\
+        'Modules.ImGUI.Main.Properties.Enabled',\n\
         true\n\
     );\n\
     openspace.setPropertyValueSingle(\n\
-        'Global Properties.ImGUI.Main.Space/Time.Enabled',\n\
+        'Modules.ImGUI.Main.Space/Time.Enabled',\n\
         true\n\
     );\n\
 else\n\
     openspace.setPropertyValueSingle(\n\
-        'Global Properties.ImGUI.Main.Properties.Enabled',\n\
+        'Modules.ImGUI.Main.Properties.Enabled',\n\
         not b\n\
     );\n\
     openspace.setPropertyValueSingle(\n\
-        'Global Properties.ImGUI.Main.Space/Time.Enabled',\n\
+        'Modules.ImGUI.Main.Space/Time.Enabled',\n\
         not b\n\
     );\n\
-    openspace.setPropertyValueSingle('Global Properties.ImGUI.Main.IsHidden', b);\n\
+    openspace.setPropertyValueSingle('Modules.ImGUI.Main.IsHidden', b);\n\
 end",
             openspace::scripting::ScriptEngine::RemoteScripting::No
         );
diff --git a/src/mission/mission.cpp b/src/mission/mission.cpp
index 1f7fb1da25..ad9795fc3e 100644
--- a/src/mission/mission.cpp
+++ b/src/mission/mission.cpp
@@ -26,6 +26,7 @@
 
 #include <openspace/documentation/verifier.h>
 
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/lua/lua_helper.h>
 
diff --git a/src/mission/missionmanager.cpp b/src/mission/missionmanager.cpp
index 3dc66b4e2b..ca38c88c84 100644
--- a/src/mission/missionmanager.cpp
+++ b/src/mission/missionmanager.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/mission/missionmanager.h>
 
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/scripting/scriptengine.h>
diff --git a/src/mission/missionmanager_lua.inl b/src/mission/missionmanager_lua.inl
index 24b998e230..8ea5caaf23 100644
--- a/src/mission/missionmanager_lua.inl
+++ b/src/mission/missionmanager_lua.inl
@@ -31,7 +31,7 @@ int loadMission(lua_State* L) {
     if (missionFileName.empty()) {
         return luaL_error(L, "Filepath is empty");
     }
-    
+
     std::string name = MissionManager::ref().loadMission(absPath(missionFileName));
     lua_pushstring(L, name.c_str());
 
@@ -64,7 +64,7 @@ int hasMission(lua_State* L) {
     if (missionName.empty()) {
         return luaL_error(L, "Missing name is empty");
     }
-    
+
     bool hasMission = MissionManager::ref().hasMission(missionName);
 
     lua_pushboolean(L, hasMission);
diff --git a/src/network/networkengine.cpp b/src/network/networkengine.cpp
index fc250462af..9cd1097094 100644
--- a/src/network/networkengine.cpp
+++ b/src/network/networkengine.cpp
@@ -84,7 +84,7 @@ bool NetworkEngine::handleMessage(const std::string& message) {
             return true;
         }
         default:
-            LERROR("Unknown type '" << type << "'");
+            LERROR(fmt::format("Unknown type '{}'", type));
             return false;
         }
 }
@@ -217,9 +217,9 @@ void NetworkEngine::sendInitialInformation() {
         std::vector<char> payload = m.body;
         payload.insert(payload.begin(), identifier.data.begin(), identifier.data.end());
         OsEng.windowWrapper().sendMessageToExternalControl(payload);
-        LINFO("Sent initial message: (s=" << m.body.size() << ")" <<
-              "[i=" << identifier.value << "]"
-        );
+        LINFO(fmt::format(
+            "Sent initial message: (s={}) [i={}]", m.body.size(), identifier.value
+        ));
 
         std::this_thread::sleep_for(std::chrono::milliseconds(SleepTime));
     }
diff --git a/src/network/parallelconnection.cpp b/src/network/parallelconnection.cpp
index b8672de32b..153aeb781f 100644
--- a/src/network/parallelconnection.cpp
+++ b/src/network/parallelconnection.cpp
@@ -400,7 +400,10 @@ void ParallelConnection::establishConnection(addrinfo *info) {
         sizeof(int)
     );
     if (result == SOCKET_ERROR) {
-        LERROR("Failed to set socket option 'reuse address'. Error code: " << _ERRNO);
+        LERROR(fmt::format(
+            "Failed to set socket option 'reuse address'. Error code: {}",
+            _ERRNO
+        ));
     }
 
     result = setsockopt(
@@ -411,17 +414,27 @@ void ParallelConnection::establishConnection(addrinfo *info) {
         sizeof(int)
     );
     if (result == SOCKET_ERROR) {
-        LERROR("Failed to set socket option 'keep alive'. Error code: " << _ERRNO);
+        LERROR(fmt::format(
+            "Failed to set socket option 'keep alive'. Error code: {}",
+            _ERRNO
+        ));
     }
 
-    LINFO("Attempting to connect to server "<< _address << " on port " << _port);
+    LINFO(fmt::format(
+        "Attempting to connect to server {} on port {}",
+        _address.value(),
+        _port.value()
+    ));
 
     // Try to connect
     result = connect(_clientSocket, info->ai_addr, static_cast<int>(info->ai_addrlen));
 
     // If the connection was successfull
     if (result != SOCKET_ERROR) {
-        LINFO("Connection established with server at ip: "<< _address);
+        LINFO(fmt::format(
+            "Connection established with server at ip: {}",
+            _address.value()
+        ));
 
         // We're connected
         _isConnected = true;
@@ -677,9 +690,10 @@ void ParallelConnection::dataMessageReceived(const std::vector<char>& messageCon
             break;
         }
         default: {
-            LERROR("Unidentified data message with identifier " << type <<
-                   " received in parallel connection."
-            );
+            LERROR(fmt::format(
+                "Unidentified message with identifier {} received in parallel connection",
+                type
+            ));
             break;
         }
     }
@@ -761,10 +775,11 @@ void ParallelConnection::sendFunc() {
             );
 
             if (result == SOCKET_ERROR) {
-                LERROR(
-                    "Failed to send message.\nError: " <<
-                    _ERRNO << " detected in connection, disconnecting."
-                );
+                LERROR(fmt::format(
+                    "Failed to send message. Error {} detected in connection"
+                    "; disconnecting",
+                    _ERRNO
+                ));
                 signalDisconnect();
             }
 
@@ -941,10 +956,10 @@ void ParallelConnection::listenCommunication() {
         // If enough data was received
         if (nBytesRead <= 0) {
             if (!_disconnect) {
-                LERROR(
-                    "Error " << _ERRNO <<
-                    " detected in connection when reading header, disconnecting!"
-                );
+                LERROR(fmt::format(
+                    "Error {} detected in connection when reader header; disconnecting!",
+                    _ERRNO
+                ));
                 signalDisconnect();
             }
             break;
@@ -964,10 +979,11 @@ void ParallelConnection::listenCommunication() {
         uint32_t messageSizeIn = *(ptr++);
 
         if (protocolVersionIn != ProtocolVersion) {
-            LERROR(
-                "Protocol versions do not match. Server version: " <<
-                protocolVersionIn << ", Client version: " << ProtocolVersion
-            );
+            LERROR(fmt::format(
+                "Protocol versions do not match. Server version: {}, Client version: {}",
+                protocolVersionIn,
+                ProtocolVersion
+            ));
             signalDisconnect();
             break;
         }
@@ -985,9 +1001,10 @@ void ParallelConnection::listenCommunication() {
 
         if (nBytesRead <= 0) {
             if (!_disconnect) {
-                LERROR(
-                    "Error " << _ERRNO <<
-                    " detected in connection when reading message, disconnecting!");
+                LERROR(fmt::format(
+                    "Error {} detected in connection when reading message; disconnecting",
+                    _ERRNO
+                ));
                 signalDisconnect();
             }
             break;
diff --git a/src/performance/performancemanager.cpp b/src/performance/performancemanager.cpp
index c8aa7093e5..c5f49f89c0 100644
--- a/src/performance/performancemanager.cpp
+++ b/src/performance/performancemanager.cpp
@@ -36,6 +36,7 @@
 #include <cstring>
 #include <iostream>
 #include <fstream>
+#include <ghoul/fmt.h>
 
 namespace {
     constexpr const char* _loggerCat = "PerformanceManager";
@@ -78,10 +79,11 @@ void PerformanceManager::createGlobalSharedMemory() {
         sharedMemory.acquireLock();
         GlobalMemory* m = reinterpret_cast<GlobalMemory*>(sharedMemory.memory());
         ++(m->referenceCount);
-        LINFO(
+        LINFO(fmt::format(
             "Using global shared memory block for performance measurements. "
-            "Reference count: " << int(m->referenceCount)
-        );
+            "Reference count: {}",
+            int(m->referenceCount)
+        ));
         sharedMemory.releaseLock();
     }
     else {
@@ -110,7 +112,10 @@ void PerformanceManager::destroyGlobalSharedMemory() {
     sharedMemory.acquireLock();
     GlobalMemory* m = reinterpret_cast<GlobalMemory*>(sharedMemory.memory());
     --(m->referenceCount);
-    LINFO("Global shared performance memory reference count: " << int(m->referenceCount));
+    LINFO(fmt::format(
+        "Global shared performance memory reference count: {}",
+        int(m->referenceCount)
+    ));
     if (m->referenceCount == 0) {
         LINFO("Removing global shared performance memory");
 
@@ -120,7 +125,7 @@ void PerformanceManager::destroyGlobalSharedMemory() {
         for (int i = 0; i < std::numeric_limits<uint8_t>::max(); ++i) {
             std::string localName = LocalSharedMemoryNameBase + std::to_string(i);
             if (SharedMemory::exists(localName)) {
-                LINFO("Removing shared memory: " << localName);
+                LINFO(fmt::format("Removing shared memory: {}", localName));
                 SharedMemory::remove(localName);
             }
         }
@@ -156,7 +161,11 @@ PerformanceManager::PerformanceManager(std::string loggingDirectory, std::string
 
     // Compute the total size
     const int totalSize = sizeof(PerformanceLayout);
-    LINFO("Create shared memory '" + localName + "' of " << totalSize << " bytes");
+    LINFO(fmt::format(
+        "Create shared memory '{}' of {} bytes",
+        localName,
+        totalSize
+    ));
 
     if (ghoul::SharedMemory::exists(localName)) {
         throw ghoul::RuntimeError(
@@ -183,7 +192,7 @@ PerformanceManager::~PerformanceManager() {
         --(m->number);
         sharedMemory.releaseLock();
 
-        LINFO("Remove shared memory '" << _performanceMemory->name() << "'");
+        LINFO(fmt::format("Remove shared memory '{}'", _performanceMemory->name()));
         ghoul::SharedMemory::remove(_performanceMemory->name());
 
         _performanceMemory = nullptr;
@@ -321,7 +330,7 @@ bool PerformanceManager::createLogDir() {
         FileSys.createDirectory(dir, ghoul::filesystem::FileSystem::Recursive::Yes);
     }
     catch (const ghoul::filesystem::FileSystem::FileSystemException& e) {
-        LERROR("Could not create log directory: " << e.message);
+        LERROR(fmt::format("Could not create log directory: {}", e.message));
         return false;
     }
     return true;
diff --git a/src/properties/optionproperty.cpp b/src/properties/optionproperty.cpp
index 874caa07ef..752bae34d8 100644
--- a/src/properties/optionproperty.cpp
+++ b/src/properties/optionproperty.cpp
@@ -60,9 +60,12 @@ void OptionProperty::addOption(int value, std::string desc) {
 
     for (const Option& o : _options) {
         if (o.value == option.value) {
-            LWARNING("The value of option {" << o.value << " -> " << o.description <<
-                "} was already registered when trying to add option {" << option.value <<
-                " -> " << option.description << "}");
+            LWARNING(fmt::format(
+                "The value of option {{ {} -> {} }} was already registered when trying "
+                "to add option {{ {} -> {} }}",
+                o.value, o.description, option.value, option.description
+
+            ));
             return;
         }
     }
@@ -92,7 +95,7 @@ void OptionProperty::setValue(int value) {
     }
 
     // Otherwise, log an error
-    LERROR("Could not find an option for value '" << value << "' in OptionProperty");
+    LERROR(fmt::format("Could not find an option for value '{}'", value));
 }
 
 bool OptionProperty::hasOption() const {
diff --git a/src/properties/property.cpp b/src/properties/property.cpp
index 5a111b3930..59fe749cbb 100644
--- a/src/properties/property.cpp
+++ b/src/properties/property.cpp
@@ -250,4 +250,9 @@ std::string Property::generateAdditionalDescription() const {
     return "";
 }
 
+void Property::setInterpolationTarget(ghoul::any) {}
+void Property::setLuaInterpolationTarget(lua_State*) {}
+void Property::setStringInterpolationTarget(std::string) {}
+void Property::interpolateValue(float, ghoul::EasingFunc<float>) {}
+
 } // namespace openspace::properties
diff --git a/src/properties/propertyowner.cpp b/src/properties/propertyowner.cpp
index 48e61cc081..d7a4e21729 100644
--- a/src/properties/propertyowner.cpp
+++ b/src/properties/propertyowner.cpp
@@ -25,10 +25,11 @@
 #include <openspace/properties/propertyowner.h>
 
 #include <openspace/properties/property.h>
+#include <ghoul/fmt.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/assert.h>
-
 #include <algorithm>
+#include <numeric>
 
 namespace openspace::properties {
 
@@ -38,7 +39,26 @@ namespace {
 
 
 PropertyOwner::PropertyOwner(PropertyOwnerInfo info)
-    : _name(std::move(info.name))
+    : DocumentationGenerator(
+        "Documented",
+        "propertyOwners",
+        {
+            {
+                "mainTemplate",
+                "${WEB}/properties/main.hbs"
+            },
+            {
+                "propertyOwnerTemplate",
+                "${WEB}/properties/propertyowner.hbs"
+            },
+            {
+                "propertyTemplate",
+                "${WEB}/properties/property.hbs"
+            }
+        },
+        "${WEB}/properties/script.js"
+    )
+    , _name(std::move(info.name))
     , _description(std::move(info.description))
     , _owner(nullptr)
 {}
@@ -154,15 +174,20 @@ void PropertyOwner::addProperty(Property* prop) {
 
     // If we found the property identifier, we need to bail out
     if (it != _properties.end() && (*it)->identifier() == prop->identifier()) {
-        LERROR("Property identifier '" << prop->identifier() <<
-            "' already present in PropertyOwner '" << name() << "'");
+        LERROR(fmt::format(
+            "Property identifier '{}' already present in PropertyOwner '{}'",
+            prop->identifier(),
+            name()
+        ));
         return;
     } else {
         // Otherwise we still have to look if there is a PropertyOwner with the same name
         const bool hasOwner = hasPropertySubOwner(prop->identifier());
         if (hasOwner) {
-            LERROR("Property identifier '" << prop->identifier() << "' already names a "
-                << "registed PropertyOwner");
+            LERROR(fmt::format(
+                "Property identifier '{}' already names a registered PropertyOwner",
+                prop->identifier()
+            ));
             return;
         }
         else {
@@ -189,15 +214,19 @@ void PropertyOwner::addPropertySubOwner(openspace::properties::PropertyOwner* ow
 
     // If we found the propertyowner's name, we need to bail out
     if (it != _subOwners.end() && (*it)->name() == owner->name()) {
-        LERROR("PropertyOwner '" << owner->name() <<
-            "' already present in PropertyOwner '" << name() << "'");
+        LERROR(fmt::format(
+            "PropertyOwner '{}' already present in PropertyOwner '{}'",
+            owner->name(),
+            name()
+        ));
         return;
     } else {
         // We still need to check if the PropertyOwners name is used in a Property
         const bool hasProp = hasProperty(owner->name());
         if (hasProp) {
-            LERROR("PropertyOwner '" << owner->name() << "'s name already names a "
-                 << "Property");
+            LERROR(fmt::format(
+                "PropertyOwner '{}'s name already names a Property", owner->name()
+            ));
             return;
         }
         else {
@@ -226,8 +255,9 @@ void PropertyOwner::removeProperty(Property* prop) {
         (*it)->setPropertyOwner(nullptr);
         _properties.erase(it);
     } else {
-        LERROR("Property with identifier '" << prop->identifier() <<
-            "' not found for removal.");
+        LERROR(fmt::format(
+            "Property with identifier '{}' not found for removal", prop->identifier()
+        ));
     }
 }
 
@@ -249,8 +279,9 @@ void PropertyOwner::removePropertySubOwner(openspace::properties::PropertyOwner*
     if (it != _subOwners.end() && (*it)->name() == owner->name()) {
         _subOwners.erase(it);
     } else {
-        LERROR("PropertyOwner with name '" << owner->name() <<
-            "' not found for removal.");
+        LERROR(fmt::format(
+            "PropertyOwner with name '{}' not found for removal", owner->name()
+        ));
     }
 }
 
@@ -289,4 +320,62 @@ void PropertyOwner::removeTag(const std::string& tag) {
     );
 }
 
+std::string PropertyOwner::generateJson() const {
+    std::function<std::string(properties::PropertyOwner*)> createJson =
+        [&createJson](properties::PropertyOwner* owner) -> std::string
+    {
+        std::stringstream json;
+        json << "{";
+        json << "\"name\": \"" << owner->name() << "\",";
+
+        json << "\"properties\": [";
+        auto properties = owner->properties();
+        for (properties::Property* p : properties) {
+            json << "{";
+            json << "\"id\": \"" << p->identifier() << "\",";
+            json << "\"type\": \"" << p->className() << "\",";
+            json << "\"fullyQualifiedId\": \"" << p->fullyQualifiedIdentifier() << "\",";
+            json << "\"guiName\": \"" << p->guiName() << "\",";
+            json << "\"description\": \"" << escapedJson(p->description()) << "\"";
+            json << "}";
+            if (p != properties.back()) {
+                json << ",";
+            }
+        }
+        json << "],";
+
+        json << "\"propertyOwners\": [";
+        auto propertyOwners = owner->propertySubOwners();
+        for (properties::PropertyOwner* o : propertyOwners) {
+            json << createJson(o);
+            if (o != propertyOwners.back()) {
+                json << ",";
+            }
+        }
+        json << "]";
+        json << "}";
+
+        return json.str();
+    };
+
+
+    std::stringstream json;
+    json << "[";
+    std::vector<PropertyOwner*> subOwners = propertySubOwners();
+    if (!subOwners.empty()) {
+        json << std::accumulate(
+            std::next(subOwners.begin()),
+            subOwners.end(),
+            createJson(*subOwners.begin()),
+            [createJson](std::string a, PropertyOwner* n) {
+            return a + "," + createJson(n);
+        }
+        );
+    }
+
+    json << "]";
+
+    return json.str();
+}
+
 } // namespace openspace::properties
diff --git a/src/properties/selectionproperty.cpp b/src/properties/selectionproperty.cpp
index 00e4b0b321..34f94969ec 100644
--- a/src/properties/selectionproperty.cpp
+++ b/src/properties/selectionproperty.cpp
@@ -46,9 +46,10 @@ void SelectionProperty::addOption(Option option) {
         if (o.value == option.value) {
             LWARNINGC(
                 "SelectionProperty",
-                "The value of option {" << o.value << " -> " << o.description <<
-                "} was already registered when trying to add option {" << option.value <<
-                " -> " << option.description << "}"
+                fmt::format("The value of option {{ {} -> {} }} was already registered "
+                    "when trying to add option {{ {} -> {} }}",
+                    o.value, o.description, option.value, option.description
+                )
             );
             return;
         }
diff --git a/src/query/query.cpp b/src/query/query.cpp
index 220f3f2c82..61e51c4ed6 100644
--- a/src/query/query.cpp
+++ b/src/query/query.cpp
@@ -37,10 +37,6 @@
 #include <modules/iswa/util/iswamanager.h>
 #include <modules/iswa/rendering/iswacygnet.h>
 
-namespace {
-    constexpr const char* _loggerCat = "Query";
-} // namespace
-
 namespace openspace {
 
 Scene* sceneGraph() {
@@ -58,51 +54,15 @@ Renderable* renderable(const std::string& name) {
 }
 
 properties::Property* property(const std::string& uri) {
-    properties::Property* globalProp = OsEng.globalPropertyOwner().property(uri);
-    if (globalProp) {
-        return globalProp;
-    }
-    else {
-        // The URI consists of the following form at this stage:
-        // <node name>.{<property owner>.}^(0..n)<property id>
-        const size_t nameSeparator = uri.find(properties::PropertyOwner::URISeparator);
-        if (nameSeparator == std::string::npos) {
-            LERROR("Malformed URI '" << uri << "': At least one '" << nameSeparator
-                   << "' separator must be present.");
-            return nullptr;
-        }
-        const std::string nameUri = uri.substr(0, nameSeparator);
-        const std::string remainingUri = uri.substr(nameSeparator + 1);
-
-        SceneGraphNode* node = sceneGraphNode(nameUri);
-        if (node) {
-            properties::Property* property = node->property(remainingUri);
-            return property;
-        }
-
-        std::shared_ptr<ScreenSpaceRenderable> ssr =
-            OsEng.renderEngine().screenSpaceRenderable(nameUri);
-        if (ssr) {
-            properties::Property* property = ssr->property(remainingUri);
-            return property;
-        }
-#ifdef OPENSPACE_MODULE_ISWA_ENABLED
-        std::shared_ptr<IswaBaseGroup> group = IswaManager::ref().iswaGroup(nameUri);
-        if(group){
-            properties::Property* property = group->property(remainingUri);
-            return property;
-        }
-#endif
-        LERROR("Node or ScreenSpaceRenderable' " << nameUri << "' did not exist");
-        return nullptr;
-    }
+    properties::Property* property = OsEng.rootPropertyOwner().property(uri);
+    return property;
 }
 
 std::vector<properties::Property*> allProperties() {
     std::vector<properties::Property*> properties;
 
     std::vector<properties::Property*> p =
-        OsEng.globalPropertyOwner().propertiesRecursive();
+        OsEng.rootPropertyOwner().propertiesRecursive();
 
     properties.insert(
         properties.end(),
@@ -110,31 +70,7 @@ std::vector<properties::Property*> allProperties() {
         p.end()
     );
 
-    std::vector<properties::Property*> q =
-        OsEng.virtualPropertyManager().propertiesRecursive();
-
-    properties.insert(
-        properties.end(),
-        q.begin(),
-        q.end()
-    );
-
-    const Scene* graph = sceneGraph();
-    if (graph) {
-        std::vector<SceneGraphNode*> nodes = graph->allSceneGraphNodes();
-
-        for (SceneGraphNode* n : nodes) {
-            std::vector<properties::Property*> props = n->propertiesRecursive();
-            properties.insert(
-                properties.end(),
-                props.begin(),
-                props.end()
-            );
-        }
-    }
-
     return properties;
 }
 
-
 }  // namespace
diff --git a/src/rendering/abufferrenderer.cpp b/src/rendering/abufferrenderer.cpp
index 7cf0de7b5f..0545a6a664 100644
--- a/src/rendering/abufferrenderer.cpp
+++ b/src/rendering/abufferrenderer.cpp
@@ -951,10 +951,11 @@ void ABufferRenderer::updateRaycastData() {
     for (auto &raycaster : raycasters) {
         if (nextId > MaxRaycasters) {
             int nIgnored = MaxRaycasters - static_cast<int>(raycasters.size());
-            LWARNING(
-                "ABufferRenderer does not support more than 32 raycasters. " <<
-                "Ignoring " << nIgnored << " raycasters"
-            );
+            LWARNING(fmt::format(
+                "ABufferRenderer does not support more than 32 raycasters. "
+                "Ignoring {} raycasters",
+                nIgnored
+            ));
             break;
         }
 
diff --git a/src/rendering/dashboard.cpp b/src/rendering/dashboard.cpp
index 8bf9f3a158..51efdf8e40 100644
--- a/src/rendering/dashboard.cpp
+++ b/src/rendering/dashboard.cpp
@@ -30,11 +30,23 @@
 #include <ghoul/misc/assert.h>
 #include "dashboard_lua.inl"
 
+namespace {
+    static const openspace::properties::Property::PropertyInfo EnabledInfo = {
+        "IsEnabled",
+        "Enabled",
+        "If this value is 'false', this dashboard will be invisible, regardless of the "
+        "state of the individual components"
+    };
+} // namespace
+
 namespace openspace {
 
 Dashboard::Dashboard()
     : properties::PropertyOwner({ "Dashboard" })
-{}
+    , _isEnabled(EnabledInfo, true)
+{
+    addProperty(_isEnabled);
+}
 
 void Dashboard::addDashboardItem(std::unique_ptr<DashboardItem> item) {
     std::string originalName = item->name();
@@ -85,6 +97,10 @@ void Dashboard::removeDashboardItems() {
 }
 
 void Dashboard::render(glm::vec2& penPosition) {
+    if (!_isEnabled) {
+        return;
+    }
+
     for (const std::unique_ptr<DashboardItem>& item : _items) {
         if (item->isEnabled()) {
             item->render(penPosition);
diff --git a/src/rendering/renderable.cpp b/src/rendering/renderable.cpp
index 6ab6e314c4..b30d62e5fe 100644
--- a/src/rendering/renderable.cpp
+++ b/src/rendering/renderable.cpp
@@ -37,7 +37,6 @@
 #include <ghoul/opengl/programobject.h>
 
 namespace {
-    constexpr const char* _loggerCat = "Renderable";
     constexpr const char* keyStart = "StartTime";
     constexpr const char* keyEnd = "EndTime";
     constexpr const char* KeyType = "Type";
@@ -48,6 +47,12 @@ namespace {
         "Is Enabled",
         "This setting determines whether this object will be visible or not."
     };
+
+    static const openspace::properties::Property::PropertyInfo OpacityInfo = {
+        "Opacity",
+        "Transparency",
+        "This value determines the transparency of this object."
+    };
 } // namespace
 
 namespace openspace {
@@ -59,21 +64,27 @@ documentation::Documentation Renderable::Documentation() {
         "Renderable",
         "renderable",
         {
-        {
-            KeyType,
-            new StringAnnotationVerifier("A valid Renderable created by a factory"),
-            Optional::No,
-            "This key specifies the type of Renderable that gets created. It has to be "
-            "one of the valid Renderables that are available for creation (see the "
-            "FactoryDocumentation for a list of possible Renderables), which depends on "
-            "the configration of the application"
-        },
-        {
-            EnabledInfo.identifier,
-            new BoolVerifier,
-            Optional::Yes,
-            EnabledInfo.description
-        }
+            {
+                KeyType,
+                new StringAnnotationVerifier("A valid Renderable created by a factory"),
+                Optional::No,
+                "This key specifies the type of Renderable that gets created. It has to "
+                "be one of the valid Renderables that are available for creation (see "
+                "the FactoryDocumentation for a list of possible Renderables), which "
+                "depends on the configration of the application"
+            },
+            {
+                EnabledInfo.identifier,
+                new BoolVerifier,
+                Optional::Yes,
+                EnabledInfo.description
+            },
+            {
+                OpacityInfo.identifier,
+                new DoubleInRangeVerifier(0.0, 1.0),
+                Optional::Yes,
+                OpacityInfo.description
+            }
         }
     };
 }
@@ -95,17 +106,13 @@ std::unique_ptr<Renderable> Renderable::createFromDictionary(
     auto factory = FactoryManager::ref().factory<Renderable>();
     ghoul_assert(factory, "Renderable factory did not exist");
     std::unique_ptr<Renderable> result = factory->create(renderableType, dictionary);
-    if (result == nullptr) {
-        LERROR("Failed to create a Renderable object of type '" << renderableType << "'");
-        return nullptr;
-    }
-
     return result;
 }
 
 Renderable::Renderable(const ghoul::Dictionary& dictionary)
     : properties::PropertyOwner({ "renderable" })
     , _enabled(EnabledInfo, true)
+    , _opacity(OpacityInfo, 1.f, 0.f, 1.f)
     , _renderBin(RenderBin::Opaque)
     , _startTime("")
     , _endTime("")
@@ -136,7 +143,7 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary)
         }
     }
 
-    if (_startTime != "" && _endTime != "") {
+    if (!_startTime.empty() && !_endTime.empty()) {
         _hasTimeInterval = true;
     }
 
@@ -144,6 +151,10 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary)
         _enabled = dictionary.value<bool>(EnabledInfo.identifier);
     }
 
+    if (dictionary.hasKey(OpacityInfo.identifier)) {
+        _opacity = static_cast<float>(dictionary.value<double>(OpacityInfo.identifier));
+    }
+
     addProperty(_enabled);
 }
 
@@ -235,4 +246,15 @@ void Renderable::onEnabledChange(std::function<void(bool)> callback) {
     });
 }
 
+void Renderable::registerUpdateRenderBinFromOpacity() {
+    _opacity.onChange([this](){
+        if (_opacity > 0.f && _opacity < 1.f) {
+            setRenderBin(Renderable::RenderBin::Transparent);
+        }
+        else {
+            setRenderBin(Renderable::RenderBin::Opaque);
+        }
+    });
+}
+
 }  // namespace openspace
diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index 18cb13d7f4..fac337db8c 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -74,6 +74,10 @@
 #include <ghoul/io/texture/texturewritersoil.h>
 #endif //GHOUL_USE_SOIL
 
+#ifdef GHOUL_USE_STB
+#include <ghoul/io/texture/texturereaderstb.h>
+#endif // GHOUL_USE_STB
+
 #include <array>
 #include <stack>
 
@@ -257,16 +261,14 @@ RenderEngine::RenderEngine()
         if (_doPerformanceMeasurements) {
             if (!_performanceManager) {
                 std::string loggingDir = "${BASE}";
-
-                const std::string KeyDir = ConfigurationManager::KeyLogging + "." +
-                                           ConfigurationManager::PartLogDir;
+                constexpr const char* KeyDir = ConfigurationManager::LoggingDirectory;
                 if (OsEng.configurationManager().hasKey(KeyDir)) {
                     loggingDir = OsEng.configurationManager().value<std::string>(KeyDir);
                 }
 
                 std::string prefix = "PM-";
-                const std::string KeyPrefix = ConfigurationManager::KeyLogging + "." +
-                                           ConfigurationManager::PartLogPerformancePrefix;
+                constexpr const char* KeyPrefix =
+                                           ConfigurationManager::LoggingPerformancePrefix;
                 if (OsEng.configurationManager().hasKey(KeyPrefix)) {
                     prefix = OsEng.configurationManager().value<std::string>(KeyPrefix);
                 }
@@ -341,8 +343,7 @@ void RenderEngine::setRendererFromString(const std::string& renderingMethod) {
         newRenderer = std::make_unique<ABufferRenderer>();
         break;
     case RendererImplementation::Invalid:
-        LFATAL("Rendering method '" << renderingMethod << "' not among the available "
-            << "rendering methods");
+        LFATAL(fmt::format("Rendering method '{}' not available", renderingMethod));
     }
 
     setRenderer(std::move(newRenderer));
@@ -384,7 +385,7 @@ void RenderEngine::initialize() {
     _deferredcasterManager = std::make_unique<DeferredcasterManager>();
     _nAaSamples = OsEng.windowWrapper().currentNumberOfAaSamples();
 
-    LINFO("Setting renderer from string: " << renderingMethod);
+    LINFO(fmt::format("Setting renderer from string: {}", renderingMethod));
     setRendererFromString(renderingMethod);
 
 #ifdef GHOUL_USE_DEVIL
@@ -405,6 +406,11 @@ void RenderEngine::initialize() {
         std::make_shared<ghoul::io::TextureWriterSOIL>()
     );
 #endif // GHOUL_USE_SOIL
+#ifdef GHOUL_USE_STB
+    ghoul::io::TextureReader::ref().addReader(
+        std::make_shared<ghoul::io::TextureReaderSTB>()
+    );    
+#endif
 
     ghoul::io::TextureReader::ref().addReader(
         std::make_shared<ghoul::io::TextureReaderCMAP>()
@@ -464,7 +470,11 @@ void RenderEngine::deinitializeGL() {
 }
 
 void RenderEngine::updateScene() {
-    if (!_scene) return;
+    if (!_scene) {
+        return;
+    }
+
+    _scene->updateInterpolations();
 
     const Time& currentTime = OsEng.timeManager().time();
     _scene->update({
@@ -689,6 +699,16 @@ void RenderEngine::postDraw() {
     }
 
     if (_shouldTakeScreenshot) {
+        // We only create the directory here, as we don't want to spam the users
+        // screenshot folder everytime we start OpenSpace even when we are not taking any
+        // screenshots. So the first time we actually take one, we create the folder:
+        if (!FileSys.directoryExists(absPath("${THIS_SCREENSHOT_PATH}"))) {
+            FileSys.createDirectory(
+                absPath("${THIS_SCREENSHOT_PATH}"),
+                ghoul::filesystem::FileSystem::Recursive::Yes
+            );
+        }
+
         OsEng.windowWrapper().takeScreenshot(_applyWarping);
         _shouldTakeScreenshot = false;
     }
diff --git a/src/rendering/renderengine_lua.inl b/src/rendering/renderengine_lua.inl
index 538de4bbe1..ee437b9799 100644
--- a/src/rendering/renderengine_lua.inl
+++ b/src/rendering/renderengine_lua.inl
@@ -119,7 +119,7 @@ int addScreenSpaceRenderable(lua_State* L) {
 
 int removeScreenSpaceRenderable(lua_State* L) {
     ghoul::lua::checkArgumentsAndThrow(L, 1, "lua::removeScreenSpaceRenderable");
-    
+
     using ghoul::lua::errorLocation;
 
     std::string name = ghoul::lua::checkStringAndPop(L);
@@ -130,7 +130,9 @@ int removeScreenSpaceRenderable(lua_State* L) {
     if (!s) {
         LERRORC(
             "removeScreenSpaceRenderable",
-            errorLocation(L) << "Could not find ScreenSpaceRenderable '" << name << "'"
+            fmt::format(
+                "{}: Could not find ScreenSpaceRenderable '{}'",  errorLocation(L), name
+            )
         );
         ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
         return 0;
diff --git a/src/rendering/transferfunction.cpp b/src/rendering/transferfunction.cpp
index 45480b43a9..78f61b811b 100644
--- a/src/rendering/transferfunction.cpp
+++ b/src/rendering/transferfunction.cpp
@@ -164,9 +164,9 @@ void TransferFunction::setTextureFromTxt() {
     }
 
     // allocate new float array with zeros
-    float* transferFunction = new float[width*4]();
-    for (int i = 0; i < 4*width; ++i) {
-        transferFunction[i] = 0.0f;
+    float* transferFunction = new float[width * 4];
+    for (int i = 0; i < 4 * width; ++i) {
+        transferFunction[i] = 0.f;
     }
 
     size_t lowerIndex = static_cast<size_t>(floorf(lower * static_cast<float>(width-1)));
@@ -176,9 +176,9 @@ void TransferFunction::setTextureFromTxt() {
     auto currentKey = prevKey + 1;
     auto lastKey = mappingKeys.end() -1;
 
-    for (size_t i=lowerIndex; i<=upperIndex; i++) {
-        float fpos = static_cast<float>(i)/static_cast<float>(width-1);
-        if (fpos > (*currentKey).position) {
+    for (size_t i = lowerIndex; i <= upperIndex; ++i) {
+        float fpos = static_cast<float>(i) / static_cast<float>(width-1);
+        if (fpos > currentKey->position) {
             prevKey = currentKey;
             currentKey++;
             if (currentKey == mappingKeys.end()) {
@@ -186,18 +186,18 @@ void TransferFunction::setTextureFromTxt() {
             }
         }
 
-        float dist = fpos-(*prevKey).position;
-        float weight = dist/((*currentKey).position-(*prevKey).position);
+        float dist = fpos - prevKey->position;
+        float weight = dist / (currentKey->position - prevKey->position);
 
-        for (size_t channel=0; channel<4; ++channel) {
-            size_t position = 4*i + channel;
+        for (size_t channel = 0; channel < 4; ++channel) {
+            size_t position = 4 * i + channel;
             // Interpolate linearly between prev and next mapping key
-            float value = ((*prevKey).color[channel] * (1.f - weight) +
-                          (*currentKey).color[channel] * weight) / 255.f;
+            float value = (prevKey->color[channel] * (1.f - weight) +
+                          currentKey->color[channel] * weight) / 255.f;
             if (channel < 3) {
                 // Premultiply with alpha
-                value *= ((*prevKey).color[3] * (1.f - weight) +
-                         (*currentKey).color[3] * weight) / 255.f;
+                value *= (prevKey->color[3] * (1.f - weight) +
+                         currentKey->color[3] * weight) / 255.f;
             }
             transferFunction[position] = value;
         }
@@ -221,13 +221,19 @@ void TransferFunction::setTextureFromImage() {
 }
 
 glm::vec4 TransferFunction::sample(size_t offset) {
-    if (!_texture) return glm::vec4(0.0);
+    if (!_texture) {
+        return glm::vec4(0.f);
+    }
 
     int nPixels = _texture->width();
 
     // Clamp to range.
-    if (offset >= nPixels) offset = nPixels - 1;
-    if (offset < 0) offset = 0;
+    if (offset >= nPixels) {
+        offset = nPixels - 1;
+    }
+    if (offset < 0) {
+        offset = 0;
+    }
 
     return _texture->texelAsFloat(offset);
 }
diff --git a/src/scene/asset.cpp b/src/scene/asset.cpp
index 23c1aa0db9..1521c30823 100644
--- a/src/scene/asset.cpp
+++ b/src/scene/asset.cpp
@@ -23,12 +23,12 @@
  ****************************************************************************************/
 
 #include <openspace/scene/asset.h>
+
 #include <openspace/scene/assetloader.h>
-
+#include <ghoul/fmt.h>
 #include <ghoul/logging/logmanager.h>
-
-#include <iterator>
 #include <algorithm>
+#include <iterator>
 #include <unordered_set>
 
 namespace {
@@ -122,9 +122,7 @@ void Asset::setState(Asset::State state) {
     }
 }
 
-void Asset::requiredAssetChangedState(std::shared_ptr<Asset> child,
-    Asset::State childState)
-{
+void Asset::requiredAssetChangedState(std::shared_ptr<Asset>, Asset::State childState) {
     if (!isLoaded()) {
         // Prohibit state change to SyncResolved if additional requirements
         // may still be added.
@@ -368,7 +366,7 @@ bool Asset::isInitialized() const {
 
 bool Asset::startSynchronizations() {
     if (!isLoaded()) {
-        LWARNING("Cannot start synchronizations of unloaded asset " << id());
+        LWARNING(fmt::format("Cannot start synchronizations of unloaded asset {}", id()));
         return false;
     }
     for (auto& child : requestedAssets()) {
@@ -502,10 +500,10 @@ bool Asset::initialize() {
         return true;
     }
     if (!isSynchronized()) {
-        LERROR("Cannot initialize unsynchronized asset " << id());
+        LERROR(fmt::format("Cannot initialize unsynchronized asset {}", id()));
         return false;
     }
-    LDEBUG("Initializing asset " << id());
+    LDEBUG(fmt::format("Initializing asset {}", id()));
 
     // 1. Initialize requirements
     for (auto& child : _requiredAssets) {
@@ -523,8 +521,9 @@ bool Asset::initialize() {
     try {
         loader()->callOnInitialize(this);
     } catch (const ghoul::lua::LuaRuntimeException& e) {
-        LERROR("Failed to initialize asset " << id() << ". " <<
-            e.component << ": " << e.message);
+        LERROR(fmt::format(
+            "Failed to initialize asset {}; {}: {}", id(), e.component, e.message
+        ));
         // TODO: rollback;
         setState(Asset::State::InitializationFailed);
         return false;
@@ -538,9 +537,13 @@ bool Asset::initialize() {
         try {
             loader()->callOnDependencyInitialize(child.get(), this);
         } catch (const ghoul::lua::LuaRuntimeException& e) {
-            LERROR("Failed to initialize required asset " <<
-                child->id() << " of " << id() << ". " <<
-                e.component << ": " << e.message);
+            LERROR(fmt::format(
+                "Failed to initialize required asset {} of {}; {}: {}",
+                child->id(),
+                id(),
+                e.component,
+                e.message
+            ));
             // TODO: rollback;
             setState(Asset::State::InitializationFailed);
             return false;
@@ -553,9 +556,13 @@ bool Asset::initialize() {
             try {
                 loader()->callOnDependencyInitialize(child.get(), this);
             } catch (const ghoul::lua::LuaRuntimeException& e) {
-                LERROR("Failed to initialize requested asset " <<
-                    child->id() << " of " << id() << ". " <<
-                    e.component << ": " << e.message);
+                LERROR(fmt::format(
+                    "Failed to initialize requested asset {} of {}; {}: {}",
+                    child->id(),
+                    id(),
+                    e.component,
+                    e.message
+                ));
                 // TODO: rollback;
             }
         }
@@ -568,9 +575,13 @@ bool Asset::initialize() {
             try {
                 loader()->callOnDependencyInitialize(this, p.get());
             } catch (const ghoul::lua::LuaRuntimeException& e) {
-                LERROR("Failed to initialize required asset " <<
-                    id() << " of " << p->id() << ". " <<
-                    e.component << ": " << e.message);
+                LERROR(fmt::format(
+                    "Failed to initialize required asset {} of {}; {}: {}",
+                    id(),
+                    p->id(),
+                    e.component,
+                    e.message
+                ));
                 // TODO: rollback;
             }
         }
@@ -589,7 +600,7 @@ void Asset::deinitialize() {
     if (!isInitialized()) {
         return;
     }
-    LDEBUG("Deintializing asset " << id());
+    LDEBUG(fmt::format("Deintializing asset {}", id()));
 
     // Perform inverse actions as in initialize, in reverse order (7 - 1)
 
@@ -601,9 +612,13 @@ void Asset::deinitialize() {
                 loader()->callOnDependencyDeinitialize(this, p.get());
             }
             catch (const ghoul::lua::LuaRuntimeException& e) {
-                LERROR("Failed to deinitialize requested asset " <<
-                       id() << " of " << p->id() << ". " <<
-                       e.component << ": " << e.message);
+                LERROR(fmt::format(
+                    "Failed to deinitialize requested asset {} of {}; {}: {}",
+                    id(),
+                    p->id(),
+                    e.component,
+                    e.message
+                ));
             }
         }
     }
@@ -615,9 +630,13 @@ void Asset::deinitialize() {
                 loader()->callOnDependencyDeinitialize(child.get(), this);
             }
             catch (const ghoul::lua::LuaRuntimeException& e) {
-                LERROR("Failed to deinitialize requested asset " <<
-                       child->id() << " of " << id() << ". " <<
-                       e.component << ": " << e.message);
+                LERROR(fmt::format(
+                    "Failed to deinitialize requested asset {} of {}; {}: {}",
+                    child->id(),
+                    id(),
+                    e.component,
+                    e.message
+                ));
             }
         }
     }
@@ -628,9 +647,13 @@ void Asset::deinitialize() {
             loader()->callOnDependencyDeinitialize(child.get(), this);
         }
         catch (const ghoul::lua::LuaRuntimeException& e) {
-            LERROR("Failed to deinitialize required asset " <<
-                child->id() << " of " << id() << ". " <<
-                e.component << ": " << e.message);
+            LERROR(fmt::format(
+                "Failed to deinitialize required asset {} of {}; {}: {}",
+                child->id(),
+                id(),
+                e.component,
+                e.message
+            ));
         }
     }
 
@@ -642,8 +665,9 @@ void Asset::deinitialize() {
         loader()->callOnDeinitialize(this);
     }
     catch (const ghoul::lua::LuaRuntimeException& e) {
-        LERROR("Failed to deinitialize asset " << id() << ". " <<
-            e.component << ": " << e.message);
+        LERROR(fmt::format(
+            "Failed to deinitialize asset {}; {}: {}", id(), e.component, e.message
+        ));
         return;
     }
 
diff --git a/src/scene/assetloader.cpp b/src/scene/assetloader.cpp
index 1b2351bb1a..9a2c42784e 100644
--- a/src/scene/assetloader.cpp
+++ b/src/scene/assetloader.cpp
@@ -33,7 +33,7 @@
 #include <ghoul/misc/defer.h>
 #include <ghoul/filesystem/filesystem.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include "assetloader_lua.inl"
 
@@ -254,8 +254,9 @@ bool AssetLoader::loadAsset(std::shared_ptr<Asset> asset) {
     };
 
     if (!FileSys.fileExists(asset->assetFilePath())) {
-        LERROR("Could not load asset '" << asset->assetFilePath() <<
-               "': File does not exist.");
+        LERROR(fmt::format(
+            "Could not load asset '{}': File does not exist", asset->assetFilePath())
+        );
         lua_settop(*_luaState, top);
         return false;
     }
@@ -263,7 +264,9 @@ bool AssetLoader::loadAsset(std::shared_ptr<Asset> asset) {
     try {
         ghoul::lua::runScriptFile(*_luaState, asset->assetFilePath());
     } catch (const ghoul::lua::LuaRuntimeException& e) {
-        LERROR("Could not load asset '" << asset->assetFilePath() << "': " << e.message);
+        LERROR(fmt::format(
+            "Could not load asset '{}': {}", asset->assetFilePath(), e.message)
+        );
         lua_settop(*_luaState, top);
         return false;
     }
@@ -420,11 +423,11 @@ int AssetLoader::onInitializeDependencyLua(Asset* dependant, Asset* dependency)
 
 int AssetLoader::onDeinitializeDependencyLua(Asset* dependant, Asset* dependency) {
     ghoul::lua::checkArgumentsAndThrow(*_luaState, 1, "lua::onDeinitializeDependency");
-    
+
     int referenceIndex = luaL_ref(*_luaState, LUA_REGISTRYINDEX);
     _onDependencyDeinitializationFunctionRefs[dependant][dependency]
         .push_back(referenceIndex);
-    
+
     lua_settop(*_luaState, 0);
     return 0;
 }
diff --git a/src/scene/assetmanager_lua.inl b/src/scene/assetmanager_lua.inl
index a02c6ad58a..0d94f96679 100644
--- a/src/scene/assetmanager_lua.inl
+++ b/src/scene/assetmanager_lua.inl
@@ -52,7 +52,7 @@ int remove(lua_State* state) {
 int removeAll(lua_State* state) {
     ghoul::lua::checkArgumentsAndThrow(state, 0, "lua::removeAll");
 
-    
+
     AssetManager* assetManager =
         reinterpret_cast<AssetManager*>(lua_touserdata(state, lua_upvalueindex(1)));
 
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
index 4fbfdc25fc..5940caacdc 100644
--- a/src/scene/scene.cpp
+++ b/src/scene/scene.cpp
@@ -35,23 +35,21 @@
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/util/time.h>
-
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
-#include <ghoul/misc/dictionary.h>
-#include <ghoul/misc/exception.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/lua/ghoul_lua.h>
 #include <ghoul/lua/lua_helper.h>
 #include <ghoul/misc/dictionary.h>
+#include <ghoul/misc/exception.h>
+#include <ghoul/misc/invariants.h>
 #include <ghoul/misc/threadpool.h>
 #include <ghoul/opengl/programobject.h>
 #include <ghoul/opengl/texture.h>
-
+#include <algorithm>
 #include <chrono>
 #include <iostream>
 #include <iterator>
-#include <numeric>
 #include <fstream>
 #include <string>
 #include <stack>
@@ -69,25 +67,7 @@ namespace {
 namespace openspace {
 
 Scene::Scene(std::unique_ptr<SceneInitializer> initializer)
-    : DocumentationGenerator(
-        "Documented",
-        "propertyOwners",
-        {
-            {
-                "mainTemplate",
-                "${WEB}/properties/main.hbs"
-            },
-            {
-                "propertyOwnerTemplate",
-                "${WEB}/properties/propertyowner.hbs"
-            },
-            {
-                "propertyTemplate",
-                "${WEB}/properties/property.hbs"
-            }
-        },
-        "${WEB}/properties/script.js"
-    )
+    : properties::PropertyOwner({"Scene", "Scene"})
     , _dirtyNodeRegistry(false)
     , _initializer(std::move(initializer))
 {
@@ -125,6 +105,7 @@ void Scene::registerNode(SceneGraphNode* node) {
 
     _topologicallySortedNodes.push_back(node);
     _nodesByName[node->name()] = node;
+    addPropertySubOwner(node);
     _dirtyNodeRegistry = true;
 }
 
@@ -138,6 +119,12 @@ void Scene::unregisterNode(SceneGraphNode* node) {
         _topologicallySortedNodes.end()
     );
     _nodesByName.erase(node->name());
+    // Just try to remove all properties; if the property doesn't exist, the
+    // removeInterpolation will not do anything
+    for (properties::Property* p : node->properties()) {
+        removeInterpolation(p);
+    }
+    removePropertySubOwner(node);
     _dirtyNodeRegistry = true;
 }
 
@@ -214,10 +201,10 @@ void Scene::sortTopologically() {
         }
     }
     if (inDegrees.size() > 0) {
-        LERROR(
-            "The scene contains circular dependencies. " <<
-            inDegrees.size() << " nodes will be disabled."
-        );
+        LERROR(fmt::format(
+            "The scene contains circular dependencies. {} nodes will be disabled",
+            inDegrees.size()
+        ));
     }
 
     for (auto it : inDegrees) {
@@ -387,8 +374,10 @@ SceneGraphNode* Scene::loadNode(const ghoul::Dictionary& dict) {
     const bool hasParent = dict.hasKey(KeyParentName);
 
     if (_nodesByName.find(nodeName) != _nodesByName.end()) {
-        LERROR("Cannot add scene graph node " << nodeName <<
-               ". A node with that name already exisis.");
+        LERROR(fmt::format(
+            "Cannot add scene graph node '{}'. A node with that name already exists",
+            nodeName
+        ));
         return nullptr;
     }
 
@@ -455,79 +444,117 @@ SceneGraphNode* Scene::loadNode(const ghoul::Dictionary& dict) {
     return rawNodePointer;
 }
 
+void Scene::addInterpolation(properties::Property* prop, float durationSeconds,
+                             ghoul::EasingFunction easingFunction)
+{
+    ghoul_precondition(prop != nullptr, "prop must not be nullptr");
+    ghoul_precondition(durationSeconds > 0.0, "durationSeconds must be positive");
+    ghoul_postcondition(
+        std::find_if(
+            _interpolationInfos.begin(),
+            _interpolationInfos.end(),
+            [prop](const InterpolationInfo& info) {
+                return info.prop == prop && !info.isExpired;
+            }
+        ) != _interpolationInfos.end(),
+        "A new interpolation record exists for p that is not expired"
+    );
+
+    ghoul::EasingFunc<float> func =
+        easingFunction == ghoul::EasingFunction::Linear
+         ?
+        nullptr :
+        ghoul::easingFunction<float>(easingFunction);
+
+    // First check if the current property already has an interpolation information
+    for (std::vector<InterpolationInfo>::iterator it = _interpolationInfos.begin();
+        it != _interpolationInfos.end();
+        ++it)
+    {
+        if (it->prop == prop) {
+            it->beginTime = std::chrono::steady_clock::now();
+            it->durationSeconds = durationSeconds;
+            it->easingFunction = func;
+            // If we found it, we can break since we make sure that each property is only
+            // represented once in this
+            return;
+        }
+    }
+
+    InterpolationInfo i;
+    i.prop = prop;
+    i.beginTime = std::chrono::steady_clock::now();
+    i.durationSeconds = durationSeconds;
+    i.easingFunction = func;
+
+    _interpolationInfos.push_back(std::move(i));
+}
+
+void Scene::removeInterpolation(properties::Property* prop) {
+    ghoul_precondition(prop != nullptr, "prop must not be nullptr");
+    ghoul_postcondition(
+        std::find_if(
+            _interpolationInfos.begin(),
+            _interpolationInfos.end(),
+            [prop](const InterpolationInfo& info) {
+                return info.prop == prop;
+            }
+        ) == _interpolationInfos.end(),
+        "No interpolation record exists for prop"
+    );
+
+    _interpolationInfos.erase(
+        std::remove_if(
+            _interpolationInfos.begin(),
+            _interpolationInfos.end(),
+            [prop](const InterpolationInfo& info) { return info.prop == prop; }
+        ),
+        _interpolationInfos.end()
+    );
+}
+
+void Scene::updateInterpolations() {
+    using namespace std::chrono;
+    auto now = steady_clock::now();
+
+    for (InterpolationInfo& i : _interpolationInfos) {
+        long long usPassed = duration_cast<std::chrono::microseconds>(
+            now - i.beginTime
+        ).count();
+
+        float t = static_cast<float>(
+            static_cast<double>(usPassed) /
+            static_cast<double>(i.durationSeconds * 1000000)
+        );
+
+        // @FRAGILE(abock): This method might crash if someone deleted the property
+        //                  underneath us. We take care of removing entire PropertyOwners,
+        //                  but we assume that Propertys live as long as their
+        //                  SceneGraphNodes. This is true in general, but if Propertys are
+        //                  created and destroyed often by the SceneGraphNode, this might
+        //                  become a problem.
+        i.prop->interpolateValue(glm::clamp(t, 0.f, 1.f), i.easingFunction);
+
+        i.isExpired = (t >= 1.f);
+    }
+
+    _interpolationInfos.erase(
+        std::remove_if(
+            _interpolationInfos.begin(),
+            _interpolationInfos.end(),
+            [](const InterpolationInfo& i) {
+                return i.isExpired;
+            }
+        ),
+        _interpolationInfos.end()
+    );
+}
+
 void Scene::writeSceneLicenseDocumentation(const std::string& path) const {
     SceneLicenseWriter writer(_licenses);
     writer.writeDocumentation(path);
 }
 
-std::string Scene::generateJson() const {
-    std::function<std::string(properties::PropertyOwner*)> createJson =
-        [&createJson](properties::PropertyOwner* owner) -> std::string
-    {
-        std::stringstream json;
-        json << "{";
-        json << "\"name\": \"" << owner->name() << "\",";
-
-        json << "\"properties\": [";
-        auto properties = owner->properties();
-        for (properties::Property* p : properties) {
-            json << "{";
-            json << "\"id\": \"" << p->identifier() << "\",";
-            json << "\"type\": \"" << p->className() << "\",";
-            json << "\"fullyQualifiedId\": \"" << p->fullyQualifiedIdentifier() << "\",";
-            json << "\"guiName\": \"" << p->guiName() << "\",";
-            json << "\"description\": \"" << escapedJson(p->description()) << "\"";
-            json << "}";
-            if (p != properties.back()) {
-                json << ",";
-            }
-        }
-        json << "],";
-
-        json << "\"propertyOwners\": [";
-        auto propertyOwners = owner->propertySubOwners();
-        for (properties::PropertyOwner* o : propertyOwners) {
-            json << createJson(o);
-            if (o != propertyOwners.back()) {
-                json << ",";
-            }
-        }
-        json << "]";
-        json << "}";
-
-        return json.str();
-    };
-
-
-    std::stringstream json;
-    json << "[";
-    std::vector<SceneGraphNode*> nodes = allSceneGraphNodes();
-    if (!nodes.empty()) {
-        json << std::accumulate(
-            std::next(nodes.begin()),
-            nodes.end(),
-            createJson(*nodes.begin()),
-            [createJson](std::string a, SceneGraphNode* n) {
-            return a + "," + createJson(n);
-        }
-        );
-    }
-
-    json << "]";
-
-    std::string jsonString = "";
-    for (const char& c : json.str()) {
-        if (c == '\'') {
-            jsonString += "\\'";
-        }
-        else {
-            jsonString += c;
-        }
-    }
-
-    return jsonString;
-}
-
 scripting::LuaLibrary Scene::luaLibrary() {
     return {
         "",
@@ -536,41 +563,42 @@ scripting::LuaLibrary Scene::luaLibrary() {
                 "setPropertyValue",
                 &luascriptfunctions::property_setValue,
                 {},
-                "string, *",
+                "name, value [, duration, easing, optimization]",
                 "Sets all property(s) identified by the URI (with potential wildcards) "
                 "in the first argument. The second argument can be any type, but it has "
                 "to match the type that the property (or properties) expect. If the "
-                "first term (separated by '.') in the uri is bracketed with { }, then "
-                "this term is treated as a group tag name, and the function will "
-                "search through all property owners to find those that are tagged with "
-                "this group name, and set their property values accordingly."
-            },
-            {
-                "setPropertyValueRegex",
-                &luascriptfunctions::property_setValueRegex,
-                {},
-                "string, *",
-                "Sets all property(s) that pass the regular expression in the first "
-                "argument. The second argument can be any type, but it has to match "
-                "the type of the properties that matched the regular expression. "
-                "The regular expression has to be of the ECMAScript grammar. If the "
-                "first term (separated by '.') in the uri is bracketed with { }, then "
-                "this term is treated as a group tag name, and the function will search "
-                "through all property owners to find those that are tagged with this "
-                "group name, and set their property values accordingly."
+                "third is not present or is '0', the value changes instantly, otherwise "
+                "the change will take that many seconds and the value is interpolated at "
+                "each steap in between. The fourth parameter is an optional easing "
+                "function if a 'duration' has been specified. If 'duration' is 0, this "
+                "parameter value is ignored. Otherwise, it can be one of many supported "
+                "easing functions. See easing.h for available functions. The fifth "
+                "argument must be either empty, 'regex', or 'single'. If the last "
+                "argument is empty (the default), the URI is interpreted using a "
+                "wildcard in which '*' is expanded to '(.*)' and bracketed components "
+                "'{ }' are interpreted as group tag names. Then, the passed value will "
+                "be set on all properties that fit the regex + group name combination. "
+                "If the third argument is 'regex' neither the '*' expansion, nor the "
+                "group tag expansion is performed and the first argument is used as an "
+                "ECMAScript style regular expression that matches against the fully "
+                "qualified IDs of properties. If the third arugment is 'single' no "
+                "substitutions are performed and exactly 0 or 1 properties are changed."
             },
             {
                 "setPropertyValueSingle",
                 &luascriptfunctions::property_setValueSingle,
                 {},
-                "string, *",
-                "Sets all property(s) identified by the URI in the first argument to the "
-                "value passed in the second argument. The type of the second argument is "
-                "arbitrary, but it must agree with the type the denoted Property expects."
-                " If the first term (separated by '.') in the uri is bracketed with { }, "
-                " then this term is treated as a group tag name, and the function will "
-                "search through all property owners to find those that are tagged with "
-                "this group name, and set their property values accordingly."
+                "URI, value [, duration, easing]",
+                "Sets the property identified by the URI in the first argument. The "
+                "second argument can be any type, but it has to match the type that the "
+                "property expects. If the third is not present or is '0', the value "
+                "changes instantly, otherwise the change will take that many seconds and "
+                "the value is interpolated at each steap in between. The fourth "
+                "parameter is an optional easing function if a 'duration' has been "
+                "specified. If 'duration' is 0, this parameter value is ignored. "
+                "Otherwise, it has to be 'linear', 'easein', 'easeout', or 'easeinout'. "
+                "This is the same as calling the setValue method and passing 'single' as "
+                "the fourth argument to setPropertyValue."
             },
             {
                 "getPropertyValue",
diff --git a/src/scene/scene_lua.inl b/src/scene/scene_lua.inl
index 2f0e22050d..f7b10d582e 100644
--- a/src/scene/scene_lua.inl
+++ b/src/scene/scene_lua.inl
@@ -23,24 +23,14 @@
  ****************************************************************************************/
 
 #include <openspace/documentation/documentation.h>
-
+#include <ghoul/misc/defer.h>
+#include <ghoul/misc/easing.h>
 #include <regex>
 
 namespace openspace {
 
 namespace {
 
-void executePropertySet(properties::Property* prop, lua_State* L) {
-    prop->setLuaValue(L);
-    //ensure properties are synced over parallel connection
-    std::string value;
-    prop->getStringValue(value);
-    /*OsEng.parallelConnection().scriptMessage(
-    prop->fullyQualifiedIdentifier(),
-    value
-    );*/
-}
-
 template <class T>
 properties::PropertyOwner* findPropertyOwnerWithMatchingGroupTag(T* prop,
                                                            const std::string& tagToMatch)
@@ -67,13 +57,17 @@ properties::PropertyOwner* findPropertyOwnerWithMatchingGroupTag(T* prop,
 }
 
 void applyRegularExpression(lua_State* L, std::regex regex,
-                            std::vector<properties::Property*> properties, int type,
-                            std::string groupName = "")
+                            std::vector<properties::Property*> properties,
+                            double interpolationDuration,
+                            const std::string& groupName,
+                            ghoul::EasingFunction easingFunction)
 {
     using ghoul::lua::errorLocation;
     using ghoul::lua::luaTypeToString;
     bool isGroupMode = !groupName.empty();
 
+    const int type = lua_type(L, -1);
+
     for (properties::Property* prop : properties) {
         // Check the regular expression for all properties
         std::string id = prop->fullyQualifiedIdentifier();
@@ -93,20 +87,36 @@ void applyRegularExpression(lua_State* L, std::regex regex,
             }
 
             if (type != prop->typeLua()) {
-                LERRORC("property_setValue",
-                        errorLocation(L) << "Property '" <<
-                        prop->fullyQualifiedIdentifier() <<
-                        "' does not accept input of type '" << luaTypeToString(type) <<
-                        "'. Requested type: '" << luaTypeToString(prop->typeLua()) << "'"
+                LERRORC(
+                    "property_setValue",
+                    fmt::format(
+                        "{}: Property '{}' does not accept input of type '{}'. "
+                        "Requested type: '{}'",
+                        errorLocation(L),
+                        prop->fullyQualifiedIdentifier(),
+                        luaTypeToString(type),
+                        luaTypeToString(prop->typeLua())
+                    )
                 );
             } else {
-               executePropertySet(prop, L);
+                if (interpolationDuration == 0.0) {
+                    OsEng.renderEngine().scene()->removeInterpolation(prop);
+                    prop->setLuaValue(L);
+                }
+                else {
+                    prop->setLuaInterpolationTarget(L);
+                    OsEng.renderEngine().scene()->addInterpolation(
+                        prop,
+                        static_cast<float>(interpolationDuration),
+                        easingFunction
+                    );
+                }
             }
         }
     }
 }
 
-//Checks to see if URI contains a group tag (with { } around the first term). If so,
+// Checks to see if URI contains a group tag (with { } around the first term). If so,
 // returns true and sets groupName with the tag
 bool doesUriContainGroupTag(const std::string& command, std::string& groupName) {
     std::string name = command.substr(0, command.find_first_of("."));
@@ -133,79 +143,41 @@ std::string extractUriWithoutGroupName(std::string uri) {
 
 namespace openspace::luascriptfunctions {
 
-int setPropertyCall_single(properties::Property* prop, std::string uri, lua_State* L,
-                           const int type)
+int setPropertyCall_single(properties::Property& prop, const std::string& uri,
+                          lua_State* L, double duration,
+                          ghoul::EasingFunction eastingFunction)
 {
     using ghoul::lua::errorLocation;
     using ghoul::lua::luaTypeToString;
 
-    if (type != prop->typeLua()) {
-        LERRORC("property_setValue", errorLocation(L) << "Property '" << uri <<
-            "' does not accept input of type '" << luaTypeToString(type) <<
-            "'. Requested type: '" << luaTypeToString(prop->typeLua()) << "'");
+    const int type = lua_type(L, -1);
+    if (type != prop.typeLua()) {
+        LERRORC(
+            "property_setValue",
+            fmt::format(
+                "{}: Property '{}' does not accept input of type '{}'. "
+                "Requested type: '{}'",
+                errorLocation(L),
+                uri,
+                luaTypeToString(type),
+                luaTypeToString(prop.typeLua())
+            )
+        );
     }
     else {
-        prop->setLuaValue(L);
-        //ensure properties are synced over parallel connection
-        std::string value;
-        prop->getStringValue(value);
-    }
-
-    return 0;
-}
-
-/**
- * \ingroup LuaScripts
- * setPropertyValueSingle(string, *):
- * Sets all property(s) identified by the URI in the first argument to the value passed
- * in the second argument. The type of the second argument is arbitrary, but it must
- * agree with the type the denoted Property expects.
- * If the first term (separated by '.') in the uri is bracketed with { }, then this
- * term is treated as a group tag name, and the function will search through all
- * property owners to find those that are tagged with this group name, and set their
- * property values accordingly.
- */
-int property_setValueSingle(lua_State* L) {
-    using ghoul::lua::errorLocation;
-    using ghoul::lua::luaTypeToString;
-
-    ghoul::lua::checkArgumentsAndThrow(L, 2, "lua::property_setValueSingle");
-
-    std::string uri = luaL_checkstring(L, -2);
-    const int type = lua_type(L, -1);
-    std::string tagToMatch;
-
-    if (doesUriContainGroupTag(uri, tagToMatch)) {
-        std::string pathRemainderToMatch = extractUriWithoutGroupName(uri);
-        for (properties::Property* prop : allProperties()) {
-            std::string propFullId = prop->fullyQualifiedIdentifier();
-            //Look for a match in the uri with the group name (first term) removed
-            int propMatchLength =
-                static_cast<int>(propFullId.length()) -
-                static_cast<int>(pathRemainderToMatch.length());
-
-            if (propMatchLength >= 0) {
-                std::string thisPropMatchId = propFullId.substr(propMatchLength);
-                //If remainder of uri matches (with group name removed),
-                if (pathRemainderToMatch.compare(thisPropMatchId) == 0)  {
-                    properties::PropertyOwner* matchingTaggedOwner
-                        = findPropertyOwnerWithMatchingGroupTag(prop, tagToMatch);
-                    if (matchingTaggedOwner) {
-                        setPropertyCall_single(prop, uri, L, type);
-                    }
-                }
-            }
+        if (duration == 0.0) {
+            OsEng.renderEngine().scene()->removeInterpolation(&prop);
+            prop.setLuaValue(L);
         }
-    } else {
-        properties::Property* prop = property(uri);
-        if (!prop) {
-            LERRORC("property_setValue", errorLocation(L) << "Property with URI '"
-                << uri << "' was not found");
-            return 0;
+        else {
+            prop.setLuaInterpolationTarget(L);
+            OsEng.renderEngine().scene()->addInterpolation(
+                &prop,
+                static_cast<float>(duration),
+                eastingFunction
+            );
         }
-        setPropertyCall_single(prop, uri, L, type);
     }
-
     return 0;
 }
 
@@ -225,77 +197,153 @@ int property_setValue(lua_State* L) {
     using ghoul::lua::errorLocation;
     using ghoul::lua::luaTypeToString;
 
-    ghoul::lua::checkArgumentsAndThrow(L, 2, "lua::property_setGroup");
+    ghoul::lua::checkArgumentsAndThrow(L, { 2, 5 }, "lua::property_setValue");
+    defer { lua_settop(L, 0); };
 
-    std::string regex = luaL_checkstring(L, -2);
-    std::string groupName;
+    std::string uriOrRegex = luaL_checkstring(L, 1);
+    std::string optimization;
+    double interpolationDuration = 0.0;
+    std::string easingMethodName;
+    ghoul::EasingFunction easingMethod = ghoul::EasingFunction::Linear;
 
-    // Replace all wildcards *  with the correct regex (.*)
-    size_t startPos = regex.find("*");
-    while (startPos != std::string::npos) {
-        regex.replace(startPos, 1, "(.*)");
-        startPos += 4;
-        startPos = regex.find("*", startPos);
+    if (lua_gettop(L) >= 3) {
+        if (lua_type(L, 3) == LUA_TNUMBER) {
+            interpolationDuration = luaL_checknumber(L, 3);
+        }
+        else {
+            optimization = luaL_checkstring(L, 3);
+        }
+
+        if (lua_gettop(L) >= 4) {
+            if (lua_type(L, 4) == LUA_TNUMBER) {
+                interpolationDuration = luaL_checknumber(L, 4);
+            }
+            else {
+                optimization = luaL_checkstring(L, 4);
+            }
+        }
+
+        if (lua_gettop(L) == 5) {
+            easingMethodName = luaL_checkstring(L, 5);
+        }
+
+        // Later functions expect the value to be at the last position on the stack
+        lua_pushvalue(L, 2);
     }
 
-    if (doesUriContainGroupTag(regex, groupName)) {
-        std::string pathRemainderToMatch = extractUriWithoutGroupName(regex);
-        //Remove group name from start of regex and replace with '.*'
-        regex = replaceUriWithGroupName(regex, ".*");
+    if (interpolationDuration == 0.0 && !easingMethodName.empty()) {
+        LWARNINGC(
+            "property_setValue",
+            "Easing method specified while interpolation duration is equal to 0"
+        );
     }
 
-    applyRegularExpression(
-        L,
-        std::regex(regex/*, std::regex_constants::optimize*/),
-        allProperties(),
-        lua_type(L, -1),
-        groupName
-    );
+    if (!easingMethodName.empty()) {
+        bool correctName = ghoul::isValidEasingFunctionName(easingMethodName.c_str());
+        if (!correctName) {
+            LWARNINGC(
+                "property_setValue",
+                fmt::format("{} is not a valid easing method", easingMethodName)
+            );
+        }
+        else {
+            easingMethod = ghoul::easingFunctionFromName(easingMethodName.c_str());
+        }
+    }
 
+    if (optimization.empty()) {
+        // Replace all wildcards * with the correct regex (.*)
+        size_t startPos = uriOrRegex.find("*");
+        while (startPos != std::string::npos) {
+            uriOrRegex.replace(startPos, 1, "(.*)");
+            startPos += 4;
+            startPos = uriOrRegex.find("*", startPos);
+        }
+
+        std::string groupName;
+        if (doesUriContainGroupTag(uriOrRegex, groupName)) {
+            std::string pathRemainderToMatch = extractUriWithoutGroupName(uriOrRegex);
+            //Remove group name from start of regex and replace with '.*'
+            uriOrRegex = replaceUriWithGroupName(uriOrRegex, ".*");
+        }
+
+        try {
+            applyRegularExpression(
+                L,
+                std::regex(uriOrRegex),
+                allProperties(),
+                interpolationDuration,
+                groupName,
+                easingMethod
+            );
+        }
+        catch (const std::regex_error& e) {
+            LERRORC(
+                "property_setValue",
+                fmt::format(
+                    "Malformed regular expression: '{}': {}", uriOrRegex, e.what()
+                )
+            );
+        }
+        return 0;
+    }
+    else if (optimization == "regex") {
+        try {
+            applyRegularExpression(
+                L,
+                std::regex(uriOrRegex),
+                allProperties(),
+                interpolationDuration,
+                "",
+                easingMethod
+            );
+        }
+        catch (const std::regex_error& e) {
+            LERRORC(
+                "property_setValueRegex",
+                fmt::format(
+                    "Malformed regular expression: '{}': {}", uriOrRegex, e.what()
+                )
+            );
+        }
+    }
+    else if (optimization == "single") {
+        properties::Property* prop = property(uriOrRegex);
+        if (!prop) {
+            LERRORC(
+                "property_setValue",
+                fmt::format(
+                    "{}: Property with URI '{}' was not found",
+                    errorLocation(L),
+                    uriOrRegex
+                )
+            );
+            return 0;
+        }
+        return setPropertyCall_single(
+            *prop,
+            uriOrRegex,
+            L,
+            interpolationDuration,
+            easingMethod
+        );
+    }
+    else {
+        LERRORC(
+            "lua::property_setGroup",
+            fmt::format(
+                "{}: Unexpected optimization '{}'",
+                errorLocation(L),
+                optimization
+            )
+        );
+    }
     return 0;
 }
 
-/**
- * \ingroup LuaScripts
- * setPropertyValueRegex(string, *):
- * Sets all property(s) that pass the regular expression in the first argument. The second
- * argument can be any type, but it has to match the type of the properties that matched
- * the regular expression. The regular expression has to be of the ECMAScript grammar.
- * If the first term (separated by '.') in the uri is bracketed with { }, then this
- * term is treated as a group tag name, and the function will search through all
- * property owners to find those that are tagged with this group name, and set their
- * property values accordingly.
-*/
-int property_setValueRegex(lua_State* L) {
-    using ghoul::lua::errorLocation;
-    using ghoul::lua::luaTypeToString;
-
-    ghoul::lua::checkArgumentsAndThrow(L, 2, "lua::property_setValueRegex");
-
-    std::string regex = luaL_checkstring(L, -2);
-    std::string groupName;
-
-    if (doesUriContainGroupTag(regex, groupName)) {
-        std::string pathRemainderToMatch = extractUriWithoutGroupName(regex);
-        //Remove group name from start of regex and replace with '.*'
-        regex = replaceUriWithGroupName(regex, ".*");
-    }
-
-    try {
-        applyRegularExpression(
-            L,
-            std::regex(regex, std::regex_constants::optimize),
-            allProperties(),
-            lua_type(L, -1),
-            groupName
-        );
-    }
-    catch (const std::regex_error& e) {
-        LERRORC("property_setValueRegex", "Malformed regular expression: '"
-            << regex << "':" << e.what());
-    }
-
-    return 0;
+int property_setValueSingle(lua_State* L) {
+    lua_pushstring(L, "single");
+    return property_setValue(L);
 }
 
 /**
@@ -317,7 +365,11 @@ int property_getValue(lua_State* L) {
     if (!prop) {
         LERRORC(
             "property_getValue",
-            errorLocation(L) << "Property with URL '" << uri << "' was not found"
+            fmt::format(
+                "{}: Property with URI '{}' was not found",
+                errorLocation(L),
+                uri
+            )
         );
         ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
         return 0;
@@ -394,16 +446,16 @@ int removeSceneGraphNode(lua_State* L) {
     if (!node) {
         LERRORC(
             "removeSceneGraphNode",
-            errorLocation(L) << "Could not find node '" << nodeName << "'"
-            );
+            fmt::format("{}: Could not find node '{}'", errorLocation(L), nodeName)
+        );
         return 0;
     }
     SceneGraphNode* parent = node->parent();
     if (!parent) {
         LERRORC(
             "removeSceneGraphNode",
-            errorLocation(L) << "Cannot remove root node"
-            );
+            fmt::format("{}: Cannot remove root node", errorLocation(L))
+        );
         return 0;
     }
     node->deinitializeGL();
diff --git a/src/scene/scenegraphnode.cpp b/src/scene/scenegraphnode.cpp
index 678dac0f4e..46bf237288 100644
--- a/src/scene/scenegraphnode.cpp
+++ b/src/scene/scenegraphnode.cpp
@@ -93,12 +93,15 @@ std::unique_ptr<SceneGraphNode> SceneGraphNode::createFromDictionary(
             translationDictionary
         );
         if (result->_transform.translation == nullptr) {
-            LERROR("Failed to create ephemeris for SceneGraphNode '"
-                << result->name() << "'");
+            LERROR(fmt::format(
+                "Failed to create ephemeris for SceneGraphNode '{}'", result->name()
+            ));
             return nullptr;
         }
         result->addPropertySubOwner(result->_transform.translation.get());
-        LDEBUG("Successfully created ephemeris for '" << result->name() << "'");
+        LDEBUG(fmt::format(
+            "Successfully created ephemeris for '{}'", result->name()
+        ));
     }
 
     if (dictionary.hasKey(keyTransformRotation)) {
@@ -106,12 +109,13 @@ std::unique_ptr<SceneGraphNode> SceneGraphNode::createFromDictionary(
         dictionary.getValue(keyTransformRotation, rotationDictionary);
         result->_transform.rotation = Rotation::createFromDictionary(rotationDictionary);
         if (result->_transform.rotation == nullptr) {
-            LERROR("Failed to create rotation for SceneGraphNode '"
-                << result->name() << "'");
+            LERROR(fmt::format(
+                "Failed to create rotation for SceneGraphNode '{}'", result->name()
+            ));
             return nullptr;
         }
         result->addPropertySubOwner(result->_transform.rotation.get());
-        LDEBUG("Successfully created rotation for '" << result->name() << "'");
+        LDEBUG(fmt::format("Successfully created rotation for '{}'", result->name()));
     }
 
     if (dictionary.hasKey(keyTransformScale)) {
@@ -119,12 +123,13 @@ std::unique_ptr<SceneGraphNode> SceneGraphNode::createFromDictionary(
         dictionary.getValue(keyTransformScale, scaleDictionary);
         result->_transform.scale = Scale::createFromDictionary(scaleDictionary);
         if (result->_transform.scale == nullptr) {
-            LERROR("Failed to create scale for SceneGraphNode '"
-                << result->name() << "'");
+            LERROR(fmt::format(
+                "Failed to create scale for SceneGraphNode '{}'", result->name()
+            ));
             return nullptr;
         }
         result->addPropertySubOwner(result->_transform.scale.get());
-        LDEBUG("Successfully created scale for '" << result->name() << "'");
+        LDEBUG(fmt::format("Successfully created scale for '{}'", result->name()));
     }
 
     // We initialize the renderable last as it probably has the most dependencies
@@ -136,12 +141,13 @@ std::unique_ptr<SceneGraphNode> SceneGraphNode::createFromDictionary(
 
         result->_renderable = Renderable::createFromDictionary(renderableDictionary);
         if (result->_renderable == nullptr) {
-            LERROR("Failed to create renderable for SceneGraphNode '"
-                << result->name() << "'");
+            LERROR(fmt::format(
+                "Failed to create renderable for SceneGraphNode '{}'", result->name()
+            ));
             return nullptr;
         }
         result->addPropertySubOwner(result->_renderable.get());
-        LDEBUG("Successfully created renderable for '" << result->name() << "'");
+        LDEBUG(fmt::format("Successfully created renderable for '{}'", result->name()));
     }
 
     if (dictionary.hasKey(KeyTag)) {
@@ -167,8 +173,7 @@ std::unique_ptr<SceneGraphNode> SceneGraphNode::createFromDictionary(
         result->_guiPath = dictionary.value<std::string>(KeyGuiPath);
     }
 
-    LDEBUG("Successfully created SceneGraphNode '"
-                   << result->name() << "'");
+    LDEBUG(fmt::format("Successfully created SceneGraphNode '{}'", result->name()));
     return result;
 }
 
@@ -189,7 +194,7 @@ SceneGraphNode::SceneGraphNode()
 SceneGraphNode::~SceneGraphNode() {}
 
 void SceneGraphNode::initialize() {
-    LDEBUG("Initialize: " << name());
+    LDEBUG(fmt::format("Initialize: {}", name()));
     if (_renderable) {
         _renderable->initialize();
     }
@@ -214,7 +219,7 @@ void SceneGraphNode::initializeGL() {
 }
 
 void SceneGraphNode::deinitialize() {
-    LDEBUG("Deinitialize: " << name());
+    LDEBUG(fmt::format("Deinitialize: {}", name()));
 
     setScene(nullptr);
 
diff --git a/src/scripting/scriptengine.cpp b/src/scripting/scriptengine.cpp
index 167c96d26f..5d70cfa16d 100644
--- a/src/scripting/scriptengine.cpp
+++ b/src/scripting/scriptengine.cpp
@@ -129,8 +129,11 @@ void ScriptEngine::addLibrary(LuaLibrary library) {
             if (itf != merged.functions.end()) {
                 // the function with the desired name is already present, but we don't
                 // want to overwrite it
-                LERROR("Lua function '" << fun.name << "' in library '" << library.name <<
-                    "' has been defined twice");
+                LERROR(fmt::format(
+                    "Lua function '{}' in library '{}' has been defined twice",
+                    fun.name,
+                    library.name
+                ));
                 return;
             }
             else {
@@ -192,7 +195,7 @@ bool ScriptEngine::runScriptFile(const std::string& filename) {
         return false;
     }
     if (!FileSys.fileExists(filename)) {
-        LERROR("Script with name '" << filename << "' did not exist");
+        LERROR(fmt::format("Script with name '{}' did not exist", filename));
         return false;
     }
 
@@ -227,32 +230,34 @@ bool ScriptEngine::isLibraryNameAllowed(lua_State* state, const std::string& nam
             result = true;
             break;
         case LUA_TBOOLEAN:
-            LERROR("Library name '" << name << "' specifies a boolean");
+            LERROR(fmt::format("Library name '{}' specifies a boolean", name));
             break;
         case LUA_TLIGHTUSERDATA:
-            LERROR("Library name '" << name << "' specifies a light user data");
+            LERROR(fmt::format("Library name '{}' specifies a light user data", name));
             break;
         case LUA_TNUMBER:
-            LERROR("Library name '" << name << "' specifies a number");
+            LERROR(fmt::format("Library name '{}' specifies a number", name));
             break;
         case LUA_TSTRING:
-            LERROR("Library name '" << name << "' specifies a string");
+            LERROR(fmt::format("Library name '{}' specifies a string", name));
             break;
         case LUA_TTABLE: {
             if (hasLibrary(name))
-                LERROR("Library with name '" << name << "' has been registered before");
+                LERROR(fmt::format(
+                    "Library with name '{}' has been registered before", name
+                ));
             else
-                LERROR("Library name '" << name << "' specifies a table");
+                LERROR(fmt::format("Library name '{}' specifies a table", name));
             break;
         }
         case LUA_TFUNCTION:
-            LERROR("Library name '" << name << "' specifies a function");
+            LERROR(fmt::format("Library name '{}' specifies a function", name));
             break;
         case LUA_TUSERDATA:
-            LERROR("Library name '" << name << "' specifies a user data");
+            LERROR(fmt::format("Library name '{}' specifies a user data", name));
             break;
         case LUA_TTHREAD:
-            LERROR("Library name '" << name << "' specifies a thread");
+            LERROR(fmt::format("Library name '{}' specifies a thread", name));
             break;
     }
 
@@ -269,7 +274,7 @@ void ScriptEngine::addLibraryFunctions(lua_State* state, LuaLibrary& library,
             lua_getfield(state, -1, p.name.c_str());
             const bool isNil = lua_isnil(state, -1);
             if (!isNil) {
-                LERROR("Function name '" << p.name << "' was already assigned");
+                LERROR(fmt::format("Function name '{}' was already assigned", p.name));
                 return;
             }
             lua_pop(state, 1);
@@ -292,9 +297,11 @@ void ScriptEngine::addLibraryFunctions(lua_State* state, LuaLibrary& library,
         lua_pushstring(state, "documentation");
         lua_gettable(state, -2);
         if (lua_isnil(state, -1)) {
-            LERROR(
-                "Module '" << library.name << "' did not provide a documentation in " <<
-                "script file '" << script << "'");
+            LERROR(fmt::format(
+                "Module '{}' did not provide a documentation in script file '{}'",
+                library.name,
+                script
+            ));
         }
         else {
             lua_pushnil(state);
@@ -573,17 +580,7 @@ std::string ScriptEngine::generateJson() const {
     }
     json << "]";
 
-    std::string jsonString = "";
-    for (const char& c : json.str()) {
-        if (c == '\'') {
-            jsonString += "\\'";
-        }
-        else {
-            jsonString += c;
-        }
-    }
-
-    return jsonString;
+    return json.str();
 }
 
 bool ScriptEngine::writeLog(const std::string& script) {
@@ -602,15 +599,17 @@ bool ScriptEngine::writeLog(const std::string& script) {
             _logFilename = absPath(_logFilename);
             _logFileExists = true;
 
-            LDEBUG("Using script log of type '" << _logType <<
-                   "' to file '" << _logFilename << "'");
+            LDEBUG(fmt::format(
+                "Using script log of type '{}' to file '{}'", _logType, _logFilename
+            ));
 
             // Test file and clear previous input
             std::ofstream file(_logFilename, std::ofstream::out | std::ofstream::trunc);
 
             if (!file.good()) {
-                LERROR("Could not open file '" << _logFilename
-                       << "' for logging scripts");
+                LERROR(fmt::format(
+                    "Could not open file '{}' for logging scripts", _logFilename
+                ));
 
                 return false;
             }
@@ -623,7 +622,7 @@ bool ScriptEngine::writeLog(const std::string& script) {
     // Simple text output to logfile
     std::ofstream file(_logFilename, std::ofstream::app);
     if (!file.good()) {
-        LERROR("Could not open file '" << _logFilename << "' for logging scripts");
+        LERROR(fmt::format("Could not open file '{}' for logging scripts", _logFilename));
         return false;
     }
 
diff --git a/src/scripting/scriptengine_lua.inl b/src/scripting/scriptengine_lua.inl
index 91a61df7ae..ea08a2774e 100644
--- a/src/scripting/scriptengine_lua.inl
+++ b/src/scripting/scriptengine_lua.inl
@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <ghoul/filesystem/directory.h>
+#include <ghoul/filesystem/file.h>
 
 namespace openspace::luascriptfunctions {
 
@@ -96,19 +97,22 @@ int printInternal(ghoul::logging::LogLevel level, lua_State* L) {
         case LUA_TFUNCTION:
         case LUA_TUSERDATA:
         case LUA_TTHREAD:
-            LOGC(level, "print", "Function parameter was of type '" <<
-                    luaTypeToString(type) << "'");
+            log(
+                level,
+                "print",
+                fmt::format("Function parameter was of type '{}'", luaTypeToString(type))
+            );
             break;
         case LUA_TNIL:
             break;
         case LUA_TBOOLEAN:
-            LOGC(level, "print", lua_toboolean(L, -1));
+            log(level, "print", fmt::format("{}", lua_toboolean(L, -1)));
             break;
         case LUA_TNUMBER:
-            LOGC(level, "print", lua_tonumber(L, -1));
+            log(level, "print", fmt::format("{}", lua_tonumber(L, -1)));
             break;
         case LUA_TSTRING:
-            LOGC(level, "print", lua_tostring(L, -1));
+            log(level, "print", lua_tostring(L, -1));
             break;
     }
     lua_settop(L, 0);
@@ -306,7 +310,7 @@ int directoryForPath(lua_State* L) {
     const std::string path = ghoul::filesystem::File(file).directoryName();
 
     lua_pushstring(L, path.c_str());
-    
+
     return 1;
 }
 
diff --git a/src/scripting/scriptscheduler.cpp b/src/scripting/scriptscheduler.cpp
index cc4d03f706..0fe0b24e7a 100644
--- a/src/scripting/scriptscheduler.cpp
+++ b/src/scripting/scriptscheduler.cpp
@@ -29,7 +29,7 @@
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/util/time.h>
 #include <ghoul/logging/logmanager.h>
-#include <ghoul/filesystem/filesystem>
+//#include <ghoul/filesystem/filesystem>
 
 #include <openspace/documentation/documentation.h>
 #include <openspace/documentation/verifier.h>
diff --git a/src/scripting/scriptscheduler_lua.inl b/src/scripting/scriptscheduler_lua.inl
index ab32cbf98c..3aa1d5192a 100644
--- a/src/scripting/scriptscheduler_lua.inl
+++ b/src/scripting/scriptscheduler_lua.inl
@@ -84,6 +84,7 @@ int loadScheduledScript(lua_State* L) {
         });
     }
 
+    lua_settop(L, 0);
     ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
     return 0;
 }
diff --git a/src/scripting/systemcapabilitiesbinding.cpp b/src/scripting/systemcapabilitiesbinding.cpp
index 5c237bafd1..0b892477a6 100644
--- a/src/scripting/systemcapabilitiesbinding.cpp
+++ b/src/scripting/systemcapabilitiesbinding.cpp
@@ -25,12 +25,11 @@
 #include <openspace/scripting/systemcapabilitiesbinding.h>
 
 #include <openspace/scripting/scriptengine.h>
-
+#include <ghoul/fmt.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/misc.h>
 #include <ghoul/systemcapabilities/generalcapabilitiescomponent.h>
 #include <ghoul/systemcapabilities/openglcapabilitiescomponent.h>
-
 #include <cctype>
 
 using namespace ghoul::lua;
@@ -87,7 +86,10 @@ int hasOpenGLVersion(lua_State* L) {
 
     std::vector<std::string> v = ghoul::tokenizeString(ghoul::lua::checkStringAndPop(L));
     if (v.size() != 2 && v.size() != 3) {
-        LERRORC("hasVersion", ghoul::lua::errorLocation(L) << "Malformed version string");
+        LERRORC(
+            "hasVersion",
+            fmt::format("{}: Malformed version string", ghoul::lua::errorLocation(L))
+        );
         return 0;
     }
 
@@ -96,7 +98,9 @@ int hasOpenGLVersion(lua_State* L) {
             if (!std::isdigit(c)) {
                 LERRORC(
                     "hasVersion",
-                    ghoul::lua::errorLocation(L) << "Malformed version string"
+                    fmt::format(
+                        "{}: Malformed version string", ghoul::lua::errorLocation(L)
+                    )
                 );
                 return 0;
             }
diff --git a/src/util/blockplaneintersectiongeometry.cpp b/src/util/blockplaneintersectiongeometry.cpp
index 75e7028eeb..22a059c5df 100644
--- a/src/util/blockplaneintersectiongeometry.cpp
+++ b/src/util/blockplaneintersectiongeometry.cpp
@@ -36,12 +36,11 @@ namespace {
 
 namespace openspace {
 
-BlockPlaneIntersectionGeometry::BlockPlaneIntersectionGeometry(
-        glm::vec3 blockSize,
-        glm::vec3 planeNormal,
-        float planeDistance)
-    : _initialized(false)
-    , _vaoId(0)
+BlockPlaneIntersectionGeometry::BlockPlaneIntersectionGeometry(glm::vec3 blockSize,
+                                                               glm::vec3 planeNormal,
+                                                               float planeDistance)
+    // : _initialized(false)
+    : _vaoId(0)
     , _vBufferId(0)
     , _size(blockSize)
 {}
diff --git a/src/util/httprequest.cpp b/src/util/httprequest.cpp
index b88a861a90..caf1cc1576 100644
--- a/src/util/httprequest.cpp
+++ b/src/util/httprequest.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/util/httprequest.h>
 
+#include <ghoul/fmt.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/assert.h>
@@ -320,7 +321,7 @@ HttpFileDownload::HttpFileDownload(
 
 bool HttpFileDownload::initDownload() {
     if (!_overwrite && FileSys.fileExists(_destination)) {
-        LWARNING("File " << _destination << " already exists!");
+        LWARNING(fmt::format("File {} already exists", _destination));
         return false;
     }
 
@@ -361,39 +362,45 @@ bool HttpFileDownload::initDownload() {
 
             std::string message(Buffer, size);
 
-            LERROR("Cannot open file " << destinationFile << ": " << message);
+            LERROR(fmt::format("Cannot open file {}: {}", destinationFile, message));
 
             return false;
         }
         else {
-            LERROR("Cannot open file " << destinationFile);
+            LERROR(fmt::format("Cannot open file {}", destinationFile));
             return false;
         }
 #else
         if (errno) {
 #if defined(__unix__)
             char buffer[255];
-            LERROR(
-                "Cannot open file " << destinationFile << ": " <<
+            LERROR(fmt::format(
+                "Cannot open file '{}': {}",
+                destinationFile,
                 std::string(strerror_r(errno, buffer, sizeof(buffer)))
-            );
+            ));
             return false;
 #else
-            LERROR(
-                "Cannot open file " << destinationFile << ": " <<
+            LERROR(fmt::format(
+                "Cannot open file '{}': {}",
+                destinationFile,
                 std::string(strerror(errno))
-            );
+            ));
             return false;
 #endif
         }
 
-        LERROR("Cannot open file " << destinationFile);
+        LERROR(fmt::format("Cannot open file {}", destinationFile));
         return false;
 #endif
     }
     return true;
 }
 
+const std::string& HttpFileDownload::destination() const {
+    return _destination;
+}
+
 bool HttpFileDownload::deinitDownload() {
     _file.close();
     --nCurrentFilehandles;
diff --git a/src/util/keys.cpp b/src/util/keys.cpp
index 87f3969cd0..a7d17f76ee 100644
--- a/src/util/keys.cpp
+++ b/src/util/keys.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/util/keys.h>
 
+#include <ghoul/fmt.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/misc.h>
 
@@ -102,7 +103,7 @@ KeyWithModifier stringToKey(std::string str) {
                 m |= itMod->second;
             }
             else {
-                LERROR("Unknown modifier key '" << s << "'");
+                LERROR(fmt::format("Unknown modifier key '{}'", s));
             }
         }
     );
diff --git a/src/util/openspacemodule.cpp b/src/util/openspacemodule.cpp
index 12ea8def9d..197dfb40ae 100644
--- a/src/util/openspacemodule.cpp
+++ b/src/util/openspacemodule.cpp
@@ -26,7 +26,8 @@
 
 #include <openspace/documentation/documentation.h>
 
-#include <ghoul/filesystem/filesystem>
+#include <ghoul/fmt.h>
+#include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/misc/dictionary.h>
 
@@ -63,7 +64,7 @@ void OpenSpaceModule::initialize(const ModuleEngine* moduleEngine,
         ghoul::filesystem::FileSystem::TokenClosingBraces;
 
     std::string path = modulePath();
-    LDEBUG("Registering module path: " << moduleToken << ": " << path);
+    LDEBUG(fmt::format("Registering module path {}: {}", moduleToken, path));
     FileSys.registerPathToken(moduleToken, path);
 
     _moduleEngine = moduleEngine;
diff --git a/src/util/powerscaledcoordinate.cpp b/src/util/powerscaledcoordinate.cpp
index e5fbdbb512..902214eba1 100644
--- a/src/util/powerscaledcoordinate.cpp
+++ b/src/util/powerscaledcoordinate.cpp
@@ -93,9 +93,9 @@ PowerScaledCoordinate
     // rescale and return
     double tp = 1.0 / pow(k, digits);
     return PowerScaledCoordinate(
-        static_cast<float>(d1 * tp), 
-        static_cast<float>(d2 * tp), 
-        static_cast<float>(d3 * tp), 
+        static_cast<float>(d1 * tp),
+        static_cast<float>(d2 * tp),
+        static_cast<float>(d3 * tp),
         static_cast<float>(digits));
 }
 
@@ -178,12 +178,14 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator+=(const PowerScaledCoordi
         double p = pow(k, -ds);
         *this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] * p + _vec[0]),
                                       static_cast<float>(rhs._vec[1] * p + _vec[1]),
-                                      static_cast<float>(rhs._vec[2] * p + _vec[2]), _vec[3]);
+                                      static_cast<float>(rhs._vec[2] * p + _vec[2]),
+                                      _vec[3]);
     } else {
         double p = pow(k, ds);
         *this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] + _vec[0] * p),
                                       static_cast<float>(rhs._vec[1] + _vec[1] * p),
-                                      static_cast<float>(rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
+                                      static_cast<float>(rhs._vec[2] + _vec[2] * p),
+                                      rhs._vec[3]);
     }
 
     return *this;
@@ -202,12 +204,14 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator-=(const PowerScaledCoordi
         double p = pow(k, -ds);
         *this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] * p + _vec[0]),
                                       static_cast<float>(-rhs._vec[1] * p + _vec[1]),
-                                      static_cast<float>(-rhs._vec[2] * p + _vec[2]), _vec[3]);
+                                      static_cast<float>(-rhs._vec[2] * p + _vec[2]),
+                                      _vec[3]);
     } else {
         double p = pow(k, ds);
         *this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] + _vec[0] * p),
                                       static_cast<float>(-rhs._vec[1] + _vec[1] * p),
-                                      static_cast<float>(-rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
+                                      static_cast<float>(-rhs._vec[2] + _vec[2] * p),
+                                      rhs._vec[3]);
     }
 
     return *this;
@@ -215,8 +219,8 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator-=(const PowerScaledCoordi
 
 PowerScaledCoordinate PowerScaledCoordinate::operator*(const double& rhs) const
 {
-    return PowerScaledCoordinate(static_cast<float>(_vec[0] * rhs), 
-                                 static_cast<float>(_vec[1] * rhs), 
+    return PowerScaledCoordinate(static_cast<float>(_vec[0] * rhs),
+                                 static_cast<float>(_vec[1] * rhs),
                                  static_cast<float>(_vec[2] * rhs), _vec[3]);
 }
 
@@ -231,13 +235,13 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator*=(const PowerScaledScalar
     if (ds >= 0.0) {
         double p = pow(k, -ds);
         *this = PowerScaledCoordinate(
-            static_cast<float>(rhs._data[0] * p * _vec[0]), 
+            static_cast<float>(rhs._data[0] * p * _vec[0]),
             static_cast<float>(rhs._data[0] * p * _vec[1]),
             static_cast<float>(rhs._data[0] * p * _vec[2]), this->_vec[3] + _vec[3]);
     } else {
         double p = pow(k, ds);
         *this = PowerScaledCoordinate(
-            static_cast<float>(rhs._data[0] * _vec[0] * p), 
+            static_cast<float>(rhs._data[0] * _vec[0] * p),
             static_cast<float>(rhs._data[0] * _vec[1] * p),
             static_cast<float>(rhs._data[0] * _vec[2] * p), rhs._data[1] + rhs._data[1]);
     }
diff --git a/src/util/powerscaledscalar.cpp b/src/util/powerscaledscalar.cpp
index 05c742340b..890f4f597c 100644
--- a/src/util/powerscaledscalar.cpp
+++ b/src/util/powerscaledscalar.cpp
@@ -97,11 +97,11 @@ PowerScaledScalar & PowerScaledScalar::operator+=(const PowerScaledScalar &rhs)
     double ds = this->_data[1] - rhs._data[1];
     if(ds >= 0.0) {
         *this = PowerScaledScalar(
-            static_cast<float>(rhs._data[0] * pow(k, -ds) + this->_data[0]), 
+            static_cast<float>(rhs._data[0] * pow(k, -ds) + this->_data[0]),
             this->_data[1]);
     } else {
         *this = PowerScaledScalar(
-            static_cast<float>(rhs._data[0] + this->_data[0] * pow(k, ds)), 
+            static_cast<float>(rhs._data[0] + this->_data[0] * pow(k, ds)),
             rhs._data[1]);
     }
 
@@ -117,11 +117,11 @@ PowerScaledScalar & PowerScaledScalar::operator-=(const PowerScaledScalar &rhs)
     double ds = this->_data[1] - rhs._data[1];
     if(ds >= 0.0) {
         *this = PowerScaledScalar(
-            static_cast<float>(-rhs._data[0] * pow(k, -ds) + this->_data[0]), 
+            static_cast<float>(-rhs._data[0] * pow(k, -ds) + this->_data[0]),
             this->_data[1]);
     } else {
         *this = PowerScaledScalar(
-            static_cast<float>(-rhs._data[0] + this->_data[0] * pow(k, ds)), 
+            static_cast<float>(-rhs._data[0] + this->_data[0] * pow(k, ds)),
             rhs._data[1]);
     }
 
@@ -136,11 +136,11 @@ PowerScaledScalar & PowerScaledScalar::operator*=(const PowerScaledScalar &rhs)
     double ds = this->_data[1] - rhs._data[1];
     if(ds >= 0.0) {
         *this = PowerScaledScalar(
-            static_cast<float>(rhs._data[0] * pow(k, -ds) * this->_data[0]), 
+            static_cast<float>(rhs._data[0] * pow(k, -ds) * this->_data[0]),
             this->_data[1] + this->_data[1]);
     } else {
         *this = PowerScaledScalar(
-            static_cast<float>(rhs._data[0] * this->_data[0] * pow(k, ds)), 
+            static_cast<float>(rhs._data[0] * this->_data[0] * pow(k, ds)),
             rhs._data[1] + rhs._data[1]);
     }
 
@@ -157,7 +157,7 @@ PowerScaledScalar & PowerScaledScalar::operator*=(const float &rhs) {
     double ds = this->_data[1];
     if(ds >= 0) {
         *this = PowerScaledScalar(
-            static_cast<float>(rhs*pow(k, -ds) * this->_data[0]), 
+            static_cast<float>(rhs*pow(k, -ds) * this->_data[0]),
             this->_data[1] + this->_data[1]);
     } else {
         *this = PowerScaledScalar(
@@ -188,11 +188,6 @@ bool PowerScaledScalar::operator<(const PowerScaledScalar &other) const {
     if(ds >= 0) {
         double upscaled = other._data[0]*pow(k,-ds);
         return _data[0] < upscaled;
-        /*
-        bool retur =(vec_[0] < upscaled);
-        std::printf("this: %f, upscaled: %f, this<upscaled: %i\n", vec_[0], upscaled, retur);
-        return retur;
-        */
     } else {
         double upscaled = _data[0]*pow(k,-ds);
         return other._data[0] > upscaled;
diff --git a/src/util/powerscaledsphere.cpp b/src/util/powerscaledsphere.cpp
index 4308fe7a51..fa0983b035 100644
--- a/src/util/powerscaledsphere.cpp
+++ b/src/util/powerscaledsphere.cpp
@@ -94,12 +94,12 @@ PowerScaledSphere::PowerScaledSphere(const PowerScaledScalar& radius, int segmen
             const int t = segments + 1;
             _iarray[nr] = t * (i - 1) + j + 0; //1
             ++nr;
-            _iarray[nr] = t * (i + 0) + j + 0; //2 
+            _iarray[nr] = t * (i + 0) + j + 0; //2
             ++nr;
             _iarray[nr] = t * (i + 0) + j + 1; //3
             ++nr;
 
-            _iarray[nr] = t * (i - 1) + j + 0; //4 
+            _iarray[nr] = t * (i - 1) + j + 0; //4
             ++nr;
             _iarray[nr] = t * (i + 0) + j + 1; //5
             ++nr;
@@ -109,20 +109,20 @@ PowerScaledSphere::PowerScaledSphere(const PowerScaledScalar& radius, int segmen
             /*
             _iarray[nr] = t * (i - 1) + j + 0; //1
             ++nr;
-            _iarray[nr] = t * (i + 0) + j + 0; //2 
+            _iarray[nr] = t * (i + 0) + j + 0; //2
             ++nr;
             _iarray[nr] = t * (i + 0) + j + 1; //3
             ++nr;
             _iarray[nr] = t * (i - 1) + j + 1; //6
             ++nr;
-            _iarray[nr] = t * (i - 1) + j + 0; //4 
+            _iarray[nr] = t * (i - 1) + j + 0; //4
             ++nr;
             */
         }
     }
 }
 
-// Alternative Constructor for using accurate triaxial ellipsoid 
+// Alternative Constructor for using accurate triaxial ellipsoid
 PowerScaledSphere::PowerScaledSphere(glm::vec3 radius, int segments)
     : _vaoID(0)
     , _vBufferID(0)
@@ -181,12 +181,12 @@ PowerScaledSphere::PowerScaledSphere(glm::vec3 radius, int segments)
             const int t = segments + 1;
             _iarray[nr] = t * (i - 1) + j + 0; //1
             ++nr;
-            _iarray[nr] = t * (i + 0) + j + 0; //2 
+            _iarray[nr] = t * (i + 0) + j + 0; //2
             ++nr;
             _iarray[nr] = t * (i + 0) + j + 1; //3
             ++nr;
 
-            _iarray[nr] = t * (i - 1) + j + 0; //4 
+            _iarray[nr] = t * (i - 1) + j + 0; //4
             ++nr;
             _iarray[nr] = t * (i + 0) + j + 1; //5
             ++nr;
@@ -196,7 +196,7 @@ PowerScaledSphere::PowerScaledSphere(glm::vec3 radius, int segments)
     }
 }
 
-PowerScaledSphere::PowerScaledSphere(const PowerScaledSphere& cpy) 
+PowerScaledSphere::PowerScaledSphere(const PowerScaledSphere& cpy)
     : _vaoID(cpy._vaoID)
     , _vBufferID(cpy._vBufferID)
     , _iBufferID(cpy._iBufferID)
diff --git a/src/util/screenlog.cpp b/src/util/screenlog.cpp
index 5fc063c4bc..e0ce4c8e2e 100644
--- a/src/util/screenlog.cpp
+++ b/src/util/screenlog.cpp
@@ -57,7 +57,7 @@ void ScreenLog::log(LogLevel level, const string& category, const string& messag
         _entries.push_back({
             level,
             std::chrono::steady_clock::now(),
-            Log::getTimeString(),
+            Log::timeString(),
             category,
             message
         });
diff --git a/src/util/spicemanager.cpp b/src/util/spicemanager.cpp
index b75da976b8..6cf77c1580 100644
--- a/src/util/spicemanager.cpp
+++ b/src/util/spicemanager.cpp
@@ -25,6 +25,7 @@
 #include <openspace/util/spicemanager.h>
 
 #include <ghoul/logging/logmanager.h>
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/misc/assert.h>
 #include <ghoul/misc/exception.h>
@@ -32,7 +33,7 @@
 #include <glm/gtc/type_ptr.hpp>
 
 #include <algorithm>
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 
 #include "SpiceUsr.h"
 #include "SpiceZpr.h"
@@ -43,7 +44,7 @@ namespace {
     // The value comes from
     // http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/getmsg_c.html
     // as the maximum message length
-    const unsigned SpiceErrorBufferSize = 1841;
+    constexpr const unsigned SpiceErrorBufferSize = 1841;
 
     // This method checks if one of the previous SPICE methods has failed. If it has, an
     // exception with the SPICE error message is thrown
@@ -239,7 +240,7 @@ SpiceManager::KernelHandle SpiceManager::loadKernel(string filePath) {
     string fileDirectory = ghoul::filesystem::File(path, RawPath::Yes).directoryName();
     FileSys.setCurrentDirectory(fileDirectory);
 
-    LINFO("Loading SPICE kernel '" << path << "'");
+    LINFO(fmt::format("Loading SPICE kernel '{}'", path));
     // Load the kernel
     furnsh_c(path.c_str());
 
diff --git a/src/util/spicemanager_lua.inl b/src/util/spicemanager_lua.inl
index 330c167475..fa26c3572e 100644
--- a/src/util/spicemanager_lua.inl
+++ b/src/util/spicemanager_lua.inl
@@ -22,6 +22,8 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
+#include <ghoul/filesystem/filesystem.h>
+
 namespace openspace::luascriptfunctions {
 
 /**
@@ -36,7 +38,9 @@ int loadKernel(lua_State* L) {
 
     bool isString = (lua_isstring(L, -1) == 1);
     if (!isString) {
-        LERROR(ghoul::lua::errorLocation(L) << "Expected argument of type 'string'");
+        LERROR(fmt::format(
+            "{}: Expected argument of type 'string'", ghoul::lua::errorLocation(L)
+        ));
         return 0;
     }
 
@@ -66,8 +70,10 @@ int unloadKernel(lua_State* L) {
     if (!isString && !isNumber) {
         LERRORC(
             "loadKernel",
-            ghoul::lua::errorLocation(L) <<
-            "Expected argument of type 'string' or 'number'"
+            fmt::format(
+                "{}: Expected argument of type 'string' or 'number'",
+                ghoul::lua::errorLocation(L)
+            )
         );
         lua_settop(L, 0);
         ghoul_assert(lua_gettop(L) == 0, "Incorrect number of items left on stack");
diff --git a/src/util/taskloader.cpp b/src/util/taskloader.cpp
index 1278b6b9f5..f5cb1a21bb 100644
--- a/src/util/taskloader.cpp
+++ b/src/util/taskloader.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/util/taskloader.h>
 
+#include <ghoul/filesystem/file.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/lua/lua_helper.h>
@@ -54,7 +55,9 @@ std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromDictionary(
             std::string taskType = subTask.value<std::string>("Type");
             std::unique_ptr<Task> task = Task::createFromDictionary(subTask);
             if (!task) {
-                LERROR("Failed to create a Task object of type '" << taskType << "'");
+                LERROR(fmt::format(
+                    "Failed to create a Task object of type '{}'", taskType
+                ));
             }
             tasks.push_back(std::move(task));
         }
@@ -65,8 +68,9 @@ std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromDictionary(
 std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromFile(const std::string& path) {
     std::string absTasksFile = absPath(path);
     if (!FileSys.fileExists(ghoul::filesystem::File(absTasksFile))) {
-        LERROR("Could not load tasks file '" << absTasksFile << "'. " <<
-            "File not found");
+        LERROR(fmt::format(
+            "Could not load tasks file '{}. File not found", absTasksFile
+        ));
         return std::vector<std::unique_ptr<Task>>();
     }
 
@@ -77,8 +81,12 @@ std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromFile(const std::string&
             tasksDictionary
         );
     } catch (const ghoul::RuntimeError& e) {
-        LERROR("Could not load tasks file '" << absTasksFile << "'. " <<
-            "Lua error: " << e.message << ": " << e.component);
+        LERROR(fmt::format(
+            "Could not load tasks file '{}. Lua error: {}: {}",
+            absTasksFile,
+            e.message,
+            e.component
+        ));
         return std::vector<std::unique_ptr<Task>>();
     }
     return tasksFromDictionary(tasksDictionary);
diff --git a/src/util/time_lua.inl b/src/util/time_lua.inl
index 396a86f552..996d8bb56c 100644
--- a/src/util/time_lua.inl
+++ b/src/util/time_lua.inl
@@ -24,7 +24,7 @@
 
 #include <ghoul/misc/assert.h>
 
-#include <fmt/format.h>
+#include <ghoul/fmt.h>
 #include <ctime>
 
 namespace openspace::luascriptfunctions {
diff --git a/src/util/timeconversion.cpp b/src/util/timeconversion.cpp
index eb61bc6950..08228e7b1c 100644
--- a/src/util/timeconversion.cpp
+++ b/src/util/timeconversion.cpp
@@ -55,7 +55,7 @@ std::pair<double, std::string> simplifyTime(double seconds, bool forceSingularFo
         double val = seconds / 1e-3;
         return {
             val,
-            (val == 1.0 || forceSingularForm) ? "millisecond" : "milliseconds" 
+            (val == 1.0 || forceSingularForm) ? "millisecond" : "milliseconds"
         };
     }
 
diff --git a/src/util/transformationmanager.cpp b/src/util/transformationmanager.cpp
index eba2959ee3..f84580190d 100644
--- a/src/util/transformationmanager.cpp
+++ b/src/util/transformationmanager.cpp
@@ -26,17 +26,16 @@
 #include <openspace/util/spicemanager.h>
 #include <ghoul/logging/logmanager.h>
 
-namespace {
-    constexpr const char* _loggerCat = "TransformationManager";
-} // namespace
-
 namespace openspace {
 
 TransformationManager::TransformationManager(){
 #ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
     _kameleon = std::make_shared<ccmc::Kameleon>();
 #else
-    LWARNING("Kameleon module needed for transformations with dynamic frames");
+    LWARNINGC(
+        "TransformationManager",
+        "Kameleon module needed for transformations with dynamic frames"
+    );
 #endif
     _kameleonFrames = {
         "J2000", "GEI", "GEO", "MAG", "GSE", "GSM", "SM", "RTN", "GSEQ",   //geocentric
@@ -124,7 +123,10 @@ glm::dmat3 TransformationManager::frameTransformationMatrix(
         return kameleonTransformation*spiceTransformation;
     }
 #else
-    LERROR("Can not transform dynamic frames without kameleon module enabled");
+    LERRORC(
+        "TransformationManager",
+        "Can not transform dynamic frames without kameleon module enabled"
+    );
 #endif
     return glm::dmat3(1.0);
 }
diff --git a/tests/main.cpp b/tests/main.cpp
index 7d828d58ed..af3fb23472 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -31,6 +31,7 @@
 #pragma clang diagnostic ignored "-Wmissing-noreturn"
 #pragma clang diagnostic ignored "-Wshift-sign-overflow"
 #pragma clang diagnostic ignored "-Wsign-compare"
+#pragma clang diagnostic ignored "-Wused-but-marked-unused"
 #elif defined(__GNUC__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wundef"
@@ -54,9 +55,9 @@
 #include <openspace/util/factorymanager.h>
 #include <openspace/util/spicemanager.h>
 #include <openspace/util/time.h>
-#include <ghoul/cmdparser/cmdparser>
-#include <ghoul/filesystem/filesystem>
-#include <ghoul/logging/logging>
+//#include <ghoul/cmdparser/cmdparser>
+//#include <ghoul/filesystem/filesystem>
+//#include <ghoul/logging/logging>
 #include <ghoul/lua/ghoul_lua.h>
 #include <ghoul/misc/dictionary.h>
 #include <iostream>
diff --git a/tests/regression/517.inl b/tests/regression/517.inl
index 774f842459..cf28d26f79 100644
--- a/tests/regression/517.inl
+++ b/tests/regression/517.inl
@@ -31,8 +31,8 @@ TEST_F(Issue527, Regression) {
     openspace::properties::OptionProperty p({ "id", "gui", "desc"});
 
     p.addOptions({
-        {-1, "a" },
-        {-2, "b" }
+        { -1, "a" },
+        { -2, "b" }
     });
 
 
diff --git a/tests/test_gdalwms.inl b/tests/test_gdalwms.inl
index 23de410577..c1aeaacab3 100644
--- a/tests/test_gdalwms.inl
+++ b/tests/test_gdalwms.inl
@@ -33,8 +33,6 @@
 #include "cpl_conv.h"
 #include "cpl_string.h"
 
-#include <ghoul/filesystem/filesystem>
-
 // Error: cannot open source file "wms/wmsdriver.h"
 //#include "wms/wmsdriver.h" 
 
diff --git a/tests/test_rawvolumeio.inl b/tests/test_rawvolumeio.inl
index f161d6cd36..cacb18b60d 100644
--- a/tests/test_rawvolumeio.inl
+++ b/tests/test_rawvolumeio.inl
@@ -34,12 +34,10 @@
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/glm.h>
 
-using namespace openspace;
-
 class RawVolumeIoTest : public testing::Test {};
 
 TEST_F(RawVolumeIoTest, TinyInputOutput) {
-    using namespace volume;
+    using namespace openspace::volume;
 
     glm::uvec3 dims{ 1, 1, 1 };
     float value = 0.5;
@@ -62,7 +60,7 @@ TEST_F(RawVolumeIoTest, TinyInputOutput) {
 }
 
 TEST_F(RawVolumeIoTest, BasicInputOutput) {
-    using namespace volume;
+    using namespace openspace::volume;
 
     glm::uvec3 dims{ 2, 4, 8 };
     auto value = [dims](glm::uvec3 v) {
@@ -70,7 +68,8 @@ TEST_F(RawVolumeIoTest, BasicInputOutput) {
     };
 
     RawVolume<float> vol(dims);
-    vol.forEachVoxel([&vol, &value](glm::uvec3 x, float v) {
+    vol.forEachVoxel([&vol, &value](glm::uvec3 x, float
+        ) {
         vol.set(x, value(x));
     });