diff --git a/.github/workflows/cmake.yaml b/.github/workflows/cmake.yaml
index 4223b0e..ff1af42 100644
--- a/.github/workflows/cmake.yaml
+++ b/.github/workflows/cmake.yaml
@@ -2,50 +2,52 @@ name: CMake
 
 on:
   push:
-    branches: [ "master" ]
+    branches: ["master", "conan2"]
   pull_request:
-    branches: [ "master" ]
-
-env:
-  BUILD_TYPE: Release
+    branches: ["master"]
 
 jobs:
   build:
-    runs-on: ${{matrix.os}}
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        os: [ubuntu-latest, windows-latest]
+        build_type: [Release, Debug]
 
     steps:
-    - uses: actions/checkout@v3
-
-    - name: Setup ccache
-      uses: Chocobo1/setup-ccache-action@v1
-      with:
-        windows_compile_environment: msvc
+    - uses: actions/checkout@v4
 
-    - 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: Get conan
+      uses: turtlebrowser/get-conan@v1.0
 
-    - 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: Get conan home
+      id: conan-home
+      run: echo "CONAN_HOME=$(conan config home)" >> $GITHUB_OUTPUT
 
-    - name: Configure CMake
-      if: runner.os != 'Windows'
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+    - name: Cache conan packages
+      uses: actions/cache@v4
+      with:
+        path: ${{ steps.conan-home.outputs.CONAN_HOME/p}}
+        key: ${{ matrix.os }}-${{ matrix.build_type }}-packages
+
+    - 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
-      # 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}}
+      run: conan build .
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0cfd02c..0296cc0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,6 +12,10 @@ 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/compiler_flags.cmake)
 include(cmake/copy_dll.cmake)
 enable_testing() # needed to create the target lib/test
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/app.cpp b/chip-8-sdl/app.cpp
index 6d83aba..840db2d 100644
--- a/chip-8-sdl/app.cpp
+++ b/chip-8-sdl/app.cpp
@@ -15,13 +15,13 @@
 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 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)
+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),
@@ -71,17 +71,17 @@ app::app(config& conf, std::string const& rom_path, std::vector<uint8_t> const&
         sdl_nullcheck(m_font.get(), fmt::format("Failed to open font file: {}", font_strpath).c_str());
     }
 
-    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);
+    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<chip8_screen>(m_renderer, 0, PANEL_HEIGHT, m_conf.fg_color, m_conf.bg_color, m_emulator, SCALE_FACTOR));
+    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)
@@ -91,7 +91,7 @@ app::~app()
 }
 
 // FIXME: this should return EXIT_FAILURE when something goes wrong
-int app::exec()
+int App::exec()
 {
     while (!m_quit)
     {
@@ -112,7 +112,7 @@ int app::exec()
     return EXIT_SUCCESS;
 }
 
-void app::handle_event()
+void App::handle_event()
 {
     while (SDL_PollEvent(&m_event))
     {
@@ -170,7 +170,7 @@ void app::handle_event()
     }
 }
 
-void app::render()
+void App::render()
 {
     set_renderer_color(m_renderer, m_conf.bg_color);
     SDL_RenderClear(m_renderer.get());
@@ -183,7 +183,7 @@ void app::render()
     SDL_RenderPresent(m_renderer.get());
 }
 
-void app::play_sound()
+void App::play_sound()
 {
     if (m_audio_enabled)
     {
@@ -193,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 1a0e853..8193cda 100644
--- a/chip-8-sdl/app.h
+++ b/chip-8-sdl/app.h
@@ -6,13 +6,13 @@
 #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, std::vector<uint8_t> const& program);
-    ~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);
@@ -22,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 23bfc63..116bc2a 100644
--- a/chip-8-sdl/config.h
+++ b/chip-8-sdl/config.h
@@ -6,7 +6,7 @@
 #include <optional>
 #include <yaml-cpp/yaml.h>
 
-struct config
+struct Config
 {
 public:
     static constexpr uint16_t default_width  = 640;
@@ -23,14 +23,14 @@ struct config
     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 4f026b1..9ed4f80 100644
--- a/chip-8-sdl/main.cpp
+++ b/chip-8-sdl/main.cpp
@@ -30,17 +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);
+    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 077be2e..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::unique_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 54500a1..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 28cbc98..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),
+    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 4bb597d..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, const 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::unique_ptr<label>;
+using label_ptr = std::unique_ptr<Label>;
diff --git a/chip-8-sdl/widget/panel.cpp b/chip-8-sdl/widget/panel.cpp
index d772c04..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();
 
@@ -30,25 +30,25 @@ void panel::draw()
     }
 }
 
-void panel::add_child(widget_ptr&& child)
+void Panel::add_child(widget_ptr&& child)
 {
     m_children.push_back(std::move(child));
     apply_layout();
 }
 
-void panel::set_layout(Layout l)
+void Panel::set_layout(Layout l)
 {
     m_layout = l;
     apply_layout();
 }
 
-void panel::apply_layout()
+void Panel::apply_layout()
 {
     switch (m_layout) {
         case Layout::Horizontal:
         {
             int next_x = 2;
-            for (widget_ptr& widget : m_children) 
+            for (widget_ptr& widget : m_children)
             {
                 widget->x() = next_x;
                 next_x += widget->w();
@@ -58,7 +58,7 @@ void panel::apply_layout()
         case Layout::Vertical:
         {
             int next_y = 0;
-            for (widget_ptr& widget : m_children) 
+            for (widget_ptr& widget : m_children)
             {
                 widget->y() = next_y;
                 next_y += widget->h();
diff --git a/chip-8-sdl/widget/panel.h b/chip-8-sdl/widget/panel.h
index 1457beb..2215b0d 100644
--- a/chip-8-sdl/widget/panel.h
+++ b/chip-8-sdl/widget/panel.h
@@ -5,15 +5,15 @@
 #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, Layout layout = Layout::NoLayout)
-        : widget(renderer, x, y, w, h, fg_color, bg_color),
+    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 set_layout(Layout layout);
@@ -24,4 +24,4 @@ class panel : public widget
     Layout m_layout = Layout::NoLayout;
 };
 
-using panel_ptr = std::unique_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 a96c105..bb4126f 100644
--- a/chip-8-sdl/widget/widget.h
+++ b/chip-8-sdl/widget/widget.h
@@ -3,11 +3,11 @@
 
 #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;
 
@@ -29,4 +29,4 @@ class widget
     SDL_Color m_bg_color;
 };
 
-using widget_ptr = std::unique_ptr<widget>;
+using widget_ptr = std::unique_ptr<Widget>;
diff --git a/conanfile.py b/conanfile.py
index eb5e46b..d4df0a2 100644
--- a/conanfile.py
+++ b/conanfile.py
@@ -14,7 +14,10 @@ class Chip8Recipe(ConanFile):
     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/*"
+    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")
diff --git a/lib/include/chip8.h b/lib/include/chip8.h
index bd28a22..b131a3e 100644
--- a/lib/include/chip8.h
+++ b/lib/include/chip8.h
@@ -9,7 +9,7 @@
 #include "cpu_quirks.h"
 #include "opcode.h"
 
-class chip8
+class Chip8
 {
     friend class chip8_test;
 
@@ -23,7 +23,7 @@ class chip8
     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> font
+    static constexpr std::array<uint8_t, 80> DEFAULT_FONT
     {
         0xF0, 0x90, 0x90, 0x90, 0xF0, // 0
         0x20, 0x60, 0x20, 0x20, 0x70, // 1
@@ -44,7 +44,7 @@ class chip8
     };
 
     bool vram_dirty;
-    chip8(std::vector<uint8_t> const& rom);
+    Chip8(std::vector<uint8_t> const& rom);
 
     [[noreturn]] void panic(std::string msg);
     void dump_regs(std::ostream& stream);
@@ -52,7 +52,7 @@ 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);
@@ -79,7 +79,7 @@ class chip8
     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 e24e908..e828f3c 100644
--- a/lib/src/chip8.cpp
+++ b/lib/src/chip8.cpp
@@ -6,8 +6,8 @@
 
 #include "chip8.h"
 
-chip8::chip8(std::vector<uint8_t> const& rom)
-    : quirks(quirks_profile::CHIP_8)
+Chip8::Chip8(std::vector<uint8_t> const& rom)
+    : quirks(QuirksProfile::CHIP_8)
 {
     vram_dirty = true;
     V.fill(0);
@@ -31,11 +31,11 @@ chip8::chip8(std::vector<uint8_t> const& rom)
     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);
@@ -48,7 +48,7 @@ chip8::chip8(std::vector<uint8_t> const& rom)
     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);
@@ -62,13 +62,13 @@ 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)
     {
@@ -80,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);
     }
 
@@ -97,7 +97,7 @@ 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
@@ -105,7 +105,7 @@ uint16_t chip8::fetch_opcode()
     return raw_opcode;
 }
 
-void chip8::execute(opcode opcode)
+void Chip8::execute(Opcode opcode)
 {
     #ifndef NDEBUG
         // fmt::print("opcode:{:#06x} ", opcode.raw_opcode);
@@ -160,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 >= 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");
@@ -195,7 +195,7 @@ void chip8::ret()
 }
 
 /* 1NNN -> Jump to address NNN */
-void chip8::jmp(uint16_t NNN)
+void Chip8::jmp(uint16_t NNN)
 {
     if (NNN > RAM_SIZE)
         panic(fmt::format("Can not 'jmp' to invalid address {:#06x}", NNN));
@@ -204,7 +204,7 @@ void chip8::jmp(uint16_t NNN)
 }
 
 /* 2NNN -> Call subroutine at NNN */
-void chip8::call(uint16_t NNN)
+void Chip8::call(uint16_t NNN)
 {
     if (NNN > RAM_SIZE)
         panic(fmt::format("Cannot 'call' invalid address {:#06x}", NNN));
@@ -216,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");
 
@@ -225,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");
 
@@ -234,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");
@@ -244,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");
 
@@ -252,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");
 
@@ -260,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");
@@ -269,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");
@@ -280,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");
@@ -291,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");
@@ -303,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");
@@ -315,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");
@@ -327,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");
@@ -341,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");
@@ -353,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");
@@ -365,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");
@@ -375,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)
@@ -394,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");
 
@@ -407,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");
@@ -430,7 +430,7 @@ void chip8::draw(uint8_t X, uint8_t Y, uint8_t N)
         // FIXME: there is probably a better way implement this quirk
         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
@@ -449,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");
 
@@ -459,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");
 
@@ -468,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");
 
@@ -477,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");
 
@@ -495,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");
 
@@ -503,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");
 
@@ -511,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");
 
@@ -520,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");
 
@@ -533,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");
 
@@ -545,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");
 
@@ -558,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/addi.cpp b/lib/test/addi.cpp
index 5e15a8b..06403f4 100644
--- a/lib/test/addi.cpp
+++ b/lib/test/addi.cpp
@@ -17,7 +17,7 @@ TEST_CASE("addi 0x7XNN")
 
     SUBCASE("Simple execution")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(nullptr, 0);
         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(nullptr, 0);
         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..ce9bb20 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..ed53dcd 100644
--- a/lib/test/clear.cpp
+++ b/lib/test/clear.cpp
@@ -8,7 +8,7 @@
 TEST_CASE("clear 0x00E0")
 {
     uint8_t program[2] = { 0x00, 0xE0 };
-    chip8 cpu = chip8(program, sizeof(program));
+    Chip8 cpu = Chip8(program, sizeof(program));
     SUBCASE("Decode")
     {
         opcode info = opcode::decode(program[0], program[1]);
diff --git a/lib/test/movi.cpp b/lib/test/movi.cpp
index 4bc6638..5c923c6 100644
--- a/lib/test/movi.cpp
+++ b/lib/test/movi.cpp
@@ -17,7 +17,7 @@ TEST_CASE("movi 0x6XNN")
 
     SUBCASE("Empty register")
     {
-        chip8 cpu = chip8(nullptr, 0);
+        Chip8 cpu = Chip8(nullptr, 0);
         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(nullptr, 0);
         CHECK(cpu.get_registers()[0xD] == 0);
         chip8_test::movi(cpu, 0xD, 0xFF);
         CHECK(cpu.get_registers()[0xD] == 0xFF);