diff --git a/include/openspace/scene/asset.h b/include/openspace/scene/asset.h
index 3e658f9095..2f94650545 100644
--- a/include/openspace/scene/asset.h
+++ b/include/openspace/scene/asset.h
@@ -44,9 +44,15 @@ class Asset : public std::enable_shared_from_this<Asset> {
 public:
     using Optional = std::pair<std::shared_ptr<Asset>, bool>;
 
-    enum class ReadyState : unsigned int {
+    enum class State : unsigned int {
+        Unloaded,
+        LoadingFailed,
         Loaded,
-        Initialized
+        Synchronizing,
+        SyncResolved,
+        SyncRejected,
+        Initialized,
+        InitializationFailed
     };
 
     /**
@@ -65,12 +71,18 @@ public:
     std::string assetDirectory() const;
     std::string assetName() const;
     AssetLoader* loader() const;
-    ReadyState readyState() const;
+    State state() const;
 
+    void setState(State state);
     void addSynchronization(std::shared_ptr<ResourceSynchronization> synchronization);
     std::vector<std::shared_ptr<ResourceSynchronization>> synchronizations();
     std::vector<std::shared_ptr<Asset>> allAssets();
 
+    bool startSynchronizations();
+    bool cancelSynchronizations();
+    bool restartSynchronizations();
+    float synchronizationProgress();
+
     bool isInitReady() const;
     void initialize();
     void deinitialize();
@@ -86,7 +98,10 @@ public:
 
     std::string resolveLocalResource(std::string resourceName);
 private:
-    ReadyState _readyState;
+    void startSync(ResourceSynchronization& rs);
+    void cancelSync(ResourceSynchronization& rs);
+
+    State _state;
     AssetLoader* _loader;
     std::vector<std::shared_ptr<ResourceSynchronization>> _synchronizations;
 
diff --git a/include/openspace/scene/assetloader.h b/include/openspace/scene/assetloader.h
index 41aea6eb5e..7d3fda4c66 100644
--- a/include/openspace/scene/assetloader.h
+++ b/include/openspace/scene/assetloader.h
@@ -28,7 +28,6 @@
 #include <openspace/scene/scenegraphnode.h>
 
 #include <openspace/scripting/lualibrary.h>
-#include <openspace/scene/assetsynchronizer.h>
 #include <openspace/util/resourcesynchronization.h>
 
 #include <ghoul/misc/dictionary.h>
@@ -170,7 +169,6 @@ private:
     std::map<std::string, std::shared_ptr<Asset>> _importedAssets;
     std::vector<std::shared_ptr<Asset>> _assetStack;
 
-    AssetSynchronizer* _assetSynchronizer;
     std::string _assetRootDirectory;
     ghoul::lua::LuaState* _luaState;
 
diff --git a/include/openspace/scene/assetmanager.h b/include/openspace/scene/assetmanager.h
index ab4c46a782..c803fdfafe 100644
--- a/include/openspace/scene/assetmanager.h
+++ b/include/openspace/scene/assetmanager.h
@@ -54,32 +54,20 @@ class Asset;
 class AssetManager {
 public:
     AssetManager(
-        std::unique_ptr<AssetLoader> loader,
-        std::unique_ptr<AssetSynchronizer> synchronizer
+        std::unique_ptr<AssetLoader> loader
     );
 
-    enum class AssetState : int {
-        Unloaded,
-        Loaded,
-        LoadingFailed,
-        Synchronized,
-        SynchronizationFailed,
-        Initialized,
-        InitializationFailed
-    };
-
     struct ManagedAsset {
         std::string path;
         std::shared_ptr<Asset> asset;
-        AssetState state;
     };
 
     bool update();
 
-    void setTargetAssetState(const std::string& path, AssetState targetState);
-    void setTargetAssetState(Asset* asset, AssetState targetState);
-    AssetState currentAssetState(Asset* asset);
-    AssetState currentAssetState(const std::string& path);
+    void setTargetAssetState(const std::string& path, Asset::State targetState);
+    void setTargetAssetState(Asset* asset, Asset::State targetState);
+    Asset::State currentAssetState(Asset* asset);
+    Asset::State currentAssetState(const std::string& path);
 
     void clearAllTargetAssets();
     std::vector<std::shared_ptr<Asset>> loadedAssets();
@@ -96,7 +84,7 @@ private:
     std::vector<ManagedAsset> _managedAssets;
     
 
-    std::unordered_map<std::string, AssetState> _pendingStateChangeCommands;
+    std::unordered_map<std::string, Asset::State> _pendingStateChangeCommands;
     //std::unordered_map<Asset*, AssetState> _stateChangesInProgress;
     std::unordered_set<Asset*> _pendingInitializations;
 
@@ -104,7 +92,6 @@ private:
     std::unordered_map<Asset*, std::unordered_set<Asset*>> _syncDependencies;
     
     std::unique_ptr<AssetLoader> _assetLoader;
-    std::unique_ptr<AssetSynchronizer> _assetSynchronizer;
 };
 
 } // namespace openspace
diff --git a/include/openspace/scene/assetsynchronizer.h b/include/openspace/scene/assetsynchronizer.h
deleted file mode 100644
index 54679b6454..0000000000
--- a/include/openspace/scene/assetsynchronizer.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2017                                                               *
- *                                                                                       *
- * 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___ASSETSYNCHRONIZER___H__
-#define __OPENSPACE_CORE___ASSETSYNCHRONIZER___H__
-
-#include <openspace/scene/scenegraphnode.h>
-#include <openspace/scene/asset.h>
-
-#include <openspace/scripting/lualibrary.h>
-
-#include <ghoul/misc/dictionary.h>
-#include <ghoul/lua/luastate.h>
-
-#include <ghoul/lua/ghoul_lua.h>
-#include <ghoul/filesystem/directory.h>
-
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace openspace {
-
-class AssetSynchronizer {
-public:
-    enum class SynchronizationState : int {
-        Unsynced,
-        Synchronizing,
-        Resolved,
-        Rejected
-    };
-
-    struct StateChange {
-        std::shared_ptr<Asset> asset;
-        SynchronizationState state;
-    };
-
-    struct AssetResourceSync {
-        std::shared_ptr<Asset> asset;
-        std::shared_ptr<ResourceSynchronization> sync;
-    };
-
-    AssetSynchronizer();
-    void startSync(std::shared_ptr<Asset> asset);
-    void cancelSync(std::shared_ptr<Asset> asset);
-    void restartSync(std::shared_ptr<Asset> asset);
-
-    SynchronizationState assetState(Asset* asset);
-    float assetProgress(Asset* asset);
-
-    std::vector<StateChange> getStateChanges();
-
-private:
-    void startAssetResourceSync(std::shared_ptr<Asset> a, std::shared_ptr<ResourceSynchronization> rs);
-    void cancelAssetResourceSync(std::shared_ptr<Asset> a, std::shared_ptr<ResourceSynchronization> rs);
-    
-    void handleSyncStateChange(std::shared_ptr<Asset>, std::shared_ptr<ResourceSynchronization>, ResourceSynchronization::State state);
-    
-    void setState(std::shared_ptr<Asset> a, SynchronizationState state);
-
-    std::vector<std::shared_ptr<Asset>> _synchronizingAssets;
-    std::unordered_map<Asset*, StateChange> _stateChanges;
-    std::unordered_map<ResourceSynchronization*, std::unordered_set<Asset*>> _resourceToAssetMap;
-};
-
-} // namespace openspace
-
-#endif // __OPENSPACE_CORE___ASSETSYNCHRONIZER___H__
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 882f8f9a26..fca6186101 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -132,7 +132,6 @@ set(OPENSPACE_SOURCE
     ${OPENSPACE_BASE_DIR}/src/scene/assetloader_lua.inl
     ${OPENSPACE_BASE_DIR}/src/scene/assetmanager.cpp
     ${OPENSPACE_BASE_DIR}/src/scene/assetmanager_lua.inl
-    ${OPENSPACE_BASE_DIR}/src/scene/assetsynchronizer.cpp
     ${OPENSPACE_BASE_DIR}/src/scene/translation.cpp
     ${OPENSPACE_BASE_DIR}/src/scene/rotation.cpp
     ${OPENSPACE_BASE_DIR}/src/scene/scale.cpp
@@ -303,7 +302,6 @@ set(OPENSPACE_HEADER
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/asset.h
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/assetloader.h
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/assetmanager.h
-    ${OPENSPACE_BASE_DIR}/include/openspace/scene/assetsynchronizer.h
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/translation.h
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/rotation.h
     ${OPENSPACE_BASE_DIR}/include/openspace/scene/scale.h
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index 051bfecf5b..847de20e7e 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -412,8 +412,7 @@ void OpenSpaceEngine::create(int argc, char** argv,
 
     // Set up asset loader
     _engine->_assetManager = std::make_unique<AssetManager>(
-        std::make_unique<AssetLoader>(*OsEng.scriptEngine().luaState(), "${ASSETS}"),
-        std::make_unique<AssetSynchronizer>()
+        std::make_unique<AssetLoader>(*OsEng.scriptEngine().luaState(), "${ASSETS}")
     );
     //_engine->_globalPropertyNamespace->addPropertySubOwner(_engine->_assetLoader->rootAsset());
 }
@@ -601,7 +600,7 @@ void OpenSpaceEngine::loadSingleAsset(const std::string& assetPath) {
 
     _renderEngine->setScene(_scene.get());
     _assetManager->clearAllTargetAssets();
-    _assetManager->setTargetAssetState(assetPath, AssetManager::AssetState::Initialized);
+    _assetManager->setTargetAssetState(assetPath, Asset::State::Initialized);
 
     bool showMessage = true;
     std::string kMessage =
diff --git a/src/scene/asset.cpp b/src/scene/asset.cpp
index b67848a73e..bfdfb98b04 100644
--- a/src/scene/asset.cpp
+++ b/src/scene/asset.cpp
@@ -36,7 +36,7 @@ namespace {
 namespace openspace {
 
 Asset::Asset(AssetLoader* loader)
-    : _readyState(Asset::ReadyState::Loaded)
+    : _state(State::Unloaded)
     , _loader(loader)
     , _hasAssetPath(false)
     , _assetName("Root Asset")
@@ -44,7 +44,7 @@ Asset::Asset(AssetLoader* loader)
 {}
 
 Asset::Asset(AssetLoader* loader, ghoul::filesystem::File assetPath)
-    : _readyState(Asset::ReadyState::Loaded)
+    : _state(State::Unloaded)
     , _loader(loader)
     , _hasAssetPath(true)
     , _assetPath(assetPath)
@@ -57,8 +57,18 @@ std::string Asset::resolveLocalResource(std::string resourceName) {
         resourceName;
 }
 
-Asset::ReadyState Asset::readyState() const {
-    return _readyState;
+void Asset::startSync(ResourceSynchronization & rs) {
+}
+
+void Asset::cancelSync(ResourceSynchronization & rs) {
+}
+
+Asset::State Asset::state() const {
+    return _state;
+}
+
+void Asset::setState(Asset::State state) {
+    _state = state;
 }
 
 void Asset::addSynchronization(std::shared_ptr<ResourceSynchronization> synchronization) {
@@ -80,6 +90,76 @@ std::vector<std::shared_ptr<Asset>> Asset::allAssets() {
     return assetVector;
 }
 
+bool Asset::startSynchronizations() {
+    bool startedAnySync = false;
+    for (auto& dep : _dependencies) {
+        bool started = dep->startSynchronizations();
+        if (started) {
+            startedAnySync = true;
+        }
+    }
+    for (const auto& s : _synchronizations) {
+        if (!s->isResolved()) {
+            startedAnySync = true;
+            startSync(*s);
+        }
+    }
+    if (!startedAnySync) {
+        setState(State::SyncResolved);
+    }
+    return startedAnySync;
+}
+
+bool Asset::cancelSynchronizations() {
+    bool cancelledAnySync = false;
+    for (auto& dep : _dependencies) {
+        bool cancelled = dep->cancelSynchronizations();
+        if (cancelled) {
+            cancelledAnySync = true;
+        }
+    }
+    for (const auto& s : _synchronizations) {
+        if (s->isSyncing()) {
+            cancelledAnySync = true;
+            cancelSync(*s);
+        }
+    }
+    if (cancelledAnySync) {
+        setState(State::Loaded);
+    }
+    return cancelledAnySync;
+}
+
+bool Asset::restartSynchronizations() {
+    cancelSynchronizations();
+    return startSynchronizations();
+}
+
+float Asset::synchronizationProgress() {
+    std::vector<std::shared_ptr<Asset>> assets = allAssets();
+
+    size_t nTotalBytes = 0;
+    size_t nSyncedBytes = 0;
+
+    for (const auto& a : assets) {
+        const std::vector<std::shared_ptr<ResourceSynchronization>> syncs =
+            a->synchronizations();
+
+        for (const auto& sync : syncs) {
+            if (sync->nTotalBytesIsKnown()) {
+                nTotalBytes += sync->nTotalBytes();
+                nSyncedBytes += sync->nSynchronizedBytes();
+            } else {
+                return 0;
+            }
+        }
+    }
+    if (nTotalBytes == 0) {
+        return 1.f;
+    }
+    return static_cast<float>(nSyncedBytes) / static_cast<float>(nTotalBytes);
+}
+
 bool Asset::isInitReady() const {
     // An asset is ready for initialization if all synchronizations are resolved
     // and all its dependencies are ready for initialization.
@@ -98,7 +178,7 @@ bool Asset::isInitReady() const {
 
 void Asset::initialize() {
     LDEBUG("Initializing asset " << id());
-    if (_readyState == Asset::ReadyState::Initialized) {
+    if (state() == Asset::State::Initialized) {
         return;
     }
 
@@ -112,7 +192,7 @@ void Asset::initialize() {
         dependency->initialize();
     }
 
-    _readyState = Asset::ReadyState::Initialized;
+    setState(Asset::State::Initialized);
 
     // Call onInitialize in Lua
     loader()->callOnInitialize(this);
@@ -124,7 +204,7 @@ void Asset::initialize() {
 }
 
 void Asset::deinitialize() {
-    if (_readyState != Asset::ReadyState::Initialized) {
+    if (state() != Asset::State::Initialized) {
         return;
     }
 
@@ -136,7 +216,7 @@ void Asset::deinitialize() {
     // Call onDeinitialize in Lua
     loader()->callOnDeinitialize(this);
 
-    _readyState = Asset::ReadyState::Loaded;
+    setState(Asset::State::Loaded);
 
     // Make sure no dependencies are left dangling
     for (auto& dependency : _dependencies) {
@@ -183,8 +263,8 @@ bool Asset::hasDependency(const Asset* asset) const {
 }
 
 void Asset::addDependency(std::shared_ptr<Asset> dependency) {
-    if (_readyState == Asset::ReadyState::Initialized) {
-        // TODO: Throw: cannot add dep while asset is initialized.
+    if (state() == Asset::State::Unloaded) {
+        // TODO: Throw: Can only add dependency when in Loaded state
         return;
     }
 
@@ -258,7 +338,7 @@ bool Asset::hasDependants() const {
 bool Asset::hasInitializedDependants() const {
     for (const auto& dependant : _dependants) {
         std::shared_ptr<Asset> d = dependant.lock();
-        if (d && d->readyState() == Asset::ReadyState::Initialized &&
+        if (d && d->state() == Asset::State::Initialized &&
             d->hasDependency(this))
         {
             return true;
diff --git a/src/scene/assetloader.cpp b/src/scene/assetloader.cpp
index b5d9070ae9..8c87de1901 100644
--- a/src/scene/assetloader.cpp
+++ b/src/scene/assetloader.cpp
@@ -101,6 +101,7 @@ std::shared_ptr<Asset> AssetLoader::importAsset(std::string path) {
 
     ghoul::lua::runScriptFile(*_luaState, path);
     _importedAssets.emplace(asset->id(), asset);
+    asset->setState(Asset::State::Loaded);
 
     return asset;
 }
diff --git a/src/scene/assetmanager.cpp b/src/scene/assetmanager.cpp
index ebc56e0a8a..dd22b985b4 100644
--- a/src/scene/assetmanager.cpp
+++ b/src/scene/assetmanager.cpp
@@ -37,10 +37,8 @@ namespace {
 }
 
 namespace openspace {
-AssetManager::AssetManager(std::unique_ptr<AssetLoader> loader, 
-   std::unique_ptr<AssetSynchronizer> synchronizer)
+AssetManager::AssetManager(std::unique_ptr<AssetLoader> loader)
     : _assetLoader(std::move(loader))
-    , _assetSynchronizer(std::move(synchronizer))
 {}
 
 bool AssetManager::update() {
@@ -51,8 +49,8 @@ bool AssetManager::update() {
     // Load assets
     for (const auto& c : _pendingStateChangeCommands) {
         const std::string& path = c.first;
-        const AssetState targetState = c.second;
-        if (targetState != AssetState::Unloaded && !_assetLoader->loadedAsset(path)) {
+        const Asset::State targetState = c.second;
+        if (targetState != Asset::State::Unloaded && !_assetLoader->loadedAsset(path)) {
             std::shared_ptr<Asset> asset = tryLoadAsset(path);
         }
     }
@@ -60,24 +58,22 @@ bool AssetManager::update() {
     // Start/cancel synchronizations and/or deinitialize
     for (const auto& c : _pendingStateChangeCommands) {
         const std::string& path = c.first;
-        const AssetState targetState = c.second;
+        const Asset::State targetState = c.second;
         
         std::shared_ptr<Asset> asset = _assetLoader->loadedAsset(path);
         if (!asset) {
             continue;
         }
 
-        AssetSynchronizer::SynchronizationState currentSyncState =
-            _assetSynchronizer->assetState(asset.get());
+        Asset::State assetState = asset->state();
         
         const bool syncedOrSyncing =
-            (currentSyncState == AssetSynchronizer::SynchronizationState::Resolved ||
-             currentSyncState == AssetSynchronizer::SynchronizationState::Synchronizing);
+            (assetState == Asset::State::SyncResolved ||
+             assetState == Asset::State::Synchronizing);
         
         const bool shouldBeSynced =
-            (targetState == AssetState::Synchronized ||
-             targetState == AssetState::Initialized);
-        
+            (targetState == Asset::State::SyncResolved ||
+             targetState == Asset::State::Initialized);
 
         if (shouldBeSynced && !syncedOrSyncing) {
             startSynchronization(*asset);
@@ -85,8 +81,8 @@ bool AssetManager::update() {
             cancelSynchronization(*asset);
         }
         
-        const bool shouldBeInitialized = targetState == AssetState::Initialized;
-        const bool isInitialized = asset->readyState() == Asset::ReadyState::Initialized;
+        const bool shouldBeInitialized = targetState == Asset::State::Initialized;
+        const bool isInitialized = asset->state() == Asset::State::Initialized;
         
         if (shouldBeInitialized && !isInitialized) {
             _pendingInitializations.insert(asset.get());
@@ -96,7 +92,8 @@ bool AssetManager::update() {
         }
     }
     
-    std::vector<AssetSynchronizer::StateChange> stateChanges =
+    // TODO: Handle state changes
+    /*std::vector<AssetSynchronizer::StateChange> stateChanges =
         _assetSynchronizer->getStateChanges();
     
     for (AssetSynchronizer::StateChange& stateChange : stateChanges) {
@@ -111,7 +108,7 @@ bool AssetManager::update() {
             _pendingInitializations.erase(it);
             tryInitializeAsset(*a);
         }
-    }
+    }*/
 
     _pendingStateChangeCommands.clear();
     return false;
@@ -224,11 +221,11 @@ void AssetManager::handleSyncStateChange(AssetSynchronizer::StateChange stateCha
     _syncAncestors.erase(stateChange.asset.get());
 }*/
 
-void AssetManager::setTargetAssetState(const std::string& path, AssetState targetState) {
+void AssetManager::setTargetAssetState(const std::string& path, Asset::State targetState) {
     _pendingStateChangeCommands[path] = targetState;
 }
 
-AssetManager::AssetState AssetManager::currentAssetState(Asset* asset) {
+Asset::State AssetManager::currentAssetState(Asset* asset) {
     const auto it = std::find_if(
         _managedAssets.begin(),
         _managedAssets.end(),
@@ -237,12 +234,12 @@ AssetManager::AssetState AssetManager::currentAssetState(Asset* asset) {
         }
     );
     if (it == _managedAssets.end()) {
-        return AssetManager::AssetState::Unloaded;
+        return Asset::State::Unloaded;
     }
-    return it->state;
+    return it->asset->state();
 }
 
-AssetManager::AssetState AssetManager::currentAssetState(const std::string& assetIdentifier) {
+Asset::State AssetManager::currentAssetState(const std::string& assetIdentifier) {
     const auto it = std::find_if(
         _managedAssets.begin(),
         _managedAssets.end(),
@@ -251,16 +248,16 @@ AssetManager::AssetState AssetManager::currentAssetState(const std::string& asse
     }
     );
     if (it == _managedAssets.end()) {
-        return AssetManager::AssetState::Unloaded;
+        return Asset::State::Unloaded;
     }
-    return it->state;
+    return it->asset->state();
 }
 
 
 void AssetManager::clearAllTargetAssets() {
     _pendingStateChangeCommands.clear();
     for (const auto& ma : _managedAssets) {
-        _pendingStateChangeCommands[ma.path] = AssetState::Unloaded;
+        _pendingStateChangeCommands[ma.path] = Asset::State::Unloaded;
     }
 }
 
@@ -320,6 +317,7 @@ void AssetManager::unloadAsset(Asset* asset) {
 }
     
 std::shared_ptr<Asset> AssetManager::tryLoadAsset(const std::string& path) {
+    /*
     std::shared_ptr<Asset> asset;
     try {
         asset = _assetLoader->loadAsset(path);
@@ -331,7 +329,7 @@ std::shared_ptr<Asset> AssetManager::tryLoadAsset(const std::string& path) {
         _managedAssets.push_back(ManagedAsset{
             path,
             nullptr,
-            AssetState::LoadingFailed
+            Asset::State::LoadingFailed
         });
         return nullptr;
     }
@@ -349,8 +347,9 @@ std::shared_ptr<Asset> AssetManager::tryLoadAsset(const std::string& path) {
             AssetState::Loaded
         });
         return asset;
-    }
+    } */
     return nullptr;
+   
 }
 
 bool AssetManager::tryInitializeAsset(Asset& asset) {
diff --git a/src/scene/assetmanager_lua.inl b/src/scene/assetmanager_lua.inl
index c1b1e628c1..81e16427ef 100644
--- a/src/scene/assetmanager_lua.inl
+++ b/src/scene/assetmanager_lua.inl
@@ -33,7 +33,7 @@ int loadAsset(lua_State* state) {
 
     std::string assetName = luaL_checkstring(state, -1);
 
-    assetManager->setTargetAssetState(assetName, AssetManager::AssetState::Loaded);
+    assetManager->setTargetAssetState(assetName, Asset::State::Loaded);
     return 0;
 }
 
@@ -46,7 +46,7 @@ int synchronizeAsset(lua_State* state) {
 
     std::string assetName = luaL_checkstring(state, -1);
 
-    assetManager->setTargetAssetState(assetName, AssetManager::AssetState::Synchronized);
+    assetManager->setTargetAssetState(assetName, Asset::State::SyncResolved);
     return 0;
 }
 
@@ -60,7 +60,7 @@ int initializeAsset(lua_State* state) {
 
     std::string assetName = luaL_checkstring(state, -1);
 
-    assetManager->setTargetAssetState(assetName, AssetManager::AssetState::Initialized);
+    assetManager->setTargetAssetState(assetName, Asset::State::Initialized);
     return 0;
 }
 
@@ -73,7 +73,7 @@ int unloadAsset(lua_State* state) {
 
     std::string assetName = luaL_checkstring(state, -1);
 
-    assetManager->setTargetAssetState(assetName, AssetManager::AssetState::Unloaded);
+    assetManager->setTargetAssetState(assetName, Asset::State::Unloaded);
     return 0;
 }
 
diff --git a/src/scene/assetsynchronizer.cpp b/src/scene/assetsynchronizer.cpp
deleted file mode 100644
index 7dbe371a45..0000000000
--- a/src/scene/assetsynchronizer.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-/*****************************************************************************************
- *                                                                                       *
- * OpenSpace                                                                             *
- *                                                                                       *
- * Copyright (c) 2014-2017                                                               *
- *                                                                                       *
- * 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/scene/assetsynchronizer.h>
-
-#include <algorithm>
-#include <memory>
-#include <numeric>
-
-namespace openspace {
-AssetSynchronizer::AssetSynchronizer() {}
-
-void AssetSynchronizer::startSync(std::shared_ptr<Asset> asset) {
-    std::vector<std::shared_ptr<Asset>> assets = asset->allAssets();
-    for (const auto& a : assets) {
-        std::vector<std::shared_ptr<ResourceSynchronization>> syncs =
-            a->synchronizations();
-
-        bool startedAnySync = false;
-        for (const auto& s : syncs) {
-            if (!s->isResolved()) {
-                startedAnySync = true;
-                startAssetResourceSync(a, s);
-            }
-        }
-        if (!startedAnySync) {
-            setState(a, SynchronizationState::Resolved);
-        }
-    }
-}
-
-void AssetSynchronizer::cancelSync(std::shared_ptr<Asset> asset) {
-    std::vector<std::shared_ptr<Asset>> assets = asset->allAssets();
-    for (const auto& a : assets) {
-        std::vector<std::shared_ptr<ResourceSynchronization>> syncs =
-            a->synchronizations();
-
-        bool cancelledAnySync = false;
-        for (const auto& s : syncs) {
-            if (s->isSyncing()) {
-                cancelledAnySync = true;
-                cancelAssetResourceSync(a, s);
-            }
-        }
-        if (cancelledAnySync) {
-            setState(a, SynchronizationState::Unsynced);
-        }
-    }
-}
-
-void AssetSynchronizer::restartSync(std::shared_ptr<Asset> asset) {
-    cancelSync(asset);
-    startSync(asset);
-}
-
-
-float AssetSynchronizer::assetProgress(Asset* asset) {
-    std::vector<std::shared_ptr<Asset>> assets = asset->allAssets();
-
-    size_t nTotalBytes = 0;
-    size_t nSyncedBytes = 0;
-
-    for (const auto& a : assets) {
-        const std::vector<std::shared_ptr<ResourceSynchronization>> syncs =
-            asset->synchronizations();
-
-        for (const auto& sync : syncs) {
-            if (sync->nTotalBytesIsKnown()) {
-                nTotalBytes += sync->nTotalBytes();
-                nSyncedBytes += sync->nSynchronizedBytes();
-            } else {
-                return 0;
-            }
-        }
-    }
-    if (nTotalBytes == 0) {
-        return 1.f;
-    }
-    
-    return static_cast<float>(nSyncedBytes)/static_cast<float>(nTotalBytes);
-}
-
-
-std::vector<AssetSynchronizer::StateChange> AssetSynchronizer::getStateChanges() {
-    std::vector<StateChange> stateChangesVector;
-    for (auto& s : _stateChanges) {
-        stateChangesVector.push_back(std::move(s.second));
-    }
-    _stateChanges.clear();
-    return stateChangesVector;
-}
-    
-AssetSynchronizer::SynchronizationState AssetSynchronizer::assetState(Asset*) {
-    return SynchronizationState::Unsynced;
-}
-    
-void AssetSynchronizer::startAssetResourceSync(
-    std::shared_ptr<Asset> asset,
-    std::shared_ptr<ResourceSynchronization> sync)
-{
-    _stateChanges[asset.get()] = StateChange{asset, SynchronizationState::Synchronizing};
-    _resourceToAssetMap[sync.get()].insert(asset.get());
-    
-    ResourceSynchronization::CallbackHandle h =
-        sync->addStateChangeCallback([this, asset, sync](ResourceSynchronization::State state) {
-            handleSyncStateChange(asset, sync, state);
-        });
-}
-
-void AssetSynchronizer::cancelAssetResourceSync(
-    std::shared_ptr<Asset> asset,
-    std::shared_ptr<ResourceSynchronization> sync)
-{
-    // Todo: implement this
-}
-
-    
-void AssetSynchronizer::setState(
-    std::shared_ptr<Asset> asset,
-    AssetSynchronizer::SynchronizationState state)
-{
-    _stateChanges[asset.get()] = StateChange{asset, state};
-}
-    
-void AssetSynchronizer::handleSyncStateChange(
-    std::shared_ptr<Asset> asset,
-    std::shared_ptr<ResourceSynchronization> sync,
-    ResourceSynchronization::State state)
-{
-    if (state == ResourceSynchronization::State::Resolved) {
-        _resourceToAssetMap[sync.get()].erase(asset.get());
-        if (_resourceToAssetMap[sync.get()].empty()) {
-//            _stateChanges[asset.get()] =
-        }
-    }
-}
-
-/*
-bool AssetSynchronizer::assetIsSynchronized(Asset * asset) {
-    std::vector<std::shared_ptr<ResourceSynchronization>> syncs = asset->synchronizations();
-    for (const auto& s : syncs) {
-        if (!s->isResolved()) {
-            return false;
-        }
-    }
-    return true;
-}*/
-
-}