diff --git a/include/utils/App/App.h b/include/utils/App/App.h
index c3f278e..d8a3b32 100644
--- a/include/utils/App/App.h
+++ b/include/utils/App/App.h
@@ -95,15 +95,22 @@ namespace Archimedes {
             std::list<std::variant<std::string, Module*>> toOpen;
 
             void handleEvents() {
+                bool handled = false;
                 while(!events.empty()) {
                     for(auto it = runOrder.rbegin(); it != runOrder.rend(); it++) {
                         if(modules[*it]->onEvent(*events.front())) {
                             Event* e = events.front();
                             events.pop_front();
                             delete e;
+                            handled = true;
                             break;
                         }
                     }
+
+                    if(handled) {
+                        std::cout << "Error: Unhandled Event: " << (std::string) *events.front() << std::endl; 
+                    }
+                    handled = false;
                 }
             }
             
diff --git a/include/utils/Events/Event.h b/include/utils/Events/Event.h
index cfe29e3..e1a0bc1 100644
--- a/include/utils/Events/Event.h
+++ b/include/utils/Events/Event.h
@@ -9,9 +9,7 @@ namespace Archimedes {
 
         public:
 
-            virtual ~Event() {
-                std::cout << (std::string)*this;
-            }
+            virtual ~Event() {}
 
             virtual operator std::string() const = 0;
 
diff --git a/include/utils/Window/Window.h b/include/utils/Window/Window.h
index b93a235..3a284ad 100644
--- a/include/utils/Window/Window.h
+++ b/include/utils/Window/Window.h
@@ -20,7 +20,7 @@ namespace Archimedes {
 
             void doFrame() {
 
-                //window.pollEvents();
+                window.pollEvents();
 
                 window.getSize(renderer->w, renderer->h);
 
diff --git a/include/utils/Window/WindowEvents.h b/include/utils/Window/WindowEvents.h
index 5abf794..56916ba 100644
--- a/include/utils/Window/WindowEvents.h
+++ b/include/utils/Window/WindowEvents.h
@@ -27,7 +27,7 @@ namespace Archimedes {
                 
             }
 
-            operator std::string() const { return "Archimedes::WindowResizeEvent"; }
+            operator std::string() const override { return "Archimedes::WindowResizeEvent"; }
 
             int width, height;
 
@@ -45,7 +45,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowCloseEvent"; }
+            operator std::string() const override { return "Archimedes::WindowCloseEvent"; }
 
             const Window* window;
     };
@@ -62,7 +62,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowKeyPressedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowKeyPressedEvent"; }
 
             unsigned int key;
             unsigned int repeat;
@@ -80,7 +80,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowKeyReleasedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowKeyReleasedEvent"; }
             
             unsigned int key;
     };
@@ -97,7 +97,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowMouseButtonPressedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowMouseButtonPressedEvent"; }
 
             unsigned int button;
     };
@@ -114,7 +114,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowMouseButtonReleasedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowMouseButtonReleasedEvent"; }
             
             unsigned int button;
     };
@@ -131,7 +131,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowScrollEvent"; }
+            operator std::string() const override { return "Archimedes::WindowScrollEvent"; }
 
             double dx, dy;
     };
@@ -142,15 +142,15 @@ namespace Archimedes {
 
             WindowMouseMovedEvent() : x(0), y(0) {}
 
-            WindowMouseMovedEvent(int x, int y) : x(x), y(y) {}
+            WindowMouseMovedEvent(double x, double y) : x(x), y(y) {}
 
             ~WindowMouseMovedEvent() {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowMouseMovedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowMouseMovedEvent"; }
 
-            int x, y;
+            double x, y;
     };
     
     class WindowFocusedEvent : public Event {
@@ -165,7 +165,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowFocusedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowFocusedEvent"; }
 
             const Window* window;
     };
@@ -182,7 +182,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowFocusLostEvent"; }
+            operator std::string() const override { return "Archimedes::WindowFocusLostEvent"; }
 
             const Window* window;
     };
@@ -199,7 +199,7 @@ namespace Archimedes {
             
             }
 
-            operator std::string() const { return "Archimedes::WindowMovedEvent"; }
+            operator std::string() const override { return "Archimedes::WindowMovedEvent"; }
 
             int x, y;
     };
diff --git a/modules/ClientModule/src/ClientEvents.h b/modules/ClientModule/src/ClientEvents.h
index 5372339..ddc86ca 100644
--- a/modules/ClientModule/src/ClientEvents.h
+++ b/modules/ClientModule/src/ClientEvents.h
@@ -19,7 +19,7 @@ namespace CMEvent {
                     msg->Release();
             }
 
-            operator std::string() const { return "CMEvent::DataRecievedEvent"; }
+            operator std::string() const override { return "CMEvent::DataRecievedEvent"; }
 
             ISteamNetworkingMessage* msg;
 
@@ -33,7 +33,7 @@ namespace CMEvent {
 
             DataSentEvent(ISteamNetworkingMessage* m) : msg(m) {}
 
-            operator std::string() const { return "CMEvent::DataSentEvent"; }
+            operator std::string() const override { return "CMEvent::DataSentEvent"; }
 
             ISteamNetworkingMessage* msg;
     };
@@ -46,7 +46,7 @@ namespace CMEvent {
 
             ConnectionStatusChangedEvent(SteamNetConnectionStatusChangedCallback_t* i) : info(i) {}
 
-            operator std::string() const { return "CMEvent::ConnectionStatusChangedEvent"; }
+            operator std::string() const override { return "CMEvent::ConnectionStatusChangedEvent"; }
 
             SteamNetConnectionStatusChangedCallback_t* info;
     };
diff --git a/modules/ImguiModule/src/ImguiModule.cpp b/modules/ImguiModule/src/ImguiModule.cpp
index 22a0647..407c526 100644
--- a/modules/ImguiModule/src/ImguiModule.cpp
+++ b/modules/ImguiModule/src/ImguiModule.cpp
@@ -80,3 +80,64 @@ void ImguiModule::onLoad() {
     ImGui_ImplGlfw_NewFrame();
     ImGui::NewFrame();
 }
+
+bool ImguiModule::onEvent(const Archimedes::Event &event) {
+/*
+    unsigned int type = app->getEventType(event);
+    ImGuiIO& io = ImGui::GetIO();
+ 
+    if(type == app->getEventType(Archimedes::WindowResizeEvent())) {
+        Archimedes::WindowResizeEvent& e = (Archimedes::WindowResizeEvent&) event;
+        io.DisplaySize = ImVec2(e.width, e.height);
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowKeyPressedEvent())) {
+        if(io.WantCaptureKeyboard) {
+            Archimedes::WindowKeyPressedEvent& e = (Archimedes::WindowKeyPressedEvent&) event;
+            io.KeysData[e.key].Down = true;
+
+            return true;
+        }
+        return false;
+    } else if(type == app->getEventType(Archimedes::WindowKeyReleasedEvent())) {
+        if(io.WantCaptureKeyboard) {
+            Archimedes::WindowKeyPressedEvent& e = (Archimedes::WindowKeyPressedEvent&) event;
+            io.KeysData[e.key].Down = false;
+
+            return true;
+        }
+        return false;
+    } else if(type == app->getEventType(Archimedes::WindowMouseButtonPressedEvent())) {
+        if(io.WantCaptureMouse) {
+            Archimedes::WindowMouseButtonPressedEvent& e = (Archimedes::WindowMouseButtonPressedEvent&) event;
+            io.MouseDown[e.button] = true;
+            return true;
+        } else
+            return false;
+    } else if(type == app->getEventType(Archimedes::WindowMouseButtonReleasedEvent())) {
+        if(io.WantCaptureMouse) {
+            Archimedes::WindowMouseButtonReleasedEvent& e = (Archimedes::WindowMouseButtonReleasedEvent&) event;
+            io.MouseDown[e.button] = false;
+            return true;
+        } else
+            return false;
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowScrollEvent())) {
+        if(io.WantCaptureMouse) {
+            Archimedes::WindowScrollEvent& e = (Archimedes::WindowScrollEvent&) event;
+            io.MouseWheel += e.dy;
+            io.MouseWheelH += e.dx;
+            return true;
+        } else
+            return false;
+    } else if(type == app->getEventType(Archimedes::WindowMouseMovedEvent())) {
+        if(io.WantSetMousePos) {
+            Archimedes::WindowMouseMovedEvent& e = (Archimedes::WindowMouseMovedEvent&) event;
+            io.MousePos = ImVec2(e.x, e.y);
+            return true;
+        } else
+            return false;
+    }
+*/
+    return false;
+
+}
diff --git a/modules/ImguiModule/src/ImguiModule.h b/modules/ImguiModule/src/ImguiModule.h
index 3c85835..ae262f8 100644
--- a/modules/ImguiModule/src/ImguiModule.h
+++ b/modules/ImguiModule/src/ImguiModule.h
@@ -16,9 +16,9 @@ class ImguiModule : public Archimedes::Module {
 
         ~ImguiModule();
 
-        void onLoad();
+        void onLoad() override;
 
-        bool onEvent(const Archimedes::Event& e) { return false; }
+        bool onEvent(const Archimedes::Event&) override;
 
         ImGuiContext* getContext() { return context; }
 
diff --git a/modules/WindowModule/src/WindowModule.cpp b/modules/WindowModule/src/WindowModule.cpp
index ad26fba..04a9baa 100644
--- a/modules/WindowModule/src/WindowModule.cpp
+++ b/modules/WindowModule/src/WindowModule.cpp
@@ -2,28 +2,52 @@
 
 WindowModule::~WindowModule() {
     if(app) {
+        app->unregisterEvent(Archimedes::WindowResizeEvent());
+        app->unregisterEvent(Archimedes::WindowCloseEvent());
+        app->unregisterEvent(Archimedes::WindowKeyPressedEvent());
+        app->unregisterEvent(Archimedes::WindowKeyReleasedEvent());
+        app->unregisterEvent(Archimedes::WindowMouseButtonPressedEvent());
+        app->unregisterEvent(Archimedes::WindowMouseButtonReleasedEvent());
+        app->unregisterEvent(Archimedes::WindowScrollEvent());
+        app->unregisterEvent(Archimedes::WindowMouseMovedEvent());
+        app->unregisterEvent(Archimedes::WindowFocusedEvent());
+        app->unregisterEvent(Archimedes::WindowFocusLostEvent());
+        app->unregisterEvent(Archimedes::WindowMovedEvent());
+
         if(renderer) {
             renderer->getCmdList().clear();
             delete renderer;
         }
-        if(window) {
-            delete window;
+        for(auto* w : windows) {
+            if(w)
+                delete w;
         }
     }
 }
 
 void WindowModule::onLoad() {
 
-    window = new Archimedes::Window([this](Archimedes::Event* e){
+    app->registerEvent(Archimedes::WindowResizeEvent());
+    app->registerEvent(Archimedes::WindowCloseEvent());
+    app->registerEvent(Archimedes::WindowKeyPressedEvent());
+    app->registerEvent(Archimedes::WindowKeyReleasedEvent());
+    app->registerEvent(Archimedes::WindowMouseButtonPressedEvent());
+    app->registerEvent(Archimedes::WindowMouseButtonReleasedEvent());
+    app->registerEvent(Archimedes::WindowScrollEvent());
+    app->registerEvent(Archimedes::WindowMouseMovedEvent());
+    app->registerEvent(Archimedes::WindowFocusedEvent());
+    app->registerEvent(Archimedes::WindowFocusLostEvent());
+    app->registerEvent(Archimedes::WindowMovedEvent());
+
+    windows.push_back(new Archimedes::Window([this](Archimedes::Event* e){
         app->emitEvent(e);
-    });
+    }));
     
     renderer = new Archimedes::Renderer();
 
-    window->setRenderer(renderer);
+    for(auto* window : windows)
+        window->setRenderer(renderer);
     
-    //renderer = window->getRenderer();
-
     if(!renderer->init()) {
         std::cout << "Renderer init failed!\n";
         std::abort();
@@ -32,16 +56,60 @@ void WindowModule::onLoad() {
 
 void WindowModule::run() {
 
-    if(window->shouldClose()) {
-        app->end();
+    for(auto* window : windows) {
+        
+        if(window->shouldClose()) {
+            app->end();
+        }
+
+        for(auto e : window->getWindowImpl().data.eventList) {
+            app->emitEvent(e);
+        }
+
+        window->getWindowImpl().data.eventList.clear();
+
+        window->doFrame();
     }
-
-    for(auto e : window->getWindowImpl().data.eventList) {
-        app->emitEvent(e);
-    }
-
-    window->getWindowImpl().data.eventList.clear();
-
-    window->doFrame();
 }
         
+bool WindowModule::onEvent(const Archimedes::Event& e) {
+
+    unsigned int type = app->getEventType(e);
+
+    if(type == app->getEventType(Archimedes::WindowResizeEvent())) {
+        
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowCloseEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowKeyPressedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowKeyReleasedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowMouseButtonPressedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowMouseButtonReleasedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowScrollEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowMouseMovedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowFocusedEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowFocusLostEvent())) {
+
+        return true;
+    } else if(type == app->getEventType(Archimedes::WindowMovedEvent())) {
+
+        return true;
+    }
+
+    return false;
+}
diff --git a/modules/WindowModule/src/WindowModule.h b/modules/WindowModule/src/WindowModule.h
index 550a326..36b2c99 100644
--- a/modules/WindowModule/src/WindowModule.h
+++ b/modules/WindowModule/src/WindowModule.h
@@ -15,20 +15,22 @@ class WindowModule : public Archimedes::Module {
 
         WindowModule() { name = "WindowModule"; }
 
-        ~WindowModule();
+        ~WindowModule() override;
 
-        void run();
+        void run() override;
 
-        void onLoad();
+        void onLoad() override;
+
+        bool onEvent(const Archimedes::Event& e) override;
         
         //interface for other modules
         
-        Archimedes::Window* getWindow() { return window; }
+        std::vector<Archimedes::Window*>& getWindow() { return windows; }
         Archimedes::Renderer* getRenderer() { return renderer; }
 
     private:
 
-        Archimedes::Window* window;
+        std::vector<Archimedes::Window*> windows;
         Archimedes::Renderer* renderer;
 
 };