diff --git a/Jenkinsfile b/Jenkinsfile
index 57ff97f0f2..b97149c963 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -25,50 +25,56 @@ echo flags
 
 stage('Build') {
 	parallel linux: {
-		node('linux') {
-			checkout scm
-			sh 'git submodule update --init --recursive'
-			sh '''
-				mkdir -p build
-				cd build 
-				cmake .. ''' +
-				flags + ''' ..
-			make
-			'''
+		timeout(time: 30, unit: 'MINUTES') {
+			node('linux') {
+				checkout scm
+				sh 'git submodule update --init --recursive'
+				sh '''
+					mkdir -p build
+					cd build
+					cmake .. ''' +
+					flags + ''' ..
+				make
+				'''
+			}
 		}
 	},
 	windows: {
-		node('windows') {
-			checkout scm
-			bat '''
-				git submodule update --init --recursive
-				if not exist "build" mkdir "build"
-				cd build
-				cmake -G "Visual Studio 14 2015 Win64" .. ''' +
-				flags + ''' ..
-				msbuild.exe OpenSpace.sln /m:8 /p:Configuration=Debug
-			'''
+		timeout(time: 30, unit: 'MINUTES') {
+			node('windows') {
+				checkout scm
+				bat '''
+					git submodule update --init --recursive
+					if not exist "build" mkdir "build"
+					cd build
+					cmake -G "Visual Studio 14 2015 Win64" .. ''' +
+					flags + ''' ..
+					msbuild.exe OpenSpace.sln /m:8 /p:Configuration=Debug
+				'''
+			}
 		}
 	},
 	osx: {
-		node('osx') {
-			checkout scm
-			sh 'git submodule update --init --recursive'
-			sh '''
-				export PATH=${PATH}:/usr/local/bin:/Applications/CMake.app/Contents/bin
-				export CMAKE_BUILD_TOOL=/Applications/CMake.app/Contents/bin/CMake
-				srcDir=$PWD
-				if [ ! -d ${srcDir} ]; then
-				  mkdir ${srcDir}
-				fi
-				if [ ! -d ${srcDir}/build ]; then
-				  mkdir ${srcDir}/build
-				fi
-				cd ${srcDir}/build
-				/Applications/CMake.app/Contents/bin/cmake -G Xcode -D NASM=/usr/local/Cellar/nasm/2.11.08/bin/nasm ${srcDir} .. ''' +
-				flags + '''
-				xcodebuild
-				'''
+		timeout(time: 30, unit: 'MINUTES') {
+			node('osx') {
+				checkout scm
+				sh 'git submodule update --init --recursive'
+				sh '''
+					export PATH=${PATH}:/usr/local/bin:/Applications/CMake.app/Contents/bin
+					export CMAKE_BUILD_TOOL=/Applications/CMake.app/Contents/bin/CMake
+					srcDir=$PWD
+					if [ ! -d ${srcDir} ]; then
+					  mkdir ${srcDir}
+					fi
+					if [ ! -d ${srcDir}/build ]; then
+					  mkdir ${srcDir}/build
+					fi
+					cd ${srcDir}/build
+					/Applications/CMake.app/Contents/bin/cmake -G Xcode -D NASM=/usr/local/Cellar/nasm/2.11.08/bin/nasm ${srcDir} .. ''' +
+					flags + '''
+					xcodebuild
+					'''
+			}
 		}
 	}
 }	
\ No newline at end of file
diff --git a/apps/Launcher/main.cpp b/apps/Launcher/main.cpp
index ccf862687c..8b7f06e18d 100644
--- a/apps/Launcher/main.cpp
+++ b/apps/Launcher/main.cpp
@@ -23,7 +23,6 @@
  ****************************************************************************************/
 
 #include <QApplication>
-
 #include <QFile>
 
 #include "mainwindow.h"
diff --git a/apps/Launcher/mainwindow.cpp b/apps/Launcher/mainwindow.cpp
index d1f6012f14..51fe2e9207 100644
--- a/apps/Launcher/mainwindow.cpp
+++ b/apps/Launcher/mainwindow.cpp
@@ -29,12 +29,14 @@
 
 #include <openspace/engine/configurationmanager.h>
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/logfactory.h>
 
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/logging/log.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/logging/consolelog.h>
 #include <ghoul/logging/htmllog.h>
+#include <ghoul/logging/visualstudiooutputlog.h>
 
 #include <QApplication>
 #include <QComboBox>
@@ -168,7 +170,77 @@ MainWindow::~MainWindow() {
     delete _informationWidget;
 }
 
+
+void MainWindow::configureLogging() {
+    const std::string KeyLogLevel =
+    openspace::ConfigurationManager::KeyLauncher + '.' + openspace::ConfigurationManager::PartLogLevel;
+    const std::string KeyLogImmediateFlush =
+    openspace::ConfigurationManager::KeyLauncher + '.' + openspace::ConfigurationManager::PartImmediateFlush;
+    const std::string KeyLogs =
+    openspace::ConfigurationManager::KeyLauncher + '.' + openspace::ConfigurationManager::PartLogs;
+
+    ghoul::logging::LogLevel ghoulLogLevel;
+    std::string logLevel = "None";
+    bool immediateFlush = false;
+
+    if (_optionParser->isSet("d")) {
+        ghoulLogLevel = static_cast<ghoul::logging::LogLevel>(_optionParser->value("d").toInt());
+    } else {
+        if (_configuration->hasKeyAndValue<std::string>(KeyLogLevel)) {
+            _configuration->getValue(KeyLogLevel, logLevel);
+            _configuration->getValue(KeyLogImmediateFlush, immediateFlush);
+        }
+        ghoulLogLevel = ghoul::logging::levelFromString(logLevel);
+    }
+    printf("%d", ghoulLogLevel);
+
+    using ImmediateFlush = ghoul::logging::LogManager::ImmediateFlush;
+
+    ghoul::logging::LogManager::initialize(
+                      ghoulLogLevel,
+                      immediateFlush ? ImmediateFlush::Yes : ImmediateFlush::No
+                      );
+    LogMgr.addLog(std::make_unique<ghoul::logging::ConsoleLog>());
+    // TODO: This can crash the system in cases where the logfile can't be created ---abock
+    LogMgr.addLog(std::make_unique< ghoul::logging::HTMLLog >("LauncherLog.html", ghoul::logging::HTMLLog::Append::No));
+    LogMgr.addLog(std::make_unique< QLog >());
+
+    if (_configuration->hasKeyAndValue<ghoul::Dictionary>(KeyLogs)) {
+        ghoul::Dictionary logs;
+        _configuration->getValue(KeyLogs, logs);
+
+        for (size_t i = 1; i <= logs.size(); ++i) {
+            ghoul::Dictionary logInfo;
+            logs.getValue(std::to_string(i), logInfo);
+
+            try {
+                LogMgr.addLog(openspace::createLog(logInfo));
+            }
+            catch (const ghoul::RuntimeError& e) {
+                LERRORC(e.component, e.message);
+            }
+        }
+    }
+
+#ifdef WIN32
+    if (IsDebuggerPresent()) {
+        LogMgr.addLog(std::make_unique<ghoul::logging::VisualStudioOutputLog>());
+    }
+#endif // WIN32
+
+#ifndef GHOUL_LOGGING_ENABLE_TRACE
+    if (ghoulLogLevel == ghoul::logging::LogLevel::Trace) {
+        LWARNING("Desired logging level is set to 'Trace' but application was " <<
+                 "compiled without Trace support");
+    }
+#endif // GHOUL_LOGGING_ENABLE_TRACE
+
+}
+
 void MainWindow::initialize() {
+    // ParseOptions
+    generateOptions();
+
     // Get the news information
     QNetworkRequest request;
     request.setUrl(QUrl(NewsURL));
@@ -189,18 +261,14 @@ void MainWindow::initialize() {
     _syncWidget->setWindowModality(Qt::WindowModal);
     _syncWidget->hide();
 
-    ghoul::logging::LogManager::initialize(ghoul::logging::LogLevel::Debug);
-    LogMgr.addLog( std::make_unique< ghoul::logging::ConsoleLog >() );
-    // TODO: This can crash the system in cases where the logfile can't be created ---abock
-    LogMgr.addLog( std::make_unique< ghoul::logging::HTMLLog >("LauncherLog.html", ghoul::logging::HTMLLog::Append::No) );
-    LogMgr.addLog( std::make_unique< QLog >() );
-
     std::string configurationFile = _configurationFile;
-    
+
     _configuration = new openspace::ConfigurationManager;
     configurationFile = _configuration->findConfiguration( configurationFile );
     _configuration->loadFromFile(configurationFile);
 
+    configureLogging();
+
     // Load all available scenes
     QString modulesDirectory = QString::fromStdString(absPath("${SCENE}"));
     QDir d(modulesDirectory);
@@ -263,3 +331,20 @@ void MainWindow::newsReadyRead() {
     _informationWidget->setText(news);
     _newsReply->deleteLater();
 }
+
+void MainWindow::generateOptions() {
+
+    _optionParser = new QCommandLineParser;
+    _optionParser->setApplicationDescription("OpenSpace Launcher");
+    _optionParser->addHelpOption();
+    _optionParser->addVersionOption();
+
+    _optionParser->addOptions({
+        { { "d", "debug" },
+        QCoreApplication::translate("main", "Debug output level"),
+        QCoreApplication::translate("main", "0, 1, 2, 3, 4, 5, 6, 7"),
+        QCoreApplication::translate("main", "1"),
+        }
+    });
+    _optionParser->process(*QApplication::instance());
+}
diff --git a/apps/Launcher/mainwindow.h b/apps/Launcher/mainwindow.h
index 9fd2626d4d..9c1e56449c 100644
--- a/apps/Launcher/mainwindow.h
+++ b/apps/Launcher/mainwindow.h
@@ -31,6 +31,7 @@
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QTextEdit>
+#include <QCommandLineParser>
 
 class QComboBox;
 class QNetworkAccessManager;
@@ -56,9 +57,12 @@ private slots:
     void newsNetworkError();
     void newsReadyRead();
 
+    void generateOptions();
+
 private:
     void initialize();
-    
+    void configureLogging();
+
     QNetworkReply* _newsReply;
     
     QTextEdit* _informationWidget;
@@ -74,42 +78,9 @@ private:
 
     QNetworkAccessManager _networkManager;
     openspace::ConfigurationManager* _configuration;
+
+    QCommandLineParser* _optionParser;
 };
 
-//class MainWindow : public QWidget {
-//Q_OBJECT
-//public:
-//    MainWindow();
-//    ~MainWindow();
-//
-//    std::string nextTarget() const;
-//
-//public slots:
-//    void sendScript(QString script);
-//
-//private slots:
-//    void onConnect(QString host, QString port);
-//    void onDisconnect();
-//
-//    void onSocketConnected();
-//    void onSocketDisconnected();
-//
-//    void readTcpData();
-//    void handleStatusMessage(QByteArray data);
-//    void handlePlaybook(QByteArray data);
-//
-//    void fullyConnected();
-//
-//private:
-//    ConfigurationWidget* _configurationWidget;
-//    ControlWidget* _timeControlWidget;
-//    InformationWidget* _informationWidget;
-//    TimelineWidget* _timelineWidget;
-//    
-//    QTcpSocket* _socket;
-//
-//    bool _hasHongKangTimeline = false;
-//    bool _hasLabelTimeline = false;
-//};
 
 #endif // __OPENSPACE_APP_LAUNCHER___MAINWINDOW___H__
diff --git a/data/fonts/Inconsolata/Inconsolata-Regular.ttf b/data/fonts/Inconsolata/Inconsolata-Regular.ttf
new file mode 100644
index 0000000000..592ccd2007
Binary files /dev/null and b/data/fonts/Inconsolata/Inconsolata-Regular.ttf differ
diff --git a/include/openspace/engine/configurationmanager.h b/include/openspace/engine/configurationmanager.h
index 92909e6789..8ec3aa167d 100644
--- a/include/openspace/engine/configurationmanager.h
+++ b/include/openspace/engine/configurationmanager.h
@@ -93,6 +93,8 @@ public:
     /// The key that stores the verbosity (None, Minimal, Default, Full) of the system
     /// capabilities components
     static const std::string PartCapabilitiesVerbosity;
+    /// The key that stores the settings for determining Launcher-related settings
+    static const std::string KeyLauncher;
     /// The full key that stores the verbosity of the system capabilities component
     static const std::string KeyCapabilitiesVerbosity;
     /// The key that stores the time (in seconds) that the application will wait before
diff --git a/include/openspace/interaction/interactionhandler.h b/include/openspace/interaction/interactionhandler.h
index 891dfca494..162404d227 100644
--- a/include/openspace/interaction/interactionhandler.h
+++ b/include/openspace/interaction/interactionhandler.h
@@ -65,7 +65,6 @@ public:
 
     // Interaction mode setters
     void setCameraStateFromDictionary(const ghoul::Dictionary& cameraDict);
-    void setInteractionMode(const std::string& interactionModeKey);
     InteractionMode* interactionMode();
     
     void goToChunk(int x, int y, int level);
@@ -73,9 +72,10 @@ public:
     
     void resetKeyBindings();
 
-    void addKeyframe(const datamessagestructures::CameraKeyframe &kf);
+    void addKeyframe(double timestamp, KeyframeInteractionMode::CameraPose pose);
     void removeKeyframesAfter(double timestamp);
     void clearKeyframes();
+    size_t nKeyframes() const;
     const std::vector<datamessagestructures::CameraKeyframe>& keyframes() const;
 
     void bindKeyLocal(
@@ -134,7 +134,7 @@ private:
     
     std::string generateJson() const override;
 
-    void setInteractionMode(std::shared_ptr<InteractionMode> interactionMode);
+    void setInteractionMode(InteractionMode* interactionMode);
 
     bool _cameraUpdatedFromScript = false;
 
@@ -143,14 +143,18 @@ private:
     std::unique_ptr<InputState> _inputState;
     Camera* _camera;
 
-    std::shared_ptr<InteractionMode> _currentInteractionMode;
+    InteractionMode* _currentInteractionMode;
 
-    std::map<std::string, std::shared_ptr<InteractionMode>> _interactionModes;
     std::shared_ptr<OrbitalInteractionMode::MouseStates> _mouseStates;
 
+    std::unique_ptr<OrbitalInteractionMode> _orbitalInteractionMode;
+    std::unique_ptr<GlobeBrowsingInteractionMode> _globeBrowsingInteractionMode;
+    std::unique_ptr<KeyframeInteractionMode> _keyframeInteractionMode;
+
     // Properties
     properties::StringProperty _origin;
-
+    properties::OptionProperty _interactionModeOption;
+    
     properties::BoolProperty _rotationalFriction;
     properties::BoolProperty _horizontalFriction;
     properties::BoolProperty _verticalFriction;
diff --git a/include/openspace/interaction/interactionmode.h b/include/openspace/interaction/interactionmode.h
index 0698e2992e..dc99ec1498 100644
--- a/include/openspace/interaction/interactionmode.h
+++ b/include/openspace/interaction/interactionmode.h
@@ -28,6 +28,7 @@
 #include <openspace/network/parallelconnection.h>
 #include <openspace/util/mouse.h>
 #include <openspace/util/keys.h>
+#include <openspace/util/timeline.h>
 
 #ifdef OPENSPACE_MODULE_GLOBEBROWSING_ENABLED
 #include <modules/globebrowsing/tile/tileindex.h>
@@ -80,14 +81,6 @@ namespace interaction {
         void mousePositionCallback(double mouseX, double mouseY);
         void mouseScrollWheelCallback(double mouseScrollDelta);
 
-        // Mutators
-        void addKeyframe(const datamessagestructures::CameraKeyframe &kf);
-        void removeKeyframesAfter(double timestamp);
-        void clearKeyframes();
-        void clearOldKeyframes();
-
-        static bool compareKeyframeTimes(const datamessagestructures::CameraKeyframe& a, const datamessagestructures::CameraKeyframe& b);
-
         // Accessors
         const std::list<std::pair<Key, KeyModifier> >& getPressedKeys() const;
         const std::list<MouseButton>& getPressedMouseButtons() const;
@@ -104,9 +97,6 @@ namespace interaction {
         std::list<MouseButton> _mouseButtonsDown;
         glm::dvec2 _mousePosition;
         double _mouseScrollDelta;
-
-        // Remote input via keyframes
-        std::vector<datamessagestructures::CameraKeyframe> _keyframes;
     };
 
 
@@ -194,16 +184,23 @@ protected:
 class KeyframeInteractionMode : public InteractionMode
 {
 public:
+    struct CameraPose {
+        glm::dvec3 position;
+        glm::quat rotation;
+        std::string focusNode;
+        bool followFocusNodeRotation;
+    };
+
     KeyframeInteractionMode();
     ~KeyframeInteractionMode();
 
     virtual void updateMouseStatesFromInput(const InputState& inputState, double deltaTime);
     virtual void updateCameraStateFromMouseStates(Camera& camera, double deltaTime);
     bool followingNodeRotation() const override;
+    Timeline<CameraPose>& timeline();
 
 private:
-    std::vector<datamessagestructures::CameraKeyframe> _keyframes;
-    double _currentKeyframeTime;
+    Timeline<CameraPose> _cameraPoseTimeline;
 };
 
 class GlobeBrowsingInteractionMode;
diff --git a/include/openspace/interaction/luaconsole.h b/include/openspace/interaction/luaconsole.h
index 77beaf3109..09ff1c1bf8 100644
--- a/include/openspace/interaction/luaconsole.h
+++ b/include/openspace/interaction/luaconsole.h
@@ -28,12 +28,19 @@
 #include <openspace/network/parallelconnection.h>
 #include <openspace/properties/propertyowner.h>
 #include <openspace/properties/scalar/boolproperty.h>
+#include <openspace/properties/vector/vec4property.h>
 #include <openspace/scripting/scriptengine.h>
 #include <openspace/util/keys.h>
 
 #include <string>
 #include <vector>
 
+namespace ghoul {
+namespace opengl {
+    class ProgramObject;
+} // namespace opengl
+} // namespace ghoul
+
 namespace openspace {
 
 class LuaConsole : public properties::PropertyOwner {
@@ -46,7 +53,9 @@ public:
     bool keyboardCallback(Key key, KeyModifier modifier, KeyAction action);
     void charCallback(unsigned int codepoint, KeyModifier modifier);
 
+    void update();
     void render();
+    float currentHeight() const;
 
 private:
     void parallelConnectionChanged(const ParallelConnection::Status& status);
@@ -55,6 +64,14 @@ private:
     properties::BoolProperty _isVisible;
     properties::BoolProperty _remoteScripting;
 
+    properties::Vec4Property _backgroundColor;
+    properties::Vec4Property _highlightColor;
+    properties::Vec4Property _separatorColor;
+    properties::Vec4Property _entryTextColor;
+    properties::Vec4Property _historyTextColor;
+    properties::IntProperty _historyLength;
+
+    
     size_t _inputPosition;
     std::vector<std::string> _commandsHistory;
     size_t _activeCommand;
@@ -65,6 +82,17 @@ private:
         bool hasInitialValue;
         std::string initialValue;
     } _autoCompleteInfo;
+
+    float _currentHeight;
+    float _targetHeight;
+    float _fullHeight;
+
+    std::shared_ptr<ghoul::fontrendering::Font> _font;
+    std::shared_ptr<ghoul::fontrendering::Font> _historyFont;
+
+    std::unique_ptr<ghoul::opengl::ProgramObject> _program;
+    GLuint _vao;
+    GLuint _vbo;
 };
 
 } // namespace openspace
diff --git a/include/openspace/properties/property.h b/include/openspace/properties/property.h
index 54e7a07532..5fbc8e6a78 100644
--- a/include/openspace/properties/property.h
+++ b/include/openspace/properties/property.h
@@ -68,9 +68,9 @@ public:
      */
     enum class Visibility {
         All = 3,  ///< Visible for all types, no matter what
-        Developer = 2, ///< Visible in Developer mode
-        User = 1, ///< Visible in User mode
-        Hidden = 0 ///< Never visible
+        Hidden = 2, ///< Never visible
+        Developer = 1, ///< Visible in Developer mode
+        User = 0 ///< Visible in User mode
     };
 
     /**
@@ -292,6 +292,18 @@ public:
      */
     void setReadOnly(bool state);
 
+    /**
+    * Default view options that can be used in the Property::setViewOption method. The
+    * values are: Property::ViewOptions::Color = <code>color</code>,
+    * Property::ViewOptions::LightPosition = <code>lightPosition</code>,
+    * Property::ViewOptions::PowerScaledScalar = <code>powerScaledScalar</code>, and
+    * Property::ViewOptions::PowerScaledCoordinate = <code>powerScaledCoordinate</code>.
+    */
+    struct ViewOptions {
+        static const char* Color;
+        static const char* LightPosition;
+    };
+
     /**
      * This method allows the developer to give hints to the GUI about different
      * representations for the GUI. The same Property (for example Vec4Property) can be
@@ -307,18 +319,14 @@ public:
     void setViewOption(std::string option, bool value = true);
 
     /**
-     * Default view options that can be used in the Property::setViewOption method. The
-     * values are: Property::ViewOptions::Color = <code>color</code>,
-     * Property::ViewOptions::LightPosition = <code>lightPosition</code>,
-     * Property::ViewOptions::PowerScaledScalar = <code>powerScaledScalar</code>, and
-     * Property::ViewOptions::PowerScaledCoordinate = <code>powerScaledCoordinate</code>.
+     * This method returns the state of a \p option hint. See Property::ViewOptions for a
+     * default list of possible options. As these are only hints, the GUI is free to
+     * ignore any suggestion by the developer.
+     * \param option The view option that should be retrieved
+     * \param defaultValue The value that is returned if the \p option was not set
+     * \return The view option's value
      */
-    struct ViewOptions {
-        static const char* Color;
-        static const char* LightPosition;
-        static const char* PowerScaledScalar;
-        static const char* PowerScaledCoordinate;
-    };
+    bool viewOption(const std::string& option, bool defaultValue = false) const;
 
     /**
      * Returns the metaData that contains all information for external applications to
diff --git a/include/openspace/util/time.h b/include/openspace/util/time.h
index 5241d21a61..947f7a0948 100644
--- a/include/openspace/util/time.h
+++ b/include/openspace/util/time.h
@@ -55,8 +55,6 @@ namespace openspace {
  * The synchronization of the simulation time requires 
  */
 
-class SyncBuffer;
-
 class Time {
 public:
     /**
@@ -90,20 +88,6 @@ public:
 
     static Time now();
 
-    /**
-     * Returns the reference to the Time singleton object.
-     * \return The reference to the Time singleton object
-     * \pre The Time singleton must have been initialized
-     */
-    static Time& ref();
-
-    /**
-     * Returns <code>true</code> if the singleton has been successfully initialized,
-     * <code>false</code> otherwise
-     * \return <code>true</code> if the singleton has been successfully initialized,
-     * <code>false</code> otherwise
-     */
-    static bool isInitialized();
     
     /**
      * Sets the current time to the specified value in seconds past the J2000 epoch. This
@@ -210,15 +194,10 @@ public:
      */
     static scripting::LuaLibrary luaLibrary();
 
-    std::vector<Syncable*> getSyncables();
-
 private:
-    static Time* _instance; ///< The singleton instance
-
-    SyncData<double> _time;
-    SyncData<double> _dt;
-    SyncData<bool> _timeJumped;
-
+    double _time;
+    double _dt;
+    bool _timeJumped;
     bool _timePaused = false;    
 };
 
diff --git a/include/openspace/util/timeline.h b/include/openspace/util/timeline.h
new file mode 100644
index 0000000000..794aecf96a
--- /dev/null
+++ b/include/openspace/util/timeline.h
@@ -0,0 +1,96 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014-2017                                                               *
+ *                                                                                       *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+ * software and associated documentation files (the "Software"), to deal in the Software *
+ * without restriction, including without limitation the rights to use, copy, modify,    *
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+ * permit persons to whom the Software is furnished to do so, subject to the following   *
+ * conditions:                                                                           *
+ *                                                                                       *
+ * The above copyright notice and this permission notice shall be included in all copies *
+ * or substantial portions of the Software.                                              *
+ *                                                                                       *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+ ****************************************************************************************/
+
+#ifndef __OPENSPACE_CORE___TIMELINE___H__
+#define __OPENSPACE_CORE___TIMELINE___H__
+
+#include <algorithm>
+#include <deque>
+#include <cstddef>
+
+namespace openspace {
+
+/**
+* Base class for keyframes
+*/
+struct KeyframeBase {
+    size_t id;
+    double timestamp;
+};
+
+/**
+* Templated class for keyframes containing data
+*/
+template <typename T>
+struct Keyframe : public KeyframeBase {
+    Keyframe(size_t i, double t, T p)
+        : KeyframeBase{i, t}
+        , data(p)
+    {}
+    T data;
+};
+
+/**
+* Templated class for timelines
+*/
+template <typename T>
+class Timeline {
+public:
+    Timeline();
+    virtual ~Timeline();
+    void addKeyframe(double time, T data);
+    void clearKeyframes();
+    void removeKeyframe(size_t id);
+    void removeKeyframesBefore(double timestamp, bool inclusive = false);
+    void removeKeyframesAfter(double timestamp, bool inclusive = false);
+    void removeKeyframesBetween(double begin, double end, bool inclusiveBegin = false, bool inclusiveEnd = false);
+    size_t nKeyframes() const;
+    const Keyframe<T>* firstKeyframeAfter(double timestamp, bool inclusive = false) const;
+    const Keyframe<T>* lastKeyframeBefore(double timestamp, bool inclusive = false) const;
+    const std::deque<Keyframe<T>>& keyframes() const;
+private:
+    size_t _nextKeyframeId;
+    std::deque<Keyframe<T>> _keyframes;
+};
+
+/**
+* Return true if the timestamp of a is smaller the timestamp of b.
+*/
+bool compareKeyframeTimes(const KeyframeBase& a, const KeyframeBase& b);
+
+/**
+* Return true if a is smaller than the timestamp of b.
+*/
+bool compareTimeWithKeyframeTime(double a, const KeyframeBase& b);
+
+/**
+* Return true if the timestamp of a is smaller than b.
+*/
+bool compareKeyframeTimeWithTime(const KeyframeBase& a, double b);
+
+} // namespace openspace
+
+#include <openspace/util/timeline.inl>;
+
+#endif // __OPENSPACE_CORE___TIMELINE___H__
diff --git a/include/openspace/util/timeline.inl b/include/openspace/util/timeline.inl
new file mode 100644
index 0000000000..f3b4a3774f
--- /dev/null
+++ b/include/openspace/util/timeline.inl
@@ -0,0 +1,121 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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.                                         *
+ ****************************************************************************************/
+
+namespace openspace {
+
+template <typename T>
+Timeline<T>::Timeline()
+    : _nextKeyframeId(1)
+{}
+
+template <typename T>
+Timeline<T>::~Timeline() {}
+
+template <typename T>
+void Timeline<T>::addKeyframe(double timestamp, T data) {
+    Keyframe<T> keyframe(++_nextKeyframeId, timestamp, data);
+    auto iter = std::upper_bound(_keyframes.begin(), _keyframes.end(), keyframe, &compareKeyframeTimes);
+    _keyframes.insert(iter, keyframe);
+}
+
+template <typename T>
+void Timeline<T>::removeKeyframesAfter(double timestamp, bool inclusive) {
+    auto iter = inclusive
+        ? std::lower_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareKeyframeTimeWithTime)
+        : std::upper_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareTimeWithKeyframeTime);
+
+    _keyframes.erase(iter, _keyframes.end());
+}
+
+template <typename T>
+void Timeline<T>::removeKeyframesBefore(double timestamp, bool inclusive) {
+    auto iter = inclusive
+        ? std::upper_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareTimeWithKeyframeTime)
+        : std::lower_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareKeyframeTimeWithTime);
+
+    _keyframes.erase(_keyframes.begin(), iter);
+}
+
+template <typename T>
+void Timeline<T>::removeKeyframesBetween(double begin, double end, bool inclusiveBegin, bool inclusiveEnd) {
+    auto beginIter = inclusiveBegin
+        ? std::lower_bound(_keyframes.begin(), _keyframes.end(), begin, &compareKeyframeTimeWithTime)
+        : std::upper_bound(_keyframes.begin(), _keyframes.end(), begin, &compareTimeWithKeyframeTime);
+
+    auto endIter = inclusiveEnd
+        ? std::upper_bound(beginIter, _keyframes.end(), end, &compareTimeWithKeyframeTime)
+        : std::lower_bound(beginIter, _keyframes.end(), end, &compareKeyframeTimeWithTime);
+
+    _keyframes.erase(beginIter, endIter);
+}
+
+template <typename T>
+void Timeline<T>::clearKeyframes() {
+    _keyframes.clear();
+}
+
+template <typename T>
+void Timeline<T>::removeKeyframe(size_t id) {
+    _keyframes.erase(std::remove_if(_keyframes.begin(), _keyframes.end(), [id] (Keyframe<T> keyframe) {
+        return keyframe.id == id;
+    }), _keyframes.end());
+}
+
+template <typename T>
+size_t Timeline<T>::nKeyframes() const {
+    return _keyframes.size();
+}
+
+template <typename T>
+const Keyframe<T>* Timeline<T>::firstKeyframeAfter(double timestamp, bool inclusive) const {
+    auto it = inclusive
+        ? std::lower_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareKeyframeTimeWithTime)
+        : std::upper_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareTimeWithKeyframeTime);
+    if (it == _keyframes.end()) {
+        return nullptr;
+    }
+    return &(*it);
+}
+
+template <typename T>
+const Keyframe<T>* Timeline<T>::lastKeyframeBefore(double timestamp, bool inclusive) const {
+    auto it = inclusive
+        ? std::upper_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareTimeWithKeyframeTime)
+        : std::lower_bound(_keyframes.begin(), _keyframes.end(), timestamp, &compareKeyframeTimeWithTime);
+    if (it == _keyframes.begin()) {
+        return nullptr;
+    }
+    it--;
+    return &(*it);
+}
+
+
+template<typename T>
+const std::deque<Keyframe<T>>& Timeline<T>::keyframes() const {
+    return _keyframes;
+}
+
+
+}
+
diff --git a/include/openspace/util/timemanager.h b/include/openspace/util/timemanager.h
index 018765fbf6..a499c2d400 100644
--- a/include/openspace/util/timemanager.h
+++ b/include/openspace/util/timemanager.h
@@ -27,24 +27,26 @@
 
 #include <vector>
 #include <deque>
-#include <openspace/network/messagestructures.h>
+#include <openspace/util/timeline.h>
+#include <openspace/util/time.h>
+#include <openspace/util/syncdata.h>
 
 namespace openspace {
 
 class TimeManager {
 public:
+    Time& time();
+    std::vector<Syncable*> getSyncables();
     void preSynchronization(double dt);
-    void addKeyframe(const datamessagestructures::TimeKeyframe& kf);
+    void addKeyframe(double timestamp, Time kf);
     void removeKeyframesBefore(double timestamp);
     void removeKeyframesAfter(double timestamp);
     void clearKeyframes();
-    const std::deque<datamessagestructures::TimeKeyframe>& keyframes() const;
+    size_t nKeyframes() const;
 private:
+    Timeline<Time> _timeline;
+    SyncData<Time> _currentTime;
     void consumeKeyframes(double dt);
-    std::deque<datamessagestructures::TimeKeyframe> _keyframes;
-    static bool compareKeyframeTimes(
-        const datamessagestructures::TimeKeyframe& a,
-        const datamessagestructures::TimeKeyframe& b);
     double _latestConsumedTimestamp;
 };
 
diff --git a/include/openspace/util/updatestructures.h b/include/openspace/util/updatestructures.h
index a7785b183d..6785fac877 100644
--- a/include/openspace/util/updatestructures.h
+++ b/include/openspace/util/updatestructures.h
@@ -27,6 +27,7 @@
 
 #include <openspace/util/camera.h>
 #include <openspace/util/powerscaledcoordinate.h>
+#include <openspace/util/time.h>
 
 namespace openspace {
 
@@ -45,11 +46,8 @@ struct TransformData {
 
 struct UpdateData {
     TransformData modelTransform;
-    double time;
-    double delta;
-    bool timePaused;
-    bool isTimeJump;
-    bool doPerformanceMeasurement;
+    const Time time;
+    const bool doPerformanceMeasurement;
 };
 
 
@@ -58,6 +56,7 @@ struct RenderData {
     // psc position to be removed in favor of the double precision position defined in
     // the translation in transform.
     psc position;
+    const Time time;
     bool doPerformanceMeasurement;
     int renderBinMask;
     TransformData modelTransform;
diff --git a/modules/atmosphere/rendering/atmosphereraycaster.h b/modules/atmosphere/rendering/atmosphereraycaster.h
index 076fa60ce1..8f91e028c7 100644
--- a/modules/atmosphere/rendering/atmosphereraycaster.h
+++ b/modules/atmosphere/rendering/atmosphereraycaster.h
@@ -41,8 +41,8 @@ namespace ghoul {
 
 namespace openspace {
 
-class RenderData;
-class RaycastData;
+struct RenderData;
+struct RaycastData;
 
 class AtmosphereRaycaster : public VolumeRaycaster {
 public:
diff --git a/modules/atmosphere/rendering/renderableatmosphere.cpp b/modules/atmosphere/rendering/renderableatmosphere.cpp
index f7d71af5c0..1bb4752ebe 100644
--- a/modules/atmosphere/rendering/renderableatmosphere.cpp
+++ b/modules/atmosphere/rendering/renderableatmosphere.cpp
@@ -121,7 +121,7 @@ void RenderableAtmosphere::update(const UpdateData& data) {
         _raycaster->setColor(_color);
         _raycaster->setStepSize(_stepSize);
         _raycaster->setModelTransform(transform);
-        _raycaster->setTime(data.time);
+        _raycaster->setTime(data.time.j2000Seconds());
     }
 }
 
diff --git a/modules/atmosphere/rendering/renderableplanetatmosphere.cpp b/modules/atmosphere/rendering/renderableplanetatmosphere.cpp
index 8235c11cbc..ed53c6d235 100644
--- a/modules/atmosphere/rendering/renderableplanetatmosphere.cpp
+++ b/modules/atmosphere/rendering/renderableplanetatmosphere.cpp
@@ -806,13 +806,13 @@ namespace openspace {
         // set spice-orientation in accordance to timestamp
         //_stateMatrix = SpiceManager::ref().positionTransformMatrix(_frame, "GALACTIC", data.time);
         _stateMatrix = data.modelTransform.rotation;
-        _time = data.time;
+        _time = data.time.j2000Seconds();
 
         if (_programObject && _programObject->isDirty())
             _programObject->rebuildFromFile();
 
         if (_deferredcaster) {
-            _deferredcaster->setTime(data.time);
+            _deferredcaster->setTime(data.time.j2000Seconds());
             glm::dmat4 modelTransform;
             computeModelTransformMatrix(&modelTransform);
             _deferredcaster->setModelTransform(modelTransform);
diff --git a/modules/base/rendering/renderablesphericalgrid.cpp b/modules/base/rendering/renderablesphericalgrid.cpp
index f167f514aa..00a1f8b862 100644
--- a/modules/base/rendering/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/renderablesphericalgrid.cpp
@@ -230,7 +230,7 @@ void RenderableSphericalGrid::render(const RenderData& data){
 }
 
 void RenderableSphericalGrid::update(const UpdateData& data) {
-    _parentMatrix = SpiceManager::ref().positionTransformMatrix("IAU_JUPITER", "GALACTIC", data.time);
+    _parentMatrix = SpiceManager::ref().positionTransformMatrix("IAU_JUPITER", "GALACTIC", data.time.j2000Seconds());
 
 }
 }
\ No newline at end of file
diff --git a/modules/base/rendering/renderabletrailorbit.cpp b/modules/base/rendering/renderabletrailorbit.cpp
index 47a723d301..f3f8e8c367 100644
--- a/modules/base/rendering/renderabletrailorbit.cpp
+++ b/modules/base/rendering/renderabletrailorbit.cpp
@@ -195,7 +195,7 @@ void RenderableTrailOrbit::update(const UpdateData& data) {
 
     // 2
     // Write the current location into the floating position
-    glm::vec3 p = _translation->position(data.time);
+    glm::vec3 p = _translation->position(data.time.j2000Seconds());
     _vertexArray[_primaryRenderInformation.first] = { p.x, p.y, p.z };
 
     glBindVertexArray(_primaryRenderInformation._vaoID);
@@ -316,22 +316,22 @@ RenderableTrailOrbit::UpdateReport RenderableTrailOrbit::updateTrails(
 {
     // If we are doing a time jump, it is in general faster to recalculate everything
     // than to only update parts of the array
-    if (data.isTimeJump) {
+    if (data.time.timeJumped()) {
         _needsFullSweep = true;
     }
     if (_needsFullSweep) {
-        fullSweep(data.time);
+        fullSweep(data.time.j2000Seconds());
         return { true, UpdateReport::All } ;
     }
 
     // When time stands still (at the iron hill), we don't need to perform any work
-    if (data.delta == 0.0) {
+    if (data.time.deltaTime() == 0.0) {
         return { false, 0 };
     }
 
     double secondsPerPoint = _period / (_resolution - 1);
     // How much time has passed since the last permanent point
-    double delta = data.time - _lastPointTime;
+    double delta = data.time.j2000Seconds() - _lastPointTime;
 
     // We'd like to test for equality with 0 here, but due to rounding issues, we won't
     // get there. If this check is not here, we will trigger the positive or negative
@@ -357,7 +357,7 @@ RenderableTrailOrbit::UpdateReport RenderableTrailOrbit::updateTrails(
         // If we would need to generate more new points than there are total points in the
         // array, it is faster to regenerate the entire array
         if (nNewPoints >= _resolution) {
-            fullSweep(data.time);
+            fullSweep(data.time.j2000Seconds());
             return { true, UpdateReport::All };
         }
 
@@ -392,7 +392,7 @@ RenderableTrailOrbit::UpdateReport RenderableTrailOrbit::updateTrails(
         // If we would need to generate more new points than there are total points in the
         // array, it is faster to regenerate the entire array
         if (nNewPoints >= _resolution) {
-            fullSweep(data.time);
+            fullSweep(data.time.j2000Seconds());
             return { true, UpdateReport::All };
         }
 
diff --git a/modules/base/rendering/renderabletrailtrajectory.cpp b/modules/base/rendering/renderabletrailtrajectory.cpp
index 889bdf3a14..8094ba3abd 100644
--- a/modules/base/rendering/renderabletrailtrajectory.cpp
+++ b/modules/base/rendering/renderabletrailtrajectory.cpp
@@ -255,7 +255,7 @@ void RenderableTrailTrajectory::update(const UpdateData& data) {
         // If only trail so far should be rendered, we need to find the corresponding time
         // in the array and only render it until then
         _primaryRenderInformation.first = 0;
-        double t = (data.time - _start) / (_end - _start);
+        double t = (data.time.j2000Seconds() - _start) / (_end - _start);
         _primaryRenderInformation.count = std::min(
             static_cast<GLsizei>(ceil(_vertexArray.size() * t)),
             static_cast<GLsizei>(_vertexArray.size() - 1)
@@ -264,7 +264,7 @@ void RenderableTrailTrajectory::update(const UpdateData& data) {
 
     // If we are inside the valid time, we additionally want to draw a line from the last
     // correct point to the current location of the object
-    if (data.time >= _start && data.time <= _end && !_renderFullTrail) {
+    if (data.time.j2000Seconds() >= _start && data.time.j2000Seconds() <= _end && !_renderFullTrail) {
         // Copy the last valid location
         glm::dvec3 v0(
             _vertexArray[_primaryRenderInformation.count - 1].x,
@@ -273,7 +273,7 @@ void RenderableTrailTrajectory::update(const UpdateData& data) {
         );
         
         // And get the current location of the object
-        glm::dvec3 p = _translation->position(data.time);
+        glm::dvec3 p = _translation->position(data.time.j2000Seconds());
         glm::dvec3 v1 = { p.x, p.y, p.z };
 
         // Comptue the difference between the points in double precision
diff --git a/modules/globebrowsing/globes/renderableglobe.cpp b/modules/globebrowsing/globes/renderableglobe.cpp
index 5ab0ac0a3c..1bd3f63484 100644
--- a/modules/globebrowsing/globes/renderableglobe.cpp
+++ b/modules/globebrowsing/globes/renderableglobe.cpp
@@ -423,7 +423,7 @@ void RenderableGlobe::render(const RenderData& data, RendererTasks& tasks) {
 }
 
 void RenderableGlobe::update(const UpdateData& data) {
-    _time = data.time;
+    _time = data.time.j2000Seconds();
     _distanceSwitch.update(data);
 
     glm::dmat4 translation =
@@ -445,7 +445,7 @@ void RenderableGlobe::update(const UpdateData& data) {
 
 #ifdef OPENSPACE_MODULE_ATMOSPHERE_ENABLED
     if (_deferredcaster) {
-        _deferredcaster->setTime(data.time);
+        _deferredcaster->setTime(data.time.j2000Seconds());
         _deferredcaster->setModelTransform(_cachedModelTransform);
     }
 #endif
diff --git a/modules/globebrowsing/tile/tileprovider/temporaltileprovider.h b/modules/globebrowsing/tile/tileprovider/temporaltileprovider.h
index 784c206912..0a98966908 100644
--- a/modules/globebrowsing/tile/tileprovider/temporaltileprovider.h
+++ b/modules/globebrowsing/tile/tileprovider/temporaltileprovider.h
@@ -28,8 +28,10 @@
 #ifdef GLOBEBROWSING_USE_GDAL
 
 #include <modules/globebrowsing/tile/tileprovider/tileprovider.h>
+#include <openspace/engine/openspaceengine.h>
 
 #include <openspace/util/time.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/timerange.h>
 
 #include <ghoul/misc/dictionary.h>
@@ -197,7 +199,7 @@ public:
 
     typedef std::string TimeKey;
 
-    std::shared_ptr<TileProvider> getTileProvider(Time t = Time::ref());
+    std::shared_ptr<TileProvider> getTileProvider(Time t = OsEng.timeManager().time());
     std::shared_ptr<TileProvider> getTileProvider(TimeKey timekey);
 
 private:
diff --git a/modules/iswa/rendering/iswacygnet.h b/modules/iswa/rendering/iswacygnet.h
index 24cc04071b..89271d39d4 100644
--- a/modules/iswa/rendering/iswacygnet.h
+++ b/modules/iswa/rendering/iswacygnet.h
@@ -34,6 +34,9 @@
 #include <openspace/properties/triggerproperty.h>
 #include <openspace/rendering/renderable.h>
 #include <openspace/rendering/transferfunction.h>
+
+#include <openspace/engine/openspaceengine.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/time.h>
 
 #include <modules/iswa/rendering/iswabasegroup.h>
@@ -115,7 +118,7 @@ protected:
      * this should be the data file.
      * @return true if update was successfull
      */
-    virtual bool downloadTextureResource(double timestamp = Time::ref().j2000Seconds()) = 0;
+    virtual bool downloadTextureResource(double timestamp = OsEng.timeManager().time().j2000Seconds()) = 0;
     virtual bool readyToRender() const = 0;
      /**
      * should set all uniforms needed to render
diff --git a/modules/iswa/util/iswamanager.h b/modules/iswa/util/iswamanager.h
index 3af0a8048f..a26638ae65 100644
--- a/modules/iswa/util/iswamanager.h
+++ b/modules/iswa/util/iswamanager.h
@@ -35,6 +35,8 @@
 #ifdef OPENSPACE_MODULE_KAMELEON_ENABLED
 #include <ccmc/Kameleon.h>
 #endif
+
+#include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/downloadmanager.h>
 #include <modules/kameleon/include/kameleonwrapper.h>
 #include <openspace/rendering/renderable.h>
@@ -43,6 +45,7 @@
 #include <openspace/util/spicemanager.h>
 #include <openspace/properties/selectionproperty.h>
 #include <modules/iswa/ext/json/json.hpp>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/time.h>
 
 
@@ -92,7 +95,7 @@ public:
 
     std::future<DownloadManager::MemoryFile> fetchImageCygnet(int id, double timestamp);
     std::future<DownloadManager::MemoryFile> fetchDataCygnet(int id, double timestamp);
-    std::string iswaUrl(int id, double timestamp = Time::ref().j2000Seconds(), std::string type = "image");
+    std::string iswaUrl(int id, double timestamp = OsEng.timeManager().time().j2000Seconds(), std::string type = "image");
 
     std::shared_ptr<IswaBaseGroup> iswaGroup(std::string name);
     
diff --git a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
index 797ab6e88a..b2bb8f51d1 100644
--- a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
+++ b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
@@ -528,8 +528,8 @@ std::vector<unsigned int> RenderableMultiresVolume::getBuffers() {
 }*/
 
 void RenderableMultiresVolume::update(const UpdateData& data) {
-        _timestep++;
-    _time = data.time;
+    _timestep++;
+    _time = data.time.j2000Seconds();
 
     if (_gatheringStats) {
         std::chrono::system_clock::time_point frameEnd = std::chrono::system_clock::now();
diff --git a/modules/newhorizons/rendering/renderablecrawlingline.cpp b/modules/newhorizons/rendering/renderablecrawlingline.cpp
index 9b26b94903..3cb3a1d586 100644
--- a/modules/newhorizons/rendering/renderablecrawlingline.cpp
+++ b/modules/newhorizons/rendering/renderablecrawlingline.cpp
@@ -240,10 +240,10 @@ void RenderableCrawlingLine::update(const UpdateData& data) {
         _source,
         //"ECLIPJ2000",
         "GALACTIC",
-        data.time
+        data.time.j2000Seconds()
     );
 
-    glm::dmat3 tm = SpiceManager::ref().frameTransformationMatrix(_instrumentName, "ECLIPJ2000", data.time);
+    glm::dmat3 tm = SpiceManager::ref().frameTransformationMatrix(_instrumentName, "ECLIPJ2000", data.time.j2000Seconds());
 
     //_positions[SourcePosition] = { 0.f, 0.f, 0.f, 0.f };
 
diff --git a/modules/newhorizons/rendering/renderablefov.cpp b/modules/newhorizons/rendering/renderablefov.cpp
index ffea6bb70f..33d7e51270 100644
--- a/modules/newhorizons/rendering/renderablefov.cpp
+++ b/modules/newhorizons/rendering/renderablefov.cpp
@@ -409,7 +409,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
         if (!isInFov) {
             // If the target is not in the field of view, we don't need to perform any
             // surface intercepts
-            glm::vec3 o = orthogonalProjection(bound, data.time, target);
+            glm::vec3 o = orthogonalProjection(bound, data.time.j2000Seconds(), target);
 
             second = {
                 { o.x, o.y, o.z },
@@ -426,7 +426,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                 _instrument.name,
                 ref.first,
                 _instrument.aberrationCorrection,
-                data.time,
+                data.time.j2000Seconds(),
                 bound
             );
 
@@ -443,7 +443,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                     r.surfaceVector = SpiceManager::ref().frameTransformationMatrix(
                         ref.first,
                         _instrument.referenceFrame,
-                        data.time
+                        data.time.j2000Seconds()
                     ) * r.surfaceVector;
                 }
 
@@ -460,7 +460,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
             }
             else {
                 // This point did not intersect the target though others did
-                glm::vec3 o = orthogonalProjection(bound, data.time, target);
+                glm::vec3 o = orthogonalProjection(bound, data.time.j2000Seconds(), target);
                 second = {
                     { o.x, o.y, o.z },
                     RenderInformation::VertexColorTypeInFieldOfView
@@ -516,7 +516,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                     _instrument.name,
                     makeBodyFixedReferenceFrame(_instrument.referenceFrame).first,
                     _instrument.aberrationCorrection,
-                    data.time,
+                    data.time.j2000Seconds(),
                     probe
                 ).interceptFound;
             };
@@ -531,7 +531,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                     _instrument.name,
                     ref.first,
                     _instrument.aberrationCorrection,
-                    data.time,
+                    data.time.j2000Seconds(),
                     probe
                 );
 
@@ -539,7 +539,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                     r.surfaceVector = SpiceManager::ref().frameTransformationMatrix(
                         ref.first,
                         _instrument.referenceFrame,
-                        data.time
+                        data.time.j2000Seconds()
                     ) * r.surfaceVector;
                 }
 
@@ -561,7 +561,7 @@ void RenderableFov::computeIntercepts(const UpdateData& data, const std::string&
                     };
                 }
                 else {
-                    const glm::vec3 o = orthogonalProjection(tBound, data.time, target);
+                    const glm::vec3 o = orthogonalProjection(tBound, data.time.j2000Seconds(), target);
 
                     _orthogonalPlane.data[indexForBounds(i) + m] = {
                         { o.x, o.y, o.z },
@@ -1003,8 +1003,8 @@ void RenderableFov::update(const UpdateData& data) {
         _drawFOV = ImageSequencer::ref().instrumentActive(_instrument.name);
     }
 
-    if (_drawFOV && !data.timePaused) {
-        auto t = determineTarget(data.time);
+    if (_drawFOV && !data.time.paused()) {
+        auto t = determineTarget(data.time.j2000Seconds());
         std::string target = t.first;
         bool inFOV = t.second;
 
@@ -1012,7 +1012,7 @@ void RenderableFov::update(const UpdateData& data) {
         updateGPU();
 
         double t2 = (ImageSequencer::ref().getNextCaptureTime());
-        double diff = (t2 - data.time);
+        double diff = (t2 - data.time.j2000Seconds());
         _interpolationTime = 0.0;
         float interpolationStart = 7.0; //seconds before
         if (diff <= interpolationStart) {
diff --git a/modules/newhorizons/rendering/renderablemodelprojection.cpp b/modules/newhorizons/rendering/renderablemodelprojection.cpp
index 150ddafd6e..6523f3827d 100644
--- a/modules/newhorizons/rendering/renderablemodelprojection.cpp
+++ b/modules/newhorizons/rendering/renderablemodelprojection.cpp
@@ -277,7 +277,7 @@ void RenderableModelProjection::update(const UpdateData& data) {
     if (_depthFboProgramObject->isDirty())
         _depthFboProgramObject->rebuildFromFile();
 
-    _time = data.time;
+    _time = data.time.j2000Seconds();
 
     if (openspace::ImageSequencer::ref().isReady()) {
         openspace::ImageSequencer::ref().updateSequencer(_time);
diff --git a/modules/newhorizons/rendering/renderableplaneprojection.cpp b/modules/newhorizons/rendering/renderableplaneprojection.cpp
index a9a3917f3b..adc506b196 100644
--- a/modules/newhorizons/rendering/renderableplaneprojection.cpp
+++ b/modules/newhorizons/rendering/renderableplaneprojection.cpp
@@ -159,7 +159,7 @@ void RenderablePlaneProjection::render(const RenderData& data) {
 }
 
 void RenderablePlaneProjection::update(const UpdateData& data) {
-    double time = data.time;
+    double time = data.time.j2000Seconds();
     const Image img = openspace::ImageSequencer::ref().getLatestImageForInstrument(_instrument);
     
     if (img.path == "")
diff --git a/modules/newhorizons/rendering/renderableplanetprojection.cpp b/modules/newhorizons/rendering/renderableplanetprojection.cpp
index 5a24935b7c..ae891c31d7 100644
--- a/modules/newhorizons/rendering/renderableplanetprojection.cpp
+++ b/modules/newhorizons/rendering/renderableplanetprojection.cpp
@@ -32,7 +32,6 @@
 #include <openspace/rendering/renderengine.h>
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/util/factorymanager.h>
-#include <openspace/util/time.h>
 
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/io/texture/texturereader.h>
@@ -465,7 +464,7 @@ void RenderablePlanetProjection::update(const UpdateData& data) {
 
     _projectionComponent.update();
 
-    _time = Time::ref().j2000Seconds();
+    _time = data.time.j2000Seconds();
     _capture = false;
 
     if (openspace::ImageSequencer::ref().isReady()){
diff --git a/modules/newhorizons/rendering/renderableshadowcylinder.cpp b/modules/newhorizons/rendering/renderableshadowcylinder.cpp
index 72e8206064..7e9c23d5dc 100644
--- a/modules/newhorizons/rendering/renderableshadowcylinder.cpp
+++ b/modules/newhorizons/rendering/renderableshadowcylinder.cpp
@@ -137,11 +137,11 @@ void RenderableShadowCylinder::render(const RenderData& data){
 }
 
 void RenderableShadowCylinder::update(const UpdateData& data) {
-    _stateMatrix = SpiceManager::ref().positionTransformMatrix(_bodyFrame, _mainFrame, data.time);
+    _stateMatrix = SpiceManager::ref().positionTransformMatrix(_bodyFrame, _mainFrame, data.time.j2000Seconds());
     if (_shader->isDirty()) {
         _shader->rebuildFromFile();
     }
-    createCylinder(data.time);
+    createCylinder(data.time.j2000Seconds());
 }
 
 glm::vec4 psc_addition(glm::vec4 v1, glm::vec4 v2) {
diff --git a/modules/newhorizons/util/imagesequencer.cpp b/modules/newhorizons/util/imagesequencer.cpp
index 18899828ea..2f72aa275f 100644
--- a/modules/newhorizons/util/imagesequencer.cpp
+++ b/modules/newhorizons/util/imagesequencer.cpp
@@ -28,6 +28,8 @@
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>
 #include <openspace/util/time.h>
+#include <openspace/util/timemanager.h>
+#include <openspace/engine/openspaceengine.h>
 #include <ghoul/filesystem/cachemanager.h>
 #include <modules/newhorizons/util/decoder.h>
 
@@ -83,14 +85,10 @@ bool ImageSequencer::isReady() {
     return _hasData;
 }
 
-void ImageSequencer::updateSequencer(double time) {
-    if (Time::ref().timeJumped() && Time::ref().deltaTime() == 0) {
-        Time::ref().setDeltaTime(0.1);
-    } // Time is not properly updated when time jump with dt = 0 
-
-    if (_currentTime != time) {
+void ImageSequencer::updateSequencer(const Time& time) {
+    if (_currentTime != time.j2000Seconds()) {
         _previousTime = _currentTime;
-        _currentTime = time;
+        _currentTime = time.j2000Seconds();
     }
 }
 
@@ -279,7 +277,7 @@ bool ImageSequencer::getImagePaths(std::vector<Image>& captures,
 
     // check if this instance is either in range or 
     // a valid candidate to recieve data 
-    if (!instrumentActive(instrumentRequest) && !Time::ref().timeJumped()) return false;
+    if (!instrumentActive(instrumentRequest) && !OsEng.timeManager().time().timeJumped()) return false;
 
 
     //if (!Time::ref().timeJumped() && projectee == getCurrentTarget().second)
diff --git a/modules/newhorizons/util/imagesequencer.h b/modules/newhorizons/util/imagesequencer.h
index 3f776c68ad..8364c099c7 100644
--- a/modules/newhorizons/util/imagesequencer.h
+++ b/modules/newhorizons/util/imagesequencer.h
@@ -34,6 +34,7 @@
 
 namespace openspace {
 
+class Time;
 class SequenceParser;
 
 /**
@@ -79,7 +80,7 @@ public:
      * Updates sequencer with current <code>time</code>. This is used internally for keeping
      * track of both current simulation time and the time of the previously rendered frame.  
      */    
-    void updateSequencer(double time);
+    void updateSequencer(const Time& time);
     /**
     * Runs parser and recieves the datastructures filled by it. 
     * \see SequenceParser
diff --git a/modules/onscreengui/onscreenguimodule.cpp b/modules/onscreengui/onscreenguimodule.cpp
index 051801b4b6..a06c05eb59 100644
--- a/modules/onscreengui/onscreenguimodule.cpp
+++ b/modules/onscreengui/onscreenguimodule.cpp
@@ -31,6 +31,7 @@
 #include <openspace/engine/virtualpropertymanager.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/interaction/interactionhandler.h>
+#include <openspace/interaction/luaconsole.h>
 #include <openspace/network/parallelconnection.h>
 #include <openspace/rendering/renderengine.h>
 #include <openspace/rendering/screenspacerenderable.h>
@@ -61,7 +62,8 @@ OnScreenGUIModule::OnScreenGUIModule()
                         &(OsEng.settingsEngine()),
                         &(OsEng.interactionHandler()),
                         &(OsEng.renderEngine()),
-                        &(OsEng.parallelConnection())
+                        &(OsEng.parallelConnection()),
+                        &(OsEng.console())
                     };
                     return res;
                 }
diff --git a/modules/onscreengui/src/gui.cpp b/modules/onscreengui/src/gui.cpp
index e114c2d8df..7a44eb4583 100644
--- a/modules/onscreengui/src/gui.cpp
+++ b/modules/onscreengui/src/gui.cpp
@@ -229,7 +229,7 @@ GUI::GUI()
     , _property("Properties")
     , _screenSpaceProperty("ScreenSpace Properties")
     , _virtualProperty("Virtual Properties")
-    , _currentVisibility(properties::Property::Visibility::All)
+    , _currentVisibility(properties::Property::Visibility::Developer)
 {
     addPropertySubOwner(_help);
     addPropertySubOwner(_origin);
@@ -634,7 +634,7 @@ void GUI::renderAndUpdatePropertyVisibility() {
     int t = static_cast<std::underlying_type_t<V>>(_currentVisibility);
 
     // Array is sorted by importance
-    std::array<const char*, 4> items = { "None", "User", "Developer", "All"};
+    std::array<const char*, 4> items = { "User", "Developer", "Hidden", "All"};
     ImGui::Combo("PropertyVisibility", &t, items.data(), static_cast<int>(items.size()));
 
     _currentVisibility = static_cast<V>(t);
diff --git a/modules/onscreengui/src/guiparallelcomponent.cpp b/modules/onscreengui/src/guiparallelcomponent.cpp
index 6ad99aec77..d865f7f0b1 100644
--- a/modules/onscreengui/src/guiparallelcomponent.cpp
+++ b/modules/onscreengui/src/guiparallelcomponent.cpp
@@ -82,11 +82,11 @@ void GuiParallelComponent::renderClientWithHost() {
     ImGui::Text("%s", connectionInfo.c_str());
     renderClientCommon();
 
-    const std::deque<datamessagestructures::TimeKeyframe> timeKeyframes = OsEng.timeManager().keyframes();
-    const std::vector<datamessagestructures::CameraKeyframe> cameraKeyframes = OsEng.interactionHandler().keyframes();
+    const size_t nTimeKeyframes = OsEng.timeManager().nKeyframes();
+    const size_t nCameraKeyframes = OsEng.interactionHandler().nKeyframes();
 
-    std::string timeKeyframeInfo = "TimeKeyframes : " + std::to_string(timeKeyframes.size());
-    std::string cameraKeyframeInfo = "CameraKeyframes : " + std::to_string(cameraKeyframes.size());
+    std::string timeKeyframeInfo = "TimeKeyframes : " + std::to_string(nTimeKeyframes);
+    std::string cameraKeyframeInfo = "CameraKeyframes : " + std::to_string(nCameraKeyframes);
     std::string latencyStandardDeviation = "Latency standard deviation: " + std::to_string(parallel.latencyStandardDeviation()) + " s";
 
     const bool resetTimeOffset = ImGui::Button("Reset time offset");
diff --git a/modules/onscreengui/src/guitimecomponent.cpp b/modules/onscreengui/src/guitimecomponent.cpp
index 29ad93e8ce..46ed240f2e 100644
--- a/modules/onscreengui/src/guitimecomponent.cpp
+++ b/modules/onscreengui/src/guitimecomponent.cpp
@@ -25,6 +25,7 @@
 #include <modules/onscreengui/include/guitimecomponent.h>
 
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/time.h>
 
 #include "imgui.h"
@@ -37,7 +38,7 @@ GuiTimeComponent::GuiTimeComponent()
 {}
 
 void GuiTimeComponent::render() {
-    float deltaTime = static_cast<float>(Time::ref().deltaTime());
+    float deltaTime = static_cast<float>(OsEng.timeManager().time().deltaTime());
     
     bool changed = ImGui::SliderFloat("Delta Time", &deltaTime, -50000.f, 50000.f);
     if (changed) {
diff --git a/modules/onscreengui/src/renderproperties.cpp b/modules/onscreengui/src/renderproperties.cpp
index 0e4ad7b3e3..0c7855e279 100644
--- a/modules/onscreengui/src/renderproperties.cpp
+++ b/modules/onscreengui/src/renderproperties.cpp
@@ -407,13 +407,22 @@ void renderVec3Property(Property* prop, const std::string& ownerName,
     float max = std::max(std::max(p->maxValue().x, p->maxValue().y), p->maxValue().z);
 
 
-    ImGui::SliderFloat3(
-        name.c_str(),
-        glm::value_ptr(value),
-        min,
-        max,
-        "%.5f"
-    );
+
+    if (prop->viewOption(Property::ViewOptions::Color)) {
+        ImGui::ColorEdit3(
+            name.c_str(),
+            glm::value_ptr(value)
+        );
+    }
+    else {
+        ImGui::SliderFloat3(
+            name.c_str(),
+            glm::value_ptr(value),
+            min,
+            max,
+            "%.5f"
+        );
+    }
     renderTooltip(prop);
 
     if (value != p->value()) {
@@ -443,13 +452,22 @@ void renderVec4Property(Property* prop, const std::string& ownerName,
     float max = std::max(std::max(std::max(
         p->maxValue().x, p->maxValue().y), p->maxValue().z), p->maxValue().w);
 
-    ImGui::SliderFloat4(
-        name.c_str(),
-        &value.x,
-        min,
-        max,
-        "%.5f"
-    );
+    if (prop->viewOption(Property::ViewOptions::Color)) {
+        ImGui::ColorEdit4(
+            name.c_str(),
+            glm::value_ptr(value)
+        );
+    }
+    else {
+        ImGui::SliderFloat4(
+            name.c_str(),
+            glm::value_ptr(value),
+            min,
+            max,
+            "%.5f"
+        );
+    }
+
     renderTooltip(prop);
 
     if (value != p->value()) {
diff --git a/modules/space/rendering/renderableconstellationbounds.cpp b/modules/space/rendering/renderableconstellationbounds.cpp
index 50dc8a5ac8..7ca4845725 100644
--- a/modules/space/rendering/renderableconstellationbounds.cpp
+++ b/modules/space/rendering/renderableconstellationbounds.cpp
@@ -211,7 +211,7 @@ void RenderableConstellationBounds::update(const UpdateData& data) {
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(
         _originReferenceFrame,
         "GALACTIC",
-        data.time
+        data.time.j2000Seconds()
     );
 }
 
diff --git a/modules/space/rendering/renderableplanet.cpp b/modules/space/rendering/renderableplanet.cpp
index 86112565d8..909936372d 100644
--- a/modules/space/rendering/renderableplanet.cpp
+++ b/modules/space/rendering/renderableplanet.cpp
@@ -531,7 +531,7 @@ void RenderablePlanet::update(const UpdateData& data) {
     // set spice-orientation in accordance to timestamp
     _stateMatrix = data.modelTransform.rotation;
     //_stateMatrix = SpiceManager::ref().positionTransformMatrix(_frame, "GALACTIC", data.time);
-    _time = data.time;
+    _time = data.time.j2000Seconds();
 }
 
 void RenderablePlanet::loadTexture() {
diff --git a/modules/space/rotation/spicerotation.cpp b/modules/space/rotation/spicerotation.cpp
index 4e3cb87bda..1e36301f21 100644
--- a/modules/space/rotation/spicerotation.cpp
+++ b/modules/space/rotation/spicerotation.cpp
@@ -119,7 +119,7 @@ void SpiceRotation::update(const UpdateData& data) {
         _matrix = SpiceManager::ref().positionTransformMatrix(
             _sourceFrame,
             _destinationFrame,
-            data.time
+            data.time.j2000Seconds()
         );
     }
     catch (const SpiceManager::SpiceException&) {
diff --git a/modules/space/translation/keplertranslation.cpp b/modules/space/translation/keplertranslation.cpp
index 8b2156ce65..cdfc67e02e 100644
--- a/modules/space/translation/keplertranslation.cpp
+++ b/modules/space/translation/keplertranslation.cpp
@@ -267,7 +267,7 @@ void KeplerTranslation::update(const UpdateData& data) {
         _orbitPlaneDirty = false;
     }
 
-    double t = data.time - _epoch;
+    double t = data.time.j2000Seconds() - _epoch;
     double meanMotion = 2.0 * glm::pi<double>() / _period;
     double meanAnomaly = glm::radians(_meanAnomalyAtEpoch.value()) + t * meanMotion;
     double e = eccentricAnomaly(meanAnomaly);
diff --git a/modules/space/translation/spicetranslation.cpp b/modules/space/translation/spicetranslation.cpp
index c6530d767d..f4924f4341 100644
--- a/modules/space/translation/spicetranslation.cpp
+++ b/modules/space/translation/spicetranslation.cpp
@@ -166,7 +166,7 @@ glm::dvec3 SpiceTranslation::position() const {
 void SpiceTranslation::update(const UpdateData& data) {
     double lightTime = 0.0;
     _position = SpiceManager::ref().targetPosition(
-        _target, _origin, _frame, {}, data.time, lightTime
+        _target, _origin, _frame, {}, data.time.j2000Seconds(), lightTime
     ) * glm::pow(10.0, 3.0);
 }
 
diff --git a/modules/toyvolume/rendering/renderabletoyvolume.cpp b/modules/toyvolume/rendering/renderabletoyvolume.cpp
index 0f16045129..e5df97b9cf 100644
--- a/modules/toyvolume/rendering/renderabletoyvolume.cpp
+++ b/modules/toyvolume/rendering/renderabletoyvolume.cpp
@@ -121,7 +121,7 @@ void RenderableToyVolume::update(const UpdateData& data) {
         _raycaster->setColor(_color);
         _raycaster->setStepSize(_stepSize);
         _raycaster->setModelTransform(transform);
-        _raycaster->setTime(data.time);
+        _raycaster->setTime(data.time.j2000Seconds());
     }
 }
 
diff --git a/openspace.cfg b/openspace.cfg
index ad2bb2000f..1825a6ec82 100644
--- a/openspace.cfg
+++ b/openspace.cfg
@@ -52,7 +52,8 @@ return {
     },
     Fonts = {
         Mono = "${FONTS}/Droid_Sans_Mono/DroidSansMono.ttf",
-        Light = "${FONTS}/Roboto/Roboto-Regular.ttf"
+        Light = "${FONTS}/Roboto/Roboto-Regular.ttf",
+        Console = "${FONTS}/Inconsolata/Inconsolata-Regular.ttf"
     },
     Logging = {
         -- LogLevel = "Trace",
@@ -63,6 +64,9 @@ return {
         },
         CapabilitiesVerbosity = "Full"
     },
+    Launcher = {
+        LogLevel="None"
+    },
     LuaDocumentation = "${DOCUMENTATION}/LuaScripting.html",
     PropertyDocumentation = "${DOCUMENTATION}/Properties.html",
     ScriptLog = "${BASE_PATH}/ScriptLog.txt",
diff --git a/shaders/luaconsole.frag b/shaders/luaconsole.frag
new file mode 100644
index 0000000000..4389d09921
--- /dev/null
+++ b/shaders/luaconsole.frag
@@ -0,0 +1,9 @@
+#version __CONTEXT__
+
+out vec4 FragColor;
+
+uniform vec4 color;
+
+void main() {
+    FragColor = color;
+}
diff --git a/shaders/luaconsole.vert b/shaders/luaconsole.vert
new file mode 100644
index 0000000000..fcb1bc6710
--- /dev/null
+++ b/shaders/luaconsole.vert
@@ -0,0 +1,14 @@
+#version __CONTEXT__
+
+in vec2 in_position;
+
+uniform float height;
+uniform ivec2 res;
+
+uniform mat4 ortho;
+
+void main() {
+    float y = float(res.y) - in_position.y * height * res.y;
+
+    gl_Position = ortho * vec4(in_position.x * res.x, y, 0.0, 1.0);
+}
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 35f60de8ef..748ed0f325 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -156,6 +156,7 @@ set(OPENSPACE_SOURCE
     ${OPENSPACE_BASE_DIR}/src/util/task.cpp
     ${OPENSPACE_BASE_DIR}/src/util/taskloader.cpp
     ${OPENSPACE_BASE_DIR}/src/util/time.cpp
+    ${OPENSPACE_BASE_DIR}/src/util/timeline.cpp
     ${OPENSPACE_BASE_DIR}/src/util/timemanager.cpp
     ${OPENSPACE_BASE_DIR}/src/util/time_lua.inl
     ${OPENSPACE_BASE_DIR}/src/util/timerange.cpp
@@ -303,6 +304,8 @@ set(OPENSPACE_HEADER
     ${OPENSPACE_BASE_DIR}/include/openspace/util/task.h
     ${OPENSPACE_BASE_DIR}/include/openspace/util/taskloader.h
     ${OPENSPACE_BASE_DIR}/include/openspace/util/time.h
+    ${OPENSPACE_BASE_DIR}/include/openspace/util/timeline.h
+    ${OPENSPACE_BASE_DIR}/include/openspace/util/timeline.inl
     ${OPENSPACE_BASE_DIR}/include/openspace/util/timemanager.h
     ${OPENSPACE_BASE_DIR}/include/openspace/util/timerange.h
     ${OPENSPACE_BASE_DIR}/include/openspace/util/updatestructures.h
diff --git a/src/engine/configurationmanager.cpp b/src/engine/configurationmanager.cpp
index 514719b2c3..71c7b32e58 100644
--- a/src/engine/configurationmanager.cpp
+++ b/src/engine/configurationmanager.cpp
@@ -68,6 +68,8 @@ const string ConfigurationManager::PartLogs = "Logs";
 const string ConfigurationManager::PartAppend = "Append";
 const string ConfigurationManager::PartCapabilitiesVerbosity = "CapabilitiesVerbosity";
 
+const string ConfigurationManager::KeyLauncher = "Launcher";
+
 const string ConfigurationManager::KeyCapabilitiesVerbosity =
     KeyLogging + "." + PartCapabilitiesVerbosity;
 
diff --git a/src/engine/configurationmanager_doc.inl b/src/engine/configurationmanager_doc.inl
index e47a9d9c39..e955c50c75 100644
--- a/src/engine/configurationmanager_doc.inl
+++ b/src/engine/configurationmanager_doc.inl
@@ -186,6 +186,25 @@ documentation::Documentation ConfigurationManager::Documentation() {
             "location will be silently overritten.",
             Optional::Yes
         },
+        {
+            ConfigurationManager::KeyLauncher,
+            new TableVerifier({
+                {
+                    ConfigurationManager::PartLogLevel,
+                    new StringInListVerifier(
+                    // List from logmanager.cpp::levelFromString
+                    { "Trace", "Debug", "Info", "Warning", "Error", "Fatal", "None" }
+                    ),
+                    "The severity of log messages that will be displayed. Only "
+                    "messages of the selected level or higher will be displayed. All "
+                    "levels below will be silently discarded. The order of "
+                    "severities is: Debug < Info < Warning < Error < Fatal < None.",
+                    Optional::Yes
+                },
+            }),
+            "Configurations for the Launcher & syncing application.",
+            Optional::Yes
+        },
         {
             ConfigurationManager::KeyShutdownCountdown,
             new DoubleGreaterEqualVerifier(0.0),
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index 9a96c49899..3e8f0a6737 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -152,6 +152,7 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     _globalPropertyNamespace->addPropertySubOwner(_renderEngine.get());
     _globalPropertyNamespace->addPropertySubOwner(_windowWrapper.get());
     _globalPropertyNamespace->addPropertySubOwner(_parallelConnection.get());
+    _globalPropertyNamespace->addPropertySubOwner(_console.get());
 
     FactoryManager::initialize();
     FactoryManager::ref().addFactory(
@@ -176,7 +177,6 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
     );
 
     SpiceManager::initialize();
-    Time::initialize();
     TransformationManager::initialize();
 }
 
@@ -346,7 +346,6 @@ void OpenSpaceEngine::create(int argc, char** argv,
     FileSys.createCacheManager(
         absPath("${" + ConfigurationManager::KeyCache + "}"), CacheVersion
     );
-    _engine->_console->initialize();
 
     // Register the provided shader directories
     ghoul::opengl::ShaderPreprocessor::addIncludePath(absPath("${SHADERS}"));
@@ -384,7 +383,7 @@ void OpenSpaceEngine::destroy() {
         func();
     }
 
-    _engine->_syncEngine->removeSyncables(Time::ref().getSyncables());
+    _engine->_syncEngine->removeSyncables(_engine->timeManager().getSyncables());
     _engine->_syncEngine->removeSyncables(_engine->_renderEngine->getSyncables());
     _engine->_syncEngine->removeSyncable(_engine->_scriptEngine.get());
 
@@ -396,7 +395,6 @@ void OpenSpaceEngine::destroy() {
 
     delete _engine;
     FactoryManager::deinitialize();
-    Time::deinitialize();
     SpiceManager::deinitialize();
 
 
@@ -563,7 +561,7 @@ void OpenSpaceEngine::loadScene(const std::string& scenePath) {
 
     Scene* previousScene = _renderEngine->scene();
     if (previousScene) {
-        _syncEngine->removeSyncables(Time::ref().getSyncables());
+        _syncEngine->removeSyncables(_timeManager->getSyncables());
         _syncEngine->removeSyncables(_renderEngine->getSyncables());
         _syncEngine->removeSyncable(_scriptEngine.get());
 
@@ -606,7 +604,7 @@ void OpenSpaceEngine::loadScene(const std::string& scenePath) {
         );
     }
 
-    _syncEngine->addSyncables(Time::ref().getSyncables());
+    _syncEngine->addSyncables(_timeManager->getSyncables());
     _syncEngine->addSyncables(_renderEngine->getSyncables());
     _syncEngine->addSyncable(_scriptEngine.get());
 
@@ -843,6 +841,8 @@ void OpenSpaceEngine::configureLogging() {
 void OpenSpaceEngine::initializeGL() {
     LTRACE("OpenSpaceEngine::initializeGL(begin)");
 
+    _engine->_console->initialize();
+
     const std::string key = ConfigurationManager::KeyOpenGLDebugContext;
     if (_configurationManager->hasKey(key)) {
         ghoul::Dictionary dict = _configurationManager->value<ghoul::Dictionary>(key);
@@ -994,7 +994,7 @@ void OpenSpaceEngine::preSynchronization() {
         double dt = _windowWrapper->averageDeltaTime();
         _timeManager->preSynchronization(dt);
 
-        auto scheduledScripts = _scriptScheduler->progressTo(Time::ref().j2000Seconds());
+        auto scheduledScripts = _scriptScheduler->progressTo(timeManager().time().j2000Seconds());
         for (auto it = scheduledScripts.first; it != scheduledScripts.second; ++it) {
             _scriptEngine->queueScript(
                 *it, ScriptEngine::RemoteScripting::Yes
@@ -1073,17 +1073,24 @@ void OpenSpaceEngine::render(const glm::mat4& sceneMatrix,
                              const glm::mat4& viewMatrix,
                              const glm::mat4& projectionMatrix)
 {
+
+    bool isGuiWindow = _windowWrapper->hasGuiWindow() ? _windowWrapper->isGuiWindow() : true;
+    bool showOverlay = isGuiWindow && _windowWrapper->isMaster() && _windowWrapper->isRegularRendering();
+    // @CLEANUP:  Replace the two windows by a single call to whether a gui should be
+    // rendered ---abock
+
+    if (showOverlay) {
+        _console->update();
+    }
+
     LTRACE("OpenSpaceEngine::render(begin)");
     _renderEngine->render(sceneMatrix, viewMatrix, projectionMatrix);
     
     for (const auto& func : _moduleCallbacks.render) {
         func();
     }
-    
-    // @CLEANUP:  Replace the two windows by a single call to whether a gui should be
-    // rendered ---abock
-    bool showGui = _windowWrapper->hasGuiWindow() ? _windowWrapper->isGuiWindow() : true;
-    if (showGui && _windowWrapper->isMaster() && _windowWrapper->isRegularRendering()) {
+
+    if (showOverlay) {
         _renderEngine->renderScreenLog();
         _console->render();
     }
diff --git a/src/interaction/interactionhandler.cpp b/src/interaction/interactionhandler.cpp
index 82d8311d1a..76b9817bd7 100644
--- a/src/interaction/interactionhandler.cpp
+++ b/src/interaction/interactionhandler.cpp
@@ -60,6 +60,15 @@ namespace {
     const char* MainTemplateFilename = "${OPENSPACE_DATA}/web/keybindings/main.hbs";
     const char* KeybindingTemplateFilename = "${OPENSPACE_DATA}/web/keybindings/keybinding.hbs";
     const char* JsFilename = "${OPENSPACE_DATA}/web/keybindings/script.js";
+    
+    const int IdOrbitalInteractionMode = 0;
+    const char* KeyOrbitalInteractionMode = "Orbital";
+    
+    const int IdGlobeBrowsingInteractionMode = 1;
+    const char* KeyGlobeBrowsingInteractionMode = "GlobeBrowsing";
+    
+    const int IdKeyframeInteractionMode = 2;
+    const char* KeyKeyframeInteractionMode = "Keyframe";
 } // namespace
 
 #include "interactionhandler_lua.inl"
@@ -85,6 +94,11 @@ InteractionHandler::InteractionHandler()
     , _verticalFriction("verticalFriction", "Vertical Friction", true)
     , _sensitivity("sensitivity", "Sensitivity", 0.5f, 0.001f, 1.f)
     , _rapidness("rapidness", "Rapidness", 1.f, 0.1f, 60.f)
+    , _interactionModeOption(
+          "interactionMode",
+          "Interaction Mode",
+          properties::OptionProperty::DisplayType::Dropdown
+      )
 {
     _origin.onChange([this]() {
         SceneGraphNode* node = sceneGraphNode(_origin.value());
@@ -100,24 +114,17 @@ InteractionHandler::InteractionHandler()
     _inputState = std::make_unique<InputState>();
     // Inject the same mouse states to both orbital and global interaction mode
     _mouseStates = std::make_unique<OrbitalInteractionMode::MouseStates>(_sensitivity * pow(10.0,-4), 1);
-    _interactionModes.insert(
-        std::pair<std::string, std::shared_ptr<InteractionMode>>(
-            "Orbital",
-            std::make_shared<OrbitalInteractionMode>(_mouseStates)
-            ));
-    _interactionModes.insert(
-        std::pair<std::string, std::shared_ptr<InteractionMode>>(
-            "GlobeBrowsing",
-            std::make_shared<GlobeBrowsingInteractionMode>(_mouseStates)
-            ));
-    _interactionModes.insert(
-        std::pair<std::string, std::shared_ptr<InteractionMode>>(
-            "Keyframe",
-            std::make_shared<KeyframeInteractionMode>()
-            ));
+
+    _orbitalInteractionMode = std::make_unique<OrbitalInteractionMode>(_mouseStates);
+    _globeBrowsingInteractionMode = std::make_unique<GlobeBrowsingInteractionMode>(_mouseStates);
+    _keyframeInteractionMode = std::make_unique<KeyframeInteractionMode>();
+
+    _interactionModeOption.addOption(IdOrbitalInteractionMode, KeyOrbitalInteractionMode);
+    _interactionModeOption.addOption(IdGlobeBrowsingInteractionMode, KeyGlobeBrowsingInteractionMode);
+    _interactionModeOption.addOption(IdKeyframeInteractionMode, KeyKeyframeInteractionMode);
 
     // Set the interactionMode
-    _currentInteractionMode = _interactionModes["Orbital"];
+    _currentInteractionMode = _orbitalInteractionMode.get();
 
     // Define lambda functions for changed properties
     _rotationalFriction.onChange([&]() {
@@ -136,8 +143,25 @@ InteractionHandler::InteractionHandler()
         _mouseStates->setVelocityScaleFactor(_rapidness);
     });
 
+    _interactionModeOption.onChange([this]() {
+        switch(_interactionModeOption.value()) {
+        case IdGlobeBrowsingInteractionMode:
+             setInteractionMode(_globeBrowsingInteractionMode.get());
+            break;
+        case IdKeyframeInteractionMode:
+            setInteractionMode(_keyframeInteractionMode.get());
+            break;
+        case IdOrbitalInteractionMode:
+        default:
+           setInteractionMode(_orbitalInteractionMode.get());
+           break;
+        }
+    });
+
+    
     // Add the properties
     addProperty(_origin);
+    addProperty(_interactionModeOption);
 
     addProperty(_rotationalFriction);
     addProperty(_horizontalFriction);
@@ -153,14 +177,9 @@ InteractionHandler::~InteractionHandler() {
 void InteractionHandler::initialize() {
     OsEng.parallelConnection().connectionEvent()->subscribe("interactionHandler", "statusChanged", [this]() {
         if (OsEng.parallelConnection().status() == ParallelConnection::Status::ClientWithHost) {
-            setInteractionMode("Keyframe");
-        } else {
-            auto keyframeModeIter = _interactionModes.find("Keyframe");
-            if (keyframeModeIter != _interactionModes.end()) {
-                if (_currentInteractionMode == keyframeModeIter->second) {
-                    setInteractionMode("Orbital");
-                }
-            }
+            setInteractionMode(_keyframeInteractionMode.get());
+        } else if (_currentInteractionMode == _keyframeInteractionMode.get()) {
+            setInteractionMode(_orbitalInteractionMode.get());
         }
     });
 }
@@ -183,7 +202,7 @@ void InteractionHandler::resetCameraDirection() {
     _currentInteractionMode->rotateToFocusNodeInterpolator().start();
 }
 
-void InteractionHandler::setInteractionMode(std::shared_ptr<InteractionMode> interactionMode) {
+void InteractionHandler::setInteractionMode(InteractionMode* interactionMode) {
     // Focus node is passed over from the previous interaction mode
     SceneGraphNode* focusNode = _currentInteractionMode->focusNode();
 
@@ -195,31 +214,13 @@ void InteractionHandler::setInteractionMode(std::shared_ptr<InteractionMode> int
 }
 
 InteractionMode * InteractionHandler::interactionMode() {
-    return _currentInteractionMode.get();
+    return _currentInteractionMode;
 }
 
-void InteractionHandler::setInteractionMode(const std::string& interactionModeKey) {
-    if (_interactionModes.find(interactionModeKey) != _interactionModes.end()) {
-        setInteractionMode(_interactionModes[interactionModeKey]);
-        LINFO("Interaction mode set to '" << interactionModeKey << "'");
-    }
-    else {
-        std::string listInteractionModes("");
-        for (auto pair : _interactionModes) {
-            listInteractionModes += "'" + pair.first + "', ";
-        }
-        LWARNING("'" << interactionModeKey <<
-            "' is not a valid interaction mode. Candidates are " << listInteractionModes);
-    }
-}
-    
 void InteractionHandler::goToChunk(int x, int y, int level) {
-    std::shared_ptr<GlobeBrowsingInteractionMode> gbim =
-        std::dynamic_pointer_cast<GlobeBrowsingInteractionMode> (_currentInteractionMode);
-    
-    if (gbim) {
+    if (_currentInteractionMode == _globeBrowsingInteractionMode.get()) {
 #ifdef OPENSPACE_MODULE_GLOBEBROWSING_ENABLED
-        gbim->goToChunk(*_camera, globebrowsing::TileIndex(x,y,level), glm::vec2(0.5,0.5), true);
+        _globeBrowsingInteractionMode->goToChunk(*_camera, globebrowsing::TileIndex(x,y,level), glm::vec2(0.5,0.5), true);
 #endif
     } else {
         LWARNING("Interaction mode must be set to 'GlobeBrowsing'");
@@ -227,12 +228,9 @@ void InteractionHandler::goToChunk(int x, int y, int level) {
 }
 
 void InteractionHandler::goToGeo(double latitude, double longitude) {
-    std::shared_ptr<GlobeBrowsingInteractionMode> gbim =
-    std::dynamic_pointer_cast<GlobeBrowsingInteractionMode> (_currentInteractionMode);
-        
-    if (gbim) {
+    if (_currentInteractionMode == _globeBrowsingInteractionMode.get()) {
 #ifdef OPENSPACE_MODULE_GLOBEBROWSING_ENABLED
-        gbim->goToGeodetic2(
+        _globeBrowsingInteractionMode->goToGeodetic2(
             *_camera,
             globebrowsing::Geodetic2(latitude, longitude) / 180 * glm::pi<double>(), true
         );
@@ -499,12 +497,6 @@ scripting::LuaLibrary InteractionHandler::luaLibrary() {
                 "that is to be executed, and the optional third argument is a human "
                 "readable description of the command for documentation purposes."
             },
-            {
-                "setInteractionMode",
-                &luascriptfunctions::setInteractionMode,
-                "string",
-                "Set the interaction mode for the camera"
-            },
             {
                 "saveCameraStateToFile",
                 &luascriptfunctions::saveCameraStateToFile,
@@ -539,20 +531,32 @@ scripting::LuaLibrary InteractionHandler::luaLibrary() {
     };
 }
 
-void InteractionHandler::addKeyframe(const datamessagestructures::CameraKeyframe &kf) {
-    _inputState->addKeyframe(kf);
+void InteractionHandler::addKeyframe(double timestamp, KeyframeInteractionMode::CameraPose pose) {
+    if (!_keyframeInteractionMode) {
+        return;
+    }
+    _keyframeInteractionMode->timeline().addKeyframe(timestamp, pose);
 }
 
 void InteractionHandler::removeKeyframesAfter(double timestamp) {
-    _inputState->removeKeyframesAfter(timestamp);
+    if (!_keyframeInteractionMode) {
+        return;
+    }
+    _keyframeInteractionMode->timeline().removeKeyframesAfter(timestamp);
 }
 
 void InteractionHandler::clearKeyframes() {
-    _inputState->clearKeyframes();
+    if (!_keyframeInteractionMode) {
+        return;
+    }
+    _keyframeInteractionMode->timeline().clearKeyframes();
 }
 
-const std::vector<datamessagestructures::CameraKeyframe>& InteractionHandler::keyframes() const {
-    return _inputState->keyframes();
+size_t InteractionHandler::nKeyframes() const {
+    if (!_keyframeInteractionMode) {
+        return 0;
+    }
+    return _keyframeInteractionMode->timeline().keyframes().size();
 }
 
 } // namespace interaction
diff --git a/src/interaction/interactionhandler_lua.inl b/src/interaction/interactionhandler_lua.inl
index 2aa76be37b..34b2db6312 100644
--- a/src/interaction/interactionhandler_lua.inl
+++ b/src/interaction/interactionhandler_lua.inl
@@ -169,28 +169,6 @@ int clearKeys(lua_State* L) {
     return 0;
 }
 
-/**
-* \ingroup LuaScripts
-* setInteractionMode():
-* Set the interaction mode
-*/
-int setInteractionMode(lua_State* L) {
-    using ghoul::lua::luaTypeToString;
-
-    int nArguments = lua_gettop(L);
-    if (nArguments != 1)
-        return luaL_error(L, "Expected %i arguments, got %i", 1, nArguments);
-
-
-    std::string interactionModeKey = luaL_checkstring(L, -1);
-    
-    if (interactionModeKey.empty())
-        return luaL_error(L, "interactionmode name string is empty");
-
-    OsEng.interactionHandler().setInteractionMode(interactionModeKey);
-    return 0;
-}
-
 int goToChunk(lua_State* L) {
     using ghoul::lua::luaTypeToString;
     
diff --git a/src/interaction/interactionmode.cpp b/src/interaction/interactionmode.cpp
index 42992093a1..cfb871bdf5 100644
--- a/src/interaction/interactionmode.cpp
+++ b/src/interaction/interactionmode.cpp
@@ -60,46 +60,6 @@ namespace interaction {
 
     }
 
-    const std::vector<datamessagestructures::CameraKeyframe>& InputState::keyframes() const {
-        return _keyframes;
-    }
-
-    void InputState::addKeyframe(const datamessagestructures::CameraKeyframe &kf) {
-        clearOldKeyframes();
-        if (kf._timestamp < OsEng.runTime()) {
-            return;
-        }
-        _keyframes.insert(std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &InputState::compareKeyframeTimes), kf);
-    }
-
-    void InputState::removeKeyframesAfter(double timestamp) {
-        datamessagestructures::CameraKeyframe kf;
-        kf._timestamp = timestamp;
-        // Remove keyframes after the inserted keyframe.
-        _keyframes.erase(std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &InputState::compareKeyframeTimes), _keyframes.end());
-    }
-
-    bool InputState::compareKeyframeTimes(const datamessagestructures::CameraKeyframe& a, const datamessagestructures::CameraKeyframe& b) {
-        return a._timestamp < b._timestamp;
-    }
-
-    void InputState::clearOldKeyframes() {
-        double now = OsEng.runTime();
-        auto isLater = [now](const datamessagestructures::CameraKeyframe kf) {
-            return kf._timestamp > now;
-        };
-
-        // Remote keyframes with earlier timestamps than the current time.
-        auto nextKeyframe = std::find_if(_keyframes.begin(), _keyframes.end(), isLater);
-        if (nextKeyframe != _keyframes.begin()) {
-            _keyframes.erase(_keyframes.begin(), nextKeyframe - 1);
-        }
-    }
-
-    void InputState::clearKeyframes() {
-        _keyframes.clear();
-    }
-
     void InputState::keyboardCallback(Key key, KeyModifier modifier, KeyAction action) {
         if (action == KeyAction::Press) {
             _keysDown.push_back(std::pair<Key, KeyModifier>(key, modifier));
@@ -205,66 +165,73 @@ Interpolator<double>& InteractionMode::rotateToFocusNodeInterpolator() {
     
     
 // KeyframeInteractionMode
-KeyframeInteractionMode::KeyframeInteractionMode(){
-
+KeyframeInteractionMode::KeyframeInteractionMode()
+{
 }
 
 KeyframeInteractionMode::~KeyframeInteractionMode() {
-
 }
 
-void KeyframeInteractionMode::updateMouseStatesFromInput(const InputState& inputState, double) {
-    _keyframes = inputState.keyframes();
+
+void KeyframeInteractionMode::updateMouseStatesFromInput(const InputState&, double) {
+    // Do nothing.
 }
 
 void KeyframeInteractionMode::updateCameraStateFromMouseStates(Camera& camera, double) {
-    if (_keyframes.size() == 0) {
-        return;
-    }
-
     double now = OsEng.runTime();
-    auto isLater = [now](const datamessagestructures::CameraKeyframe kf) {
-        return kf._timestamp > now;
-    };
 
-    auto nextKeyframe = std::find_if(_keyframes.begin(), _keyframes.end(), isLater);
-    if (nextKeyframe == _keyframes.end()) {
+    if (_cameraPoseTimeline.nKeyframes() == 0) {
         return;
     }
 
-    if (nextKeyframe == _keyframes.begin()) {
-        camera.setPositionVec3(_keyframes[0]._position);
-        camera.setRotation(_keyframes[0]._rotation);
+    const Keyframe<CameraPose>* nextKeyframe = _cameraPoseTimeline.firstKeyframeAfter(now);
+    const Keyframe<CameraPose>* prevKeyframe = _cameraPoseTimeline.lastKeyframeBefore(now);
+    double nextTime = 0;
+    double prevTime = 0;
+    double t = 0;
+
+    if (nextKeyframe) {
+        nextTime = nextKeyframe->timestamp;
+    } else {
         return;
     }
-    auto prevKeyframe = nextKeyframe - 1;
 
-    double prevTime = prevKeyframe->_timestamp;
-    double nextTime = nextKeyframe->_timestamp;
+    if (prevKeyframe) {
+        prevTime = prevKeyframe->timestamp;
+        t = (now - prevTime) / (nextTime - prevTime);
+    } else {
+        // If there is no keyframe before: Only use the next keyframe.
+        prevTime = nextTime;
+        prevKeyframe = nextKeyframe;
+        t = 1;
+    }
 
-    double t = (now - prevTime) / (nextTime - prevTime);
+    _cameraPoseTimeline.removeKeyframesBefore(prevTime);
 
+    const CameraPose& prevPose = prevKeyframe->data;
+    const CameraPose& nextPose = nextKeyframe->data;
+	
     Scene* scene = camera.parent()->scene();
-    SceneGraphNode* prevFocusNode = scene->sceneGraphNode(prevKeyframe->_focusNode);
-    SceneGraphNode* nextFocusNode = scene->sceneGraphNode(nextKeyframe->_focusNode);
+    SceneGraphNode* prevFocusNode = scene->sceneGraphNode(prevPose.focusNode);
+    SceneGraphNode* nextFocusNode = scene->sceneGraphNode(nextPose.focusNode);
 
     if (!prevFocusNode || !nextFocusNode) {
         return;
     }
 
-    glm::dvec3 prevKeyframeCameraPosition = prevKeyframe->_position;
-    glm::dvec3 nextKeyframeCameraPosition = nextKeyframe->_position;
-    glm::dquat prevKeyframeCameraRotation = prevKeyframe->_rotation;
-    glm::dquat nextKeyframeCameraRotation = nextKeyframe->_rotation;
+    glm::dvec3 prevKeyframeCameraPosition = prevPose.position;
+    glm::dvec3 nextKeyframeCameraPosition = nextPose.position;
+    glm::dquat prevKeyframeCameraRotation = prevPose.rotation;
+    glm::dquat nextKeyframeCameraRotation = nextPose.rotation;
 
     // Transform position and rotation based on focus node rotation (if following rotation)
-    if (prevKeyframe->_followNodeRotation) {
-        prevKeyframeCameraRotation = prevFocusNode->worldRotationMatrix() * glm::dmat3(prevKeyframe->_rotation);
-        prevKeyframeCameraPosition = prevFocusNode->worldRotationMatrix() * prevKeyframeCameraPosition;
+    if (prevPose.followFocusNodeRotation) {
+        prevKeyframeCameraRotation = prevFocusNode->worldRotationMatrix() * glm::dmat3(glm::dquat(prevPose.rotation));
+        prevKeyframeCameraPosition = prevFocusNode->worldRotationMatrix() * prevPose.position;
     }
-    if (nextKeyframe->_followNodeRotation) {
-        nextKeyframeCameraRotation = nextFocusNode->worldRotationMatrix() * glm::dmat3(nextKeyframe->_rotation);
-        nextKeyframeCameraPosition = nextFocusNode->worldRotationMatrix() * nextKeyframeCameraPosition;
+    if (nextPose.followFocusNodeRotation) {
+        nextKeyframeCameraRotation = nextFocusNode->worldRotationMatrix() * glm::dmat3(glm::dquat(nextPose.rotation));
+        nextKeyframeCameraPosition = nextFocusNode->worldRotationMatrix() * nextPose.position;
     }
 
     // Transform position based on focus node position
@@ -280,6 +247,10 @@ bool KeyframeInteractionMode::followingNodeRotation() const {
     return false;
 }
 
+Timeline<KeyframeInteractionMode::CameraPose>& KeyframeInteractionMode::timeline() {
+    return _cameraPoseTimeline;
+}
+
 // OrbitalInteractionMode
 OrbitalInteractionMode::MouseStates::MouseStates(double sensitivity, double velocityScaleFactor)
     : _sensitivity(sensitivity)
diff --git a/src/interaction/luaconsole.cpp b/src/interaction/luaconsole.cpp
index 37ea62df08..953f7b4504 100644
--- a/src/interaction/luaconsole.cpp
+++ b/src/interaction/luaconsole.cpp
@@ -25,6 +25,7 @@
 #include <openspace/interaction/luaconsole.h>
 
 #include <openspace/engine/openspaceengine.h>
+#include <openspace/engine/wrapper/windowwrapper.h>
 #include <openspace/network/parallelconnection.h>
 
 #include <ghoul/filesystem/cachemanager.h>
@@ -34,6 +35,9 @@
 #include <ghoul/font/fontrenderer.h>
 #include <ghoul/misc/clipboard.h>
 #include <ghoul/opengl/ghoul_gl.h>
+#include <ghoul/opengl/programobject.h>
+
+#include <glm/gtc/matrix_transform.hpp>
 
 #include <fstream>
 #include <string>
@@ -43,6 +47,8 @@ namespace {
 
     const int NoAutoComplete = -1;
 
+    const int MaximumHistoryLength = 1000;
+
     // A high number is chosen since we didn't have a version number before
     // any small number might also be equal to the console history length
 
@@ -51,6 +57,17 @@ namespace {
     const uint64_t CurrentVersion = 0xFEEEFEEE00000001;
 
     const openspace::Key CommandInputButton = openspace::Key::GraveAccent;
+
+    const char* FontName = "Console";
+    const float EntryFontSize = 14.0f;
+    const float HistoryFontSize = 11.0f;
+
+    // Additional space between the entry text and the history (in pixels)
+    const float SeparatorSpace = 30.f;
+
+    // Determines at which speed the console opens.
+     const float ConsoleOpenSpeed = 2.5;
+
 } // namespace
 
 namespace openspace {
@@ -59,27 +76,77 @@ LuaConsole::LuaConsole()
     : properties::PropertyOwner("LuaConsole")
     , _isVisible("isVisible", "Is Visible", false)
     , _remoteScripting("remoteScripting", "Remote scripting", false)
+    , _backgroundColor(
+        "backgroundColor",
+        "Background Color",
+        glm::vec4(21.f / 255.f, 23.f / 255.f, 28.f / 255.f, 0.8f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _highlightColor(
+        "highlightColor",
+        "Highlight Color",
+        glm::vec4(1.f, 1.f, 1.f, 0.f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _separatorColor(
+        "separatorColor",
+        "Separator Color",
+        glm::vec4(0.4f, 0.4f, 0.4f, 0.f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _entryTextColor(
+        "entryTextColor",
+        "Entry Text Color",
+        glm::vec4(1.f, 1.f, 1.f, 1.f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _historyTextColor(
+        "historyTextColor",
+        "History Text Color",
+        glm::vec4(1.0f, 1.0f, 1.0f, 0.65f),
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+    )
+    , _historyLength("historyLength", "History Length", 13, 0, 100)
     , _inputPosition(0)
     , _activeCommand(0)
     , _autoCompleteInfo({NoAutoComplete, false, ""})
+    , _currentHeight(0.f)
+    , _targetHeight(0.f)
+    , _fullHeight(0.f)
 {
     addProperty(_isVisible);
     addProperty(_remoteScripting);
+
+    addProperty(_historyLength);
+
+    _backgroundColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_backgroundColor);
+    _highlightColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_highlightColor);
+    _separatorColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_separatorColor);
+    _entryTextColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_entryTextColor);
+    _historyTextColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_historyTextColor);
 }
 
 void LuaConsole::initialize() {
-    std::string filename = FileSys.cacheManager()->cachedFilename(
+    const std::string filename = FileSys.cacheManager()->cachedFilename(
         HistoryFile,
         "",
         ghoul::filesystem::CacheManager::Persistent::Yes
     );
-   
-    try {
-        if (FileSys.fileExists(filename)) {
-            std::ifstream file;
-            file.exceptions(std::ofstream::badbit);
-            file.open(filename, std::ios::binary | std::ios::in);
 
+    if (FileSys.fileExists(filename)) {
+        std::ifstream file(filename, std::ios::binary | std::ios::in);
+
+        if (file.good()) {
             // Read the number of commands from the history
             uint64_t version;
             file.read(reinterpret_cast<char*>(&version), sizeof(uint64_t));
@@ -94,8 +161,6 @@ void LuaConsole::initialize() {
                 int64_t nCommands;
                 file.read(reinterpret_cast<char*>(&nCommands), sizeof(int64_t));
 
-                // @TODO: Add an upper limit on the number of commands so that the history
-                // can't grow without bounds
                 for (int64_t i = 0; i < nCommands; ++i) {
                     int64_t length;
                     file.read(reinterpret_cast<char*>(&length), sizeof(int64_t));
@@ -105,17 +170,60 @@ void LuaConsole::initialize() {
                     _commandsHistory.emplace_back(std::string(tmp.begin(), tmp.end()));
                 }
             }
-            file.close();
         }
     }
-    catch (std::exception& e) {
-        LERRORC("LuaConsole", e.what());
-    }
 
     _commands = _commandsHistory;
     _commands.push_back("");
     _activeCommand = _commands.size() - 1;
 
+    _program = ghoul::opengl::ProgramObject::Build(
+        "Console",
+        "${SHADERS}/luaconsole.vert",
+        "${SHADERS}/luaconsole.frag"
+    );
+
+    GLfloat data[] = {
+        0.f, 0.f,
+        1.f, 1.f,
+        0.f, 1.f,
+
+        0.f, 0.f,
+        1.f, 0.f,
+        1.f, 1.f
+    };
+
+    glGenVertexArrays(1, &_vao);
+    glBindVertexArray(_vao);
+    glGenBuffers(1, &_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
+
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(
+        0,
+        2,
+        GL_FLOAT,
+        GL_FALSE,
+        2 * sizeof(GLfloat),
+        reinterpret_cast<void*>(0)
+    );
+
+    glBindVertexArray(0);
+
+    _font = OsEng.fontManager().font(
+        FontName,
+        EntryFontSize,
+        ghoul::fontrendering::Font::Outline::No
+    );
+
+    _historyFont = OsEng.fontManager().font(
+        FontName,
+        HistoryFontSize,
+        ghoul::fontrendering::Font::Outline::No
+    );
+
+
     OsEng.parallelConnection().connectionEvent()->subscribe(
         "luaConsole",
         "statusChanged",
@@ -127,27 +235,39 @@ void LuaConsole::initialize() {
 }
 
 void LuaConsole::deinitialize() {
-    std::string filename = FileSys.cacheManager()->cachedFilename(
+    const std::string filename = FileSys.cacheManager()->cachedFilename(
         HistoryFile,
         "",
         ghoul::filesystem::CacheManager::Persistent::Yes
     );
 
-    std::ofstream file(filename);
-
-    uint64_t version = CurrentVersion;
-    file.write(reinterpret_cast<const char*>(&version), sizeof(uint64_t));
-
-    int64_t nCommands = _commandsHistory.size();
-    file.write(reinterpret_cast<const char*>(&nCommands), sizeof(int64_t));
-
-    for (const std::string& s : _commandsHistory) {
-        int64_t length = s.length();
-        file.write(reinterpret_cast<const char*>(&length), sizeof(int64_t));
-        // We don't write the \0 at the end on purpose
-        file.write(s.c_str(), length);
+    // We want to limit the command history to a realistic value, so that it doesn't
+    // grow without bounds
+    if (_commandsHistory.size() > MaximumHistoryLength) {
+        _commandsHistory = std::vector<std::string>(
+            _commandsHistory.end() - MaximumHistoryLength,
+            _commandsHistory.end()
+        );
     }
 
+    std::ofstream file(filename, std::ios::binary);
+    if (file.good()) {
+        uint64_t version = CurrentVersion;
+        file.write(reinterpret_cast<const char*>(&version), sizeof(uint64_t));
+
+        int64_t nCommands = _commandsHistory.size();
+        file.write(reinterpret_cast<const char*>(&nCommands), sizeof(int64_t));
+
+        for (const std::string& s : _commandsHistory) {
+            int64_t length = s.length();
+            file.write(reinterpret_cast<const char*>(&length), sizeof(int64_t));
+            // We don't write the \0 at the end on purpose
+            file.write(s.c_str(), length);
+        }
+    }
+
+    _program = nullptr;
+
     OsEng.parallelConnection().connectionEvent()->unsubscribe("luaConsole");
 }
 
@@ -162,16 +282,20 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
         if (_isVisible) {
             if (_remoteScripting) {
                 _remoteScripting = false;
-            } else {
-                _isVisible = false;
             }
-        } else {
+            else {
+                _isVisible = false;
+                _commands.back() = "";
+                _inputPosition = 0;
+            }
+        }
+        else {
             _isVisible = true;
             if (OsEng.parallelConnection().status() == ParallelConnection::Status::Host) {
                 _remoteScripting = true;
             }
         }
-        
+
         return true;
     }
 
@@ -179,31 +303,52 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
         return false;
     }
 
+    if (key == Key::Escape) {
+        _isVisible = false;
+        return true;
+    }
+
+
     const bool modifierControl = (modifier == KeyModifier::Control);
     const bool modifierShift = (modifier == KeyModifier::Shift);
 
     // Paste from clipboard
-    if (modifierControl && (key == Key::V)) {
+    if (modifierControl && (key == Key::V || key == Key::Y)) {
         addToCommand(ghoul::clipboardText());
         return true;
     }
 
     // Copy to clipboard
-    if (modifierControl && (key == Key::C)) {
+    if (modifierControl && key == Key::C) {
         ghoul::setClipboardText(_commands.at(_activeCommand));
         return true;
     }
 
+    // Cut to clipboard
+    if (modifierControl && key == Key::X) {
+        ghoul::setClipboardText(_commands.at(_activeCommand));
+        _commands.at(_activeCommand).clear();
+        _inputPosition = 0;
+    }
+
+    // Cut part after cursor to clipboard ("Kill")
+    if (modifierControl && key == Key::K) {
+        auto here = _commands.at(_activeCommand).begin() + _inputPosition;
+        auto end = _commands.at(_activeCommand).end();
+        ghoul::setClipboardText(std::string(here, end));
+        _commands.at(_activeCommand).erase(here, end);
+    }
+
     // Go to the previous character
-    if ((key == Key::Left) && (_inputPosition > 0)) {
-        --_inputPosition;
+    if (key == Key::Left || (modifierControl && key == Key::B)) {
+        if (_inputPosition > 0) {
+            --_inputPosition;
+        }
         return true;
     }
 
     // Go to the next character
-    if (key == Key::Right) {
-        //&& _inputPosition < _commands.at(_activeCommand).length())
-        //++_inputPosition;
+    if (key == Key::Right || (modifierControl && key == Key::F)) {
         _inputPosition = std::min(
             _inputPosition + 1,
             _commands.at(_activeCommand).length()
@@ -245,48 +390,40 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
         }
         return true;
     }
-        
+
     // Go to the beginning of command string
-    if (key == Key::Home) {
+    if (key == Key::Home || (modifierControl && key == Key::A)) {
         _inputPosition = 0;
         return true;
     }
 
     // Go to the end of command string
-    if (key == Key::End) {
+    if (key == Key::End || (modifierControl && key == Key::E)) {
         _inputPosition = _commands.at(_activeCommand).size();
         return true;
     }
 
-    if (key == Key::Enter) {
-        // SHIFT+ENTER == new line
-        if (modifierShift) {
-            addToCommand("\n");
-        }
-        // ENTER == run lua script
-        else {
-            std::string cmd = _commands.at(_activeCommand);
-            if (cmd != "") {
-                using RemoteScripting = scripting::ScriptEngine::RemoteScripting;
-                OsEng.scriptEngine().queueScript(
-                    cmd,
-                    _remoteScripting ? RemoteScripting::Yes : RemoteScripting::No
-                );
-                    
-                // Only add the current command to the history if it hasn't been
-                // executed before. We don't want two of the same commands in a row
-                if (_commandsHistory.empty() || (cmd != _commandsHistory.back())) {
-                    _commandsHistory.push_back(_commands.at(_activeCommand));
-                }
+    if (key == Key::Enter || key == Key::KeypadEnter) {
+        std::string cmd = _commands.at(_activeCommand);
+        if (cmd != "") {
+            using RemoteScripting = scripting::ScriptEngine::RemoteScripting;
+            OsEng.scriptEngine().queueScript(
+                cmd,
+                _remoteScripting ? RemoteScripting::Yes : RemoteScripting::No
+            );
+
+            // Only add the current command to the history if it hasn't been
+            // executed before. We don't want two of the same commands in a row
+            if (_commandsHistory.empty() || (cmd != _commandsHistory.back())) {
+                _commandsHistory.push_back(_commands.at(_activeCommand));
             }
-                
-            // Some clean up after the execution of the command
-            _commands = _commandsHistory;
-            _commands.push_back("");
-            _activeCommand = _commands.size() - 1;
-            _inputPosition = 0;
-            _isVisible = false;
         }
+
+        // Some clean up after the execution of the command
+        _commands = _commandsHistory;
+        _commands.push_back("");
+        _activeCommand = _commands.size() - 1;
+        _inputPosition = 0;
         return true;
     }
 
@@ -306,7 +443,7 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
         std::sort(allCommands.begin(), allCommands.end());
 
         std::string currentCommand = _commands.at(_activeCommand);
-            
+
         // Check if it is the first time the tab has been pressed. If so, we need to
         // store the already entered command so that we can later start the search
         // from there. We will overwrite the 'currentCommand' thus making the storage
@@ -332,7 +469,7 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
                 std::back_inserter(commandLowerCase),
                 [](char v) { return static_cast<char>(tolower(v)); }
             );
-                
+
             std::string initialValueLowerCase;
             std::transform(
                 _autoCompleteInfo.initialValue.begin(),
@@ -340,11 +477,11 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
                 std::back_inserter(initialValueLowerCase),
                 [](char v) { return static_cast<char>(tolower(v)); }
             );
-    
+
             bool correctCommand =
                 commandLowerCase.substr(0, fullLength) == initialValueLowerCase;
-                
-            if (correctLength && correctCommand && (i > _autoCompleteInfo.lastIndex)){
+
+            if (correctLength && correctCommand && (i > _autoCompleteInfo.lastIndex)) {
                 // We found our index, so store it
                 _autoCompleteInfo.lastIndex = i;
 
@@ -390,6 +527,11 @@ bool LuaConsole::keyboardCallback(Key key, KeyModifier modifier, KeyAction actio
         }
     }
 
+    // We want to ignore the function keys as they don't translate to text anyway
+    if (key >= Key::F1 && key <= Key::F25) {
+        return false;
+    }
+
     return true;
 }
 
@@ -420,98 +562,205 @@ void LuaConsole::charCallback(unsigned int codepoint, KeyModifier modifier) {
     addToCommand(std::string(1, static_cast<const char>(codepoint)));
 }
 
-void LuaConsole::render() {
-    const float FontSize = 10.0f;
+void LuaConsole::update() {
+    // Compute the height by simulating _historyFont number of lines and checking
+    // what the bounding box for that text would be.
+    using namespace ghoul::fontrendering;
+    size_t nLines = std::min(static_cast<size_t>(_historyLength), _commandsHistory.size());
+    const auto bbox = FontRenderer::defaultRenderer().boundingBox(
+        *_historyFont,
+        std::string(nLines, '\n').c_str()
+    );
 
-    if (!_isVisible) {
+    // Update the full height and the target height.
+    // Add the height of the entry line and space for a separator.
+    _fullHeight = (bbox.boundingBox.y + EntryFontSize + SeparatorSpace);
+    _targetHeight = _isVisible ? _fullHeight : 0;
+
+    const float frametime = static_cast<float>(OsEng.windowWrapper().deltaTime());
+
+    // Update the current height.
+    // The current height is the offset that is used to slide
+    // the console in from the top.
+    const glm::ivec2 res = OsEng.windowWrapper().currentWindowResolution();
+    const glm::vec2 dpiScaling = OsEng.windowWrapper().dpiScaling();
+    _currentHeight += (_targetHeight - _currentHeight) *
+        std::pow(0.98, 1.0 / (ConsoleOpenSpeed / dpiScaling.y * frametime));
+
+    _currentHeight = std::max(0.0f, _currentHeight);
+    _currentHeight = std::min(static_cast<float>(res.y), _currentHeight);
+}
+
+
+void LuaConsole::render() {
+    using namespace ghoul::fontrendering;
+
+    // Don't render the console if it's collapsed.
+    if (_currentHeight < 1.0f) {
         return;
     }
-    
-    const int ySize = OsEng.renderEngine().fontResolution().y;
 
-    const float startY =
-        static_cast<float>(ySize) - 2.0f * FontSize - FontSize * 15.0f * 2.0f;;
+    if (_program->isDirty()) {
+        _program->rebuildFromFile();
+    }
+  
+    const glm::vec2 dpiScaling = OsEng.windowWrapper().dpiScaling();
+    const glm::ivec2 res =
+        glm::vec2(OsEng.windowWrapper().currentWindowResolution()) / dpiScaling;
+  
 
-    const glm::vec4 red(1, 0, 0, 1);
-    const glm::vec4 lightBlue(0.4, 0.4, 1, 1);
-    const glm::vec4 green(0, 1, 0, 1);
-    const glm::vec4 white(1, 1, 1, 1);
-    std::shared_ptr<ghoul::fontrendering::Font> font = OsEng.fontManager().font(
-        "Mono", FontSize
+    // Render background
+    glDisable(GL_CULL_FACE);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_DEPTH_TEST);
+
+    _program->activate();
+
+    _program->setUniform("res", res);
+    _program->setUniform("color", _backgroundColor);
+    _program->setUniform("height", _currentHeight / res.y);
+    _program->setUniform(
+        "ortho",
+        glm::ortho(
+            0.f, static_cast<float>(res.x), 0.f, static_cast<float>(res.y)
+        )
     );
 
-    using ghoul::fontrendering::RenderFont;
+    // Draw the background color
+    glBindVertexArray(_vao);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
 
-    if (_remoteScripting) {
-        int nClients = OsEng.parallelConnection().nConnections() - 1;
-        if (nClients == 1) {
-            RenderFont(
-                *font,
-                glm::vec2(15.f, startY + 20.0f),
-                red,
-                "Broadcasting script to 1 client"
-            );
-        } else {
-            RenderFont(
-                *font,
-                glm::vec2(15.f, startY + 20.0f),
-                red,
-                ("Broadcasting script to " + std::to_string(nClients) + " clients").c_str()
-            );
+    // Draw the highlight lines above and below the background
+    _program->setUniform("color", _highlightColor);
+    glDrawArrays(GL_LINES, 1, 4);
+
+    // Draw the separator between the current entry box and the history
+    _program->setUniform("color", _separatorColor);
+    _program->setUniform("height", _currentHeight / res.y - 2.5f * EntryFontSize / res.y);
+    glDrawArrays(GL_LINES, 1, 2);
+
+    _program->deactivate();
+
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+
+    // Render text on top of the background
+    glm::vec2 inputLocation = glm::vec2(
+        EntryFontSize / 2.f,
+        res.y - _currentHeight + EntryFontSize
+    );
+
+    // Render the current command
+    std::string currentCommand = _commands.at(_activeCommand);
+    // We chop off the beginning of the string until it fits on the screen (with a margin)
+    // this should be replaced as soon as the mono-spaced fonts work properly. Right now,
+    // every third character is a bit wider than the others
+    while (true) {
+        const float w = ghoul::fontrendering::FontRenderer::defaultRenderer().boundingBox(
+            *_font,
+            "> %s",
+            currentCommand.c_str()
+        ).boundingBox.x + inputLocation.x;
+
+        const float d = w - res.x * 0.995f;
+        if (d < 0.f) {
+            break;
         }
-        RenderFont(*font, glm::vec2(15.f, startY), red, "$");
+
+        currentCommand = currentCommand.substr(std::max(1.f, d / _font->glyph('m')->width()));
+    }
+    RenderFontCr(
+        *_font,
+        inputLocation,
+        _entryTextColor,
+        "> %s",
+        currentCommand.c_str()
+    );
+    
+    // Just offset the ^ marker slightly for a nicer look
+    inputLocation.y += 3 * dpiScaling.y;
+
+    // Render the ^ marker below the text to show where the current entry point is
+    RenderFont(
+        *_font,
+        inputLocation,
+        _entryTextColor,
+        (std::string(currentCommand.length() + 2, ' ') + "^").c_str()
+    );
+    
+    glm::vec2 historyInputLocation = glm::vec2(
+        HistoryFontSize / 2.f,
+        res.y - HistoryFontSize * 1.5f + _fullHeight - _currentHeight
+    );
+
+    // @CPP17: Replace with array_view
+    std::vector<std::string> commandSubset;
+    if (_commandsHistory.size() < static_cast<size_t>(_historyLength)) {
+        commandSubset = _commandsHistory;
     }
     else {
-        if (OsEng.parallelConnection().isHost()) {
-            RenderFont(
-                *font,
-                glm::vec2(15.f, startY + 20.0f),
-                lightBlue,
-                "Local script execution"
-            );
-        }
-        RenderFont(*font, glm::vec2(15.f, startY), lightBlue, "$");
-    }
-    RenderFont(
-        *font,
-        glm::vec2(15.f + FontSize, startY),
-        white,
-        "%s",
-        _commands.at(_activeCommand).c_str()
-    );
-    
-    const size_t n = std::count(
-        _commands.at(_activeCommand).begin(),
-        _commands.at(_activeCommand).begin() + _inputPosition,
-        '\n'
-    );
-    size_t p = _commands.at(_activeCommand).find_last_of('\n', _inputPosition);
-    size_t linepos = _inputPosition;
-
-    if (n > 0) {
-        if (p == _inputPosition) {
-            p = _commands.at(_activeCommand).find_last_of('\n', _inputPosition - 1);
-            if (p != std::string::npos) {
-                linepos -= p + 1;
-            }
-            else {
-                linepos = _inputPosition - 1;
-            }
-        }
-        else {
-            linepos -= p + 1;
-        }
+        commandSubset = std::vector<std::string>(
+            _commandsHistory.end() - _historyLength,
+            _commandsHistory.end()
+        );
     }
 
-    std::stringstream ss;
-    ss << "%" << linepos + 1 << "s";
-    RenderFont(
-        *font,
-        glm::vec2(15.f + FontSize * 0.5f, startY - (FontSize) * (n + 1) * 3.0f / 2.0f),
-        green,
-        ss.str().c_str(),
-        "^"
-    );
+    for (const std::string& cmd : commandSubset) {
+        RenderFontCr(
+            *_historyFont,
+            historyInputLocation,
+            _historyTextColor,
+            "%s",
+            cmd.c_str()
+        );
+    }
+
+    // Computes the location for right justified text on the same y height as the entry
+    auto locationForRightJustifiedText = [&](const std::string& text) {
+        using namespace ghoul::fontrendering;
+
+        const glm::vec2 loc = glm::vec2(
+            EntryFontSize / 2.f,
+            res.y - _currentHeight + EntryFontSize
+        );
+
+        const auto bbox = FontRenderer::defaultRenderer().boundingBox(
+            *_font, text.c_str()
+        );
+        return glm::vec2(
+            loc.x + res.x - bbox.boundingBox.x - 10.f,
+            loc.y
+        );
+    };
+
+    if (_remoteScripting) {
+        const glm::vec4 red(1, 0, 0, 1);
+
+        ParallelConnection::Status status = OsEng.parallelConnection().status();
+        const int nClients =
+            status != ParallelConnection::Status::Disconnected ?
+            OsEng.parallelConnection().nConnections() - 1 :
+            0;
+
+        const std::string nClientsText =
+            nClients == 1 ?
+            "Broadcasting script to 1 client" :
+            "Broadcasting script to " + std::to_string(nClients) + " clients";
+
+        const glm::vec2 loc = locationForRightJustifiedText(nClientsText);
+        RenderFont(*_font, loc, red, nClientsText.c_str());
+    } else if (OsEng.parallelConnection().isHost()) {
+        const glm::vec4 lightBlue(0.4, 0.4, 1, 1);
+
+        const std::string localExecutionText = "Local script execution";
+        const glm::vec2 loc = locationForRightJustifiedText(localExecutionText);
+        RenderFont(*_font, loc, lightBlue, localExecutionText.c_str());
+    }
+}
+
+float LuaConsole::currentHeight() const {
+    return _currentHeight;
 }
 
 void LuaConsole::addToCommand(std::string c) {
diff --git a/src/network/networkengine.cpp b/src/network/networkengine.cpp
index 09d60687b9..0d8e559fb7 100644
--- a/src/network/networkengine.cpp
+++ b/src/network/networkengine.cpp
@@ -24,6 +24,7 @@
 
 #include <openspace/network/networkengine.h>
 #include <openspace/util/time.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/engine/wrapper/windowwrapper.h>
 
@@ -95,11 +96,13 @@ void NetworkEngine::publishStatusMessage() {
     // 8 bytes: delta time as double
     // Total: 40
 
+    Time& currentTime = OsEng.timeManager().time();
+
     uint16_t messageSize = 0;
     
-    double time = Time::ref().j2000Seconds();
-    std::string timeString = Time::ref().UTC();
-    double delta = Time::ref().deltaTime();
+    double time = currentTime.j2000Seconds();
+    std::string timeString = currentTime.UTC();
+    double delta = currentTime.deltaTime();
 
     messageSize += sizeof(time);
     messageSize += static_cast<uint16_t>(timeString.length());
diff --git a/src/network/parallelconnection.cpp b/src/network/parallelconnection.cpp
index eaf2d86168..0a73c4eb12 100644
--- a/src/network/parallelconnection.cpp
+++ b/src/network/parallelconnection.cpp
@@ -68,6 +68,7 @@
 #include <openspace/interaction/interactionmode.h>
 #include <openspace/scene/scenegraphnode.h>
 #include <openspace/util/timemanager.h>
+#include <openspace/interaction/interactionmode.h>
 #include <openspace/util/time.h>
 #include <openspace/openspace.h>
 #include <openspace/scripting/script_helper.h>
@@ -549,7 +550,13 @@ void ParallelConnection::dataMessageReceived(const std::vector<char>& messageCon
             kf._timestamp = calculateBufferedKeyframeTime(kf._timestamp);
 
             OsEng.interactionHandler().removeKeyframesAfter(kf._timestamp);
-            OsEng.interactionHandler().addKeyframe(kf);
+            interaction::KeyframeInteractionMode::CameraPose pose;
+            pose.focusNode = kf._focusNode;
+            pose.position = kf._position;
+            pose.rotation = kf._rotation;
+            pose.followFocusNodeRotation = kf._followNodeRotation;
+
+            OsEng.interactionHandler().addKeyframe(kf._timestamp, pose);
             break;
         }
         case datamessagestructures::Type::TimeData: {
@@ -557,7 +564,12 @@ void ParallelConnection::dataMessageReceived(const std::vector<char>& messageCon
             kf._timestamp = calculateBufferedKeyframeTime(kf._timestamp);
 
             OsEng.timeManager().removeKeyframesAfter(kf._timestamp);
-            OsEng.timeManager().addKeyframe(kf);
+            Time time(kf._time);
+            time.setDeltaTime(kf._dt);
+            time.setPause(kf._paused);
+            time.setTimeJumped(kf._requiresTimeJump);
+
+            OsEng.timeManager().addKeyframe(kf._timestamp, time);
             break;
         }
         case datamessagestructures::Type::ScriptData: {
@@ -970,7 +982,7 @@ void ParallelConnection::preSynchronization() {
     }
     
     if (status() == Status::Host) {
-        if (Time::ref().timeJumped()) {
+        if (OsEng.timeManager().time().timeJumped()) {
             _timeJumped = true;
         }
         double now = OsEng.runTime();
@@ -1061,10 +1073,12 @@ void ParallelConnection::sendTimeKeyframe() {
     // Create a keyframe with current position and orientation of camera
     datamessagestructures::TimeKeyframe kf;
     
-    kf._dt = Time::ref().deltaTime();
-    kf._paused = Time::ref().paused();
+    Time& time = OsEng.timeManager().time();
+
+    kf._dt = time.deltaTime();
+    kf._paused = time.paused();
     kf._requiresTimeJump = _timeJumped;
-    kf._time = Time::ref().j2000Seconds();
+    kf._time = time.j2000Seconds();
 
     // Timestamp as current runtime of OpenSpace instance
     kf._timestamp = OsEng.runTime();
diff --git a/src/properties/property.cpp b/src/properties/property.cpp
index a06c186588..a71331a745 100644
--- a/src/properties/property.cpp
+++ b/src/properties/property.cpp
@@ -42,8 +42,6 @@ namespace {
 
 const char* Property::ViewOptions::Color = "color";
 const char* Property::ViewOptions::LightPosition = "lightPosition";
-const char* Property::ViewOptions::PowerScaledCoordinate = "powerScaledCoordinate";
-const char* Property::ViewOptions::PowerScaledScalar = "powerScaledScalar";
 
 const char* Property::IdentifierKey = "Identifier";
 const char* Property::NameKey = "Name";
@@ -156,6 +154,12 @@ void Property::setViewOption(std::string option, bool value) {
     );
 }
 
+bool Property::viewOption(const std::string& option, bool defaultValue) const {
+    bool v = defaultValue;
+    _metaData.getValue(_metaDataKeyViewPrefix + option, v);
+    return v;
+}
+
 const ghoul::Dictionary& Property::metaData() const {
     return _metaData;
 }
diff --git a/src/rendering/abufferrenderer.cpp b/src/rendering/abufferrenderer.cpp
index e9b5cd7f94..98097aa375 100644
--- a/src/rendering/abufferrenderer.cpp
+++ b/src/rendering/abufferrenderer.cpp
@@ -34,6 +34,7 @@
 #include <openspace/scene/scene.h>
 #include <openspace/util/camera.h>
 #include <openspace/util/updatestructures.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/performance/performancemeasurement.h>
 
 
@@ -265,7 +266,8 @@ void ABufferRenderer::render(float blackoutFactor, bool doPerformanceMeasurement
         static_cast<int>(Renderable::RenderBin::Transparent) |
         static_cast<int>(Renderable::RenderBin::Overlay);
 
-    RenderData data{ *_camera, psc(), doPerformanceMeasurements, renderBinMask };
+    Time time = OsEng.timeManager().time();
+    RenderData data{ *_camera, psc(), time, doPerformanceMeasurements, renderBinMask };
     RendererTasks tasks;
     _scene->render(data, tasks);
     _blackoutFactor = blackoutFactor;
diff --git a/src/rendering/framebufferrenderer.cpp b/src/rendering/framebufferrenderer.cpp
index 63b467df0f..f77e40bed6 100644
--- a/src/rendering/framebufferrenderer.cpp
+++ b/src/rendering/framebufferrenderer.cpp
@@ -29,6 +29,7 @@
 #include <string>
 #include <openspace/scene/scene.h>
 #include <openspace/util/camera.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/engine/openspaceengine.h>
 #include <openspace/rendering/renderable.h>
 #include <openspace/rendering/deferredcaster.h>
@@ -486,7 +487,9 @@ void FramebufferRenderer::render(float blackoutFactor, bool doPerformanceMeasure
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    RenderData data = { *_camera, psc(), doPerformanceMeasurements, 0 };
+    Time time = OsEng.timeManager().time();
+
+    RenderData data = { *_camera, psc(), time, doPerformanceMeasurements, 0 };
     RendererTasks tasks;
 
     // Capture standard fbo
diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index e5b7584dac..1becfdf91e 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -43,8 +43,10 @@
 #include <openspace/performance/performancemanager.h>
 #include <openspace/rendering/renderer.h>
 
+#include <openspace/interaction/luaconsole.h>
 #include <openspace/util/camera.h>
 #include <openspace/util/time.h>
+#include <openspace/util/timemanager.h>
 #include <openspace/util/screenlog.h>
 #include <openspace/util/spicemanager.h>
 #include <openspace/rendering/raycastermanager.h>
@@ -307,12 +309,10 @@ void RenderEngine::deinitialize() {
 }
 
 void RenderEngine::updateScene() {
+    const Time& currentTime = OsEng.timeManager().time();
     _scene->update({
         { glm::dvec3(0), glm::dmat3(1), 1.0 },
-        Time::ref().j2000Seconds(),
-        Time::ref().deltaTime(),
-        Time::ref().paused(),
-        Time::ref().timeJumped(),
+        currentTime,
         _performanceManager != nullptr
     });
     
@@ -483,8 +483,9 @@ void RenderEngine::renderShutdownInformation(float timer, float fullTime) {
 }
 
 void RenderEngine::postDraw() {
-    if (Time::ref().timeJumped()) {
-        Time::ref().setTimeJumped(false);
+    Time& currentTime = OsEng.timeManager().time();
+    if (currentTime.timeJumped()) {
+        currentTime.setTimeJumped(false);
     }
 
     if (_shouldTakeScreenshot) {
@@ -835,13 +836,15 @@ void RenderEngine::renderInformation() {
             //OsEng.windowWrapper().viewportPixelCoordinates().w
         );
 
+        penPosition.y -= OsEng.console().currentHeight();
+
         if (_showDate && _fontDate) {
             penPosition.y -= _fontDate->height();
             RenderFontCr(
                 *_fontDate,
                 penPosition,
                 "Date: %s",
-                Time::ref().UTC().c_str()
+                OsEng.timeManager().time().UTC().c_str()
             );
         }
         else {
@@ -852,7 +855,7 @@ void RenderEngine::renderInformation() {
                 *_fontInfo,
                 penPosition,
                 "Simulation increment (s): %.3f",
-                Time::ref().deltaTime()
+                OsEng.timeManager().time().deltaTime()
             );
 
             FrametimeType frametimeType = FrametimeType(_frametimeType.value());
@@ -942,7 +945,7 @@ void RenderEngine::renderInformation() {
 
 #ifdef OPENSPACE_MODULE_NEWHORIZONS_ENABLED
             bool hasNewHorizons = scene()->sceneGraphNode("NewHorizons");
-            double currentTime = Time::ref().j2000Seconds();
+            double currentTime = OsEng.timeManager().time().j2000Seconds();
 
             if (MissionManager::ref().hasCurrentMission()) {
 
diff --git a/src/scene/scenegraphnode.cpp b/src/scene/scenegraphnode.cpp
index 79baf099e8..24d30087ab 100644
--- a/src/scene/scenegraphnode.cpp
+++ b/src/scene/scenegraphnode.cpp
@@ -321,6 +321,7 @@ void SceneGraphNode::render(const RenderData& data, RendererTasks& tasks) {
     RenderData newData = {
         data.camera,
         thisPositionPSC,
+        data.time,
         data.doPerformanceMeasurement,
         data.renderBinMask,
         { _worldPositionCached, _worldRotationCached, _worldScaleCached }
diff --git a/src/scene/translation.cpp b/src/scene/translation.cpp
index f4bd69aebe..9dc3eb3931 100644
--- a/src/scene/translation.cpp
+++ b/src/scene/translation.cpp
@@ -86,9 +86,6 @@ glm::dvec3 Translation::position(double time) {
     update({
         {},
         time,
-        1.0,
-        false,
-        false,
         false
     });
 
diff --git a/src/scripting/scriptscheduler.cpp b/src/scripting/scriptscheduler.cpp
index c7b92be2bb..dd01785e9e 100644
--- a/src/scripting/scriptscheduler.cpp
+++ b/src/scripting/scriptscheduler.cpp
@@ -103,7 +103,7 @@ ScriptScheduler::ScheduledScript::ScheduledScript(const ghoul::Dictionary& dicti
     : time(-std::numeric_limits<double>::max())
 {
     std::string timeStr = dictionary.value<std::string>(KeyTime);
-    time = Time::ref().convertTime(timeStr);
+    time = Time::convertTime(timeStr);
     
     // If a universal script is specified, retrieve it and add a ; as a separator so that
     // it can be added to the other scripts
diff --git a/src/util/time.cpp b/src/util/time.cpp
index 65343141c1..b7e0f51b4b 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -26,6 +26,8 @@
 
 #include <time.h>
 
+#include <openspace/engine/openspaceengine.h>
+#include <openspace/util/timemanager.h>
 #include "time_lua.inl"
 
 #include <openspace/util/spicemanager.h>
@@ -36,9 +38,6 @@
 
 namespace openspace {
 
-Time* Time::_instance = nullptr;
-    
-
 double Time::convertTime(const std::string& time) {
     ghoul_assert(!time.empty(), "timeString must not be empty");
     return SpiceManager::ref().ephemerisTimeFromDate(time);
@@ -54,26 +53,11 @@ Time::Time(const Time& other)
     : _time(other._time)
     , _dt(other._dt)
     , _timeJumped(other._timeJumped)
+    , _timePaused(other._timePaused)
 {
 
 }
 
-void Time::initialize() {
-    ghoul_assert(_instance == nullptr, "Static time must not have been ininitialized");
-    _instance = new Time();
-}
-
-void Time::deinitialize() {
-    ghoul_assert(_instance, "Static time must have been ininitialized");
-    delete _instance;
-    _instance = nullptr;
-}
-
-Time& Time::ref() {
-    ghoul_assert(_instance, "Static time must have been ininitialized");
-    return *_instance;
-}
-
 Time Time::now() {
     Time now;
     time_t secondsSince1970;
@@ -85,10 +69,6 @@ Time Time::now() {
     return now;
 }
 
-bool Time::isInitialized() {
-    return (_instance != nullptr);
-}
-
 void Time::setTime(double value, bool requireJump) {
     _time = value;
     _timeJumped = requireJump;
@@ -169,10 +149,6 @@ bool Time::paused() const {
     return _timePaused;
 }
 
-std::vector<Syncable*> Time::getSyncables() {
-    return{ &_time, &_dt, &_timeJumped};
-}
-
 scripting::LuaLibrary Time::luaLibrary() {
     return {
         "time",
diff --git a/src/util/time_lua.inl b/src/util/time_lua.inl
index 9ab125b457..cc1ee5ca6a 100644
--- a/src/util/time_lua.inl
+++ b/src/util/time_lua.inl
@@ -46,7 +46,7 @@ int time_setDeltaTime(lua_State* L) {
     const bool isNumber = (lua_isnumber(L, -1) != 0);
     if (isNumber) {
         double value = lua_tonumber(L, -1);
-        openspace::Time::ref().setDeltaTime(value);
+        OsEng.timeManager().time().setDeltaTime(value);
         return 0;
     }
     else {
@@ -67,7 +67,7 @@ int time_setDeltaTime(lua_State* L) {
  * Returns the delta time by calling the Time::deltaTime method
  */
 int time_deltaTime(lua_State* L) {
-    lua_pushnumber(L, openspace::Time::ref().deltaTime());
+    lua_pushnumber(L, OsEng.timeManager().time().deltaTime());
     return 1;
 }
 
@@ -82,7 +82,7 @@ int time_togglePause(lua_State* L) {
         return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
     }
 
-    openspace::Time::ref().togglePause();
+    OsEng.timeManager().time().togglePause();
     return 0;
 }
 
@@ -98,7 +98,7 @@ int time_setPause(lua_State* L) {
     }
 
     bool pause = lua_toboolean(L, -1) == 1;
-    openspace::Time::ref().setPause(pause);
+    OsEng.timeManager().time().setPause(pause);
     return 0;
 }
 
@@ -130,12 +130,12 @@ int time_setTime(lua_State* L) {
     }
     if (isNumber) {
         double value = lua_tonumber(L, -1);
-        openspace::Time::ref().setTime(value);
+        OsEng.timeManager().time().setTime(value);
         return 0;
     }
     if (isString) {
         const char* time = lua_tostring(L, -1);
-        openspace::Time::ref().setTime(time);
+        OsEng.timeManager().time().setTime(time);
         return 0;
     }
     return 0;
@@ -148,7 +148,7 @@ int time_setTime(lua_State* L) {
  * It is returned by calling the Time::currentTime method.
  */
 int time_currentTime(lua_State* L) {
-    lua_pushnumber(L, openspace::Time::ref().j2000Seconds());
+    lua_pushnumber(L, OsEng.timeManager().time().j2000Seconds());
     return 1;
 }
 
@@ -159,7 +159,7 @@ int time_currentTime(lua_State* L) {
  * timezone by calling the Time::UTC method
  */
 int time_currentTimeUTC(lua_State* L) {
-    lua_pushstring(L, openspace::Time::ref().UTC().c_str());
+    lua_pushstring(L, OsEng.timeManager().time().UTC().c_str());
     return 1;
 }
 
diff --git a/src/util/timeline.cpp b/src/util/timeline.cpp
new file mode 100644
index 0000000000..e5a131fda1
--- /dev/null
+++ b/src/util/timeline.cpp
@@ -0,0 +1,41 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014-2017                                                               *
+ *                                                                                       *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+ * software and associated documentation files (the "Software"), to deal in the Software *
+ * without restriction, including without limitation the rights to use, copy, modify,    *
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+ * permit persons to whom the Software is furnished to do so, subject to the following   *
+ * conditions:                                                                           *
+ *                                                                                       *
+ * The above copyright notice and this permission notice shall be included in all copies *
+ * or substantial portions of the Software.                                              *
+ *                                                                                       *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+ ****************************************************************************************/
+
+#include <openspace/util/timeline.h>
+
+namespace openspace {
+
+bool compareKeyframeTimes(const KeyframeBase& a, const KeyframeBase& b) {
+    return a.timestamp < b.timestamp;
+}
+
+bool compareTimeWithKeyframeTime(double a, const KeyframeBase& b) {
+    return a < b.timestamp;
+}
+
+bool compareKeyframeTimeWithTime(const KeyframeBase& a, double b) {
+    return a.timestamp < b;
+}
+
+} // namespace
diff --git a/src/util/timemanager.cpp b/src/util/timemanager.cpp
index 61502b221f..ac654c9c85 100644
--- a/src/util/timemanager.cpp
+++ b/src/util/timemanager.cpp
@@ -24,8 +24,8 @@
 
 #include <openspace/util/timemanager.h>
 #include <openspace/engine/openspaceengine.h>
-#include <openspace/util/time.h>
 #include <openspace/network/parallelconnection.h>
+#include <openspace/util/timeline.h>
 
 namespace openspace {
 
@@ -34,8 +34,8 @@ using datamessagestructures::TimeKeyframe;
 void TimeManager::preSynchronization(double dt) {
 //    double now = OsEng.runTime();
     removeKeyframesBefore(_latestConsumedTimestamp);
-    if (_keyframes.size() == 0) {
-        Time::ref().advanceTime(dt);
+    if (_timeline.nKeyframes() == 0) {
+        time().advanceTime(dt);
     } else {
         consumeKeyframes(dt);
     }
@@ -43,121 +43,116 @@ void TimeManager::preSynchronization(double dt) {
 
 void TimeManager::consumeKeyframes(double dt) {
     double now = OsEng.runTime();
-    TimeKeyframe kf;
-    kf._timestamp = now;
-    auto firstFutureKeyframe = std::lower_bound(_keyframes.begin(), _keyframes.end(), kf, &TimeManager::compareKeyframeTimes);
+    
+    const std::deque<Keyframe<Time>>& keyframes = _timeline.keyframes();
+    auto firstFutureKeyframe = std::lower_bound(keyframes.begin(), keyframes.end(), now, &compareKeyframeTimeWithTime);
 
-    bool consumingTimeJump = std::find_if(_keyframes.begin(), firstFutureKeyframe, [] (const TimeKeyframe& f) {
-        return f._requiresTimeJump;
+    bool consumingTimeJump = std::find_if(keyframes.begin(), firstFutureKeyframe, [] (const Keyframe<Time>& f) {
+        return f.data.timeJumped();
     }) != firstFutureKeyframe;
 
-    Time& time = Time::ref();
-
-    if (firstFutureKeyframe == _keyframes.end()) {
+    if (firstFutureKeyframe == keyframes.end()) {
         // All keyframes are in the past.
         // Consume the latest one.
-        TimeKeyframe& current = _keyframes.back();
-        time.setTime(current._time, consumingTimeJump);
-        time.setDeltaTime(current._dt);
-        time.setPause(current._paused);
-        _latestConsumedTimestamp = current._timestamp;
+        const Keyframe<Time>& current = keyframes.back();
+        const Time& currentTime = current.data;
+        time().setTime(currentTime.j2000Seconds(), consumingTimeJump);
+        time().setDeltaTime(currentTime.deltaTime());
+        time().setPause(currentTime.paused());
+        _latestConsumedTimestamp = current.timestamp;
     }
     else {
-        TimeKeyframe& next = *firstFutureKeyframe;
+        const Keyframe<Time>& next = *firstFutureKeyframe;
+        const Time& nextTime = next.data;
 
-        if (firstFutureKeyframe != _keyframes.begin()) {
-            TimeKeyframe& latest = *(firstFutureKeyframe - 1);
+        if (firstFutureKeyframe != keyframes.begin()) {
+            const Keyframe<Time>& latest = *(firstFutureKeyframe - 1);
+            const Time& latestTime = latest.data;
             // In case of unconsumed passed keyframes, let the last one
             // determine whether the time should be paused or not.
             // If there was a time jump or time is paused, apply it directly.
             // Then consume the last keyframe.
 
-            time.setPause(latest._paused);
-            time.setTimeJumped(consumingTimeJump);
-            time.setDeltaTime(latest._dt);
+            time().setPause(latestTime.paused());
+            time().setTimeJumped(consumingTimeJump);
+            time().setDeltaTime(latestTime.deltaTime());
 
-            if (consumingTimeJump || latest._paused) {
-                time.setTime(latest._time, consumingTimeJump);
+            if (consumingTimeJump || latestTime.paused()) {
+                time().setTime(latestTime.j2000Seconds(), consumingTimeJump);
             }
-            _latestConsumedTimestamp = latest._timestamp;
+            _latestConsumedTimestamp = latest.timestamp;
         }
 
         // Do not interpolate with time jumping keyframes.
         // Instead, wait until their timestamp and apply them directly.
-        if (next._requiresTimeJump) {
-            Time::ref().advanceTime(dt);
+        if (nextTime.timeJumped()) {
+            time().advanceTime(dt);
             return;
         }
 
-        if (time.paused()) {
+        if (time().paused()) {
             return;
         }
 
         const double secondsOffTolerance = OsEng.parallelConnection().timeTolerance();
 
-        double predictedTime = time.j2000Seconds() + time.deltaTime() * (next._timestamp - now);
-        bool withinTolerance = std::abs(predictedTime - next._time) < std::abs(next._dt * secondsOffTolerance);
+        double predictedTime = time().j2000Seconds() + time().deltaTime() * (next.timestamp - now);
+        bool withinTolerance = std::abs(predictedTime - nextTime.j2000Seconds()) < std::abs(nextTime.deltaTime() * secondsOffTolerance);
         
-        if (next._dt == time.deltaTime() && withinTolerance) {
-            Time::ref().advanceTime(dt);
+        if (nextTime.deltaTime() == time().deltaTime() && withinTolerance) {
+            time().advanceTime(dt);
             return;
         }
 
         double t0 = now - dt;
         double t1 = now;
-        double t2 = next._timestamp;
+        double t2 = next.timestamp;
 
         double parameter = (t1 - t0) / (t2 - t0);
         
-        double y0 = time.j2000Seconds();
-        double yPrime0 = time.deltaTime();
+        double y0 = time().j2000Seconds();
+        double yPrime0 = time().deltaTime();
 
-        double y2 = next._time;
-        double yPrime2 = next._dt;
+        double y2 = nextTime.j2000Seconds();
+        double yPrime2 = nextTime.deltaTime();
 
         double y1 = (1 - parameter) * y0 + parameter * y2;
         double y1Prime = (y1 - y0) / dt;
 
-        time.setDeltaTime(y1Prime);
-        time.setTime(y1, false);
-        // std::cout << "Correcting time to " << y1 << ", dt=" << y1Prime << "." << std::endl;
+        time().setDeltaTime(y1Prime);
+        time().setTime(y1, false);
     }
 }
 
 
-void TimeManager::addKeyframe(const TimeKeyframe& kf) {
-    if (kf._timestamp < OsEng.runTime()) {
-        return;
-    }
-    auto iter = std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &TimeManager::compareKeyframeTimes);
-    _keyframes.insert(iter, kf);
+
+void TimeManager::addKeyframe(double timestamp, Time time) {
+    _timeline.addKeyframe(timestamp, time);
 }
 
 void TimeManager::removeKeyframesAfter(double timestamp) {
-    datamessagestructures::TimeKeyframe kf;
-    kf._timestamp = timestamp;
-    auto iter = std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &TimeManager::compareKeyframeTimes);
-    _keyframes.erase(iter, _keyframes.end());
+    _timeline.removeKeyframesAfter(timestamp);
 }
 
 
 void TimeManager::removeKeyframesBefore(double timestamp) {
-    datamessagestructures::TimeKeyframe kf;
-    kf._timestamp = timestamp;
-    auto iter = std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &TimeManager::compareKeyframeTimes);
-    _keyframes.erase(_keyframes.begin(), iter);
+    _timeline.removeKeyframesBefore(timestamp);
 }
 
 void TimeManager::clearKeyframes() {
-    _keyframes.clear();
+    _timeline.clearKeyframes();
 }
 
-const std::deque<datamessagestructures::TimeKeyframe>& TimeManager::keyframes() const {
-    return _keyframes;
+size_t TimeManager::nKeyframes() const {
+    return _timeline.nKeyframes();
 }
 
-bool TimeManager::compareKeyframeTimes(const TimeKeyframe& a, const TimeKeyframe& b) {
-    return a._timestamp < b._timestamp;
+Time& TimeManager::time() {
+    return _currentTime;
+}
+
+std::vector<Syncable*> TimeManager::getSyncables() {
+    return{ &_currentTime };
 }
 
 }
diff --git a/tests/main.cpp b/tests/main.cpp
index bfc94797c5..14067ab794 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -40,6 +40,7 @@
 #include <test_common.inl>
 #include <test_spicemanager.inl>
 #include <test_sceneloader.inl>
+#include <test_timeline.inl>
 
 #ifdef OPENSPACE_MODULE_GLOBEBROWSING_ENABLED
 //#include <test_chunknode.inl>
diff --git a/tests/test_scriptscheduler.inl b/tests/test_scriptscheduler.inl
index 0515055c1e..bb306adcad 100644
--- a/tests/test_scriptscheduler.inl
+++ b/tests/test_scriptscheduler.inl
@@ -60,16 +60,16 @@ TEST_F(ScriptSchedulerTest, SimpleForward) {
         { "BackwardScript", "BackwardScript1"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(res.first, res.second);
     
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03")
+        openspace::Time::convertTime("2000 JAN 03")
     );
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
@@ -94,20 +94,20 @@ TEST_F(ScriptSchedulerTest, MultipleForwardSingleJump) {
     
     ScriptScheduler scheduler;
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(res.first, res.second);
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript2", *(res.first));
 }
@@ -130,16 +130,16 @@ TEST_F(ScriptSchedulerTest, MultipleForwardOrdering) {
     
     ScriptScheduler scheduler;
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
     EXPECT_EQ("ForwardScript2", *(std::next(res.first)));
@@ -157,15 +157,15 @@ TEST_F(ScriptSchedulerTest, SimpleBackward) {
         { "BackwardScript", "BackwardScript1"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 05"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 05"));
     scheduler.loadScripts({
         { "1", testDictionary }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
 }
@@ -188,20 +188,20 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardSingleJump) {
         { "BackwardScript", "BackwardScript2"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
     
-    auto res =  scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    auto res =  scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(res.first, res.second);
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
 }
@@ -224,16 +224,16 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardOrdering) {
         { "BackwardScript", "BackwardScript2"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
     EXPECT_EQ("BackwardScript1", *(std::next(res.first)));
@@ -280,24 +280,24 @@ TEST_F(ScriptSchedulerTest, ForwardBackwards) {
         { "BackwardScript", "BackwardScript2"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
 }
@@ -320,18 +320,18 @@ TEST_F(ScriptSchedulerTest, Rewind) {
         { "BackwardScript", "BackwardScript2"s }
     };
     
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 },
         { "2", testDictionary2 }
     });
     
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     
     scheduler.rewind();
     
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 }
@@ -406,23 +406,23 @@ TEST_F(ScriptSchedulerTest, JumpEqual) {
     });
 
     auto res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 11:00:00")
+        openspace::Time::convertTime("2000 JAN 03 11:00:00")
     );
     ASSERT_EQ(res.first, res.second);
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:00:00")
+        openspace::Time::convertTime("2000 JAN 03 12:00:00")
     );
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:01:00")
+        openspace::Time::convertTime("2000 JAN 03 12:01:00")
     );
     ASSERT_EQ(res.first, res.second);
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:00:00")
+        openspace::Time::convertTime("2000 JAN 03 12:00:00")
     );
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
@@ -445,13 +445,13 @@ TEST_F(ScriptSchedulerTest, SameTime) {
     });
 
     auto res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:00:00")
+        openspace::Time::convertTime("2000 JAN 03 12:00:00")
     );
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:00:00")
+        openspace::Time::convertTime("2000 JAN 03 12:00:00")
     );
     ASSERT_EQ(res.first, res.second);
 }
@@ -473,23 +473,23 @@ TEST_F(ScriptSchedulerTest, MultiInnerJump) {
     });
 
     auto res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 10:00:00")
+        openspace::Time::convertTime("2000 JAN 03 10:00:00")
     );
     ASSERT_EQ(res.first, res.second);
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 11:00:00")
+        openspace::Time::convertTime("2000 JAN 03 11:00:00")
     );
     ASSERT_EQ(res.first, res.second);
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 13:00:00")
+        openspace::Time::convertTime("2000 JAN 03 13:00:00")
     );
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 
     res = scheduler.progressTo(
-        openspace::Time::ref().convertTime("2000 JAN 03 12:30:00")
+        openspace::Time::convertTime("2000 JAN 03 12:30:00")
     );
     ASSERT_EQ(res.first, res.second);
 }
@@ -513,7 +513,7 @@ TEST_F(ScriptSchedulerTest, MultipleForwardSingleJumpMultipleLoad) {
 
     ScriptScheduler scheduler;
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -522,14 +522,14 @@ TEST_F(ScriptSchedulerTest, MultipleForwardSingleJumpMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript2", *(res.first));
 }
@@ -552,7 +552,7 @@ TEST_F(ScriptSchedulerTest, MultipleForwardOrderingMultipleLoad) {
 
     ScriptScheduler scheduler;
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -560,10 +560,10 @@ TEST_F(ScriptSchedulerTest, MultipleForwardOrderingMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 02"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 02"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
     EXPECT_EQ("ForwardScript2", *(std::next(res.first)));
@@ -587,7 +587,7 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardSingleJumpMultipleLoad) {
         { "BackwardScript", "BackwardScript2"s }
     };
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -595,14 +595,14 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardSingleJumpMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
 }
@@ -625,7 +625,7 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardOrderingMultipleLoad) {
         { "BackwardScript", "BackwardScript2"s }
     };
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -633,10 +633,10 @@ TEST_F(ScriptSchedulerTest, MultipleBackwardOrderingMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 06"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 06"));
     ASSERT_EQ(res.first, res.second);
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
     EXPECT_EQ("BackwardScript1", *(std::next(res.first)));
@@ -660,7 +660,7 @@ TEST_F(ScriptSchedulerTest, ForwardBackwardsMultipleLoad) {
         { "BackwardScript", "BackwardScript2"s }
     };
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -668,18 +668,18 @@ TEST_F(ScriptSchedulerTest, ForwardBackwardsMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript1", *(res.first));
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("BackwardScript2", *(res.first));
 }
@@ -702,7 +702,7 @@ TEST_F(ScriptSchedulerTest, RewindMultipleLoad) {
         { "BackwardScript", "BackwardScript2"s }
     };
 
-    scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 01"));
+    scheduler.progressTo(openspace::Time::convertTime("2000 JAN 01"));
     scheduler.loadScripts({
         { "1", testDictionary1 }
     });
@@ -710,12 +710,12 @@ TEST_F(ScriptSchedulerTest, RewindMultipleLoad) {
         { "1", testDictionary2 }
     });
 
-    auto res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 07"));
+    auto res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 07"));
     ASSERT_EQ(2, std::distance(res.first, res.second));
 
     scheduler.rewind();
 
-    res = scheduler.progressTo(openspace::Time::ref().convertTime("2000 JAN 04"));
+    res = scheduler.progressTo(openspace::Time::convertTime("2000 JAN 04"));
     ASSERT_EQ(1, std::distance(res.first, res.second));
     EXPECT_EQ("ForwardScript1", *(res.first));
 }
diff --git a/tests/test_timeline.inl b/tests/test_timeline.inl
new file mode 100644
index 0000000000..0d90915780
--- /dev/null
+++ b/tests/test_timeline.inl
@@ -0,0 +1,100 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * 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>
+
+using namespace openspace;
+
+class TimelineTest : public testing::Test {};
+
+TEST_F(TimelineTest, AddAndCountKeyframes) {
+    Timeline<Time> timeline;
+    timeline.addKeyframe(0.0, Time::now());
+    timeline.addKeyframe(1.0, Time::now());
+
+    ASSERT_EQ(timeline.nKeyframes(), 2);
+}
+
+TEST_F(TimelineTest, QueryKeyframes) {
+    Timeline<float> timeline;
+    timeline.addKeyframe(0.0, 0.f);
+    timeline.addKeyframe(1.0, 1.f);
+
+    ASSERT_EQ(timeline.nKeyframes(), 2);
+
+    ASSERT_EQ(timeline.firstKeyframeAfter(0.0)->data, 1.f) << "Incorrect keyframe returned";
+    ASSERT_EQ(timeline.firstKeyframeAfter(0.0, false)->data, 1.f) << "Incorrect keyframe returned";
+    ASSERT_EQ(timeline.firstKeyframeAfter(0.0, true)->data, 0.f) << "Incorrect keyframe returned";
+
+    ASSERT_EQ(timeline.lastKeyframeBefore(1.0)->data, 0.f) << "Incorrect keyframe returned";
+    ASSERT_EQ(timeline.lastKeyframeBefore(1.0, false)->data, 0.f) << "Incorrect keyframe returned";
+    ASSERT_EQ(timeline.lastKeyframeBefore(1.0, true)->data, 1.f) << "Incorrect keyframe returned";
+}
+
+TEST_F(TimelineTest, RemoveKeyframes) {
+    Timeline<float> timeline;
+    timeline.addKeyframe(0.0, 0.f);
+    timeline.addKeyframe(1.0, 1.f);
+
+    timeline.removeKeyframesBefore(0.0);
+    ASSERT_EQ(timeline.nKeyframes(), 2);
+
+    timeline.removeKeyframesBefore(0.0, false);
+    ASSERT_EQ(timeline.nKeyframes(), 2);
+
+    timeline.removeKeyframesBefore(0.0, true);
+    ASSERT_EQ(timeline.nKeyframes(), 1);
+
+    timeline.removeKeyframesAfter(1.0);
+    ASSERT_EQ(timeline.nKeyframes(), 1);
+
+    timeline.removeKeyframesAfter(1.0, false);
+    ASSERT_EQ(timeline.nKeyframes(), 1);
+
+    timeline.removeKeyframesAfter(1.0, true);
+    ASSERT_EQ(timeline.nKeyframes(), 0);
+}
+
+TEST_F(TimelineTest, RemoveKeyframesInRange) {
+    Timeline<float> timeline;
+    timeline.addKeyframe(0.0, 0.f);
+    timeline.addKeyframe(1.0, 1.f);
+    timeline.addKeyframe(2.0, 2.f);
+    timeline.addKeyframe(3.0, 3.f);
+
+    timeline.removeKeyframesBetween(1.0, 2.0);
+    ASSERT_EQ(timeline.nKeyframes(), 4);
+
+    timeline.removeKeyframesBetween(1.0, 2.0, false, true);
+    ASSERT_EQ(timeline.nKeyframes(), 3);
+
+    timeline.removeKeyframesBetween(1.0, 2.0, true, true);
+    ASSERT_EQ(timeline.nKeyframes(), 2);
+
+    timeline.removeKeyframesBetween(-1.0, 4.0);
+    ASSERT_EQ(timeline.nKeyframes(), 0);
+}