diff --git a/CMakeLists.txt b/CMakeLists.txt
index fe5111876..021b4318b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,9 +71,6 @@ add_subdirectory(rwcore)
 add_subdirectory(rwengine)
 add_subdirectory(rwgame)
 
-if(BUILD_VIEWER)
-    add_subdirectory(rwviewer)
-endif()
 if(BUILD_TESTS)
     enable_testing()
     add_subdirectory(tests)
diff --git a/cmake/ctest/build.ctest b/cmake/ctest/build.ctest
index 90aa096e0..550e755f2 100644
--- a/cmake/ctest/build.ctest
+++ b/cmake/ctest/build.ctest
@@ -10,7 +10,6 @@ set(_ARGS_BOOL
     BUILD_TYPE
     CHECK_IWYU
     BUILD_TOOLS
-    BUILD_VIEWER
 
     RUN_TESTS
     SEPARATE_TEST_SUITES
@@ -121,17 +120,11 @@ if(USE_CONAN)
         set(CONAN_CONFIGURATION "Release")
     endif()
 
-    if(BUILD_VIEWER)
-        set(_BUILD_VIEWER True)
-    else()
-        set(_BUILD_VIEWER False)
-    endif()
-
     execute_process(
         COMMAND
             "${CONAN_BIN}" install "${CTEST_SOURCE_DIRECTORY}"
                 -s arch=${CONAN_ARCH} -s build_type=${CONAN_CONFIGURATION}
-                -o viewer=${_BUILD_VIEWER} --build missing
+                --build missing
         WORKING_DIRECTORY "${CTEST_BINARY_DIRECTORY}"
         RESULT_VARIABLE RES
         )
@@ -161,7 +154,6 @@ set(CTEST_CONFIGURATION_TYPE "${BUILD_TYPE}")
 
 set(_CONFIGURE_OPTIONS
     "-DBUILD_TOOLS=${BUILD_TOOLS}"
-    "-DBUILD_VIEWER=${BUILD_VIEWER}"
     "-DBUILD_TESTS=TRUE"
     "-DTEST_COVERAGE=${TEST_COVERAGE}"
     "-DSEPARATE_TEST_SUITES=${SEPARATE_TEST_SUITES}"
diff --git a/cmake/ctest/configure_darwin.ctest b/cmake/ctest/configure_darwin.ctest
index 39b2bb5ed..d62266f04 100644
--- a/cmake/ctest/configure_darwin.ctest
+++ b/cmake/ctest/configure_darwin.ctest
@@ -7,7 +7,6 @@ endif()
 set(CONFIGURE_EXTRA_OPTIONS ";")
 set(BUILD_EXTRA_FLAGS "")
 set(BUILD_TOOLS TRUE)
-set(BUILD_VIEWER TRUE)
 set(CHECK_IWYU FALSE)
 set(ENABLE_SANITIZERS "")
 
diff --git a/cmake/ctest/configure_linux.ctest b/cmake/ctest/configure_linux.ctest
index c02ee81fc..d22c6a98f 100644
--- a/cmake/ctest/configure_linux.ctest
+++ b/cmake/ctest/configure_linux.ctest
@@ -8,7 +8,6 @@ set(CONFIGURE_EXTRA_OPTIONS ";")
 set(BUILD_EXTRA_FLAGS "")
 
 set(BUILD_TOOLS TRUE)
-set(BUILD_VIEWER TRUE)
 set(CHECK_IWYU FALSE)
 set(ENABLE_SANITIZERS "address")
 
diff --git a/cmake/ctest/configure_windows.ctest b/cmake/ctest/configure_windows.ctest
index a89d56b97..f3fafccf8 100644
--- a/cmake/ctest/configure_windows.ctest
+++ b/cmake/ctest/configure_windows.ctest
@@ -30,6 +30,5 @@ set(BUILD_TYPE "${CONFIGURATION}")
 set(CONAN_ARCH "x86_64")
 
 set(BUILD_TOOLS TRUE)
-set(BUILD_VIEWER TRUE)
 set(CHECK_IWYU FALSE) #FIXME: ENABLE
 set(ENABLE_SANITIZERS "")
diff --git a/cmake_options.cmake b/cmake_options.cmake
index d0d10cb03..ec8766cd2 100644
--- a/cmake_options.cmake
+++ b/cmake_options.cmake
@@ -2,7 +2,6 @@ option(RW_VERBOSE_DEBUG_MESSAGES "Print verbose debugging messages" ON)
 
 option(BUILD_TOOLS "Build tools")
 option(BUILD_TESTS "Build test suite")
-option(BUILD_VIEWER "Build GUI data viewer")
 
 option(ENABLE_SCRIPT_DEBUG "Enable verbose script execution")
 option(ENABLE_PROFILING "Enable detailed profiling metrics")
diff --git a/conanfile.py b/conanfile.py
index 81a3dca04..86d47fbaa 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -9,13 +9,11 @@ class OpenrwConan(ConanFile):
     description = "OpenRW 'Open ReWrite' is an un-official open source recreation of the classic Grand Theft Auto III game executable"
     settings = 'os', 'compiler', 'build_type', 'arch'
     options = {
-        'viewer': [True, False],
         'tools': [True, False],
         'profiling': [True, False],
     }
 
     default_options = {
-        'viewer': True,
         'tools': True,
         'profiling': True,
         'bullet3:shared': False,
@@ -24,7 +22,7 @@ class OpenrwConan(ConanFile):
 
     generators = 'cmake',
     exports_sources = 'CMakeLists.txt', 'cmake_configure.cmake', 'cmake_options.cmake', 'CMakeCPack.cmake', 'COPYING', \
-                      'cmake/modules/*', 'benchmarks', 'rwcore/*', 'rwengine/*', 'rwgame/*', 'rwviewer/*', \
+                      'cmake/modules/*', 'benchmarks', 'rwcore/*', 'rwengine/*', 'rwgame/*', \
                       'rwtools/*', 'tests/*', 'external/*'
 
     _rw_dependencies = {
@@ -37,24 +35,15 @@ class OpenrwConan(ConanFile):
             'boost/1.68.0@conan/stable',
             'bzip2/1.0.8@conan/stable',
         ),
-        'viewer': (
-            'qt/5.12.0@bincrafters/stable',
-        ),
         'tools': (
             'freetype/2.9.0@bincrafters/stable',
+            'qt/5.12.0@bincrafters/stable',
         ),
     }
 
-    def configure(self):
-        if self.options.viewer:
-            self.options['qt'].opengl = 'desktop'
-
     def requirements(self):
         for dep in self._rw_dependencies['game']:
             self.requires(dep)
-        if self.options.viewer:
-            for dep in self._rw_dependencies['viewer']:
-                self.requires(dep)
         if self.options.tools:
             for dep in self._rw_dependencies['tools']:
                 self.requires(dep)
@@ -65,7 +54,6 @@ def _configure_cmake(self):
             'BUILD_SHARED_LIBS': False,
             'CMAKE_BUILD_TYPE': self.settings.build_type,
             'BUILD_TESTS': True,
-            'BUILD_VIEWER': self.options.viewer,
             'BUILD_TOOLS': self.options.tools,
             'ENABLE_PROFILING': self.options.profiling,
             'USE_CONAN': True,
@@ -80,9 +68,6 @@ def build(self):
         cmake.build()
 
     def package(self):
-        if self.options.viewer:
-            # FIXME: https://github.com/osechet/conan-qt/issues/6 and https://github.com/conan-io/conan/issues/2619
-            self.copy('qt.conf', dst='bin', src='rwviewer')
         cmake = self._configure_cmake()
         cmake.install()
 
diff --git a/rwgame/CMakeLists.txt b/rwgame/CMakeLists.txt
index 86e302004..f50778673 100644
--- a/rwgame/CMakeLists.txt
+++ b/rwgame/CMakeLists.txt
@@ -45,6 +45,11 @@ add_library(librwgame STATIC
     states/DebugState.cpp
     states/BenchmarkState.hpp
     states/BenchmarkState.cpp
+
+    viewer/RWViewer.hpp
+    viewer/RWViewer.cpp
+    viewer/RWViewerWindows.hpp
+    viewer/RWViewerWindows.cpp
     )
 
 openrw_target_apply_options(
diff --git a/rwgame/RWConfig.inc b/rwgame/RWConfig.inc
index 17494a91d..9b0169948 100644
--- a/rwgame/RWConfig.inc
+++ b/rwgame/RWConfig.inc
@@ -23,3 +23,5 @@ RWARG_OPT(  std::string,    loadGamePath,
 RWCONFIGARG(std::string,    gameLanguage,   "american",             "game.language",        GAME,       "language",     "LANGUAGE", "Language")
 
 RWARG(      bool,           help,                                                           GENERAL,    "help",         nullptr,    "Show this help message")
+
+RWARG(      bool,           viewer,                                                         GENERAL,    "viewer",       nullptr,    "Data Viewer")
diff --git a/rwgame/RWGame.cpp b/rwgame/RWGame.cpp
index e2e539d72..257159a4f 100644
--- a/rwgame/RWGame.cpp
+++ b/rwgame/RWGame.cpp
@@ -1,7 +1,5 @@
 #include "RWGame.hpp"
 
-#include <glm/gtx/norm.hpp>
-
 #include "RWImGui.hpp"
 #include "GameInput.hpp"
 #include "State.hpp"
@@ -12,20 +10,21 @@
 #include "states/MenuState.hpp"
 
 #include <core/Profiler.hpp>
-
 #include <engine/Payphone.hpp>
 #include <engine/SaveGame.hpp>
-#include <objects/GameObject.hpp>
-
 #include <script/SCMFile.hpp>
-
 #include <ai/AIGraphNode.hpp>
 #include <ai/PlayerController.hpp>
 #include <core/Logger.hpp>
 #include <objects/CharacterObject.hpp>
 #include <objects/VehicleObject.hpp>
 
+#include <imgui.h>
+
+#include <glm/gtx/norm.hpp>
+
 #include <boost/algorithm/string/predicate.hpp>
+
 #include <functional>
 #include <iomanip>
 #include <iostream>
@@ -47,6 +46,121 @@ static constexpr std::array<
                     {GameRenderer::Arrow, "arrow.dff", ""}}};
 
 constexpr float kMaxPhysicsSubSteps = 2;
+
+void WindowDebugStats(RWGame& game) {
+    auto& io = ImGui::GetIO();
+
+    auto time_ms = 1000.0f / io.Framerate;
+    constexpr size_t average_every_frame = 240;
+    static float times[average_every_frame];
+    static size_t times_index = 0;
+    static float time_average = 0, time_min = 0, time_max = 0;
+    times[times_index++] = time_ms;
+    if (times_index >= average_every_frame) {
+        times_index = 0;
+        time_average = 0;
+        time_min = std::numeric_limits<float>::max();
+        time_max = std::numeric_limits<float>::lowest();
+
+        for (auto time : times) {
+            time_average += time;
+            time_min = std::min(time, time_min);
+            time_max = std::max(time, time_max);
+        }
+        time_average /= average_every_frame;
+    }
+
+    const auto& world = game.getWorld();
+    auto& renderer = game.getRenderer();
+
+    ImGui::SetNextWindowPos({20.f, 20.f});
+    ImGui::Begin("Engine Information", nullptr,
+                 ImGuiWindowFlags_NoDecoration |
+                     ImGuiWindowFlags_NoSavedSettings |
+                     ImGuiWindowFlags_NoInputs);
+    ImGui::Text("%.3f ms/frame (%.1f FPS)\n%.3f / %.3f / %.3f ms",
+                static_cast<double>(1000.0f / io.Framerate),
+                static_cast<double>(io.Framerate),
+                static_cast<double>(time_average),
+                static_cast<double>(time_min),
+                static_cast<double>(time_max));
+    ImGui::Text("Timescale %.2f",
+                static_cast<double>(world->state->basic.timeScale));
+    ImGui::Text("%i Drawn %lu Culled", renderer.getRenderer().getDrawCount(),
+                renderer.getCulledCount());
+    ImGui::Text("%i Textures %i Buffers",
+                renderer.getRenderer().getTextureCount(),
+                renderer.getRenderer().getBufferCount());
+    ImGui::End();
+}
+
+void WindowDebugObjects(RWGame& game, const ViewCamera& camera) {
+    auto& data = game.getGameData();
+    auto world = game.getWorld();
+
+    ImGui::SetNextWindowPos({20.f, 20.f});
+    ImGui::Begin("Object Information", nullptr,
+                 ImGuiWindowFlags_NoDecoration |
+                     ImGuiWindowFlags_NoSavedSettings |
+                     ImGuiWindowFlags_NoInputs);
+    ImGui::Text("%lu Models", data.modelinfo.size());
+    ImGui::Text("Dynamic Objects\n %lu Vehicles\n %lu Peds",
+                world->vehiclePool.objects.size(),
+                world->pedestrianPool.objects.size());
+    ImGui::End();
+
+    // Render worldspace overlay for nearby objects
+    constexpr float kNearbyDistance = 25.f;
+    const auto& view = camera.position;
+    const auto& model = camera.getView();
+    const auto& proj = camera.frustum.projection();
+    const auto& size = game.getWindow().getSize();
+    glm::vec4 viewport(0.f, 0.f, size.x, size.y);
+    auto isnearby = [&](GameObject* o) {
+        return glm::distance2(o->getPosition(), view) <
+               kNearbyDistance * kNearbyDistance;
+    };
+    auto showdata = [&](GameObject* o, std::stringstream& ss) {
+        auto screen = glm::project(o->getPosition(), model, proj, viewport);
+        if (screen.z >= 1.f) {
+            return;
+        }
+        ImGui::SetNextWindowPos({screen.x, viewport.w - screen.y}, 0,
+                                {0.5f, 0.5f});
+        ImGui::Begin(
+            std::to_string(reinterpret_cast<uintptr_t>(o)).c_str(), nullptr,
+            ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings |
+                ImGuiWindowFlags_NoInputs);
+        ImGui::Text("%s", ss.str().c_str());
+        ImGui::End();
+    };
+
+    for (auto& [id, obj] : world->vehiclePool.objects) {
+        if (!isnearby(obj.get())) continue;
+        auto v = static_cast<VehicleObject*>(obj.get());
+
+        std::stringstream ss;
+        ss << v->getVehicle()->vehiclename_ << "\n"
+           << (v->isFlipped() ? "Flipped" : "Upright") << "\n"
+           << (v->isStopped() ? "Stopped" : "Moving") << "\n"
+           << v->getVelocity() << "m/s\n";
+
+        showdata(v, ss);
+    }
+    for (auto& [id, obj] : world->pedestrianPool.objects) {
+        if (!isnearby(obj.get())) continue;
+        auto c = static_cast<CharacterObject*>(obj.get());
+        const auto& state = c->getCurrentState();
+        auto act = c->controller->getCurrentActivity();
+
+        std::stringstream ss;
+        ss << "Health: " << state.health << " (" << state.armour << ")\n"
+           << (c->isAlive() ? "Alive" : "Dead") << "\n"
+           << "Activity: " << (act ? act->name() : "Idle") << "\n";
+
+        showdata(c, ss);
+    }
+}
 }  // namespace
 
 #define MOUSE_SENSITIVITY_SCALE 2.5f
@@ -669,7 +783,7 @@ void RWGame::render(float alpha, float time) {
 
     renderer.getRenderer().popDebugGroup();
 
-    renderDebugView();
+    renderDebugView(viewCam);
 
     if (!world->isPaused()) hudDrawer.drawOnScreenText(world.get(), renderer);
 
@@ -678,10 +792,10 @@ void RWGame::render(float alpha, float time) {
         stateManager.draw(renderer);
     }
 
-    imgui.endFrame(viewCam);
+    imgui.endFrame();
 }
 
-void RWGame::renderDebugView() {
+void RWGame::renderDebugView(const ViewCamera& viewCam) {
     RW_PROFILE_SCOPE(__func__);
     switch (debugview_) {
         case DebugViewMode::Physics:
@@ -691,6 +805,12 @@ void RWGame::renderDebugView() {
         case DebugViewMode::Navigation:
             renderDebugPaths();
             break;
+        case RWGame::DebugViewMode::General:
+            WindowDebugStats(*this);
+            break;
+        case RWGame::DebugViewMode::Objects:
+            WindowDebugObjects(*this, viewCam);
+            break;
         default:
             break;
     }
diff --git a/rwgame/RWGame.hpp b/rwgame/RWGame.hpp
index ffd11aba5..d0b6a5231 100644
--- a/rwgame/RWGame.hpp
+++ b/rwgame/RWGame.hpp
@@ -22,15 +22,6 @@
 #include <chrono>
 
 class RWGame final : public GameBase {
-public:
-    enum class DebugViewMode {
-        Disabled,
-        General,
-        Physics,
-        Navigation,
-        Objects
-    };
-
 private:
     GameData data;
     GameRenderer renderer;
@@ -50,6 +41,14 @@ class RWGame final : public GameBase {
     bool inFocus = true;
     ViewCamera currentCam;
 
+    enum class DebugViewMode {
+        Disabled,
+        General,
+        Physics,
+        Navigation,
+        Objects
+    };
+
     DebugViewMode debugview_ = DebugViewMode::Disabled;
     int lastDraws{0};  /// Number of draws issued for the last frame.
 
@@ -94,10 +93,6 @@ class RWGame final : public GameBase {
         return hudDrawer;
     }
 
-    DebugViewMode getDebugViewMode() const {
-        return debugview_;
-    }
-
     bool hitWorldRay(glm::vec3& hit, glm::vec3& normal,
                      GameObject** object = nullptr);
 
@@ -128,7 +123,7 @@ class RWGame final : public GameBase {
 
     float tickWorld(const float deltaTime, float accumulatedTime);
 
-    void renderDebugView();
+    void renderDebugView(const ViewCamera&);
 
     void tickObjects(float dt) const;
 };
diff --git a/rwgame/RWImGui.cpp b/rwgame/RWImGui.cpp
index 6ee496a5b..ad15c4363 100644
--- a/rwgame/RWImGui.cpp
+++ b/rwgame/RWImGui.cpp
@@ -15,123 +15,7 @@
 #include <gl/gl_core_3_3.h>
 #include <glm/gtx/norm.hpp>
 
-namespace {
-void WindowDebugStats(RWGame& game) {
-    auto& io = ImGui::GetIO();
-
-    auto time_ms = 1000.0f / io.Framerate;
-    constexpr size_t average_every_frame = 240;
-    static float times[average_every_frame];
-    static size_t times_index = 0;
-    static double time_average = 0, time_min = 0, time_max = 0;
-    times[times_index++] = time_ms;
-    if (times_index >= average_every_frame) {
-        times_index = 0;
-        time_average = 0;
-        time_min = std::numeric_limits<double>::max();
-        time_max = std::numeric_limits<double>::lowest();
-
-        for (double time : times) {
-            time_average += time;
-            time_min = std::min(time, time_min);
-            time_max = std::max(time, time_max);
-        }
-        time_average /= average_every_frame;
-    }
-
-    const auto& world = game.getWorld();
-    auto& renderer = game.getRenderer();
-
-    ImGui::SetNextWindowPos({20.f, 20.f});
-    ImGui::Begin("Engine Information", nullptr,
-                 ImGuiWindowFlags_NoDecoration |
-                     ImGuiWindowFlags_NoSavedSettings |
-                     ImGuiWindowFlags_NoInputs);
-    ImGui::Text("%.3f ms/frame (%.1f FPS)\n%.3f / %.3f / %.3f ms",
-                static_cast<double>(1000.0f / io.Framerate),
-                static_cast<double>(io.Framerate), time_average, time_min,
-                time_max);
-    ImGui::Text("Timescale %.2f",
-                static_cast<double>(world->state->basic.timeScale));
-    ImGui::Text("%i Drawn %lu Culled", renderer.getRenderer().getDrawCount(),
-                renderer.getCulledCount());
-    ImGui::Text("%i Textures %i Buffers",
-                renderer.getRenderer().getTextureCount(),
-                renderer.getRenderer().getBufferCount());
-    ImGui::End();
-}
-
-void WindowDebugObjects(RWGame& game, const ViewCamera& camera) {
-    auto& data = game.getGameData();
-    auto world = game.getWorld();
-
-    ImGui::SetNextWindowPos({20.f, 20.f});
-    ImGui::Begin("Object Information", nullptr,
-                 ImGuiWindowFlags_NoDecoration |
-                     ImGuiWindowFlags_NoSavedSettings |
-                     ImGuiWindowFlags_NoInputs);
-    ImGui::Text("%lu Models", data.modelinfo.size());
-    ImGui::Text("Dynamic Objects\n %lu Vehicles\n %lu Peds",
-                world->vehiclePool.objects.size(),
-                world->pedestrianPool.objects.size());
-    ImGui::End();
-
-    // Render worldspace overlay for nearby objects
-    constexpr float kNearbyDistance = 25.f;
-    const auto& view = camera.position;
-    const auto& model = camera.getView();
-    const auto& proj = camera.frustum.projection();
-    const auto& size = game.getWindow().getSize();
-    glm::vec4 viewport(0.f, 0.f, size.x, size.y);
-    auto isnearby = [&](GameObject* o) {
-        return glm::distance2(o->getPosition(), view) <
-               kNearbyDistance * kNearbyDistance;
-    };
-    auto showdata = [&](GameObject* o, std::stringstream& ss) {
-        auto screen = glm::project(o->getPosition(), model, proj, viewport);
-        if (screen.z >= 1.f) {
-            return;
-        }
-        ImGui::SetNextWindowPos({screen.x, viewport.w - screen.y}, 0,
-                                {0.5f, 0.5f});
-        ImGui::Begin(
-            std::to_string(reinterpret_cast<uintptr_t>(o)).c_str(), nullptr,
-            ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings |
-                ImGuiWindowFlags_NoInputs);
-        ImGui::Text("%s", ss.str().c_str());
-        ImGui::End();
-    };
-
-    for (auto& p : world->vehiclePool.objects) {
-        if (!isnearby(p.second.get())) continue;
-        auto v = static_cast<VehicleObject*>(p.second.get());
-
-        std::stringstream ss;
-        ss << v->getVehicle()->vehiclename_ << "\n"
-           << (v->isFlipped() ? "Flipped" : "Upright") << "\n"
-           << (v->isStopped() ? "Stopped" : "Moving") << "\n"
-           << v->getVelocity() << "m/s\n";
-
-        showdata(v, ss);
-    }
-    for (auto& p : world->pedestrianPool.objects) {
-        if (!isnearby(p.second.get())) continue;
-        auto c = static_cast<CharacterObject*>(p.second.get());
-        const auto& state = c->getCurrentState();
-        auto act = c->controller->getCurrentActivity();
-
-        std::stringstream ss;
-        ss << "Health: " << state.health << " (" << state.armour << ")\n"
-           << (c->isAlive() ? "Alive" : "Dead") << "\n"
-           << "Activity: " << (act ? act->name() : "Idle") << "\n";
-
-        showdata(c, ss);
-    }
-}
-}  // namespace
-
-RWImGui::RWImGui(RWGame &game)
-    : _game(game) {
+RWImGui::RWImGui(GameBase& game) : _game(game) {
 }
 
 RWImGui::~RWImGui() {
@@ -182,18 +66,7 @@ void RWImGui::startFrame() {
     ImGui::NewFrame();
 }
 
-void RWImGui::endFrame(const ViewCamera& camera) {
-    switch (_game.getDebugViewMode()) {
-        case RWGame::DebugViewMode::General:
-            WindowDebugStats(_game);
-            break;
-        case RWGame::DebugViewMode::Objects:
-            WindowDebugObjects(_game, camera);
-            break;
-        default:
-            break;
-    }
-
+void RWImGui::endFrame() {
     static bool show_demo_window = false;
     if (show_demo_window) {
         ImGui::ShowDemoWindow(&show_demo_window);
diff --git a/rwgame/RWImGui.hpp b/rwgame/RWImGui.hpp
index 765d0a3ae..b214c41da 100644
--- a/rwgame/RWImGui.hpp
+++ b/rwgame/RWImGui.hpp
@@ -3,21 +3,21 @@
 
 #include <SDL.h>
 
-class RWGame;
+class GameBase;
 struct ImGuiContext;
 class ViewCamera;
 
 class RWImGui {
-    RWGame &_game;
+    GameBase &_game;
     ImGuiContext *_context = nullptr;
 public:
-    RWImGui(RWGame &game);
+    RWImGui(GameBase &game);
     ~RWImGui();
     void init();
     void destroy();
     bool processEvent(SDL_Event &event);
     void startFrame();
-    void endFrame(const ViewCamera &);
+    void endFrame();
 };
 
 #endif // RWGAME_RWIMGUI_HPP
diff --git a/rwgame/main.cpp b/rwgame/main.cpp
index 674e0c8a7..246ad8393 100644
--- a/rwgame/main.cpp
+++ b/rwgame/main.cpp
@@ -2,8 +2,9 @@
 
 #include <iostream>
 
-#include "RWGame.hpp"
 #include <SDL.h>
+#include "RWGame.hpp"
+#include "viewer/RWViewer.hpp"
 
 #include <core/Logger.hpp>
 
@@ -28,9 +29,13 @@ int main(int argc, const char* argv[]) {
     SDL_SetMainReady();
 
     try {
-        RWGame game(logger, argLayerOpt);
-
-        return game.run();
+        if (argLayerOpt->viewer) {
+            RWViewer game(logger, argLayerOpt);
+            return game.run();
+        } else {
+            RWGame game(logger, argLayerOpt);
+            return game.run();
+        }
     } catch (std::runtime_error& ex) {
         // Catch runtime_error as these are fatal issues the user may want to
         // know about like corrupted files or GL initialisation failure.
diff --git a/rwgame/viewer/RWViewer.cpp b/rwgame/viewer/RWViewer.cpp
new file mode 100644
index 000000000..632647a70
--- /dev/null
+++ b/rwgame/viewer/RWViewer.cpp
@@ -0,0 +1,396 @@
+#include "RWViewer.hpp"
+
+#include "GameInput.hpp"
+#include "RWImGui.hpp"
+
+#include <core/Logger.hpp>
+#include <core/Profiler.hpp>
+#include <objects/CharacterObject.hpp>
+#include <objects/InstanceObject.hpp>
+#include <objects/VehicleObject.hpp>
+
+#include <imgui.h>
+
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtx/norm.hpp>
+#include <glm/gtx/quaternion.hpp>
+
+#include <array>
+
+#include <string.h>
+
+namespace {
+static constexpr std::array<
+    std::tuple<GameRenderer::SpecialModel, char const*, char const*>, 3>
+    kSpecialModels{{{GameRenderer::ZoneCylinderA, "zonecyla.dff", "particle"},
+                    {GameRenderer::ZoneCylinderB, "zonecylb.dff", "particle"},
+                    {GameRenderer::Arrow, "arrow.dff", ""}}};
+const auto kViewerFov = glm::radians(90.f);
+
+auto viewAnglesToQuat(float yaw, float pitch) {
+    return glm::angleAxis(glm::radians(yaw), glm::vec3(0.f, 0.f, -1.f)) *
+           glm::angleAxis(glm::radians(pitch), glm::vec3(0.f, 1.f, 0.f));
+}
+}  // namespace
+
+RWViewer::RWViewer(Logger& log, const std::optional<RWArgConfigLayer>& args)
+    : GameBase(log, args)
+    , data_(&log, config.gamedataPath())
+    , renderer_(&log, &data_)
+    , imgui_(*this) {
+    RW_PROFILE_THREAD("Main");
+    RW_TIMELINE_ENTER("Startup", MP_YELLOW);
+
+    log.info("Game", "Game directory: " + config.gamedataPath());
+
+    if (!GameData::isValidGameDirectory(config.gamedataPath())) {
+        throw std::runtime_error("Invalid game directory path: " +
+                                 config.gamedataPath());
+    }
+
+    imgui_.init();
+
+    data_.load();
+    textViewer_.emplace(data_);
+    iplViewer_.emplace(log, data_);
+
+    for (const auto& [specialModel, fileName, name] : kSpecialModels) {
+        auto model = data_.loadClump(fileName, name);
+        renderer_.setSpecialModel(specialModel, model);
+    }
+
+    // Set up text renderer_
+    renderer_.text.setFontTexture(FONT_PAGER, "pager");
+    renderer_.text.setFontTexture(FONT_PRICEDOWN, "font1");
+    renderer_.text.setFontTexture(FONT_ARIAL, "font2");
+
+    data_.loadDynamicObjects(
+        (rwfs::path{config.gamedataPath()} / "data/object.dat")
+            .string());  // FIXME: use path
+
+    data_.loadGXT("text/" + config.gameLanguage() + ".gxt");
+
+    world_ = std::make_unique<GameWorld>(&log, &data_);
+    world_->state = &state_;
+
+    log.info("Game", "Started");
+    RW_TIMELINE_LEAVE("Startup");
+}
+
+RWViewer::~RWViewer() {
+    log.info("Game", "Beginning cleanup");
+}
+
+int RWViewer::run() {
+    namespace chrono = std::chrono;
+
+    auto lastFrame = chrono::steady_clock::now();
+
+    while (continue_) {
+        RW_PROFILE_FRAME_BOUNDARY();
+        RW_PROFILE_SCOPE("Main Loop");
+
+        continue_ = updateInput();
+
+        auto currentFrame = chrono::steady_clock::now();
+        auto frameTime =
+            chrono::duration<float>(currentFrame - lastFrame).count();
+        lastFrame = currentFrame;
+
+        render(1, frameTime);
+
+        getWindow().swap();
+    }
+
+    return 0;
+}
+
+bool RWViewer::updateInput() {
+    RW_PROFILE_SCOPE(__func__);
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+        if (imgui_.processEvent(event)) {
+            continue;
+        }
+        switch (event.type) {
+            case SDL_QUIT:
+                return false;
+
+            case SDL_WINDOWEVENT:
+                switch (event.window.event) {
+                    case SDL_WINDOWEVENT_FOCUS_GAINED:
+                        break;
+
+                    case SDL_WINDOWEVENT_FOCUS_LOST:
+                        break;
+                }
+                break;
+
+            case SDL_KEYDOWN:
+                globalKeyEvent(event);
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                if (event.button.button == 1) mouseMode_ = MouseMode::Dragging;
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                if (event.button.button == 1) mouseMode_ = MouseMode::Hovering;
+                break;
+
+            case SDL_MOUSEWHEEL:
+                viewAngles_.z =
+                    glm::max(1.f, viewAngles_.z +
+                                      -(event.wheel.y * viewAngles_.z * 0.1f));
+                break;
+
+            case SDL_MOUSEMOTION:
+                if (mouseMode_ == MouseMode::Dragging) {
+                    viewAngles_.x += event.motion.xrel * 0.5f;
+                    viewAngles_.y += event.motion.yrel * 0.5f;
+                }
+                break;
+        }
+    }
+    return true;
+}
+
+void RWViewer::tick(float dt) {
+    RW_UNUSED(dt);
+    RW_PROFILE_SCOPE(__func__);
+}
+
+void RWViewer::render(float alpha, float time) {
+    RW_PROFILE_SCOPEC(__func__, MP_CORNFLOWERBLUE);
+    RW_UNUSED(time);
+
+    getRenderer().getRenderer().swap();
+    imgui_.startFrame();
+
+    glm::ivec2 windowSize = getWindow().getSize();
+    renderer_.setViewport(windowSize.x, windowSize.y);
+
+    ViewCamera viewCam{};
+    viewCam.frustum.fov = kViewerFov;
+    viewCam.frustum.aspectRatio =
+        windowSize.x / static_cast<float>(windowSize.y);
+
+    viewCam.rotation = viewAnglesToQuat(viewAngles_.x, viewAngles_.y);
+
+    glEnable(GL_DEPTH_TEST);
+    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+    renderer_.getRenderer().pushDebugGroup("World");
+
+    switch (viewMode_) {
+        case ViewMode::Model: {
+            auto viewDirection = viewCam.rotation * glm::vec3{-1.f, 0.f, 0.f};
+            viewCam.position = viewDirection * viewAngles_.z;
+            renderer_.renderWorld(world_.get(), viewCam, alpha);
+            break;
+        }
+        case ViewMode::World:
+            viewCam.position = viewPosition_;
+            renderer_.renderWorld(iplViewer_->world(), viewCam, alpha);
+            break;
+    }
+
+    renderer_.getRenderer().popDebugGroup();
+
+    drawWindows();
+    drawMenu();
+
+    imgui_.endFrame();
+}
+
+void RWViewer::globalKeyEvent(const SDL_Event& event) {
+    auto r = viewAnglesToQuat(viewAngles_.x, viewAngles_.y);
+    switch (event.key.keysym.sym) {
+        case SDLK_LEFTBRACKET:
+            world_->offsetGameTime(-30);
+            break;
+        case SDLK_RIGHTBRACKET:
+            world_->offsetGameTime(30);
+            break;
+
+        case SDLK_w:
+        case SDLK_UP:
+            viewPosition_ += r * glm::vec3{1.f, 0.f, 0.f};
+            break;
+        case SDLK_s:
+        case SDLK_DOWN:
+            viewPosition_ -= r * glm::vec3{1.f, 0.f, 0.f};
+            break;
+        case SDLK_a:
+        case SDLK_LEFT:
+            viewPosition_ += r * glm::vec3{0.f, 1.f, 0.f};
+            break;
+        case SDLK_d:
+        case SDLK_RIGHT:
+            viewPosition_ -= r * glm::vec3{0.f, 1.f, 0.f};
+            break;
+
+        default:
+            break;
+    }
+}
+
+void RWViewer::drawMenu() {
+    auto menu = [](const char* name, auto then) {
+        if (ImGui::BeginMenu(name)) then(), ImGui::EndMenu();
+    };
+
+    if (ImGui::BeginMainMenuBar()) {
+        menu("File", [&]() {
+            if (ImGui::MenuItem("Quit", "Alt+F4")) {
+                continue_ = false;
+            }
+        });
+        menu("View", [&]() {
+            if (ImGui::MenuItem("Model", "", viewMode_ == ViewMode::Model))
+                viewMode_ = ViewMode::Model;
+            if (ImGui::MenuItem("World", "", viewMode_ == ViewMode::World))
+                viewMode_ = ViewMode::World;
+            if (ImGui::MenuItem("Remove Object", "")) {
+                if (viewedObject_) {
+                    world_->destroyObject(viewedObject_);
+                    viewedObject_ = nullptr;
+                }
+            }
+        });
+        menu("Windows", [&]() {
+            ImGui::MenuItem("Models", "", &showModelList_);
+            ImGui::MenuItem("Texts", "", &showTextViewer_);
+            ImGui::MenuItem("Map", "", &showIplViewer_);
+            ImGui::Separator();
+            ImGui::MenuItem("Demo", "", &showImGuiDemo_);
+        });
+        ImGui::EndMainMenuBar();
+    }
+}
+
+void RWViewer::drawWindows() {
+    auto window = [](const char* name, bool& openWindow, const ImVec2& size,
+                     auto then) {
+        if (!openWindow) return;
+        ImGui::SetNextWindowSize(size, ImGuiCond_FirstUseEver);
+        if (ImGui::Begin(name, &openWindow)) then();
+        ImGui::End();
+    };
+
+    window("Models", showModelList_, {400, 180}, [&]() {
+        static ImGuiTextFilter filter;
+
+        filter.Draw();
+        {
+            ImGui::BeginChild("ModelList", ImVec2(0, 0), false);
+            ImGui::Columns(3);
+
+            ImGui::Text("Model");
+            ImGui::NextColumn();
+            ImGui::Text("ID");
+            ImGui::NextColumn();
+            ImGui::Text("Type");
+            ImGui::NextColumn();
+            ImGui::Separator();
+
+            auto& models = data_.modelinfo;
+            for (const auto& [id, info] : models) {
+                if (filter.PassFilter(info->name.c_str()) ||
+                    filter.PassFilter(std::to_string(id).c_str())) {
+                    bool selected = false;
+                    ImGui::PushID(id);
+                    if (ImGui::Selectable(
+                            info->name.c_str(), &selected,
+                            ImGuiSelectableFlags_SpanAllColumns |
+                                ImGuiSelectableFlags_AllowDoubleClick))
+                        if (ImGui::IsMouseDoubleClicked(0)) viewModel(id);
+                    if (ImGui::BeginPopupContextItem()) {
+                        if (ImGui::MenuItem("Details")) showModel(id);
+                        if (ImGui::MenuItem("View")) viewModel(id);
+                        ImGui::EndPopup();
+                    }
+                    ImGui::NextColumn();
+                    ImGui::Text("%u", id);
+                    ImGui::NextColumn();
+                    ImGui::Text(
+                        "%s", BaseModelInfo::getTypeName(info->type()).c_str());
+                    ImGui::NextColumn();
+                    ImGui::PopID();
+                }
+            }
+            ImGui::EndChild();
+        }
+    });
+
+    for (auto& id : showModels_) drawModelWindow(id);
+
+    window("Texts", showTextViewer_, {920, 320},
+           [&]() { textViewer_->draw(renderer_); });
+
+    window("Map", showIplViewer_, {320, 320},
+           [&]() { iplViewer_->draw(renderer_); });
+
+    if (showImGuiDemo_) ImGui::ShowDemoWindow(&showImGuiDemo_);
+}
+
+void RWViewer::drawModelWindow(ModelID id) {
+    std::stringstream ss;
+    ss << "Model " << id;
+
+    bool open = true;
+    ImGui::Begin(ss.str().c_str(), &open, ImGuiWindowFlags_NoCollapse);
+    if (!open) showModels_.erase(id);
+
+    auto it = data_.modelinfo.find(id);
+    if (it == data_.modelinfo.end()) {
+        ImGui::Text("Invalid Model");
+        ImGui::End();
+        return;
+    }
+    const auto& info = it->second;
+
+    ImGui::Text("%s", info->name.c_str());
+    ImGui::Text("%s", BaseModelInfo::getTypeName(info->type()).c_str());
+    if (info->type() == ModelDataType::VehicleInfo) {
+        auto& vehicle = static_cast<VehicleModelInfo&>(*info);
+        ImGui::Text("Vehicle Name: %s", vehicle.vehiclename_.c_str());
+    }
+
+    ImGui::End();
+}
+
+void RWViewer::viewModel(ModelID model) {
+    viewMode_ = ViewMode::Model;
+    if (viewedObject_) {
+        world_->destroyObject(viewedObject_);
+        viewedObject_ = nullptr;
+    }
+
+    auto it = data_.modelinfo.find(model);
+    if (it == data_.modelinfo.end()) {
+        return;
+    }
+    const auto& info = it->second;
+
+    if (info->type() == ModelDataType::VehicleInfo) {
+        viewedObject_ = world_->createVehicle(model, {}, {1.f, 0.f, 0.f, 0.f});
+    }
+    if (info->type() == ModelDataType::SimpleInfo) {
+        viewedObject_ = world_->createInstance(model, {}, {1.f, 0.f, 0.f, 0.f});
+    }
+    if (info->type() == ModelDataType::PedInfo) {
+        viewedObject_ =
+            world_->createPedestrian(model, {}, {1.f, 0.f, 0.f, 0.f});
+    }
+
+    float radius = 10.f;
+    if (auto clump = viewedObject_->getClump(); clump)
+        radius = clump->getBoundingRadius();
+    if (auto atomic = viewedObject_->getAtomic(); atomic) {
+        auto& geo = atomic->getGeometry()->geometryBounds;
+        radius = glm::length(geo.center) + geo.radius;
+    }
+    constexpr auto kViewSlop = 1.f;
+    viewAngles_.z = kViewSlop * ((radius * 2) / (glm::tan(kViewerFov / 2.f)));
+}
diff --git a/rwgame/viewer/RWViewer.hpp b/rwgame/viewer/RWViewer.hpp
new file mode 100644
index 000000000..f519db54d
--- /dev/null
+++ b/rwgame/viewer/RWViewer.hpp
@@ -0,0 +1,92 @@
+#ifndef RWGAME_RWVIEWER_HPP
+#define RWGAME_RWVIEWER_HPP
+
+#include "GameBase.hpp"
+#include "RWConfig.hpp"
+#include "RWImGui.hpp"
+#include "RWViewerWindows.hpp"
+#include "game.hpp"
+
+#include <engine/GameData.hpp>
+#include <engine/GameState.hpp>
+#include <engine/GameWorld.hpp>
+#include <fonts/GameTexts.hpp>
+#include <render/DebugDraw.hpp>
+#include <render/GameRenderer.hpp>
+
+#include <SDL_events.h>
+
+#include <chrono>
+#include <optional>
+#include <set>
+
+class RWViewer final : public GameBase {
+public:
+    RWViewer(Logger& log, const std::optional<RWArgConfigLayer>& args);
+    ~RWViewer() override;
+
+    int run();
+
+    GameWorld* getWorld() {
+        return world_.get();
+    }
+
+    const GameData& getGameData() const {
+        return data_;
+    }
+
+    GameRenderer& getRenderer() {
+        return renderer_;
+    }
+
+private:
+    void tick(float dt);
+    void render(float alpha, float dt);
+
+    void globalKeyEvent(const SDL_Event& event);
+
+    bool updateInput();
+
+    void drawMenu();
+    void drawWindows();
+
+    void drawModelWindow(ModelID);
+
+    void showModel(ModelID model) {
+        showModels_.insert(model);
+    }
+
+    void viewModel(ModelID model);
+
+    GameData data_;
+    GameRenderer renderer_;
+    GameState state_;
+    RWImGui imgui_;
+
+    std::unique_ptr<GameWorld> world_;
+
+    bool continue_ = true;
+
+    bool showModelList_ = false;
+    bool showTextViewer_ = false;
+    std::optional<TextViewer> textViewer_;
+    bool showImGuiDemo_ = false;
+    bool showIplViewer_ = false;
+    std::optional<IPLViewer> iplViewer_;
+    std::set<ModelID> showModels_;
+
+    enum class ViewMode {
+        World,
+        Model,
+    };
+    ViewMode viewMode_ = ViewMode::World;
+    enum class MouseMode { Hovering, Dragging };
+    MouseMode mouseMode_ = MouseMode::Hovering;
+
+    GameObject* viewedObject_ = nullptr;
+    glm::vec3 viewAngles_{};
+
+    glm::vec3 viewPosition_{};
+};
+
+#endif
diff --git a/rwgame/viewer/RWViewerWindows.cpp b/rwgame/viewer/RWViewerWindows.cpp
new file mode 100644
index 000000000..cfaa6f798
--- /dev/null
+++ b/rwgame/viewer/RWViewerWindows.cpp
@@ -0,0 +1,208 @@
+#include <viewer/RWViewerWindows.hpp>
+
+#include <engine/GameWorld.hpp>
+#include <loaders/LoaderGXT.hpp>
+#include <objects/InstanceObject.hpp>
+#include <platform/FileHandle.hpp>
+
+#include <imgui.h>
+
+#include <algorithm>
+
+namespace {
+std::array<int, 3> kFonts{{FONT_PAGER, FONT_PRICEDOWN, FONT_ARIAL}};
+std::array<const char*, 3> kFontNames{{"Pager", "Pricedown", "Arial"}};
+
+std::vector<std::string> getFontTextureNames(GameData& data) {
+    const auto& gameDataPath = rwfs::path(data.getDataPath());
+    rwfs::path textPath;
+    for (const rwfs::path& p : rwfs::directory_iterator(gameDataPath)) {
+        if (!rwfs::is_directory(p)) {
+            continue;
+        }
+        std::string filename = p.filename().string();
+        std::transform(filename.begin(), filename.end(), filename.begin(),
+                       ::tolower);
+        if (filename == "text") {
+            textPath = p;
+            break;
+        }
+    }
+    if (!textPath.string().length()) {
+        throw std::runtime_error("text directory not found in gamedata path");
+    }
+    std::vector<std::string> names;
+    for (const rwfs::path& p : rwfs::directory_iterator(textPath)) {
+        auto langName = p.filename().string();
+        std::transform(langName.begin(), langName.end(), langName.begin(),
+                       ::tolower);
+        names.emplace_back(std::move(langName));
+    }
+    return names;
+}
+}  // namespace
+
+TextViewer::TextViewer(GameData& data)
+    : data_(data), languages_(getFontTextureNames(data)) {
+    LoaderGXT loader;
+    for (const auto& textName : languages_) {
+        GameTexts texts;
+        auto handle = data.index.openFile(textName);
+        loader.load(texts, handle);
+        const auto& language = textName;
+        const auto& stringTable = texts.getStringTable();
+        for (const auto& tableItem : stringTable) {
+            texts_[tableItem.first][language] = {tableItem.second, ""};
+        }
+    }
+
+    cacheStrings();
+}
+
+void TextViewer::cacheStrings() {
+    for (auto& text : texts_) {
+        for (const auto& l : languages_) {
+            auto it = text.second.find(l);
+            if (it != text.second.end()) {
+                it->second.second = GameStringUtil::toString(
+                    it->second.first, kFonts[currentFont_]);
+            }
+        }
+    }
+}
+
+void TextViewer::draw(GameRenderer& r) {
+    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.15f);
+    if (ImGui::Combo("##font", &currentFont_, kFontNames.data(),
+                     kFontNames.size()))
+        cacheStrings();
+    ImGui::PopItemWidth();
+
+    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.1f);
+    ImGui::SameLine();
+    ImGui::InputFloat("##font_size", &currentFontSize_);
+    ImGui::PopItemWidth();
+
+    ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+    ImGui::SameLine();
+    if (ImGui::InputText("##font_text", previewStr_, 512)) {
+        previewText_ =
+            GameStringUtil::fromString(previewStr_, kFonts[currentFont_]);
+    }
+    ImGui::PopItemWidth();
+
+    ImGui::SameLine();
+    ImGui::Checkbox("Draw Preview", &drawPreview_);
+
+    ImGui::Columns(static_cast<int>(1 + languages_.size()));
+    ImGui::Text("Code");
+    ImGui::NextColumn();
+    for (const auto& l : languages_) {
+        ImGui::Text("%s", l.c_str());
+        ImGui::NextColumn();
+    }
+    ImGui::Separator();
+
+    for (const auto& [code, text] : texts_) {
+        ImGui::Text("%s", code.c_str());
+        ImGui::NextColumn();
+
+        for (const auto& l : languages_) {
+            auto it = text.find(l);
+            if (it != text.end()) {
+                if (ImGui::Selectable(it->second.second.c_str(), false,
+                                      ImGuiSelectableFlags_AllowDoubleClick)) {
+                    if (ImGui::IsMouseDoubleClicked(0)) {
+                        strncpy(previewStr_, it->second.second.c_str(), 512);
+                        previewText_ = it->second.first;
+                    }
+                }
+                if (ImGui::IsItemHovered())
+                    ImGui::SetTooltip("%s", it->second.second.c_str());
+            }
+            ImGui::NextColumn();
+        }
+    }
+
+    if (!drawPreview_) return;
+
+    {
+        TextRenderer::TextInfo ti;
+        ti.font = kFonts[currentFont_];
+        ti.size = currentFontSize_;
+        ti.baseColour = glm::u8vec3(255);
+        ti.backgroundColour = glm::u8vec4(0, 0, 0, 0);
+        ti.align = TextRenderer::TextInfo::TextAlignment::Left;
+        ti.wrapX = 0;
+
+        ti.text = previewText_;
+        ti.screenPosition = glm::vec2(10, 50);
+        r.text.renderText(ti, false);
+    }
+
+    {
+        TextRenderer::TextInfo ti;
+        ti.font = kFonts[currentFont_];
+        ti.size = currentFontSize_;
+        ti.baseColour = glm::u8vec3(255);
+        ti.backgroundColour = glm::u8vec4(0, 0, 0, 0);
+        ti.align = TextRenderer::TextInfo::TextAlignment::Left;
+        ti.wrapX = 0;
+
+        const auto ROW_STRIDE = currentFontSize_ * 1.2f;
+        const auto COL_STRIDE = currentFontSize_ * 1.2f;
+
+        for (GameStringChar c = 0x20; c < 0xb2; ++c) {
+            unsigned column = c % 0x10;
+            unsigned row = (c / 0x10) - 2 + 3; /* +3 to offset first line*/
+            ti.text = c;
+            ti.screenPosition =
+                glm::vec2(10 + (column * COL_STRIDE), 50 + (row * ROW_STRIDE));
+            r.text.renderText(ti, false);
+        }
+    }
+}
+
+IPLViewer::IPLViewer(Logger& log, GameData& data)
+    : data_(data), world_(std::make_unique<GameWorld>(&log, &data)) {
+    std::transform(begin(data_.iplLocations), end(data_.iplLocations),
+                   std::back_inserter(ipls_), [](const auto& a) -> IPLFileData {
+                       return {false, a.first, a.second, {}, {}};
+                   });
+    world_->state = &state_;
+}
+
+void IPLViewer::draw(GameRenderer& r) {
+    for (auto& ipl : ipls_) {
+        if (ImGui::Checkbox(ipl.name.c_str(), &ipl.enabled)) {
+            if (ipl.enabled)
+                showIPL(ipl);
+            else
+                hideIPL(ipl);
+        }
+    }
+}
+
+void IPLViewer::showIPL(IPLViewer::IPLFileData& ipl) {
+    if (ipl.loader.m_instances.empty()) {
+        ipl.loader.load(ipl.path);
+    }
+
+    for (const auto& inst : ipl.loader.m_instances) {
+        auto instance = world_->createInstance(inst.id, inst.pos, inst.rot);
+        if (!instance) {
+            world_->logger->error("World", "No object data for instance " +
+                                               std::to_string(inst.id) +
+                                               " in " + ipl.name);
+        } else {
+            ipl.objects.push_back(instance);
+        }
+    }
+}
+
+void IPLViewer::hideIPL(IPLViewer::IPLFileData& ipl) {
+    for (auto& object : ipl.objects) {
+        world_->destroyObject(object);
+    }
+    ipl.objects.clear();
+}
diff --git a/rwgame/viewer/RWViewerWindows.hpp b/rwgame/viewer/RWViewerWindows.hpp
new file mode 100644
index 000000000..0160f941a
--- /dev/null
+++ b/rwgame/viewer/RWViewerWindows.hpp
@@ -0,0 +1,63 @@
+#ifndef RWGAME_RWVIEWERWINDOWS_HPP
+#define RWGAME_RWVIEWERWINDOWS_HPP
+
+#include <engine/GameData.hpp>
+#include <engine/GameState.hpp>
+#include <fonts/GameTexts.hpp>
+#include <loaders/LoaderIPL.hpp>
+#include <objects/GameObject.hpp>
+#include <render/GameRenderer.hpp>
+
+#include <core/Logger.hpp>
+
+#include <string>
+#include <vector>
+
+class TextViewer {
+public:
+    explicit TextViewer(GameData& data);
+
+    void cacheStrings();
+    void draw(GameRenderer& r);
+
+private:
+    GameData& data_;
+    std::vector<std::string> languages_;
+    int currentFont_ = 0;
+    float currentFontSize_ = 20.f;
+    using StringPair = std::pair<GameString, std::string>;
+    std::map<GameStringKey, std::map<std::string, StringPair>> texts_;
+    char previewStr_[512] = {};
+    GameString previewText_;
+    bool drawPreview_ = true;
+};
+
+class IPLViewer {
+public:
+    IPLViewer(Logger&, GameData& data);
+
+    void draw(GameRenderer& r);
+
+    GameWorld* world() const {
+        return world_.get();
+    }
+
+private:
+    struct IPLFileData {
+        bool enabled;
+        std::string name;
+        std::string path;
+        LoaderIPL loader;
+        std::vector<GameObject*> objects;
+    };
+
+    void showIPL(IPLFileData&);
+    void hideIPL(IPLFileData&);
+
+    GameData& data_;
+    GameState state_;
+    std::unique_ptr<GameWorld> world_;
+    std::vector<IPLFileData> ipls_;
+};
+
+#endif  // RWGAME_RWVIEWERWINDOWS_HPP
diff --git a/rwviewer/CMakeLists.txt b/rwviewer/CMakeLists.txt
deleted file mode 100644
index d20c237d4..000000000
--- a/rwviewer/CMakeLists.txt
+++ /dev/null
@@ -1,67 +0,0 @@
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_INCLUDE_CURRENT_DIR ON)
-
-find_package(Qt5OpenGL REQUIRED)
-find_package(Qt5Widgets REQUIRED)
-
-add_executable(rwviewer
-    main.cpp
-
-    ViewerWindow.hpp
-    ViewerWindow.cpp
-    
-    models/AnimationListModel.hpp
-    models/AnimationListModel.cpp
-    models/ObjectListModel.hpp
-    models/ObjectListModel.cpp
-    models/DFFFramesTreeModel.hpp
-    models/DFFFramesTreeModel.cpp
-    models/IMGArchiveModel.hpp
-    models/IMGArchiveModel.cpp
-    models/ItemListModel.hpp
-    models/ItemListModel.cpp
-    models/TextModel.hpp
-    models/TextModel.cpp
-
-    views/ObjectViewer.hpp
-    views/ObjectViewer.cpp
-    views/ModelViewer.hpp
-    views/ModelViewer.cpp
-    views/TextViewer.hpp
-    views/TextViewer.cpp
-    views/WorldViewer.hpp
-    views/WorldViewer.cpp
-    views/ViewerInterface.hpp
-    views/ViewerInterface.cpp
-    
-    QOpenGLContextWrapper.hpp
-    QOpenGLContextWrapper.cpp
-    ViewerWidget.hpp
-    ViewerWidget.cpp
-    
-    widgets/AnimationListWidget.hpp
-    widgets/AnimationListWidget.cpp
-    widgets/ItemListWidget.hpp
-    widgets/ItemListWidget.cpp
-    widgets/ModelFramesWidget.hpp
-    widgets/ModelFramesWidget.cpp
-    )
-
-target_link_libraries(rwviewer
-    PRIVATE
-        rwengine
-        Qt5::OpenGL
-        Qt5::Widgets
-    )
-
-openrw_target_apply_options(
-    TARGET rwviewer
-    CORE
-    COVERAGE
-    INSTALL INSTALL_PDB
-    )
-
-if(USE_CONAN)
-    set(QT5_ROOT "${CONAN_QT_ROOT}")
-    configure_file(qt.conf.in qt.conf)
-endif()
diff --git a/rwviewer/QOpenGLContextWrapper.cpp b/rwviewer/QOpenGLContextWrapper.cpp
deleted file mode 100644
index 1958f4956..000000000
--- a/rwviewer/QOpenGLContextWrapper.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "QOpenGLContextWrapper.hpp"
-
-#include <QApplication>
-#include <QMessageBox>
-#include <QOpenGLContext>
-
-QOpenGLContextWrapper::QOpenGLContextWrapper(QWidget *parent)
-    : m_parent(parent) {
-}
-
-void QOpenGLContextWrapper::setup(QSurfaceFormat format) {
-    m_context = new QOpenGLContext(m_parent);
-    m_context->setShareContext(QOpenGLContext::globalShareContext());
-    m_context->setFormat(format);
-}
-
-bool QOpenGLContextWrapper::create() {
-    if (!m_context->create()) {
-        QMessageBox::critical(m_parent, "OpenGL Failure",
-                              "Failed to create OpenGL context");
-        QApplication::exit(1);
-        return false;
-    }
-    return true;
-}
-
-bool QOpenGLContextWrapper::makeCurrent(QSurface *surface) {
-    return m_context->makeCurrent(surface);
-}
-
-void QOpenGLContextWrapper::doneCurrent() {
-    m_context->doneCurrent();
-}
-
-void QOpenGLContextWrapper::swapBuffers(QSurface *surface) {
-    m_context->swapBuffers(surface);
-}
diff --git a/rwviewer/QOpenGLContextWrapper.hpp b/rwviewer/QOpenGLContextWrapper.hpp
deleted file mode 100644
index 2df71a4a7..000000000
--- a/rwviewer/QOpenGLContextWrapper.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef _RWVIEWER_QOPENGLWRAPPER_HPP
-#define _RWVIEWER_QOPENGLWRAPPER_HPP
-
-#include <QSurfaceFormat>
-
-class QOpenGLContext;
-class QSurface;
-class QWidget;
-
-class QOpenGLContextWrapper {
-public:
-    QOpenGLContextWrapper(QWidget *parent);
-    void setup(QSurfaceFormat format);
-    bool create();
-
-    bool makeCurrent(QSurface *surface);
-    void doneCurrent();
-    void swapBuffers(QSurface *surface);
-
-    QOpenGLContext *get() {
-        return m_context;
-    }
-private:
-    QOpenGLContext *m_context;
-    QWidget *m_parent;
-};
-
-#endif
diff --git a/rwviewer/README.md b/rwviewer/README.md
deleted file mode 100644
index 9facc8ff1..000000000
--- a/rwviewer/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# RWViewer
-
-Qt Viewer for viewing contents of archives, viewing DFF models etc.
diff --git a/rwviewer/ViewerWidget.cpp b/rwviewer/ViewerWidget.cpp
deleted file mode 100644
index 952312fce..000000000
--- a/rwviewer/ViewerWidget.cpp
+++ /dev/null
@@ -1,369 +0,0 @@
-#include "ViewerWidget.hpp"
-
-#include "QOpenGLContextWrapper.hpp"
-
-#include <engine/Animator.hpp>
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-#include <glm/gtc/type_ptr.hpp>
-#include <objects/CharacterObject.hpp>
-#include <objects/InstanceObject.hpp>
-#include <objects/VehicleObject.hpp>
-#include <render/GameRenderer.hpp>
-#include <render/ObjectRenderer.hpp>
-#include <render/TextRenderer.hpp>
-
-#include <QFileDialog>
-#include <QMouseEvent>
-
-const float kViewFov = glm::radians(90.0f);
-
-namespace {
-ViewCamera OrbitCamera (const glm::vec2& viewPort, const glm::vec2& viewAngles,
-                        float viewDistance, glm::mat4& view, glm::mat4& proj)
-{
-    ViewCamera vc;
-    glm::vec3 eye(sin(viewAngles.x) * cos(viewAngles.y),
-                  cos(viewAngles.x) * cos(viewAngles.y), sin(viewAngles.y));
-
-    vc.position = eye * viewDistance;
-    vc.frustum.aspectRatio = viewPort.x / viewPort.y;
-    proj = vc.frustum.projection();
-    view = glm::lookAt(vc.position, {0.f, 0.f, 0.f}, {0.f, 0.f, 1.f});
-    vc.rotation = -glm::quat_cast(view);
-    vc.frustum.update(proj * view);
-    return vc;
-}
-}
-
-ViewerWidget::ViewerWidget(QOpenGLContextWrapper* context, QWindow* parent)
-    : QWindow(parent)
-    , m_context(context) {
-    setSurfaceType(OpenGLSurface);
-}
-
-struct WidgetVertex {
-    float x, y, z;
-    static const AttributeList vertex_attributes() {
-        return {{ATRS_Position, 3, sizeof(WidgetVertex), 0ul}};
-    }
-};
-
-std::vector<WidgetVertex> widgetVerts = {{-.5f, 0.f, 0.f}, {.5f, 0.f, 0.f},
-                                         {0.f, -.5f, 0.f}, {0.f, .5f, 0.f},
-                                         {0.f, 0.f, -.5f}, {0.f, 0.f, .5f}};
-
-void ViewerWidget::initGL() {
-    _frameWidgetDraw = new DrawBuffer;
-    _frameWidgetDraw->setFaceType(GL_LINES);
-    _frameWidgetGeom = new GeometryBuffer;
-    _frameWidgetGeom->uploadVertices(widgetVerts);
-    _frameWidgetDraw->addGeometry(_frameWidgetGeom);
-
-    glGenTextures(1, &whiteTex);
-    glBindTexture(GL_TEXTURE_2D, whiteTex);
-    GLuint tex = 0xFFFFFFFF;
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE,
-                 &tex);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-}
-
-void ViewerWidget::drawModel(GameRenderer& r, ClumpPtr& model) {
-    glm::mat4 view{1.0f}, proj{1.0f};
-    const auto& vc = OrbitCamera({width(), height()},
-                                 viewAngles,
-                                 viewDistance,
-                                 view, proj);
-
-    r.getRenderer().useProgram(r.worldProg.get());
-    r.getRenderer().setSceneParameters(
-            {proj, view, glm::vec4(0.15f), glm::vec4(0.7f), glm::vec4(1.f),
-             glm::vec4(0.f), 90.f, vc.frustum.far});
-    model->getFrame()->updateHierarchyTransform();
-
-    ObjectRenderer _renderer(world(), vc, 1.f);
-    RenderList renders;
-    _renderer.renderClump(model.get(), glm::mat4(1.0f), nullptr, renders);
-    r.getRenderer().drawBatched(renders);
-
-    drawFrameWidget(model->getFrame().get());
-    r.renderPostProcess();
-}
-
-void ViewerWidget::drawObject(GameRenderer &r, GameObject *object) {
-    glm::mat4 view{1.0f}, proj{1.0f};
-    const auto& vc = OrbitCamera({width(), height()},
-                                 viewAngles,
-                                 viewDistance,
-                                 view, proj);
-
-    r.getRenderer().useProgram(r.worldProg.get());
-    r.getRenderer().setSceneParameters(
-            {proj, view, glm::vec4(0.15f), glm::vec4(0.7f), glm::vec4(1.f),
-             glm::vec4(0.f), 90.f, vc.frustum.far});
-
-    ObjectRenderer objectRenderer(world(), vc, 1.f);
-    RenderList renders;
-    objectRenderer.buildRenderList(object, renders);
-    std::sort(renders.begin(), renders.end(),
-              [](const Renderer::RenderInstruction& a,
-                 const Renderer::RenderInstruction& b) {
-                  return a.sortKey < b.sortKey;
-              });
-    r.getRenderer().drawBatched(renders);
-    r.renderPostProcess();
-}
-
-void ViewerWidget::drawWorld(GameRenderer& r) {
-    ViewCamera vc;
-    vc.frustum.fov = kViewFov;
-    vc.frustum.far = 1000.f;
-    vc.frustum.near = 0.1f;
-    vc.position = viewPosition;
-    vc.rotation = glm::angleAxis(glm::half_pi<float>() + viewAngles.x,
-                                 glm::vec3(0.f, 0.f, 1.f)) *
-                  glm::angleAxis(viewAngles.y, glm::vec3(0.f, 1.f, 0.f));
-    vc.frustum.aspectRatio = width() / (height() * 1.f);
-    r.renderWorld(world(), vc, 0.f);
-}
-
-void ViewerWidget::drawText(GameRenderer& r) {
-    for(auto &textInfo : textInfos) {
-        _renderer->text.renderText(textInfo, false);
-    }
-    r.renderPostProcess();
-}
-
-void ViewerWidget::paintGL() {
-    glViewport(0, 0, width() * devicePixelRatio(), height() * devicePixelRatio());
-    glClearColor(0.3f, 0.3f, 0.3f, 1.f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-    if (world() == nullptr) return;
-
-    RW_CHECK(_renderer != nullptr, "GameRenderer is null");
-    auto& r = *_renderer;
-    r.getRenderer().invalidate();
-    r.setViewport(width() * devicePixelRatio(), height() * devicePixelRatio());
-
-    glEnable(GL_DEPTH_TEST);
-
-    r.getRenderer().invalidate();
-    r.setupRender();
-
-    switch (_viewMode) {
-    case Mode::Model:
-        if (_model) drawModel(r, _model);
-        break;
-    case Mode::Object:
-        if (_object) drawObject(r, _object);
-        break;
-    case Mode::World:
-        drawWorld(r);
-        break;
-    case Mode::Text:
-        drawText(r);
-        break;
-    }
-}
-
-void ViewerWidget::drawFrameWidget(ModelFrame* f, const glm::mat4& m) {
-    auto thisM = m * f->getTransform();
-    Renderer::DrawParameters dp;
-    dp.count = _frameWidgetGeom->getCount();
-    dp.start = 0;
-    dp.ambient = 1.f;
-    dp.diffuse = 1.f;
-    if (f == selectedFrame) {
-        dp.colour = {255, 255, 0, 255};
-        // Sorry!
-        glLineWidth(10.f);
-    } else {
-        dp.colour = {255, 255, 255, 255};
-        glLineWidth(1.f);
-    }
-    dp.textures = {{whiteTex}};
-
-    RW_CHECK(_renderer != nullptr, "GameRenderer is null");
-    if(_renderer != nullptr) {
-        _renderer->getRenderer().drawArrays(thisM, _frameWidgetDraw, dp);
-    }
-
-    for (auto c : f->getChildren()) {
-        drawFrameWidget(c.get(), thisM);
-    }
-}
-
-GameWorld* ViewerWidget::world() {
-    return _world;
-}
-
-void ViewerWidget::showObject(quint16 item) {
-    RW_ASSERT(world());
-    _viewMode = Mode::Object;
-    _objectID = item;
-
-    if (_object) _world->destroyObject(_object);
-    _object = nullptr;
-
-    auto def = world()->data->modelinfo[item].get();
-    if (!def) {
-        return;
-    }
-
-    if (!world()->data->loadModel(item)) {
-        return;
-    }
-
-    switch (def->type()) {
-    default:
-        _object = _world->createInstance(item, {});
-        break;
-    case ModelDataType::PedInfo:
-        _object = _world->createPedestrian(item, {});
-        break;
-    case ModelDataType::VehicleInfo:
-        _object = _world->createVehicle(item, {});
-        break;
-    }
-
-    RW_CHECK(_object != nullptr, "Dummy Object is null");
-
-    if (_object->getClump()) {
-        auto objectRadius = _object->getClump()->getBoundingRadius();
-        viewDistance = objectRadius * 2;
-        viewAngles.x = glm::radians(-45.f);
-        viewAngles.y = glm::radians(22.5f);
-    }
-}
-
-void ViewerWidget::clearText() {
-    textInfos.clear();
-}
-
-void ViewerWidget::showText(const TextRenderer::TextInfo &ti) {
-    textInfos.push_back(ti);
-}
-
-void ViewerWidget::showModel(ClumpPtr model) {
-    _viewMode = Mode::Model;
-    _model = model;
-    textInfos.clear();
-}
-
-void ViewerWidget::selectFrame(ModelFrame* frame) {
-    selectedFrame = frame;
-}
-
-void ViewerWidget::exportModel() {
-#if 0
-    QString toSv = QFileDialog::getSaveFileName(
-        this, "Export Model", QDir::homePath(), "Model (*.DFF)");
-
-    if (toSv.size() == 0) return;
-
-	auto it = world()->objectTypes.find(currentObjectID);
-	if( it != world()->objectTypes.end() ) {
-		for( auto& archive : world()->data.archives ) {
-			for(size_t i = 0; i < archive.second.getAssetCount(); ++i) {
-				auto& assetI = archive.second.getAssetInfoByIndex(i);;
-				std::string q(assetI.name);
-				std::transform(q.begin(), q.end(), q.begin(), ::tolower);
-				if( q.find(it->second->modelName) != q.npos ) {
-					archive.second.saveAsset(q, toSv.toStdString());
-				}
-			}
-		}
-	}
-#endif
-}
-
-void ViewerWidget::keyPressEvent(QKeyEvent* e) {
-    if (e->key() == Qt::Key_Shift) moveFast = true;
-
-    glm::vec3 movement{};
-    if (e->key() == Qt::Key_W) movement.y += moveFast ? 10.f : 1.f;
-    if (e->key() == Qt::Key_S) movement.y -= moveFast ? 10.f : 1.f;
-    if (e->key() == Qt::Key_A) movement.x -= moveFast ? 10.f : 1.f;
-    if (e->key() == Qt::Key_D) movement.x += moveFast ? 10.f : 1.f;
-
-    if (movement.length() > 0.f) {
-        movement = (glm::angleAxis(viewAngles.x, glm::vec3(0.f, 0.f, 1.f)) *
-                    glm::angleAxis(viewAngles.y, glm::vec3(-1.f, 0.f, 0.f))) *
-                   movement;
-        viewPosition += movement;
-    }
-}
-
-void ViewerWidget::keyReleaseEvent(QKeyEvent* e) {
-    if (e->key() == Qt::Key_Shift) moveFast = false;
-}
-
-ClumpPtr ViewerWidget::currentModel() const {
-    return _model;
-}
-
-GameObject* ViewerWidget::currentObject() const {
-    return _object;
-}
-
-void ViewerWidget::mousePressEvent(QMouseEvent* e) {
-    dragging = true;
-    dstart = e->localPos();
-    dastart = viewAngles;
-}
-
-void ViewerWidget::mouseReleaseEvent(QMouseEvent*) {
-    dragging = false;
-}
-
-void ViewerWidget::mouseMoveEvent(QMouseEvent* e) {
-    if (dragging) {
-        auto d = e->localPos() - dstart;
-        viewAngles = dastart + glm::vec2(d.x(), d.y()) * 0.01f;
-    }
-}
-
-void ViewerWidget::wheelEvent(QWheelEvent* e) {
-    viewDistance = qMax(viewDistance - e->angleDelta().y() / 240.f, 0.5f);
-}
-
-void ViewerWidget::gameLoaded(GameWorld *world, GameRenderer *renderer) {
-    _world = world;
-    _renderer = renderer;
-}
-
-void ViewerWidget::renderNow() {
-    if (!isExposed()) {
-        return;
-    }
-
-    m_context->makeCurrent(this);
-
-    if (!initialised) {
-        initGL();
-        initialised = true;
-    }
-
-    paintGL();
-    m_context->swapBuffers(this);
-
-    requestUpdate();
-}
-
-bool ViewerWidget::event(QEvent *e) {
-    switch(e->type()) {
-    case QEvent::UpdateRequest:
-        renderNow();
-        return true;
-    default: return QWindow::event(e);
-    }
-}
-
-void ViewerWidget::exposeEvent(QExposeEvent *) {
-    if (isExposed()) {
-        requestUpdate();
-    }
-}
-
diff --git a/rwviewer/ViewerWidget.hpp b/rwviewer/ViewerWidget.hpp
deleted file mode 100644
index b793d92ac..000000000
--- a/rwviewer/ViewerWidget.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef _RWVIEWER_VIEWERWIDGET_HPP_
-#define _RWVIEWER_VIEWERWIDGET_HPP_
-#include <QTimer>
-#include <data/Clump.hpp>
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-#include <gl/DrawBuffer.hpp>
-#include <gl/GeometryBuffer.hpp>
-#include <loaders/LoaderIFP.hpp>
-#include <render/TextRenderer.hpp>
-#include <glm/glm.hpp>
-
-#include <QWindow>
-
-class Clump;
-class GameRenderer;
-class QOpenGLContextWrapper;
-
-class ViewerWidget : public QWindow {
-    Q_OBJECT
-public:
-    enum class Mode {
-        //! View an Object, \see showObject
-        Object,
-        //! View a DFF model, \see showModel
-        Model,
-        //! View loaded instances, \see showWorld();
-        World,
-        //! View text strings, \see showText
-        Text,
-    };
-
-    ViewerWidget(QOpenGLContextWrapper* context, QWindow* parent);
-
-    void initGL();
-    void paintGL();
-
-    void renderNow();
-    bool event(QEvent*) override;
-
-    void exposeEvent(QExposeEvent*) override;
-
-    ClumpPtr currentModel() const;
-    GameObject* currentObject() const;
-
-    GameWorld* world();
-
-    void setMode(Mode m) {
-        _viewMode = m;
-    }
-
-    Mode currentMode() const {
-        return _viewMode;
-    }
-
-public slots:
-    void showObject(quint16 item);
-    void showModel(ClumpPtr model);
-    void clearText();
-    void showText(const TextRenderer::TextInfo &ti);
-    void selectFrame(ModelFrame* frame);
-    void exportModel();
-
-    void gameLoaded(GameWorld* world, GameRenderer* renderer);
-
-signals:
-    void fileOpened(const QString& file);
-
-    void modelChanged(ClumpPtr model);
-
-protected:
-    void keyPressEvent(QKeyEvent*) override;
-    void keyReleaseEvent(QKeyEvent*) override;
-    void mousePressEvent(QMouseEvent*) override;
-    void mouseReleaseEvent(QMouseEvent*) override;
-    void mouseMoveEvent(QMouseEvent*) override;
-    void wheelEvent(QWheelEvent*) override;
-
-    Mode _viewMode = Mode::World;
-
-    QOpenGLContextWrapper* m_context;
-    GameWorld* _world = nullptr;
-    GameRenderer* _renderer = nullptr;
-
-    std::vector<TextRenderer::TextInfo> textInfos;
-    ClumpPtr _model;
-    ModelFrame* selectedFrame = nullptr;
-    GameObject* _object = nullptr;
-    quint16 _objectID = 0;
-
-
-    float viewDistance = 1.f;
-    glm::vec2 viewAngles{};
-    glm::vec3 viewPosition{};
-
-    bool dragging = false;
-    QPointF dstart;
-    glm::vec2 dastart{};
-    bool moveFast = false;
-
-    DrawBuffer* _frameWidgetDraw = nullptr;
-    GeometryBuffer* _frameWidgetGeom = nullptr;
-    GLuint whiteTex;
-
-    void drawFrameWidget(ModelFrame* f, const glm::mat4& = glm::mat4(1.f));
-    bool initialised = false;
-
-    void drawModel(GameRenderer& r, ClumpPtr& model);
-    void drawObject(GameRenderer& r, GameObject* object);
-    void drawWorld(GameRenderer& r);
-    void drawText(GameRenderer& r);
-
-};
-
-#endif
diff --git a/rwviewer/ViewerWindow.cpp b/rwviewer/ViewerWindow.cpp
deleted file mode 100644
index 8f17d6329..000000000
--- a/rwviewer/ViewerWindow.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-#include "ViewerWindow.hpp"
-#include <ViewerWidget.hpp>
-#include "views/ModelViewer.hpp"
-#include "views/ObjectViewer.hpp"
-#include "views/WorldViewer.hpp"
-#include "views/TextViewer.hpp"
-
-#include <engine/GameState.hpp>
-#include <engine/GameWorld.hpp>
-#include <render/GameRenderer.hpp>
-
-#include <QApplication>
-#include <QFileDialog>
-#include <QMenuBar>
-#include <QPushButton>
-#include <QSettings>
-#include <QWindow>
-#include <QMessageBox>
-
-static int MaxRecentGames = 5;
-
-ViewerWindow::ViewerWindow(QWidget* parent, Qt::WindowFlags flags)
-    : QMainWindow(parent, flags)
-    , m_context(this)
-    , gameData(nullptr)
-    , gameWorld(nullptr)
-    , renderer(nullptr) {
-    show();
-    setMinimumSize(640, 480);
-    createMenus();
-    if (!setupEngine()) {
-        return;
-    }
-    createDefaultViews();
-}
-
-void ViewerWindow::createMenus() {
-    QMenuBar* mb = this->menuBar();
-    QMenu* file = mb->addMenu("&File");
-
-    file->addAction("Open &Game", this, SLOT(loadGame()));
-
-    file->addSeparator();
-    for (int i = 0; i < MaxRecentGames; ++i) {
-        QAction* r = file->addAction("");
-        recentGames.append(r);
-        connect(r, &QAction::triggered, this, [r, this]() {
-            QString recentGame = r->data().toString();
-            loadGame(recentGame);
-        });
-    }
-
-    recentSep = file->addSeparator();
-    auto ex = file->addAction("E&xit");
-    ex->setShortcut(QKeySequence::Quit);
-    connect(ex, &QAction::triggered,
-            QApplication::instance(), &QApplication::closeAllWindows);
-
-    mb->addMenu("&Data");
-
-    updateRecentGames();
-}
-
-bool ViewerWindow::setupEngine() {
-    QSurfaceFormat format = windowHandle()->format();
-    format.setProfile(QSurfaceFormat::CoreProfile);
-    format.setVersion(3,3);
-    m_context.setup(format);
-
-    hiddenSurface = new QOffscreenSurface(windowHandle()->screen());
-    hiddenSurface->setFormat(format);
-    hiddenSurface->create();
-
-    if (!m_context.create()) {
-        QMessageBox::critical(this, "OpenGL Failure",
-                              "Failed to create OpenGL context");
-        QApplication::exit(1);
-        return false;
-    }
-
-    return true;
-}
-
-void ViewerWindow::createDefaultViews() {
-    views = new QTabWidget(this);
-
-    auto objectView = new ObjectViewer(this);
-    views->addTab(objectView, "Objects");
-    connect(this, &ViewerWindow::gameLoaded, objectView, &ObjectViewer::showData);
-
-    auto modelView = new ModelViewer(this);
-    views->addTab(modelView, "Model");
-    connect(this, &ViewerWindow::gameLoaded, modelView, &ModelViewer::showData);
-    connect(objectView, &ObjectViewer::showObjectModel, modelView, &ModelViewer::showObject);
-
-    auto worldView = new WorldViewer(this);
-    views->addTab(worldView, "World");
-    connect(this, &ViewerWindow::gameLoaded, worldView, &WorldViewer::showData);
-
-    auto textView = new TextViewer(this);
-    views->addTab(textView, "Texts");
-    connect(this, &ViewerWindow::gameLoaded, textView, &TextViewer::showData);
-
-    setCentralWidget(views);
-}
-
-void ViewerWindow::showEvent(QShowEvent*) {
-    static bool first = true;
-    if (first) {
-        QSettings settings("OpenRW", "rwviewer");
-        restoreGeometry(settings.value("window/geometry").toByteArray());
-        restoreState(settings.value("window/windowState").toByteArray());
-        first = false;
-    }
-}
-
-void ViewerWindow::closeEvent(QCloseEvent* event) {
-    QSettings settings("OpenRW", "rwviewer");
-    settings.setValue("window/geometry", saveGeometry());
-    settings.setValue("window/windowState", saveState());
-    QMainWindow::closeEvent(event);
-}
-
-void ViewerWindow::loadGame() {
-    QString dir = QFileDialog::getExistingDirectory(
-        this, tr("Open Directory"), QDir::homePath(),
-        QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
-
-    if (dir.size() > 0) loadGame(dir);
-}
-
-void ViewerWindow::loadGame(const QString& path) {
-    QDir gameDir(path);
-    if (path.isEmpty()) {
-        return;
-    }
-    if (!gameDir.exists()) {
-        QMessageBox::critical(this, "Error", "The requested path doesn't exist");
-        return;
-    }
-
-    if (!makeCurrent()) {
-        return;
-    }
-
-    gameData = std::make_unique<GameData>(&engineLog, gameDir.absolutePath().toStdString());
-    gameData->load();
-
-    gameWorld = std::make_unique<GameWorld>(&engineLog, gameData.get());
-    renderer = std::make_unique<GameRenderer>(&engineLog, gameData.get());
-    gameWorld->state = new GameState;
-
-    renderer->text.setFontTexture(FONT_PAGER, "pager");
-    renderer->text.setFontTexture(FONT_PRICEDOWN, "font1");
-    renderer->text.setFontTexture(FONT_ARIAL, "font2");
-
-    gameLoaded(gameWorld.get(), renderer.get());
-
-    QSettings settings("OpenRW", "rwviewer");
-    QStringList recent = settings.value("recentGames").toStringList();
-    recent.removeAll(path);
-    recent.prepend(path);
-    while (recent.size() > MaxRecentGames) recent.removeLast();
-    settings.setValue("recentGames", recent);
-
-    updateRecentGames();
-}
-
-void ViewerWindow::showObjectModel(uint16_t) {
-    RW_MESSAGE("showObjectModel unimplemented");  // FIXME: unimplemented
-}
-
-void ViewerWindow::updateRecentGames() {
-    QSettings settings("OpenRW", "rwviewer");
-    QStringList recent = settings.value("recentGames").toStringList();
-
-    for (int i = 0; i < MaxRecentGames; ++i) {
-        if (i < recent.size()) {
-            QString fnm(QFileInfo(recent[i]).fileName());
-            recentGames[i]->setText(tr("&%1 - %2").arg(i).arg(fnm));
-            recentGames[i]->setData(recent[i]);
-            recentGames[i]->setVisible(true);
-        } else {
-            recentGames[i]->setVisible(false);
-        }
-    }
-
-    recentSep->setVisible(recent.size() > 0);
-}
-
-ViewerWindow::~ViewerWindow() {
-
-}
-
-bool ViewerWindow::makeCurrent() {
-    if (!m_context.makeCurrent(hiddenSurface)) {
-        QMessageBox::critical(this, "OpenGL", "makeCurrent failed");
-        QApplication::exit(1);
-        return false;
-    }
-    return true;
-}
-
-ViewerWidget *ViewerWindow::createViewer() {
-    auto view = new ViewerWidget(&m_context, windowHandle());
-    connect(this, &ViewerWindow::gameLoaded, view, &ViewerWidget::gameLoaded);
-    return view;
-}
diff --git a/rwviewer/ViewerWindow.hpp b/rwviewer/ViewerWindow.hpp
deleted file mode 100644
index 554d630f5..000000000
--- a/rwviewer/ViewerWindow.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef _VIEWERWINDOW_HPP_
-#define _VIEWERWINDOW_HPP_
-
-#include "QOpenGLContextWrapper.hpp"
-
-#include <core/Logger.hpp>
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-
-#include <QMainWindow>
-#include <QTabWidget>
-#include <QVBoxLayout>
-#include <QOffscreenSurface>
-
-#include <memory>
-
-class ViewerWidget;
-class ViewerInterface;
-class GameRenderer;
-
-class ViewerWindow : public QMainWindow {
-    Q_OBJECT
-    QOpenGLContextWrapper m_context;
-    QOffscreenSurface* hiddenSurface;
-    QTabWidget* views;
-
-    Logger engineLog;
-
-    std::unique_ptr<GameData> gameData;
-    std::unique_ptr<GameWorld> gameWorld;
-    std::unique_ptr<GameRenderer> renderer;
-
-public:
-    ViewerWindow(QWidget* parent = 0, Qt::WindowFlags flags = 0);
-    ~ViewerWindow();
-
-    virtual void showEvent(QShowEvent*);
-    virtual void closeEvent(QCloseEvent*);
-
-    ViewerWidget* createViewer();
-
-public slots:
-    void loadGame();
-
-    void loadGame(const QString& path);
-
-signals:
-    void gameLoaded(GameWorld*, GameRenderer*);
-
-private slots:
-    void showObjectModel(uint16_t object);
-
-private:
-    QList<QAction*> recentGames;
-    QAction* recentSep;
-    void updateRecentGames();
-
-    void createMenus();
-    bool setupEngine();
-    void createDefaultViews();
-
-    bool makeCurrent();
-};
-
-#endif
diff --git a/rwviewer/main.cpp b/rwviewer/main.cpp
deleted file mode 100644
index e29a23da0..000000000
--- a/rwviewer/main.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <QApplication>
-#include "ViewerWindow.hpp"
-
-int main(int argc, char *argv[]) {
-    QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
-    QApplication app(argc, argv);
-
-    ViewerWindow viewer;
-
-    return app.exec();
-}
diff --git a/rwviewer/models/AnimationListModel.cpp b/rwviewer/models/AnimationListModel.cpp
deleted file mode 100644
index 82f18b050..000000000
--- a/rwviewer/models/AnimationListModel.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include "AnimationListModel.hpp"
-
-QVariant AnimationListModel::data(const QModelIndex& index, int role) const {
-    if (role == Qt::DisplayRole) {
-        if (index.row() >= 0 &&
-            static_cast<unsigned>(index.row()) < animations.size()) {
-            auto& f = animations.at(index.row());
-            if (index.column() == 0) {
-                return QString(f.first.c_str());
-            }
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QVariant AnimationListModel::headerData(int section,
-                                        Qt::Orientation orientation,
-                                        int role) const {
-    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
-        if (section == 0) {
-            return "Name";
-        }
-    }
-    return QVariant::Invalid;
-}
-
-int AnimationListModel::rowCount(const QModelIndex&) const {
-    return static_cast<int>(animations.size());
-}
-
-int AnimationListModel::columnCount(const QModelIndex&) const {
-    return 1;
-}
diff --git a/rwviewer/models/AnimationListModel.hpp b/rwviewer/models/AnimationListModel.hpp
deleted file mode 100644
index e4c7f96a2..000000000
--- a/rwviewer/models/AnimationListModel.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef _ANIMATIONLISTMODEL_HPP_
-#define _ANIMATIONLISTMODEL_HPP_
-#include <QAbstractItemModel>
-#include <loaders/LoaderIFP.hpp>
-
-typedef std::vector<std::pair<std::string, AnimationPtr>> AnimationList;
-
-class AnimationListModel : public QAbstractListModel {
-    Q_OBJECT
-
-    AnimationList animations;
-
-public:
-    AnimationListModel(const AnimationList& anims, QObject* parent = 0)
-        : QAbstractListModel(parent), animations(anims) {
-    }
-
-    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    QVariant data(const QModelIndex& index,
-                          int role = Qt::DisplayRole) const override;
-
-    QVariant headerData(int section, Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const override;
-
-    const AnimationList& getAnimations() const {
-        return animations;
-    }
-};
-
-#endif
diff --git a/rwviewer/models/DFFFramesTreeModel.cpp b/rwviewer/models/DFFFramesTreeModel.cpp
deleted file mode 100644
index 737664bb8..000000000
--- a/rwviewer/models/DFFFramesTreeModel.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include "DFFFramesTreeModel.hpp"
-#include <data/Clump.hpp>
-
-DFFFramesTreeModel::DFFFramesTreeModel(ClumpPtr m,
-                                       QObject* parent)
-    : QAbstractItemModel(parent), model(m) {
-}
-
-int DFFFramesTreeModel::columnCount(const QModelIndex&) const {
-    return 1;
-}
-
-int DFFFramesTreeModel::rowCount(const QModelIndex& parent) const {
-    ModelFrame* f = static_cast<ModelFrame*>(parent.internalPointer());
-    if (f) {
-        return static_cast<int>(f->getChildren().size());
-    }
-
-    if (parent.row() == -1) {
-        return 1;
-    }
-
-    return 0;
-}
-
-QModelIndex DFFFramesTreeModel::index(int row, int column,
-                                      const QModelIndex& parent) const {
-    if (parent.row() == -1 && parent.column() == -1) {
-        return createIndex(row, column, model->getFrame().get());
-    }
-    ModelFrame* f = static_cast<ModelFrame*>(parent.internalPointer());
-    ModelFrame* p = f->getChildren()[row].get();
-    return createIndex(row, column, p);
-}
-
-QModelIndex DFFFramesTreeModel::parent(const QModelIndex& child) const {
-    ModelFrame* c = static_cast<ModelFrame*>(child.internalPointer());
-    if (c->getParent()) {
-        auto cp = c->getParent();
-        if (cp->getParent()) {
-            for (size_t i = 0; i < cp->getParent()->getChildren().size(); ++i) {
-                if (cp->getParent()->getChildren()[i].get() == c->getParent()) {
-                    return createIndex(static_cast<int>(i), 0, c->getParent());
-                }
-            }
-        } else {
-            return createIndex(0, 0, cp);
-        }
-    }
-    return QModelIndex();
-}
-
-QVariant DFFFramesTreeModel::data(const QModelIndex& index, int role) const {
-    ModelFrame* f = static_cast<ModelFrame*>(index.internalPointer());
-    if (role == Qt::DisplayRole) {
-        if (index.column() == 0) {
-            return QString(f->getName().c_str());
-        }
-    } else if (role == Qt::CheckStateRole) {
-        if (index.column() == 0) {
-            return true;
-        }
-    }
-    return QVariant();
-}
-
-bool DFFFramesTreeModel::setData(const QModelIndex& index,
-                                 const QVariant& value, int role) {
-    if (!index.isValid()) {
-        return false;
-    }
-
-    if (role == Qt::CheckStateRole) {
-        if (index.column() == 0) {
-            if (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked) {
-                RW_UNIMPLEMENTED("Hiding Frames");
-            } else {
-            }
-            return true;
-        }
-    }
-
-    return false;
-}
-
-Qt::ItemFlags DFFFramesTreeModel::flags(const QModelIndex& index) const {
-    if (!index.isValid()) {
-        return 0;
-    }
-
-    Qt::ItemFlags flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
-
-    if (index.column() == 0) {
-        flags |= Qt::ItemIsUserCheckable;
-    }
-
-    return flags;
-}
-
-QVariant DFFFramesTreeModel::headerData(int,
-                                        Qt::Orientation orientation,
-                                        int role) const {
-    if (orientation == Qt::Horizontal) {
-        if (role == Qt::DisplayRole) {
-            return "Name";
-        }
-    }
-    return QVariant();
-}
diff --git a/rwviewer/models/DFFFramesTreeModel.hpp b/rwviewer/models/DFFFramesTreeModel.hpp
deleted file mode 100644
index 2237d43b5..000000000
--- a/rwviewer/models/DFFFramesTreeModel.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#ifndef _DFFFRAMESTREEMODEL_HPP_
-#define _DFFFRAMESTREEMODEL_HPP_
-#include <QAbstractItemModel>
-#include <rw/forward.hpp>
-#include <rw/types.hpp>
-
-class DFFFramesTreeModel : public QAbstractItemModel {
-    ClumpPtr model;
-
-public:
-    explicit DFFFramesTreeModel(ClumpPtr m, QObject* parent = 0);
-
-    virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
-
-    virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
-
-    virtual QVariant data(const QModelIndex& index,
-                          int role = Qt::DisplayRole) const;
-
-    virtual bool setData(const QModelIndex& index, const QVariant& value,
-                         int role);
-
-    virtual Qt::ItemFlags flags(const QModelIndex& index) const;
-
-    virtual QModelIndex index(int row, int column,
-                              const QModelIndex& parent = QModelIndex()) const;
-
-    virtual QModelIndex parent(const QModelIndex& child) const;
-
-    virtual QVariant headerData(int section, Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const;
-};
-
-#endif
diff --git a/rwviewer/models/IMGArchiveModel.cpp b/rwviewer/models/IMGArchiveModel.cpp
deleted file mode 100644
index 8c7b752e7..000000000
--- a/rwviewer/models/IMGArchiveModel.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "IMGArchiveModel.hpp"
-
-QVariant IMGArchiveModel::data(const QModelIndex& index, int role) const {
-    if (role == Qt::DisplayRole) {
-        if (index.row() >= 0 &&
-            static_cast<unsigned>(index.row()) < archive.getAssetCount()) {
-            auto& f = archive.getAssetInfoByIndex(index.row());
-            if (index.column() == 0) {
-                return QString(f.name);
-            }
-            if (index.column() == 1) {
-                return f.size;
-            }
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QVariant IMGArchiveModel::headerData(int section, Qt::Orientation orientation,
-                                     int role) const {
-    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
-        if (section == 0) {
-            return "Name";
-        }
-        if (section == 1) {
-            return "Size";
-        }
-    }
-    return QVariant::Invalid;
-}
-
-int IMGArchiveModel::rowCount(const QModelIndex&) const {
-    return static_cast<int>(archive.getAssetCount());
-}
-
-int IMGArchiveModel::columnCount(const QModelIndex&) const {
-    return 2;
-}
diff --git a/rwviewer/models/IMGArchiveModel.hpp b/rwviewer/models/IMGArchiveModel.hpp
deleted file mode 100644
index 350f90684..000000000
--- a/rwviewer/models/IMGArchiveModel.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _IMGARCHIVEMODEL_HPP_
-#define _IMGARCHIVEMODEL_HPP_
-#include <QAbstractItemModel>
-#include <loaders/LoaderIMG.hpp>
-
-class IMGArchiveModel : public QAbstractListModel {
-    Q_OBJECT
-
-    LoaderIMG archive;
-
-public:
-    IMGArchiveModel(const LoaderIMG& archive, QObject* parent = 0)
-        : QAbstractListModel(parent), archive(archive) {
-    }
-
-    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    QVariant data(const QModelIndex& index,
-                          int role = Qt::DisplayRole) const override;
-
-    QVariant headerData(int section, Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const override;
-
-    const LoaderIMG& getArchive() const {
-        return archive;
-    }
-};
-
-#endif
diff --git a/rwviewer/models/ItemListModel.cpp b/rwviewer/models/ItemListModel.cpp
deleted file mode 100644
index 698b1a829..000000000
--- a/rwviewer/models/ItemListModel.cpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "ItemListModel.hpp"
-#include <engine/GameData.hpp>
-
-qint16 ItemListModel::getIDOf(unsigned int row) const {
-    if (row < world()->data->modelinfo.size()) {
-        return row;
-    }
-
-    return -1;
-}
-
-ItemListModel::ItemListModel(GameWorld *world, QObject *parent)
-    : QAbstractTableModel(parent), _world(world) {
-}
-
-int ItemListModel::rowCount(const QModelIndex &) const {
-    return static_cast<int>(_world->data->modelinfo.size());
-}
-
-int ItemListModel::columnCount(const QModelIndex &) const {
-    return 2;
-}
-
-QVariant ItemListModel::data(const QModelIndex &index, int role) const {
-    if (role == Qt::DisplayRole) {
-        qint16 id = getIDOf(index.row());
-        if (id == -1) return QVariant::Invalid;
-        if (index.column() == 0) {
-            return id;
-        } else if (index.column() == 1) {
-            return QString::fromStdString("TODO");
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QVariant ItemListModel::headerData(int section, Qt::Orientation orientation,
-                                   int role) const {
-    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
-        if (section == 0) {
-            return "ID";
-        }
-        if (section == 1) {
-            return "Model";
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QModelIndex ItemListModel::index(int row, int column,
-                                 const QModelIndex &parent) const {
-    return hasIndex(row, column, parent)
-               ? createIndex(row, column, getIDOf(row))
-               : QModelIndex();
-}
diff --git a/rwviewer/models/ItemListModel.hpp b/rwviewer/models/ItemListModel.hpp
deleted file mode 100644
index 1bcaafa9a..000000000
--- a/rwviewer/models/ItemListModel.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef ITEMLISTMODEL_HPP
-#define ITEMLISTMODEL_HPP
-
-#include <QAbstractItemModel>
-
-#include <engine/GameWorld.hpp>
-
-class ItemListModel : public QAbstractTableModel {
-    Q_OBJECT
-
-    GameWorld* _world;
-
-public:
-    explicit ItemListModel(GameWorld* _world, QObject* parent = 0);
-
-    GameWorld* world() const {
-        return _world;
-    }
-
-    qint16 getIDOf(unsigned int row) const;
-
-    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    QVariant data(const QModelIndex& index,
-                          int role = Qt::DisplayRole) const override;
-
-    QVariant headerData(int section, Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const override;
-
-    QModelIndex index(int row, int column, const QModelIndex& parent) const override;
-};
-
-#endif  // ITEMLISTMODEL_HPP
diff --git a/rwviewer/models/ObjectListModel.cpp b/rwviewer/models/ObjectListModel.cpp
deleted file mode 100644
index bc502b689..000000000
--- a/rwviewer/models/ObjectListModel.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "ObjectListModel.hpp"
-
-ObjectListModel::ObjectListModel(GameData *dat, QObject *parent)
-    : QAbstractTableModel(parent), _gameData(dat) {
-}
-
-int ObjectListModel::rowCount(const QModelIndex &) const {
-    return static_cast<int>(_gameData->modelinfo.size());
-}
-
-int ObjectListModel::columnCount(const QModelIndex &) const {
-    return 3;
-}
-
-QVariant ObjectListModel::data(const QModelIndex &index, int role) const {
-    if (role == Qt::DisplayRole) {
-        if (!index.isValid()) return QVariant::Invalid;
-        auto id = index.internalId();
-        if (index.column() == 0) {
-            return id;
-        } else if (index.column() == 1) {
-            auto object = _gameData->modelinfo[id].get();
-            return QString::fromStdString(
-                BaseModelInfo::getTypeName(object->type()));
-        } else if (index.column() == 2) {
-            auto object = _gameData->modelinfo[id].get();
-            return QString::fromStdString(object->name);
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QVariant ObjectListModel::headerData(int section, Qt::Orientation orientation,
-                                     int role) const {
-    if (role == Qt::DisplayRole && orientation == Qt::Horizontal) {
-        switch (section) {
-            case 0:
-                return "ID";
-            case 1:
-                return "Type";
-            case 2:
-                return "Model";
-        }
-    }
-    return QVariant::Invalid;
-}
-
-QModelIndex ObjectListModel::index(int row, int column,
-                                   const QModelIndex &parent) const {
-    auto it = _gameData->modelinfo.begin();
-    for (int i = 0; i < row; i++) it++;
-    auto id = it->second->id();
-
-    return hasIndex(row, column, parent) ? createIndex(row, column, id)
-                                         : QModelIndex();
-}
diff --git a/rwviewer/models/ObjectListModel.hpp b/rwviewer/models/ObjectListModel.hpp
deleted file mode 100644
index 652b062fb..000000000
--- a/rwviewer/models/ObjectListModel.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef _OBJECTLISTMODEL_HPP_
-#define _OBJECTLISTMODEL_HPP_
-
-#include <QAbstractItemModel>
-
-#include <engine/GameData.hpp>
-
-class ObjectListModel : public QAbstractTableModel {
-    Q_OBJECT
-
-    GameData* _gameData;
-
-public:
-    explicit ObjectListModel(GameData* gameDat, QObject* parent = 0);
-
-    GameData* gameData() const {
-        return _gameData;
-    }
-
-    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    int columnCount(const QModelIndex& parent = QModelIndex()) const override;
-
-    QVariant data(const QModelIndex& index,
-                          int role = Qt::DisplayRole) const override;
-
-    QVariant headerData(int section, Qt::Orientation orientation,
-                                int role = Qt::DisplayRole) const override;
-
-    QModelIndex index(int row, int column, const QModelIndex& parent) const override;
-};
-
-#endif  // _OBJECTLISTMODEL_HPP_
diff --git a/rwviewer/models/TextModel.cpp b/rwviewer/models/TextModel.cpp
deleted file mode 100644
index ab4b9f9c2..000000000
--- a/rwviewer/models/TextModel.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#include "TextModel.hpp"
-#include <iostream>
-
-#include <QBrush>
-
-TextModel::TextModel(QObject *parent)
-     : QAbstractTableModel(parent) {
-
-}
-
-void TextModel::setMapData(const TextMapType &textMap) {
-    beginResetModel();
-    m_textMap = textMap;
-    endResetModel();
-}
-
-int TextModel::rowCount(const QModelIndex &) const {
-    return static_cast<int>(m_textMap.keys.size());
-}
-
-int TextModel::columnCount(const QModelIndex &) const {
-    return static_cast<int>(m_textMap.languages.size());
-}
-
-const GameString &TextModel::lookupIndex(const QModelIndex &index) const {
-    const auto &language = m_textMap.languages.at(index.column());
-    const auto &key = m_textMap.keys.at(index.row());
-    return m_textMap.map_lang_key_tran.at(language).at(key);
-}
-
-QVariant TextModel::data(const QModelIndex &index, int role) const {
-    switch (role) {
-    case Qt::DisplayRole:
-        try {
-            const auto &gameText = this->lookupIndex(index);
-            auto gameString = GameStringUtil::toString(gameText, m_font);
-            return QString::fromStdString(gameString);
-        } catch (const std::out_of_range &) {
-            return QVariant::Invalid;
-        } catch (...) {
-            throw;
-        }
-    case Qt::BackgroundRole:
-        try {
-            this->lookupIndex(index);
-            return QVariant::Invalid;
-        } catch (const std::out_of_range &) {
-            return QBrush(Qt::red);
-        }
-        break;
-    default:
-        return QVariant::Invalid;
-    }
-}
-
-QVariant TextModel::headerData(int section, Qt::Orientation orientation, int role) const {
-    switch (role) {
-    case Qt::DisplayRole:
-        switch (orientation) {
-        case Qt::Horizontal:
-            return QString::fromStdString(m_textMap.languages[section]);
-        case Qt::Vertical:
-            return QString::fromStdString(m_textMap.keys[section]);
-        default:
-            return QVariant::Invalid;
-        }
-    default:
-    return QVariant::Invalid;
-    }
-}
-
-void TextModel::fontChanged(font_t font) {
-    beginResetModel();
-    m_font = font;
-    endResetModel();
-}
diff --git a/rwviewer/models/TextModel.hpp b/rwviewer/models/TextModel.hpp
deleted file mode 100644
index 8ecc10be4..000000000
--- a/rwviewer/models/TextModel.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef _TEXTMODEL_HPP_
-#define _TEXTMODEL_HPP_
-
-#include <string>
-#include <map>
-#include <vector>
-
-#include <QAbstractTableModel>
-
-#include <fonts/GameTexts.hpp>
-
-struct TextMapType {
-    std::vector<std::string> languages;
-    std::vector<std::string> keys;
-    std::map<std::string, std::map<std::string, GameString>> map_lang_key_tran;
-};
-
-class TextModel : public QAbstractTableModel {
-    Q_OBJECT
-public:
-    TextModel(QObject *parent = nullptr);
-    void setMapData(const TextMapType &textMap);
-    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
-    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
-    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
-    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
-    const GameString &lookupIndex(const QModelIndex &index) const;
-public slots:
-    void fontChanged(font_t font);
-private:
-    font_t m_font = FONT_PAGER;
-    TextMapType m_textMap;
-};
-
-#endif
diff --git a/rwviewer/qt.conf.in b/rwviewer/qt.conf.in
deleted file mode 100644
index 0f0492b54..000000000
--- a/rwviewer/qt.conf.in
+++ /dev/null
@@ -1,2 +0,0 @@
-[Paths]
-Prefix = @QT5_ROOT@
diff --git a/rwviewer/views/ModelViewer.cpp b/rwviewer/views/ModelViewer.cpp
deleted file mode 100644
index cc915fc5b..000000000
--- a/rwviewer/views/ModelViewer.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include "ModelViewer.hpp"
-#include <QDebug>
-#include <engine/Animator.hpp>
-#include <fstream>
-#include <objects/GameObject.hpp>
-#include <platform/FileHandle.hpp>
-#include <widgets/ModelFramesWidget.hpp>
-#include "ViewerWidget.hpp"
-
-ModelViewer::ModelViewer(QWidget* parent, Qt::WindowFlags f)
-    : ViewerInterface(parent, f), viewing(nullptr) {
-    mainSplit = new QSplitter;
-    mainLayout = new QVBoxLayout;
-
-    frames = new ModelFramesWidget;
-    frames->setMaximumWidth(300);
-
-    viewerWidget = createViewer();
-    viewerWidget->setMode(ViewerWidget::Mode::Model);
-
-    mainSplit->addWidget(frames);
-    mainSplit->addWidget(QWidget::createWindowContainer(viewerWidget));
-    mainLayout->addWidget(mainSplit);
-
-    setLayout(mainLayout);
-}
-
-void ModelViewer::showModel(ClumpPtr model) {
-    viewing = model;
-    viewerWidget->showModel(model);
-    frames->setModel(model);
-}
-
-void ModelViewer::showObject(uint16_t object) {
-    auto def = world()->data->modelinfo[object].get();
-    if (!def) {
-        return;
-    }
-
-    auto modelName = def->name + ".dff";
-    auto textureName = def->name + ".txd";
-    auto textures = world()->data->loadTextureArchive(textureName);
-
-    LoaderDFF dffLoader;
-    dffLoader.setTextureLookupCallback(
-        [&](const std::string& texture, const std::string&) {
-            return textures.at(texture).get();
-        });
-
-    auto file = world()->data->index.openFile(modelName);
-    if (!file.data) {
-        RW_ERROR("Couldn't load " << modelName);
-        return;
-    }
-    showModel(dffLoader.loadFromMemory(file));
-}
-
-
diff --git a/rwviewer/views/ModelViewer.hpp b/rwviewer/views/ModelViewer.hpp
deleted file mode 100644
index dc926c8df..000000000
--- a/rwviewer/views/ModelViewer.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef _MODELVIEWER_HPP_
-#define _MODELVIEWER_HPP_
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-
-#include "ViewerInterface.hpp"
-
-#include <QLabel>
-#include <QLayout>
-#include <QSplitter>
-#include <QTreeView>
-#include <QVBoxLayout>
-
-class ViewerWidget;
-class Clump;
-class ModelFramesWidget;
-
-class ModelViewer : public ViewerInterface {
-    Q_OBJECT
-
-    ClumpPtr viewing;
-
-    QSplitter* mainSplit;
-    QVBoxLayout* mainLayout;
-    ViewerWidget* viewerWidget;
-
-    ModelFramesWidget* frames;
-
-public:
-    ModelViewer(QWidget* parent = 0, Qt::WindowFlags f = 0);
-
-public slots:
-
-    /**
-     * Display a raw model
-     */
-    void showModel(ClumpPtr model);
-
-    /**
-     * Display a game object's model
-     */
-    void showObject(uint16_t object);
-};
-
-#endif
diff --git a/rwviewer/views/ObjectViewer.cpp b/rwviewer/views/ObjectViewer.cpp
deleted file mode 100644
index e74df86e1..000000000
--- a/rwviewer/views/ObjectViewer.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-#include "ObjectViewer.hpp"
-#include <models/ObjectListModel.hpp>
-#include <ViewerWindow.hpp>
-
-#include <QCheckBox>
-#include <QLineEdit>
-#include <QMenu>
-
-
-class ObjectSearchModel : public QSortFilterProxyModel {
-public:
-    ObjectSearchModel(QObject* parent)
-        : QSortFilterProxyModel(parent) { }
-
-    void showCARS(bool cars) {
-        _showCars = cars;
-        invalidateFilter();
-    }
-
-    void showOBJS(bool objs) {
-        _showMisc = objs;
-        invalidateFilter();
-    }
-
-    void showPEDS(bool peds) {
-        _showPeds = peds;
-        invalidateFilter();
-    }
-
-    void filterName(const QString& name) {
-        _name = name.toStdString();
-        invalidateFilter();
-    }
-
-    bool filterAcceptsRow(int sourceRow,
-                          const QModelIndex &sourceParent) const override
-    {
-        auto index0 = sourceModel()->index(sourceRow, 0, sourceParent);
-        const auto& model = _data->modelinfo.at(index0.internalId());
-
-        switch (model->type()) {
-            case ModelDataType::VehicleInfo:
-                if (!_showCars)
-                    return false;
-                break;
-            case ModelDataType::PedInfo:
-                if (!_showPeds)
-                    return false;
-                break;
-            default:
-                if (!_showMisc)
-                    return false;
-                break;
-        }
-
-        return !(!_name.empty() && model->name.find(_name) == std::string::npos);
-    }
-
-    void setModel(ObjectListModel* model) {
-        _data = model->gameData();
-        QSortFilterProxyModel::setSourceModel(model);
-    }
-
-    GameData* _data = nullptr;
-private:
-    bool _showPeds = true;
-    bool _showMisc = true;
-    bool _showCars = true;
-
-    std::string _name;
-};
-
-namespace {
-QLayout* searchControls(ObjectSearchModel* search) {
-    auto bar = new QHBoxLayout;
-
-    auto searchBox = new QLineEdit;
-    searchBox->setPlaceholderText("Search");
-    QObject::connect(searchBox, &QLineEdit::textChanged, search, &ObjectSearchModel::filterName);
-
-    auto cars = new QCheckBox;
-    cars->setText("CARS");
-    cars->setChecked(true);
-    QObject::connect(cars, &QCheckBox::clicked, search, &ObjectSearchModel::showCARS );
-    auto peds = new QCheckBox;
-    peds->setText("PEDS");
-    peds->setChecked(true);
-    QObject::connect(peds, &QCheckBox::clicked, search, &ObjectSearchModel::showPEDS );
-    auto misc = new QCheckBox;
-    misc->setText("Misc");
-    misc->setChecked(true);
-    QObject::connect(misc, &QCheckBox::clicked, search, &ObjectSearchModel::showOBJS );
-
-    bar->addWidget(searchBox, 1);
-    bar->addWidget(cars);
-    bar->addWidget(peds);
-    bar->addWidget(misc);
-
-    return bar;
-}
-}
-
-ObjectViewer::ObjectViewer(QWidget* parent, Qt::WindowFlags f)
-    : ViewerInterface(parent, f) {
-    mainLayout = new QHBoxLayout(this);
-
-    auto leftLayout = new QVBoxLayout;
-
-    objectList = new QTableView;
-    objectMenu = new QMenu(objectList);
-    objectList->setContextMenuPolicy(Qt::CustomContextMenu);
-    auto viewModelAction = new QAction("View Model", objectMenu);
-    objectMenu->addAction(viewModelAction);
-    connect(viewModelAction, SIGNAL(triggered()), this, SLOT(menuViewModel()));
-    connect(objectList, SIGNAL(customContextMenuRequested(QPoint)), this,
-            SLOT(onCustomContextMenu(QPoint)));
-    filterModel = new ObjectSearchModel(this);
-    objectList->setModel(filterModel);
-    objectList->setColumnWidth(0, 50);
-    objectList->setColumnWidth(1, 150);
-    objectList->setColumnWidth(2, 200);
-    objectList->setSortingEnabled(true);
-    objectList->setSelectionBehavior(QAbstractItemView::SelectionBehavior::SelectRows);
-    connect(objectList->selectionModel(),
-            SIGNAL(currentChanged(QModelIndex, QModelIndex)), this,
-            SLOT(showItem(QModelIndex)));
-
-    leftLayout->addLayout(searchControls(filterModel));
-    leftLayout->addWidget(objectList);
-    mainLayout->addLayout(leftLayout, 6);
-
-    previewWidget = createViewer();
-    previewWidget->setMode(ViewerWidget::Mode::Object);
-
-    infoLayout = new QGridLayout;
-
-    previewID = new QLabel;
-    previewModel = new QLabel;
-    previewClass = new QLabel;
-    infoLayout->addWidget(new QLabel("ID"), 1, 0);
-    infoLayout->addWidget(previewID, 1, 1);
-    infoLayout->addWidget(new QLabel("Type"), 2, 0);
-    infoLayout->addWidget(previewClass, 2, 1);
-    infoLayout->addWidget(new QLabel("Model"), 3, 0);
-    infoLayout->addWidget(previewModel, 3, 1);
-    infoLayout->addWidget(QWidget::createWindowContainer(previewWidget), 0, 0, 1, 2);
-    infoLayout->setRowStretch(0, 1);
-
-    mainLayout->addLayout(infoLayout, 4);
-    setLayout(mainLayout);
-}
-
-void ObjectViewer::worldChanged() {
-    if (filterModel->sourceModel()) {
-        delete filterModel->sourceModel();
-    }
-
-    auto newModel = new ObjectListModel(world()->data, this);
-    filterModel->setModel(newModel);
-    objectList->sortByColumn(0, Qt::AscendingOrder);
-
-    objectList->resizeColumnsToContents();
-}
-
-void ObjectViewer::showItem(qint16 item) {
-    auto def = world()->data->modelinfo[item].get();
-
-    if (def) {
-        previewID->setText(QString::number(def->id()));
-        previewClass->setText(
-            QString::fromStdString(BaseModelInfo::getTypeName(def->type())));
-        previewModel->setText(QString::fromStdString(def->name));
-        previewWidget->showObject(item);
-    }
-}
-
-void ObjectViewer::showItem(QModelIndex model) {
-    auto source = filterModel->mapToSource(model);
-    showItem(source.internalId());
-}
-
-void ObjectViewer::onCustomContextMenu(const QPoint& p) {
-    contextMenuIndex = objectList->indexAt(p);
-    if (contextMenuIndex.isValid()) {
-        objectMenu->exec(objectList->mapToGlobal(p));
-    }
-}
-
-void ObjectViewer::menuViewModel() {
-    if (contextMenuIndex.isValid()) {
-        auto source = filterModel->mapToSource(contextMenuIndex);
-        showObjectModel(source.internalId());
-    }
-}
diff --git a/rwviewer/views/ObjectViewer.hpp b/rwviewer/views/ObjectViewer.hpp
deleted file mode 100644
index 94bb2b530..000000000
--- a/rwviewer/views/ObjectViewer.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef _OBJECTVIEWER_HPP_
-#define _OBJECTVIEWER_HPP_
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-
-#include "ViewerInterface.hpp"
-
-#include <QGridLayout>
-#include <QHBoxLayout>
-#include <QLabel>
-#include <QTableView>
-#include <QSortFilterProxyModel>
-
-class ViewerWidget;
-class Clump;
-
-class ObjectSearchModel;
-
-class ObjectViewer : public ViewerInterface {
-    Q_OBJECT
-
-    QTableView* objectList;
-
-    QHBoxLayout* mainLayout;
-    QGridLayout* infoLayout;
-    ViewerWidget* previewWidget;
-    QLabel* previewID;
-    QLabel* previewModel;
-    QLabel* previewClass;
-
-    QMenu* objectMenu;
-    QModelIndex contextMenuIndex;
-
-    ObjectSearchModel* filterModel;
-
-public:
-    ObjectViewer(QWidget* parent = 0, Qt::WindowFlags f = 0);
-
-protected:
-    void worldChanged() override;
-
-signals:
-    void showObjectModel(uint16_t object);
-
-public slots:
-    void showItem(qint16 item);
-
-private slots:
-
-    void showItem(QModelIndex model);
-
-    void onCustomContextMenu(const QPoint&);
-    void menuViewModel();
-};
-
-#endif
diff --git a/rwviewer/views/TextViewer.cpp b/rwviewer/views/TextViewer.cpp
deleted file mode 100644
index c7efa4f15..000000000
--- a/rwviewer/views/TextViewer.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "TextViewer.hpp"
-
-#include <render/TextRenderer.hpp>
-#include <rw/filesystem.hpp>
-
-#include <algorithm>
-#include <cctype>
-#include <iomanip>
-#include <iostream>
-
-#include <boost/filesystem.hpp>
-#include <fonts/GameTexts.hpp>
-#include <loaders/LoaderGXT.hpp>
-#include <models/TextModel.hpp>
-#include <platform/FileHandle.hpp>
-#include <render/GameRenderer.hpp>
-
-#include <QGroupBox>
-#include <QFormLayout>
-#include <QHBoxLayout>
-#include <QVBoxLayout>
-#include <QItemSelection>
-#include <QLineEdit>
-#include <QModelIndex>
-#include <QPushButton>
-#include <QRadioButton>
-#include <QRegExp>
-#include <QRegExpValidator>
-#include <QSpinBox>
-#include <QSplitter>
-#include <QTableView>
-#include <QTextEdit>
-
-void TextTableView::selectionChanged(const QItemSelection &selected, const QItemSelection &) {
-    if (!selected.size())
-        return;
-    auto index = selected.indexes()[0];
-    if (!index.isValid())
-        return;
-
-    auto *textModel = dynamic_cast<TextModel *>(this->model());
-    if (!textModel) {
-        return;
-    }
-    try {
-        auto gameString = textModel->lookupIndex(index);
-        emit gameStringChanged(gameString);
-    } catch (std::out_of_range &) {
-        return;
-    }
-}
-
-TextViewer::TextViewer(QWidget* parent, Qt::WindowFlags f)
-    : ViewerInterface(parent, f) {
-
-    auto dataLayout = new QVBoxLayout;
-
-    auto splitter = new QSplitter;
-    splitter->setChildrenCollapsible(false);
-    splitter->setOrientation(Qt::Horizontal);
-
-    viewerWidget = createViewer();
-
-    textModel = new TextModel;
-    textTable = new TextTableView;
-    textTable->setModel(textModel);
-    textTable->setSelectionMode(QAbstractItemView::SingleSelection);
-    connect(textTable, &TextTableView::gameStringChanged, this, &TextViewer::onGameStringChange);
-    dataLayout->addWidget(textTable);
-
-    auto propLayout = new QHBoxLayout;
-
-    connect(this, &TextViewer::fontChanged, this, &TextViewer::onFontChange);
-    auto groupBox = new QGroupBox;
-    auto *groupBoxLayout = new QHBoxLayout;
-    auto *radioFont1 = new QRadioButton(tr("Pager"));
-    connect(radioFont1, &QRadioButton::clicked, [this]() {emit fontChanged(FONT_PAGER);});
-    groupBoxLayout->addWidget(radioFont1);
-    auto *radioFont2 = new QRadioButton(tr("Pricedown"));
-    connect(radioFont2, &QRadioButton::clicked, [this]() {emit fontChanged(FONT_PRICEDOWN);});
-    groupBoxLayout->addWidget(radioFont2);
-    auto *radioFont3 = new QRadioButton(tr("Arial"));
-    connect(radioFont3, &QRadioButton::clicked, [this]() {emit fontChanged(FONT_ARIAL);});
-    groupBoxLayout->addWidget(radioFont3);
-    groupBox->setLayout(groupBoxLayout);
-    groupBox->setProperty("border", "2px solid gray");
-    propLayout->addWidget(groupBox);
-
-    radioFont1->click();
-
-    auto textSizeLayout = new QFormLayout;
-    auto textSizeSpinBox = new QSpinBox;
-    textSizeSpinBox->setMinimum(1);
-    textSizeSpinBox->setMaximum(50);
-    connect(textSizeSpinBox, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TextViewer::onFontSizeChange);
-    textSizeSpinBox->setValue(20);
-    textSizeLayout->addRow(tr("Font size"), textSizeSpinBox);
-    propLayout->addLayout(textSizeLayout);
-
-    propLayout->addStretch();
-    dataLayout->addLayout(propLayout);
-
-    hexLineEdit = new QLineEdit;
-    hexLineEdit->setReadOnly(true);
-    hexLineEdit->setValidator(new QRegExpValidator(QRegExp("[0-9A-F]*")));
-    dataLayout->addWidget(hexLineEdit);
-
-    textEdit = new QTextEdit;
-    dataLayout->addWidget(textEdit);
-
-    auto dataWidget = new QWidget;
-    dataWidget->setLayout(dataLayout);
-    splitter->addWidget(dataWidget);
-
-    viewerWidget->setMode(ViewerWidget::Mode::Text);
-    splitter->addWidget(QWidget::createWindowContainer(viewerWidget));
-
-    auto mainLayout = new QHBoxLayout;
-    mainLayout->addWidget(splitter);
-    setLayout(mainLayout);
-
-    connect(textSizeSpinBox, static_cast<void(QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &TextViewer::onFontSizeChange);
-    connect(textEdit, &QTextEdit::textChanged, this, &TextViewer::onStringChange);
-}
-
-void TextViewer::onFontChange(font_t font) {
-    currentFont = font;
-    emit textModel->fontChanged(font);
-    updateRender();
-}
-
-void TextViewer::onFontSizeChange(int size) {
-    currentFontSize = size;
-    updateRender();
-}
-
-void TextViewer::onStringChange() {
-    auto string = textEdit->toPlainText();
-    auto newGameString = GameStringUtil::fromString(string.toStdString(), currentFont);
-    onGameStringChange(newGameString);
-}
-
-void TextViewer::onGameStringChange(const GameString &gameString) {
-    if (!currentGameString.compare(gameString)) {
-        return;
-    }
-    currentGameString = gameString;
-
-    std::ostringstream oss;
-    oss << std::hex;
-    for (auto c : gameString) {
-        oss << std::setw(sizeof(gameString[0])) << std::setfill('0')
-                << int(c) << " ";
-    }
-    auto newHexText = QString::fromStdString(oss.str());
-    if (hexLineEdit->text().compare(newHexText)) {
-        hexLineEdit->setText(newHexText);
-    }
-
-    updateRender();
-}
-
-void TextViewer::updateRender() {
-    viewerWidget->clearText();
-    const int ROW_STRIDE = currentFontSize * 1.2;
-    const int COL_STRIDE = currentFontSize * 1.2;
-    {
-        TextRenderer::TextInfo ti;
-        ti.font = currentFont;
-        ti.size = currentFontSize;
-        ti.baseColour = glm::u8vec3(255);
-        ti.backgroundColour = glm::u8vec4(0, 0, 0, 0);
-        ti.align = TextRenderer::TextInfo::TextAlignment::Left;
-        ti.wrapX = 0;
-
-        ti.text = currentGameString;
-        ti.screenPosition = glm::vec2(10, 10);
-        viewerWidget->showText(ti);
-    }
-
-    {
-        TextRenderer::TextInfo ti;
-        ti.font = currentFont;
-        ti.size = currentFontSize;
-        ti.baseColour = glm::u8vec3(255);
-        ti.backgroundColour = glm::u8vec4(0, 0, 0, 0);
-        ti.align = TextRenderer::TextInfo::TextAlignment::Left;
-        ti.wrapX = 0;
-
-        for(GameStringChar c=0x20; c<0xb2; ++c) {
-            unsigned column = c % 0x10;
-            unsigned row = (c / 0x10) - 2 + 3; /* +3 to offset first line*/
-            ti.text = c;
-            ti.screenPosition = glm::vec2(10 + (column * COL_STRIDE), 10 + (row * ROW_STRIDE));
-            viewerWidget->showText(ti);
-        }
-    }
-}
-
-void TextViewer::worldChanged() {
-    auto textNames = getFontTextureNames();
-    TextMapType textMap;
-    LoaderGXT loader;
-    std::set<std::string> keys;
-    for(const auto &textName : textNames) {
-        GameTexts texts;
-        auto handle = world()->data->index.openFile(textName);
-        loader.load(texts, handle);
-        const auto &language = textName;
-        textMap.languages.push_back(language);
-        const auto &stringTable = texts.getStringTable();
-        for (const auto &tableItem : stringTable) {
-            keys.insert(tableItem.first);
-            textMap.map_lang_key_tran[language][tableItem.first] = tableItem.second;
-        }
-    }
-    textMap.keys.resize(keys.size());
-    std::move(keys.begin(), keys.end(), textMap.keys.begin());
-
-    textModel->setMapData(textMap);
-}
-
-std::vector<std::string> TextViewer::getFontTextureNames() {
-    const auto &gameDataPath = rwfs::path(world()->data->getDataPath());
-    rwfs::path textPath;
-    for (const rwfs::path &p : rwfs::directory_iterator(gameDataPath)) {
-        if (!rwfs::is_directory(p)) {
-            continue;
-        }
-        std::string filename = p.filename().string();
-        std::transform(filename.begin(), filename.end(), filename.begin(), ::tolower);
-        if (!filename.compare("text")) {
-            textPath = p;
-            break;
-        }
-    }
-    if (!textPath.string().length()) {
-        throw std::runtime_error("text directory not found in gamedata path");
-    }
-    std::vector<std::string> names;
-    for (const rwfs::path &p : rwfs::directory_iterator(textPath)) {
-//        auto langName = p.lexically_relative(gameDataPath).string();
-        auto langName = p.filename().string();
-        std::transform(langName.begin(), langName.end(), langName.begin(), ::tolower);
-        names.push_back(langName);
-    }
-    return names;
-}
diff --git a/rwviewer/views/TextViewer.hpp b/rwviewer/views/TextViewer.hpp
deleted file mode 100644
index 5666184f6..000000000
--- a/rwviewer/views/TextViewer.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef _TEXTVIEWER_HPP_
-#define _TEXTVIEWER_HPP_
-
-#include "ViewerInterface.hpp"
-
-#include <fonts/GameTexts.hpp>
-#include <rw/filesystem.hpp>
-
-#include <QTableView>
-
-#include <vector>
-
-class TextModel;
-class ViewerWidget;
-
-class QLayout;
-class QItemSelection;
-class QLineEdit;
-class QTextEdit;
-class QModelIndex;
-class QString;
-class QWidget;
-
-class TextTableView : public QTableView {
-    Q_OBJECT
-protected slots:
-    virtual void selectionChanged(const QItemSelection &selected, const QItemSelection &deselected) override;
-signals:
-    void gameStringChanged(const GameString &string);
-};
-
-class TextViewer : public ViewerInterface {
-    Q_OBJECT
-
-    TextModel *textModel;
-    TextTableView *textTable;
-    ViewerWidget *viewerWidget;
-
-    QLineEdit *hexLineEdit;
-    QTextEdit *textEdit;
-
-    void worldChanged() override;
-
-    GameString currentGameString;
-    font_t currentFont;
-    int currentFontSize;
-
-    void updateRender();
-
-    void setGameString(const GameString &gameString);
-    std::vector<std::string> getFontTextureNames();
-public:
-    TextViewer(QWidget* parent = nullptr, Qt::WindowFlags f = nullptr);
-
-signals:
-    void fontChanged(font_t font);
-private slots:
-    void onGameStringChange(const GameString &gameString);
-    void onStringChange();
-    void onFontChange(size_t font);
-    void onFontSizeChange(int font);
-};
-
-#endif
diff --git a/rwviewer/views/ViewerInterface.cpp b/rwviewer/views/ViewerInterface.cpp
deleted file mode 100644
index 87b7f51c5..000000000
--- a/rwviewer/views/ViewerInterface.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#include "ViewerInterface.hpp"
-
-#include "ViewerWindow.hpp"
-
-ViewerWidget* ViewerInterface::createViewer() {
-    return static_cast<ViewerWindow*>(window())->createViewer();
-}
\ No newline at end of file
diff --git a/rwviewer/views/ViewerInterface.hpp b/rwviewer/views/ViewerInterface.hpp
deleted file mode 100644
index dc49e3b3d..000000000
--- a/rwviewer/views/ViewerInterface.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef _RWVIEWER_VIEWERINTERFACE_HPP_
-#define _RWVIEWER_VIEWERINTERFACE_HPP_
-#include <engine/GameWorld.hpp>
-
-#include <ViewerWidget.hpp>
-
-#include <QWidget>
-
-class ViewerInterface : public QWidget {
-    Q_OBJECT
-public:
-    ViewerInterface(QWidget* parent = 0, Qt::WindowFlags f = 0)
-        : QWidget(parent, f), m_world(nullptr) {
-    }
-
-    GameWorld* world() {
-        return m_world;
-    }
-
-protected:
-    virtual void worldChanged() {}
-
-    ViewerWidget* createViewer();
-
-signals:
-    void gameLoaded(GameWorld*, GameRenderer*);
-
-public slots:
-    void showData(GameWorld* world, GameRenderer* renderer) {
-        m_world = world;
-        gameLoaded(world, renderer);
-        worldChanged();
-    }
-
-private:
-    GameWorld* m_world;
-};
-
-#endif
diff --git a/rwviewer/views/WorldViewer.cpp b/rwviewer/views/WorldViewer.cpp
deleted file mode 100644
index 35d61ecd1..000000000
--- a/rwviewer/views/WorldViewer.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "WorldViewer.hpp"
-#include "ViewerWidget.hpp"
-
-#include <QFileDialog>
-
-WorldViewer::WorldViewer(QWidget* parent, Qt::WindowFlags f)
-    : ViewerInterface(parent, f) {
-    mainLayout = new QVBoxLayout;
-
-    mainLayout->addWidget(QWidget::createWindowContainer(createViewer()));
-
-    setLayout(mainLayout);
-}
-
-void WorldViewer::loadPlacements(const QString& file) {
-    world()->placeItems(file.toStdString());
-    placementsLoaded(file);
-}
-
-void WorldViewer::loadPlacements() {
-    QFileDialog dialog(this, "Open Placements", "", "Placement (*.ipl)");
-    if (dialog.exec()) {
-        loadPlacements(dialog.selectedFiles()[0]);
-    }
-}
diff --git a/rwviewer/views/WorldViewer.hpp b/rwviewer/views/WorldViewer.hpp
deleted file mode 100644
index c988d4f14..000000000
--- a/rwviewer/views/WorldViewer.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _RWVIEWER_WORLDVIEWER_HPP_
-#define _RWVIEWER_WORLDVIEWER_HPP_
-#include <engine/GameData.hpp>
-#include <engine/GameWorld.hpp>
-
-#include "ViewerInterface.hpp"
-
-#include <QLabel>
-#include <QLayout>
-#include <QSplitter>
-#include <QTreeView>
-#include <QVBoxLayout>
-
-class WorldViewer : public ViewerInterface {
-    Q_OBJECT
-
-    QVBoxLayout* mainLayout;
-    ViewerWidget* viewerWidget;
-
-public:
-    WorldViewer(QWidget* parent = 0, Qt::WindowFlags f = 0);
-
-signals:
-    void placementsLoaded(const QString& file);
-
-public slots:
-    void loadPlacements(const QString& file);
-    void loadPlacements();
-};
-
-#endif
diff --git a/rwviewer/widgets/AnimationListWidget.cpp b/rwviewer/widgets/AnimationListWidget.cpp
deleted file mode 100644
index c9d3b6cd3..000000000
--- a/rwviewer/widgets/AnimationListWidget.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include "AnimationListWidget.hpp"
-#include <QVBoxLayout>
-
-AnimationListWidget::AnimationListWidget(QWidget* parent, Qt::WindowFlags flags)
-    : QDockWidget(parent, flags), filter(nullptr), model(nullptr) {
-    setWindowTitle("Animations");
-    QVBoxLayout* layout = new QVBoxLayout();
-    QWidget* intermediate = new QWidget();
-
-    searchbox = new QLineEdit();
-    searchbox->setPlaceholderText("Search");
-
-    table = new QListView();
-    layout->addWidget(searchbox);
-    layout->addWidget(table);
-    intermediate->setLayout(layout);
-    setWidget(intermediate);
-
-    filter = new QSortFilterProxyModel;
-    table->setModel(filter);
-    connect(table->selectionModel(),
-            SIGNAL(currentChanged(QModelIndex, QModelIndex)),
-            SLOT(selectedIndexChanged(QModelIndex)));
-    connect(searchbox, SIGNAL(textChanged(QString)), SLOT(setFilter(QString)));
-}
-
-void AnimationListWidget::setAnimations(const AnimationList& archive) {
-    auto m = new AnimationListModel(archive);
-    filter->setSourceModel(m);
-    if (model) {
-        delete model;
-    }
-    model = m;
-}
-
-void AnimationListWidget::selectedIndexChanged(const QModelIndex& current) {
-    auto mts = filter->mapToSource(current);
-    if (mts.row() >= 0 &&
-        static_cast<unsigned>(mts.row()) < model->getAnimations().size()) {
-        auto& f = model->getAnimations().at(mts.row());
-        emit selectedAnimationChanged(f.second);
-    }
-}
-
-void AnimationListWidget::setFilter(const QString& f) {
-    filter->setFilterRegExp(QRegExp(f, Qt::CaseInsensitive));
-}
diff --git a/rwviewer/widgets/AnimationListWidget.hpp b/rwviewer/widgets/AnimationListWidget.hpp
deleted file mode 100644
index 9546398b7..000000000
--- a/rwviewer/widgets/AnimationListWidget.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef _ANIMATIONLISTWIDGET_HPP_
-#define _ANIMATIONLISTWIDGET_HPP_
-#include <QDockWidget>
-#include <QLineEdit>
-#include <QListView>
-#include <QSortFilterProxyModel>
-#include "models/AnimationListModel.hpp"
-
-class AnimationListWidget : public QDockWidget {
-    Q_OBJECT
-
-    QSortFilterProxyModel* filter;
-    AnimationListModel* model;
-    QListView* table;
-    QLineEdit* searchbox;
-
-public:
-    AnimationListWidget(QWidget* parent = 0, Qt::WindowFlags flags = 0);
-
-    void setAnimations(const AnimationList& anims);
-
-signals:
-
-    void selectedAnimationChanged(AnimationPtr anim);
-
-public slots:
-    void selectedIndexChanged(const QModelIndex& current);
-
-    void setFilter(const QString& f);
-};
-
-#endif
diff --git a/rwviewer/widgets/ItemListWidget.cpp b/rwviewer/widgets/ItemListWidget.cpp
deleted file mode 100644
index 0c89e24a0..000000000
--- a/rwviewer/widgets/ItemListWidget.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include "ItemListWidget.hpp"
-#include <QHeaderView>
-#include <QVBoxLayout>
-
-ItemListWidget::ItemListWidget(QWidget* parent, Qt::WindowFlags flags)
-    : QDockWidget(parent, flags), filter(nullptr), model(nullptr) {
-    setWindowTitle("Items");
-    QVBoxLayout* layout = new QVBoxLayout();
-    QWidget* intermediate = new QWidget();
-
-    searchbox = new QLineEdit();
-    searchbox->setPlaceholderText("Search");
-
-    table = new QTableView();
-    layout->addWidget(searchbox);
-    layout->addWidget(table);
-    table->setSelectionBehavior(QAbstractItemView::SelectRows);
-    intermediate->setLayout(layout);
-    setWidget(intermediate);
-
-    filter = new QSortFilterProxyModel;
-    table->setModel(filter);
-    filter->setFilterKeyColumn(-1);  // Search all columns
-    connect(table->selectionModel(),
-            SIGNAL(currentChanged(QModelIndex, QModelIndex)),
-            SLOT(selectedIndexChanged(QModelIndex)));
-    connect(searchbox, SIGNAL(textChanged(QString)), SLOT(setFilter(QString)));
-}
-
-void ItemListWidget::worldLoaded(GameWorld* world) {
-    if (model) delete model;
-    model = new ItemListModel(world, this);
-    filter->setSourceModel(model);
-}
-
-void ItemListWidget::selectedIndexChanged(const QModelIndex& current) {
-    auto mts = filter->mapToSource(current);
-    if (mts.isValid()) {
-        emit selectedItemChanged(model->getIDOf(mts.row()));
-    }
-}
-
-void ItemListWidget::setFilter(const QString& f) {
-    filter->setFilterRegExp(QRegExp(f, Qt::CaseInsensitive));
-}
diff --git a/rwviewer/widgets/ItemListWidget.hpp b/rwviewer/widgets/ItemListWidget.hpp
deleted file mode 100644
index a522649fa..000000000
--- a/rwviewer/widgets/ItemListWidget.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef _ITEMLISTWIDGET_HPP_
-#define _ITEMLISTWIDGET_HPP_
-#include <QDockWidget>
-#include <QLineEdit>
-#include <QSortFilterProxyModel>
-#include <QTableView>
-#include "models/ItemListModel.hpp"
-
-class ItemListWidget : public QDockWidget {
-    Q_OBJECT
-
-    QSortFilterProxyModel* filter;
-    ItemListModel* model;
-    QTableView* table;
-    QLineEdit* searchbox;
-
-public:
-    ItemListWidget(QWidget* parent = 0, Qt::WindowFlags flags = 0);
-
-signals:
-    void selectedItemChanged(const qint16 id);
-
-public slots:
-
-    void worldLoaded(GameWorld* world);
-
-    void selectedIndexChanged(const QModelIndex& current);
-
-    void setFilter(const QString& f);
-};
-
-#endif
diff --git a/rwviewer/widgets/ModelFramesWidget.cpp b/rwviewer/widgets/ModelFramesWidget.cpp
deleted file mode 100644
index cfd1253c7..000000000
--- a/rwviewer/widgets/ModelFramesWidget.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "ModelFramesWidget.hpp"
-#include <data/Clump.hpp>
-#include <glm/gtx/string_cast.hpp>
-
-void ModelFramesWidget::updateInfoBox(ClumpPtr, ModelFrame* f) {
-    if (f == nullptr) {
-        _frameLabel->setText("");
-    } else {
-        auto labText = QString("Name: %1\nTranslation: %2")
-                           .arg(QString::fromStdString(f->getName()))
-                           .arg(QString::fromStdString(
-                               glm::to_string(f->getDefaultTranslation())));
-        _frameLabel->setText(labText);
-    }
-}
-
-void ModelFramesWidget::selectedModelChanged(const QModelIndex& n,
-                                             const QModelIndex&) {
-    updateInfoBox(gmodel, static_cast<ModelFrame*>(n.internalPointer()));
-    selectedFrameChanged(static_cast<ModelFrame*>(n.internalPointer()));
-}
-
-ModelFramesWidget::ModelFramesWidget(QWidget* parent, Qt::WindowFlags flags)
-    : QWidget(parent, flags), gmodel(nullptr), framemodel(nullptr) {
-    setWindowTitle("Frames");
-
-    _layout = new QVBoxLayout;
-    tree = new QTreeView(this);
-    _layout->addWidget(tree);
-    _frameLabel = new QLabel(this);
-    _layout->addWidget(_frameLabel);
-
-    setLayout(_layout);
-}
-
-void ModelFramesWidget::setModel(ClumpPtr model) {
-    if (framemodel) {
-        delete framemodel;
-        framemodel = nullptr;
-        tree->setModel(nullptr);
-    }
-    gmodel = model;
-    if (model.get() != nullptr) {
-        framemodel = new DFFFramesTreeModel(model, this);
-        tree->setModel(framemodel);
-        tree->setDisabled(false);
-        connect(tree->selectionModel(),
-                SIGNAL(currentChanged(QModelIndex, QModelIndex)),
-                SLOT(selectedModelChanged(QModelIndex, QModelIndex)));
-    } else {
-        tree->setDisabled(true);
-    }
-}
diff --git a/rwviewer/widgets/ModelFramesWidget.hpp b/rwviewer/widgets/ModelFramesWidget.hpp
deleted file mode 100644
index 1f9487fb0..000000000
--- a/rwviewer/widgets/ModelFramesWidget.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef _MODELFRAMESWIDGET_HPP_
-#define _MODELFRAMESWIDGET_HPP_
-#include <QDockWidget>
-#include <QLabel>
-#include <QTreeView>
-#include <QVBoxLayout>
-#include <rw/types.hpp>
-#include "models/DFFFramesTreeModel.hpp"
-
-class ModelFrame;
-
-class ModelFramesWidget : public QWidget {
-    Q_OBJECT
-
-    ClumpPtr gmodel;
-    DFFFramesTreeModel* framemodel;
-    QTreeView* tree;
-    QVBoxLayout* _layout;
-    QLabel* _frameLabel;
-
-private slots:
-
-    void updateInfoBox(ClumpPtr model, ModelFrame* f);
-
-    void selectedModelChanged(const QModelIndex&, const QModelIndex&);
-
-public:
-    ModelFramesWidget(QWidget* parent = 0, Qt::WindowFlags flags = 0);
-
-public slots:
-
-    void setModel(ClumpPtr model);
-
-signals:
-
-    void selectedFrameChanged(ModelFrame* frame);
-};
-
-#endif
diff --git a/scripts/conan/create_vs_solution.py b/scripts/conan/create_vs_solution.py
index 536558f9b..149829a70 100755
--- a/scripts/conan/create_vs_solution.py
+++ b/scripts/conan/create_vs_solution.py
@@ -38,7 +38,7 @@ def create_solution(path, vs_version, arch):
     cmake_generator = to_cmake_generator(vs_version=vs_version, arch=arch)
     subprocess.run([
         'cmake', '-DUSE_CONAN=ON', '-DBOOST_STATIC=ON', '-DMSVC_NO_DEBUG_RUNTIME=ON',
-        '-DBUILD_TESTS=ON', '-DBUILD_VIEWER=ON', '-DBUILD_TOOLS=ON',
+        '-DBUILD_TESTS=ON', '-DBUILD_TOOLS=ON',
         '-G{}'.format(cmake_generator), str(openrw_path),
     ], cwd=path, check=True)