diff --git a/assets/shaders/Image.frag b/assets/shaders/Image.frag
new file mode 100644
index 0000000000000000000000000000000000000000..1af2c2fd7e6e20ebec8c3eff60f7b4a4cf6cc871
--- /dev/null
+++ b/assets/shaders/Image.frag
@@ -0,0 +1,10 @@
+#version 330 core
+out vec4 FragColor;
+
+in vec2 Texture;
+
+uniform sampler2D uSampler;
+
+void main() {
+    FragColor = texture(uSampler, Texture);
+}
\ No newline at end of file
diff --git a/assets/shaders/Image.vert b/assets/shaders/Image.vert
new file mode 100644
index 0000000000000000000000000000000000000000..74c6db6c61d5a8f5f73827f1ff15703f20d7c357
--- /dev/null
+++ b/assets/shaders/Image.vert
@@ -0,0 +1,14 @@
+#version 330 core
+layout (location = 0) in vec2 aPos;
+layout (location = 1) in vec2 aTex;
+
+uniform mat4 uProj;
+uniform mat4 uView;
+uniform mat4 uModel;
+
+out vec2 Texture;
+
+void main() {
+    Texture = aTex;
+    gl_Position = uProj * uView * uModel * vec4(aPos.x, aPos.y, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/source/engine/graphics/back/geometry/Geometry.cpp b/source/engine/graphics/back/geometry/Geometry.cpp
deleted file mode 100644
index 26a8f590e14f3b6c3d52d9a248ad3ae7c0da6d62..0000000000000000000000000000000000000000
--- a/source/engine/graphics/back/geometry/Geometry.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "Geometry.hpp"
-
-namespace megu {
-    template <Primitive P>
-    Geometry<P>::Geometry(const Layout_Initializer & layout)
-    : _layout(layout) {}
-
-    template <Primitive P>
-    Geometry_Indiced<P>::Geometry_Indiced(const Layout_Initializer & layout)
-    : Geometry<P>(layout) {}
-
-    template <class T, Primitive P>
-    Static_Geometry<T,P>::Static_Geometry(const Layout_Initializer & layout)
-    : Geometry<P>(layout) {}
-
-    template <class T, Primitive P>
-    Static_Geometry_Indiced<T, P>:: Static_Geometry_Indiced(const Layout_Initializer & layout)
-    : Geometry<P>(layout) {}
-}
\ No newline at end of file
diff --git a/source/engine/graphics/back/geometry/Geometry.hpp b/source/engine/graphics/back/geometry/Geometry.hpp
index d61e0eaf9d126e4cb000a20c5e3e8a0fe0d729d6..7b34f29090660d2aac1b896631091be7a995f7b2 100644
--- a/source/engine/graphics/back/geometry/Geometry.hpp
+++ b/source/engine/graphics/back/geometry/Geometry.hpp
@@ -13,55 +13,57 @@ namespace megu {
     using Vertices_t = std::vector<float>;
     using Elements_t = std::vector<unsigned int>;
 
-    enum Primitive {
+    enum Primitive_t {
         TRIANGLES   = GL_TRIANGLES,
         QUADS       = GL_QUADS,
     };
 
-    template <Primitive P>
+    template <Primitive_t P>
     class Geometry {
         public: 
             Geometry() = delete;
-            Geometry(const Layout_Initializer &);
+            Geometry(const Layout &);
            ~Geometry() = default;
 
             virtual const Vertices_t & vertices() const = 0;
 
+            inline static Primitive_t Primitive() {return P;}
+
         private:
             Layout _layout;
     };
 
-    template <Primitive P>
-    class Geometry_Indiced : virtual public Geometry<P> {
+    template <Primitive_t P>
+    class Geometry_Indiced : public Geometry<P> {
         public:
             Geometry_Indiced() = delete;
-            Geometry_Indiced(const Layout_Initializer &);
+            Geometry_Indiced(const Layout &);
            ~Geometry_Indiced() = default;
 
             virtual const Elements_t & elements() const = 0;
     };
 
-    template <class T, Primitive P>
-    class Static_Geometry : virtual public Geometry<P> {
+    template <class T, Primitive_t P>
+    class Static_Geometry : public Geometry<P> {
         public:
             Static_Geometry() = delete;
-            Static_Geometry(const Layout_Initializer &);
+            Static_Geometry(const Layout &);
            ~Static_Geometry() = default;
 
             const Vertices_t & vertices() const final override {return Static_Geometry<T, P>::Vertices();}
             static const Vertices_t & Vertices() {return T::Vertices();}
     };
 
-    template <class T, Primitive P>
+    template <class T, Primitive_t P>
     class Static_Geometry_Indiced : public Geometry_Indiced<P>, public Static_Geometry<T, P> {
         public:
             Static_Geometry_Indiced() = delete;
-            Static_Geometry_Indiced(const Layout_Initializer &);
+            Static_Geometry_Indiced(const Layout &);
            ~Static_Geometry_Indiced() = default;
 
             const Elements_t  & elements() const final override {return Static_Geometry_Indiced<T, P>::Elements();}
             static const Elements_t & Elements() {return T::Elements();}
-    };
+    };   
+}
 
-   
-}
\ No newline at end of file
+#include "Geometry.tpp"
\ No newline at end of file
diff --git a/source/engine/graphics/back/geometry/Geometry.tpp b/source/engine/graphics/back/geometry/Geometry.tpp
new file mode 100644
index 0000000000000000000000000000000000000000..c8cdbdcb2ac16a8dfbc2aa511f76a82eb78961ab
--- /dev/null
+++ b/source/engine/graphics/back/geometry/Geometry.tpp
@@ -0,0 +1,19 @@
+#include "Geometry.hpp"
+
+namespace megu {
+    template <Primitive_t P>
+    Geometry<P>::Geometry(const Layout & layout)
+    : _layout(layout) {}
+
+    template <Primitive_t P>
+    Geometry_Indiced<P>::Geometry_Indiced(const Layout & layout)
+    : Geometry<P>(layout) {}
+
+    template <class T, Primitive_t P>
+    Static_Geometry<T,P>::Static_Geometry(const Layout & layout)
+    : Geometry<P>(layout) {}
+
+    template <class T, Primitive_t P>
+    Static_Geometry_Indiced<T, P>:: Static_Geometry_Indiced(const Layout & layout)
+    : Geometry<P>(layout) {}
+}
\ No newline at end of file
diff --git a/source/engine/graphics/back/textures/TextureBuffer.cpp b/source/engine/graphics/back/textures/TextureBuffer.cpp
index 0c7e3f521030a8a2fbd45011825d3215a48e82de..1d020b3acb297474efe3a7ae0f70c712ef89e686 100644
--- a/source/engine/graphics/back/textures/TextureBuffer.cpp
+++ b/source/engine/graphics/back/textures/TextureBuffer.cpp
@@ -23,7 +23,7 @@ namespace megu {
         return *this;
     }   
 
-    GLuint TextureBuffer::getPixel(GLuint x, GLuint y) const {
+    GLuint TextureBuffer::get(GLuint x, GLuint y) const {
         return this->_data.at((this->_width * y) + x);
     }
 
@@ -75,7 +75,7 @@ namespace megu {
         this->_data.clear();
     }
 
-    void TextureBuffer::setPixel(GLuint x, GLuint y, GLubyte v) {
+    void TextureBuffer::set(GLuint x, GLuint y, GLubyte v) {
         this->_data[(y * this->_width) + x] = v;
     }
 }
\ No newline at end of file
diff --git a/source/engine/graphics/back/textures/TextureBuffer.hpp b/source/engine/graphics/back/textures/TextureBuffer.hpp
index 1c96c4235123215a8e25026b4683bf7190a11053..cb7f87fa4d17be2ec6ff3d3082cdc0927c78fb5f 100644
--- a/source/engine/graphics/back/textures/TextureBuffer.hpp
+++ b/source/engine/graphics/back/textures/TextureBuffer.hpp
@@ -21,13 +21,13 @@ namespace megu {
             inline const GLubyte * data_ptr() const {return this->_data.data();}
             inline bool empty() const {return this->_data.empty();}
 
-            GLuint getPixel(GLuint, GLuint) const;
+            GLuint get(GLuint, GLuint) const;
 
             void load(const GLubyte *, size_t);
             void load(const std::filesystem::path &, bool = true);
             void free();
 
-            void setPixel(GLuint, GLuint, GLubyte);
+            void set(GLuint, GLuint, GLubyte);
 
         private:
             GLuint _width, _height;
diff --git a/source/engine/graphics/front/geometry/FlatGeometry.cpp b/source/engine/graphics/front/geometry/FlatGeometry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e6e0de17daf4a8e06e0814b8c18f96367a8767fb
--- /dev/null
+++ b/source/engine/graphics/front/geometry/FlatGeometry.cpp
@@ -0,0 +1,21 @@
+#include "FlatGeometry.hpp"
+
+namespace megu {
+    Flat_Geometry::Flat_Geometry()
+    : Geometry({layout::FLAT, layout::COLOR}) {}
+    
+    Vertices_t Static_Flat_Geometry::_Vertices = {
+        0.f,  0.f,    0.f, 0.f,
+        1.f,  0.f,    1.f, 0.f,
+        1.f,  1.f,    1.f, 1.f,
+        0.f,  1.f,    0.f, 1.f
+    };
+
+    Static_Flat_Geometry::Static_Flat_Geometry()
+    : Static_Geometry<Static_Flat_Geometry, QUADS>(Static_Flat_Geometry::GetLayout()) {}
+
+    const Vertices_t & Static_Flat_Geometry::Vertices() {
+        return Static_Flat_Geometry::_Vertices;
+    }
+    
+}
\ No newline at end of file
diff --git a/source/engine/graphics/front/geometry/FlatGeometry.hpp b/source/engine/graphics/front/geometry/FlatGeometry.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7f56662bcaa71c655fd5d924ad14bd4173eb3976
--- /dev/null
+++ b/source/engine/graphics/front/geometry/FlatGeometry.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <engine/graphics/back/geometry/Geometry.hpp>
+
+namespace megu {
+    class Flat_Geometry : public Geometry<QUADS> {
+        public:
+            Flat_Geometry();
+           ~Flat_Geometry() = default;
+    }; 
+
+    class Static_Flat_Geometry : public Static_Geometry<Static_Flat_Geometry, QUADS> {
+        public:
+            Static_Flat_Geometry();
+           ~Static_Flat_Geometry() = default;
+
+            inline static Layout GetLayout() {return {layout::FLAT, layout::TEXTURE};}
+
+            static const Vertices_t & Vertices();
+            
+        private:
+            static Vertices_t _Vertices;
+    };
+}
diff --git a/source/engine/graphics/front/group/DrawGroup.hpp b/source/engine/graphics/front/group/DrawGroup.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9a485553feab5e4de392008b34664fb409a0d1f
--- /dev/null
+++ b/source/engine/graphics/front/group/DrawGroup.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <engine/graphics/back/cameras/Camera.hpp>
+
+namespace megu {
+    class DrawGroup {
+        public:
+            virtual void draw(const Camera &) const = 0;
+    };
+}
\ No newline at end of file
diff --git a/source/engine/graphics/front/group/ImageGroup.cpp b/source/engine/graphics/front/group/ImageGroup.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..47fe30a4360cb91119c2ec3b765b8f0f93aeaa8f
--- /dev/null
+++ b/source/engine/graphics/front/group/ImageGroup.cpp
@@ -0,0 +1,34 @@
+#include "ImageGroup.hpp"
+
+namespace megu {
+    ImageGroup::ImageGroup() 
+    : _images(nullptr), _vbo(this->_vao, Static_Flat_Geometry::GetLayout(), 400) {
+        {
+            Source vert("assets/shaders/Image.vert", Source::Categorie::VERTEX);
+            Source frag("assets/shaders/Image.frag", Source::Categorie::FRAGMENT);
+
+            this->_program << vert;
+            this->_program << frag;
+            this->_program.link();
+
+            vert.release();
+            frag.release();
+        }
+
+        this->_vbo << Static_Flat_Geometry::Vertices();
+    }
+
+    void ImageGroup::draw(const Camera & camera) const {
+        this->_vao.bind();
+        this->_program.use();
+
+        this->_images->texture().bind(0);
+
+        this->_program.setUniform("uProj", camera.projection());
+        this->_program.setUniform("uView", camera.view());
+        this->_program.setUniform("uModel", this->_images->transformation().model());
+        this->_program.setUniform("uSampler", 0);
+
+        glDrawArrays(Static_Flat_Geometry::Primitive(), 0, static_cast<GLsizei>(this->_vbo.size()));
+    }
+}
\ No newline at end of file
diff --git a/source/engine/graphics/front/group/ImageGroup.hpp b/source/engine/graphics/front/group/ImageGroup.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..465609efcd3788c70bc94344e10991511e7e96b1
--- /dev/null
+++ b/source/engine/graphics/front/group/ImageGroup.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "DrawGroup.hpp"
+
+#include <engine/graphics/back/buffers/VertexArray.hpp>
+#include <engine/graphics/back/buffers/VerticeBuffer.hpp>
+#include <engine/graphics/back/shaders/Program.hpp>
+
+#include <engine/graphics/front/object/Image.hpp>
+
+namespace megu {
+    class ImageGroup : public DrawGroup {
+        public:
+            ImageGroup();
+           ~ImageGroup() = default;
+
+            void draw(const Camera & camera) const override;
+
+            inline void temp_set(Image & image) {this->_images = &image;}
+
+        private:
+            Image * _images;
+
+            VertexArray _vao;
+            VerticeBuffer _vbo;
+            Program _program;
+    };
+}
\ No newline at end of file
diff --git a/source/engine/graphics/front/object/Image.cpp b/source/engine/graphics/front/object/Image.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d719bfba3917729233dae4fa2fe6f300b83ad744
--- /dev/null
+++ b/source/engine/graphics/front/object/Image.cpp
@@ -0,0 +1,19 @@
+#include "Image.hpp"
+
+namespace megu {
+    Image::Image() 
+    : _texture(), 
+      _transformation(), 
+      _geometry() {}
+
+    void Image::load(const std::filesystem::path & path, bool flip) {
+        TextureBuffer buffer;
+        buffer.load(path, flip);
+        this->load(buffer);
+    }
+
+    void Image::load(const TextureBuffer & buffer) {
+        this->setSize(buffer.width(), buffer.height());
+        this->_texture.store(buffer);
+    }
+}
\ No newline at end of file
diff --git a/source/engine/graphics/front/object/Image.hpp b/source/engine/graphics/front/object/Image.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0392e9411f0a2068338a2d76664cf29d321633d7
--- /dev/null
+++ b/source/engine/graphics/front/object/Image.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <filesystem>
+#include <glm/vec2.hpp>
+
+#include <engine/graphics/back/geometry/Transformable.hpp>
+#include <engine/graphics/back/textures/Texture.hpp> 
+
+#include <engine/graphics/front/geometry/FlatGeometry.hpp>
+
+namespace megu {
+    class Image {
+        public:
+            Image();
+           ~Image() = default;
+
+            inline glm::vec2 getPosition() const {return glm::vec2(this->_transformation.x(), this->_transformation.y());}
+            inline glm::vec2 getSize() const {return glm::vec2(this->_transformation.scaling().x, this->_transformation.scaling().y);}
+           
+
+            inline void setPosition(float x, float y) {this->_transformation.setPosition(x, y);}
+            inline void setSize(float x, float y) {this->_transformation.setScaling(x, y);}
+
+            void load(const std::filesystem::path &, bool = true);
+            void load(const TextureBuffer &);
+
+            inline const Texture & texture() const {return this->_texture;}
+            inline const Transformable & transformation() const {return this->_transformation;}
+
+        private:
+            Texture _texture;
+            Transformable _transformation;
+            Static_Flat_Geometry _geometry;
+    };
+}
\ No newline at end of file
diff --git a/source/main.cpp b/source/main.cpp
index d0207f29da94f815d12c5521c5dee08954b136ac..ba376e78122fea9e4d928a16b3817a595f004c3f 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -3,14 +3,14 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 
-#include <engine/graphics/errors.hpp>
-#include <engine/graphics/back.hpp>
-
-#define NORMALIZE(X) X/255.f
-
 #define WINDOW_WIDTH  1200
 #define WINDOW_HEIGHT 720
 
+#include <engine/graphics/back/cameras/View.hpp>
+#include <engine/graphics/front/object/Image.hpp>
+#include <engine/graphics/front/group/ImageGroup.hpp>
+#include <engine/graphics/errors.hpp>
+
 int main(int argc, const char * argv[]) {
     try {
         //? GLFW
@@ -54,106 +54,21 @@ int main(int argc, const char * argv[]) {
         glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
 
         megu::error::opengl_error::check();
-        std::cout <<  "Viewport" << std::endl;
-
-        //? Buffers
-        megu::VertexArray vao;
-        megu::VerticeBuffer vbo(vao, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC);
-
-        std::vector<float> vertices = {
-            -1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255), 
-             1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255),
-             1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
-
-             1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
-            -1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
-            -1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255), 
-
-            -1.f, -0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
-             1.f, -0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
-             1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
-
-             1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
-            -1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
-            -1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114)
-        };
-
-        vbo << vertices;
-
-        std::cout << "VBO" << std::endl;
-
-        megu::VertexArray vao_2;
-        megu::VerticeBuffer vbo_2(vao_2, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC);
-
-        std::vector<float> vertices_2 = {
-            -0.5f, -0.5f, 0.0,  NORMALIZE(255), NORMALIZE(0), NORMALIZE(0),  
-             0.5f, -0.5f, 0.0,  NORMALIZE(0), NORMALIZE(255), NORMALIZE(0),  
-             0.0f,  0.5f, 0.0,  NORMALIZE(0), NORMALIZE(0), NORMALIZE(255),  
-        };
-
-        vbo_2 << vertices_2;
-
-        megu::VertexArray vao_F;
-        megu::VerticeBuffer vbo_F(vao_F, {megu::layout::POSITION, megu::layout::TEXTURE}, 64, megu::EditMode::STATIC);
-
-        std::vector<float> vertices_F = {
-            -1.f, -1.f, 0.f,    0.f, 0.f,
-             1.f, -1.f, 0.f,    1.f, 0.f,
-             1.f,  1.f, 0.f,    1.f, 1.f,
-
-            -1.f, -1.f, 0.f,    0.f, 0.f,
-             1.f,  1.f, 0.f,    1.f, 1.f,
-            -1.f,  1.f, 0.f,    0.f, 1.f
-        };
-
-        vbo_F << vertices_F;
 
-        std::cout << "VBO - FBO" << std::endl;
+        //? Camera
+        megu::View view(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
 
-        //? Material
+        //? Image
+        megu::Image image;
+        image.load("assets/textures/Test.png");
 
-        megu::TextureBuffer buffer;
-        buffer.load("assets/textures/All_Might_Armored.png");
+        image.setSize(WINDOW_WIDTH/2, WINDOW_HEIGHT/2);
 
-        megu::Texture texture;
-        texture.store(buffer);
-        buffer.free();
-
-        //? FBO
-
-        megu::FrameBuffer fbo(WINDOW_WIDTH, WINDOW_HEIGHT);
-        megu::FrameBuffer fbo_2(WINDOW_WIDTH, WINDOW_HEIGHT);
-
-        //? Shaders
-        megu::Program program;
-
-        {
-            megu::Source vertex("assets/shaders/Basic.vert", megu::Source::Categorie::VERTEX);
-            megu::Source fragment("assets/shaders/Basic.frag", megu::Source::Categorie::FRAGMENT);
-
-            program << vertex;
-            program << fragment;
-
-            program.link();
-        }
-
-        std::cout << "Shader - FBO" << std::endl;
-
-
-        megu::Program program_F;
-
-        {
-            megu::Source vertex("assets/shaders/Texture.vert", megu::Source::Categorie::VERTEX);
-            megu::Source fragment("assets/shaders/Texture.frag", megu::Source::Categorie::FRAGMENT);
-
-            program_F << vertex;
-            program_F << fragment;
-
-            program_F.link();
-        }
-
-        std::cout << "Shader" << std::endl;
+        std::cout << "Texture" << std::endl;
 
+        //? Group
+        megu::ImageGroup group;
+        group.temp_set(image);
 
         //? Render Loop
         glClearColor(0.0f, 0.0f, 0.0f, 0.f);
@@ -163,28 +78,10 @@ int main(int argc, const char * argv[]) {
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
             glfwPollEvents();
 
-            /*fbo.bind();
-            vao.bind();
-            program.use();
-            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo.size()));
+            group.draw(view);
 
-            fbo_2.bind();
-            vao_2.bind();
-            program.use();
-            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_2.size()));*/
-
-            megu::FrameBuffer::BindDefaultFrameBuffer();
-            vao_F.bind();
+            image.setPosition(sin(glfwGetTime()) * WINDOW_WIDTH/2, cos(glfwGetTime()) * WINDOW_HEIGHT/2);
             
-            //fbo.texture().bind(0);
-            //fbo_2.texture().bind(1);
-
-            texture.bind(0);
-
-            program_F.use();
-            program_F.setUniform("uSamp", std::vector<GLint>({0, 1}));
-
-            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_F.size()));
 
             glfwSwapBuffers(window);
         }
diff --git a/source/main.cpp.old b/source/main.cpp.old
new file mode 100644
index 0000000000000000000000000000000000000000..d0207f29da94f815d12c5521c5dee08954b136ac
--- /dev/null
+++ b/source/main.cpp.old
@@ -0,0 +1,198 @@
+#include <iostream>
+
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+
+#include <engine/graphics/errors.hpp>
+#include <engine/graphics/back.hpp>
+
+#define NORMALIZE(X) X/255.f
+
+#define WINDOW_WIDTH  1200
+#define WINDOW_HEIGHT 720
+
+int main(int argc, const char * argv[]) {
+    try {
+        //? GLFW
+        if(glfwInit() == GLFW_FALSE) {
+            std::cerr << "GLFW : GLFW Init Error" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        GLFWmonitor * monitore = glfwGetPrimaryMonitor();
+        const GLFWvidmode * videoMode = glfwGetVideoMode(monitore);
+
+        glfwWindowHint(GLFW_RED_BITS, videoMode->redBits);
+        glfwWindowHint(GLFW_GREEN_BITS, videoMode->greenBits);
+        glfwWindowHint(GLFW_BLUE_BITS, videoMode->blueBits);
+        glfwWindowHint(GLFW_REFRESH_RATE, videoMode->refreshRate);
+
+        glfwWindowHint(GLFW_RESIZABLE, true);
+        glfwWindowHint(GLFW_DECORATED, true);
+        glfwWindowHint(GLFW_VISIBLE, true);
+        glfwWindowHint(GLFW_DOUBLEBUFFER, true);
+
+        GLFWwindow * window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Scene", NULL, NULL);
+        if(window == NULL) {
+            std::cerr << "GLFW : Window Init Error" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        glfwMakeContextCurrent(window);
+        glfwSwapInterval(0);
+        std::cout << "GLFW Inited" << std::endl;
+
+        //? Glew
+        if (glewInit()) {
+            std::cerr << "Failed to initialize GLAD" << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        std::cout << "Glew Inited" << std::endl;
+
+        //? Viewport
+        glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
+
+        megu::error::opengl_error::check();
+        std::cout <<  "Viewport" << std::endl;
+
+        //? Buffers
+        megu::VertexArray vao;
+        megu::VerticeBuffer vbo(vao, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC);
+
+        std::vector<float> vertices = {
+            -1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255), 
+             1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255),
+             1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
+
+             1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
+            -1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
+            -1.f, -1.f,  0.f,   NORMALIZE(33),  NORMALIZE(114), NORMALIZE(255), 
+
+            -1.f, -0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
+             1.f, -0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114),
+             1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
+
+             1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
+            -1.f,  1.f,  0.f,   NORMALIZE(190), NORMALIZE(105), NORMALIZE(170),
+            -1.f,  0.0f, 0.f,   NORMALIZE(217), NORMALIZE(63),  NORMALIZE(114)
+        };
+
+        vbo << vertices;
+
+        std::cout << "VBO" << std::endl;
+
+        megu::VertexArray vao_2;
+        megu::VerticeBuffer vbo_2(vao_2, {megu::layout::POSITION, megu::layout::COLOR}, 128, megu::EditMode::STATIC);
+
+        std::vector<float> vertices_2 = {
+            -0.5f, -0.5f, 0.0,  NORMALIZE(255), NORMALIZE(0), NORMALIZE(0),  
+             0.5f, -0.5f, 0.0,  NORMALIZE(0), NORMALIZE(255), NORMALIZE(0),  
+             0.0f,  0.5f, 0.0,  NORMALIZE(0), NORMALIZE(0), NORMALIZE(255),  
+        };
+
+        vbo_2 << vertices_2;
+
+        megu::VertexArray vao_F;
+        megu::VerticeBuffer vbo_F(vao_F, {megu::layout::POSITION, megu::layout::TEXTURE}, 64, megu::EditMode::STATIC);
+
+        std::vector<float> vertices_F = {
+            -1.f, -1.f, 0.f,    0.f, 0.f,
+             1.f, -1.f, 0.f,    1.f, 0.f,
+             1.f,  1.f, 0.f,    1.f, 1.f,
+
+            -1.f, -1.f, 0.f,    0.f, 0.f,
+             1.f,  1.f, 0.f,    1.f, 1.f,
+            -1.f,  1.f, 0.f,    0.f, 1.f
+        };
+
+        vbo_F << vertices_F;
+
+        std::cout << "VBO - FBO" << std::endl;
+
+        //? Material
+
+        megu::TextureBuffer buffer;
+        buffer.load("assets/textures/All_Might_Armored.png");
+
+        megu::Texture texture;
+        texture.store(buffer);
+        buffer.free();
+
+        //? FBO
+
+        megu::FrameBuffer fbo(WINDOW_WIDTH, WINDOW_HEIGHT);
+        megu::FrameBuffer fbo_2(WINDOW_WIDTH, WINDOW_HEIGHT);
+
+        //? Shaders
+        megu::Program program;
+
+        {
+            megu::Source vertex("assets/shaders/Basic.vert", megu::Source::Categorie::VERTEX);
+            megu::Source fragment("assets/shaders/Basic.frag", megu::Source::Categorie::FRAGMENT);
+
+            program << vertex;
+            program << fragment;
+
+            program.link();
+        }
+
+        std::cout << "Shader - FBO" << std::endl;
+
+
+        megu::Program program_F;
+
+        {
+            megu::Source vertex("assets/shaders/Texture.vert", megu::Source::Categorie::VERTEX);
+            megu::Source fragment("assets/shaders/Texture.frag", megu::Source::Categorie::FRAGMENT);
+
+            program_F << vertex;
+            program_F << fragment;
+
+            program_F.link();
+        }
+
+        std::cout << "Shader" << std::endl;
+
+
+        //? Render Loop
+        glClearColor(0.0f, 0.0f, 0.0f, 0.f);
+
+        std::cout << "Render Loop Begin !" << std::endl;
+        while(!glfwWindowShouldClose(window)) {
+            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            glfwPollEvents();
+
+            /*fbo.bind();
+            vao.bind();
+            program.use();
+            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo.size()));
+
+            fbo_2.bind();
+            vao_2.bind();
+            program.use();
+            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_2.size()));*/
+
+            megu::FrameBuffer::BindDefaultFrameBuffer();
+            vao_F.bind();
+            
+            //fbo.texture().bind(0);
+            //fbo_2.texture().bind(1);
+
+            texture.bind(0);
+
+            program_F.use();
+            program_F.setUniform("uSamp", std::vector<GLint>({0, 1}));
+
+            glDrawArrays(GL_TRIANGLES, 0, static_cast<GLsizei>(vbo_F.size()));
+
+            glfwSwapBuffers(window);
+        }
+        std::cout << "Render Loop End !" << std::endl;
+    }
+    catch(std::exception & error) {
+        std::cerr << error.what() << std::endl;
+    }
+
+    return EXIT_SUCCESS;
+}
\ No newline at end of file