diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3d82dc9..0772247 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -22,12 +22,12 @@ CPMAddPackage(
 
 CPMAddPackage(
         NAME J3ML
-        URL https://git.redacted.cc/josh/j3ml/archive/Release-3.1.zip
+        URL https://git.redacted.cc/josh/j3ml/archive/Release-3.2.zip
 )
 
 CPMAddPackage(
         NAME ReWindow
-        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-15.zip
+        URL https://git.redacted.cc/Redacted/ReWindow/archive/Prerelease-21.zip
 )
 
 CPMAddPackage(
@@ -37,17 +37,12 @@ CPMAddPackage(
 
 CPMAddPackage(
         NAME jlog
-        URL https://git.redacted.cc/josh/jlog/Prerelease-12.zip
+        URL https://git.redacted.cc/josh/jlog/Prerelease-16.zip
 )
 
 CPMAddPackage(
-        NAME Event
-        URL https://git.redacted.cc/josh/Event/archive/Release-6.zip
-)
-
-CPMAddPackage(
-        NAME ReTexture
-        URL https://git.redacted.cc/Redacted/ReTexture/archive/Release-1.2.zip
+        NAME ReImage
+        URL https://git.redacted.cc/Redacted/ReImage/archive/Release-2.0.zip
 )
 
 if (WIN32)
@@ -91,7 +86,7 @@ include_directories(
 target_include_directories(JGL PUBLIC
         ${PROJECT_SOURCE_DIR}/include
         ${OPENGL_INCLUDE_DIRS}
-        ${ReTexture_SOURCE_DIR}/include
+        ${ReImage_SOURCE_DIR}/include
         ${mcolor_SOURCE_DIR}/include
         ${J3ML_SOURCE_DIR}/include
         ${glad_SOURCE_DIR}/include
@@ -104,13 +99,13 @@ add_executable(JGL_Demo main.cpp)
 if (UNIX AND NOT APPLE)
     target_include_directories(JGL PRIVATE ${FREETYPE_INCLUDE_DIRS})
     target_link_libraries(JGL PRIVATE ${FREETYPE_LIBRARIES})
-    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReTexture)
+    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage)
 endif()
 
 if (WIN32)
     target_include_directories(JGL PRIVATE ${freetype_SOURCE_DIR}/include)
     target_link_libraries(JGL PRIVATE freetype)
-    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReTexture)
+    target_link_libraries(JGL PUBLIC ${OPENGL_LIBRARIES} mcolor J3ML glad jlog ReImage)
 endif()
 
 target_link_libraries(JGL_Demo PUBLIC JGL ReWindowLibrary Event)
diff --git a/include/JGL/types/Texture.h b/include/JGL/types/Texture.h
index 5d9087b..44b4c82 100644
--- a/include/JGL/types/Texture.h
+++ b/include/JGL/types/Texture.h
@@ -1,12 +1,12 @@
 #pragma once
-#include <ReTexture/Texture.h>
+#include <ReImage/Image.h>
 #include <J3ML/LinearAlgebra.hpp>
 #include <Color3.hpp>
 #include <Color4.hpp>
 #include <glad/glad.h>
 
 namespace JGL {
-    using namespace ReTexture;
+    using namespace ReImage;
     enum class TextureFilteringMode : u8 {
         NEAREST = 0, //Fastest for 2D, Sometimes causes graphical issues.
         BILINEAR = 1, //Fast and pretty, The best for 2D.
@@ -30,15 +30,15 @@ namespace JGL {
     protected:
         GLuint texture_handle = 0;
         Vector2 texture_size = {0, 0};
-        ReTexture::TextureFlag texture_flags;
-        ReTexture::TextureFormat texture_format;
+        ReImage::TextureFlag texture_flags;
+        ReImage::TextureFormat texture_format;
         TextureFilteringMode texture_filtering_mode;
         TextureWrappingMode texture_wrapping_mode;
-        void load(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
+        void load(Image* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
     public:
         /// Load a texture from a file,
         explicit Texture(const std::string& file, TextureFilteringMode filtering_mode = TextureFilteringMode::BILINEAR, TextureWrappingMode wrapping_mode = TextureWrappingMode::CLAMP_TO_EDGE, const TextureFlag& flags = TextureFlag::INVERT_Y);
-        Texture(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
+        Texture(Image* software_texture, const Vector2& size, const TextureFormat& format, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode);
         /* Initialize a texture filled with trash data
         this is primarily for the RenderTarget */
         explicit Texture(const Vector2& size);
diff --git a/src/types/RenderTarget.cpp b/src/types/RenderTarget.cpp
index 1e88855..f60274f 100644
--- a/src/types/RenderTarget.cpp
+++ b/src/types/RenderTarget.cpp
@@ -1,5 +1,4 @@
 #include <JGL/types/RenderTarget.h>
-#include <ReTexture/Texture.h>
 #include <JGL/logger/logger.h>
 #include <stdexcept>
 
diff --git a/src/types/Texture.cpp b/src/types/Texture.cpp
index e6ce979..21ce6c8 100644
--- a/src/types/Texture.cpp
+++ b/src/types/Texture.cpp
@@ -1,13 +1,13 @@
 #include <JGL/types/Texture.h>
 #include <iostream>
 
-using namespace ReTexture;
+using namespace ReImage;
 
 namespace JGL
 {
-    Texture::Texture(const std::string& file, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode, const ReTexture::TextureFlag& flags)
+    Texture::Texture(const std::string& file, TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode, const TextureFlag& flags)
     {
-        auto* t = new ReTexture::SoftwareTexture(file, flags);
+        auto* t = new ReImage::Image(file, flags);
         GLuint previous_texture;
         glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*) &previous_texture);
 
@@ -41,7 +41,7 @@ namespace JGL
         glBindTexture(GL_TEXTURE_2D, previous_texture);
     }
 
-    void Texture::load(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format,
+    void Texture::load(Image* software_texture, const Vector2& size, const TextureFormat& format,
                            TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
 
         GLuint previous_texture;
@@ -52,11 +52,11 @@ namespace JGL
 
             if (format == TextureFormat::RGBA)
                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (int) size.x, (int) size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE,
-                             software_texture->pixelData.data());
+                             software_texture->pixel_data.data());
 
             else if (format == TextureFormat::RGB)
                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, (int) size.x, (int) size.y, 0, GL_RGB, GL_UNSIGNED_BYTE,
-                             software_texture->pixelData.data());
+                             software_texture->pixel_data.data());
 
             if (wrapping_mode == TextureWrappingMode::CLAMP_TO_EDGE)
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE),
@@ -85,27 +85,27 @@ namespace JGL
                      filtering_mode == TextureFilteringMode::MIPMAP_BILINEAR ||
                      filtering_mode == TextureFilteringMode::MIPMAP_TRILINEAR) {
                 //3 mipmap levels.
-                auto *m1 = new SoftwareTexture(software_texture->downscale(2));
-                auto *m2 = new SoftwareTexture(software_texture->downscale(4));
-                auto *m3 = new SoftwareTexture(software_texture->downscale(8));
+                auto *m1 = new Image(software_texture->downscale(2));
+                auto *m2 = new Image(software_texture->downscale(4));
+                auto *m3 = new Image(software_texture->downscale(8));
 
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3);
 
                 if (format == TextureFormat::RGBA) {
                     glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, m1->getWidth(), m1->getHeight(), 0, GL_RGBA,
-                                 GL_UNSIGNED_BYTE, m1->pixelData.data());
+                                 GL_UNSIGNED_BYTE, m1->pixel_data.data());
                     glTexImage2D(GL_TEXTURE_2D, 2, GL_RGBA, m2->getWidth(), m2->getHeight(), 0, GL_RGBA,
-                                 GL_UNSIGNED_BYTE, m2->pixelData.data());
+                                 GL_UNSIGNED_BYTE, m2->pixel_data.data());
                     glTexImage2D(GL_TEXTURE_2D, 3, GL_RGBA, m3->getWidth(), m3->getHeight(), 0, GL_RGBA,
-                                 GL_UNSIGNED_BYTE, m3->pixelData.data());
+                                 GL_UNSIGNED_BYTE, m3->pixel_data.data());
                 } else if (format == TextureFormat::RGB) {
                     glTexImage2D(GL_TEXTURE_2D, 1, GL_RGB, m1->getWidth(), m1->getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE,
-                                 m1->pixelData.data());
+                                 m1->pixel_data.data());
                     glTexImage2D(GL_TEXTURE_2D, 2, GL_RGB, m2->getWidth(), m2->getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE,
-                                 m2->pixelData.data());
+                                 m2->pixel_data.data());
                     glTexImage2D(GL_TEXTURE_2D, 3, GL_RGB, m3->getWidth(), m3->getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE,
-                                 m3->pixelData.data());
+                                 m3->pixel_data.data());
                 }
 
                 if (filtering_mode == TextureFilteringMode::MIPMAP_NEAREST)
@@ -187,7 +187,7 @@ namespace JGL
         return texture_wrapping_mode;
     }
 
-    Texture::Texture(SoftwareTexture* software_texture, const Vector2& size, const TextureFormat& format,
+    Texture::Texture(Image* software_texture, const Vector2& size, const TextureFormat& format,
                      TextureFilteringMode filtering_mode, TextureWrappingMode wrapping_mode) {
         load(software_texture, size, format, filtering_mode, wrapping_mode);
     }
@@ -198,10 +198,9 @@ namespace JGL
 
     Texture::Texture(const Texture& rhs) {
         auto pixels = rhs.GetPixelData();
-        std::vector<unsigned char> pixels_correct(pixels.size() * sizeof(Color4));
-        memcpy(pixels_correct.data(), pixels.data(), pixels.size() * sizeof(Color4));
-        auto software_texture = SoftwareTexture(pixels_correct, rhs.texture_format, rhs.GetDimensions().x, rhs.GetDimensions().y);
-        this->load(&software_texture, rhs.GetDimensions(), rhs.texture_format, rhs.texture_filtering_mode, rhs.texture_wrapping_mode);
+        auto image = Image(pixels.data(), pixels.size(), rhs.GetDimensions().x, rhs.GetDimensions().y);
+        this->load(&image, rhs.GetDimensions(), rhs.texture_format, rhs.texture_filtering_mode, rhs.texture_wrapping_mode);
+        this->texture_flags = rhs.texture_flags;
     }
 
     void Texture::SetFlags(const TextureFlag &flags) {