diff --git a/.gitignore b/.gitignore
index ec2481e..ca37570 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,3 +19,13 @@ tags
 # Persistent undo
 [._]*.un~
 
+subprojects
+builddir
+ttassets
+backup
+*.exe
+*.dll
+*.world
+coverage
+coverage/*
+.venv
diff --git a/.vimrc_proj b/.vimrc_proj
new file mode 100644
index 0000000..2b745b4
--- /dev/null
+++ b/.vimrc_proj
@@ -0,0 +1 @@
+set makeprg=meson\ compile\ -C\ .
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..fa86918
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,58 @@
+all: build test
+
+reset:
+ifeq '$(OS)' 'Windows_NT'
+	powershell -executionpolicy bypass .\scripts\reset_build.ps1
+else
+	sh -x ./scripts/reset_build.sh
+endif
+
+%.cpp : %.rl
+	ragel -o $@ $<
+
+build: lel_parser.cpp
+	meson compile -j 10 -C builddir
+
+release_build:
+	meson --wipe builddir -Db_ndebug=true --buildtype release
+	meson compile -j 10 -C builddir
+
+debug_build:
+	meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized
+	meson compile -j 10 -C builddir
+
+tracy_build:
+	meson setup --wipe builddir --buildtype debugoptimized -Dtracy_enable=true -Dtracy:on_demand=true
+	meson compile -j 10 -C builddir
+
+test: build
+	./builddir/runtests
+
+run: build test
+ifeq '$(OS)' 'Windows_NT'
+	powershell "cp ./builddir/calculator.exe ."
+	./calculator
+else
+	./builddir/calculator
+endif
+
+debug: build
+	gdb --nx -x .gdbinit --ex run --args builddir/calculator
+
+debug_run: build
+	gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/calculator
+
+debug_walk: build test
+	gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/calculator t
+
+clean:
+	meson compile --clean -C builddir
+
+debug_test: build
+	gdb --nx -x .gdbinit --ex run --args builddir/runtests -e
+
+win_installer:
+	powershell 'start "C:\Program Files (x86)\solicus\InstallForge\bin\ifbuilderenvx86.exe" scripts\win_installer.ifp'
+
+coverage_report:
+	powershell 'scripts/coverage_report.ps1'
diff --git a/dbc.cpp b/dbc.cpp
new file mode 100644
index 0000000..6b17faf
--- /dev/null
+++ b/dbc.cpp
@@ -0,0 +1,47 @@
+#include "dbc.hpp"
+#include <iostream>
+
+void dbc::log(const string &message, const std::source_location location) {
+  std::cout << '[' << location.file_name() << ':'
+     << location.line() << "|"
+     << location.function_name() << "] "
+     << message << std::endl;
+}
+
+void dbc::sentinel(const string &message, const std::source_location location) {
+  string err = fmt::format("[SENTINEL!] {}", message);
+  dbc::log(err, location);
+  throw dbc::SentinelError{err};
+}
+
+void dbc::pre(const string &message, bool test, const std::source_location location) {
+  if(!test) {
+    string err = fmt::format("[PRE!] {}", message);
+    dbc::log(err, location);
+    throw dbc::PreCondError{err};
+  }
+}
+
+void dbc::pre(const string &message, std::function<bool()> tester, const std::source_location location) {
+  dbc::pre(message, tester(), location);
+}
+
+void dbc::post(const string &message, bool test, const std::source_location location) {
+  if(!test) {
+    string err = fmt::format("[POST!] {}", message);
+    dbc::log(err, location);
+    throw dbc::PostCondError{err};
+  }
+}
+
+void dbc::post(const string &message, std::function<bool()> tester, const std::source_location location) {
+  dbc::post(message, tester(), location);
+}
+
+void dbc::check(bool test, const string &message, const std::source_location location) {
+  if(!test) {
+    string err = fmt::format("[CHECK!] {}\n", message);
+    dbc::log(err, location);
+    throw dbc::CheckError{err};
+  }
+}
diff --git a/dbc.hpp b/dbc.hpp
new file mode 100644
index 0000000..87e4fb0
--- /dev/null
+++ b/dbc.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <fmt/core.h>
+#include <functional>
+#include <source_location>
+
+using std::string;
+
+namespace dbc {
+  class Error {
+    public:
+      const string message;
+      Error(string m) : message{m} {}
+      Error(const char *m) : message{m} {}
+  };
+
+  class CheckError : public Error {};
+  class SentinelError : public Error {};
+  class PreCondError : public Error {};
+  class PostCondError : public Error {};
+
+  void log(const string &message,
+      const std::source_location location =
+      std::source_location::current());
+
+  [[noreturn]] void sentinel(const string &message,
+      const std::source_location location =
+      std::source_location::current());
+
+  void pre(const string &message, bool test,
+      const std::source_location location =
+      std::source_location::current());
+
+  void pre(const string &message, std::function<bool()> tester,
+      const std::source_location location =
+      std::source_location::current());
+
+  void post(const string &message, bool test,
+      const std::source_location location =
+      std::source_location::current());
+
+  void post(const string &message, std::function<bool()> tester,
+      const std::source_location location =
+      std::source_location::current());
+
+  void check(bool test, const string &message,
+      const std::source_location location =
+      std::source_location::current());
+}
diff --git a/guecs.cpp b/guecs.cpp
new file mode 100644
index 0000000..22dba4b
--- /dev/null
+++ b/guecs.cpp
@@ -0,0 +1,354 @@
+#include "guecs.hpp"
+#include "shaders.hpp"
+#include "sound.hpp"
+#include "textures.hpp"
+#include <typeinfo>
+
+namespace guecs {
+  using std::make_shared;
+
+  void Textual::init(lel::Cell &cell, shared_ptr<sf::Font> font_ptr) {
+    dbc::check(font_ptr != nullptr, "you failed to initialize this WideText");
+    if(font == nullptr) font = font_ptr;
+    if(text == nullptr) text = make_shared<sf::Text>(*font, content, size);
+    text->setFillColor(color);
+
+    if(centered) {
+      auto bounds = text->getLocalBounds();
+      auto text_cell = lel::center(bounds.size.x, bounds.size.y, cell);
+      // this stupid / 2 is because SFML renders from baseline rather than from the claimed bounding box
+      text->setPosition({float(text_cell.x), float(text_cell.y) - text_cell.h / 2});
+    } else {
+      text->setPosition({float(cell.x + padding * 2), float(cell.y + padding * 2)});
+    }
+
+    text->setCharacterSize(size);
+  }
+
+  void Textual::update(const wstring& new_content) {
+    content = new_content;
+    text->setString(content);
+  }
+
+  void Sprite::update(const string& new_name) {
+    if(new_name != name) {
+      name = new_name;
+      auto sprite_texture = textures::get(name);
+      sprite->setTexture(*sprite_texture.texture);
+      sprite->setTextureRect(sprite_texture.sprite->getTextureRect());
+    }
+  }
+
+  void Sprite::init(lel::Cell &cell) {
+    auto sprite_texture = textures::get(name);
+
+    sprite = make_shared<sf::Sprite>(
+        *sprite_texture.texture,
+        sprite_texture.sprite->getTextureRect());
+
+    sprite->setPosition({
+        float(cell.x + padding),
+        float(cell.y + padding)});
+
+    auto bounds = sprite->getLocalBounds();
+
+    sprite->setScale({
+        float(cell.w - padding * 2) / bounds.size.x,
+        float(cell.h - padding * 2) / bounds.size.y});
+  }
+
+  void Rectangle::init(lel::Cell& cell) {
+    sf::Vector2f size{float(cell.w) - padding * 2, float(cell.h) - padding * 2};
+    if(shape == nullptr) shape = make_shared<sf::RectangleShape>(size);
+    shape->setPosition({float(cell.x + padding), float(cell.y + padding)});
+    shape->setFillColor(color);
+    shape->setOutlineColor(border_color);
+    shape->setOutlineThickness(border_px);
+  }
+
+
+  void Meter::init(lel::Cell& cell) {
+    bar.init(cell);
+  }
+
+  void Meter::render(lel::Cell& cell) {
+    float level = std::clamp(percent, 0.0f, 1.0f) * float(cell.w);
+    // ZED: this 6 is a border width, make it a thing
+    bar.shape->setSize({std::max(level, 0.0f), float(cell.h - 6)});
+  }
+
+  void Sound::play(bool hover) {
+    if(!hover) {
+      sound::play(on_click);
+    }
+  }
+
+  void Sound::stop(bool hover) {
+    if(!hover) {
+      sound::stop(on_click);
+    }
+  }
+
+  void Background::init() {
+    sf::Vector2f size{float(w), float(h)};
+    if(shape == nullptr) shape = make_shared<sf::RectangleShape>(size);
+    shape->setPosition({float(x), float(y)});
+    shape->setFillColor(color);
+  }
+
+  void Effect::init(lel::Cell &cell) {
+    $shader_version = shaders::version();
+    $shader = shaders::get(name);
+    $shader->setUniform("u_resolution", sf::Vector2f({float(cell.w), float(cell.h)}));
+    $clock = std::make_shared<sf::Clock>();
+  }
+
+  void Effect::step() {
+    sf::Time cur_time = $clock->getElapsedTime();
+    float u_time = cur_time.asSeconds();
+
+    if(u_time < $u_time_end) {
+      $shader->setUniform("u_duration", duration);
+      $shader->setUniform("u_time_end", $u_time_end);
+      $shader->setUniform("u_time", u_time);
+    } else {
+      $active = false;
+    }
+  }
+
+  void Effect::run() {
+    $active = true;
+    sf::Time u_time = $clock->getElapsedTime();
+    $u_time_end = u_time.asSeconds() + duration;
+  }
+
+  shared_ptr<sf::Shader> Effect::checkout_ptr() {
+    if(shaders::updated($shader_version)) {
+      $shader = shaders::get(name);
+      $shader_version = shaders::version();
+    }
+
+    return $shader;
+  }
+
+  void Effect::stop() {
+    $active = false;
+  }
+
+  UI::UI() {
+    $font = make_shared<sf::Font>(FONT_FILE_NAME);
+  }
+
+  void UI::position(int x, int y, int width, int height) {
+    $parser.position(x, y, width, height);
+  }
+
+  sf::Vector2f UI::get_position() {
+    return {float($parser.grid_x), float($parser.grid_y)};
+  }
+
+  sf::Vector2f UI::get_size() {
+    return {float($parser.grid_w), float($parser.grid_h)};
+  }
+
+  void UI::layout(const string& grid) {
+    $grid = grid;
+    bool good = $parser.parse($grid);
+    dbc::check(good, "LEL parsing failed.");
+
+    for(auto& [name, cell] : $parser.cells) {
+      auto ent = init_entity(name);
+      set<lel::Cell>(ent, cell);
+    }
+  }
+
+  Entity UI::init_entity(const string& name) {
+    auto ent = entity();
+    // this lets you look up an entity by name
+    $name_ents.insert_or_assign(name, ent);
+    // this makes it easier to get the name during querying
+    set<CellName>(ent, {name});
+    return ent;
+  }
+
+  Entity UI::entity(const string& name) {
+    dbc::check($name_ents.contains(name),
+        fmt::format("GUECS entity {} does not exist. Mispelled cell name?", name));
+    return $name_ents.at(name);
+  }
+
+  Entity UI::entity(const string& name, int id) {
+    return entity(fmt::format("{}{}", name, id));
+  }
+
+  void UI::init() {
+    query<Background>([](auto, auto& bg) {
+        bg.init();
+    });
+
+    query<lel::Cell, Rectangle>([](auto, auto& cell, auto& rect) {
+      rect.init(cell);
+    });
+
+    query<lel::Cell, Effect>([](auto, auto& cell, auto& shader) {
+      shader.init(cell);
+    });
+
+    query<Rectangle, Meter>([](auto, auto& bg, auto &meter) {
+      bg.shape->setFillColor(meter.color);
+    });
+
+    query<lel::Cell, Meter>([](auto, auto &cell, auto& meter) {
+      meter.init(cell);
+    });
+
+    query<lel::Cell, Textual>([this](auto, auto& cell, auto& text) {
+      text.init(cell, $font);
+    });
+
+    query<lel::Cell, Label>([this](auto, auto& cell, auto& text) {
+      text.init(cell, $font);
+    });
+
+    query<lel::Cell, Sprite>([&](auto, auto &cell, auto &sprite) {
+      sprite.init(cell);
+    });
+  }
+
+  void UI::debug_layout(sf::RenderWindow& window) {
+    query<lel::Cell>([&](const auto, auto &cell) {
+      sf::RectangleShape rect{{float(cell.w), float(cell.h)}};
+      rect.setPosition({float(cell.x), float(cell.y)});
+      rect.setFillColor(sf::Color::Transparent);
+      rect.setOutlineColor(sf::Color::Red);
+      rect.setOutlineThickness(2.0f);
+      window.draw(rect);
+    });
+  }
+
+  void UI::render(sf::RenderWindow& window) {
+    if(auto bg = get_if<Background>(MAIN)) {
+      window.draw(*(bg->shape));
+    }
+
+    query<Effect>([&](auto, auto& shader) {
+      if(shader.$active) shader.step();
+    });
+
+    query<Rectangle>([&](auto ent, auto& rect) {
+        render_helper(window, ent, true, rect.shape);
+    });
+
+    query<lel::Cell, Meter>([&](auto ent, auto& cell, auto &meter) {
+      meter.render(cell);
+      render_helper(window, ent, true, meter.bar.shape);
+    });
+
+    query<Sprite>([&](auto ent, auto& sprite) {
+        render_helper(window, ent, false, sprite.sprite);
+    });
+
+    query<Label>([&](auto ent, auto& text) {
+        render_helper(window, ent, false, text.text);
+    });
+
+    query<Textual>([&](auto ent, auto& text) {
+        render_helper(window, ent, true, text.text);
+    });
+  }
+
+  bool UI::mouse(float x, float y, bool hover) {
+    int action_count = 0;
+
+    query<lel::Cell>([&](auto ent, auto& cell) {
+      if((x >= cell.x && x <= cell.x + cell.w) &&
+          (y >= cell.y && y <= cell.y + cell.h))
+      {
+        do_if<Effect>(ent, [hover](auto& effect) {
+          effect.$shader->setUniform("hover", hover);
+          effect.run();
+        });
+
+        do_if<Sound>(ent, [hover](auto& sound) {
+            // here set that it played then only play once
+            sound.play(hover);
+        });
+
+        if(hover) return;
+
+        click_on(ent);
+
+        action_count++;
+      } else {
+        do_if<Effect>(ent, [hover](auto& effect) {
+          effect.stop();
+        });
+
+        do_if<Sound>(ent, [hover](auto& sound) {
+            // here set that it played then only play once
+            sound.stop(hover);
+        });
+      }
+    });
+
+    return action_count > 0;
+  }
+
+  void UI::show_sprite(const string& region, const string& sprite_name) {
+    auto ent = entity(region);
+
+    if(auto sprite = get_if<Sprite>(ent)) {
+      sprite->update(sprite_name);
+    } else {
+      set_init<Sprite>(ent, {sprite_name});
+    }
+  }
+
+  void UI::show_text(const string& region, const wstring& content) {
+    auto ent = entity(region);
+
+    if(auto tc = get_if<Textual>(ent)) {
+      tc->text->setString(content);
+    } else {
+      auto &cell = cell_for(ent);
+      Textual to_set{content, TEXT_SIZE};
+      to_set.init(cell, $font);
+      set<Textual>(ent, to_set);
+    }
+  }
+
+  void UI::click_on(const string& name, bool required) {
+    auto ent = entity(name);
+
+    if(required) {
+      dbc::check(has<Clickable>(ent),
+          fmt::format("click_on required '{}' to exist but it doesn't", name));
+    }
+
+    click_on(ent);
+  }
+
+  void UI::click_on(Entity ent) {
+    if(auto clicked = get_if<Clickable>(ent)) {
+      if(auto action_data = get_if<ActionData>(ent)) {
+        clicked->action(ent, action_data->data);
+      } else {
+        clicked->action(ent, {});
+      }
+    }
+  }
+
+  void UI::show_label(const string& region, const wstring& content) {
+    auto ent = entity(region);
+
+    if(auto tc = get_if<Label>(ent)) {
+      tc->text->setString(content);
+    } else {
+      auto &cell = cell_for(ent);
+      Label to_set{content, LABEL_SIZE};
+      to_set.init(cell, $font);
+      to_set.text->setFillColor(TEXT_COLOR);
+      set<Label>(ent, to_set);
+    }
+  }
+}
diff --git a/guecs.hpp b/guecs.hpp
new file mode 100644
index 0000000..cce73e8
--- /dev/null
+++ b/guecs.hpp
@@ -0,0 +1,340 @@
+#pragma once
+#include "dbc.hpp"
+#include "color.hpp"
+#include "lel.hpp"
+#include <string>
+#include <memory>
+#include <SFML/Graphics.hpp>
+#include <functional>
+#include "events.hpp"
+#include <any>
+#include <queue>
+#include <typeindex>
+#include <unordered_map>
+
+namespace guecs {
+  constexpr const int PADDING = 3;
+  constexpr const int BORDER_PX = 1;
+  constexpr const int TEXT_SIZE = 30;
+  constexpr const int LABEL_SIZE = 20;
+  constexpr const sf::Color FILL_COLOR = ColorValue::DARK_MID;
+  constexpr const sf::Color TEXT_COLOR = ColorValue::LIGHT_LIGHT;
+  constexpr const sf::Color BG_COLOR = ColorValue::MID;
+  constexpr const sf::Color BORDER_COLOR = ColorValue::MID;
+  constexpr const char *FONT_FILE_NAME="assets/text.otf";
+
+  using std::shared_ptr, std::wstring, std::string;
+
+  using Entity = unsigned long;
+
+  using EntityMap = std::unordered_map<Entity, size_t>;
+
+  template <typename T>
+    struct ComponentStorage {
+      std::vector<T> data;
+      std::queue<size_t> free_indices;
+    };
+
+  struct Textual {
+    std::wstring content;
+    unsigned int size = TEXT_SIZE;
+    sf::Color color = TEXT_COLOR;
+    int padding = PADDING;
+    bool centered = false;
+    shared_ptr<sf::Font> font = nullptr;
+    shared_ptr<sf::Text> text = nullptr;
+
+    void init(lel::Cell &cell, shared_ptr<sf::Font> font_ptr);
+    void update(const std::wstring& new_content);
+  };
+
+  struct Label : public Textual {
+    template<typename... Args>
+      Label(Args... args) : Textual(args...)
+    {
+      centered = true;
+      size = LABEL_SIZE;
+    }
+
+    Label() {
+      centered = true;
+    };
+  };
+
+  struct Clickable {
+    /* This is actually called by UI::mouse and passed the entity ID of the
+     * button pressed so you can interact with it in the event handler.
+     */
+    std::function<void(Entity ent, std::any data)> action;
+  };
+
+  struct Sprite {
+    string name;
+    int padding = PADDING;
+    std::shared_ptr<sf::Sprite> sprite = nullptr;
+
+    void init(lel::Cell &cell);
+    void update(const string& new_name);
+  };
+
+  struct Rectangle {
+    int padding = PADDING;
+    sf::Color color = FILL_COLOR;
+    sf::Color border_color = BORDER_COLOR;
+    int border_px = BORDER_PX;
+    shared_ptr<sf::RectangleShape> shape = nullptr;
+
+    void init(lel::Cell& cell);
+  };
+
+  struct Meter {
+    float percent = 1.0f;
+    sf::Color color = ColorValue::BLACK;
+    Rectangle bar;
+
+    void init(lel::Cell& cell);
+    void render(lel::Cell& cell);
+  };
+
+  struct ActionData {
+    std::any data;
+  };
+
+  struct CellName {
+    string name;
+  };
+
+  struct Effect {
+    float duration = 0.1f;
+    string name{"ui_shader"};
+    float $u_time_end = 0.0;
+    bool $active = false;
+    std::shared_ptr<sf::Clock> $clock = nullptr;
+    std::shared_ptr<sf::Shader> $shader = nullptr;
+    int $shader_version = 0;
+
+    void init(lel::Cell &cell);
+    void run();
+    void stop();
+    void step();
+    shared_ptr<sf::Shader> checkout_ptr();
+  };
+
+  struct Sound {
+    string on_click{"ui_click"};
+    void play(bool hover);
+    void stop(bool hover);
+  };
+
+  struct Background {
+    float x = 0.0f;
+    float y = 0.0f;
+    float w = 0.0f;
+    float h = 0.0f;
+    sf::Color color = BG_COLOR;
+    shared_ptr<sf::RectangleShape> shape = nullptr;
+
+    Background(lel::Parser& parser, sf::Color bg_color=BG_COLOR) :
+      x(parser.grid_x),
+      y(parser.grid_y),
+      w(parser.grid_w),
+      h(parser.grid_h),
+      color(bg_color)
+    {}
+
+    Background() {}
+
+    void init();
+  };
+
+
+  class UI {
+    public:
+      Entity MAIN = 0;
+      unsigned long entity_count = 1;
+      std::unordered_map<std::type_index, EntityMap> $components;
+      std::unordered_map<std::type_index, std::any> $component_storages;
+      std::unordered_map<string, Entity> $name_ents;
+      shared_ptr<sf::Font> $font = nullptr;
+      lel::Parser $parser;
+      string $grid = "";
+
+      UI();
+
+      void position(int x, int y, int width, int height);
+      sf::Vector2f get_position();
+      sf::Vector2f get_size();
+      void layout(const string& grid);
+      Entity init_entity(const string& name);
+      Entity entity(const string& name);
+      Entity entity(const string& name, int id);
+
+      inline lel::CellMap& cells() {
+        return $parser.cells;
+      }
+
+      void init();
+      void render(sf::RenderWindow& window);
+      bool mouse(float x, float y, bool hover);
+      void click_on(const string& name, bool required=false);
+      void click_on(Entity slot_id);
+      void debug_layout(sf::RenderWindow& window);
+
+      Entity entity() { return ++entity_count; }
+
+      template <typename Comp>
+        size_t make_component() {
+          auto &storage = component_storage_for<Comp>();
+          size_t index;
+
+          if(!storage.free_indices.empty()) {
+            index = storage.free_indices.front();
+            storage.free_indices.pop();
+          } else {
+            storage.data.emplace_back();
+            index = storage.data.size() - 1;
+          }
+
+          return index;
+        }
+
+      template <typename Comp>
+        ComponentStorage<Comp> &component_storage_for() {
+          auto type_index = std::type_index(typeid(Comp));
+          $component_storages.try_emplace(type_index, ComponentStorage<Comp>{});
+          return std::any_cast<ComponentStorage<Comp> &>(
+              $component_storages.at(type_index));
+        }
+
+      template <typename Comp>
+        EntityMap &entity_map_for() {
+          return $components[std::type_index(typeid(Comp))];
+        }
+
+      template <typename Comp>
+        void set(Entity ent, Comp val) {
+          EntityMap &map = entity_map_for<Comp>();
+
+          if(has<Comp>(ent)) {
+            get<Comp>(ent) = val;
+            return;
+          }
+
+          map.insert_or_assign(ent, make_component<Comp>());
+          get<Comp>(ent) = val;
+        }
+
+      template <typename Comp>
+        Comp& get(Entity ent) {
+          EntityMap &map = entity_map_for<Comp>();
+          auto &storage = component_storage_for<Comp>();
+          auto index = map.at(ent);
+          return storage.data[index];
+        }
+
+      template <typename Comp>
+        Comp* get_if(Entity entity) {
+          EntityMap &map = entity_map_for<Comp>();
+          auto &storage = component_storage_for<Comp>();
+          if(map.contains(entity)) {
+            auto index = map.at(entity);
+            return &storage.data[index];
+          } else {
+            return nullptr;
+          }
+        }
+
+      template <typename Comp>
+        bool has(Entity ent) {
+          EntityMap &map = entity_map_for<Comp>();
+          return map.contains(ent);
+        }
+
+      template <typename Comp>
+        void remove(Entity ent) {
+          EntityMap &map = entity_map_for<Comp>();
+
+          if(map.contains(ent)) {
+            size_t index = map.at(ent);
+            component_storage_for<Comp>().free_indices.push(index);
+          }
+
+          map.erase(ent);
+        }
+
+      template <typename Comp>
+        void query(std::function<void(Entity, Comp &)> cb) {
+          EntityMap &map = entity_map_for<Comp>();
+
+          for(auto &[entity, index] : map) {
+            cb(entity, get<Comp>(entity));
+          }
+        }
+
+      template <typename CompA, typename CompB>
+        void query(std::function<void(Entity, CompA &, CompB &)> cb) {
+          EntityMap &map_a = entity_map_for<CompA>();
+          EntityMap &map_b = entity_map_for<CompB>();
+
+          for(auto &[entity, index_a] : map_a) {
+            if(map_b.contains(entity)) {
+              cb(entity, get<CompA>(entity), get<CompB>(entity));
+            }
+          }
+        }
+
+      template <typename Comp>
+        void set_init(Entity ent, Comp val) {
+          dbc::check(has<lel::Cell>(ent),"WRONG! slot is missing its cell?!");
+          auto& cell = get<lel::Cell>(ent);
+          val.init(cell);
+          set<Comp>(ent, val);
+        }
+
+      template <typename Comp>
+        void do_if(Entity ent, std::function<void(Comp &)> cb) {
+          if(has<Comp>(ent)) {
+            cb(get<Comp>(ent));
+          }
+        }
+
+      lel::Cell& cell_for(Entity ent) {
+        return get<lel::Cell>(ent);
+      }
+
+      lel::Cell& cell_for(const string& name) {
+        Entity ent = entity(name);
+        return get<lel::Cell>(ent);
+      }
+
+
+      // BUG: close could just be remove with overload
+      template <typename Comp>
+        void close(string region) {
+          auto ent = entity(region);
+          if(has<Comp>(ent)) {
+            remove<Comp>(ent);
+          }
+        }
+
+      template<typename T>
+        void render_helper(sf::RenderWindow& window, Entity ent, bool is_shape, T& target) {
+          sf::Shader *shader_ptr = nullptr;
+
+          if(auto shader = get_if<Effect>(ent)) {
+            if(shader->$active && !is_shape) {
+              auto ptr = shader->checkout_ptr();
+              ptr->setUniform("is_shape", is_shape);
+              // NOTE: this is needed because SFML doesn't handle shared_ptr
+              shader_ptr = ptr.get();
+            }
+          }
+
+          window.draw(*target, shader_ptr);
+        }
+
+      void show_sprite(const string& region, const string& sprite_name);
+      void show_text(const string& region, const wstring& content);
+      void show_label(const string& region, const wstring& content);
+  };
+}
diff --git a/guecstra.cpp b/guecstra.cpp
new file mode 100644
index 0000000..915b8a1
--- /dev/null
+++ b/guecstra.cpp
@@ -0,0 +1,18 @@
+#include "guecstra.hpp"
+
+namespace guecs {
+
+  Clickable make_action(DinkyECS::World& target, Events::GUI event) {
+    return {[&, event](auto ent, auto data){
+      // remember that ent is passed in from the UI::mouse handler
+      target.send<Events::GUI>(event, ent, data);
+    }};
+  }
+
+  Clickable make_action(DinkyECS::World& target, Events::GUI event, std::any data) {
+    return {[&, event, data](auto ent, auto){
+      // remember that ent is passed in from the UI::mouse handler
+      target.send<Events::GUI>(event, ent, data);
+    }};
+  }
+}
diff --git a/guecstra.hpp b/guecstra.hpp
new file mode 100644
index 0000000..b9d62b3
--- /dev/null
+++ b/guecstra.hpp
@@ -0,0 +1,7 @@
+#include "components.hpp"
+#include "guecs.hpp"
+
+namespace guecs {
+  Clickable make_action(DinkyECS::World& target, Events::GUI event);
+  Clickable make_action(DinkyECS::World& target, Events::GUI event, std::any data);
+}
diff --git a/lel.cpp b/lel.cpp
new file mode 100644
index 0000000..e2579fd
--- /dev/null
+++ b/lel.cpp
@@ -0,0 +1,117 @@
+#include "lel.hpp"
+#include <fmt/core.h>
+#include "dbc.hpp"
+#include <numeric>
+
+#include "lel_parser.cpp"
+
+namespace lel {
+
+  Parser::Parser(int x, int y, int width, int height) :
+    grid_x(x),
+    grid_y(y),
+    grid_w(width),
+    grid_h(height),
+    cur(0, 0)
+  {
+  }
+
+  Parser::Parser() : cur(0, 0) { }
+
+  void Parser::position(int x, int y, int width, int height) {
+    grid_x = x;
+    grid_y = y;
+    grid_w = width;
+    grid_h = height;
+  }
+
+  void Parser::id(std::string name) {
+    if(name != "_") {
+      dbc::check(!cells.contains(name),
+          fmt::format("duplicate cell name {}", name));
+      cells.insert_or_assign(name, cur);
+    }
+
+    cur = {cur.col + 1, cur.row};
+    auto& row = grid.back();
+    row.push_back(name);
+  }
+
+  void Parser::finalize() {
+    size_t rows = grid.size();
+    int cell_height = grid_h / rows;
+
+    for(auto& row : grid) {
+      size_t columns = row.size();
+      int cell_width = grid_w / columns;
+      dbc::check(cell_width > 0, "invalid cell width calc");
+      dbc::check(cell_height > 0, "invalid cell height calc");
+
+      for(auto& name : row) {
+        if(name == "_") continue;
+        auto& cell = cells.at(name);
+
+        // ZED: getting a bit hairy but this should work
+        if(cell.percent) {
+          // when percent mode we have to take unset to 100%
+          if(cell.max_w == 0) cell.max_w = 100;
+          if(cell.max_h == 0) cell.max_h = 100;
+          cell.max_w *= cell_width * 0.01;
+          cell.max_h *= cell_height * 0.01;
+        } else {
+          if(cell.max_w == 0) cell.max_w = cell_width;
+          if(cell.max_h == 0) cell.max_h = cell_height;
+        }
+
+        cell.w = cell.expand ? std::min(cell.max_w, grid_w) : std::min(cell_width, cell.max_w);
+        cell.h = cell.expand ? std::min(cell.max_h, grid_h) : std::min(cell_height, cell.max_h);
+
+        dbc::check(cell.h > 0, fmt::format("invalid height cell {}", name));
+        dbc::check(cell.w > 0, fmt::format("invalid width cell {}", name));
+
+        cell.x = grid_x + (cell.col * cell_width);
+        cell.y = grid_y + (cell.row * cell_height);
+
+        // keep the midpoint since it is used a lot
+        cell.mid_x = std::midpoint(cell.x, cell.x + cell.w);
+        cell.mid_y = std::midpoint(cell.y, cell.y + cell.h);
+
+        // perform alignments
+        if(cell.right) cell.x += cell_width - cell.w;
+        if(cell.bottom) cell.y += cell_height - cell.h;
+        if(cell.center) {
+          cell.x = cell.mid_x - cell.w / 2;
+          cell.y = cell.mid_y - cell.h / 2;
+        }
+      }
+    }
+  }
+
+  void Parser::reset() {
+    cur = {0, 0};
+    grid.clear();
+    cells.clear();
+  }
+
+  std::optional<std::string> Parser::hit(int x, int y) {
+    for(auto& [name, cell] : cells) {
+      if((x >= cell.x && x <= cell.x + cell.w) &&
+          (y >= cell.y && y <= cell.y + cell.h)) {
+        return name;
+      }
+    }
+
+    return std::nullopt;
+  }
+
+  Cell center(int width, int height, Cell &parent) {
+    Cell copy = parent;
+
+    copy.x = parent.mid_x - width / 2;
+    copy.y = parent.mid_y - height / 2;
+    copy.w = width;
+    copy.h = height;
+
+    return copy;
+  }
+}
diff --git a/lel.hpp b/lel.hpp
new file mode 100644
index 0000000..b48df96
--- /dev/null
+++ b/lel.hpp
@@ -0,0 +1,54 @@
+#pragma once
+#include <string>
+#include <unordered_map>
+#include <optional>
+#include <vector>
+
+namespace lel {
+
+  struct Cell {
+    int x = 0;
+    int y = 0;
+    int w = 0;
+    int h = 0;
+    int mid_x = 0;
+    int mid_y = 0;
+    int max_w = 0;
+    int max_h = 0;
+    int col = 0;
+    int row = 0;
+    bool right = false;
+    bool bottom = false;
+    bool expand = false;
+    bool center = false;
+    bool percent = false;
+
+    Cell(int col, int row) : col(col), row(row) {}
+    Cell() {}
+  };
+
+  using Row = std::vector<std::string>;
+  using CellMap = std::unordered_map<std::string, Cell>;
+
+  struct Parser {
+    int grid_x = 0;
+    int grid_y = 0;
+    int grid_w = 0;
+    int grid_h = 0;
+    Cell cur;
+    std::vector<Row> grid;
+    CellMap cells;
+
+    Parser(int x, int y, int width, int height);
+    Parser();
+
+    void position(int x, int y, int width, int height);
+    void id(std::string name);
+    void reset();
+    bool parse(std::string input);
+    void finalize();
+    std::optional<std::string> hit(int x, int y);
+  };
+
+  Cell center(int width, int height, Cell &parent);
+}
diff --git a/lel_parser.cpp b/lel_parser.cpp
new file mode 100644
index 0000000..3af72bc
--- /dev/null
+++ b/lel_parser.cpp
@@ -0,0 +1,261 @@
+
+#line 1 "lel_parser.rl"
+#include "lel.hpp"
+#include <fmt/core.h>
+#include <iostream>
+
+namespace lel {
+
+
+#line 40 "lel_parser.rl"
+
+
+
+#line 10 "lel_parser.cpp"
+static const char _Parser_actions[] = {
+	0, 1, 1, 1, 2, 1, 3, 1, 
+	4, 1, 5, 1, 6, 1, 9, 1, 
+	10, 1, 11, 1, 12, 1, 13, 2, 
+	0, 7, 2, 0, 8, 2, 4, 1, 
+	2, 4, 5
+};
+
+static const char _Parser_key_offsets[] = {
+	0, 0, 4, 20, 33, 35, 39, 41, 
+	44, 56, 61
+};
+
+static const char _Parser_trans_keys[] = {
+	32, 91, 9, 13, 32, 37, 40, 42, 
+	46, 61, 94, 95, 9, 13, 60, 62, 
+	65, 90, 97, 122, 37, 40, 42, 46, 
+	61, 94, 95, 60, 62, 65, 90, 97, 
+	122, 48, 57, 41, 44, 48, 57, 48, 
+	57, 41, 48, 57, 32, 93, 95, 124, 
+	9, 13, 48, 57, 65, 90, 97, 122, 
+	32, 93, 124, 9, 13, 32, 91, 9, 
+	13, 0
+};
+
+static const char _Parser_single_lengths[] = {
+	0, 2, 8, 7, 0, 2, 0, 1, 
+	4, 3, 2
+};
+
+static const char _Parser_range_lengths[] = {
+	0, 1, 4, 3, 1, 1, 1, 1, 
+	4, 1, 1
+};
+
+static const char _Parser_index_offsets[] = {
+	0, 0, 4, 17, 28, 30, 34, 36, 
+	39, 48, 53
+};
+
+static const char _Parser_indicies[] = {
+	0, 2, 0, 1, 3, 4, 5, 6, 
+	7, 9, 7, 10, 3, 8, 10, 10, 
+	1, 4, 5, 6, 7, 9, 7, 10, 
+	8, 10, 10, 1, 11, 1, 12, 13, 
+	14, 1, 15, 1, 16, 17, 1, 18, 
+	20, 19, 21, 18, 19, 19, 19, 1, 
+	22, 23, 24, 22, 1, 25, 2, 25, 
+	1, 0
+};
+
+static const char _Parser_trans_targs[] = {
+	1, 0, 2, 2, 3, 4, 3, 3, 
+	3, 3, 8, 5, 3, 6, 5, 7, 
+	3, 7, 9, 8, 10, 2, 9, 10, 
+	2, 10
+};
+
+static const char _Parser_trans_actions[] = {
+	0, 0, 3, 0, 17, 0, 13, 5, 
+	11, 15, 21, 19, 23, 23, 0, 19, 
+	26, 0, 7, 0, 32, 29, 0, 9, 
+	1, 0
+};
+
+static const int Parser_start = 1;
+static const int Parser_first_final = 10;
+static const int Parser_error = 0;
+
+static const int Parser_en_main = 1;
+
+
+#line 43 "lel_parser.rl"
+
+bool Parser::parse(std::string input) {
+  reset();
+  int cs = 0;
+  const char *start = nullptr;
+  const char *begin = input.data();
+  const char *p = input.data();
+  const char *pe = p + input.size();
+  std::string tk;
+
+  
+#line 91 "lel_parser.cpp"
+	{
+	cs = Parser_start;
+	}
+
+#line 54 "lel_parser.rl"
+  
+#line 94 "lel_parser.cpp"
+	{
+	int _klen;
+	unsigned int _trans;
+	const char *_acts;
+	unsigned int _nacts;
+	const char *_keys;
+
+	if ( p == pe )
+		goto _test_eof;
+	if ( cs == 0 )
+		goto _out;
+_resume:
+	_keys = _Parser_trans_keys + _Parser_key_offsets[cs];
+	_trans = _Parser_index_offsets[cs];
+
+	_klen = _Parser_single_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + _klen - 1;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + ((_upper-_lower) >> 1);
+			if ( (*p) < *_mid )
+				_upper = _mid - 1;
+			else if ( (*p) > *_mid )
+				_lower = _mid + 1;
+			else {
+				_trans += (unsigned int)(_mid - _keys);
+				goto _match;
+			}
+		}
+		_keys += _klen;
+		_trans += _klen;
+	}
+
+	_klen = _Parser_range_lengths[cs];
+	if ( _klen > 0 ) {
+		const char *_lower = _keys;
+		const char *_mid;
+		const char *_upper = _keys + (_klen<<1) - 2;
+		while (1) {
+			if ( _upper < _lower )
+				break;
+
+			_mid = _lower + (((_upper-_lower) >> 1) & ~1);
+			if ( (*p) < _mid[0] )
+				_upper = _mid - 2;
+			else if ( (*p) > _mid[1] )
+				_lower = _mid + 2;
+			else {
+				_trans += (unsigned int)((_mid - _keys)>>1);
+				goto _match;
+			}
+		}
+		_trans += _klen;
+	}
+
+_match:
+	_trans = _Parser_indicies[_trans];
+	cs = _Parser_trans_targs[_trans];
+
+	if ( _Parser_trans_actions[_trans] == 0 )
+		goto _again;
+
+	_acts = _Parser_actions + _Parser_trans_actions[_trans];
+	_nacts = (unsigned int) *_acts++;
+	while ( _nacts-- > 0 )
+	{
+		switch ( *_acts++ )
+		{
+	case 0:
+#line 11 "lel_parser.rl"
+	{tk = input.substr(start - begin, p - start); }
+	break;
+	case 1:
+#line 13 "lel_parser.rl"
+	{}
+	break;
+	case 2:
+#line 14 "lel_parser.rl"
+	{ grid.push_back(Row()); }
+	break;
+	case 3:
+#line 15 "lel_parser.rl"
+	{ cur.bottom = (*p) == '.'; }
+	break;
+	case 4:
+#line 16 "lel_parser.rl"
+	{ id(input.substr(start - begin, p - start)); }
+	break;
+	case 5:
+#line 17 "lel_parser.rl"
+	{ cur.col = 0; cur.row++; }
+	break;
+	case 6:
+#line 18 "lel_parser.rl"
+	{ cur.right = (*p) == '>'; }
+	break;
+	case 7:
+#line 19 "lel_parser.rl"
+	{cur.max_w = std::stoi(tk); }
+	break;
+	case 8:
+#line 20 "lel_parser.rl"
+	{ cur.max_h = std::stoi(tk); }
+	break;
+	case 9:
+#line 21 "lel_parser.rl"
+	{ cur.expand = true; }
+	break;
+	case 10:
+#line 22 "lel_parser.rl"
+	{ cur.center = true; }
+	break;
+	case 11:
+#line 23 "lel_parser.rl"
+	{ cur.percent = true; }
+	break;
+	case 12:
+#line 33 "lel_parser.rl"
+	{ start = p; }
+	break;
+	case 13:
+#line 36 "lel_parser.rl"
+	{start = p;}
+	break;
+#line 209 "lel_parser.cpp"
+		}
+	}
+
+_again:
+	if ( cs == 0 )
+		goto _out;
+	if ( ++p != pe )
+		goto _resume;
+	_test_eof: {}
+	_out: {}
+	}
+
+#line 55 "lel_parser.rl"
+
+  bool good = pe - p == 0;
+  if(good) {
+    finalize();
+  } else {
+    dbc::log("error at:");
+    std::cout << p;
+  }
+  return good;
+}
+
+}
diff --git a/lel_parser.rl b/lel_parser.rl
new file mode 100644
index 0000000..784d639
--- /dev/null
+++ b/lel_parser.rl
@@ -0,0 +1,66 @@
+#include "lel.hpp"
+#include <fmt/core.h>
+#include <iostream>
+
+namespace lel {
+
+%%{
+  machine Parser;
+  alphtype char;
+
+  action token {tk = input.substr(start - begin, fpc - start); }
+
+  action col {}
+  action ltab { grid.push_back(Row()); }
+  action valign { cur.bottom = fc == '.'; }
+  action id { id(input.substr(start - begin, fpc - start)); }
+  action row { cur.col = 0; cur.row++; }
+  action align { cur.right = fc == '>'; }
+  action setwidth {cur.max_w = std::stoi(tk); }
+  action setheight { cur.max_h = std::stoi(tk); }
+  action expand { cur.expand = true; }
+  action center { cur.center = true; }
+  action percent { cur.percent = true; }
+
+  col = "|" $col;
+  ltab = "[" $ltab;
+  rtab = "]" $row;
+  valign = ("^" | ".") $valign;
+  expand = "*" $expand;
+  center = "=" $center;
+  percent = "%" $percent;
+  halign = ("<" | ">") $align;
+  number =  digit+ >{ start = fpc; } %token;
+  setw = ("(" number %setwidth ("," number %setheight)? ")") ;
+  modifiers = (percent | center | expand | valign | halign | setw);
+  id = modifiers* ((alpha | '_')+ :>> (alnum | '_')*) >{start = fpc;} %id;
+  row = space* ltab space* id space* (col space* id space*)* space* rtab space*;
+
+  main := row+;
+}%%
+
+%% write data;
+
+bool Parser::parse(std::string input) {
+  reset();
+  int cs = 0;
+  const char *start = nullptr;
+  const char *begin = input.data();
+  const char *p = input.data();
+  const char *pe = p + input.size();
+  std::string tk;
+
+  %% write init;
+  %% write exec;
+
+  bool good = pe - p == 0;
+  if(good) {
+    finalize();
+  } else {
+    dbc::log("error at:");
+    std::cout << p;
+  }
+  return good;
+}
+
+}
diff --git a/meson.build b/meson.build
new file mode 100644
index 0000000..fd2e3d7
--- /dev/null
+++ b/meson.build
@@ -0,0 +1,91 @@
+# clang might need _LIBCPP_ENABLE_CXX26_REMOVED_CODECVT
+
+project('lel-guecs', 'cpp',
+  version: '0.1.0',
+  default_options: [
+    'cpp_std=c++20',
+    'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1',
+  ])
+
+# use this for common options only for our executables
+cpp_args=[]
+link_args=[]
+# these are passed as override_defaults
+exe_defaults = [ 'warning_level=2' ]
+
+cc = meson.get_compiler('cpp')
+dependencies = []
+
+if build_machine.system() == 'windows'
+  add_global_link_arguments(
+    '-static-libgcc',
+    '-static-libstdc++',
+    '-static',
+    language: 'cpp',
+  )
+
+  sfml_main = dependency('sfml_main')
+  opengl32 = cc.find_library('opengl32', required: true)
+  winmm = cc.find_library('winmm', required: true)
+  gdi32 = cc.find_library('gdi32', required: true)
+
+  dependencies += [
+      opengl32, winmm, gdi32, sfml_main
+  ]
+  exe_defaults += ['werror=true']
+
+elif build_machine.system() == 'darwin'
+  add_global_link_arguments(
+    language: 'cpp',
+  )
+
+  opengl = dependency('OpenGL')
+  corefoundation = dependency('CoreFoundation')
+  carbon = dependency('Carbon')
+  cocoa = dependency('Cocoa')
+  iokit = dependency('IOKit')
+  corevideo = dependency('CoreVideo')
+
+  link_args += ['-ObjC']
+  exe_defaults += ['werror=false']
+  dependencies += [
+    opengl, corefoundation, carbon, cocoa, iokit, corevideo
+  ]
+endif
+
+catch2 = subproject('catch2').get_variable('catch2_with_main_dep')
+fmt = subproject('fmt').get_variable('fmt_dep')
+json = subproject('nlohmann_json').get_variable('nlohmann_json_dep')
+freetype2 = subproject('freetype2').get_variable('freetype_dep')
+
+flac = subproject('flac').get_variable('flac_dep')
+ogg = subproject('ogg').get_variable('libogg_dep')
+vorbis = subproject('vorbis').get_variable('vorbis_dep')
+vorbisfile = subproject('vorbis').get_variable('vorbisfile_dep')
+vorbisenc = subproject('vorbis').get_variable('vorbisenc_dep')
+sfml_audio = subproject('sfml').get_variable('sfml_audio_dep')
+sfml_graphics = subproject('sfml').get_variable('sfml_graphics_dep')
+sfml_network = subproject('sfml').get_variable('sfml_network_dep')
+sfml_system = subproject('sfml').get_variable('sfml_system_dep')
+sfml_window = subproject('sfml').get_variable('sfml_window_dep')
+
+dependencies += [
+  fmt, json, freetype2,
+  flac, ogg, vorbis, vorbisfile, vorbisenc,
+  sfml_audio, sfml_graphics,
+  sfml_network, sfml_system,
+  sfml_window
+]
+
+sources = [
+  'dbc.cpp',
+  'lel.cpp'
+]
+
+executable('runtests', sources + [
+  'tests/lel.cpp',
+  ],
+  cpp_args: cpp_args,
+  link_args: link_args,
+  override_options: exe_defaults,
+  dependencies: dependencies + [catch2])
diff --git a/scripts/coverage_report.ps1 b/scripts/coverage_report.ps1
new file mode 100644
index 0000000..79e38de
--- /dev/null
+++ b/scripts/coverage_report.ps1
@@ -0,0 +1,13 @@
+rm -recurse -force coverage/*
+cp *.cpp,*.hpp,*.rl builddir
+
+. .venv/Scripts/activate
+
+rm -recurse -force coverage
+cp scripts\gcovr_patched_coverage.py .venv\Lib\site-packages\gcovr\coverage.py
+
+gcovr -o coverage/ --html --html-details  --html-theme github.dark-blue --gcov-ignore-errors all --gcov-ignore-parse-errors negative_hits.warn_once_per_file -e builddir/subprojects -e builddir -e subprojects -j 10 .
+
+rm *.gcov.json.gz
+
+start .\coverage\coverage_details.html
diff --git a/scripts/coverage_reset.ps1 b/scripts/coverage_reset.ps1
new file mode 100644
index 0000000..4799ae6
--- /dev/null
+++ b/scripts/coverage_reset.ps1
@@ -0,0 +1,7 @@
+mv .\subprojects\packagecache .
+rm -recurse -force .\subprojects\,.\builddir\
+mkdir subprojects
+mv .\packagecache .\subprojects\
+mkdir builddir
+cp wraps\*.wrap subprojects\
+meson setup --default-library=static --prefer-static -Db_coverage=true builddir
diff --git a/scripts/coverage_reset.sh b/scripts/coverage_reset.sh
new file mode 100644
index 0000000..9970738
--- /dev/null
+++ b/scripts/coverage_reset.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -e
+
+mv -f ./subprojects/packagecache .
+rm -rf subprojects builddir
+mkdir subprojects
+mv packagecache ./subprojects/
+mkdir builddir
+cp wraps/*.wrap subprojects/
+# on OSX you can't do this with static
+meson setup -Db_coverage=true builddir
diff --git a/scripts/gcovr_patched_coverage.py b/scripts/gcovr_patched_coverage.py
new file mode 100644
index 0000000..7baecca
--- /dev/null
+++ b/scripts/gcovr_patched_coverage.py
@@ -0,0 +1,1020 @@
+# -*- coding:utf-8 -*-
+
+#  ************************** Copyrights and license ***************************
+#
+# This file is part of gcovr 8.3, a parsing and reporting tool for gcov.
+# https://gcovr.com/en/8.3
+#
+# _____________________________________________________________________________
+#
+# Copyright (c) 2013-2025 the gcovr authors
+# Copyright (c) 2013 Sandia Corporation.
+# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+# the U.S. Government retains certain rights in this software.
+#
+# This software is distributed under the 3-clause BSD License.
+# For more information, see the README.rst file.
+#
+# ****************************************************************************
+
+"""
+The gcovr coverage data model.
+
+This module represents the core data structures
+and should not have dependencies on any other gcovr module,
+also not on the gcovr.utils module.
+
+The data model should contain the exact same information
+as the JSON input/output format.
+
+The types ending with ``*Coverage``
+contain per-project/-line/-decision/-branch coverage.
+
+The types ``SummarizedStats``, ``CoverageStat``, and ``DecisionCoverageStat``
+report aggregated metrics/percentages.
+"""
+
+from __future__ import annotations
+import logging
+import os
+import re
+from typing import (
+    ItemsView,
+    Iterator,
+    Iterable,
+    Optional,
+    TypeVar,
+    Union,
+    Literal,
+    ValuesView,
+)
+from dataclasses import dataclass
+
+from .utils import commonpath, force_unix_separator
+
+LOGGER = logging.getLogger("gcovr")
+
+_T = TypeVar("_T")
+
+
+def sort_coverage(
+    covdata: Union[
+        dict[str, FileCoverage],
+        dict[str, Union[FileCoverage, CoverageContainerDirectory]],
+    ],
+    sort_key: Literal["filename", "uncovered-number", "uncovered-percent"],
+    sort_reverse: bool,
+    by_metric: Literal["line", "branch", "decision"],
+    filename_uses_relative_pathname: bool = False,
+) -> list[str]:
+    """Sort a coverage dict.
+
+    covdata (dict): the coverage dictionary
+    sort_key ("filename", "uncovered-number", "uncovered-percent"): the values to sort by
+    sort_reverse (bool): reverse order if True
+    by_metric ("line", "branch", "decision"): select the metric to sort
+    filename_uses_relative_pathname (bool): for html, we break down a pathname to the
+        relative path, but not for other formats.
+
+    returns: the sorted keys
+    """
+
+    basedir = commonpath(list(covdata.keys()))
+
+    def key_filename(key: str) -> list[Union[int, str]]:
+        def convert_to_int_if_possible(text: str) -> Union[int, str]:
+            return int(text) if text.isdigit() else text
+
+        key = (
+            force_unix_separator(
+                os.path.relpath(os.path.realpath(key), os.path.realpath(basedir))
+            )
+            if filename_uses_relative_pathname
+            else key
+        ).casefold()
+
+        return [convert_to_int_if_possible(part) for part in re.split(r"([0-9]+)", key)]
+
+    def coverage_stat(key: str) -> CoverageStat:
+        cov = covdata[key]
+        if by_metric == "branch":
+            return cov.branch_coverage()
+        if by_metric == "decision":
+            return cov.decision_coverage().to_coverage_stat
+        return cov.line_coverage()
+
+    def key_num_uncovered(key: str) -> int:
+        stat = coverage_stat(key)
+        uncovered = stat.total - stat.covered
+        return uncovered
+
+    def key_percent_uncovered(key: str) -> float:
+        stat = coverage_stat(key)
+        covered = stat.covered
+        total = stat.total
+
+        # No branches are always put directly after (or before when reversed)
+        # files with 100% coverage (by assigning such files 110% coverage)
+        return covered / total if total > 0 else 1.1
+
+    if sort_key == "uncovered-number":
+        # First sort filename alphabetical and then by the requested key
+        return sorted(
+            sorted(covdata, key=key_filename),
+            key=key_num_uncovered,
+            reverse=sort_reverse,
+        )
+    if sort_key == "uncovered-percent":
+        # First sort filename alphabetical and then by the requested key
+        return sorted(
+            sorted(covdata, key=key_filename),
+            key=key_percent_uncovered,
+            reverse=sort_reverse,
+        )
+
+    # By default, we sort by filename alphabetically
+    return sorted(covdata, key=key_filename, reverse=sort_reverse)
+
+
+class BranchCoverage:
+    r"""Represent coverage information about a branch.
+
+    Args:
+        source_block_id (int):
+            The block number.
+        count (int):
+            Number of times this branch was followed.
+        fallthrough (bool, optional):
+            Whether this is a fallthrough branch. False if unknown.
+        throw (bool, optional):
+            Whether this is an exception-handling branch. False if unknown.
+        destination_block_id (int, optional):
+            The destination block of the branch. None if unknown.
+        excluded (bool, optional):
+            Whether the branch is excluded.
+    """
+
+    first_undefined_source_block_id: bool = True
+
+    __slots__ = (
+        "source_block_id",
+        "count",
+        "fallthrough",
+        "throw",
+        "destination_block_id",
+        "excluded",
+    )
+
+    def __init__(
+        self,
+        source_block_id: Optional[int],
+        count: int,
+        fallthrough: bool = False,
+        throw: bool = False,
+        destination_block_id: Optional[int] = None,
+        excluded: Optional[bool] = None,
+    ) -> None:
+        if count < 0:
+            raise AssertionError("count must not be a negative value.")
+
+        self.source_block_id = source_block_id
+        self.count = count
+        self.fallthrough = fallthrough
+        self.throw = throw
+        self.destination_block_id = destination_block_id
+        self.excluded = excluded
+
+    @property
+    def source_block_id_or_0(self) -> int:
+        """Get a valid block number (0) if there was no definition in GCOV file."""
+        if self.source_block_id is None:
+            self.source_block_id = 0
+            if BranchCoverage.first_undefined_source_block_id:
+                BranchCoverage.first_undefined_source_block_id = False
+                LOGGER.info("No block number defined, assuming 0 for all undefined")
+
+        return self.source_block_id
+
+    @property
+    def is_excluded(self) -> bool:
+        """Return True if the branch is excluded."""
+        return False if self.excluded is None else self.excluded
+
+    @property
+    def is_reportable(self) -> bool:
+        """Return True if the branch is reportable."""
+        return not self.excluded
+
+    @property
+    def is_covered(self) -> bool:
+        """Return True if the branch is covered."""
+        return self.is_reportable and self.count > 0
+
+
+class CallCoverage:
+    r"""Represent coverage information about a call.
+
+    Args:
+        callno (int):
+            The number of the call.
+        covered (bool):
+            Whether the call was performed.
+        excluded (bool, optional):
+            Whether the call is excluded.
+    """
+
+    __slots__ = "callno", "covered", "excluded"
+
+    def __init__(
+        self,
+        callno: int,
+        covered: bool,
+        excluded: Optional[bool] = False,
+    ) -> None:
+        self.callno = callno
+        self.covered = covered
+        self.excluded = excluded
+
+    @property
+    def is_reportable(self) -> bool:
+        """Return True if the call is reportable."""
+        return not self.excluded
+
+    @property
+    def is_covered(self) -> bool:
+        """Return True if the call is covered."""
+        return self.is_reportable and self.covered
+
+
+class ConditionCoverage:
+    r"""Represent coverage information about a condition.
+
+    Args:
+        count (int):
+            The number of the call.
+        covered (int):
+            Whether the call was performed.
+        not_covered_true list[int]:
+            The conditions which were not true.
+        not_covered_false list[int]:
+            The conditions which were not false.
+        excluded (bool, optional):
+            Whether the condition is excluded.
+    """
+
+    __slots__ = "count", "covered", "not_covered_true", "not_covered_false", "excluded"
+
+    def __init__(
+        self,
+        count: int,
+        covered: int,
+        not_covered_true: list[int],
+        not_covered_false: list[int],
+        excluded: Optional[bool] = False,
+    ) -> None:
+        if count < 0:
+            raise AssertionError("count must not be a negative value.")
+        if count < covered:
+            raise AssertionError("count must not be less than covered.")
+        self.count = count
+        self.covered = covered
+        self.not_covered_true = not_covered_true
+        self.not_covered_false = not_covered_false
+        self.excluded = excluded
+
+
+class DecisionCoverageUncheckable:
+    r"""Represent coverage information about a decision."""
+
+    __slots__ = ()
+
+    def __init__(self) -> None:
+        pass
+
+
+class DecisionCoverageConditional:
+    r"""Represent coverage information about a decision.
+
+    Args:
+        count_true (int):
+            Number of times this decision was made.
+
+        count_false (int):
+            Number of times this decision was made.
+
+    """
+
+    __slots__ = "count_true", "count_false"
+
+    def __init__(self, count_true: int, count_false: int) -> None:
+        if count_true < 0:
+            raise AssertionError("count_true must not be a negative value.")
+        self.count_true = count_true
+        if count_false < 0:
+            raise AssertionError("count_true must not be a negative value.")
+        self.count_false = count_false
+
+
+class DecisionCoverageSwitch:
+    r"""Represent coverage information about a decision.
+
+    Args:
+        count (int):
+            Number of times this decision was made.
+    """
+
+    __slots__ = ("count",)
+
+    def __init__(self, count: int) -> None:
+        if count < 0:
+            raise AssertionError("count must not be a negative value.")
+        self.count = count
+
+
+DecisionCoverage = Union[
+    DecisionCoverageConditional,
+    DecisionCoverageSwitch,
+    DecisionCoverageUncheckable,
+]
+
+
+class FunctionCoverage:
+    r"""Represent coverage information about a function.
+
+    The counter is stored as dictionary with the line as key to be able
+    to merge function coverage in different ways
+
+    Args:
+        name (str):
+            The mangled name of the function, None if not available.
+        demangled_name (str):
+            The demangled name (signature) of the functions.
+        lineno (int):
+            The line number.
+        count (int):
+            How often this function was executed.
+        blocks (float):
+            Block coverage of function.
+        start ((int, int)), optional):
+            Tuple with function start line and column.
+        end ((int, int)), optional):
+            Tuple with function end line and column.
+        excluded (bool, optional):
+            Whether this line is excluded by a marker.
+    """
+
+    __slots__ = (
+        "name",
+        "demangled_name",
+        "count",
+        "blocks",
+        "start",
+        "end",
+        "excluded",
+    )
+
+    def __init__(
+        self,
+        name: Optional[str],
+        demangled_name: str,
+        *,
+        lineno: int,
+        count: int,
+        blocks: float,
+        start: Optional[tuple[int, int]] = None,
+        end: Optional[tuple[int, int]] = None,
+        excluded: bool = False,
+    ) -> None:
+        if count < 0: count = 0
+        self.name = name
+        self.demangled_name = demangled_name
+        self.count = dict[int, int]({lineno: count})
+        self.blocks = dict[int, float]({lineno: blocks})
+        self.excluded = dict[int, bool]({lineno: excluded})
+        self.start: Optional[dict[int, tuple[int, int]]] = (
+            None if start is None else {lineno: start}
+        )
+        self.end: Optional[dict[int, tuple[int, int]]] = (
+            None if end is None else {lineno: end}
+        )
+
+
+class LineCoverage:
+    r"""Represent coverage information about a line.
+
+    Each line is either *excluded* or *reportable*.
+
+    A *reportable* line is either *covered* or *uncovered*.
+
+    The default state of a line is *coverable*/*reportable*/*uncovered*.
+
+    Args:
+        lineno (int):
+            The line number.
+        count (int):
+            How often this line was executed at least partially.
+        function_name (str, optional):
+            Mangled name of the function the line belongs to.
+        block_ids (*int, optional):
+            List of block ids in this line
+        excluded (bool, optional):
+            Whether this line is excluded by a marker.
+        md5 (str, optional):
+            The md5 checksum of the source code line.
+    """
+
+    __slots__ = (
+        "lineno",
+        "count",
+        "function_name",
+        "block_ids",
+        "excluded",
+        "md5",
+        "branches",
+        "conditions",
+        "decision",
+        "calls",
+    )
+
+    def __init__(
+        self,
+        lineno: int,
+        count: int,
+        function_name: Optional[str] = None,
+        block_ids: Optional[list[int]] = None,
+        md5: Optional[str] = None,
+        excluded: bool = False,
+    ) -> None:
+        if lineno <= 0:
+            raise AssertionError("Line number must be a positive value.")
+        if count < 0:
+            raise AssertionError("count must not be a negative value.")
+
+        self.lineno: int = lineno
+        self.count: int = count
+        self.function_name: Optional[str] = function_name
+        self.block_ids: Optional[list[int]] = block_ids
+        self.md5: Optional[str] = md5
+        self.excluded: bool = excluded
+        self.branches = dict[int, BranchCoverage]()
+        self.conditions = dict[int, ConditionCoverage]()
+        self.decision: Optional[DecisionCoverage] = None
+        self.calls = dict[int, CallCoverage]()
+
+    @property
+    def is_excluded(self) -> bool:
+        """Return True if the line is excluded."""
+        return self.excluded
+
+    @property
+    def is_reportable(self) -> bool:
+        """Return True if the line is reportable."""
+        return not self.excluded
+
+    @property
+    def is_covered(self) -> bool:
+        """Return True if the line is covered."""
+        return self.is_reportable and self.count > 0
+
+    @property
+    def is_uncovered(self) -> bool:
+        """Return True if the line is uncovered."""
+        return self.is_reportable and self.count == 0
+
+    @property
+    def has_uncovered_branch(self) -> bool:
+        """Return True if the line has a uncovered branches."""
+        return not all(
+            branchcov.is_covered or branchcov.is_excluded
+            for branchcov in self.branches.values()
+        )
+
+    @property
+    def has_uncovered_decision(self) -> bool:
+        """Return True if the line has a uncovered decision."""
+        if self.decision is None:
+            return False
+
+        if isinstance(self.decision, DecisionCoverageUncheckable):
+            return False
+
+        if isinstance(self.decision, DecisionCoverageConditional):
+            return self.decision.count_true == 0 or self.decision.count_false == 0
+
+        if isinstance(self.decision, DecisionCoverageSwitch):
+            return self.decision.count == 0
+
+        raise AssertionError(f"Unknown decision type: {self.decision!r}")
+
+    def exclude(self) -> None:
+        """Exclude line from coverage statistic."""
+        self.excluded = True
+        self.count = 0
+        self.branches.clear()
+        self.conditions.clear()
+        self.decision = None
+        self.calls.clear()
+
+    def branch_coverage(self) -> CoverageStat:
+        """Return the branch coverage statistic of the line."""
+        total = 0
+        covered = 0
+        for branchcov in self.branches.values():
+            if branchcov.is_reportable:
+                total += 1
+                if branchcov.is_covered:
+                    covered += 1
+        return CoverageStat(covered=covered, total=total)
+
+    def condition_coverage(self) -> CoverageStat:
+        """Return the condition coverage statistic of the line."""
+        total = 0
+        covered = 0
+        for condition in self.conditions.values():
+            total += condition.count
+            covered += condition.covered
+        return CoverageStat(covered=covered, total=total)
+
+    def decision_coverage(self) -> DecisionCoverageStat:
+        """Return the decision coverage statistic of the line."""
+        if self.decision is None:
+            return DecisionCoverageStat(0, 0, 0)
+
+        if isinstance(self.decision, DecisionCoverageUncheckable):
+            return DecisionCoverageStat(0, 1, 2)  # TODO should it be uncheckable=2?
+
+        if isinstance(self.decision, DecisionCoverageConditional):
+            covered = 0
+            if self.decision.count_true > 0:
+                covered += 1
+            if self.decision.count_false > 0:
+                covered += 1
+            return DecisionCoverageStat(covered, 0, 2)
+
+        if isinstance(self.decision, DecisionCoverageSwitch):
+            covered = 0
+            if self.decision.count > 0:
+                covered += 1
+            return DecisionCoverageStat(covered, 0, 1)
+
+        raise AssertionError(f"Unknown decision type: {self.decision!r}")
+
+
+class FileCoverage:
+    """Represent coverage information about a file."""
+
+    __slots__ = "filename", "functions", "lines", "data_sources"
+
+    def __init__(
+        self, filename: str, data_source: Optional[Union[str, set[str]]]
+    ) -> None:
+        self.filename: str = filename
+        self.functions = dict[str, FunctionCoverage]()
+        self.lines = dict[int, LineCoverage]()
+        self.data_sources = (
+            set[str]()
+            if data_source is None
+            else set[str](
+                [data_source] if isinstance(data_source, str) else data_source
+            )
+        )
+
+    def filter_for_function(self, functioncov: FunctionCoverage) -> FileCoverage:
+        """Get a file coverage object reduced to a single function"""
+        if functioncov.name not in self.functions:
+            raise AssertionError(
+                f"Function {functioncov.name} must be in filtered file coverage object."
+            )
+        if functioncov.name is None:
+            raise AssertionError(
+                "Data for filtering is missing. Need supported GCOV JSON format to get the information."
+            )
+        filecov = FileCoverage(self.filename, self.data_sources)
+        filecov.functions[functioncov.name] = functioncov
+
+        filecov.lines = {
+            lineno: linecov
+            for lineno, linecov in self.lines.items()
+            if linecov.function_name == functioncov.name
+        }
+
+        return filecov
+
+    @property
+    def stats(self) -> SummarizedStats:
+        """Create a coverage statistic of a file coverage object."""
+        return SummarizedStats(
+            line=self.line_coverage(),
+            branch=self.branch_coverage(),
+            condition=self.condition_coverage(),
+            decision=self.decision_coverage(),
+            function=self.function_coverage(),
+            call=self.call_coverage(),
+        )
+
+    def function_coverage(self) -> CoverageStat:
+        """Return the function coverage statistic of the file."""
+        total = 0
+        covered = 0
+
+        for functioncov in self.functions.values():
+            for lineno, excluded in functioncov.excluded.items():
+                if not excluded:
+                    total += 1
+                    if functioncov.count[lineno] > 0:
+                        covered += 1
+
+        return CoverageStat(covered, total)
+
+    def line_coverage(self) -> CoverageStat:
+        """Return the line coverage statistic of the file."""
+        total = 0
+        covered = 0
+
+        for linecov in self.lines.values():
+            if linecov.is_reportable:
+                total += 1
+                if linecov.is_covered:
+                    covered += 1
+
+        return CoverageStat(covered, total)
+
+    def branch_coverage(self) -> CoverageStat:
+        """Return the branch coverage statistic of the file."""
+        stat = CoverageStat.new_empty()
+
+        for linecov in self.lines.values():
+            if linecov.is_reportable:
+                stat += linecov.branch_coverage()
+
+        return stat
+
+    def condition_coverage(self) -> CoverageStat:
+        """Return the condition coverage statistic of the file."""
+        stat = CoverageStat.new_empty()
+
+        for linecov in self.lines.values():
+            if linecov.is_reportable:
+                stat += linecov.condition_coverage()
+
+        return stat
+
+    def decision_coverage(self) -> DecisionCoverageStat:
+        """Return the decision coverage statistic of the file."""
+        stat = DecisionCoverageStat.new_empty()
+
+        for linecov in self.lines.values():
+            if linecov.is_reportable:
+                stat += linecov.decision_coverage()
+
+        return stat
+
+    def call_coverage(self) -> CoverageStat:
+        """Return the call coverage statistic of the file."""
+        covered = 0
+        total = 0
+
+        for linecov in self.lines.values():
+            if linecov.is_reportable and len(linecov.calls) > 0:
+                for callcov in linecov.calls.values():
+                    if callcov.is_reportable:
+                        total += 1
+                        if callcov.is_covered:
+                            covered += 1
+
+        return CoverageStat(covered, total)
+
+
+class CoverageContainer:
+    """Coverage container holding all the coverage data."""
+
+    def __init__(self) -> None:
+        self.data = dict[str, FileCoverage]()
+        self.directories = list[CoverageContainerDirectory]()
+
+    def __getitem__(self, key: str) -> FileCoverage:
+        return self.data[key]
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.data
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.data)
+
+    def values(self) -> ValuesView[FileCoverage]:
+        """Get the file coverage data objects."""
+        return self.data.values()
+
+    def items(self) -> ItemsView[str, FileCoverage]:
+        """Get the file coverage data items."""
+        return self.data.items()
+
+    @property
+    def stats(self) -> SummarizedStats:
+        """Create a coverage statistic from a coverage data object."""
+        stats = SummarizedStats.new_empty()
+        for filecov in self.values():
+            stats += filecov.stats
+        return stats
+
+    def sort_coverage(
+        self,
+        sort_key: Literal["filename", "uncovered-number", "uncovered-percent"],
+        sort_reverse: bool,
+        by_metric: Literal["line", "branch", "decision"],
+        filename_uses_relative_pathname: bool = False,
+    ) -> list[str]:
+        """Sort the coverage data"""
+        return sort_coverage(
+            self.data,
+            sort_key,
+            sort_reverse,
+            by_metric,
+            filename_uses_relative_pathname,
+        )
+
+    @staticmethod
+    def _get_dirname(filename: str) -> Optional[str]:
+        """Get the directory name with a trailing path separator.
+
+        >>> import os
+        >>> CoverageContainer._get_dirname("bar/foobar.cpp".replace("/", os.sep)).replace(os.sep, "/")
+        'bar/'
+        >>> CoverageContainer._get_dirname("/foo/bar/A/B.cpp".replace("/", os.sep)).replace(os.sep, "/")
+        '/foo/bar/A/'
+        >>> CoverageContainer._get_dirname(os.sep) is None
+        True
+        """
+        if filename == os.sep:
+            return None
+        return str(os.path.dirname(filename.rstrip(os.sep))) + os.sep
+
+    def populate_directories(
+        self, sorted_keys: Iterable[str], root_filter: re.Pattern[str]
+    ) -> None:
+        r"""Populate the list of directories and add accumulated stats.
+
+        This function will accumulate statistics such that every directory
+        above it will know the statistics associated with all files deep within a
+        directory structure.
+
+        Args:
+            sorted_keys: The sorted keys for covdata
+            root_filter: Information about the filter used with the root directory
+        """
+
+        # Get the directory coverage
+        subdirs = dict[str, CoverageContainerDirectory]()
+        for key in sorted_keys:
+            filecov = self[key]
+            dircov: Optional[CoverageContainerDirectory] = None
+            dirname: Optional[str] = (
+                os.path.dirname(filecov.filename)
+                .replace("\\", os.sep)
+                .replace("/", os.sep)
+                .rstrip(os.sep)
+            ) + os.sep
+            while dirname is not None and root_filter.search(dirname + os.sep):
+                if dirname not in subdirs:
+                    subdirs[dirname] = CoverageContainerDirectory(dirname)
+                if dircov is None:
+                    subdirs[dirname][filecov.filename] = filecov
+                else:
+                    subdirs[dirname].data[dircov.filename] = dircov
+                    subdirs[dircov.filename].parent_dirname = dirname
+                subdirs[dirname].stats += filecov.stats
+                dircov = subdirs[dirname]
+                dirname = CoverageContainer._get_dirname(dirname)
+
+        # Replace directories where only one sub container is available
+        # with the content this sub container
+        LOGGER.debug(
+            "Replace directories with only one sub element with the content of this."
+        )
+        subdirs_to_remove = set()
+        for dirname, covdata_dir in subdirs.items():
+            # There is exact one element, replace current element with referenced element
+            if len(covdata_dir) == 1:
+                # Get the orphan item
+                orphan_key, orphan_value = next(iter(covdata_dir.items()))
+                # The only child is a File object
+                if isinstance(orphan_value, FileCoverage):
+                    # Replace the reference to ourself with our content
+                    if covdata_dir.parent_dirname is not None:
+                        LOGGER.debug(
+                            f"Move {orphan_key} to {covdata_dir.parent_dirname}."
+                        )
+                        parent_covdata_dir = subdirs[covdata_dir.parent_dirname]
+                        parent_covdata_dir[orphan_key] = orphan_value
+                        del parent_covdata_dir[dirname]
+                        subdirs_to_remove.add(dirname)
+                else:
+                    LOGGER.debug(
+                        f"Move content of {orphan_value.dirname} to {dirname}."
+                    )
+                    # Replace the children with the orphan ones
+                    covdata_dir.data = orphan_value.data
+                    # Change the parent key of each new child element
+                    for new_child_value in covdata_dir.values():
+                        if isinstance(new_child_value, CoverageContainerDirectory):
+                            new_child_value.parent_dirname = dirname
+                    # Mark the key for removal.
+                    subdirs_to_remove.add(orphan_key)
+
+        for dirname in subdirs_to_remove:
+            del subdirs[dirname]
+
+        self.directories = list(subdirs.values())
+
+
+class CoverageContainerDirectory:
+    """Represent coverage information about a directory."""
+
+    __slots__ = "dirname", "parent_dirname", "data", "stats"
+
+    def __init__(self, dirname: str) -> None:
+        super().__init__()
+        self.dirname: str = dirname
+        self.parent_dirname: Optional[str] = None
+        self.data = dict[str, Union[FileCoverage, CoverageContainerDirectory]]()
+        self.stats: SummarizedStats = SummarizedStats.new_empty()
+
+    def __setitem__(
+        self, key: str, item: Union[FileCoverage, CoverageContainerDirectory]
+    ) -> None:
+        self.data[key] = item
+
+    def __getitem__(self, key: str) -> Union[FileCoverage, CoverageContainerDirectory]:
+        return self.data[key]
+
+    def __delitem__(self, key: str) -> None:
+        del self.data[key]
+
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def values(self) -> ValuesView[Union[FileCoverage, CoverageContainerDirectory]]:
+        """Get the file coverage data objects."""
+        return self.data.values()
+
+    def items(self) -> ItemsView[str, Union[FileCoverage, CoverageContainerDirectory]]:
+        """Get the file coverage data items."""
+        return self.data.items()
+
+    @property
+    def filename(self) -> str:
+        """Helpful function for when we use this DirectoryCoverage in a union with FileCoverage"""
+        return self.dirname
+
+    def sort_coverage(
+        self,
+        sort_key: Literal["filename", "uncovered-number", "uncovered-percent"],
+        sort_reverse: bool,
+        by_metric: Literal["line", "branch", "decision"],
+        filename_uses_relative_pathname: bool = False,
+    ) -> list[str]:
+        """Sort the coverage data"""
+        return sort_coverage(
+            self.data,
+            sort_key,
+            sort_reverse,
+            by_metric,
+            filename_uses_relative_pathname,
+        )
+
+    def line_coverage(self) -> CoverageStat:
+        """A simple wrapper function necessary for sort_coverage()."""
+        return self.stats.line
+
+    def branch_coverage(self) -> CoverageStat:
+        """A simple wrapper function necessary for sort_coverage()."""
+        return self.stats.branch
+
+    def decision_coverage(self) -> DecisionCoverageStat:
+        """A simple wrapper function necessary for sort_coverage()."""
+        return self.stats.decision
+
+
+@dataclass
+class SummarizedStats:
+    """Data class for the summarized coverage statistics."""
+
+    line: CoverageStat
+    branch: CoverageStat
+    condition: CoverageStat
+    decision: DecisionCoverageStat
+    function: CoverageStat
+    call: CoverageStat
+
+    @staticmethod
+    def new_empty() -> SummarizedStats:
+        """Create a empty coverage statistic."""
+        return SummarizedStats(
+            line=CoverageStat.new_empty(),
+            branch=CoverageStat.new_empty(),
+            condition=CoverageStat.new_empty(),
+            decision=DecisionCoverageStat.new_empty(),
+            function=CoverageStat.new_empty(),
+            call=CoverageStat.new_empty(),
+        )
+
+    def __iadd__(self, other: SummarizedStats) -> SummarizedStats:
+        self.line += other.line
+        self.branch += other.branch
+        self.condition += other.condition
+        self.decision += other.decision
+        self.function += other.function
+        self.call += other.call
+        return self
+
+
+@dataclass
+class CoverageStat:
+    """A single coverage metric, e.g. the line coverage percentage of a file."""
+
+    covered: int
+    """How many elements were covered."""
+
+    total: int
+    """How many elements there were in total."""
+
+    @staticmethod
+    def new_empty() -> CoverageStat:
+        """Create a empty coverage statistic."""
+        return CoverageStat(0, 0)
+
+    @property
+    def percent(self) -> Optional[float]:
+        """Percentage of covered elements, equivalent to ``self.percent_or(None)``"""
+        return self.percent_or(None)
+
+    def percent_or(self, default: _T) -> Union[float, _T]:
+        """Percentage of covered elements.
+
+        Coverage is truncated to one decimal:
+        >>> CoverageStat(1234, 10000).percent_or("default")
+        12.3
+
+        Coverage is capped at 99.9% unless everything is covered:
+        >>> CoverageStat(9999, 10000).percent_or("default")
+        99.9
+        >>> CoverageStat(10000, 10000).percent_or("default")
+        100.0
+
+        If there are no elements, percentage is NaN and the default will be returned:
+        >>> CoverageStat(0, 0).percent_or("default")
+        'default'
+        """
+        if not self.total:
+            return default
+
+        # Return 100% only if covered == total.
+        if self.covered == self.total:
+            return 100.0
+
+        # There is at least one uncovered item.
+        # Round to 1 decimal and clamp to max 99.9%.
+        ratio = self.covered / self.total
+        return min(99.9, round(ratio * 100.0, 1))
+
+    def __iadd__(self, other: CoverageStat) -> CoverageStat:
+        self.covered += other.covered
+        self.total += other.total
+        return self
+
+
+@dataclass
+class DecisionCoverageStat:
+    """A CoverageStat for decision coverage (accounts for Uncheckable cases)."""
+
+    covered: int
+    uncheckable: int
+    total: int
+
+    @classmethod
+    def new_empty(cls) -> DecisionCoverageStat:
+        """Create a empty decision coverage statistic."""
+        return cls(0, 0, 0)
+
+    @property
+    def to_coverage_stat(self) -> CoverageStat:
+        """Convert a decision coverage statistic to a coverage statistic."""
+        return CoverageStat(covered=self.covered, total=self.total)
+
+    @property
+    def percent(self) -> Optional[float]:
+        """Return the percent value of the coverage."""
+        return self.to_coverage_stat.percent
+
+    def percent_or(self, default: _T) -> Union[float, _T]:
+        """Return the percent value of the coverage or the given default if no coverage is present."""
+        return self.to_coverage_stat.percent_or(default)
+
+    def __iadd__(self, other: DecisionCoverageStat) -> DecisionCoverageStat:
+        self.covered += other.covered
+        self.uncheckable += other.uncheckable
+        self.total += other.total
+        return self
diff --git a/scripts/reset_build.ps1 b/scripts/reset_build.ps1
new file mode 100644
index 0000000..975852d
--- /dev/null
+++ b/scripts/reset_build.ps1
@@ -0,0 +1,7 @@
+mv .\subprojects\packagecache .
+rm -recurse -force .\subprojects\,.\builddir\
+mkdir subprojects
+mv .\packagecache .\subprojects\
+mkdir builddir
+cp wraps\*.wrap subprojects\
+meson setup --default-library=static --prefer-static  builddir
diff --git a/scripts/reset_build.sh b/scripts/reset_build.sh
new file mode 100644
index 0000000..89931e7
--- /dev/null
+++ b/scripts/reset_build.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+mv -f ./subprojects/packagecache .
+rm -rf subprojects builddir
+mkdir subprojects
+mv -f packagecache ./subprojects/ && true
+mkdir builddir
+cp wraps/*.wrap subprojects/
+# on OSX you can't do this with static
+meson setup --default-library=static --prefer-static  builddir
diff --git a/scripts/win_installer.ifp b/scripts/win_installer.ifp
new file mode 100644
index 0000000..f1a9f29
Binary files /dev/null and b/scripts/win_installer.ifp differ
diff --git a/tests/guecs.cpp b/tests/guecs.cpp
new file mode 100644
index 0000000..3b41065
--- /dev/null
+++ b/tests/guecs.cpp
@@ -0,0 +1,32 @@
+#include <catch2/catch_test_macros.hpp>
+#include <fmt/core.h>
+#include "constants.hpp"
+#include "guecs.hpp"
+#include "textures.hpp"
+#include <fmt/xchar.h>
+
+using namespace guecs;
+
+TEST_CASE("prototype one gui", "[ecs-gui]") {
+  guecs::UI gui;
+  textures::init();
+
+  gui.position(0, 0, 1000, 500);
+  gui.layout("[test1|test2|test3][test4|_|test5]");
+
+  for(auto& [name, cell] : gui.cells()) {
+    auto button = gui.entity(name);
+    gui.set<lel::Cell>(button, cell);
+    gui.set<Rectangle>(button, {});
+    gui.set<Clickable>(button, {});
+    gui.set<Textual>(button, {L"whatever"});
+  }
+
+  gui.init();
+
+  // at this point it's mostly ready but I'd need to render it to a window real quick
+  sf::RenderWindow window;
+  window.setSize({SCREEN_WIDTH, SCREEN_HEIGHT});
+  gui.render(window);
+  window.display();
+}
diff --git a/tests/lel.cpp b/tests/lel.cpp
new file mode 100644
index 0000000..8898a23
--- /dev/null
+++ b/tests/lel.cpp
@@ -0,0 +1,52 @@
+#include "lel.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <fmt/core.h>
+#include <string>
+
+TEST_CASE("test basic ops", "[lel]") {
+  lel::Parser parser(0, 0, 500, 500);
+
+  bool good = parser.parse(
+     "[ label_1         | label3      | test1]"
+     "[ *(300,300)text1 | %(150)people | ^test2]"
+     "[ >label2         | _           | .test3]"
+     "[ =message        | buttons     | test4]");
+
+  REQUIRE(good);
+
+  for(size_t rowcount = 0; rowcount < parser.grid.size(); rowcount++) {
+    auto& row = parser.grid[rowcount];
+
+    for(size_t colcount = 0; colcount < row.size(); colcount++) {
+      auto &name = row[colcount];
+      if(name == "_") {
+        REQUIRE(!parser.cells.contains(name));
+      } else {
+        auto &cell = parser.cells.at(name);
+        REQUIRE(cell.row == int(rowcount));
+        REQUIRE(cell.col == int(colcount));
+      }
+    }
+  }
+
+  REQUIRE(parser.cells.size() == 11);
+  REQUIRE(parser.cells.at("label2").right == true);
+  REQUIRE(parser.cells.at("text1").expand == true);
+  REQUIRE(parser.cells.at("text1").w == 300);
+  REQUIRE(parser.cells.at("text1").h == 300);
+  REQUIRE(parser.cells.at("people").expand == false);
+  REQUIRE(parser.cells.at("message").expand == false);
+  REQUIRE(parser.cells.at("message").center == true);
+
+  for(auto& [name, cell] : parser.cells) {
+    REQUIRE(cell.w > 0);
+    REQUIRE(cell.h > 0);
+  }
+
+  auto hit = parser.hit(10, 10);
+  REQUIRE(*hit == "label_1");
+
+  auto nohit = parser.hit(1000, 1000);
+  REQUIRE(!nohit);
+  REQUIRE(nohit == std::nullopt);
+}
diff --git a/wraps/catch2.wrap b/wraps/catch2.wrap
new file mode 100644
index 0000000..f9bf436
--- /dev/null
+++ b/wraps/catch2.wrap
@@ -0,0 +1,11 @@
+[wrap-file]
+directory = Catch2-3.7.1
+source_url = https://github.com/catchorg/Catch2/archive/v3.7.1.tar.gz
+source_filename = Catch2-3.7.1.tar.gz
+source_hash = c991b247a1a0d7bb9c39aa35faf0fe9e19764213f28ffba3109388e62ee0269c
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/catch2_3.7.1-1/Catch2-3.7.1.tar.gz
+wrapdb_version = 3.7.1-1
+
+[provide]
+catch2 = catch2_dep
+catch2-with-main = catch2_with_main_dep
diff --git a/wraps/flac.wrap b/wraps/flac.wrap
new file mode 100644
index 0000000..ee36479
--- /dev/null
+++ b/wraps/flac.wrap
@@ -0,0 +1,13 @@
+[wrap-file]
+directory = flac-1.4.3
+source_url = https://github.com/xiph/flac/releases/download/1.4.3/flac-1.4.3.tar.xz
+source_filename = flac-1.4.3.tar.xz
+source_hash = 6c58e69cd22348f441b861092b825e591d0b822e106de6eb0ee4d05d27205b70
+patch_filename = flac_1.4.3-2_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/flac_1.4.3-2/get_patch
+patch_hash = 3eace1bd0769d3e0d4ff099960160766a5185d391c8f583293b087a1f96c2a9c
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/flac_1.4.3-2/flac-1.4.3.tar.xz
+wrapdb_version = 1.4.3-2
+
+[provide]
+flac = flac_dep
diff --git a/wraps/fmt.wrap b/wraps/fmt.wrap
new file mode 100644
index 0000000..fd50847
--- /dev/null
+++ b/wraps/fmt.wrap
@@ -0,0 +1,13 @@
+[wrap-file]
+directory = fmt-11.0.2
+source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz
+source_filename = fmt-11.0.2.tar.gz
+source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f
+patch_filename = fmt_11.0.2-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch
+patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz
+wrapdb_version = 11.0.2-1
+
+[provide]
+fmt = fmt_dep
diff --git a/wraps/freetype2.wrap b/wraps/freetype2.wrap
new file mode 100644
index 0000000..acad6f4
--- /dev/null
+++ b/wraps/freetype2.wrap
@@ -0,0 +1,11 @@
+[wrap-file]
+directory = freetype-2.13.3
+source_url = https://download.savannah.gnu.org/releases/freetype/freetype-2.13.3.tar.xz
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/freetype2_2.13.3-1/freetype-2.13.3.tar.xz
+source_filename = freetype-2.13.3.tar.xz
+source_hash = 0550350666d427c74daeb85d5ac7bb353acba5f76956395995311a9c6f063289
+wrapdb_version = 2.13.3-1
+
+[provide]
+freetype2 = freetype_dep
+freetype = freetype_dep
diff --git a/wraps/libpng.wrap b/wraps/libpng.wrap
new file mode 100644
index 0000000..06044a9
--- /dev/null
+++ b/wraps/libpng.wrap
@@ -0,0 +1,13 @@
+[wrap-file]
+directory = libpng-1.6.44
+source_url = https://github.com/glennrp/libpng/archive/v1.6.44.tar.gz
+source_filename = libpng-1.6.44.tar.gz
+source_hash = 0ef5b633d0c65f780c4fced27ff832998e71478c13b45dfb6e94f23a82f64f7c
+patch_filename = libpng_1.6.44-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/libpng_1.6.44-1/get_patch
+patch_hash = 394b07614c45fbd1beac8b660386216a490fe12f841a1a445799b676c9c892fb
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/libpng_1.6.44-1/libpng-1.6.44.tar.gz
+wrapdb_version = 1.6.44-1
+
+[provide]
+libpng = libpng_dep
diff --git a/wraps/nlohmann_json.wrap b/wraps/nlohmann_json.wrap
new file mode 100644
index 0000000..8c46676
--- /dev/null
+++ b/wraps/nlohmann_json.wrap
@@ -0,0 +1,11 @@
+[wrap-file]
+directory = nlohmann_json-3.11.3
+lead_directory_missing = true
+source_url = https://github.com/nlohmann/json/releases/download/v3.11.3/include.zip
+source_filename = nlohmann_json-3.11.3.zip
+source_hash = a22461d13119ac5c78f205d3df1db13403e58ce1bb1794edc9313677313f4a9d
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/nlohmann_json_3.11.3-1/nlohmann_json-3.11.3.zip
+wrapdb_version = 3.11.3-1
+
+[provide]
+nlohmann_json = nlohmann_json_dep
diff --git a/wraps/ogg.wrap b/wraps/ogg.wrap
new file mode 100644
index 0000000..e7f23eb
--- /dev/null
+++ b/wraps/ogg.wrap
@@ -0,0 +1,13 @@
+[wrap-file]
+directory = libogg-1.3.5
+source_url = https://downloads.xiph.org/releases/ogg/libogg-1.3.5.tar.xz
+source_filename = libogg-1.3.5.tar.xz
+source_hash = c4d91be36fc8e54deae7575241e03f4211eb102afb3fc0775fbbc1b740016705
+patch_filename = ogg_1.3.5-6_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/ogg_1.3.5-6/get_patch
+patch_hash = 8be6dcd5f93bbf9c0b9c8ec1fa29810226a60f846383074ca05b313a248e78b2
+source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/ogg_1.3.5-6/libogg-1.3.5.tar.xz
+wrapdb_version = 1.3.5-6
+
+[provide]
+ogg = libogg_dep
diff --git a/wraps/sfml.wrap b/wraps/sfml.wrap
new file mode 100644
index 0000000..577ed1e
--- /dev/null
+++ b/wraps/sfml.wrap
@@ -0,0 +1,14 @@
+[wrap-git]
+directory=SFML-3.0.0
+url=https://github.com/SFML/SFML.git
+revision=3.0.0
+depth=1
+method=cmake
+
+[provide]
+sfml_audio = sfml_audio_dep
+sfml_graphics = sfml_graphics_dep
+sfml_main = sfml_main_dep
+sfml_network = sfml_network_dep
+sfml_system = sfml_system_dep
+sfml_window = sfml_window_dep
diff --git a/wraps/tracy.wrap b/wraps/tracy.wrap
new file mode 100644
index 0000000..3e1bda5
--- /dev/null
+++ b/wraps/tracy.wrap
@@ -0,0 +1,7 @@
+[wrap-git]
+url=https://github.com/wolfpld/tracy.git
+revision=v0.11.1
+depth=1
+
+[provide]
+tracy = tracy_dep
diff --git a/wraps/vorbis.wrap b/wraps/vorbis.wrap
new file mode 100644
index 0000000..7425c11
--- /dev/null
+++ b/wraps/vorbis.wrap
@@ -0,0 +1,14 @@
+[wrap-file]
+directory = libvorbis-1.3.7
+source_url = https://downloads.xiph.org/releases/vorbis/libvorbis-1.3.7.tar.xz
+source_filename = libvorbis-1.3.7.tar.xz
+source_hash = b33cc4934322bcbf6efcbacf49e3ca01aadbea4114ec9589d1b1e9d20f72954b
+patch_filename = vorbis_1.3.7-4_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/vorbis_1.3.7-4/get_patch
+patch_hash = 979e22b24b16c927040700dfd8319cd6ba29bf52a14dbc66b1cb4ea60504f14a
+wrapdb_version = 1.3.7-4
+
+[provide]
+vorbis = vorbis_dep
+vorbisfile = vorbisfile_dep
+vorbisenc = vorbisenc_dep