diff --git a/.github/workflows/cmake.yaml b/.github/workflows/cmake.yaml
deleted file mode 100644
index 4223b0e..0000000
--- a/.github/workflows/cmake.yaml
+++ /dev/null
@@ -1,51 +0,0 @@
-name: CMake
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-env:
-  BUILD_TYPE: Release
-
-jobs:
-  build:
-    runs-on: ${{matrix.os}}
-    strategy:
-      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Setup ccache
-      uses: Chocobo1/setup-ccache-action@v1
-      with:
-        windows_compile_environment: msvc
-
-    - name: Cache CMake build directory
-      uses: actions/cache@v3
-      env:
-        cache-name: cache-cmake-build
-      with:
-        path: ${{github.workspace}}/build
-        key: ${{matrix.os}}-${{env.BUILD_TYPE}}-build2
-
-    - name: Configure CMake (Windows)
-      # Builind with shared libs fails on Windows ATM
-      if: runner.os == 'Windows'
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILD_SHARED_LIBS=OFF
-
-    - name: Configure CMake
-      if: runner.os != 'Windows'
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
-
-    - name: Build
-      # According to this link, github runners should have at least two CPUs
-      # https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} --parallel 2
-
-    - name: Test
-      working-directory: ${{github.workspace}}/build
-      run: ctest -C ${{env.BUILD_TYPE}}
diff --git a/.github/workflows/conan.yaml b/.github/workflows/conan.yaml
new file mode 100644
index 0000000..55c682b
--- /dev/null
+++ b/.github/workflows/conan.yaml
@@ -0,0 +1,56 @@
+name: conan
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        build_type: [Release, Debug]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Get conan
+      uses: turtlebrowser/get-conan@v1.2
+
+    - name: Set conan packages path
+      run: echo "CONAN_PACKAGES=$(conan config home)/p" >> $GITHUB_ENV
+      if: ${{ matrix.os == 'ubuntu-latest' }}
+
+    - name: Set conan packages path
+      run: |
+        "CONAN_PACKAGES=$(conan config home)\p" | Out-File -FilePath $env:GITHUB_ENV -Append
+      if: ${{ matrix.os == 'windows-latest' }}
+
+    - name: Cache conan home
+      uses: actions/cache@v4
+      with:
+        path: ${{ env.CONAN_PACKAGES }}
+        key: ${{ matrix.os }}-${{ matrix.build_type }}-conan
+
+    - name: Create default profile
+      run: conan profile detect --force
+
+    - name: Install dependencies
+      run: |
+        conan install .                                    \
+          --settings build_type=${{ matrix.build_type }}   \
+          --build=missing                                  \
+          --conf tools.system.package_manager:mode=install \
+          --conf tools.system.package_manager:sudo=True
+      if: ${{ matrix.os == 'ubuntu-latest' }}
+
+    - name: Install dependencies
+      run: |
+        conan install .                                  `
+          --settings build_type=${{ matrix.build_type }} `
+          --build=missing
+      if: ${{ matrix.os == 'windows-latest' }}
+
+    - name: Build
+      run: conan build .
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e1c1adc..6a70213 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,17 +1,21 @@
 cmake_minimum_required(VERSION 3.20)
 
-project("Chip-8" VERSION 0.1 LANGUAGES CXX C)
+project("Chip-8" VERSION 0.1 LANGUAGES CXX)
 
 option(BUILD_SHARED_LIBS "Build shared libs" ON)
 option(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS "Export Windows symbols" ON)
 
-if (MSVC)
-    message(WARNING "BUILD_SHARED_LIBS can't be used with MSVC")
-    set(BUILD_SHARED_LIBS OFF)
-endif()
+find_package(SDL2 REQUIRED)
+find_package(SDL2_ttf REQUIRED)
+find_package(fmt REQUIRED)
+find_package(doctest REQUIRED)
+find_package(cxxopts REQUIRED)
+find_package(yaml-cpp REQUIRED)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
-include(cmake/dependencies.cmake)
-include(cmake/copy_dll.cmake)
 include(cmake/compiler_flags.cmake)
 enable_testing() # needed to create the target lib/test
 add_subdirectory(lib)
diff --git a/README.MD b/README.MD
index abe6b3b..796fd68 100644
--- a/README.MD
+++ b/README.MD
@@ -10,10 +10,13 @@ It contains:
 ## Build
 
 Requirements:
-- C and C++ compiler
-- Cmake v3.20 or later
+- C++ 20 compiler
+- conan 2.x
 
 ```console
-cmake -B build
-cmake --build build
-```
\ No newline at end of file
+# on Linux, you might need to add these options:
+#   -c tools.system.package_manager:mode=install
+#   -c tools.system.package_manager:sudo=True
+conan install . --build=missing
+conan build .
+```
diff --git a/chip-8-disassembler/CMakeLists.txt b/chip-8-disassembler/CMakeLists.txt
index 0b809a9..c2a93dc 100644
--- a/chip-8-disassembler/CMakeLists.txt
+++ b/chip-8-disassembler/CMakeLists.txt
@@ -4,4 +4,3 @@ add_executable(chip-8-disassembler disas.cpp)
 target_include_directories(chip-8-disassembler PRIVATE ${CHIP8_INCLUDE_DIRS})
 target_link_libraries(chip-8-disassembler PRIVATE chip-8 fmt::fmt)
 enable_warnings(chip-8-disassembler)
-copy_dll(chip-8-disassembler "chip-8;fmt")
diff --git a/chip-8-disassembler/disas.cpp b/chip-8-disassembler/disas.cpp
index 2405f24..38fcd88 100644
--- a/chip-8-disassembler/disas.cpp
+++ b/chip-8-disassembler/disas.cpp
@@ -22,7 +22,7 @@ int main(int argc, char** argv)
     for (std::size_t i = 0; i < program.size() && i + 1 < program.size(); i += 2)
     {
         uint16_t raw_opcode = program[i] << 8 | program[i + 1];
-        opcode decoded_opcode = opcode::decode(raw_opcode);
+        Opcode decoded_opcode = Opcode::decode(raw_opcode);
         std::cout << fmt::format("{:#06x}     {}\n", addr, decoded_opcode.string_repr());
         addr += 2;
     }
diff --git a/chip-8-sdl/CMakeLists.txt b/chip-8-sdl/CMakeLists.txt
index 95a5369..ed07049 100644
--- a/chip-8-sdl/CMakeLists.txt
+++ b/chip-8-sdl/CMakeLists.txt
@@ -11,16 +11,18 @@ add_executable(chip-8-sdl
     widget/widget.cpp
 )
 
-if (WIN32)
-    set_target_properties(chip-8-sdl PROPERTIES WIN32_EXECUTABLE TRUE)
-    target_link_libraries(chip-8-sdl PRIVATE SDL2main)
-endif()
 target_include_directories(chip-8-sdl PRIVATE ${CHIP8_INCLUDE_DIRS} ".")
 target_include_directories(chip-8-sdl SYSTEM PRIVATE "${cxxopts_SOURCE_DIR}/include")
-target_link_libraries(chip-8-sdl PRIVATE chip-8 "$<IF:$<BOOL:${BUILD_SHARED_LIBS}>,SDL2,SDL2-static>" SDL2_ttf yaml-cpp fmt::fmt)
+target_link_libraries(chip-8-sdl PRIVATE
+    chip-8
+    SDL2::SDL2main
+    SDL2::SDL2-static
+    SDL2_ttf::SDL2_ttf-static
+    yaml-cpp
+    fmt::fmt
+    cxxopts::cxxopts
+)
 enable_warnings(chip-8-sdl)
-copy_dll(chip-8-sdl "SDL2;SDL2_ttf;chip-8;fmt;yaml-cpp")
-
 get_filename_component(SOUND_FILE_PATH "res/audio/beep-02.wav" ABSOLUTE)
 get_filename_component(FONT_FILE_PATH "res/fonts/PressStart2P-Regular.ttf" ABSOLUTE)
 configure_file(configuration.yaml.in configuration.yaml)
diff --git a/chip-8-sdl/app.cpp b/chip-8-sdl/app.cpp
index 61b4c30..840db2d 100644
--- a/chip-8-sdl/app.cpp
+++ b/chip-8-sdl/app.cpp
@@ -1,9 +1,12 @@
 #include <fmt/core.h>
 #include <fstream>
 #include <iostream>
+#include <istream>
 
 #include "app.h"
 #include "icons/folder.h"
+#include "icons/play.h"
+#include "icons/warning.h"
 #include "widget/button.h"
 #include "widget/chip8_screen.h"
 #include "widget/label.h"
@@ -11,37 +14,37 @@
 
 static constexpr int font_point_size = 12;
 
-static constexpr int scale_factor = 10;
-static constexpr int panel_width = chip8::screen_width * scale_factor;
-static constexpr int panel_height = (chip8::screen_height / 8) * scale_factor;
-static constexpr int renderer_width = chip8::screen_width * scale_factor;
-static constexpr int renderer_height = chip8::screen_height * scale_factor + panel_height;
-static constexpr int chip8screen_y = panel_height;
-
-app::app(config& conf, std::string const& rom_path, const uint8_t* program, size_t program_size)
-    : m_emulator(program, program_size), m_rom_path(rom_path)
+static constexpr int SCALE_FACTOR = 10;
+static constexpr int PANEL_WIDTH = Chip8::SCREEN_WIDTH * SCALE_FACTOR;
+static constexpr int PANEL_HEIGHT = (Chip8::SCREEN_HEIGHT / 8) * SCALE_FACTOR;
+static constexpr int RENDERER_WIDTH = Chip8::SCREEN_WIDTH * SCALE_FACTOR;
+static constexpr int RENDERER_HEIGHT = Chip8::SCREEN_HEIGHT * SCALE_FACTOR + PANEL_HEIGHT;
+static constexpr int CHIP8SCREEN_Y = PANEL_HEIGHT;
+
+App::App(Config& conf, std::string const& rom_path, std::vector<uint8_t> const& program)
+    : m_emulator(program),
+      m_rom_path(rom_path),
+      m_conf(conf),
+      m_window(SDLUniqueWindow(SDL_CreateWindow("Chip-8 Emulator",
+        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+        conf.window_width, conf.window_height, 0) , SDLCleaner())),
+      m_quit(false),
+      m_audio_enabled(false),
+      m_wav_buffer(nullptr),
+      m_audio_device(0)
 {
     sdl_checksuccess(SDL_Init(init_flags), "Failed to initialize the SDL: %s\n");
     sdl_checksuccess(TTF_Init(), "Failed to initialize SDL_ttf: %s\n");
-    m_conf = conf;
-    m_window = SDLUniqueWindow(SDL_CreateWindow("Chip-8 Emulator",
-        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
-        conf.window_width, conf.window_height, 0)
-        , SDLCleaner());
     sdl_nullcheck(m_window.get(), "Failed to create the window: %s\n");
     SDL_SetWindowResizable(m_window.get(), SDL_TRUE);
     m_renderer = SDLSharedRenderer(SDL_CreateRenderer(m_window.get(), -1, SDL_RENDERER_ACCELERATED), SDLCleaner());
     sdl_nullcheck(m_renderer.get(), "Failed to create the renderer: %s\n");
     set_renderer_color(m_renderer, m_conf.bg_color);
     sdl_checksuccess(SDL_RenderClear(m_renderer.get()), "Failed to clear the renderer: %s\n");
-    sdl_checksuccess(SDL_RenderSetLogicalSize(m_renderer.get(), renderer_width, renderer_height),
-        "Failed to set the renderer's logical scale: %s");
+    // sdl_checksuccess(SDL_RenderSetLogicalSize(m_renderer.get(), RENDERER_WIDTH, RENDERER_HEIGHT),
+        // "Failed to set the renderer's logical scale: %s");
     sdl_checksuccess(SDL_RenderSetIntegerScale(m_renderer.get(), SDL_TRUE),
         "Failed to set integer scaling on the renderer: %s");
-    m_quit = false;
-    m_audio_enabled = false;
-    m_audio_device = 0;
-    m_wav_buffer = nullptr;
     if (conf.sound_file)
     {
         std::string sound_strpath = conf.sound_file.value().string();
@@ -68,17 +71,17 @@ app::app(config& conf, std::string const& rom_path, const uint8_t* program, size
         sdl_nullcheck(m_font.get(), fmt::format("Failed to open font file: {}", font_strpath).c_str());
     }
 
-    panel_ptr p1 = std::make_shared<panel>(m_renderer, 0, 0, panel_width, panel_height, m_conf.fg_color, m_conf.bg_color);
-    button_ptr b1 = std::make_shared<button>(m_renderer, 1, 2, 32, 32, m_conf.fg_color, m_conf.bg_color, folder_icon, 32, 32);
-    //label_ptr l1 = std::make_shared<label>(m_renderer, 1, 2, panel_width - 2, panel_height - 3, m_rom_path, m_font, m_conf.fg_color, m_conf.bg_color);
-    //p1->add_child(l1);
-    p1->add_child(b1);
-
-    m_widgets.push_back(p1);
-    m_widgets.push_back(std::make_shared<chip8_screen>(m_renderer, 0, panel_height, m_conf.fg_color, m_conf.bg_color, m_emulator, scale_factor));
+    panel_ptr p1 = std::make_unique<Panel>(m_renderer, 0, 0, PANEL_WIDTH, PANEL_HEIGHT, m_conf.fg_color, m_conf.bg_color, Layout::Horizontal);
+    p1->add_child(std::make_unique<Button>(m_renderer, 1, 2, 32, 32, m_conf.fg_color, m_conf.bg_color, folder_icon, 32, 32));
+    p1->add_child(std::make_unique<Button>(m_renderer, 1, 2, 32, 32, m_conf.fg_color, m_conf.bg_color, play_icon, 32, 32));
+    p1->add_child(std::make_unique<Button>(m_renderer, 1, 2, 32, 32, m_conf.fg_color, m_conf.bg_color, warning_icon, 32, 32));
+    // label_ptr l1 = std::make_shared<Label>(m_renderer, 1, 2, PANEL_WIDTH - 2, PANEL_HEIGHT - 3,  m_conf.fg_color, m_conf.bg_color, m_rom_path, m_font);
+    // p1->add_child(l1);
+    m_widgets.push_back(std::make_unique<Chip8Screen>(m_renderer, 0, PANEL_HEIGHT, m_conf.fg_color, m_conf.bg_color, m_emulator, SCALE_FACTOR));
+    m_widgets.push_back(std::move(p1));
 }
 
-app::~app()
+App::~App()
 {
 
     if (m_audio_device > 0)
@@ -88,7 +91,7 @@ app::~app()
 }
 
 // FIXME: this should return EXIT_FAILURE when something goes wrong
-int app::exec()
+int App::exec()
 {
     while (!m_quit)
     {
@@ -109,7 +112,7 @@ int app::exec()
     return EXIT_SUCCESS;
 }
 
-void app::handle_event()
+void App::handle_event()
 {
     while (SDL_PollEvent(&m_event))
     {
@@ -167,11 +170,11 @@ void app::handle_event()
     }
 }
 
-void app::render()
+void App::render()
 {
     set_renderer_color(m_renderer, m_conf.bg_color);
     SDL_RenderClear(m_renderer.get());
-    for (widget_ptr widget : m_widgets)
+    for (widget_ptr const& widget : m_widgets)
     {
         widget->draw();
         SDL_SetRenderTarget(m_renderer.get(), NULL);
@@ -180,7 +183,7 @@ void app::render()
     SDL_RenderPresent(m_renderer.get());
 }
 
-void app::play_sound()
+void App::play_sound()
 {
     if (m_audio_enabled)
     {
@@ -190,7 +193,7 @@ void app::play_sound()
     }
 }
 
-std::vector<uint8_t> app::load_rom(std::filesystem::path rom_path)
+std::vector<uint8_t> App::load_rom(std::filesystem::path rom_path)
 {
     std::ifstream rom_file(rom_path.string(), std::ios::binary);
     if (!rom_file)
diff --git a/chip-8-sdl/app.h b/chip-8-sdl/app.h
index 48b81c4..8193cda 100644
--- a/chip-8-sdl/app.h
+++ b/chip-8-sdl/app.h
@@ -1,17 +1,18 @@
 #include <vector>
+#include <cstdint>
 
 #include "chip8.h"
 #include "config.h"
 #include "sdl_helper.h"
 #include "widget/widget.h"
 
-class app
+class App
 {
 public:
     static constexpr uint32_t init_flags = SDL_INIT_AUDIO | SDL_INIT_EVENTS| SDL_INIT_TIMER | SDL_INIT_VIDEO;
 
-    app(config& conf, std::string const& rom_path, const uint8_t* program, size_t program_size);
-    ~app();
+    App(Config& conf, std::string const& rom_path, std::vector<uint8_t> const& program);
+    ~App();
     int exec();
 
     static std::vector<uint8_t> load_rom(std::filesystem::path rom_path);
@@ -21,9 +22,9 @@ class app
     void render();
     void play_sound();
 
-    chip8 m_emulator;
+    Chip8 m_emulator;
     std::string const& m_rom_path;
-    config m_conf;
+    Config m_conf;
     SDLUniqueWindow m_window;
     SDLSharedRenderer m_renderer;
     SDL_Event m_event;
diff --git a/chip-8-sdl/config.h b/chip-8-sdl/config.h
index 3921e8a..116bc2a 100644
--- a/chip-8-sdl/config.h
+++ b/chip-8-sdl/config.h
@@ -6,31 +6,31 @@
 #include <optional>
 #include <yaml-cpp/yaml.h>
 
-struct config
+struct Config
 {
 public:
     static constexpr uint16_t default_width  = 640;
     static constexpr uint16_t default_height = 360;
-    static constexpr uint8_t default_instructions_per_frame = 10;
+    static constexpr uint16_t default_instructions_per_frame = 10;
     static constexpr SDL_Color default_fg_color = SDL_Color { 255, 255, 255, 255 };
     static constexpr SDL_Color default_bg_color = SDL_Color { 0, 0, 0, 255 };
 
     uint16_t window_width;
     uint16_t window_height;
-    uint8_t instructions_per_frame;
+    uint16_t instructions_per_frame;
     SDL_Color fg_color;
     SDL_Color bg_color;
     std::optional<std::filesystem::path> sound_file;
     std::optional<std::filesystem::path> font_file;
 
-    config()
+    Config()
         : window_width(default_width), window_height(default_height),
         instructions_per_frame(default_instructions_per_frame),
         fg_color(default_fg_color), bg_color(default_bg_color),
         sound_file(std::nullopt), font_file(std::nullopt)
     {}
 
-    config(YAML::Node const& yaml_conf)
+    Config(YAML::Node const& yaml_conf)
     {
         window_width = val_from_conf(yaml_conf, "window_width", default_width);
         window_height = val_from_conf(yaml_conf, "window_height", default_height);
diff --git a/chip-8-sdl/main.cpp b/chip-8-sdl/main.cpp
index 7655fa2..9ed4f80 100644
--- a/chip-8-sdl/main.cpp
+++ b/chip-8-sdl/main.cpp
@@ -2,6 +2,7 @@
 #include <filesystem>
 #include <SDL.h>
 #include <yaml-cpp/yaml.h>
+#include <fmt/core.h>
 
 #include "app.h"
 #include "chip8.h"
@@ -29,16 +30,17 @@ int main(int argc, char** argv)
         exit(EXIT_FAILURE);
     }
 
-    config conf;
+    Config conf;
     if (result.count("file"))
     {
+        fmt::print("Loading config {}\n", result["file"].as<std::string>());
         YAML::Node config_yaml = YAML::LoadFile(result["file"].as<std::string>());
-        conf = config(config_yaml);
+        conf = Config(config_yaml);
     }
 
     std::string rom_path = result["rom"].as<std::string>();
-    std::vector<uint8_t> rom_content = app::load_rom(rom_path);
-    app chip8_emulator(conf, rom_path, rom_content.data(), rom_content.size());
+    std::vector<uint8_t> rom_content = App::load_rom(rom_path);
+    App chip8_emulator(conf, rom_path, rom_content);
 
     return chip8_emulator.exec();
 }
diff --git a/chip-8-sdl/widget/button.cpp b/chip-8-sdl/widget/button.cpp
index f1233ab..334eb96 100644
--- a/chip-8-sdl/widget/button.cpp
+++ b/chip-8-sdl/widget/button.cpp
@@ -1,9 +1,9 @@
 #include "button.h"
 
-button::~button()
+Button::~Button()
 {}
 
-void button::draw()
+void Button::draw()
 {
     as_rendering_target();
 
diff --git a/chip-8-sdl/widget/button.h b/chip-8-sdl/widget/button.h
index 1660da4..ef966e7 100644
--- a/chip-8-sdl/widget/button.h
+++ b/chip-8-sdl/widget/button.h
@@ -6,14 +6,14 @@
 
 using icon = std::array<uint8_t, 1024>;
 
-class button : public widget
+class Button : public Widget
 {
 public:
-    button(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color, icon const& icon_data, int icon_w, int icon_h)
-        : widget(renderer, x, y, w, h, fg_color, bg_color),
+    Button(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color, icon const& icon_data, int icon_w, int icon_h)
+        : Widget(renderer, x, y, w, h, fg_color, bg_color),
         m_icon(icon_data), m_icon_w(icon_w), m_icon_h(icon_h)
     {}
-    ~button() override;
+    ~Button() override;
     void draw() override;
 private:
     icon const& m_icon;
@@ -21,4 +21,4 @@ class button : public widget
     int m_icon_h;
 };
 
-using button_ptr = std::shared_ptr<button>;
+using button_ptr = std::unique_ptr<Button>;
diff --git a/chip-8-sdl/widget/chip8_screen.cpp b/chip-8-sdl/widget/chip8_screen.cpp
index 381ccdb..d7c9a38 100644
--- a/chip-8-sdl/widget/chip8_screen.cpp
+++ b/chip-8-sdl/widget/chip8_screen.cpp
@@ -1,26 +1,26 @@
 #include "chip8_screen.h"
 #include "sdl_helper.h"
 
-chip8_screen::~chip8_screen()
+Chip8Screen::~Chip8Screen()
 {}
 
-void chip8_screen::draw()
+void Chip8Screen::draw()
 {
     as_rendering_target();
 
     set_renderer_color(m_renderer, m_bg_color);
     SDL_RenderClear(m_renderer.get());
-    std::array<uint8_t, chip8::vram_size> const& emulator_vram = m_emulator.get_vram();
+    std::array<uint8_t, Chip8::VRAM_SIZE> const& emulator_vram = m_emulator.get_vram();
     if (m_emulator.vram_dirty)
     {
         SDL_Rect pixel = SDL_Rect { 0, 0, m_scale_factor, m_scale_factor };
-        for (std::size_t y = 0; y < chip8::screen_height; y++)
+        for (std::size_t y = 0; y < Chip8::SCREEN_HEIGHT; y++)
         {
             pixel.y = y * pixel.h;
-            for (std::size_t x = 0; x < chip8::screen_width; x++)
+            for (std::size_t x = 0; x < Chip8::SCREEN_WIDTH; x++)
             {
                 pixel.x = x * pixel.w;
-                uint8_t pixel_val = emulator_vram[x + y * chip8::screen_width];
+                uint8_t pixel_val = emulator_vram[x + y * Chip8::SCREEN_WIDTH];
                 if (pixel_val)
                     set_renderer_color(m_renderer, m_fg_color);
                 else
diff --git a/chip-8-sdl/widget/chip8_screen.h b/chip-8-sdl/widget/chip8_screen.h
index 8e3bce8..ca14e9e 100644
--- a/chip-8-sdl/widget/chip8_screen.h
+++ b/chip-8-sdl/widget/chip8_screen.h
@@ -3,16 +3,16 @@
 #include "chip8.h"
 #include "widget.h"
 
-class chip8_screen : public widget
+class Chip8Screen : public Widget
 {
 public:
-    chip8_screen(SDLSharedRenderer renderer, int x, int y, SDL_Color fg_color, SDL_Color bg_color, chip8 const& emulator, int scale_factor)
-        : widget(renderer, x, y, chip8::screen_width * scale_factor, chip8::screen_height * scale_factor, fg_color, bg_color),
-        m_emulator(emulator), m_scale_factor(scale_factor)
+    Chip8Screen(SDLSharedRenderer renderer, int x, int y, SDL_Color fg_color, SDL_Color bg_color, Chip8 const& emulator, int SCALE_FACTOR)
+        : Widget(renderer, x, y, Chip8::SCREEN_WIDTH * SCALE_FACTOR, Chip8::SCREEN_HEIGHT * SCALE_FACTOR, fg_color, bg_color),
+        m_emulator(emulator), m_scale_factor(SCALE_FACTOR)
     {}
-    ~chip8_screen() override;
+    ~Chip8Screen() override;
     void draw() override;
 private:
-    chip8 const& m_emulator;
+    Chip8 const& m_emulator;
     int m_scale_factor;
 };
diff --git a/chip-8-sdl/widget/label.cpp b/chip-8-sdl/widget/label.cpp
index 8c7b143..562cc70 100644
--- a/chip-8-sdl/widget/label.cpp
+++ b/chip-8-sdl/widget/label.cpp
@@ -1,10 +1,10 @@
 #include "label.h"
 #include "sdl_helper.h"
 
-label::~label()
+Label::~Label()
 {}
 
-void label::draw()
+void Label::draw()
 {
     if (!m_changed || !m_font.get())
         return;
diff --git a/chip-8-sdl/widget/label.h b/chip-8-sdl/widget/label.h
index 7fd60c8..e92c966 100644
--- a/chip-8-sdl/widget/label.h
+++ b/chip-8-sdl/widget/label.h
@@ -4,14 +4,14 @@
 
 #include "widget.h"
 
-class label : public widget
+class Label : public Widget
 {
 public:
-    label(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color, std::string content, TTFSharedFont font)
-        : widget(renderer, x, y, w, h, fg_color, bg_color),
+    Label(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color, const std::string content, TTFSharedFont font)
+        : Widget(renderer, x, y, w, h, fg_color, bg_color),
         m_content(content), m_font(font), m_changed(true)
     {}
-    ~label() override;
+    ~Label() override;
     void draw() override;
 private:
     std::string m_content;
@@ -20,4 +20,4 @@ class label : public widget
     bool m_changed;
 };
 
-using label_ptr = std::shared_ptr<label>;
+using label_ptr = std::unique_ptr<Label>;
diff --git a/chip-8-sdl/widget/layout.h b/chip-8-sdl/widget/layout.h
new file mode 100644
index 0000000..a0e60a9
--- /dev/null
+++ b/chip-8-sdl/widget/layout.h
@@ -0,0 +1,7 @@
+#pragma once
+
+enum class Layout {
+    NoLayout,
+    Horizontal,
+    Vertical,
+};
diff --git a/chip-8-sdl/widget/panel.cpp b/chip-8-sdl/widget/panel.cpp
index f38b9ec..310261f 100644
--- a/chip-8-sdl/widget/panel.cpp
+++ b/chip-8-sdl/widget/panel.cpp
@@ -3,10 +3,10 @@
 #include "panel.h"
 #include "sdl_helper.h"
 
-panel::~panel()
+Panel::~Panel()
 {}
 
-void panel::draw()
+void Panel::draw()
 {
     as_rendering_target();
 
@@ -22,7 +22,7 @@ void panel::draw()
     set_renderer_color(m_renderer, m_fg_color);
     SDL_RenderDrawLines(m_renderer.get(), edges.data(), edges.size());
 
-    for (widget_ptr widget : m_children)
+    for (widget_ptr const& widget : m_children)
     {
         widget->draw();
         as_rendering_target();
@@ -30,7 +30,42 @@ void panel::draw()
     }
 }
 
-void panel::add_child(widget_ptr child)
+void Panel::add_child(widget_ptr&& child)
 {
-    m_children.push_back(child);
+    m_children.push_back(std::move(child));
+    apply_layout();
+}
+
+void Panel::set_layout(Layout l)
+{
+    m_layout = l;
+    apply_layout();
+}
+
+void Panel::apply_layout()
+{
+    switch (m_layout) {
+        case Layout::Horizontal:
+        {
+            int next_x = 2;
+            for (widget_ptr& widget : m_children)
+            {
+                widget->x() = next_x;
+                next_x += widget->w();
+            }
+            break;
+        }
+        case Layout::Vertical:
+        {
+            int next_y = 0;
+            for (widget_ptr& widget : m_children)
+            {
+                widget->y() = next_y;
+                next_y += widget->h();
+            }
+            break;
+        }
+        case Layout::NoLayout:
+            break;
+    }
 }
diff --git a/chip-8-sdl/widget/panel.h b/chip-8-sdl/widget/panel.h
index 6ae07ee..2215b0d 100644
--- a/chip-8-sdl/widget/panel.h
+++ b/chip-8-sdl/widget/panel.h
@@ -3,19 +3,25 @@
 #include <vector>
 
 #include "widget.h"
+#include "layout.h"
 
-class panel : public widget
+class Panel : public Widget
 {
 public:
-    panel(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color)
-        : widget(renderer, x, y, w, h, fg_color, bg_color),
-        m_children()
+    Panel(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color, Layout layout = Layout::NoLayout)
+        : Widget(renderer, x, y, w, h, fg_color, bg_color),
+        m_children(),
+        m_layout(layout)
     {}
-    ~panel() override;
+    ~Panel() override;
     void draw() override;
-    void add_child(widget_ptr child);
+    void add_child(widget_ptr&& child);
+    void set_layout(Layout layout);
 private:
+    void apply_layout();
+
     std::vector<widget_ptr> m_children;
+    Layout m_layout = Layout::NoLayout;
 };
 
-using panel_ptr = std::shared_ptr<panel>;
+using panel_ptr = std::unique_ptr<Panel>;
diff --git a/chip-8-sdl/widget/widget.cpp b/chip-8-sdl/widget/widget.cpp
index 47fee8f..3903ca0 100644
--- a/chip-8-sdl/widget/widget.cpp
+++ b/chip-8-sdl/widget/widget.cpp
@@ -1,7 +1,7 @@
 #include "sdl_helper.h"
 #include "widget.h"
 
-widget::widget(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color)
+Widget::Widget(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color)
     : m_rect { x, y, w, h }, m_fg_color(fg_color), m_bg_color(bg_color)
 {
     m_renderer = renderer;
@@ -9,10 +9,10 @@ widget::widget(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color
     sdl_nullcheck(m_texture.get(), "Failed to create the texture: %s\n");
 }
 
-widget::~widget()
+Widget::~Widget()
 {}
 
-void widget::as_rendering_target() const
+void Widget::as_rendering_target() const
 {
    sdl_checksuccess(SDL_SetRenderTarget(m_renderer.get(), m_texture.get()), "Failed to set the widget as rendering target: %s\n");
 }
diff --git a/chip-8-sdl/widget/widget.h b/chip-8-sdl/widget/widget.h
index 1445a49..bb4126f 100644
--- a/chip-8-sdl/widget/widget.h
+++ b/chip-8-sdl/widget/widget.h
@@ -3,20 +3,24 @@
 
 #include "sdl_helper.h"
 
-class widget
+class Widget
 {
 public:
-    widget(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color);
-    virtual ~widget();
+    Widget(SDLSharedRenderer renderer, int x, int y, int w, int h, SDL_Color fg_color, SDL_Color bg_color);
+    virtual ~Widget();
     void as_rendering_target() const;
     virtual void draw() = 0;
 
     SDL_Rect* rect() { return &m_rect; }
     SDL_Texture* texture() const { return m_texture.get(); }
-    int x() { return m_rect.x; }
-    int y() { return m_rect.y; }
-    int w() { return m_rect.w; }
-    int h() { return m_rect.h; }
+    int x() const { return m_rect.x; }
+    int& x() { return m_rect.x; }
+    int y() const { return m_rect.y; }
+    int& y() { return m_rect.y; }
+    int w() const { return m_rect.w; }
+    int& w() { return m_rect.w; }
+    int h() const { return m_rect.h; }
+    int& h() { return m_rect.h; }
 protected:
     SDL_Rect m_rect;
     SDLSharedRenderer m_renderer;
@@ -25,4 +29,4 @@ class widget
     SDL_Color m_bg_color;
 };
 
-using widget_ptr = std::shared_ptr<widget>;
+using widget_ptr = std::unique_ptr<Widget>;
diff --git a/cmake/copy_dll.cmake b/cmake/copy_dll.cmake
deleted file mode 100644
index b29f839..0000000
--- a/cmake/copy_dll.cmake
+++ /dev/null
@@ -1,11 +0,0 @@
-function(copy_dll exe dll_list)
-    foreach (dll ${dll_list})
-        if (WIN32 AND ${BUILD_SHARED_LIBS})
-            add_custom_command(TARGET ${exe} POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                $<TARGET_FILE:${dll}>
-                $<TARGET_FILE_DIR:${exe}>
-            )
-        endif()
-    endforeach()
-endfunction()
diff --git a/cmake/dependencies.cmake b/cmake/dependencies.cmake
deleted file mode 100644
index 7c98761..0000000
--- a/cmake/dependencies.cmake
+++ /dev/null
@@ -1,47 +0,0 @@
-include(FetchContent)
-set(FETCHCONTENT_QUIET FALSE)
-set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
-
-FetchContent_Declare(SDL2
-    GIT_REPOSITORY "https://github.com/libsdl-org/SDL"
-    GIT_TAG 2.0.22
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(SDL2)
-
-set(SDL2TTF_VENDORED TRUE)
-FetchContent_Declare(SDL2_ttf
-    GIT_REPOSITORY "https://github.com/libsdl-org/SDL_ttf.git"
-    GIT_TAG release-2.20.1
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(SDL2_ttf)
-
-FetchContent_Declare(fmt
-    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
-    GIT_TAG 8.1.1
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(fmt)
-
-FetchContent_Declare(doctest
-    GIT_REPOSITORY https://github.com/doctest/doctest.git
-    GIT_TAG v2.4.8
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(doctest)
-
-
-FetchContent_Declare(yaml-cpp
-    GIT_REPOSITORY "https://github.com/jbeder/yaml-cpp"
-    GIT_TAG yaml-cpp-0.7.0
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(yaml-cpp)
-
-FetchContent_Declare(cxxopts
-    GIT_REPOSITORY "https://github.com/jarro2783/cxxopts.git"
-    GIT_TAG v3.0.0
-    GIT_PROGRESS TRUE
-)
-FetchContent_MakeAvailable(cxxopts)
diff --git a/conanfile.py b/conanfile.py
new file mode 100644
index 0000000..837830f
--- /dev/null
+++ b/conanfile.py
@@ -0,0 +1,59 @@
+from conan import ConanFile
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
+
+class Chip8Recipe(ConanFile):
+    name = "chip-8"
+    version = "0.1"
+
+    author = "fpotier"
+    url = "https://github.com/fpotier/chip-8"
+    description = "Chip 8 emulator"
+    topics = ("chip-8", "emulator")
+
+    settings = "os", "compiler", "build_type", "arch"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False]
+    }
+    default_options = {
+        "shared": True,
+        "fPIC": True
+    }
+
+    exports_sources = "CMakeLists.txt", "lib/*", "chip-8-sdl/*", "chip-8-disassembler/*", "cmake/*"
+
+    def build_requirements(self):
+        self.tool_requires("cmake/[>=3.20.0]")
+
+    def requirements(self):
+        self.requires("sdl/2.28.3")
+        self.requires("sdl_ttf/2.20.2")
+        self.requires("fmt/10.2.1")
+        self.requires("yaml-cpp/0.8.0")
+        self.requires("cxxopts/3.0.0")
+
+        self.test_requires("doctest/2.4.11")
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def layout(self):
+        cmake_layout(self)
+
+    def generate(self):
+        deps = CMakeDeps(self)
+        deps.generate()
+        tc = CMakeToolchain(self)
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+        if not self.conf.get("tools.build:skip_test", default=False):
+            cmake.ctest()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
diff --git a/lib/include/chip8.h b/lib/include/chip8.h
index 2d43c2e..b131a3e 100644
--- a/lib/include/chip8.h
+++ b/lib/include/chip8.h
@@ -3,26 +3,27 @@
 #include <array>
 #include <cstdint>
 #include <optional>
+#include <vector>
 
 #include "chip8.h"
 #include "cpu_quirks.h"
 #include "opcode.h"
 
-class chip8
+class Chip8
 {
     friend class chip8_test;
 
 public:
-    static constexpr int ram_size = 4096;
-    static constexpr int screen_width = 64;
-    static constexpr int screen_height = 32;
-    static constexpr int vram_size = screen_width * screen_height;
-    static constexpr int register_number = 16;
-    static constexpr int stack_size = 16;
-    static constexpr int keypad_size = 16;
-    static constexpr int no_key_pressed = -1;
-    static constexpr int entry_point = 512;
-    static constexpr std::array<uint8_t, 80> font
+    static constexpr int RAM_SIZE = 4096;
+    static constexpr int SCREEN_WIDTH = 64;
+    static constexpr int SCREEN_HEIGHT = 32;
+    static constexpr int VRAM_SIZE = SCREEN_WIDTH * SCREEN_HEIGHT;
+    static constexpr int NB_REGISTER = 16;
+    static constexpr int STACK_SIZE = 16;
+    static constexpr int KEYPAD_SIZE = 16;
+    static constexpr int NO_KEY_PRESSED = -1;
+    static constexpr int ENTRYPOINT = 0x200;
+    static constexpr std::array<uint8_t, 80> DEFAULT_FONT
     {
         0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
         0x20, 0x60, 0x20, 0x20, 0x70, // 1
@@ -43,7 +44,7 @@ class chip8
     };
 
     bool vram_dirty;
-    chip8(const uint8_t* program, size_t size);
+    Chip8(std::vector<uint8_t> const& rom);
 
     [[noreturn]] void panic(std::string msg);
     void dump_regs(std::ostream& stream);
@@ -51,34 +52,34 @@ class chip8
     void print_keypad(std::ostream& stream);
     void tick(uint8_t instructions_per_frame);
     uint16_t fetch_opcode();
-    void execute(opcode opcode);
+    void execute(Opcode opcode);
     uint8_t generate_random() { return std::rand() % UINT8_MAX; }
     void key_pressed(std::size_t key_code);
     void key_released(std::size_t key_code);
 
-    std::array<uint8_t, register_number> const& get_registers() const { return V; }
-    std::array<uint8_t, ram_size> const& get_ram() const { return ram; }
-    std::array<uint8_t, vram_size> const& get_vram() const { return vram; }
-    std::array<uint16_t, stack_size> const& get_stack() const { return stack; }
+    std::array<uint8_t, NB_REGISTER> const& get_registers() const { return V; }
+    std::array<uint8_t, RAM_SIZE> const& get_ram() const { return ram; }
+    std::array<uint8_t, VRAM_SIZE> const& get_vram() const { return vram; }
+    std::array<uint16_t, STACK_SIZE> const& get_stack() const { return stack; }
     uint16_t get_I() const { return I; }
     uint16_t get_ip() const { return ip; }
     uint8_t get_sp() const { return sp; }
-    std::array<bool, keypad_size> get_keypad() const { return keypad; }
+    std::array<bool, KEYPAD_SIZE> get_keypad() const { return keypad; }
     uint8_t get_sound_timer() const { return sound_timer; }
     uint8_t get_delay_timer() const { return delay_timer; }
 
 private:
-    std::array<uint8_t, register_number> V;
-    std::array<uint8_t, ram_size> ram;
-    std::array<uint8_t, vram_size> vram;
-    std::array<uint16_t, stack_size> stack;
-    std::array<bool, keypad_size> keypad;
+    std::array<uint8_t, NB_REGISTER> V;
+    std::array<uint8_t, RAM_SIZE> ram;
+    std::array<uint8_t, VRAM_SIZE> vram;
+    std::array<uint16_t, STACK_SIZE> stack;
+    std::array<bool, KEYPAD_SIZE> keypad;
     uint16_t I;  // Index register
     uint16_t ip; // Instruction pointer
     uint8_t sp; // Stack pointer
     uint8_t delay_timer;
     uint8_t sound_timer;
-    cpu_quirks quirks;
+    CpuQuirks quirks;
     bool wait_key;
     std::optional<uint8_t> wait_key_val;
     bool wait_draw;
diff --git a/lib/include/cpu_quirks.h b/lib/include/cpu_quirks.h
index d8d5fbc..58983dc 100644
--- a/lib/include/cpu_quirks.h
+++ b/lib/include/cpu_quirks.h
@@ -2,16 +2,16 @@
 
 // https://chip-8.github.io/extensions/
 
-enum class quirks_profile
+enum class QuirksProfile
 {
     CHIP_8,
     SCHIP,
     XO_CHIP,
 };
 
-struct cpu_quirks
+struct CpuQuirks
 {
-    /* The AND, OR and XOR opcodes (8XY1, 8XY2 and 8XY3) reset the flags 
+    /* The AND, OR and XOR opcodes (8XY1, 8XY2 and 8XY3) reset the flags
      * register to zero */
     bool vf_reset;
     // https://tobiasvl.github.io/blog/write-a-chip-8-emulator/#fx55-and-fx65-store-and-load-memory
@@ -24,12 +24,12 @@ struct cpu_quirks
     // https://tobiasvl.github.io/blog/write-a-chip-8-emulator/#bnnn-jump-with-offset
     bool jumping;
 
-    cpu_quirks(quirks_profile profile)
+    CpuQuirks(QuirksProfile profile)
     {
         switch (profile)
         {
             // Consider that original implementation has no quirk
-            case quirks_profile::CHIP_8:
+            case QuirksProfile::CHIP_8:
                 vf_reset = false;
                 mem = false;
                 display_wait = false;
@@ -37,7 +37,7 @@ struct cpu_quirks
                 shifting = false;
                 jumping = false;
                 break;
-            case quirks_profile::SCHIP:
+            case QuirksProfile::SCHIP:
                 vf_reset = true;
                 mem = true;
                 display_wait = true;
@@ -45,7 +45,7 @@ struct cpu_quirks
                 shifting = true;
                 jumping = true;
                 break;
-            case quirks_profile::XO_CHIP:
+            case QuirksProfile::XO_CHIP:
                 vf_reset = true;
                 mem = false;
                 display_wait = true;
diff --git a/lib/include/opcode.h b/lib/include/opcode.h
index e209a4c..cd6ac1e 100644
--- a/lib/include/opcode.h
+++ b/lib/include/opcode.h
@@ -5,7 +5,7 @@
 
 enum class opcode_id: uint8_t;
 
-struct opcode
+struct Opcode
 {
     opcode_id id;
     uint16_t  raw_opcode;
@@ -16,8 +16,8 @@ struct opcode
     uint8_t  NN;
     uint16_t NNN;
 
-    static opcode decode(uint16_t raw_opcode);
-    static opcode decode(uint8_t raw_opcode_h, uint8_t raw_opcode_l);
+    static Opcode decode(uint16_t raw_opcode);
+    static Opcode decode(uint8_t raw_opcode_h, uint8_t raw_opcode_l);
     std::string string_repr();
 };
 
diff --git a/lib/src/chip8.cpp b/lib/src/chip8.cpp
index b5bd29e..e828f3c 100644
--- a/lib/src/chip8.cpp
+++ b/lib/src/chip8.cpp
@@ -2,11 +2,12 @@
 #include <ctime>
 #include <fmt/core.h>
 #include <iostream>
+#include <vector>
 
 #include "chip8.h"
 
-chip8::chip8(const uint8_t* program, size_t size)
-    : quirks(quirks_profile::CHIP_8)
+Chip8::Chip8(std::vector<uint8_t> const& rom)
+    : quirks(QuirksProfile::CHIP_8)
 {
     vram_dirty = true;
     V.fill(0);
@@ -15,26 +16,26 @@ chip8::chip8(const uint8_t* program, size_t size)
     stack.fill(0);
     keypad.fill(false);
     I = 0;
-    ip = entry_point;
+    ip = ENTRYPOINT;
     sp = 0;
     delay_timer = 0;
     sound_timer = 0;
     wait_key = false;
     wait_key_val = std::nullopt;
     wait_draw = false;
-    
+
     std::srand(std::time(nullptr));
 
     // Load user program
-    assert(size < ram_size);
-    std::copy(program, program + size, ram.begin() + entry_point);
+    assert(rom.size() < RAM_SIZE);
+    std::copy(rom.begin(), rom.end(), ram.begin() + ENTRYPOINT);
 
     // Load fontset
-    std::copy(font.begin(), font.end(), ram.begin());
+    std::copy(DEFAULT_FONT.begin(), DEFAULT_FONT.end(), ram.begin());
 
 }
 
-[[noreturn]] void chip8::panic(std::string msg)
+[[noreturn]] void Chip8::panic(std::string msg)
 {
     // FIXME: there should be a panic handler function
     std::cerr << fmt::format("CPU Panic:\n\t{}\n", msg);
@@ -47,11 +48,11 @@ chip8::chip8(const uint8_t* program, size_t size)
     std::abort();
 }
 
-void chip8::dump_regs(std::ostream& stream)
+void Chip8::dump_regs(std::ostream& stream)
 {
     stream << fmt::format("ip = {:#06x}\n", ip);
     stream << fmt::format("I = {:#06x}\n", I);
-    for (std::size_t i = 0; i < register_number; i += 4)
+    for (std::size_t i = 0; i < NB_REGISTER; i += 4)
     {
         stream << fmt::format("V{:02} = {:03}  V{:02} = {:03}  V{:02} = {:03}  V{:02} = {:03}\n",
             i, V[i],
@@ -61,15 +62,15 @@ void chip8::dump_regs(std::ostream& stream)
     }
 }
 
-void chip8::print_stack_trace(std::ostream& stream)
+void Chip8::print_stack_trace(std::ostream& stream)
 {
     for (int i = sp; i >= 0; i--)
         stream << fmt::format("{:02} -> {:#06x}\n", i, stack[i]);
 }
 
-void chip8::print_keypad(std::ostream& stream)
+void Chip8::print_keypad(std::ostream& stream)
 {
-    for (std::size_t i = 0; i < keypad_size; i += 4)
+    for (std::size_t i = 0; i < KEYPAD_SIZE; i += 4)
     {
         stream << fmt::format("{:#04x} {} {:#04x} {} {:#04x} {} {:#04x} {}\n",
             i, keypad[i] ? "down" : "  up",
@@ -79,14 +80,14 @@ void chip8::print_keypad(std::ostream& stream)
     }
 }
 
-void chip8::tick(uint8_t instructions_per_frame)
+void Chip8::tick(uint8_t instructions_per_frame)
 {
     wait_draw = false;
 
     for (std::size_t i = 0; i < instructions_per_frame; i++)
     {
         uint16_t raw_opcode = fetch_opcode();
-        opcode decoded_opcode = opcode::decode(raw_opcode);
+        Opcode decoded_opcode = Opcode::decode(raw_opcode);
         execute(decoded_opcode);
     }
 
@@ -96,25 +97,25 @@ void chip8::tick(uint8_t instructions_per_frame)
         sound_timer--;
 }
 
-uint16_t chip8::fetch_opcode()
+uint16_t Chip8::fetch_opcode()
 {
     uint16_t raw_opcode = ram[ip] << 8 | ram[ip + 1];
     ip += 2; // Instructions are 16 bits wide
-    
+
     return raw_opcode;
 }
 
-void chip8::execute(opcode opcode)
+void Chip8::execute(Opcode opcode)
 {
     #ifndef NDEBUG
-        fmt::print("opcode:{:#06x} ", opcode.raw_opcode);
-        for (std::size_t i = 0; i < register_number; i++)
-            fmt::print("V{}={} ", i, V[i]);
-        fmt::print("ip={:#06x} ", ip - 2);
-        fmt::print("I={:#06x} ", I);
-        fmt::print("sp={} ", sp);
-        fmt::print("dt={} ", delay_timer);
-        fmt::print("st={} \n", sound_timer);
+        // fmt::print("opcode:{:#06x} ", opcode.raw_opcode);
+        // for (std::size_t i = 0; i < NB_REGISTER; i++)
+        //     fmt::print("V{}={} ", i, V[i]);
+        // fmt::print("ip={:#06x} ", ip - 2);
+        // fmt::print("I={:#06x} ", I);
+        // fmt::print("sp={} ", sp);
+        // fmt::print("dt={} ", delay_timer);
+        // fmt::print("st={} \n", sound_timer);
     #endif
 
     switch (opcode.id)
@@ -159,33 +160,33 @@ void chip8::execute(opcode opcode)
     }
 }
 
-void chip8::key_pressed(std::size_t key_code)
+void Chip8::key_pressed(std::size_t key_code)
 {
     keypad[key_code] = true;
 }
 
-void chip8::key_released(std::size_t key_code)
+void Chip8::key_released(std::size_t key_code)
 {
     if (wait_key)
         wait_key_val = key_code;
     keypad[key_code] = false;
 }
 
-void chip8::check_register(uint8_t index, std::string instruction_name)
+void Chip8::check_register(uint8_t index, std::string instruction_name)
 {
-    if (index >= register_number)
+    if (index >= NB_REGISTER)
         panic(fmt::format("'{}' Invalid register index {:#04x}", instruction_name, index));
 }
 
 /* 00E0 -> Clears the screen */
-void chip8::clear()
+void Chip8::clear()
 {
     vram.fill(0);
     vram_dirty = true;
 }
 
 /* 00EE -> Returns from a subroutine */
-void chip8::ret()
+void Chip8::ret()
 {
     if (sp == 0)
         panic("Use of 'ret' instruction but callstack is empty");
@@ -194,20 +195,20 @@ void chip8::ret()
 }
 
 /* 1NNN -> Jump to address NNN */
-void chip8::jmp(uint16_t NNN)
+void Chip8::jmp(uint16_t NNN)
 {
-    if (NNN > ram_size)
+    if (NNN > RAM_SIZE)
         panic(fmt::format("Can not 'jmp' to invalid address {:#06x}", NNN));
 
     ip = NNN;
 }
 
 /* 2NNN -> Call subroutine at NNN */
-void chip8::call(uint16_t NNN)
+void Chip8::call(uint16_t NNN)
 {
-    if (NNN > ram_size)
+    if (NNN > RAM_SIZE)
         panic(fmt::format("Cannot 'call' invalid address {:#06x}", NNN));
-    if (sp + 1 >= stack_size)
+    if (sp + 1 >= STACK_SIZE)
         panic(fmt::format("Callstack overflow in 'call {:#06x}'", NNN));
 
     stack[sp++] = ip;
@@ -215,7 +216,7 @@ void chip8::call(uint16_t NNN)
 }
 
 /* 3XNN -> Skip next instruction if VX equals NN */
-void chip8::skieq(uint8_t X, uint8_t NN)
+void Chip8::skieq(uint8_t X, uint8_t NN)
 {
     check_register(X, "skieq");
 
@@ -224,7 +225,7 @@ void chip8::skieq(uint8_t X, uint8_t NN)
 }
 
 /* 4XNN -> Skip next instruction if VX does not equal NN */
-void chip8::skine(uint8_t X, uint8_t NN)
+void Chip8::skine(uint8_t X, uint8_t NN)
 {
     check_register(X, "skine");
 
@@ -233,7 +234,7 @@ void chip8::skine(uint8_t X, uint8_t NN)
 }
 
 /* 5XY0 -> Skip next instruction if VX equals VY */
-void chip8::skreq(uint8_t X, uint8_t Y)
+void Chip8::skreq(uint8_t X, uint8_t Y)
 {
     check_register(X, "skreq");
     check_register(Y, "skreq");
@@ -243,7 +244,7 @@ void chip8::skreq(uint8_t X, uint8_t Y)
 }
 
 /* 6XNN -> Sets VX to NN */
-void chip8::movi(uint8_t X, uint8_t NN)
+void Chip8::movi(uint8_t X, uint8_t NN)
 {
     check_register(X, "movi");
 
@@ -251,7 +252,7 @@ void chip8::movi(uint8_t X, uint8_t NN)
 }
 
 /* 7XNN -> Adds NN to VX (carry flag is not changed) */
-void chip8::addi(uint8_t X, uint8_t NN)
+void Chip8::addi(uint8_t X, uint8_t NN)
 {
     check_register(X, "addi");
 
@@ -259,7 +260,7 @@ void chip8::addi(uint8_t X, uint8_t NN)
 }
 
 /* 8XY0 -> Sets VX to the value of VY */
-void chip8::mov(uint8_t X, uint8_t Y)
+void Chip8::mov(uint8_t X, uint8_t Y)
 {
     check_register(X, "mov");
     check_register(Y, "mov");
@@ -268,7 +269,7 @@ void chip8::mov(uint8_t X, uint8_t Y)
 }
 
 /* 8XY1 -> Sets VX to VX | VY */
-void chip8::_or(uint8_t X, uint8_t Y)
+void Chip8::_or(uint8_t X, uint8_t Y)
 {
     check_register(X, "or");
     check_register(Y, "or");
@@ -279,7 +280,7 @@ void chip8::_or(uint8_t X, uint8_t Y)
 }
 
 /* 8XY2 -> Sets VX to VX & VY */
-void chip8::_and(uint8_t X, uint8_t Y)
+void Chip8::_and(uint8_t X, uint8_t Y)
 {
     check_register(X, "and");
     check_register(Y, "and");
@@ -290,7 +291,7 @@ void chip8::_and(uint8_t X, uint8_t Y)
 }
 
 /* 8XY3 -> Sets VX to VX ^ VY */
-void chip8::_xor(uint8_t X, uint8_t Y)
+void Chip8::_xor(uint8_t X, uint8_t Y)
 {
     check_register(X, "xor");
     check_register(Y, "xor");
@@ -302,7 +303,7 @@ void chip8::_xor(uint8_t X, uint8_t Y)
 
 /* 8XY4 -> Adds VY to VX. VF is set to 1 when there's a carry,
  * and to 0 when there is not */
-void chip8::add(uint8_t X, uint8_t Y)
+void Chip8::add(uint8_t X, uint8_t Y)
 {
     check_register(X, "add");
     check_register(Y, "add");
@@ -314,7 +315,7 @@ void chip8::add(uint8_t X, uint8_t Y)
 
 /* 8XY5 -> VY is subtracted from VX. VF is set to 0 when there's
  * a borrow, and 1 when there is not */
-void chip8::sub(uint8_t X, uint8_t Y)
+void Chip8::sub(uint8_t X, uint8_t Y)
 {
     check_register(X, "sub");
     check_register(Y, "sub");
@@ -326,7 +327,7 @@ void chip8::sub(uint8_t X, uint8_t Y)
 
 /* 8XY6 -> Stores the least significant bit of VX in VF and then
  * shifts VX to the right by 1 */
-void chip8::srl(uint8_t X, uint8_t Y)
+void Chip8::srl(uint8_t X, uint8_t Y)
 {
     check_register(X, "srl");
     check_register(Y, "srl");
@@ -340,7 +341,7 @@ void chip8::srl(uint8_t X, uint8_t Y)
 
 /* 8XY7 -> Sets VX to VY minus VX. VF is set to 0 when there's a
  * borrow, and 1 when there is not */
-void chip8::lsub(uint8_t X, uint8_t Y)
+void Chip8::lsub(uint8_t X, uint8_t Y)
 {
     check_register(X, "lsub");
     check_register(Y, "lsub");
@@ -352,7 +353,7 @@ void chip8::lsub(uint8_t X, uint8_t Y)
 
 /* 8XYE -> Stores the most significant bit of VX in VF and then
  * shifts VX to the left by 1 */
-void chip8::sll(uint8_t X, uint8_t Y)
+void Chip8::sll(uint8_t X, uint8_t Y)
 {
     check_register(X, "sll");
     check_register(Y, "sll");
@@ -364,7 +365,7 @@ void chip8::sll(uint8_t X, uint8_t Y)
     V[0xF] = flag;
 }
 /* 9XY0 -> Skips the next instruction if VX does not equal VY */
-void chip8::skrne(uint8_t X, uint8_t Y)
+void Chip8::skrne(uint8_t X, uint8_t Y)
 {
     check_register(X, "skrne");
     check_register(Y, "skrne");
@@ -374,13 +375,13 @@ void chip8::skrne(uint8_t X, uint8_t Y)
 }
 
 /* ANNN -> Sets I to the address NNN */
-void chip8::movri(uint16_t NNN)
+void Chip8::movri(uint16_t NNN)
 {
     I = NNN;
 }
 
 /* BNNN -> Jumps to the address NNN + VO */
-void chip8::jmpv0(uint16_t NNN, uint8_t X)
+void Chip8::jmpv0(uint16_t NNN, uint8_t X)
 {
     uint8_t reg = 0;
     if (quirks.jumping)
@@ -393,7 +394,7 @@ void chip8::jmpv0(uint16_t NNN, uint8_t X)
 
 /* CXNN -> Sets VX to the result of a bitwise and operation  on a random
  * number and NN */
-void chip8::rand(uint8_t X, uint8_t NN)
+void Chip8::rand(uint8_t X, uint8_t NN)
 {
     check_register(X, "rand");
 
@@ -406,7 +407,7 @@ void chip8::rand(uint8_t X, uint8_t NN)
  * the execution of this instruction. As described above, VF is set to 1 if
  * any screen pixels are flipped from set to unset when the sprite is drawn,
  * and to 0 if that does not happen */
-void chip8::draw(uint8_t X, uint8_t Y, uint8_t N)
+void Chip8::draw(uint8_t X, uint8_t Y, uint8_t N)
 {
     check_register(X, "draw");
     check_register(Y, "draw");
@@ -419,21 +420,21 @@ void chip8::draw(uint8_t X, uint8_t Y, uint8_t N)
 
     if (!quirks.clipping)
     {
-        V[X] %= screen_width;
-        V[Y] %= screen_height;
+        V[X] %= SCREEN_WIDTH;
+        V[Y] %= SCREEN_HEIGHT;
     }
 
     V[0xF] = 0;
     for (std::size_t d_y = 0; d_y < N; d_y++)
     {
         // FIXME: there is probably a better way implement this quirk
-        if (!quirks.clipping && V[Y] + d_y >= screen_height)
+        if (!quirks.clipping && V[Y] + d_y >= SCREEN_HEIGHT)
             break;
-        std::size_t line_start = (V[Y] + d_y) * chip8::screen_width + V[X];
+        std::size_t line_start = (V[Y] + d_y) * Chip8::SCREEN_WIDTH + V[X];
         for (std::size_t d_x = 0; d_x < 8; d_x++)
         {
             // FIXME: there is probably a better way implement this quirk
-            if (!quirks.clipping && V[X] + d_x >= screen_width)
+            if (!quirks.clipping && V[X] + d_x >= SCREEN_WIDTH)
                 break;
             assert(line_start + d_x < vram.size());
 
@@ -448,7 +449,7 @@ void chip8::draw(uint8_t X, uint8_t Y, uint8_t N)
 
 /* EX9E -> Skips the next instruction if the key stored in VX is
  * pressed */
-void chip8::skkp(uint8_t X)
+void Chip8::skkp(uint8_t X)
 {
     check_register(X, "skkp");
 
@@ -458,7 +459,7 @@ void chip8::skkp(uint8_t X)
 
 /* EXA1 - >Skips the next instruction if the key stored in VX is
  * not pressed */
-void chip8::skknp(uint8_t X)
+void Chip8::skknp(uint8_t X)
 {
     check_register(X, "skknp");
 
@@ -467,7 +468,7 @@ void chip8::skknp(uint8_t X)
 }
 
 /* FX07 -> Sets VX to the value of the delay timer */
-void chip8::loadd(uint8_t X)
+void Chip8::loadd(uint8_t X)
 {
     check_register(X, "loadd");
 
@@ -476,7 +477,7 @@ void chip8::loadd(uint8_t X)
 
 /* FX0A -> A key press is awaited, and then stored in VX.
  * (Blocking Operation. All instruction halted until next key event) */
-void chip8::wkey(uint8_t X)
+void Chip8::wkey(uint8_t X)
 {
     check_register(X, "wkey");
 
@@ -494,7 +495,7 @@ void chip8::wkey(uint8_t X)
 }
 
 /* FX15 -> Sets the delay timer to VX */
-void chip8::movd(uint8_t X)
+void Chip8::movd(uint8_t X)
 {
     check_register(X, "movd");
 
@@ -502,7 +503,7 @@ void chip8::movd(uint8_t X)
 }
 
 /* FX18 -> Sets the sound timer to VX */
-void chip8::movs(uint8_t X)
+void Chip8::movs(uint8_t X)
 {
     check_register(X, "movs");
 
@@ -510,7 +511,7 @@ void chip8::movs(uint8_t X)
 }
 
 /* FX1E -> Adds VX to I. VF is not affected */
-void chip8::addri(uint8_t X)
+void Chip8::addri(uint8_t X)
 {
     check_register(X, "addri");
 
@@ -519,7 +520,7 @@ void chip8::addri(uint8_t X)
 
 /* FX29 -> Sets I to the location of the sprite for the character in VX.
  * Characters 0-F (in hexadecimal) are represented by a 4x5 font */
-void chip8::spri(uint8_t X)
+void Chip8::spri(uint8_t X)
 {
     check_register(X, "spri");
 
@@ -532,7 +533,7 @@ void chip8::spri(uint8_t X)
  * (In other words, take the decimal representation of VX, place the
  * hundreds digit in memory at location in I, the tens digit at location
  * I+1, and the ones digit at location I+2.) */
-void chip8::bcd(uint8_t X)
+void Chip8::bcd(uint8_t X)
 {
     check_register(X, "bcd");
 
@@ -544,7 +545,7 @@ void chip8::bcd(uint8_t X)
 /* FX55 -> Stores from V0 to VX (including VX) in memory, starting at
  * address I. The offset from I is increased by 1 for each value written,
  * but I itself is left unmodified */
-void chip8::store(uint8_t X)
+void Chip8::store(uint8_t X)
 {
     check_register(X, "store");
 
@@ -557,7 +558,7 @@ void chip8::store(uint8_t X)
 /* FX65 -> Fills from V0 to VX (including VX) with values from memory,
  * starting at address I. The offset from I is increased by 1 for each
  * value written, but I itself is left unmodified */
-void chip8::load(uint8_t X)
+void Chip8::load(uint8_t X)
 {
     check_register(X, "load");
 
diff --git a/lib/src/opcode.cpp b/lib/src/opcode.cpp
index f3bce27..d81d6a3 100644
--- a/lib/src/opcode.cpp
+++ b/lib/src/opcode.cpp
@@ -4,7 +4,7 @@
 
 #include "opcode.h"
 
-std::string opcode::string_repr()
+std::string Opcode::string_repr()
 {
     std::string instruction = opcode_str[static_cast<uint8_t>(id)];
     switch (id)
@@ -56,9 +56,9 @@ std::string opcode::string_repr()
     return "";
 }
 
-opcode opcode::decode(uint16_t raw_opcode)
+Opcode Opcode::decode(uint16_t raw_opcode)
 {
-    opcode op_info;
+    Opcode op_info;
     op_info.raw_opcode = raw_opcode;
     op_info.X = (raw_opcode >> 8) & 0x0F;
     op_info.Y = (raw_opcode >> 4) & 0x0F;
@@ -132,7 +132,7 @@ opcode opcode::decode(uint16_t raw_opcode)
     return op_info;
 }
 
-opcode opcode::decode(uint8_t raw_opcode_h, uint8_t raw_opcode_l)
+Opcode Opcode::decode(uint8_t raw_opcode_h, uint8_t raw_opcode_l)
 {
-    return opcode::decode(raw_opcode_h << 8 | raw_opcode_l);
+    return Opcode::decode(raw_opcode_h << 8 | raw_opcode_l);
 }
diff --git a/lib/test/CMakeLists.txt b/lib/test/CMakeLists.txt
index 56aa5b5..6d73abb 100644
--- a/lib/test/CMakeLists.txt
+++ b/lib/test/CMakeLists.txt
@@ -6,9 +6,8 @@ function(chip_8_test test_name)
         chip8_test.cpp
     )
     target_include_directories(${test_name} PRIVATE ${CHIP8_INCLUDE_DIRS})
-    target_link_libraries(${test_name} PRIVATE chip-8 doctest)
+    target_link_libraries(${test_name} PRIVATE chip-8 doctest::doctest)
     enable_warnings(${test_name})
-    copy_dll(${test_name} "chip-8;fmt")
     add_test(NAME ${test_name} COMMAND ${test_name})
 endfunction()
 
diff --git a/lib/test/addi.cpp b/lib/test/addi.cpp
index 5e15a8b..ed36715 100644
--- a/lib/test/addi.cpp
+++ b/lib/test/addi.cpp
@@ -9,7 +9,7 @@ TEST_CASE("addi 0x7XNN")
 {
     SUBCASE("Decode")
     {
-        opcode info = opcode::decode(0x71, 0x34);
+        Opcode info = Opcode::decode(0x71, 0x34);
         CHECK(info.id == opcode_id::ADDI);
         CHECK(info.X == 0x1);
         CHECK(info.NN == 0x34);
@@ -17,7 +17,7 @@ TEST_CASE("addi 0x7XNN")
 
     SUBCASE("Simple execution")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(std::vector<uint8_t>());
         CHECK(cpu.get_registers()[0x3] == 0);
         chip8_test::addi(cpu, 0x3, 0xAB);
         CHECK(cpu.get_registers()[0x3] == 0xAB);
@@ -25,7 +25,7 @@ TEST_CASE("addi 0x7XNN")
 
     SUBCASE("Overflow (VF must not change)")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(std::vector<uint8_t>());
         CHECK(cpu.get_registers()[0xD] == 0);
         chip8_test::movi(cpu, 0xD, 0xFF);
         CHECK(cpu.get_registers()[0xD] == 0xFF);
diff --git a/lib/test/chip8_test.cpp b/lib/test/chip8_test.cpp
index 7112f75..e7a82f6 100644
--- a/lib/test/chip8_test.cpp
+++ b/lib/test/chip8_test.cpp
@@ -1,176 +1,176 @@
 #include "chip8_test.h"
 
-void chip8_test::write_vram(chip8& cpu, size_t x, size_t y, bool value)
+void chip8_test::write_vram(Chip8& cpu, size_t x, size_t y, bool value)
 {
-    cpu.vram[chip8::screen_width * x + y] = value;
+    cpu.vram[Chip8::SCREEN_WIDTH * x + y] = value;
 }
 
-void chip8_test::clear(chip8& cpu)
+void chip8_test::clear(Chip8& cpu)
 {
     cpu.clear();
 }
 
-void chip8_test::ret(chip8& cpu)
+void chip8_test::ret(Chip8& cpu)
 {
     cpu.ret();
 }
 
-void chip8_test::jmp(chip8& cpu, uint16_t NNN)
+void chip8_test::jmp(Chip8& cpu, uint16_t NNN)
 {
     cpu.jmp(NNN);
 }
 
-void chip8_test::call(chip8& cpu, uint16_t NNN)
+void chip8_test::call(Chip8& cpu, uint16_t NNN)
 {
     cpu.call(NNN);
 }
 
-void chip8_test::skieq(chip8& cpu, uint8_t X, uint8_t NN)
+void chip8_test::skieq(Chip8& cpu, uint8_t X, uint8_t NN)
 {
     cpu.skieq(X, NN);
 }
 
-void chip8_test::skine(chip8& cpu, uint8_t X, uint8_t NN)
+void chip8_test::skine(Chip8& cpu, uint8_t X, uint8_t NN)
 {
     cpu.skine(X, NN);
 }
 
-void chip8_test::skreq(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::skreq(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.skreq(X, Y);
 }
 
-void chip8_test::movi(chip8& cpu, uint8_t X, uint8_t NN)
+void chip8_test::movi(Chip8& cpu, uint8_t X, uint8_t NN)
 {
     cpu.movi(X, NN);
 }
 
-void chip8_test::addi(chip8& cpu, uint8_t X, uint8_t NN)
+void chip8_test::addi(Chip8& cpu, uint8_t X, uint8_t NN)
 {
     cpu.addi(X, NN);
 }
 
-void chip8_test::mov(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::mov(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.mov(X, Y);
 }
 
-void chip8_test::_or(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::_or(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu._or(X, Y);
 }
 
-void chip8_test::_and(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::_and(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu._and(X, Y);
 }
 
-void chip8_test::_xor(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::_xor(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu._xor(X, Y);
 }
 
-void chip8_test::add(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::add(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.add(X, Y);
 }
 
-void chip8_test::sub(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::sub(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.sub(X, Y);
 }
 
-void chip8_test::srl(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::srl(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.srl(X, Y);
 }
 
-void chip8_test::lsub(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::lsub(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.lsub(X, Y);
 }
 
-void chip8_test::sll(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::sll(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.sll(X, Y);
 }
 
-void chip8_test::skrne(chip8& cpu, uint8_t X, uint8_t Y)
+void chip8_test::skrne(Chip8& cpu, uint8_t X, uint8_t Y)
 {
     cpu.skrne(X, Y);
 }
 
-void chip8_test::movri(chip8& cpu, uint16_t NNN)
+void chip8_test::movri(Chip8& cpu, uint16_t NNN)
 {
     cpu.movri(NNN);
 }
 
-void chip8_test::jmpv0(chip8& cpu, uint16_t NNN, uint8_t X)
+void chip8_test::jmpv0(Chip8& cpu, uint16_t NNN, uint8_t X)
 {
     cpu.jmpv0(NNN, X);
 }
 
-void chip8_test::rand(chip8& cpu, uint8_t X, uint8_t NN)
+void chip8_test::rand(Chip8& cpu, uint8_t X, uint8_t NN)
 {
     cpu.rand(X, NN);
 }
 
-void chip8_test::draw(chip8& cpu, uint8_t X, uint8_t Y, uint8_t N)
+void chip8_test::draw(Chip8& cpu, uint8_t X, uint8_t Y, uint8_t N)
 {
     cpu.draw(X, Y, N);
 }
 
-void chip8_test::skkp(chip8& cpu, uint8_t X)
+void chip8_test::skkp(Chip8& cpu, uint8_t X)
 {
     cpu.skkp(X);
 }
 
-void chip8_test::skknp(chip8& cpu, uint8_t X)
+void chip8_test::skknp(Chip8& cpu, uint8_t X)
 {
     cpu.skknp(X);
 }
 
-void chip8_test::loadd(chip8& cpu, uint8_t X)
+void chip8_test::loadd(Chip8& cpu, uint8_t X)
 {
     cpu.loadd(X);
 }
 
-void chip8_test::wkey(chip8& cpu, uint8_t X)
+void chip8_test::wkey(Chip8& cpu, uint8_t X)
 {
     cpu.wkey(X);
 }
 
-void chip8_test::movd(chip8& cpu, uint8_t X)
+void chip8_test::movd(Chip8& cpu, uint8_t X)
 {
     cpu.movd(X);
 }
 
-void chip8_test::movs(chip8& cpu, uint8_t X)
+void chip8_test::movs(Chip8& cpu, uint8_t X)
 {
     cpu.movs(X);
 }
 
-void chip8_test::addri(chip8& cpu, uint8_t X)
+void chip8_test::addri(Chip8& cpu, uint8_t X)
 {
     cpu.addri(X);
 }
 
-void chip8_test::spri(chip8& cpu, uint8_t X)
+void chip8_test::spri(Chip8& cpu, uint8_t X)
 {
     cpu.spri(X);
 }
 
-void chip8_test::bcd(chip8& cpu, uint8_t X)
+void chip8_test::bcd(Chip8& cpu, uint8_t X)
 {
     cpu.bcd(X);
 }
 
-void chip8_test::store(chip8& cpu, uint8_t X)
+void chip8_test::store(Chip8& cpu, uint8_t X)
 {
     cpu.store(X);
 }
 
-void chip8_test::load(chip8& cpu, uint8_t X)
+void chip8_test::load(Chip8& cpu, uint8_t X)
 {
     cpu.load(X);
 }
diff --git a/lib/test/chip8_test.h b/lib/test/chip8_test.h
index ade304c..9dc0ca8 100644
--- a/lib/test/chip8_test.h
+++ b/lib/test/chip8_test.h
@@ -5,40 +5,40 @@
 class chip8_test
 {
 public:
-    static void write_vram(chip8& cpu, size_t x, size_t y, bool value);
+    static void write_vram(Chip8& cpu, size_t x, size_t y, bool value);
 
-    static void clear(chip8& cpu);
-    static void ret(chip8& cpu);
-    static void jmp(chip8& cpu, uint16_t NNN);
-    static void call(chip8& cpu, uint16_t NNN);
-    static void skieq(chip8& cpu, uint8_t X, uint8_t NN);
-    static void skine(chip8& cpu, uint8_t X, uint8_t NN);
-    static void skreq(chip8& cpu, uint8_t X, uint8_t Y);
-    static void movi(chip8& cpu, uint8_t X, uint8_t NN);
-    static void addi(chip8& cpu, uint8_t X, uint8_t NN);
-    static void mov(chip8& cpu, uint8_t X, uint8_t Y);
-    static void _or(chip8& cpu, uint8_t X, uint8_t Y);
-    static void _and(chip8& cpu, uint8_t X, uint8_t Y);
-    static void _xor(chip8& cpu, uint8_t X, uint8_t Y);
-    static void add(chip8& cpu, uint8_t X, uint8_t Y);
-    static void sub(chip8& cpu, uint8_t X, uint8_t Y);
-    static void srl(chip8& cpu, uint8_t X, uint8_t Y);
-    static void lsub(chip8& cpu, uint8_t X, uint8_t Y);
-    static void sll(chip8& cpu, uint8_t X, uint8_t Y);
-    static void skrne(chip8& cpu, uint8_t X, uint8_t Y);
-    static void movri(chip8& cpu, uint16_t NNN);
-    static void jmpv0(chip8& cpu, uint16_t NNN, uint8_t X);
-    static void rand(chip8& cpu, uint8_t X, uint8_t NN);
-    static void draw(chip8& cpu, uint8_t X, uint8_t Y, uint8_t N);
-    static void skkp(chip8& cpu, uint8_t X);
-    static void skknp(chip8& cpu, uint8_t X);
-    static void loadd(chip8& cpu, uint8_t X);
-    static void wkey(chip8& cpu, uint8_t X);
-    static void movd(chip8& cpu, uint8_t X);
-    static void movs(chip8& cpu, uint8_t X);
-    static void addri(chip8& cpu, uint8_t X);
-    static void spri(chip8& cpu, uint8_t X);
-    static void bcd(chip8& cpu, uint8_t X);
-    static void store(chip8& cpu, uint8_t X);
-    static void load(chip8& cpu, uint8_t X);
+    static void clear(Chip8& cpu);
+    static void ret(Chip8& cpu);
+    static void jmp(Chip8& cpu, uint16_t NNN);
+    static void call(Chip8& cpu, uint16_t NNN);
+    static void skieq(Chip8& cpu, uint8_t X, uint8_t NN);
+    static void skine(Chip8& cpu, uint8_t X, uint8_t NN);
+    static void skreq(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void movi(Chip8& cpu, uint8_t X, uint8_t NN);
+    static void addi(Chip8& cpu, uint8_t X, uint8_t NN);
+    static void mov(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void _or(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void _and(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void _xor(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void add(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void sub(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void srl(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void lsub(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void sll(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void skrne(Chip8& cpu, uint8_t X, uint8_t Y);
+    static void movri(Chip8& cpu, uint16_t NNN);
+    static void jmpv0(Chip8& cpu, uint16_t NNN, uint8_t X);
+    static void rand(Chip8& cpu, uint8_t X, uint8_t NN);
+    static void draw(Chip8& cpu, uint8_t X, uint8_t Y, uint8_t N);
+    static void skkp(Chip8& cpu, uint8_t X);
+    static void skknp(Chip8& cpu, uint8_t X);
+    static void loadd(Chip8& cpu, uint8_t X);
+    static void wkey(Chip8& cpu, uint8_t X);
+    static void movd(Chip8& cpu, uint8_t X);
+    static void movs(Chip8& cpu, uint8_t X);
+    static void addri(Chip8& cpu, uint8_t X);
+    static void spri(Chip8& cpu, uint8_t X);
+    static void bcd(Chip8& cpu, uint8_t X);
+    static void store(Chip8& cpu, uint8_t X);
+    static void load(Chip8& cpu, uint8_t X);
 };
diff --git a/lib/test/clear.cpp b/lib/test/clear.cpp
index f0ddc6d..0ea48f0 100644
--- a/lib/test/clear.cpp
+++ b/lib/test/clear.cpp
@@ -1,5 +1,6 @@
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
 #include "doctest/doctest.h"
+#include <vector>
 
 #include "chip8.h"
 #include "chip8_test.h"
@@ -7,11 +8,11 @@
 
 TEST_CASE("clear 0x00E0")
 {
-    uint8_t program[2] = { 0x00, 0xE0 };
-    chip8 cpu = chip8(program, sizeof(program));
+    std::vector<uint8_t> program = { 0x00, 0xE0 };
+    Chip8 cpu = Chip8(program);
     SUBCASE("Decode")
     {
-        opcode info = opcode::decode(program[0], program[1]);
+        Opcode info = Opcode::decode(program[0], program[1]);
         CHECK(info.id == opcode_id::CLEAR);
     }
 
diff --git a/lib/test/jmp.cpp b/lib/test/jmp.cpp
index 5a440be..d65709a 100644
--- a/lib/test/jmp.cpp
+++ b/lib/test/jmp.cpp
@@ -9,7 +9,7 @@ TEST_CASE("jmp 0x1NNN")
 {
     SUBCASE("Decode")
     {
-        opcode info = opcode::decode(0x12, 0x34);
+        Opcode info = Opcode::decode(0x12, 0x34);
         CHECK(info.id == opcode_id::JMP);
     }
 }
diff --git a/lib/test/movi.cpp b/lib/test/movi.cpp
index 4bc6638..e88c7c5 100644
--- a/lib/test/movi.cpp
+++ b/lib/test/movi.cpp
@@ -9,7 +9,7 @@ TEST_CASE("movi 0x6XNN")
 {
     SUBCASE("Decode")
     {
-        opcode info = opcode::decode(0x61, 0x34);
+        Opcode info = Opcode::decode(0x61, 0x34);
         CHECK(info.id == opcode_id::MOVI);
         CHECK(info.X == 0x1);
         CHECK(info.NN == 0x34);
@@ -17,7 +17,7 @@ TEST_CASE("movi 0x6XNN")
 
     SUBCASE("Empty register")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(std::vector<uint8_t>());
         CHECK(cpu.get_registers()[0x3] == 0);
         chip8_test::movi(cpu, 0x3, 0xFF);
         CHECK(cpu.get_registers()[0x3] == 0xFF);
@@ -25,7 +25,7 @@ TEST_CASE("movi 0x6XNN")
 
     SUBCASE("Overwrite register")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(std::vector<uint8_t>());
         CHECK(cpu.get_registers()[0xD] == 0);
         chip8_test::movi(cpu, 0xD, 0xFF);
         CHECK(cpu.get_registers()[0xD] == 0xFF);
diff --git a/lib/test/ret.cpp b/lib/test/ret.cpp
index dd8522e..8423a32 100644
--- a/lib/test/ret.cpp
+++ b/lib/test/ret.cpp
@@ -9,7 +9,7 @@ TEST_CASE("ret 0x00EE")
 {
     SUBCASE("Decode")
     {
-        opcode info = opcode::decode(0x00, 0xEE);
+        Opcode info = Opcode::decode(0x00, 0xEE);
         CHECK(info.id == opcode_id::RET);
     }
 }