diff --git a/apps/TaskRunner/main.cpp b/apps/TaskRunner/main.cpp
index 5edbd82b41..83d426cd23 100644
--- a/apps/TaskRunner/main.cpp
+++ b/apps/TaskRunner/main.cpp
@@ -31,12 +31,15 @@
 #include <ghoul/io/texture/texturereaderdevil.h>
 #include <ghoul/io/texture/texturereaderfreeimage.h>
 #include <ghoul/filesystem/filesystem.h>
+#include <ghoul/filesystem/directory.h>
+#include <ghoul/logging/logmanager.h>
+#include <ghoul/logging/consolelog.h>
 #include <ghoul/ghoul.h>
+#include <ghoul/cmdparser/commandlineparser.h>
+#include <ghoul/cmdparser/singlecommand.h>
 
 #include <openspace/scripting/scriptengine.h>
-
 #include <openspace/rendering/renderable.h>
-
 #include <openspace/util/progressbar.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/configurationmanager.h>
@@ -62,10 +65,54 @@ void initTextureReaders() {
     #endif // GHOUL_USE_FREEIMAGE
 }
 
+void performTasks(const std::string& path) {
+    using namespace openspace;
+
+    TaskLoader taskLoader;
+    std::vector<std::unique_ptr<Task>> tasks = taskLoader.tasksFromFile(path);
+
+    size_t nTasks = tasks.size();
+    if (nTasks == 1) {
+        LINFO("Task queue has 1 item");
+    }
+    else {
+        LINFO("Task queue has " << tasks.size() << " items");
+    }
+
+    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());
+        ProgressBar progressBar(100);
+        auto onProgress = [&progressBar](float progress) {
+            progressBar.print(progress * 100);
+        };
+        task.perform(onProgress);
+    }
+    std::cout << "Done performing tasks." << std::endl;
+}
+
 int main(int argc, char** argv) {
     using namespace openspace;
 
     ghoul::initialize();
+
+    ghoul::logging::LogManager::initialize(
+        ghoul::logging::LogLevel::Debug,
+        ghoul::logging::LogManager::ImmediateFlush::Yes
+    );
+    LogMgr.addLog(std::make_unique< ghoul::logging::ConsoleLog>());
+
+    LDEBUG("Initialize FileSystem");
+
+    ghoul::filesystem::Directory launchDirectory = FileSys.currentDirectory();
+
+#ifdef __APPLE__
+    ghoul::filesystem::File app(argv[0]);
+    std::string dirName = app.directoryName();
+    LINFO("Setting starting directory to '" << dirName << "'");
+    FileSys.setCurrentDirectory(dirName);
+#endif
+
     initTextureReaders();
 
     FactoryManager::initialize();
@@ -98,34 +145,49 @@ int main(int argc, char** argv) {
 
     ModuleEngine moduleEngine;
     moduleEngine.initialize();
-
-    std::string tasksPath;
-    configuration.getValue(ConfigurationManager::KeyConfigTask, tasksPath);
-
     LINFO("Initialization done.");
 
-    TaskLoader taskLoader;
-    std::vector<std::unique_ptr<Task>> tasks = taskLoader.tasksFromFile(tasksPath);
-    
-    size_t nTasks = tasks.size();
-    if (nTasks == 1) {
-        LINFO("Task queue has 1 item");
-    } else {
-        LINFO("Task queue has " << tasks.size() << " items");
+    // Parse commandline arguments
+    std::vector<std::string> args(argv, argv + argc);
+
+    ghoul::cmdparser::CommandlineParser commandlineParser(
+        "OpenSpace TaskRunner",
+        ghoul::cmdparser::CommandlineParser::AllowUnknownCommands::Yes
+    );
+
+    std::string tasksPath = "";
+    commandlineParser.addCommand(
+        std::make_unique<ghoul::cmdparser::SingleCommand<std::string>>(
+            &tasksPath,
+            "--task",
+            "-t",
+            "Provides the path to a task file to execute"
+            )
+    );
+
+    commandlineParser.setCommandLine(args);
+    commandlineParser.execute();
+
+    FileSys.setCurrentDirectory(launchDirectory);
+
+    if (tasksPath != "") {
+        performTasks(tasksPath);
+        return 0;
     }
 
-    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());
-        ProgressBar progressBar(100);
-        auto onProgress = [&progressBar](float progress) {
-            progressBar.print(progress * 100);
-        };
-        task.perform(onProgress);
+    // If no task file was specified in as argument, run in CLI mode.
+
+    std::string tasksRoot;
+    if (configuration.getValue(ConfigurationManager::KeyConfigTasksRoot, tasksRoot)) {
+        LINFO("Task root: " << tasksRoot);
+        FileSys.setCurrentDirectory(ghoul::filesystem::Directory(absPath(tasksRoot)));
     }
 
-    std::cout << "Done performing tasks." << std::endl;
+    std::cout << "TASK >";
+    while (std::cin >> tasksPath) {
+        performTasks(tasksPath);
+        std::cout << "TASK >";
+    }
 
-    std::cin.get();
     return 0;
 };
diff --git a/ext/ghoul b/ext/ghoul
index 3fd891bcc8..620e4faf5f 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit 3fd891bcc8a7b31eee4021033e9a1dbc72846f1d
+Subproject commit 620e4faf5f948259d793c17634314a97fc9d5fe8
diff --git a/include/openspace/engine/configurationmanager.h b/include/openspace/engine/configurationmanager.h
index 2f9c387251..75163f2c75 100644
--- a/include/openspace/engine/configurationmanager.h
+++ b/include/openspace/engine/configurationmanager.h
@@ -69,8 +69,8 @@ public:
     static const std::string KeyFactoryDocumentation;
     /// The key that stores the location of the scene file that is initially loaded
     static const std::string KeyConfigScene;
-    /// The key that stores the location of the tasks file that is initially loaded
-    static const std::string KeyConfigTask;
+    /// The key that stores the location of the tasks files
+    static const std::string KeyConfigTasksRoot;
     /// 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;
diff --git a/include/openspace/rendering/framebufferrenderer.h b/include/openspace/rendering/framebufferrenderer.h
index 9a0d6c9799..c82be8e536 100644
--- a/include/openspace/rendering/framebufferrenderer.h
+++ b/include/openspace/rendering/framebufferrenderer.h
@@ -46,7 +46,6 @@ namespace ghoul::opengl {
 
 namespace openspace {
 
-class RenderableVolume;
 class Camera;
 class Scene;
     
diff --git a/include/openspace/util/timemanager.h b/include/openspace/util/timemanager.h
index a499c2d400..2a7ef4d21b 100644
--- a/include/openspace/util/timemanager.h
+++ b/include/openspace/util/timemanager.h
@@ -42,8 +42,11 @@ public:
     void removeKeyframesBefore(double timestamp);
     void removeKeyframesAfter(double timestamp);
     void clearKeyframes();
+    void setTimeNextFrame(Time t);
     size_t nKeyframes() const;
 private:
+    bool _shouldSetTime;
+    Time _timeNextFrame;
     Timeline<Time> _timeline;
     SyncData<Time> _currentTime;
     void consumeKeyframes(double dt);
diff --git a/modules/globebrowsing/globebrowsingmodule.cpp b/modules/globebrowsing/globebrowsingmodule.cpp
index 97d2878707..47f48ae4a2 100644
--- a/modules/globebrowsing/globebrowsingmodule.cpp
+++ b/modules/globebrowsing/globebrowsingmodule.cpp
@@ -123,6 +123,15 @@ namespace openspace {
 GlobeBrowsingModule::GlobeBrowsingModule() : OpenSpaceModule(Name) {}
 
 void GlobeBrowsingModule::internalInitialize() {
+    // TODO: Remove dependency on OsEng.
+    // Instead, make this class implement an interface that OsEng depends on.
+    // Do not try to register module callbacks if OsEng does not exist,
+    // for example in the TaskRunner.
+
+    if (!OpenSpaceEngine::isCreated()) {
+        return;
+    }
+
     using namespace globebrowsing;
 
     // Initialize
diff --git a/modules/kameleonvolume/CMakeLists.txt b/modules/kameleonvolume/CMakeLists.txt
index 76ff95de0c..32dd9a68c6 100644
--- a/modules/kameleonvolume/CMakeLists.txt
+++ b/modules/kameleonvolume/CMakeLists.txt
@@ -28,17 +28,17 @@ set(HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/kameleonvolumereader.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kameleonvolumereader.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderablekameleonvolume.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/rendering/kameleonvolumeraycaster.h
   ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleondocumentationtask.h
   ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleonmetadatatojsontask.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleonvolumetorawtask.h
 )
 source_group("Header Files" FILES ${HEADER_FILES})
 
 set(SOURCE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderablekameleonvolume.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/rendering/kameleonvolumeraycaster.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleondocumentationtask.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleonmetadatatojsontask.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/tasks/kameleonvolumetorawtask.cpp
 )
 source_group("Source Files" FILES ${SOURCE_FILES})
 
diff --git a/modules/kameleonvolume/kameleonvolumemodule.cpp b/modules/kameleonvolume/kameleonvolumemodule.cpp
index 28681c0b12..ba5a4bd112 100644
--- a/modules/kameleonvolume/kameleonvolumemodule.cpp
+++ b/modules/kameleonvolume/kameleonvolumemodule.cpp
@@ -32,9 +32,13 @@
 #include <modules/kameleonvolume/rendering/renderablekameleonvolume.h>
 #include <modules/kameleonvolume/tasks/kameleonmetadatatojsontask.h>
 #include <modules/kameleonvolume/tasks/kameleondocumentationtask.h>
+#include <modules/kameleonvolume/tasks/kameleonvolumetorawtask.h>
 
 namespace openspace {
 
+
+using namespace kameleonvolume;
+
 KameleonVolumeModule::KameleonVolumeModule() : OpenSpaceModule(Name) {}
 
 void KameleonVolumeModule::internalInitialize() {
@@ -46,6 +50,7 @@ void KameleonVolumeModule::internalInitialize() {
     ghoul_assert(fTask, "No task factory existed");
     fTask->registerClass<KameleonMetadataToJsonTask>("KameleonMetadataToJsonTask");
     fTask->registerClass<KameleonDocumentationTask>("KameleonDocumentationTask");
+    fTask->registerClass<KameleonVolumeToRawTask>("KameleonVolumeToRawTask");
 }
 
 std::vector<documentation::Documentation> KameleonVolumeModule::documentations() const {
diff --git a/modules/kameleonvolume/kameleonvolumereader.cpp b/modules/kameleonvolume/kameleonvolumereader.cpp
index 5bde722d5e..d3e03f8296 100644
--- a/modules/kameleonvolume/kameleonvolumereader.cpp
+++ b/modules/kameleonvolume/kameleonvolumereader.cpp
@@ -48,36 +48,66 @@ namespace {
 } // namespace
 
 namespace openspace {
+namespace kameleonvolume {
 
 KameleonVolumeReader::KameleonVolumeReader(const std::string& path)
     : _path(path)
 {
     if (!FileSys.fileExists(path)) {
-        LERROR(_path << "does not exist");
-        return;
+        LERROR(_path << " does not exist");
+        throw ghoul::FileNotFoundError(_path);
     }
 
     long status = _kameleon.open(_path);
     if (status != ccmc::FileReader::OK) {
-        LERROR("Failed to open file " << _path << " with kameleon");
+        LERROR("Failed to open file " << _path << " with Kameleon");
+        throw ghoul::RuntimeError("Failed to open file: " + _path + " with Kameleon");
         return;
     }
 
     _model = _kameleon.model;
+
+    // Possibly use a kameleon interpolator instead of a model interpolator?
     _interpolator = std::unique_ptr<ccmc::Interpolator>(_model->createNewInterpolator());
 }
 
-std::unique_ptr<RawVolume<float>> KameleonVolumeReader::readFloatVolume(
+std::unique_ptr<volume::RawVolume<float>> KameleonVolumeReader::readFloatVolume(
+    const glm::uvec3 & dimensions,
+    const std::string & variable,
+    const glm::vec3 & lowerDomainBound,
+    const glm::vec3 & upperDomainBound) const
+{
+    float min, max;
+    return readFloatVolume(dimensions, variable, lowerDomainBound, upperDomainBound, min, max);
+}
+
+std::unique_ptr<volume::RawVolume<float>> KameleonVolumeReader::readFloatVolume(
     const glm::uvec3 & dimensions,
     const std::string & variable,
     const glm::vec3 & lowerBound,
-    const glm::vec3 & upperBound) const
+    const glm::vec3 & upperBound,
+    float& minValue,
+    float& maxValue) const
 {
-    auto volume = std::make_unique<RawVolume<float>>(dimensions);
+    minValue = FLT_MAX;
+    maxValue = FLT_MIN;
+
+    auto volume = std::make_unique<volume::RawVolume<float>>(dimensions);
     const glm::vec3 dims = volume->dimensions();
     const glm::vec3 diff = upperBound - lowerBound;
 
-    _model->loadVariable(variable);
+    auto interpolate =
+        [this](const std::string& variable, glm::vec3 volumeCoords) {
+            return _interpolator->interpolate(
+                variable,
+                volumeCoords[0],
+                volumeCoords[1],
+                volumeCoords[2]);
+        };
+
+    auto sample = [this, &variable, &interpolate](glm::vec3 volumeCoords) {
+        return interpolate(variable, volumeCoords);
+    };
 
     float* data = volume->data();
     for (size_t index = 0; index < volume->nCells(); index++) {
@@ -85,11 +115,14 @@ std::unique_ptr<RawVolume<float>> KameleonVolumeReader::readFloatVolume(
         glm::vec3 coordsZeroToOne = coords / dims;
         glm::vec3 volumeCoords = lowerBound + diff * coordsZeroToOne;
 
-        data[index] = _interpolator->interpolate(
-            variable,
-            static_cast<float>(volumeCoords[0]),
-            static_cast<float>(volumeCoords[1]),
-            static_cast<float>(volumeCoords[2]));
+        data[index] = sample(volumeCoords);
+
+        if (data[index] < minValue) {
+            minValue = data[index];
+        }
+        if (data[index] > maxValue) {
+            maxValue = data[index];
+        }
     }
 
     return volume;
@@ -205,12 +238,80 @@ ghoul::Dictionary KameleonVolumeReader::readMetaData() const {
     };
 }
 
-float KameleonVolumeReader::minValue(const std::string & variable) const {
+std::string KameleonVolumeReader::simulationStart() const {
+    std::string startTime;
+    if (_model->doesAttributeExist("start_time")){
+        startTime =
+            _model->getGlobalAttribute("start_time").getAttributeString();
+    } else if (_model->doesAttributeExist("tim_rundate_cal")) {
+        startTime =
+            _model->getGlobalAttribute("tim_rundate_cal").getAttributeString();
+        size_t numChars = startTime.length();
+        if (numChars < 19) {
+            // Fall through to add the required characters
+            switch (numChars) {
+                case 10 : // YYYY-MM-DD        => YYYY-MM-DDTHH
+                    startTime += "T00";
+                    [[fallthrough]];
+                case 13 : // YYYY-MM-DDTHH     => YYYY-MM-DDTHH:
+                    startTime += ":";
+                    [[fallthrough]];
+                case 14 : // YYYY-MM-DDTHH:    => YYYY-MM-DDTHH:MM
+                    startTime += "00";
+                    [[fallthrough]];
+                case 16 : // YYYY-MM-DDTHH:MM  => YYYY-MM-DDTHH:MM:
+                    startTime += ":";
+                    [[fallthrough]];
+                case 17 : // YYYY-MM-DDTHH:MM: => YYYY-MM-DDTHH:MM:SS
+                    startTime += "00";
+                    break;
+                default :
+                    break;
+            }
+        }
+    } else if (_model->doesAttributeExist("tim_obsdate_cal")) {
+        startTime =
+            _model->getGlobalAttribute("tim_obsdate_cal").getAttributeString();
+    } else if (_model->doesAttributeExist("tim_crstart_cal")) {
+        startTime =
+            _model->getGlobalAttribute("tim_crstart_cal").getAttributeString();
+    }
+
+    if (startTime.length() == 19) {
+        startTime += ".000Z";
+    }
+
+    return startTime;
+}
+
+float KameleonVolumeReader::elapsedTime() const {
+    if (_model->doesAttributeExist("elapsed_time_in_seconds")) {
+        return _model->getGlobalAttribute("elapsed_time_in_seconds").getAttributeFloat();
+    } else if (_model->doesAttributeExist("time_physical_time")) {
+        return _model->getGlobalAttribute("time_physical_time").getAttributeFloat();
+    }
+    return 0;
+}
+
+std::string KameleonVolumeReader::simulationEnd() const {
+    return _model->getGlobalAttribute("end_time").getAttributeString();
+}
+
+std::string KameleonVolumeReader::time() const {
+    double start =
+        ccmc::Time(simulationStart()).getEpoch();
+    // Get elapsed time in seconds and convert to milliseconds.
+    double elapsed = elapsedTime() * 1000;
+    return ccmc::Time(start + elapsed).toString();
+}
+
+double KameleonVolumeReader::minValue(const std::string & variable) const {
     return _model->getVariableAttribute(variable, "actual_min").getAttributeFloat();
 }
 
-float KameleonVolumeReader::maxValue(const std::string & variable) const {
+double KameleonVolumeReader::maxValue(const std::string & variable) const {
     return _model->getVariableAttribute(variable, "actual_max").getAttributeFloat();
 }
 
+} // namepace kameleonvolume
 } // namespace openspace
diff --git a/modules/kameleonvolume/kameleonvolumereader.h b/modules/kameleonvolume/kameleonvolumereader.h
index 4e220747db..17370df7cd 100644
--- a/modules/kameleonvolume/kameleonvolumereader.h
+++ b/modules/kameleonvolume/kameleonvolumereader.h
@@ -47,23 +47,37 @@
 namespace ccmc { class Model; }
 
 namespace openspace {
+namespace kameleonvolume {
 
 class KameleonVolumeReader {
 public:
     KameleonVolumeReader(const std::string& path);
-    //KameleonMetaData readMetaData();
 
-    std::unique_ptr<RawVolume<float>> readFloatVolume(
+    std::unique_ptr<volume::RawVolume<float>> readFloatVolume(
+        const glm::uvec3& dimensions,
+        const std::string& variable,
+        const glm::vec3& lowerDomainBound,
+        const glm::vec3& upperDomainBound) const;
+
+    std::unique_ptr<volume::RawVolume<float>> readFloatVolume(
         const glm::uvec3& dimensions,
         const std::string& variable,
         const glm::vec3& lowerBound,
-        const glm::vec3& upperBound) const;
+        const glm::vec3& upperBound,
+        float& minValue,
+        float& maxValue) const;
+
     ghoul::Dictionary readMetaData() const;
-    float minValue(const std::string& variable) const;
-    float maxValue(const std::string& variable) const;
+
+    std::string time() const;
+    std::string simulationStart() const;
+    std::string simulationEnd() const;
+    float elapsedTime() const;
+
+    double minValue(const std::string& variable) const;
+    double maxValue(const std::string& variable) const;
 
     std::vector<std::string> gridVariableNames() const;
-    std::vector<std::string> gridUnits() const;
     std::vector<std::string> variableNames() const;
     std::vector<std::string> variableAttributeNames() const;
     std::vector<std::string> globalAttributeNames() const;
@@ -77,6 +91,7 @@ private:
 
 };
 
+} // namespace kameleonvolume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONVOLUMEREADER___H__
diff --git a/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp b/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
index f5dfc49ae6..53ebd88c28 100644
--- a/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
+++ b/modules/kameleonvolume/rendering/renderablekameleonvolume.cpp
@@ -133,6 +133,7 @@ namespace {
 } // namespace
 
 namespace openspace {
+namespace kameleonvolume {
 
 RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dictionary)
     : Renderable(dictionary)
@@ -226,7 +227,7 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
 
     ghoul::Dictionary clipPlanesDictionary;
     dictionary.getValue(KeyClipPlanes, clipPlanesDictionary);
-    _clipPlanes = std::make_shared<VolumeClipPlanes>(clipPlanesDictionary);
+    _clipPlanes = std::make_shared<volume::VolumeClipPlanes>(clipPlanesDictionary);
     _clipPlanes->setName("clipPlanes");
 
     bool cache;
@@ -234,14 +235,14 @@ RenderableKameleonVolume::RenderableKameleonVolume(const ghoul::Dictionary& dict
         _cache = cache;
     }
 
-    _gridType.addOption(static_cast<int>(VolumeGridType::Cartesian), "Cartesian grid");
-    _gridType.addOption(static_cast<int>(VolumeGridType::Spherical), "Spherical grid");
-    _gridType.setValue(static_cast<int>(VolumeGridType::Cartesian));
+    _gridType.addOption(static_cast<int>(volume::VolumeGridType::Cartesian), "Cartesian grid");
+    _gridType.addOption(static_cast<int>(volume::VolumeGridType::Spherical), "Spherical grid");
+    _gridType.setValue(static_cast<int>(volume::VolumeGridType::Cartesian));
 
     std::string gridType;
     if (dictionary.getValue(KeyGridType, gridType)) {
         if (gridType == ValueSphericalGridType) {
-            _gridType.setValue(static_cast<int>(VolumeGridType::Spherical));
+            _gridType.setValue(static_cast<int>(volume::VolumeGridType::Spherical));
         } else {
             _autoGridType = true;
         }
@@ -256,15 +257,15 @@ void RenderableKameleonVolume::initialize() {
     _volumeTexture->uploadTexture();
     _transferFunction->update();
 
-    _raycaster = std::make_unique<KameleonVolumeRaycaster>(_volumeTexture, _transferFunction, _clipPlanes);
+    _raycaster = std::make_unique<volume::BasicVolumeRaycaster>(_volumeTexture, _transferFunction, _clipPlanes);
 
     _raycaster->setStepSize(_stepSize);
     _gridType.onChange([this] {
         _raycaster->setStepSize(_stepSize);
     });
-    _raycaster->setGridType(static_cast<VolumeGridType>(_gridType.value()));
+    _raycaster->setGridType(static_cast<volume::VolumeGridType>(_gridType.value()));
     _gridType.onChange([this] {
-        _raycaster->setGridType(static_cast<VolumeGridType>(_gridType.value()));
+        _raycaster->setGridType(static_cast<volume::VolumeGridType>(_gridType.value()));
     });
 
     updateRaycasterModelTransform();
@@ -372,7 +373,7 @@ void RenderableKameleonVolume::loadFromPath(const std::string& path) {
 }
 
 void RenderableKameleonVolume::loadRaw(const std::string& path) {
-    RawVolumeReader<float> reader(path, _dimensions);
+    volume::RawVolumeReader<float> reader(path, _dimensions);
     _rawVolume = reader.read();
     updateTextureFromVolume();
 }
@@ -401,10 +402,10 @@ void RenderableKameleonVolume::loadCdf(const std::string& path) {
 
     if (variables.size() == 3 && _autoGridType) {
         if (variables[0] == "r" && variables[0] == "theta" && variables[0] == "phi") {
-            _gridType.setValue(static_cast<int>(VolumeGridType::Spherical));
+            _gridType.setValue(static_cast<int>(volume::VolumeGridType::Spherical));
         }
         else {
-            _gridType.setValue(static_cast<int>(VolumeGridType::Cartesian));
+            _gridType.setValue(static_cast<int>(volume::VolumeGridType::Cartesian));
         }       
     }
 
@@ -414,7 +415,7 @@ void RenderableKameleonVolume::loadCdf(const std::string& path) {
 }
 
 void RenderableKameleonVolume::updateTextureFromVolume() {
-    _normalizedVolume = std::make_unique<RawVolume<GLfloat>>(_dimensions);
+    _normalizedVolume = std::make_unique<volume::RawVolume<GLfloat>>(_dimensions);
     float* in = _rawVolume->data();
     GLfloat* out = _normalizedVolume->data();
     float min = _lowerValueBound;
@@ -438,7 +439,7 @@ void RenderableKameleonVolume::updateTextureFromVolume() {
 }
 
 void RenderableKameleonVolume::storeRaw(const std::string& path) {
-    RawVolumeWriter<float> writer(path);
+    volume::RawVolumeWriter<float> writer(path);
     writer.write(*_rawVolume);
 }
     
@@ -464,3 +465,4 @@ void RenderableKameleonVolume::render(const RenderData& data, RendererTasks& tas
 }
        
 }
+}
diff --git a/modules/kameleonvolume/rendering/renderablekameleonvolume.h b/modules/kameleonvolume/rendering/renderablekameleonvolume.h
index 35b0f512ec..e25c8797b8 100644
--- a/modules/kameleonvolume/rendering/renderablekameleonvolume.h
+++ b/modules/kameleonvolume/rendering/renderablekameleonvolume.h
@@ -29,21 +29,21 @@
 #include <openspace/properties/optionproperty.h>
 #include <openspace/properties/stringproperty.h>
 #include <openspace/util/boxgeometry.h>
-#include <openspace/util/blockplaneintersectiongeometry.h>
-
 #include <openspace/rendering/renderable.h>
-
 #include <openspace/rendering/transferfunction.h>
+
 #include <modules/kameleon/include/kameleonwrapper.h>
 #include <modules/volume/rawvolume.h>
-#include <modules/kameleonvolume/rendering/kameleonvolumeraycaster.h>
+#include <modules/volume/rendering/basicvolumeraycaster.h>
 
 #include <modules/volume/rendering/volumeclipplanes.h>
 
 namespace openspace {
 
 struct RenderData;
-    
+
+namespace kameleonvolume {
+
 class RenderableKameleonVolume : public Renderable {
 public:
     RenderableKameleonVolume(const ghoul::Dictionary& dictionary);
@@ -81,7 +81,7 @@ private:
     properties::OptionProperty _gridType;
     bool _autoGridType;
 
-    std::shared_ptr<VolumeClipPlanes> _clipPlanes;
+    std::shared_ptr<volume::VolumeClipPlanes> _clipPlanes;
 
     properties::FloatProperty _stepSize;
     properties::StringProperty _sourcePath;
@@ -89,14 +89,15 @@ private:
     properties::BoolProperty _cache;
 
 
-    std::unique_ptr<RawVolume<float>> _rawVolume;
-    std::unique_ptr<RawVolume<GLfloat>> _normalizedVolume;
-    std::unique_ptr<KameleonVolumeRaycaster> _raycaster;
+    std::unique_ptr<volume::RawVolume<float>> _rawVolume;
+    std::unique_ptr<volume::RawVolume<GLfloat>> _normalizedVolume;
+    std::unique_ptr<volume::BasicVolumeRaycaster> _raycaster;
 
     std::shared_ptr<ghoul::opengl::Texture> _volumeTexture;
     std::shared_ptr<TransferFunction> _transferFunction;
 };
 
+} // namespace kameleonvolume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_KAMELEONVOLUME___RENDERABLEKAMELEONVOLUME___H__
diff --git a/modules/kameleonvolume/tasks/kameleondocumentationtask.cpp b/modules/kameleonvolume/tasks/kameleondocumentationtask.cpp
index 7ced53033f..c61581477b 100644
--- a/modules/kameleonvolume/tasks/kameleondocumentationtask.cpp
+++ b/modules/kameleonvolume/tasks/kameleondocumentationtask.cpp
@@ -46,6 +46,7 @@ namespace {
 } // namespace
 
 namespace openspace {
+namespace kameleonvolume {
 
 KameleonDocumentationTask::KameleonDocumentationTask(const ghoul::Dictionary& dictionary) {
     openspace::documentation::testSpecificationAndThrow(
@@ -164,4 +165,5 @@ documentation::Documentation KameleonDocumentationTask::documentation() {
     };
 }
 
+} // namespace kameleonvolume
 } // namespace openspace
diff --git a/modules/kameleonvolume/tasks/kameleondocumentationtask.h b/modules/kameleonvolume/tasks/kameleondocumentationtask.h
index 9938f29979..c6e5ea7266 100644
--- a/modules/kameleonvolume/tasks/kameleondocumentationtask.h
+++ b/modules/kameleonvolume/tasks/kameleondocumentationtask.h
@@ -30,6 +30,7 @@
 #include <string>
 
 namespace openspace {
+namespace kameleonvolume {
 
 class KameleonDocumentationTask : public Task {
 public:
@@ -43,6 +44,7 @@ private:
     std::string _outputPath;
 };
 
+} // namespace kameleonvolume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONDOCUMENTATIONTASK___H__
diff --git a/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.cpp b/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.cpp
index 75309f32cf..5d7740e909 100644
--- a/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.cpp
+++ b/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.cpp
@@ -39,6 +39,7 @@ namespace {
 } // namespace
 
 namespace openspace {
+namespace kameleonvolume {
 
 KameleonMetadataToJsonTask::KameleonMetadataToJsonTask(
                                                       const ghoul::Dictionary& dictionary)
@@ -98,4 +99,5 @@ documentation::Documentation KameleonMetadataToJsonTask::documentation() {
     };
 }
 
+} // namespace kameleonvolume
 } // namespace openspace
diff --git a/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.h b/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.h
index 42bf6a84b3..0d7e6077cd 100644
--- a/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.h
+++ b/modules/kameleonvolume/tasks/kameleonmetadatatojsontask.h
@@ -30,6 +30,7 @@
 #include <string>
 
 namespace openspace {
+namespace kameleonvolume {
 
 class KameleonMetadataToJsonTask : public Task {
 public:
@@ -43,6 +44,7 @@ private:
     std::string _outputPath;
 };
 
+} // namespace kameleonvolume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONMETADATATOJSONTASK___H__
diff --git a/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp
new file mode 100644
index 0000000000..c6fd38719c
--- /dev/null
+++ b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.cpp
@@ -0,0 +1,207 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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 <modules/kameleonvolume/tasks/kameleonvolumetorawtask.h>
+#include <modules/kameleonvolume/kameleonvolumereader.h>
+#include <modules/volume/rawvolume.h>
+#include <modules/volume/rawvolumewriter.h>
+
+#include <openspace/documentation/verifier.h>
+
+#include <ghoul/misc/dictionaryjsonformatter.h>
+#include <ghoul/filesystem/filesystem.h>
+
+#include <ghoul/logging/logmanager.h>
+#include <ghoul/misc/dictionaryluaformatter.h>
+
+#include <fstream>
+
+namespace {
+    const char* KeyInput = "Input";
+    const char* KeyRawVolumeOutput = "RawVolumeOutput";
+    const char* KeyDictionaryOutput = "DictionaryOutput";
+    const char* KeyDimensions = "Dimensions";
+    const char* KeyVariable = "Variable";
+    const char* KeyTime = "Time";
+    const char* KeyLowerDomainBound = "LowerDomainBound";
+    const char* KeyUpperDomainBound = "UpperDomainBound";
+
+    const char* KeyMinValue = "MinValue";
+    const char* KeyMaxValue = "MaxValue";
+
+    const char* _loggerCat = "KameleonVolumeToRawTask";
+} // namespace
+
+namespace openspace {
+namespace kameleonvolume {
+
+KameleonVolumeToRawTask::KameleonVolumeToRawTask(const ghoul::Dictionary& dictionary)
+    : _autoDomainBounds(false)
+{
+    openspace::documentation::testSpecificationAndThrow(
+        documentation(),
+        dictionary,
+        "KameleonVolumeToRawTask"
+    );
+
+    _inputPath = absPath(dictionary.value<std::string>(KeyInput));
+    _rawVolumeOutputPath = absPath(dictionary.value<std::string>(KeyRawVolumeOutput));
+    _dictionaryOutputPath = absPath(dictionary.value<std::string>(KeyDictionaryOutput));
+    _variable = dictionary.value<std::string>(KeyVariable);
+    _dimensions = glm::uvec3(dictionary.value<glm::vec3>(KeyDimensions));
+    
+    if (!dictionary.getValue<glm::vec3>(KeyLowerDomainBound, _lowerDomainBound)) {
+        _autoDomainBounds = true;
+    }
+    if (!dictionary.getValue<glm::vec3>(KeyUpperDomainBound, _upperDomainBound)) {
+        _autoDomainBounds = true;
+    }
+}
+
+std::string KameleonVolumeToRawTask::description() {
+    return "Extract volumetric data from cdf-file " + _inputPath + "." +
+        "Write raw volume data into " + _rawVolumeOutputPath +
+        " and dictionary with metadata to " + _dictionaryOutputPath;
+}
+
+void KameleonVolumeToRawTask::perform(const Task::ProgressCallback& progressCallback) {
+    KameleonVolumeReader reader(_inputPath);
+
+    std::vector<std::string> variables = reader.gridVariableNames();
+
+    if (variables.size() == 3 && _autoDomainBounds) {
+        _lowerDomainBound = glm::vec3(
+            reader.minValue(variables[0]),
+            reader.minValue(variables[1]),
+            reader.minValue(variables[2]));
+
+        _upperDomainBound = glm::vec3(
+            reader.maxValue(variables[0]),
+            reader.maxValue(variables[1]),
+            reader.maxValue(variables[2]));
+    }
+
+    
+    std::unique_ptr<volume::RawVolume<float>> rawVolume = reader.readFloatVolume(
+        _dimensions,
+        _variable,
+        _lowerDomainBound,
+        _upperDomainBound);
+
+    progressCallback(0.5f);
+
+    volume::RawVolumeWriter<float> writer(_rawVolumeOutputPath);
+    writer.write(*rawVolume);
+
+    progressCallback(0.9f);
+    
+    ghoul::Dictionary inputMetadata = reader.readMetaData();
+    ghoul::Dictionary outputMetadata;
+
+    std::string time = reader.time();
+
+    // Do not include time offset in time string
+    if (time.back() == 'Z') {
+        time.pop_back();
+    }
+
+    outputMetadata.setValue<std::string>(KeyTime, time);
+    outputMetadata.setValue<glm::vec3>(KeyDimensions, _dimensions);
+    outputMetadata.setValue<glm::vec3>(KeyLowerDomainBound, _lowerDomainBound);
+    outputMetadata.setValue<glm::vec3>(KeyUpperDomainBound, _upperDomainBound);
+    outputMetadata.setValue<float>(KeyMinValue, reader.minValue(_variable));
+    outputMetadata.setValue<float>(KeyMaxValue, reader.maxValue(_variable));
+
+    ghoul::DictionaryLuaFormatter formatter;
+    std::string metadataString = formatter.format(outputMetadata);
+
+    std::fstream f(_dictionaryOutputPath, std::ios::out);
+    f << "return " << metadataString;
+    f.close();
+
+    progressCallback(1.0f);
+}
+
+documentation::Documentation KameleonVolumeToRawTask::documentation() {
+    using namespace documentation;
+    return {
+        "KameleonVolumeToRawTask",
+        "kameleon_metadata_to_json_task",
+        {
+            {
+                "Type",
+                new StringEqualVerifier("KameleonVolumeToRawTask"),
+                Optional::No,
+                "The type of this task",
+            },
+            {
+                KeyInput,
+                new StringAnnotationVerifier("A file path to a cdf file"),
+                Optional::No,
+                "The cdf file to extract data from",
+            },
+            {
+                KeyRawVolumeOutput,
+                new StringAnnotationVerifier("A valid filepath"),
+                Optional::No,
+                "The raw volume file to export data to",
+            },
+            {
+                KeyDictionaryOutput,
+                new StringAnnotationVerifier("A valid filepath"),
+                Optional::No,
+                "The lua dictionary file to export metadata to",
+            },
+            {
+                KeyVariable,
+                new StringAnnotationVerifier("A valid kameleon variable"),
+                Optional::No,
+                "The variable name to read from the kameleon dataset",
+            },
+            {
+                KeyDimensions,
+                new DoubleVector3Verifier,
+                Optional::No,
+                "A vector representing the number of cells in each dimension",
+            },
+            {
+                KeyLowerDomainBound,
+                new DoubleVector3Verifier,
+                Optional::Yes,
+                "A vector representing the lower bound of the domain, "
+                "in the native kameleon grid units",
+            },
+            {
+                KeyUpperDomainBound,
+                new DoubleVector3Verifier,
+                Optional::Yes,
+                "A vector representing the lower bound of the domain, "
+                "in the native kameleon grid units",
+            }
+        }
+    };
+}
+
+} // namespace kameleonvolume
+} // namespace openspace
diff --git a/modules/kameleonvolume/tasks/kameleonvolumetorawtask.h b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.h
new file mode 100644
index 0000000000..2556348d2a
--- /dev/null
+++ b/modules/kameleonvolume/tasks/kameleonvolumetorawtask.h
@@ -0,0 +1,59 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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_MODULE_KAMELEONVOLUME___KAMELEONVOLUMETORAWTASK___H__
+#define __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONVOLUMETORAWTASK___H__
+
+#include <openspace/util/task.h>
+
+#include <glm/glm.hpp>
+
+#include <string>
+
+namespace openspace {
+namespace kameleonvolume {
+
+class KameleonVolumeToRawTask : public Task {
+public:
+    KameleonVolumeToRawTask(const ghoul::Dictionary& dictionary);
+    std::string description() override;
+    void perform(const Task::ProgressCallback& progressCallback) override;
+    static documentation::Documentation documentation();
+    
+private:
+    std::string _inputPath;
+    std::string _rawVolumeOutputPath;
+    std::string  _dictionaryOutputPath;
+
+    std::string _variable;
+    glm::uvec3 _dimensions;
+    bool _autoDomainBounds;
+    glm::vec3 _lowerDomainBound;
+    glm::vec3 _upperDomainBound;
+};
+
+} // namespace kameleon
+} // namespace openspace
+
+#endif // __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONMETADATATORAWTASK___H__
diff --git a/modules/toyvolume/rendering/renderabletoyvolume.cpp b/modules/toyvolume/rendering/renderabletoyvolume.cpp
index 9eef47b289..8476c5c74e 100644
--- a/modules/toyvolume/rendering/renderabletoyvolume.cpp
+++ b/modules/toyvolume/rendering/renderabletoyvolume.cpp
@@ -44,12 +44,11 @@ RenderableToyVolume::RenderableToyVolume(const ghoul::Dictionary& dictionary)
     , _rotation({ "Rotation", "Euler rotation", "" }, glm::vec3(0.f, 0.f, 0.f), glm::vec3(0), glm::vec3(6.28f)) // @TODO Missing documentation
     , _color({ "Color", "Color", "" }, glm::vec4(1.f, 0.f, 0.f, 0.1f), glm::vec4(0.f), glm::vec4(1.f)) // @TODO Missing documentation
 {
-    float stepSize;
-    int scalingExponent;
+    float stepSize, scalingExponent;
     glm::vec3 scaling, translation, rotation;
     glm::vec4 color;
     if (dictionary.getValue("ScalingExponent", scalingExponent)) {
-        _scalingExponent = scalingExponent;
+        _scalingExponent = static_cast<int>(scalingExponent);
     }
     if (dictionary.getValue("Scaling", scaling)) {
         _scaling = scaling;
diff --git a/modules/volume/CMakeLists.txt b/modules/volume/CMakeLists.txt
index c85c68fbba..e25fddba05 100644
--- a/modules/volume/CMakeLists.txt
+++ b/modules/volume/CMakeLists.txt
@@ -39,6 +39,8 @@ set(HEADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/volumesampler.h
     ${CMAKE_CURRENT_SOURCE_DIR}/volumesampler.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/volumeutils.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderabletimevaryingvolume.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/basicvolumeraycaster.h
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/volumeclipplane.h
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/volumeclipplanes.h
 )
@@ -50,7 +52,10 @@ set(SOURCE_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/rawvolumewriter.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/textureslicevolumereader.inl
     ${CMAKE_CURRENT_SOURCE_DIR}/volumesampler.inl
+    ${CMAKE_CURRENT_SOURCE_DIR}/volumegridtype.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/volumeutils.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/renderabletimevaryingvolume.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/rendering/basicvolumeraycaster.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/volumeclipplane.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/rendering/volumeclipplanes.cpp
 )
diff --git a/modules/volume/linearlrucache.h b/modules/volume/linearlrucache.h
index 8dad14e140..4639da1563 100644
--- a/modules/volume/linearlrucache.h
+++ b/modules/volume/linearlrucache.h
@@ -30,6 +30,7 @@
 #include <iterator>
 
 namespace openspace {
+namespace volume {
     
 template <typename ValueType>
 class LinearLruCache {
@@ -86,6 +87,7 @@ private:
     size_t _capacity;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___LINEARLRUCACHE___H__
diff --git a/modules/volume/lrucache.h b/modules/volume/lrucache.h
index b3de5e212b..53e76c1df5 100644
--- a/modules/volume/lrucache.h
+++ b/modules/volume/lrucache.h
@@ -30,6 +30,7 @@
 #include <iterator>
 
 namespace openspace {
+namespace volume {
     
 template <typename KeyType, typename ValueType, template<typename...> class ContainerType>
 class LruCache {
@@ -85,6 +86,7 @@ private:
     size_t _capacity;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___LRUCACHE___H__
diff --git a/modules/volume/rawvolume.h b/modules/volume/rawvolume.h
index df027b05b7..ad2302e35a 100644
--- a/modules/volume/rawvolume.h
+++ b/modules/volume/rawvolume.h
@@ -30,6 +30,7 @@
 #include <vector>
 
 namespace openspace {
+namespace volume {
 
 template <typename Type>
 class RawVolume {
@@ -54,6 +55,7 @@ private:
     std::vector<VoxelType> _data;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #include "rawvolume.inl"
diff --git a/modules/volume/rawvolume.inl b/modules/volume/rawvolume.inl
index b98c0bc250..e46af5c653 100644
--- a/modules/volume/rawvolume.inl
+++ b/modules/volume/rawvolume.inl
@@ -26,6 +26,7 @@
 #include "rawvolume.h"
 
 namespace openspace {
+namespace volume {
 
 template <typename VoxelType>
 RawVolume<VoxelType>::RawVolume(const glm::uvec3& dimensions)
@@ -57,7 +58,7 @@ size_t RawVolume<VoxelType>::nCells() const
 
 template <typename VoxelType>
 VoxelType RawVolume<VoxelType>::get(const glm::uvec3& coordinates) const {
-    return get(coordsToIndex(coordinates, dimensions()));
+    return get(coordsToIndex(coordinates));
 }
 
 template <typename VoxelType>
@@ -67,7 +68,7 @@ VoxelType RawVolume<VoxelType>::get(size_t index) const {
 
 template <typename VoxelType>
 void RawVolume<VoxelType>::set(const glm::uvec3& coordinates, const VoxelType& value) {
-    return set(coordsToIndex(coordinates, dimensions()), value);
+    return set(coordsToIndex(coordinates), value);
 }
 
 template <typename VoxelType>
@@ -87,12 +88,12 @@ void RawVolume<VoxelType>::forEachVoxel(
 
 template <typename VoxelType>
 size_t RawVolume<VoxelType>::coordsToIndex(const glm::uvec3& cartesian) const {
-    return volumeutils::coordsToIndex(cartesian, dimensions());
+    return volume::coordsToIndex(cartesian, dimensions());
 }
 
 template <typename VoxelType>
 glm::uvec3 RawVolume<VoxelType>::indexToCoords(size_t linear) const {
-    return volumeutils::indexToCoords(linear, dimensions());
+    return volume::indexToCoords(linear, dimensions());
 }
 
 template <typename VoxelType>
@@ -105,5 +106,5 @@ const VoxelType* RawVolume<VoxelType>::data() const {
     return _data.data();
 }
 
-    
-}
+} // namespace volume
+} // namespace openspace
diff --git a/modules/volume/rawvolumereader.h b/modules/volume/rawvolumereader.h
index 0405500097..2b98ad0d3a 100644
--- a/modules/volume/rawvolumereader.h
+++ b/modules/volume/rawvolumereader.h
@@ -29,6 +29,7 @@
 #include <modules/volume/rawvolume.h>
 
 namespace openspace {
+namespace volume {
 
 template <typename Type>
 class RawVolumeReader {
@@ -51,6 +52,7 @@ private:
     std::string _path;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #include "rawvolumereader.inl"
diff --git a/modules/volume/rawvolumereader.inl b/modules/volume/rawvolumereader.inl
index 293e829e55..384e08e6e7 100644
--- a/modules/volume/rawvolumereader.inl
+++ b/modules/volume/rawvolumereader.inl
@@ -25,6 +25,7 @@
 #include <fstream>
 
 namespace openspace {
+namespace volume {
 
 template <typename VoxelType>
 RawVolumeReader<VoxelType>::RawVolumeReader(const std::string& path,
@@ -69,12 +70,12 @@ VoxelType RawVolumeReader<VoxelType>::get(size_t index) const {
 
 template <typename VoxelType>
 size_t RawVolumeReader<VoxelType>::coordsToIndex(const glm::uvec3& cartesian) const {
-    return volumeutils::coordsToIndex(cartesian, dimensions());
+    return coordsToIndex(cartesian, dimensions());
 }
 
 template <typename VoxelType>
 glm::uvec3 RawVolumeReader<VoxelType>::indexToCoords(size_t linear) const {
-    return volumeutils::indexToCoords(linear, dimensions());
+    return indexToCoords(linear, dimensions());
 }
 
 
@@ -95,4 +96,5 @@ std::unique_ptr<RawVolume<VoxelType>> RawVolumeReader<VoxelType>::read() {
     return volume;
 }
 
+} // namepsace volume
 } // namespace openspace
diff --git a/modules/volume/rawvolumewriter.h b/modules/volume/rawvolumewriter.h
index 33b366131b..36694c9d76 100644
--- a/modules/volume/rawvolumewriter.h
+++ b/modules/volume/rawvolumewriter.h
@@ -30,6 +30,7 @@
 #include <modules/volume/rawvolume.h>
 
 namespace openspace {
+namespace volume {
 
 template <typename VoxelType>
 class RawVolumeWriter {
@@ -51,6 +52,7 @@ private:
     size_t _bufferSize;    
 };
 
+} // namespace volume
 } // namespace openspace 
 
 #include "rawvolumewriter.inl"
diff --git a/modules/volume/rawvolumewriter.inl b/modules/volume/rawvolumewriter.inl
index c40bce81d1..018b6bf255 100644
--- a/modules/volume/rawvolumewriter.inl
+++ b/modules/volume/rawvolumewriter.inl
@@ -26,6 +26,7 @@
 #include <modules/volume/volumeutils.h>
 
 namespace openspace {
+namespace volume {
 
 template <typename VoxelType>
 RawVolumeWriter<VoxelType>::RawVolumeWriter(std::string path, size_t bufferSize)
@@ -35,12 +36,12 @@ RawVolumeWriter<VoxelType>::RawVolumeWriter(std::string path, size_t bufferSize)
 
 template <typename VoxelType>
 size_t RawVolumeWriter<VoxelType>::coordsToIndex(const glm::uvec3& cartesian) const {
-    return volumeutils::coordsToIndex(cartesian, dimensions());
+    return coordsToIndex(cartesian, dimensions());
 }
 
 template <typename VoxelType>
 glm::ivec3 RawVolumeWriter<VoxelType>::indexToCoords(size_t linear) const {
-    return volumeutils::indexToCoords(linear, dimensions());
+    return indexToCoords(linear, dimensions());
 }
 
 template <typename VoxelType>
@@ -96,4 +97,5 @@ void RawVolumeWriter<VoxelType>::write(const RawVolume<VoxelType>& volume) {
     file.close();
 }
 
+} // namespace volume
 } // namespace openspace
diff --git a/modules/kameleonvolume/rendering/kameleonvolumeraycaster.cpp b/modules/volume/rendering/basicvolumeraycaster.cpp
similarity index 54%
rename from modules/kameleonvolume/rendering/kameleonvolumeraycaster.cpp
rename to modules/volume/rendering/basicvolumeraycaster.cpp
index 304e35d9cb..e8e2b4b3a6 100644
--- a/modules/kameleonvolume/rendering/kameleonvolumeraycaster.cpp
+++ b/modules/volume/rendering/basicvolumeraycaster.cpp
@@ -22,7 +22,7 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#include <modules/kameleonvolume/rendering/kameleonvolumeraycaster.h>
+#include <modules/volume/rendering/basicvolumeraycaster.h>
 
 #include <ghoul/glm.h>
 #include <ghoul/opengl/ghoul_gl.h>
@@ -32,44 +32,44 @@
 #include <openspace/util/powerscaledcoordinate.h>
 #include <openspace/util/updatestructures.h>
 #include <openspace/rendering/renderable.h>
-#include <modules/kameleonvolume/rendering/renderablekameleonvolume.h>
 
 namespace {
-    const char* GlslRaycastPath = "${MODULES}/kameleonvolume/shaders/raycast.glsl";
-    const char* GlslHelperPath = "${MODULES}/kameleonvolume/shaders/helper.glsl";
-    const char* GlslBoundsVsPath = "${MODULES}/kameleonvolume/shaders/boundsvs.glsl";
-    const char* GlslBoundsFsPath = "${MODULES}/kameleonvolume/shaders/boundsfs.glsl";
-} // namespace
+    const char* GlslRaycastPath = "${MODULE_VOLUME}/shaders/raycast.glsl";
+    const char* GlslHelperPath = "${MODULE_VOLUME}/shaders/helper.glsl";
+    const char* GlslBoundsVsPath = "${MODULE_VOLUME}/shaders/boundsvs.glsl";
+    const char* GlslBoundsFsPath = "${MODULE_VOLUME}/shaders/boundsfs.glsl";
+}
 
 namespace openspace {
+namespace volume {
 
-KameleonVolumeRaycaster::KameleonVolumeRaycaster(
-                                          std::shared_ptr<ghoul::opengl::Texture> texture,
-                                       std::shared_ptr<TransferFunction> transferFunction,
-                                             std::shared_ptr<VolumeClipPlanes> clipPlanes)
-    : _clipPlanes(clipPlanes)
-    , _volumeTexture(texture)
+BasicVolumeRaycaster::BasicVolumeRaycaster(
+    std::shared_ptr<ghoul::opengl::Texture> volumeTexture,
+    std::shared_ptr<TransferFunction> transferFunction,
+    std::shared_ptr<VolumeClipPlanes> clipPlanes)
+    : _volumeTexture(volumeTexture)
     , _transferFunction(transferFunction)
+    , _clipPlanes(clipPlanes)
     , _boundingBox(glm::vec3(1.0))
+    , _opacity(20.0)
+    , _rNormalization(0.0)
+    , _rUpperBound(1.0)
+    , _valueRemapping(0.0, 1.0)
 {}
-    
-KameleonVolumeRaycaster::~KameleonVolumeRaycaster() {}
 
-void KameleonVolumeRaycaster::initialize() {
+BasicVolumeRaycaster::~BasicVolumeRaycaster() {}
+
+void BasicVolumeRaycaster::initialize() {
     _boundingBox.initialize();
 }
     
-void KameleonVolumeRaycaster::deinitialize() {
-}
+void BasicVolumeRaycaster::deinitialize() {}
     
-void KameleonVolumeRaycaster::renderEntryPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) {
-    glm::dmat4 modelTransform =
-        glm::translate(glm::dmat4(1.0), data.modelTransform.translation) * // Translation
-        glm::dmat4(data.modelTransform.rotation) *  // Spice rotation
-        glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
-    glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
-
-    program.setUniform("modelViewTransform", glm::mat4(modelViewTransform));
+void BasicVolumeRaycaster::renderEntryPoints(
+    const RenderData& data,
+    ghoul::opengl::ProgramObject& program)
+{
+    program.setUniform("modelViewTransform", glm::mat4(modelViewTransform(data)));
     program.setUniform("projectionTransform", data.camera.projectionMatrix());
     
     // Cull back face
@@ -79,15 +79,23 @@ void KameleonVolumeRaycaster::renderEntryPoints(const RenderData& data, ghoul::o
     // Render bounding geometry
     _boundingBox.render();
 }
-    
-void KameleonVolumeRaycaster::renderExitPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) {
+
+glm::dmat4 BasicVolumeRaycaster::modelViewTransform(const RenderData& data) {
     glm::dmat4 modelTransform =
         glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
         glm::dmat4(data.modelTransform.rotation) *
-        glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
-    glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
+        glm::scale(glm::dmat4(1.0), glm::dvec3(data.modelTransform.scale)) *
+        glm::dmat4(_modelTransform);
 
-    program.setUniform("modelViewTransform", glm::mat4(modelViewTransform));
+    return data.camera.combinedViewMatrix() * modelTransform;
+}
+
+    
+void BasicVolumeRaycaster::renderExitPoints(
+    const RenderData& data,
+    ghoul::opengl::ProgramObject& program)
+{
+    program.setUniform("modelViewTransform", glm::mat4(modelViewTransform(data)));
     program.setUniform("projectionTransform", data.camera.projectionMatrix());
 
     // Cull front face
@@ -101,7 +109,14 @@ void KameleonVolumeRaycaster::renderExitPoints(const RenderData& data, ghoul::op
     glCullFace(GL_BACK);
 }
     
-void KameleonVolumeRaycaster::preRaycast(const RaycastData& data, ghoul::opengl::ProgramObject& program) {
+void BasicVolumeRaycaster::preRaycast(
+    const RaycastData& data,
+    ghoul::opengl::ProgramObject& program)
+{
+    if (!_volumeTexture || !_transferFunction) {
+        return;
+    }
+
     std::string stepSizeUniformName = "maxStepSize" + std::to_string(data.id);
     program.setUniform(stepSizeUniformName, _stepSize);
 
@@ -126,56 +141,110 @@ void KameleonVolumeRaycaster::preRaycast(const RaycastData& data, ghoul::opengl:
     program.setUniform("nClips_" + id, nClips);
     program.setUniform("clipNormals_" + id, clipNormals.data(), nClips);
     program.setUniform("clipOffsets_" + id, clipOffsets.data(), nClips);
+    program.setUniform("opacity_" + id, _opacity);
+    program.setUniform("rNormalization_" + id, _rNormalization);
+    program.setUniform("rUpperBound_" + id, _rUpperBound);
+    program.setUniform("valueRemapping_" + id, _valueRemapping);
 }
     
-void KameleonVolumeRaycaster::postRaycast(const RaycastData&,
-                                          ghoul::opengl::ProgramObject&)
+void BasicVolumeRaycaster::postRaycast(const RaycastData&, ghoul::opengl::ProgramObject&)
 {
     // For example: release texture units
     _textureUnit = nullptr;
     _tfUnit = nullptr;
 }
 
-bool KameleonVolumeRaycaster::cameraIsInside(const RenderData & data, glm::vec3 & localPosition)
-{
-    glm::dmat4 modelTransform =
-        glm::translate(glm::dmat4(1.0), data.modelTransform.translation) *
-        glm::dmat4(data.modelTransform.rotation) *
-        glm::dmat4(glm::scale(glm::dmat4(_modelTransform), glm::dvec3(data.modelTransform.scale)));
-    glm::dmat4 modelViewTransform = data.camera.combinedViewMatrix() * modelTransform;
 
-    glm::vec4 modelPos = glm::inverse(modelViewTransform) * glm::vec4(0.0, 0.0, 0.0, 1.0);
+
+bool BasicVolumeRaycaster::cameraIsInside(
+    const RenderData & data,
+    glm::vec3 & localPosition)
+{
+    glm::vec4 modelPos =
+        glm::inverse(modelViewTransform(data)) * glm::vec4(0.0, 0.0, 0.0, 1.0);
 
     localPosition = (glm::vec3(modelPos) + glm::vec3(0.5));
-    return (localPosition.x > 0 && localPosition.y > 0 && localPosition.z > 0 && localPosition.x < 1 && localPosition.y < 1 && localPosition.z < 1);
+
+    return (localPosition.x > 0 && localPosition.x < 1 &&
+            localPosition.y > 0 && localPosition.y < 1 &&
+            localPosition.z > 0 && localPosition.z < 1);
 }
     
-std::string KameleonVolumeRaycaster::getBoundsVsPath() const {
+std::string BasicVolumeRaycaster::getBoundsVsPath() const {
     return GlslBoundsVsPath;
 }
     
-std::string KameleonVolumeRaycaster::getBoundsFsPath() const {
+std::string BasicVolumeRaycaster::getBoundsFsPath() const {
     return GlslBoundsFsPath;
 }
 
-std::string KameleonVolumeRaycaster::getRaycastPath() const {
+std::string BasicVolumeRaycaster::getRaycastPath() const {
     return GlslRaycastPath;
 }
 
-std::string KameleonVolumeRaycaster::getHelperPath() const {
+std::string BasicVolumeRaycaster::getHelperPath() const {
     return GlslHelperPath;
 }
-    
-void KameleonVolumeRaycaster::setStepSize(float stepSize) {
+
+void BasicVolumeRaycaster::setTransferFunction(
+    std::shared_ptr<TransferFunction> transferFunction)
+{
+    _transferFunction = transferFunction;
+}
+
+void BasicVolumeRaycaster::setVolumeTexture(
+    std::shared_ptr<ghoul::opengl::Texture> volumeTexture)
+{
+    _volumeTexture = volumeTexture;
+}
+
+std::shared_ptr<ghoul::opengl::Texture> BasicVolumeRaycaster::volumeTexture() const {
+    return _volumeTexture;
+}
+
+void BasicVolumeRaycaster::setStepSize(float stepSize) {
     _stepSize = stepSize;
 }
 
-void KameleonVolumeRaycaster::setGridType(VolumeGridType gridType) {
+void BasicVolumeRaycaster::setOpacity(float opacity) {
+    _opacity = opacity;
+}
+
+float BasicVolumeRaycaster::opacity() const {
+    return _opacity;
+}
+
+void BasicVolumeRaycaster::setRNormalization(float rNormalization) {
+    _rNormalization = rNormalization;
+}
+
+float BasicVolumeRaycaster::rNormalization() const {
+    return _rNormalization;
+}
+
+void BasicVolumeRaycaster::setRUpperBound(float rUpperBound) {
+   _rUpperBound = rUpperBound;
+}
+
+float BasicVolumeRaycaster::rUpperBound() const {
+    return _rUpperBound;
+}
+
+void BasicVolumeRaycaster::setValueRemapping(float mapZeroTo, float mapOneTo) {
+    _valueRemapping = glm::vec2(mapZeroTo, mapOneTo);
+}
+
+VolumeGridType BasicVolumeRaycaster::gridType() const {
+    return _gridType;
+}
+
+void BasicVolumeRaycaster::setGridType(VolumeGridType gridType) {
     _gridType = gridType;
 }
 
-void KameleonVolumeRaycaster::setModelTransform(const glm::mat4 & transform) {
+void BasicVolumeRaycaster::setModelTransform(const glm::mat4 & transform) {
     _modelTransform = transform;
 }
-    
-}
+
+} // namespace volume
+} // namespace openspace
diff --git a/modules/kameleonvolume/rendering/kameleonvolumeraycaster.h b/modules/volume/rendering/basicvolumeraycaster.h
similarity index 79%
rename from modules/kameleonvolume/rendering/kameleonvolumeraycaster.h
rename to modules/volume/rendering/basicvolumeraycaster.h
index 8c8f026a3f..9182ffc8b8 100644
--- a/modules/kameleonvolume/rendering/kameleonvolumeraycaster.h
+++ b/modules/volume/rendering/basicvolumeraycaster.h
@@ -22,8 +22,8 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#ifndef __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONVOLUMERAYCASTER___H__
-#define __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONVOLUMERAYCASTER___H__
+#ifndef __OPENSPACE_MODULE_VOLUME___BASICVOLUMERAYCASTER___H__
+#define __OPENSPACE_MODULE_VOLUME___BASICVOLUMERAYCASTER___H__
 
 #include <string>
 #include <vector>
@@ -50,16 +50,18 @@ namespace openspace {
 struct RenderData;
 struct RaycastData;
 
-class KameleonVolumeRaycaster : public VolumeRaycaster {
+namespace volume {
+
+class BasicVolumeRaycaster : public VolumeRaycaster {
 public:
-    KameleonVolumeRaycaster(
+    BasicVolumeRaycaster(
         std::shared_ptr<ghoul::opengl::Texture> texture,
         std::shared_ptr<TransferFunction> transferFunction, 
         std::shared_ptr<VolumeClipPlanes> clipPlanes);
-
-    virtual ~KameleonVolumeRaycaster();
+    virtual ~BasicVolumeRaycaster();
     void initialize();
     void deinitialize();
+
     void renderEntryPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) override;
     void renderExitPoints(const RenderData& data, ghoul::opengl::ProgramObject& program) override;
     void preRaycast(const RaycastData& data, ghoul::opengl::ProgramObject& program) override;
@@ -71,23 +73,42 @@ public:
     std::string getRaycastPath() const override;
     std::string getHelperPath() const override;
 
+    void setVolumeTexture(std::shared_ptr<ghoul::opengl::Texture> texture);
+    std::shared_ptr<ghoul::opengl::Texture> volumeTexture() const;
+    void setTransferFunction(std::shared_ptr<TransferFunction> transferFunction);
     void setStepSize(float stepSize);
+    float opacity() const;
+    void setOpacity(float opacity);
+    float rNormalization() const;
+    void setRNormalization(float rNormalization);
+    float rUpperBound() const;
+    void setRUpperBound(float rNormalization);
+    void setValueRemapping(float mapZeroTo, float mapOneTo);
+    VolumeGridType gridType() const;
     void setGridType(VolumeGridType gridType);
     void setModelTransform(const glm::mat4& transform);
-    
+
 private:
+    glm::dmat4 modelViewTransform(const RenderData& data);
+
     std::shared_ptr<VolumeClipPlanes> _clipPlanes;
     std::shared_ptr<ghoul::opengl::Texture> _volumeTexture;
     std::shared_ptr<TransferFunction> _transferFunction;
     BoxGeometry _boundingBox;
     VolumeGridType _gridType;
     glm::mat4 _modelTransform;
+    float _opacity;
+    float _rNormalization;
+    float _rUpperBound;
+    glm::vec2 _valueRemapping;
 
     std::unique_ptr<ghoul::opengl::TextureUnit> _tfUnit;
     std::unique_ptr<ghoul::opengl::TextureUnit> _textureUnit;
     float _stepSize;
 };
 
+} // namespace volume
 } // namespace openspace
 
-#endif // __OPENSPACE_MODULE_KAMELEONVOLUME___KAMELEONVOLUMERAYCASTER___H__ 
+
+#endif // __OPENSPACE_MODULE_VOLUME___BASICVOLUMERAYCASTER___H__ 
diff --git a/modules/volume/rendering/renderabletimevaryingvolume.cpp b/modules/volume/rendering/renderabletimevaryingvolume.cpp
new file mode 100644
index 0000000000..4db921c776
--- /dev/null
+++ b/modules/volume/rendering/renderabletimevaryingvolume.cpp
@@ -0,0 +1,473 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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 <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>
+#include <openspace/rendering/raycastermanager.h>
+#include <openspace/documentation/documentation.h>
+#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 <glm/gtc/matrix_transform.hpp>
+
+namespace {
+    const char* _loggerCat = "RenderableTimeVaryingVolume";
+}
+
+namespace {
+    const char* KeyDimensions = "Dimensions";
+    const char* KeyStepSize = "StepSize";
+    const char* KeyTransferFunction = "TransferFunction";
+    const char* KeySourceDirectory = "SourceDirectory";
+    const char* KeyLowerDomainBound = "LowerDomainBound";
+    const char* KeyUpperDomainBound = "UpperDomainBound";
+    const char* KeyLowerValueBound = "LowerValueBound";
+    const char* KeyUpperValueBound = "UpperValueBound";
+    const char* KeyClipPlanes = "ClipPlanes";
+    const char* KeySecondsBefore = "SecondsBefore";
+    const char* KeySecondsAfter = "SecondsAfter";
+    const char* KeyGridType = "GridType";
+    const char* KeyMinValue = "MinValue";
+    const char* KeyMaxValue = "MaxValue";
+    const char* KeyTime = "Time";
+    const float SecondsInOneDay = 60 * 60 * 24;
+}
+
+namespace openspace {
+namespace volume {
+
+RenderableTimeVaryingVolume::RenderableTimeVaryingVolume(const ghoul::Dictionary& dictionary)
+    : Renderable(dictionary)
+    , _clipPlanes(nullptr)
+    , _stepSize({ "stepSize", "Step Size", "" }, 0.02, 0.01, 1)
+    , _gridType({ "gridType", "Grid Type", "" }, properties::OptionProperty::DisplayType::Dropdown)
+    , _secondsBefore({ "secondsBefore", "Seconds before", "" }, 0.0, 0.01, SecondsInOneDay)
+    , _secondsAfter({ "secondsAfter", "Seconds after", "" }, 0.0, 0.01, SecondsInOneDay)
+    , _sourceDirectory({ "sourceDirectory", "Source Directory", "" })
+    , _transferFunctionPath({"transferFunctionPath", "Transfer Function Path", "" })
+    , _triggerTimeJump({"triggerTimeJump", "Jump", "" })
+    , _jumpToTimestep({"jumpToTimestep", "Jump to timestep", "" }, 0, 0, 256)
+    , _currentTimestep({"currentTimestep", "Current timestep", "" }, 0, 0, 256)
+    , _opacity({"opacity", "Opacity", "" }, 10.0f, 0.0f, 50.0f)
+    , _rNormalization({"rNormalization", "Radius normalization", "" }, 0.0f, 0.0f, 2.0f)
+    , _rUpperBound({"rUpperBound", "Radius upper bound", "" }, 1.0f, 0.0f, 2.0f)
+    , _lowerValueBound({"lowerValueBound", "Lower value bound", "" }, 0.0f, 0.0f, 1000000.0f)
+    , _upperValueBound({"upperValueBound", "Upper value bound", "" }, 0.0f, 0.0f, 1000000.0f)
+    , _raycaster(nullptr)
+    , _transferFunction(nullptr)
+{
+    documentation::testSpecificationAndThrow(
+        Documentation(),
+        dictionary,
+        "RenderableTimeVaryingVolume"
+    );
+
+    _sourceDirectory = absPath(dictionary.value<std::string>(KeySourceDirectory));
+    _transferFunctionPath = absPath(dictionary.value<std::string>(KeyTransferFunction));
+    _lowerValueBound = dictionary.value<float>(KeyLowerValueBound);
+    _upperValueBound = dictionary.value<float>(KeyUpperValueBound);
+    _transferFunction = std::make_shared<TransferFunction>(_transferFunctionPath);
+
+    _gridType.addOption(static_cast<int>(volume::VolumeGridType::Cartesian), "Cartesian grid");
+    _gridType.addOption(static_cast<int>(volume::VolumeGridType::Spherical), "Spherical grid");
+    _gridType.setValue(static_cast<int>(volume::VolumeGridType::Cartesian));
+
+
+    if (dictionary.hasValue<float>(KeySecondsBefore)) {
+        _secondsBefore = dictionary.value<float>(KeySecondsBefore);
+    }
+    _secondsAfter = dictionary.value<float>(KeySecondsAfter);
+
+    ghoul::Dictionary clipPlanesDictionary;
+    dictionary.getValue(KeyClipPlanes, clipPlanesDictionary);
+    _clipPlanes = std::make_shared<volume::VolumeClipPlanes>(clipPlanesDictionary);
+    _clipPlanes->setName("clipPlanes");
+
+    if (dictionary.hasValue<std::string>(KeyGridType)) {
+        VolumeGridType gridType = volume::parseGridType(dictionary.value<std::string>(KeyGridType));
+        _gridType = (gridType == VolumeGridType::Spherical) ? 1 : 0;
+    }
+}
+    
+RenderableTimeVaryingVolume::~RenderableTimeVaryingVolume() {}
+
+void RenderableTimeVaryingVolume::initialize() {
+
+    using RawPath = ghoul::filesystem::Directory::RawPath;
+    ghoul::filesystem::Directory sequenceDir(_sourceDirectory, RawPath::Yes);
+
+    if (!FileSys.directoryExists(sequenceDir)) {
+        LERROR("Could not load sequence directory '" << sequenceDir.path() << "'");
+        return;
+    }
+
+    using Recursive = ghoul::filesystem::Directory::Recursive;
+    using Sort = ghoul::filesystem::Directory::Sort;
+
+    std::vector<std::string> sequencePaths = sequenceDir.read(Recursive::Yes, Sort::No);
+    for (auto path : sequencePaths) {
+        ghoul::filesystem::File currentFile(path);
+        std::string extension = currentFile.fileExtension();
+        if (extension == "dictionary") {
+            loadTimestepMetadata(path);
+        }
+    }
+
+
+    // TODO: defer loading of data to later. (separate thread or at least not when loading)
+    for (auto& p : _volumeTimesteps) {
+        Timestep& t = p.second;
+        std::string path = FileSys.pathByAppendingComponent(_sourceDirectory, t.baseName) + ".rawvolume";
+        RawVolumeReader<float> reader(path, t.dimensions);
+        t.rawVolume = reader.read();
+
+        float min = t.minValue;
+        float diff = t.maxValue - t.minValue;
+
+        float *data = t.rawVolume->data();
+        for (size_t i = 0; i < t.rawVolume->nCells(); ++i) {
+            data[i] = glm::clamp((data[i] - min) / diff, 0.0f, 1.0f);
+        }
+        // TODO: handle normalization properly for different timesteps + transfer function
+
+        t.texture = std::make_shared<ghoul::opengl::Texture>(
+            t.dimensions,
+            ghoul::opengl::Texture::Format::Red,
+            GL_RED,
+            GL_FLOAT,
+            ghoul::opengl::Texture::FilterMode::Linear,
+            ghoul::opengl::Texture::WrappingMode::Clamp
+        );
+
+        t.texture->setPixelData(reinterpret_cast<void*>(data), ghoul::opengl::Texture::TakeOwnership::No);
+        t.texture->uploadTexture();
+    }
+
+    _clipPlanes->initialize();
+    _transferFunction->update();
+    _raycaster = std::make_unique<volume::BasicVolumeRaycaster>(nullptr, _transferFunction, _clipPlanes);
+    _raycaster->initialize();
+    OsEng.renderEngine().raycasterManager().attachRaycaster(*_raycaster.get());
+    auto onChange = [&](bool enabled) {
+        if (enabled) {
+            OsEng.renderEngine().raycasterManager().attachRaycaster(*_raycaster.get());
+        } else {
+            OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
+        }
+    };
+    onEnabledChange(onChange);
+
+    _triggerTimeJump.onChange([this] () {
+        jumpToTimestep(_jumpToTimestep);
+    });
+
+    _jumpToTimestep.onChange([this] () {
+        jumpToTimestep(_jumpToTimestep);
+    });
+
+    const int lastTimestep = (_volumeTimesteps.size() > 0) ? (_volumeTimesteps.size() - 1) : 0;
+    _currentTimestep.setMaxValue(lastTimestep);
+    _jumpToTimestep.setMaxValue(lastTimestep);
+
+    addProperty(_stepSize);
+    addProperty(_transferFunctionPath);
+    addProperty(_sourceDirectory);
+    addPropertySubOwner(_clipPlanes.get());
+    addProperty(_triggerTimeJump);
+    addProperty(_jumpToTimestep);
+    addProperty(_currentTimestep);
+    addProperty(_opacity);
+    addProperty(_rNormalization);
+    addProperty(_rUpperBound);
+    addProperty(_lowerValueBound);
+    addProperty(_upperValueBound);
+
+    _raycaster->setGridType((_gridType.value() == 1) ? VolumeGridType::Spherical : VolumeGridType::Cartesian);
+    _gridType.onChange([this] {
+        _raycaster->setGridType((_gridType.value() == 1) ? VolumeGridType::Spherical : VolumeGridType::Cartesian);
+    });
+}
+
+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;
+    }
+
+    Timestep t;
+    t.baseName = ghoul::filesystem::File(path).baseName();
+    t.dimensions = dictionary.value<glm::vec3>(KeyDimensions);
+    t.lowerDomainBound = dictionary.value<glm::vec3>(KeyLowerDomainBound);
+    t.upperDomainBound = dictionary.value<glm::vec3>(KeyUpperDomainBound);
+    t.minValue = dictionary.value<float>(KeyMinValue);
+    t.maxValue = dictionary.value<float>(KeyMaxValue);
+
+    std::string timeString = dictionary.value<std::string>(KeyTime);
+    t.time = Time::convertTime(timeString);
+    t.inRam = false;
+    t.onGpu = false;
+    
+    _volumeTimesteps[t.time] = std::move(t);
+}
+
+RenderableTimeVaryingVolume::Timestep* RenderableTimeVaryingVolume::currentTimestep() {
+    if (_volumeTimesteps.size() == 0) {
+        return nullptr;
+    }
+    double currentTime = OsEng.timeManager().time().j2000Seconds();
+
+    // Get the first item with time > currentTime
+    auto currentTimestepIt = _volumeTimesteps.upper_bound(currentTime);
+    if (currentTimestepIt == _volumeTimesteps.end()) {
+        // No such timestep was found: show last timestep if it is within the time margin.
+        RenderableTimeVaryingVolume::Timestep* lastTimestep = &(_volumeTimesteps.rbegin()->second);
+        double threshold = lastTimestep->time + static_cast<double>(_secondsAfter);
+        return currentTime < threshold ? lastTimestep : nullptr;
+    }
+
+    if (currentTimestepIt == _volumeTimesteps.begin()) {
+        // No such timestep was found: show first timestep if it is within the time margin.
+        RenderableTimeVaryingVolume::Timestep* firstTimestep = &(_volumeTimesteps.begin()->second);
+        double threshold = firstTimestep->time - static_cast<double>(_secondsBefore);
+        return currentTime >= threshold ? firstTimestep : nullptr;
+    }
+
+    // Get the last item with time <= currentTime
+    currentTimestepIt--;
+    return &(currentTimestepIt->second);
+}
+
+int RenderableTimeVaryingVolume::timestepIndex(const RenderableTimeVaryingVolume::Timestep* t) const {
+    if (!t) {
+        return -1;
+    }
+    int index = 0;
+    for (auto& it : _volumeTimesteps) {
+        if (&(it.second) == t) {
+            return index;
+        }
+        ++index;
+    }
+    return -1;
+}
+
+RenderableTimeVaryingVolume::Timestep* RenderableTimeVaryingVolume::timestepFromIndex(int target) {
+    if (target < 0) target = 0;
+    int index = 0;
+    for (auto& it : _volumeTimesteps) {
+        if (index == target) {
+            return &(it.second);
+        }
+        ++index;
+    }
+    return nullptr;
+}
+
+void RenderableTimeVaryingVolume::jumpToTimestep(int target) {
+    Timestep* t = timestepFromIndex(target);
+    if (!t) {
+        return;
+    }
+    OsEng.timeManager().setTimeNextFrame(t->time);
+}
+
+void RenderableTimeVaryingVolume::update(const UpdateData& data) {
+    if (_raycaster) {
+        Timestep* t = currentTimestep();
+        _currentTimestep = timestepIndex(t);
+        if (t && t->texture) {
+            if (_raycaster->gridType() == volume::VolumeGridType::Cartesian) {
+                glm::dvec3 scale = t->upperDomainBound - t->lowerDomainBound;
+                glm::dvec3 translation = (t->lowerDomainBound + t->upperDomainBound) * 0.5f;
+
+                glm::dmat4 modelTransform = glm::translate(glm::dmat4(1.0), translation);
+                glm::dmat4 scaleMatrix = glm::scale(glm::dmat4(1.0), scale);
+                modelTransform = modelTransform * scaleMatrix;
+                _raycaster->setModelTransform(glm::mat4(modelTransform));
+            } else {
+                _raycaster->setModelTransform(
+                    glm::scale(
+                        glm::dmat4(1.0),
+                        glm::dvec3(t->upperDomainBound[0])
+                    )
+                );
+            }
+            _raycaster->setVolumeTexture(t->texture);
+
+            // Remap volume value to that TF value 0 is sampled for lowerValueBound, and 1 is sampled for upperLowerBound.
+            // This means that volume values = 0 need to be remapped to how localMin relates to the global range.
+            float zeroMap = (t->minValue - _lowerValueBound) / (_upperValueBound - _lowerValueBound);
+
+            // Volume values = 1 are mapped to how localMax relates to the global range.
+            float oneMap = (t->maxValue - _lowerValueBound) / (_upperValueBound - _lowerValueBound);
+            _raycaster->setValueRemapping(zeroMap, oneMap);
+        } else {
+            _raycaster->setVolumeTexture(nullptr);
+        }
+        _raycaster->setStepSize(_stepSize);
+        _raycaster->setOpacity(_opacity);
+        _raycaster->setRNormalization(_rNormalization);
+        _raycaster->setRUpperBound(_rUpperBound);
+    }
+}
+
+void RenderableTimeVaryingVolume::render(const RenderData& data, RendererTasks& tasks) {
+    if (_raycaster && _raycaster->volumeTexture()) {
+        tasks.raycasterTasks.push_back({ _raycaster.get(), data });
+    }
+}
+
+ 
+
+bool RenderableTimeVaryingVolume::isReady() const {
+    return true;
+}
+
+
+void RenderableTimeVaryingVolume::deinitialize() {
+    if (_raycaster) {
+        OsEng.renderEngine().raycasterManager().detachRaycaster(*_raycaster.get());
+        _raycaster = nullptr;
+    }
+}
+
+documentation::Documentation RenderableTimeVaryingVolume::Documentation() {
+    using namespace documentation;
+    return {
+        "RenderableTimevaryingVolume",
+        "volume_renderable_timevaryingvolume",
+        {
+            {
+                KeySourceDirectory,
+                new StringVerifier,
+                Optional::No,
+                "Specifies the path to load timesteps from"
+            },
+            {
+                KeyTransferFunction,
+                new StringVerifier,
+                Optional::No,
+                "Specifies the transfer function file path",
+            },
+            {
+                KeyLowerValueBound,
+                new DoubleVerifier,
+                Optional::No,
+                "Specifies the lower value bound."
+                "This number will be mapped to 0 before uploadin to the GPU.",
+            },
+            {
+                KeyUpperValueBound,
+                new DoubleVerifier,
+                Optional::No,
+                "Specifies the lower value bound."
+                "This number will be mapped to 0 before uploadin to the GPU."
+            },
+            {
+                KeyGridType,
+                new StringInListVerifier({"Cartesian", "Spherical"}),
+                Optional::Yes,
+                "Specifies the grid type"
+            },
+            {
+                KeySecondsBefore,
+                new DoubleVerifier,
+                Optional::Yes,
+                "Specifies the number of seconds to show the the first timestep before its actual time."
+                "The default value is 0.",
+            },
+            {
+                KeySecondsAfter,
+                new DoubleVerifier,
+                Optional::No,
+                "Specifies the number of seconds to show the the last timestep after its actual time",
+            },
+        }
+    };
+}
+
+
+documentation::Documentation RenderableTimeVaryingVolume::TimestepDocumentation() {
+    using namespace documentation;
+    return {
+        "TimevaryingVolumeTimestep",
+        "volume_timevaryingvolumetimestep",
+        {
+            {
+                KeyLowerDomainBound,
+                new Vector3Verifier<float>,
+                Optional::No,
+                "Specifies the lower domain bounds in the model coordinate system",
+            },
+            {
+                KeyUpperDomainBound,
+                new Vector3Verifier<float>,
+                Optional::No,
+                "Specifies the upper domain bounds in the model coordinate system",
+            },
+            {
+                KeyDimensions,
+                new Vector3Verifier<float>,
+                Optional::No,
+                "Specifies the number of grid cells in each dimension",
+            },
+            {
+                KeyTime,
+                new StringVerifier,
+                Optional::No,
+                "Specifies the time on the format YYYY-MM-DDTHH:MM:SS.000Z",
+            },
+            {
+                KeyMinValue,
+                new DoubleVerifier,
+                Optional::No,
+                "Specifies the minimum value stored in the volume"
+            },
+            {
+                KeyMaxValue,
+                new DoubleVerifier,
+                Optional::No,
+                "Specifies the maximum value stored in the volume"
+            }
+        }
+    };
+}
+
+} // namespace volume
+} // namespace openspace
diff --git a/modules/volume/rendering/renderabletimevaryingvolume.h b/modules/volume/rendering/renderabletimevaryingvolume.h
new file mode 100644
index 0000000000..f3fe18137f
--- /dev/null
+++ b/modules/volume/rendering/renderabletimevaryingvolume.h
@@ -0,0 +1,109 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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_MODULE_VOLUME___RENDERABLEKAMELEONVOLUME___H__
+#define __OPENSPACE_MODULE_VOLUME___RENDERABLEKAMELEONVOLUME___H__
+
+#include <openspace/rendering/renderable.h>
+
+#include <modules/volume/rawvolume.h>
+#include <modules/volume/rendering/basicvolumeraycaster.h>
+#include <modules/volume/rendering/volumeclipplanes.h>
+
+#include <openspace/properties/vectorproperty.h>
+#include <openspace/properties/optionproperty.h>
+#include <openspace/properties/stringproperty.h>
+#include <openspace/rendering/transferfunction.h>
+#include <openspace/util/boxgeometry.h>
+
+namespace openspace {
+
+struct RenderData;
+
+namespace volume {
+
+class RenderableTimeVaryingVolume : public Renderable {
+public:
+    RenderableTimeVaryingVolume(const ghoul::Dictionary& dictionary);
+    ~RenderableTimeVaryingVolume();
+    
+    void initialize() override;
+    void deinitialize() override;
+    bool isReady() const override;
+    void render(const RenderData& data, RendererTasks& tasks) override;
+    void update(const UpdateData& data) override;
+
+    static documentation::Documentation Documentation();
+    static documentation::Documentation TimestepDocumentation();
+
+private:
+    struct Timestep {
+        std::string baseName;
+        double time;
+        float minValue;
+        float maxValue;
+        glm::uvec3 dimensions;
+        glm::vec3 lowerDomainBound;
+        glm::vec3 upperDomainBound;
+        bool inRam;
+        bool onGpu;
+        std::unique_ptr<RawVolume<float>> rawVolume;
+        std::shared_ptr<ghoul::opengl::Texture> texture;
+    };
+
+    Timestep* currentTimestep();
+    int timestepIndex(const Timestep* t) const;
+    Timestep* timestepFromIndex(int index);
+    void jumpToTimestep(int i);
+
+    void loadTimestepMetadata(const std::string& path);
+
+    properties::OptionProperty _gridType;
+    std::shared_ptr<VolumeClipPlanes> _clipPlanes;
+
+    properties::FloatProperty _stepSize;
+    properties::FloatProperty _opacity;
+    properties::FloatProperty _rNormalization;
+    properties::FloatProperty _rUpperBound;
+    properties::FloatProperty _secondsBefore;
+    properties::FloatProperty _secondsAfter;
+    properties::StringProperty _sourceDirectory;
+    properties::StringProperty _transferFunctionPath;
+    properties::FloatProperty _lowerValueBound;
+    properties::FloatProperty _upperValueBound;
+
+    properties::TriggerProperty _triggerTimeJump;
+    properties::IntProperty _jumpToTimestep;
+    properties::IntProperty _currentTimestep;
+
+    std::map<double, Timestep> _volumeTimesteps;
+    std::unique_ptr<BasicVolumeRaycaster> _raycaster;
+
+    std::shared_ptr<TransferFunction> _transferFunction;
+};
+
+} // namespace volume
+} // namespace openspace
+
+#endif // __OPENSPACE_MODULE_KAMELEONVOLUME___RENDERABLEKAMELEONVOLUME___H__
diff --git a/modules/volume/rendering/volumeclipplane.cpp b/modules/volume/rendering/volumeclipplane.cpp
index 3aafeae2dd..584c6efbd6 100644
--- a/modules/volume/rendering/volumeclipplane.cpp
+++ b/modules/volume/rendering/volumeclipplane.cpp
@@ -1,4 +1,3 @@
-
 /*****************************************************************************************
  *                                                                                       *
  * OpenSpace                                                                             *
@@ -28,6 +27,7 @@
 
 
 namespace openspace {
+namespace volume {
 
 VolumeClipPlane::VolumeClipPlane(const ghoul::Dictionary& dictionary)
     : properties::PropertyOwner({ "" }) // @TODO Missing name
@@ -66,4 +66,5 @@ glm::vec2 VolumeClipPlane::offsets() {
     return _offsets;
 }
 
+} // namespace volume
 } // namespace openspace
diff --git a/modules/volume/rendering/volumeclipplane.h b/modules/volume/rendering/volumeclipplane.h
index 8996edf5b9..131d5f678a 100644
--- a/modules/volume/rendering/volumeclipplane.h
+++ b/modules/volume/rendering/volumeclipplane.h
@@ -31,6 +31,7 @@
 namespace ghoul { class Dictionary; }
 
 namespace openspace {
+namespace volume {
 
 class VolumeClipPlane : public properties::PropertyOwner {
 public:
@@ -45,6 +46,7 @@ private:
 
 };
 
-}  // namespace openspace
+} // namespace volume
+} // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___VOLUMECLIPPLANE___H__
diff --git a/modules/volume/rendering/volumeclipplanes.cpp b/modules/volume/rendering/volumeclipplanes.cpp
index 38c034a6ca..51042714f6 100644
--- a/modules/volume/rendering/volumeclipplanes.cpp
+++ b/modules/volume/rendering/volumeclipplanes.cpp
@@ -28,6 +28,7 @@
 
 
 namespace openspace {
+namespace volume {
 
 VolumeClipPlanes::VolumeClipPlanes(const ghoul::Dictionary& dictionary)
     : properties::PropertyOwner({ "" }) // @TODO Missing name
@@ -70,4 +71,5 @@ std::vector<glm::vec2> VolumeClipPlanes::offsets() {
     return offsets;
 }
 
+} // namespace volume
 } // namespace openspace
diff --git a/modules/volume/rendering/volumeclipplanes.h b/modules/volume/rendering/volumeclipplanes.h
index ffffd227ea..bb8d2eb6e5 100644
--- a/modules/volume/rendering/volumeclipplanes.h
+++ b/modules/volume/rendering/volumeclipplanes.h
@@ -36,6 +36,7 @@
 namespace ghoul { class Dictionary; }
 
 namespace openspace {
+namespace volume {
 
 class VolumeClipPlanes : public properties::PropertyOwner {
 public:
@@ -51,6 +52,7 @@ private:
     std::vector<std::shared_ptr<VolumeClipPlane>> _clipPlanes;
 };
 
-}  // namespace openspace
+} // namepsace volume
+} // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___VOLUMECLIPPLANES___H__
diff --git a/modules/kameleonvolume/shaders/boundsfs.glsl b/modules/volume/shaders/boundsfs.glsl
similarity index 100%
rename from modules/kameleonvolume/shaders/boundsfs.glsl
rename to modules/volume/shaders/boundsfs.glsl
diff --git a/modules/kameleonvolume/shaders/boundsvs.glsl b/modules/volume/shaders/boundsvs.glsl
similarity index 100%
rename from modules/kameleonvolume/shaders/boundsvs.glsl
rename to modules/volume/shaders/boundsvs.glsl
diff --git a/modules/kameleonvolume/shaders/helper.glsl b/modules/volume/shaders/helper.glsl
similarity index 93%
rename from modules/kameleonvolume/shaders/helper.glsl
rename to modules/volume/shaders/helper.glsl
index 30c3a73449..70e8106af0 100644
--- a/modules/kameleonvolume/shaders/helper.glsl
+++ b/modules/volume/shaders/helper.glsl
@@ -22,14 +22,15 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#define KAMELEON_PI      3.14159265358979323846  /* pi */
-#define KAMELEON_SQRT1_3 0.57735026919           /* 1/sqrt(3) */
+#define VOLUME_PI      3.14159265358979323846  /* pi */
+#define VOLUME_SQRT1_3 0.57735026919           /* 1/sqrt(3) */
 
-vec3 kameleon_cartesianToSpherical(vec3 zeroToOneCoords) {
+vec3 volume_cartesianToSpherical(vec3 zeroToOneCoords) {
     // Put cartesian in [-1..1] range first
     vec3 cartesian = vec3(-1.0,-1.0,-1.0) + zeroToOneCoords * 2.0f;
 
     float r = length(cartesian);
+
     float theta = 0.0;
     float phi = 0.0;
 
diff --git a/modules/kameleonvolume/shaders/raycast.glsl b/modules/volume/shaders/raycast.glsl
similarity index 78%
rename from modules/kameleonvolume/shaders/raycast.glsl
rename to modules/volume/shaders/raycast.glsl
index 54a0bf77d1..66d8b68e17 100644
--- a/modules/kameleonvolume/shaders/raycast.glsl
+++ b/modules/volume/shaders/raycast.glsl
@@ -31,6 +31,20 @@ uniform int nClips_#{id};
 uniform vec3 clipNormals_#{id}[8];
 uniform vec2 clipOffsets_#{id}[8];
 
+uniform float opacity_#{id} = 10.0;
+
+// Value remapping:
+// Linearly remap volume values of zero to x and one to y
+// before using the values to sample the transfer function.
+uniform vec2 valueRemapping_#{id} = vec2(0.0, 1.0);
+
+// Normalization factor x for radius r [0, 1].
+// value *= 1/(r^x)
+// only working for volumes given in spherical coordianates.
+// Applied after any linear value remapping.
+uniform float rNormalization_#{id} = 0.0;
+
+uniform float rUpperBound_#{id} = 1.0;
 
 void sample#{id}(vec3 samplePos, vec3 dir, inout vec3 accumulatedColor,
                  inout vec3 accumulatedAlpha, inout float stepSize)
@@ -38,7 +52,7 @@ void sample#{id}(vec3 samplePos, vec3 dir, inout vec3 accumulatedColor,
 
     vec3 transformedPos = samplePos;
     if (gridType_#{id} == 1) {
-        transformedPos = kameleon_cartesianToSpherical(samplePos);
+        transformedPos = volume_cartesianToSpherical(samplePos);
     }
 
     float clipAlpha = 1.0;
@@ -52,14 +66,23 @@ void sample#{id}(vec3 samplePos, vec3 dir, inout vec3 accumulatedColor,
         clipAlpha *= smoothstep(clipBegin, clipEnd, dot(centerToPos, clipNormal));
     }
 
+    clipAlpha *= 1.0 - smoothstep(rUpperBound_#{id} - 0.01, rUpperBound_#{id} + 0.01, transformedPos.x);
+
     if (clipAlpha > 0) {
         float val = texture(volumeTexture_#{id}, transformedPos).r;
+
+        val = mix(valueRemapping_#{id}.x, valueRemapping_#{id}.y, val);
+
+        if (rNormalization_#{id} > 0 && gridType_#{id} == 1) {
+            val *= pow(transformedPos.x, rNormalization_#{id});
+        }
+
         vec4 color = texture(transferFunction_#{id}, val);
         vec3 backColor = color.rgb;
         vec3 backAlpha = color.aaa;
 
-        backColor *= stepSize * clipAlpha;
-        backAlpha *= stepSize * clipAlpha;
+        backColor *= stepSize*opacity_#{id} * clipAlpha;
+        backAlpha *= stepSize*opacity_#{id} * clipAlpha;
 
         backColor = clamp(backColor, 0.0, 1.0);
         backAlpha = clamp(backAlpha, 0.0, 1.0);
diff --git a/modules/volume/textureslicevolumereader.h b/modules/volume/textureslicevolumereader.h
index ee3f657088..f2c1a6daed 100644
--- a/modules/volume/textureslicevolumereader.h
+++ b/modules/volume/textureslicevolumereader.h
@@ -34,6 +34,7 @@
 #include <unordered_map>
 
 namespace openspace {
+namespace volume {
 
 template <typename Type>
 class TextureSliceVolumeReader {
@@ -53,6 +54,7 @@ private:
     bool _initialized;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #include "textureslicevolumereader.inl"
diff --git a/modules/volume/textureslicevolumereader.inl b/modules/volume/textureslicevolumereader.inl
index 0366096d1e..55a686880a 100644
--- a/modules/volume/textureslicevolumereader.inl
+++ b/modules/volume/textureslicevolumereader.inl
@@ -25,6 +25,7 @@
 #include <ghoul/io/texture/texturereader.h>
 
 namespace openspace {
+namespace volume {
 
 template <typename VoxelType>
 VoxelType TextureSliceVolumeReader<VoxelType>::get(const glm::ivec3& coordinates) const {
@@ -81,4 +82,5 @@ ghoul::opengl::Texture& TextureSliceVolumeReader<VoxelType>::getSlice(int sliceI
     return *_cache.get(sliceIndex).get();
 }
 
+} // namespace volume
 } // namespace openspace
diff --git a/modules/volume/volumegridtype.cpp b/modules/volume/volumegridtype.cpp
new file mode 100644
index 0000000000..dffb8bf3ee
--- /dev/null
+++ b/modules/volume/volumegridtype.cpp
@@ -0,0 +1,48 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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 <modules/volume/volumegridtype.h>
+
+#include <string>
+
+namespace openspace {
+namespace volume {
+
+VolumeGridType parseGridType(const std::string& gridType) {
+    if (gridType == "Cartesian") {
+        return VolumeGridType::Cartesian;
+    }
+    if (gridType == "Spherical") {
+        return VolumeGridType::Spherical;
+    }
+    throw InvalidGridTypeError(gridType);
+}
+
+InvalidGridTypeError::InvalidGridTypeError(std::string gt)
+    : RuntimeError("Invalid grid type: '" + gt + "'")
+    , gridType(std::move(gt))
+{}
+
+} // namespace volume
+} // namespace openspace
diff --git a/modules/volume/volumegridtype.h b/modules/volume/volumegridtype.h
index d8817a9c80..97df397d93 100644
--- a/modules/volume/volumegridtype.h
+++ b/modules/volume/volumegridtype.h
@@ -25,13 +25,24 @@
 #ifndef __OPENSPACE_MODULE_VOLUME___VOLUMEGRIDTYPE_H__
 #define __OPENSPACE_MODULE_VOLUME___VOLUMEGRIDTYPE_H__
 
+#include <ghoul/misc/exception.h>
+
 namespace openspace {
+namespace volume {
 
 enum class VolumeGridType : int {
     Cartesian = 0,
     Spherical = 1
 };
 
+struct InvalidGridTypeError : public ghoul::RuntimeError {
+	explicit InvalidGridTypeError(std::string gridType);
+	std::string gridType;
+};
+
+VolumeGridType parseGridType(const std::string& gridType);
+
+} // namespace volume
 } // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___VOLUMEGRIDTYPE_H__
diff --git a/modules/volume/volumemodule.cpp b/modules/volume/volumemodule.cpp
index 5bbb7684bb..518e2d92b9 100644
--- a/modules/volume/volumemodule.cpp
+++ b/modules/volume/volumemodule.cpp
@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <modules/volume/volumemodule.h>
+#include <modules/volume/rendering/renderabletimevaryingvolume.h>
 
 #include <openspace/rendering/renderable.h>
 #include <openspace/util/factorymanager.h>
@@ -31,6 +32,14 @@
 
 namespace openspace {
 
-VolumeModule::VolumeModule() : OpenSpaceModule(Name) {}
+using namespace volume;
+
+VolumeModule::VolumeModule()  : OpenSpaceModule(Name) {}
+
+void VolumeModule::internalInitialize() {
+    auto fRenderable = FactoryManager::ref().factory<Renderable>();
+    ghoul_assert(fRenderable, "No renderable factory existed");
+    fRenderable->registerClass<RenderableTimeVaryingVolume>("RenderableTimeVaryingVolume");
+}
 
 } // namespace openspace
diff --git a/modules/volume/volumemodule.h b/modules/volume/volumemodule.h
index dfa753352b..4f726a1764 100644
--- a/modules/volume/volumemodule.h
+++ b/modules/volume/volumemodule.h
@@ -33,6 +33,7 @@ class VolumeModule : public OpenSpaceModule {
 public:
     constexpr static const char* Name = "Volume";
 
+    void internalInitialize() override;
     VolumeModule();
 };
 
diff --git a/modules/volume/volumesampler.h b/modules/volume/volumesampler.h
index 023771fc0d..545870b537 100644
--- a/modules/volume/volumesampler.h
+++ b/modules/volume/volumesampler.h
@@ -26,6 +26,7 @@
 #define __OPENSPACE_MODULE_VOLUME___VOLUMESAMPLER___H__
 
 namespace openspace {
+namespace volume {
 
 template <typename VolumeType>
 class VolumeSampler {
@@ -40,6 +41,7 @@ private:
     const VolumeType* _volume;
 };
 
+} // namespace volume
 } // namespace openspace
 
 #include "volumesampler.inl"
diff --git a/modules/volume/volumesampler.inl b/modules/volume/volumesampler.inl
index 82583189fb..2d116f1d9b 100644
--- a/modules/volume/volumesampler.inl
+++ b/modules/volume/volumesampler.inl
@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 namespace openspace {
+namespace volume {
     
 template <typename VolumeType>
 VolumeSampler<VolumeType>::VolumeSampler(const VolumeType& volume, const glm::vec3& filterSize) {
@@ -78,4 +79,5 @@ typename VolumeType::VoxelType VolumeSampler<VolumeType>::sample(const glm::vec3
     return value;
 }
 
+} // namespace volume
 } // namespace openspace
diff --git a/modules/volume/volumeutils.cpp b/modules/volume/volumeutils.cpp
index 6813d07394..66bf1d3f5e 100644
--- a/modules/volume/volumeutils.cpp
+++ b/modules/volume/volumeutils.cpp
@@ -24,8 +24,9 @@
 
 #include "volumeutils.h"
 
-namespace openspace::volumeutils {
-    
+namespace openspace {
+namespace volume {
+
 size_t coordsToIndex(const glm::uvec3& coords, const glm::uvec3& dims) {
     size_t w = dims.x;
     size_t h = dims.y;
@@ -48,5 +49,6 @@ glm::uvec3 indexToCoords(size_t index, const glm::uvec3& dims) {
     
     return glm::uvec3(x, y, z);
 }
-    
-} // namespace openspace::volumeutils
+
+} // namespace volume
+} // namespace openspace
diff --git a/modules/volume/volumeutils.h b/modules/volume/volumeutils.h
index db16e31e71..cd04ecd29a 100644
--- a/modules/volume/volumeutils.h
+++ b/modules/volume/volumeutils.h
@@ -27,11 +27,13 @@
 
 #include <ghoul/glm.h>
 
-namespace openspace::volumeutils {
+namespace openspace {
+namespace volume {
 
 size_t coordsToIndex(const glm::uvec3& coords, const glm::uvec3& dimensions);
 glm::uvec3 indexToCoords(size_t index, const glm::uvec3& dimensions);
 
-} // namespace openspace::volumeutils
+} // namespace volume
+} // namespace openspace
 
 #endif // __OPENSPACE_MODULE_VOLUME___VOLUMEUTILS___H__
diff --git a/openspace.cfg b/openspace.cfg
index 12db70bccb..c5f4acea00 100644
--- a/openspace.cfg
+++ b/openspace.cfg
@@ -34,14 +34,13 @@ return {
     -- Scene = "${SCENE}/rosetta.scene",
     -- Scene = "${SCENE}/osirisrex.scene",
 
-    Task = "${TASKS}/default.task",
+    TasksRoot = "${OPENSPACE_DATA}/tasks",
 
     Paths = {
         SCRIPTS = "${BASE_PATH}/scripts",
         SHADERS = "${BASE_PATH}/shaders",
         OPENSPACE_DATA = "${BASE_PATH}/data",
         SCENE = "${OPENSPACE_DATA}/scene",
-        TASKS = "${OPENSPACE_DATA}/tasks",
         SPICE = "${OPENSPACE_DATA}/spice",
         MODULES = "${BASE_PATH}/modules",
         TESTDIR = "${BASE_PATH}/tests",
diff --git a/src/engine/configurationmanager.cpp b/src/engine/configurationmanager.cpp
index 871bca32c4..29ac9b7ea2 100644
--- a/src/engine/configurationmanager.cpp
+++ b/src/engine/configurationmanager.cpp
@@ -59,7 +59,7 @@ const string ConfigurationManager::KeyKeyboardShortcuts = "KeyboardShortcuts";
 const string ConfigurationManager::KeyDocumentation = "Documentation";
 const string ConfigurationManager::KeyFactoryDocumentation = "FactoryDocumentation";
 const string ConfigurationManager::KeyConfigScene = "Scene";
-const string ConfigurationManager::KeyConfigTask = "Task";
+const string ConfigurationManager::KeyConfigTasksRoot = "TasksRoot";
 
 const string ConfigurationManager::KeyLogging = "Logging";
 const string ConfigurationManager::PartLogDir = "LogDir";
diff --git a/src/engine/configurationmanager_doc.inl b/src/engine/configurationmanager_doc.inl
index 1e6ca2cc01..5731777510 100644
--- a/src/engine/configurationmanager_doc.inl
+++ b/src/engine/configurationmanager_doc.inl
@@ -1,4 +1,4 @@
-/*****************************************************************************************
+/*****************************************************************************************
  *                                                                                       *
  * OpenSpace                                                                             *
  *                                                                                       *
@@ -53,7 +53,7 @@ documentation::Documentation ConfigurationManager::Documentation() {
             "the Scene documentation."
         },
         {
-            ConfigurationManager::KeyConfigTask,
+            ConfigurationManager::KeyConfigTasksRoot,
             new StringAnnotationVerifier(
                 "A valid task file as described in the Task documentation"
             ),
diff --git a/src/rendering/renderable.cpp b/src/rendering/renderable.cpp
index 6cc4aef685..a73095ec4f 100644
--- a/src/rendering/renderable.cpp
+++ b/src/rendering/renderable.cpp
@@ -216,8 +216,8 @@ bool Renderable::isEnabled() const {
 }
 
 void Renderable::onEnabledChange(std::function<void(bool)> callback) {
-    _enabled.onChange([&] () {
-        callback(isEnabled());
+    _enabled.onChange([this, c{ std::move(callback) }]() {
+        c(isEnabled());
     });
 }
 
diff --git a/src/rendering/transferfunction.cpp b/src/rendering/transferfunction.cpp
index f7427ca68c..54a8c08dde 100644
--- a/src/rendering/transferfunction.cpp
+++ b/src/rendering/transferfunction.cpp
@@ -109,8 +109,7 @@ void TransferFunction::setTextureFromTxt() {
     in.open(_filepath.c_str());
 
     if (!in.is_open()) {
-        LERROR("Could not open file " << _filepath);
-        return;
+        throw ghoul::FileNotFoundError(_filepath);
     }
 
     int width = 512;
diff --git a/src/util/taskloader.cpp b/src/util/taskloader.cpp
index b2867d27eb..245d17bcd2 100644
--- a/src/util/taskloader.cpp
+++ b/src/util/taskloader.cpp
@@ -46,7 +46,7 @@ std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromDictionary(const ghoul::
         std::string taskName;
         ghoul::Dictionary subTask;
         if (tasksDictionary.getValue(key, taskName)) {
-            std::string path = "${TASKS}/" + taskName + ".task";
+            std::string path = taskName + ".task";
             std::vector<std::unique_ptr<Task>> subTasks = tasksFromFile(path);
             std::move(subTasks.begin(), subTasks.end(), std::back_inserter(tasks));
         } else if (tasksDictionary.getValue(key, subTask)) {
@@ -75,10 +75,10 @@ std::vector<std::unique_ptr<Task>> TaskLoader::tasksFromFile(const std::string&
         ghoul::lua::loadDictionaryFromFile(
             absTasksFile,
             tasksDictionary
-            );
-    } catch (...) {
+        );
+    } catch (const ghoul::RuntimeError& e) {
         LERROR("Could not load tasks file '" << absTasksFile << "'. " <<
-            "Lua parse error");
+            "Lua error: " << e.message << ": " << e.component);
         return std::vector<std::unique_ptr<Task>>();
     }
     return tasksFromDictionary(tasksDictionary);
diff --git a/src/util/timemanager.cpp b/src/util/timemanager.cpp
index 2f698b8cbd..27d16c2bb3 100644
--- a/src/util/timemanager.cpp
+++ b/src/util/timemanager.cpp
@@ -34,7 +34,10 @@ using datamessagestructures::TimeKeyframe;
 void TimeManager::preSynchronization(double dt) {
 //    double now = OsEng.runTime();
     removeKeyframesBefore(_latestConsumedTimestamp);
-    if (_timeline.nKeyframes() == 0) {
+    if (_shouldSetTime) {
+        time().setTime(_timeNextFrame.j2000Seconds());
+        _shouldSetTime = false;
+    } else if (_timeline.nKeyframes() == 0) {
         time().advanceTime(dt);
     } else {
         consumeKeyframes(dt);
@@ -141,6 +144,11 @@ void TimeManager::clearKeyframes() {
     _timeline.clearKeyframes();
 }
 
+void TimeManager::setTimeNextFrame(Time t) {
+    _shouldSetTime = true;
+    _timeNextFrame = t;
+}
+
 size_t TimeManager::nKeyframes() const {
     return _timeline.nKeyframes();
 }
diff --git a/tests/main.cpp b/tests/main.cpp
index a43b3aa73a..71acb6f178 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -81,6 +81,10 @@
 //#include <test_iswamanager.inl>
 #endif
 
+#ifdef OPENSPACE_MODULE_VOLUME_ENABLED
+#include <test_rawvolumeio.inl>
+#endif
+
 #include <test_scriptscheduler.inl>
 
 #include <test_documentation.inl>
diff --git a/tests/test_rawvolumeio.inl b/tests/test_rawvolumeio.inl
new file mode 100644
index 0000000000..3afaabb3ae
--- /dev/null
+++ b/tests/test_rawvolumeio.inl
@@ -0,0 +1,93 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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 "gtest/gtest.h"
+
+#include <openspace/util/timeline.h>
+#include <openspace/util/time.h>
+
+#include <modules/volume/rawvolume.h>
+#include <modules/volume/rawvolumereader.h>
+#include <modules/volume/rawvolumewriter.h>
+
+#include <ghoul/filesystem/filesystem.h>
+#include <ghoul/glm.h>
+
+using namespace openspace;
+
+class RawVolumeIoTest : public testing::Test {};
+
+TEST_F(RawVolumeIoTest, TinyInputOutput) {
+    using namespace volume;
+
+    glm::uvec3 dims{ 1, 1, 1 };
+    float value = 0.5;
+
+    RawVolume<float> vol(dims);
+
+    vol.set({ 0, 0, 0 }, value);
+    ASSERT_EQ(vol.get({ 0, 0, 0 }), value);
+
+    std::string volumePath = absPath("${TESTDIR}/tinyvolume.rawvolume");
+
+    // Write the 1x1x1 volume to disk
+    RawVolumeWriter<float> writer(volumePath);
+    writer.write(vol);
+
+    // Read the 1x1x1 volume and make sure the value is the same.
+    RawVolumeReader<float> reader(volumePath, dims);
+    std::unique_ptr<RawVolume<float>> storedVolume = reader.read();
+    ASSERT_EQ(storedVolume->get({ 0, 0, 0 }), value);
+}
+
+TEST_F(RawVolumeIoTest, BasicInputOutput) {
+    using namespace volume;
+
+    glm::uvec3 dims{ 2, 4, 8 };
+    auto value = [dims](glm::uvec3 v) {
+        return v.z * 8 * 4 + v.y * 4 + v.x;
+    };
+
+    RawVolume<float> vol(dims);
+    vol.forEachVoxel([&vol, &value](glm::uvec3 x, float v) {
+        vol.set(x, value(x));
+    });
+
+    vol.forEachVoxel([&value](glm::uvec3 x, float v) {
+        ASSERT_EQ(v, value(x));
+    });
+
+    std::string volumePath = absPath("${TESTDIR}/basicvolume.rawvolume");
+
+    // Write the 2x4x8 volume to disk
+    RawVolumeWriter<float> writer(volumePath);
+    writer.write(vol);
+
+    // Read the 2x4x8 volume and make sure the value is the same.
+    RawVolumeReader<float> reader(volumePath, dims);
+    std::unique_ptr<RawVolume<float>> storedVolume = reader.read();
+    vol.forEachVoxel([&value](glm::uvec3 x, float v) {
+        ASSERT_EQ(v, value(x));
+    });
+}