diff --git a/include/openspace/scene/asset.h b/include/openspace/scene/asset.h
index 274be0f726..3f7b95c6ba 100644
--- a/include/openspace/scene/asset.h
+++ b/include/openspace/scene/asset.h
@@ -39,12 +39,13 @@ class AssetLoader;
 
 class Asset : public properties::PropertyOwner {
 public:
-    struct Optional : public properties::PropertyOwner {
+    class Optional : public properties::PropertyOwner {
     public:
         Optional(Asset* asset, Asset* owner, bool enabled = false);
     private:
         properties::BoolProperty _enabled;
-        Asset* asset;
+        Asset* _asset;
+        Asset* _owner;
     };
 
     enum class ReadyState : unsigned int {
@@ -64,29 +65,30 @@ public:
     */
     Asset(AssetLoader* loader, ghoul::filesystem::Directory baseDirectory, std::string assetPath);
 
-    std::string id();
-    std::string assetFilePath();
-    std::string assetName();
-    std::string assetDirectory();
-    AssetLoader* loader();
-    std::string syncDirectory();
-    ReadyState readyState();
+    std::string id() const;
+    std::string assetFilePath() const;
+    std::string assetName() const;
+    std::string assetDirectory() const;
+    AssetLoader* loader() const;
+    std::string syncDirectory() const;
+    ReadyState readyState() const;
     bool isInitReady() const;
     void initialize();
     void deinitialize();
 
-    bool hasDependency(Asset* asset);
+    bool hasDependency(const Asset* asset) const;
     void addDependency(Asset* asset);
     void removeDependency(Asset* asset);
     void removeDependency(const std::string& assetId);
 
-    bool hasDependants();
-    bool hasInitializedDependants();
+    bool hasDependants() const;
+    bool hasInitializedDependants() const;
 
-    bool hasOptional(Asset* asset);
-    bool setOptionalEnabled(Asset* asset, bool enabled);
-    bool addOptional(Asset* asset, bool enabled);
-    bool removeOptional(Asset* asset);
+    bool hasOptional(Asset* asset) const;
+    bool optionalIsEnabled(Asset* asset) const;
+    void setOptionalEnabled(Asset* asset, bool enabled);
+    void addOptional(Asset* asset, bool enabled);
+    void removeOptional(Asset* asset);
 
     void dependantDidInitialize(Asset* dependant);
     void dependantWillDeinitialize(Asset* dependant);
@@ -96,10 +98,14 @@ public:
 
     bool shouldSynchronize();
     bool shouldInitialize();
-private:
+
     std::string resolveLocalResource(std::string resourceName);
     std::string resolveSyncedResource(std::string resourceName);
 
+    static std::string generateAssetId(std::string directory, std::string name);
+private:
+
+
     ReadyState _readyState;
     AssetLoader* _loader;
 
@@ -109,6 +115,9 @@ private:
     // Asbolute path to directory with the .asset file
     std::string _assetDirectory;
 
+    // Asset id
+    std::string _id;
+
     // Asset dependencies
     std::vector<Asset*> _dependencies;
 
diff --git a/include/openspace/scene/assetloader.h b/include/openspace/scene/assetloader.h
index 95d590ca08..d8dce66c78 100644
--- a/include/openspace/scene/assetloader.h
+++ b/include/openspace/scene/assetloader.h
@@ -92,7 +92,7 @@ public:
     /**
      * Return the root asset
      */
-    Asset* rootAsset();
+    Asset* rootAsset() const;
 
     /**
      * Return the sync root directory
@@ -126,14 +126,18 @@ private:
     ResourceSynchronizer* _resourceSynchronizer;
     std::string _syncRootDirectory;
 
-    friend int assetloader::importDependency(lua_State* state);
-    friend int assetloader::importOptional(lua_State* state);
-    int importAssetLua(
-        std::string assetName,
-        bool togglableInitializationRequirement = false,
-        bool toggleOn = true);
+    int importDependencyLua(std::string assetName);
+    int importOptionalLua(std::string assetName, bool enabled);
+    int resolveLocalResourceLua(Asset* asset);
+    int resolveSyncedResourceLua(Asset* asset);
+    int createLuaTableEntries(const Asset* importer, const Asset* importedAsset);
 
     ghoul::lua::LuaState* _luaState;
+
+    friend int assetloader::importDependency(lua_State* state);
+    friend int assetloader::importOptional(lua_State* state);
+    friend int assetloader::resolveLocalResource(lua_State* state);
+    friend int assetloader::resolveSyncedResource(lua_State* state);
 };
 
 
diff --git a/modules/imgui/imguimodule.cpp b/modules/imgui/imguimodule.cpp
index 13e6e249a1..643c476f54 100644
--- a/modules/imgui/imguimodule.cpp
+++ b/modules/imgui/imguimodule.cpp
@@ -1,4 +1,4 @@
-/*****************************************************************************************
+/*****************************************************************************************
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
@@ -37,6 +37,7 @@
 #include <openspace/rendering/screenspacerenderable.h>
 #include <openspace/scene/scene.h>
 #include <openspace/scene/scenegraphnode.h>
+#include <openspace/scene/asset.h>
 #include <openspace/scene/assetloader.h>
 
 #include <ghoul/logging/logmanager.h>
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index b5a8e0d666..c9ddb9a9dd 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -45,12 +45,13 @@
 #include <openspace/scripting/scriptscheduler.h>
 #include <openspace/scripting/scriptengine.h>
 
+#include <openspace/scene/asset.h>
+#include <openspace/scene/assetloader.h>
 #include <openspace/scene/scene.h>
 #include <openspace/scene/rotation.h>
 #include <openspace/scene/scale.h>
 #include <openspace/scene/translation.h>
 #include <openspace/scene/sceneloader.h>
-#include <openspace/scene/assetloader.h>
 #include <openspace/util/resourcesynchronization.h>
 
 #include <openspace/util/factorymanager.h>
@@ -145,7 +146,7 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     , _networkEngine(new NetworkEngine)
     , _parallelConnection(new ParallelConnection)
     , _renderEngine(new RenderEngine)
-    , _resourceSynchronizer(new ResourceSynchronizer(8))
+    , _resourceSynchronizer(new ResourceSynchronizer)
     , _settingsEngine(new SettingsEngine)
     , _syncEngine(std::make_unique<SyncEngine>(4096))
     , _timeManager(new TimeManager)
diff --git a/src/scene/asset.cpp b/src/scene/asset.cpp
index b539692788..a93658c011 100644
--- a/src/scene/asset.cpp
+++ b/src/scene/asset.cpp
@@ -39,6 +39,8 @@ namespace {
         }
         return false;
     };
+
+    const char* AssetFileSuffix = "asset";
 }
 
 namespace openspace {
@@ -48,7 +50,7 @@ std::string Asset::resolveLocalResource(std::string resourceName) {
     return currentAssetDirectory + ghoul::filesystem::FileSystem::PathSeparator + resourceName;
 }
 
-std::string Asset::syncDirectory() {
+std::string Asset::syncDirectory() const {
     std::string currentAssetDirectory = assetDirectory();
     std::string rootAssetDirectory = loader()->rootAsset()->assetDirectory();
     std::string relativePath = FileSys.relativePath(currentAssetDirectory, rootAssetDirectory);
@@ -60,7 +62,7 @@ std::string Asset::syncDirectory() {
         assetName();
 }
 
-Asset::ReadyState Asset::readyState() {
+Asset::ReadyState Asset::readyState() const {
     return _readyState;
 }
 
@@ -138,7 +140,9 @@ Asset::Asset(AssetLoader* loader, ghoul::filesystem::Directory directory)
     , _assetDirectory(directory)
     , _loader(loader)
     , _readyState(Asset::ReadyState::Loaded)
-{}
+{
+    _id = generateAssetId(directory, "");
+}
 
 Asset::Asset(AssetLoader* loader, ghoul::filesystem::Directory baseDirectory, std::string assetPath)
     : PropertyOwner({ assetPath, assetPath })
@@ -167,36 +171,41 @@ Asset::Asset(AssetLoader* loader, ghoul::filesystem::Directory baseDirectory, st
         _assetDirectory = assetFile.directoryName();
         _assetName = assetFile.baseName();
     }
+    _id = generateAssetId(_assetDirectory, _assetName);
 }
 
-std::string Asset::assetFilePath() {
-    ghoul::filesystem::File dir(_assetDirectory);
+std::string Asset::assetFilePath() const {
+    //ghoul::filesystem::File dir(_assetDirectory);
     return _assetDirectory + ghoul::filesystem::FileSystem::PathSeparator + _assetName + "." + AssetFileSuffix;
 }
 
-std::string Asset::assetName() {
+std::string Asset::generateAssetId(std::string directory, std::string name) {
+    return directory + ghoul::filesystem::FileSystem::PathSeparator + name;
+}
+
+std::string Asset::assetName() const {
     return _assetName;
 }
 
-std::string Asset::assetDirectory() {
+std::string Asset::assetDirectory() const {
     return _assetDirectory;
 }
 
-std::string Asset::id() {
-    return assetFilePath();
+std::string Asset::id() const {
+    return _id;
 }
 
-AssetLoader* Asset::loader() {
+AssetLoader* Asset::loader() const {
     return _loader;
 }
 
-bool Asset::hasDependency(Asset* asset) {
-    auto it = std::find(_dependencies.begin(), _dependencies.end(), dependency);
+bool Asset::hasDependency(const Asset* asset) const {
+    const auto it = std::find(_dependencies.begin(), _dependencies.end(), asset);
     return it != _dependencies.end();
 }
 
 void Asset::addDependency(Asset* dependency) {
-    if (readyState == Initialized) {
+    if (_readyState == Asset::ReadyState::Initialized) {
         // TODO: Throw: cannot add dep while asset is initialized.
         return;
     }
@@ -230,11 +239,11 @@ void Asset::removeDependency(Asset* dependency) {
 }
 
 void Asset::removeDependency(const std::string& assetId) {
-    auto dep = std::find_if(_dependencies.begin(), _dependencies.end(), [&assetId](const Asset& d) {
-        return d.id() == assetId;
+    auto dep = std::find_if(_dependencies.begin(), _dependencies.end(), [&assetId](const Asset* d) {
+        return d->id() == assetId;
     });
     if (dep != _dependencies.end()) {
-        removeDependency(dep);
+       removeDependency(*dep);
     } else {
         LERROR("No such dependency '" << assetId << "'");
     }
@@ -248,9 +257,9 @@ void Asset::dependantWillDeinitialize(Asset* dependant) {
     loader()->callOnDependantDeinitialize(this, dependant);
 }
 
-bool Asset::hasDependants() {
+bool Asset::hasDependants() const {
     bool foundDep = false;
-    for (auto& dependant : _dependants) {
+    for (const auto& dependant : _dependants) {
         if (dependant->hasDependency(this)) {
             foundDep = true;
         }
@@ -258,10 +267,10 @@ bool Asset::hasDependants() {
     return foundDep;
 }
 
-bool Asset::hasInitializedDependants() {
+bool Asset::hasInitializedDependants() const {
     bool foundInitializedDep = false;
-    for (auto& dependant : _dependants) {
-        if (dependant->isInitialized() && dependant->hasDependency(this)) {
+    for (const auto& dependant : _dependants) {
+        if (dependant->readyState() == Asset::ReadyState::Initialized && dependant->hasDependency(this)) {
             foundInitializedDep = true;
         }
     }
@@ -270,7 +279,7 @@ bool Asset::hasInitializedDependants() {
 
 // Dependency toggle
 Asset::Optional::Optional(Asset* asset, Asset* owner, bool enabled)
-    : PropertyOwner({ dependency->name(), dependency->name() })
+    : PropertyOwner({ asset->name(), asset->name() })
     , _enabled({ "enabled", "Enabled", "Enable optional" }, enabled)
     , _asset(asset)
     , _owner(owner)
@@ -279,7 +288,7 @@ Asset::Optional::Optional(Asset* asset, Asset* owner, bool enabled)
     addPropertySubOwner(asset);
     _enabled.onChange([this]() {
         _owner->setOptionalEnabled(
-            asset,
+            _asset,
             _enabled
         );
     });
diff --git a/src/scene/assetloader.cpp b/src/scene/assetloader.cpp
index 051a732824..0c49c0c383 100644
--- a/src/scene/assetloader.cpp
+++ b/src/scene/assetloader.cpp
@@ -37,9 +37,7 @@
 #include "assetloader_lua.inl"
 
 namespace {
-    const char* AssetFileSuffix = "asset";
     const char* AssetGlobalVariableName = "asset";
-    const char* DataFileSuffix = "data";
 
     const char* SyncTableName = "sync";
     const char* ImportFunctionName = "import";
@@ -148,7 +146,9 @@ Asset* AssetLoader::loadAsset(std::string name) {
     ghoul::filesystem::Directory directory = currentDirectory();
     std::unique_ptr<Asset> asset = std::make_unique<Asset>(this, directory, name);
 
-    pushAsset(asset);
+    Asset* rawAsset = asset.get();
+
+    pushAsset(rawAsset);
     ghoul::OnScopeExit e([this]() {
         popAsset();
     });
@@ -170,15 +170,14 @@ Asset* AssetLoader::loadAsset(std::string name) {
         return nullptr;
     }
 
-    Asset* rawAsset = asset.get();
-    _importedAssets.emplace(id, std::move(asset));
+    _importedAssets.emplace(asset->id(), std::move(asset));
 
     return rawAsset;
 }
 
 Asset* AssetLoader::getAsset(std::string name) {
     ghoul::filesystem::Directory directory = currentDirectory();
-    std::string assetId = generateAssetId(directory, name);
+    std::string assetId = Asset::generateAssetId(directory, name);
 
     // Check if asset is already loaded.
     const auto it = _importedAssets.find(assetId);
@@ -187,14 +186,14 @@ Asset* AssetLoader::getAsset(std::string name) {
     return loaded ? it->second.get() : loadAsset(name);
 }
 
-AssetLoader::Asset* AssetLoader::importDependency(const std::string& name) {
+Asset* AssetLoader::importDependency(const std::string& name) {
     Asset* asset = getAsset(name);
     Asset* dependant = _assetStack.back();
     dependant->addDependency(asset);
     return asset;
 }
 
-AssetLoader::Asset* AssetLoader::importOptional(const std::string& name, bool enabled) {
+Asset* AssetLoader::importOptional(const std::string& name, bool enabled) {
     Asset* asset = getAsset(name);
     Asset* owner = _assetStack.back();
     owner->addOptional(asset, enabled);
@@ -232,7 +231,7 @@ ghoul::lua::LuaState* AssetLoader::luaState() {
     return _luaState;
 }
 
-AssetLoader::Asset* AssetLoader::rootAsset() {
+Asset* AssetLoader::rootAsset() const {
     return _rootAsset.get();
 }
 
@@ -249,7 +248,7 @@ void AssetLoader::callOnInitialize(Asset * asset) {
     lua_getfield(*_luaState, -1, OnInitializeFunctionName);
     const int status = lua_pcall(*_luaState, 0, 0, 0);
     if (status != LUA_OK) {
-        throw ghoul::lua::LuaExecutionException(lua_tostring(*state, -1));
+        throw ghoul::lua::LuaExecutionException(lua_tostring(*_luaState, -1));
     }
 }
 
@@ -262,7 +261,7 @@ void AssetLoader::callOnDeinitialize(Asset* asset) {
     lua_getfield(*_luaState, -1, OnDeinitializeFunctionName);
     const int status = lua_pcall(*_luaState, 0, 0, 0);
     if (status != LUA_OK) {
-        throw ghoul::lua::LuaExecutionException(lua_tostring(*state, -1));
+        throw ghoul::lua::LuaExecutionException(lua_tostring(*_luaState, -1));
     }
 }
 
@@ -277,7 +276,7 @@ void AssetLoader::callOnDependantInitialize(Asset* asset, Asset* dependant) {
     lua_getfield(*_luaState, -1, OnInitializeFunctionName);
     const int status = lua_pcall(*_luaState, 0, 0, 0);
     if (status != LUA_OK) {
-        throw ghoul::lua::LuaLoadingException(lua_tostring(*state, -1));
+        throw ghoul::lua::LuaLoadingException(lua_tostring(*_luaState, -1));
     }
 }
 
@@ -293,41 +292,41 @@ void AssetLoader::callOnDependantDeinitialize(Asset* asset, Asset* dependant) {
     lua_getfield(*_luaState, -1, OnDeinitializeFunctionName);
     const int status = lua_pcall(*_luaState, 0, 0, 0);
     if (status != LUA_OK) {
-        throw ghoul::lua::LuaLoadingException(lua_tostring(*state, -1));
+        throw ghoul::lua::LuaLoadingException(lua_tostring(*_luaState, -1));
     }
 }
 
 
 int AssetLoader::resolveLocalResourceLua(Asset* asset) {
-    int nArguments = lua_gettop(*state);
+    int nArguments = lua_gettop(*_luaState);
     if (nArguments != 1) {
-        return luaL_error(*state, "Expected %i arguments, got %i", 1, nArguments);
+        return luaL_error(*_luaState, "Expected %i arguments, got %i", 1, nArguments);
     }
 
     std::string resourceName = luaL_checkstring(*_luaState, -1);
     std::string resolved = asset->resolveLocalResource(resourceName);
 
-    lua_pushstring(*state, resolved.c_str());
+    lua_pushstring(*_luaState, resolved.c_str());
     return 1;
 }
 
 int AssetLoader::resolveSyncedResourceLua(Asset* asset) {
-    int nArguments = lua_gettop(*state);
+    int nArguments = lua_gettop(*_luaState);
     if (nArguments != 1) {
-        return luaL_error(*state, "Expected %i arguments, got %i", 1, nArguments);
+        return luaL_error(*_luaState, "Expected %i arguments, got %i", 1, nArguments);
     }
 
     std::string resourceName = luaL_checkstring(*_luaState, -1);
     std::string resolved = asset->resolveSyncedResource(resourceName);
 
-    lua_pushstring(*state, resolved.c_str());
+    lua_pushstring(*_luaState, resolved.c_str());
     return 1;
 }
 
 void AssetLoader::pushAsset(Asset* asset) {
     _assetStack.push_back(asset);
 
-    if (!asset->hasLuaTable()) {
+    if (asset == _rootAsset.get()) {
         return;
     }
     
@@ -357,7 +356,7 @@ void AssetLoader::pushAsset(Asset* asset) {
     // Register import-optional function
     lua_pushlightuserdata(*_luaState, this);
     lua_pushcclosure(*_luaState, &assetloader::importOptional, 1);
-    lua_setfield(*_luaState, assetTableIndex, ImportToggleFunctionName);
+    lua_setfield(*_luaState, assetTableIndex, ImportOptionalFunctionName);
 
     // Register default onDeinitialize function
     lua_pushcfunction(*_luaState, &assetloader::noOperation);
@@ -399,7 +398,7 @@ void AssetLoader::updateLuaGlobals() {
 int AssetLoader::importDependencyLua(std::string assetName) {
     Asset* importer = _assetStack.back();
 
-    Asset* importedAsset = importDependency(assetName, toggleEnabled);
+    Asset* importedAsset = importDependency(assetName);
     if (!importedAsset) {
         return luaL_error(*_luaState, "Asset '%s' not found", assetName.c_str());
     }
@@ -418,7 +417,7 @@ int AssetLoader::importOptionalLua(std::string assetName, bool enabled) {
 
 
 
-void AssetLoader::createAssetLuaTableEntries(Asset* importer, Asset* importedAsset) {
+int AssetLoader::createLuaTableEntries(const Asset* importer, const Asset* importedAsset) {
     const std::string importerId = importer->id();
     const std::string importedAssetId = importedAsset->id();
 
diff --git a/src/scene/sceneloader.cpp b/src/scene/sceneloader.cpp
index e19e04048d..2d644fadcb 100644
--- a/src/scene/sceneloader.cpp
+++ b/src/scene/sceneloader.cpp
@@ -88,7 +88,7 @@ void SceneLoader::loadScene(Scene* scene, const std::string& path) {
 
     for (const std::string& key : keys) {
         std::string assetName = assetDictionary.value<std::string>(key);
-        _assetLoader->loadAsset(assetName);
+        _assetLoader->importAsset(assetName);
     }
 
     // Sync all resources from assets that are dependencies of root asset.