diff --git a/Cargo.toml b/Cargo.toml
index aea0de4..eda13ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,7 +11,9 @@ parallel = ["legion/parallel"]
 legion = { git = "https://github.com/grzi/legion", branch = "feat/uuid_as_optional", default-features = false, features = ["codegen"]}
 
 # window & rendering
-miniquad = "0.3.0-alpha.26"
+winit = "0.24.0"
+wgpu = "0.7.0"
+futures = "0.3"
 
 # maths
 ultraviolet = "0.7"
@@ -19,8 +21,15 @@ ultraviolet = "0.7"
 # serialization
 serde = { version = "1.0.124", features = ["derive"] }
 toml = "0.5.8"
+bytemuck = { version = "1.4", features = [ "derive" ] }
 image = {version = "0.23", default-features = false, features = ["png"]}
 
 # logging
 log = { version = "0.4.14", features = ["serde"] }
-fern = { version = "0.6.0", features = ["colored"] }
\ No newline at end of file
+fern = { version = "0.6.0", features = ["colored"] }
+
+[build-dependencies]
+anyhow = "1.0"
+fs_extra = "1.1"
+glob = "0.3"
+shaderc = "0.7"
\ No newline at end of file
diff --git a/README.md b/README.md
index 3875966..8ab49ea 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 <img src="repo/banner.png" alt="Scion Engine" />
 
-Scion is a minimalist, **easy** to use, modulable game engine built on top of legion and miniquad.
+Scion is a minimalist, **easy** to use, modulable game engine built on top of legion, wgpu and winit.
 
 
 
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..bf5096e
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,81 @@
+use anyhow::*;
+use glob::glob;
+use std::fs::{read_to_string, write};
+use std::path::PathBuf;
+
+struct ShaderData {
+    src: String,
+    src_path: PathBuf,
+    spv_path: PathBuf,
+    kind: shaderc::ShaderKind,
+}
+
+impl ShaderData {
+    pub fn load(src_path: PathBuf) -> Result<Self> {
+        let extension = src_path
+            .extension()
+            .context("File has no extension")?
+            .to_str()
+            .context("Extension cannot be converted to &str")?;
+        let kind = match extension {
+            "vert" => shaderc::ShaderKind::Vertex,
+            "frag" => shaderc::ShaderKind::Fragment,
+            "comp" => shaderc::ShaderKind::Compute,
+            _ => bail!("Unsupported shader: {}", src_path.display()),
+        };
+
+        let src = read_to_string(src_path.clone())?;
+        let spv_path = src_path.with_extension(format!("{}.spv", extension));
+
+        Ok(Self {
+            src,
+            src_path,
+            spv_path,
+            kind,
+        })
+    }
+}
+
+fn main() -> Result<()> {
+    // Collect all shaders recursively within /src/
+    let mut shader_paths = [
+        glob("./src/**/*.vert")?,
+        glob("./src/**/*.frag")?,
+        glob("./src/**/*.comp")?,
+    ];
+
+    // This could be parallelized
+    let shaders = shader_paths
+        .iter_mut()
+        .flatten()
+        .map(|glob_result| ShaderData::load(glob_result?))
+        .collect::<Vec<Result<_>>>()
+        .into_iter()
+        .collect::<Result<Vec<_>>>()?;
+
+    let mut compiler = shaderc::Compiler::new().context("Unable to create shader compiler")?;
+
+    // This can't be parallelized. The [shaderc::Compiler] is not
+    // thread safe. Also, it creates a lot of resources. You could
+    // spawn multiple processes to handle this, but it would probably
+    // be better just to only compile shaders that have been changed
+    // recently.
+    for shader in shaders {
+        // This tells cargo to rerun this script if something in /src/ changes.
+        println!(
+            "cargo:rerun-if-changed={}",
+            shader.src_path.as_os_str().to_str().unwrap()
+        );
+
+        let compiled = compiler.compile_into_spirv(
+            &shader.src,
+            shader.kind,
+            &shader.src_path.to_str().unwrap(),
+            "main",
+            None,
+        )?;
+        write(shader.spv_path, compiled.as_binary_u8())?;
+    }
+
+    Ok(())
+}
diff --git a/examples/hello-world/main.rs b/examples/hello-world/main.rs
index 35f57f6..3893f67 100644
--- a/examples/hello-world/main.rs
+++ b/examples/hello-world/main.rs
@@ -1,38 +1,47 @@
 use scion::application::Scion;
+use scion::game_layer::{GameLayer, SimpleGameLayer};
 use scion::legion::{system, Resources, World};
-use scion::utils::time::Time;
-use scion::game_layer::{SimpleGameLayer, GameLayer};
-
+use scion::renderer::bidimensional::material::{Material2D, Texture2D};
+use scion::renderer::bidimensional::transform::{Position2D, Transform2D};
 use scion::renderer::bidimensional::triangle::Triangle;
-use scion::renderer::bidimensional::material::{Material2D};
 use scion::renderer::color::Color;
-use scion::renderer::bidimensional::transform::{Transform2D, Position2D};
+use scion::utils::time::Time;
+use std::path::Path;
 
 fn triangle() -> Triangle {
     Triangle {
         vertices: [
             Position2D { x: -0.5, y: -0.5 },
             Position2D { x: 0.5, y: -0.5 },
-            Position2D { x: 0., y: 0.5 }
+            Position2D { x: 0., y: 0.5 },
         ],
         uvs: None,
     }
 }
 
 #[system(for_each)]
-fn color(#[state] timer: &mut f32, #[resource] time: &Time, material: &mut Material2D, transform: &mut Transform2D) {
+fn color(
+    #[state] timer: &mut f32,
+    #[resource] time: &Time,
+    material: &mut Material2D,
+    transform: &mut Transform2D,
+) {
     *timer += time.delta_duration().as_secs_f32();
     if *timer > 0.01 {
         *timer = 0.;
         match material {
             Material2D::Color(color) => {
-                let new_red = if color.red() < 255 { color.red() + 1 } else { 0 };
+                let new_red = if color.red() < 255 {
+                    color.red() + 1
+                } else {
+                    0
+                };
                 color.replace(Color::new_rgb(new_red, color.green(), color.blue()));
             }
             _ => {}
         }
+        transform.append_angle(0.1);
     }
-    transform.append_angle(0.1);
 }
 
 #[derive(Default)]
@@ -40,12 +49,17 @@ struct Layer;
 
 impl SimpleGameLayer for Layer {
     fn on_start(&mut self, world: &mut World, _resource: &mut Resources) {
-        let triangle1 =
-            (triangle(),
-             Material2D::Color(Color::new(0, 47, 110, 1.0)),
-             Transform2D::new(Position2D { x: 0.0, y: 0.0 }, 0.5, 0.)
-            );
-        world.extend(vec![triangle1]);
+        let triangle1 = (
+            triangle(),
+            Material2D::Texture(Texture2D::from_png(Path::new("Yo"))),
+            Transform2D::new(Position2D { x: -1.0, y: 0.0 }, 0.5, 0.),
+        );
+        let triangle2 = (
+            triangle(),
+            Material2D::Texture(Texture2D::from_png(Path::new("Yo"))),
+            Transform2D::new(Position2D { x: 1.0, y: 0.0 }, 0.5, 0.),
+        );
+        world.extend(vec![triangle1, triangle2]);
     }
 }
 
@@ -54,4 +68,4 @@ fn main() {
         .with_system(color_system(0.))
         .with_game_layer(GameLayer::weak::<Layer>())
         .run();
-}
\ No newline at end of file
+}
diff --git a/src/application.rs b/src/application.rs
index 1996743..04f3313 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -1,42 +1,29 @@
-use legion::{Resources, Schedule, World};
 use legion::systems::{Builder, ParallelRunnable, Runnable};
+use legion::{Resources, Schedule, World};
 use log::info;
-use miniquad::{conf, Context, EventHandlerFree, UserData};
 
 use crate::config::scion_config::{ScionConfig, ScionConfigReader};
 use crate::utils::time::Time;
-use crate::utils::window::WindowDimensions;
-use crate::renderer::{RendererType, ScionRenderer};
 
+use crate::renderer::RendererType;
+
+use crate::game_layer::{GameLayer, GameLayerType, LayerAction};
+use winit::event::{Event, WindowEvent};
+use winit::event_loop::{ControlFlow, EventLoop};
+use winit::window::{Window, WindowBuilder};
 
-use crate::game_layer::{GameLayer, SimpleGameLayer, GameLayerType, LayerAction};
+use crate::renderer::renderer_state::RendererState;
 
 /// `Scion` is the entry point of any application made with Scion engine.
 pub struct Scion {
+    #[allow(dead_code)]
     config: ScionConfig,
     world: World,
     resources: Resources,
     schedule: Schedule,
     game_layers: Vec<Box<GameLayer>>,
-    context: Option<Context>,
-    renderer: Box<dyn ScionRenderer>,
-}
-
-impl EventHandlerFree for Scion {
-    fn update(&mut self) {
-        self.next_frame();
-    }
-
-    fn draw(&mut self) {
-        self.renderer.draw(
-            self.context.as_mut().expect("Miniquad context is mandatory"),
-            &mut self.world, &mut self.resources)
-    }
-
-    fn resize_event(&mut self, w: f32, h: f32) {
-        self.resources
-            .get_mut::<WindowDimensions>().expect("Missing Screen Dimension Resource. Did something deleted it ?").set(w, h);
-    }
+    window: Option<Window>,
+    renderer: Option<RendererState>,
 }
 
 impl Scion {
@@ -58,38 +45,105 @@ impl Scion {
         ScionBuilder::new(app_config)
     }
 
-    fn setup(mut self, context: Context) -> Self {
-        let screen_size = context.screen_size();
-        self.context = Some(context);
+    pub fn run(mut self, event_loop: EventLoop<()>) {
+        event_loop.run(move |event, _, control_flow| {
+            *control_flow = ControlFlow::Poll;
+            match event {
+                Event::WindowEvent {
+                    ref event,
+                    window_id,
+                } if window_id
+                    == self
+                        .window
+                        .as_ref()
+                        .expect("A window is mandatory to run this game !")
+                        .id() =>
+                {
+                    match event {
+                        WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                        WindowEvent::Resized(physical_size) => {
+                            self.renderer
+                                .as_mut()
+                                .expect("A renderer is mandatory to run this game !")
+                                .resize(*physical_size);
+                        }
+                        WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
+                            self.renderer
+                                .as_mut()
+                                .expect("A renderer is mandatory to run this game !")
+                                .resize(**new_inner_size);
+                        }
+                        _ => {}
+                    }
+                }
+                Event::MainEventsCleared => {
+                    self.window.as_ref().unwrap().request_redraw();
+                }
+                Event::RedrawRequested(_) => {
+                    self.renderer
+                        .as_mut()
+                        .expect("A renderer is mandatory to run this game !")
+                        .update(&mut self.world);
+                    match self
+                        .renderer
+                        .as_mut()
+                        .expect("A renderer is mandatory to run this game !")
+                        .render(&mut self.world, &mut self.resources)
+                    {
+                        Ok(_) => {}
+                        Err(e) => log::error!("{:?}", e),
+                    }
+                }
+                _ => (),
+            }
+            self.next_frame();
+        });
+    }
+
+    fn setup(&mut self) {
+        //let screen_size = context.screen_size();
         self.resources.insert(Time::default());
-        self.resources.insert(WindowDimensions::new(screen_size));
-        self.apply_layers_action(LayerAction::START);
-        self
+        // self.resources.insert(WindowDimensions::new(screen_size));
+        self.apply_layers_action(LayerAction::Start);
     }
 
     fn next_frame(&mut self) {
-        self.apply_layers_action(LayerAction::UPDATE);
-        self.resources.get_mut::<Time>().expect("Time is an internal resource and can't be missing").frame();
+        self.apply_layers_action(LayerAction::Update);
+        self.resources
+            .get_mut::<Time>()
+            .expect("Time is an internal resource and can't be missing")
+            .frame();
         self.schedule.execute(&mut self.world, &mut self.resources);
-        self.apply_layers_action(LayerAction::LATE_UPDATE);
+        self.apply_layers_action(LayerAction::LateUpdate);
     }
 
     fn apply_layers_action(&mut self, action: LayerAction) {
         let layers_len = self.game_layers.len();
         if layers_len > 0 {
-            for layer_index in (0..layers_len).rev(){
-                let current_layer = self.game_layers.get_mut(layer_index).expect("We just checked the len");
+            for layer_index in (0..layers_len).rev() {
+                let current_layer = self
+                    .game_layers
+                    .get_mut(layer_index)
+                    .expect("We just checked the len");
                 match &mut current_layer.layer {
                     GameLayerType::Strong(simple_layer) | GameLayerType::Weak(simple_layer) => {
                         match action {
-                            LayerAction::UPDATE => simple_layer.update(&mut self.world, &mut self.resources),
-                            LayerAction::START => simple_layer.on_start(&mut self.world, &mut self.resources),
-                            LayerAction::STOP => simple_layer.on_stop(&mut self.world, &mut self.resources),
-                            LayerAction::LATE_UPDATE => simple_layer.late_update(&mut self.world, &mut self.resources),
+                            LayerAction::Update => {
+                                simple_layer.update(&mut self.world, &mut self.resources)
+                            }
+                            LayerAction::Start => {
+                                simple_layer.on_start(&mut self.world, &mut self.resources)
+                            }
+                            LayerAction::_STOP => {
+                                simple_layer.on_stop(&mut self.world, &mut self.resources)
+                            }
+                            LayerAction::LateUpdate => {
+                                simple_layer.late_update(&mut self.world, &mut self.resources)
+                            }
                         };
                     }
                 }
-                if let GameLayerType::Strong(_) = current_layer.layer{
+                if let GameLayerType::Strong(_) = current_layer.layer {
                     break;
                 }
             }
@@ -101,7 +155,7 @@ pub struct ScionBuilder {
     config: ScionConfig,
     schedule_builder: Builder,
     renderer: RendererType,
-    game_layers: Vec<Box<GameLayer>>
+    game_layers: Vec<Box<GameLayer>>,
 }
 
 impl ScionBuilder {
@@ -110,7 +164,7 @@ impl ScionBuilder {
             config,
             schedule_builder: Default::default(),
             renderer: Default::default(),
-            game_layers: Default::default()
+            game_layers: Default::default(),
         }
     }
 
@@ -132,33 +186,41 @@ impl ScionBuilder {
         self
     }
 
-    pub fn with_renderer(mut self, renderer_type: RendererType) -> Self{
+    pub fn with_renderer(mut self, renderer_type: RendererType) -> Self {
         self.renderer = renderer_type;
         self
     }
 
-    pub fn with_game_layer(mut self, game_layer: Box<GameLayer>) -> Self{
+    pub fn with_game_layer(mut self, game_layer: Box<GameLayer>) -> Self {
         self.game_layers.push(game_layer);
         self
     }
 
     /// Builds, setups and runs the Scion application
     pub fn run(mut self) {
-        let scion = Scion {
+        let event_loop = EventLoop::new();
+        let window_builder: WindowBuilder = self
+            .config
+            .window_config
+            .clone()
+            .expect("The window configuration has not been found")
+            .into();
+        let window = window_builder.build(&event_loop).expect("");
+        let renderer = self.renderer.into_boxed_renderer();
+        let renderer_state = futures::executor::block_on(
+            crate::renderer::renderer_state::RendererState::new(&window, renderer),
+        );
+        let mut scion = Scion {
             config: self.config,
             world: Default::default(),
             resources: Default::default(),
             schedule: self.schedule_builder.build(),
             game_layers: self.game_layers,
-            context: None,
-            renderer: self.renderer.into_boxed_renderer()
+            window: Some(window),
+            renderer: Some(renderer_state),
         };
 
-        let mut miniquad_conf = conf::Conf::default();
-        miniquad_conf.high_dpi=true;
-        if let Some(window_config) = scion.config.window_config.as_ref() {
-            miniquad_conf.fullscreen = window_config.fullscreen;
-        }
-        miniquad::start(miniquad_conf, |ctx| UserData::free(scion.setup(ctx)));
+        scion.setup();
+        scion.run(event_loop);
     }
 }
diff --git a/src/config/logger_config.rs b/src/config/logger_config.rs
index 6e46c19..95fc99a 100644
--- a/src/config/logger_config.rs
+++ b/src/config/logger_config.rs
@@ -1,5 +1,5 @@
-use serde::{Serialize, Deserialize};
 use log::LevelFilter;
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct LoggerConfig {
@@ -12,4 +12,4 @@ impl Default for LoggerConfig {
             level_filter: LevelFilter::Info,
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/config/mod.rs b/src/config/mod.rs
index 64c08a8..d9f5afd 100644
--- a/src/config/mod.rs
+++ b/src/config/mod.rs
@@ -1,3 +1,3 @@
+pub mod logger_config;
 pub mod scion_config;
 pub mod window_config;
-pub mod logger_config;
diff --git a/src/config/scion_config.rs b/src/config/scion_config.rs
index 560c5fd..7a6c187 100644
--- a/src/config/scion_config.rs
+++ b/src/config/scion_config.rs
@@ -28,28 +28,28 @@ impl Default for ScionConfig {
     }
 }
 
-pub struct ScionConfigBuilder{
-    config: ScionConfig
+pub struct ScionConfigBuilder {
+    config: ScionConfig,
 }
 
-impl ScionConfigBuilder{
-    pub fn new() -> Self{
+impl ScionConfigBuilder {
+    pub fn new() -> Self {
         Self {
-            config:Default::default()
+            config: Default::default(),
         }
     }
 
-    pub fn with_app_name(mut self, app_name: String )-> Self{
+    pub fn with_app_name(mut self, app_name: String) -> Self {
         self.config.app_name = app_name;
         self
     }
 
-    pub fn with_logger_config(mut self, logger_config: LoggerConfig)-> Self{
+    pub fn with_logger_config(mut self, logger_config: LoggerConfig) -> Self {
         self.config.logger_config = Some(logger_config);
         self
     }
 
-    pub fn with_window_config(mut self, window_config: WindowConfig)-> Self{
+    pub fn with_window_config(mut self, window_config: WindowConfig) -> Self {
         self.config.window_config = Some(window_config);
         self
     }
diff --git a/src/config/window_config.rs b/src/config/window_config.rs
index 649d2f1..921ff33 100644
--- a/src/config/window_config.rs
+++ b/src/config/window_config.rs
@@ -1,56 +1,74 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use winit::dpi::Size;
+use winit::window::{WindowAttributes, WindowBuilder};
 
-#[derive(Debug, Serialize, Deserialize)]
+/// Main configuration for the game window
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct WindowConfig {
-    pub(crate) width: i32,
-    pub(crate) height: i32,
+    /// Window title
     pub(crate) title: String,
+    /// Enables fullscreen mode
     pub(crate) fullscreen: bool,
+    /// Default window width and height in pixels.
+    pub(crate) dimensions: Option<(u32, u32)>,
+    /// Minimum window width and height in pixels.
+    pub(crate) min_dimensions: Option<(u32, u32)>,
+    /// Maximum window width and height in pixels.
+    pub(crate) max_dimensions: Option<(u32, u32)>,
+    /// Whether to display the window, Use full for loading
+    pub(crate) visibility: bool,
+    /// The path relative to the game executable of the window icon.
+    pub(crate) icon: Option<PathBuf>,
+    /// Whether the window should always be on top of other windows.
+    pub(crate) always_on_top: bool,
+    /// Whether the window should have borders and bars.
+    pub(crate) decorations: bool,
+    /// Whether the window should be maximized upon creation.
+    pub(crate) maximized: bool,
+    /// If the user can resize the window
+    pub(crate) resizable: bool,
+    /// If the window should be able to be transparent.
+    pub(crate) transparent: bool,
 }
 
 impl Default for WindowConfig {
     fn default() -> Self {
         Self {
-            width: 800,
-            height: 600,
-            title: "Default window".to_string(),
+            title: "Default Scion game".to_string(),
             fullscreen: false,
+            dimensions: Some((1024, 768)),
+            min_dimensions: Some((640, 480)),
+            max_dimensions: None,
+            visibility: true,
+            icon: None,
+            always_on_top: false,
+            decorations: true,
+            maximized: false,
+            resizable: true,
+            transparent: false,
         }
     }
 }
 
-pub struct WindowConfigBuilder {
-    config: WindowConfig
-}
-
-impl WindowConfigBuilder {
-    pub fn new() -> Self {
-        Self {
-            config: Default::default()
-        }
-    }
-
-    pub fn with_title(mut self, title: String) -> Self {
-        self.config.title = title;
-        self
-    }
+impl Into<WindowBuilder> for WindowConfig {
+    fn into(self) -> WindowBuilder {
+        let mut builder = WindowBuilder::new();
 
-    pub fn with_width(mut self, width: i32) -> Self {
-        self.config.width = width;
-        self
+        builder.window = WindowAttributes {
+            title: self.title.clone(),
+            fullscreen: None,
+            inner_size: self.dimensions.map(|d| d.into()).map(Size::Logical),
+            min_inner_size: self.min_dimensions.map(|d| d.into()).map(Size::Logical),
+            max_inner_size: self.max_dimensions.map(|d| d.into()).map(Size::Logical),
+            visible: self.visibility,
+            window_icon: None,
+            always_on_top: self.always_on_top,
+            decorations: self.decorations,
+            maximized: self.maximized,
+            resizable: self.resizable,
+            transparent: self.transparent,
+        };
+        builder
     }
-
-    pub fn with_height(mut self, height: i32) -> Self {
-        self.config.height = height;
-        self
-    }
-
-    pub fn with_fullscreen(mut self, fullscreen: bool) -> Self {
-        self.config.fullscreen = fullscreen;
-        self
-    }
-
-    pub fn get(self) -> WindowConfig {
-        self.config
-    }
-}
\ No newline at end of file
+}
diff --git a/src/game_layer.rs b/src/game_layer.rs
index 01d2c92..c83de74 100644
--- a/src/game_layer.rs
+++ b/src/game_layer.rs
@@ -1,6 +1,5 @@
 use legion::{Resources, World};
 
-
 /// Trait to implement in order to create a `GameLayer`.
 pub trait SimpleGameLayer {
     fn on_start(&mut self, _world: &mut World, _resource: &mut Resources) {}
@@ -10,20 +9,27 @@ pub trait SimpleGameLayer {
 }
 
 pub(crate) enum LayerAction {
-    UPDATE, START, STOP, LATE_UPDATE
+    Update,
+    Start,
+    _STOP,
+    LateUpdate,
 }
 
-pub struct GameLayer{
-    pub(crate) layer: GameLayerType
+pub struct GameLayer {
+    pub(crate) layer: GameLayerType,
 }
 
 impl GameLayer {
     pub fn weak<T: SimpleGameLayer + Default + 'static>() -> Box<GameLayer> {
-        Box::new(GameLayer{layer: GameLayerType::Weak(Box::new(T::default()))})
+        Box::new(GameLayer {
+            layer: GameLayerType::Weak(Box::new(T::default())),
+        })
     }
 
     pub fn strong<T: SimpleGameLayer + Default + 'static>() -> Box<GameLayer> {
-        Box::new(GameLayer{layer: GameLayerType::Strong(Box::new(T::default()))})
+        Box::new(GameLayer {
+            layer: GameLayerType::Strong(Box::new(T::default())),
+        })
     }
 }
 
@@ -33,4 +39,4 @@ pub enum GameLayerType {
     Strong(Box<dyn SimpleGameLayer>),
     /// The next layer under a `WEAK` layer will be executed
     Weak(Box<dyn SimpleGameLayer>),
-}
\ No newline at end of file
+}
diff --git a/src/lib.rs b/src/lib.rs
index 5693412..4e5fdea 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,6 +5,6 @@ pub use ultraviolet;
 // internal export
 pub mod application;
 pub mod config;
-pub mod utils;
+pub mod game_layer;
 pub mod renderer;
-pub mod game_layer;
\ No newline at end of file
+pub mod utils;
diff --git a/src/renderer/bidimensional/gl_representations.rs b/src/renderer/bidimensional/gl_representations.rs
index d1872b8..8874bb6 100644
--- a/src/renderer/bidimensional/gl_representations.rs
+++ b/src/renderer/bidimensional/gl_representations.rs
@@ -1,20 +1,33 @@
-use ultraviolet::{Mat4, Vec4};
 use crate::renderer::bidimensional::transform::Position2D;
+use ultraviolet::{Mat4, Vec4};
 
 #[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct GlVec2 {
     pub x: f32,
     pub y: f32,
 }
 
-impl From<&Position2D> for GlVec2{
+#[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
+pub(crate) struct GlVec3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+impl From<&Position2D> for GlVec3 {
     fn from(position: &Position2D) -> Self {
-        Self{ x: position.x, y: position.y }
+        Self {
+            x: position.x,
+            y: position.y,
+            z: 0.,
+        }
     }
 }
 
 #[repr(C)]
-#[derive(Clone)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct GlColor {
     pub r: f32,
     pub g: f32,
@@ -23,7 +36,7 @@ pub(crate) struct GlColor {
 }
 
 #[repr(C)]
-#[derive(Clone)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct GlVec4 {
     pub x: f32,
     pub y: f32,
@@ -43,24 +56,85 @@ impl From<Vec4> for GlVec4 {
 }
 
 #[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct ColoredGlVertex {
-    pub pos: GlVec2,
+    pub position: GlVec3,
     pub color: GlColor,
 }
 
+impl ColoredGlVertex {
+    pub fn _desc<'a>() -> wgpu::VertexBufferLayout<'a> {
+        wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<ColoredGlVertex>() as wgpu::BufferAddress,
+            step_mode: wgpu::InputStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute {
+                    offset: 0,
+                    shader_location: 0,
+                    format: wgpu::VertexFormat::Float3,
+                },
+                wgpu::VertexAttribute {
+                    offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
+                    shader_location: 1,
+                    format: wgpu::VertexFormat::Float3,
+                },
+            ],
+        }
+    }
+}
+
 #[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct TexturedGlVertex {
-    pub pos: GlVec2,
-    pub uv: GlVec2
+    pub position: GlVec3,
+    pub tex_coords: GlVec2,
+}
+
+impl TexturedGlVertex {
+    pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> {
+        use std::mem;
+        wgpu::VertexBufferLayout {
+            array_stride: mem::size_of::<TexturedGlVertex>() as wgpu::BufferAddress,
+            step_mode: wgpu::InputStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute {
+                    offset: 0,
+                    shader_location: 0,
+                    format: wgpu::VertexFormat::Float3,
+                },
+                wgpu::VertexAttribute {
+                    offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
+                    shader_location: 1,
+                    format: wgpu::VertexFormat::Float2,
+                },
+            ],
+        }
+    }
 }
 
 #[repr(C)]
+#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
 pub(crate) struct GlUniform {
-    pub offset: (f32, f32),
-    pub trans: (GlVec4, GlVec4, GlVec4, GlVec4),
-    pub scale: (GlVec4, GlVec4, GlVec4, GlVec4),
+    pub trans: [[f32; 4]; 4],
+    pub scale: [[f32; 4]; 4],
 }
 
-pub(crate) fn create_glmat4(t: &mut Mat4) -> (GlVec4, GlVec4, GlVec4, GlVec4) {
-    (GlVec4::from(t.cols[0]), GlVec4::from(t.cols[1]), GlVec4::from(t.cols[2]), GlVec4::from(t.cols[3]))
-}
\ No newline at end of file
+impl GlUniform {
+    pub(crate) fn replace_with(&mut self, other: GlUniform) {
+        self.trans = other.trans;
+        self.scale = other.scale;
+    }
+}
+
+pub(crate) fn create_glmat4(t: &mut Mat4) -> [[f32; 4]; 4] {
+    [
+        create_glmat(&t.cols[0]),
+        create_glmat(&t.cols[1]),
+        create_glmat(&t.cols[2]),
+        create_glmat(&t.cols[3]),
+    ]
+}
+
+pub(crate) fn create_glmat(t: &Vec4) -> [f32; 4] {
+    [t.w, t.x, t.y, t.z]
+}
diff --git a/src/renderer/bidimensional/material.rs b/src/renderer/bidimensional/material.rs
index 7fbab4b..ccceed5 100644
--- a/src/renderer/bidimensional/material.rs
+++ b/src/renderer/bidimensional/material.rs
@@ -1,17 +1,18 @@
 use crate::renderer::color::Color;
-use std::path::Path;
-use image::{ImageFormat, DynamicImage};
 use crate::utils::file::read_file;
+use image::{DynamicImage, ImageFormat};
+use std::path::Path;
 
 pub enum Material2D {
     Color(Color),
-    Texture(Texture2D)
+    Texture(Texture2D),
 }
 
 pub struct Texture2D {
+    pub(crate) path: String,
     pub(crate) bytes: Vec<u8>,
     pub(crate) width: u16,
-    pub(crate) height: u16
+    pub(crate) height: u16,
 }
 
 impl Texture2D {
@@ -19,7 +20,10 @@ impl Texture2D {
         if let Ok(bytes) = read_file(&file_path) {
             let converted_image = image::load_from_memory_with_format(&bytes, ImageFormat::Png);
             if let Ok(image) = converted_image {
-                return Texture2D::create_texture_from_dynamic_image(image);
+                return Texture2D::create_texture_from_dynamic_image(
+                    image,
+                    file_path.to_str().unwrap().to_string(),
+                );
             }
         }
         log::error!("Error while loading your texture, loading fallback texture instead.");
@@ -28,15 +32,21 @@ impl Texture2D {
 
     fn fallback_texture() -> Texture2D {
         let bytes = include_bytes!("missing_texture.png");
-        let image = image::load_from_memory_with_format(bytes, ImageFormat::Png).expect("The fallback image has not been found !");
-        return Texture2D::create_texture_from_dynamic_image(image);
+        let image = image::load_from_memory_with_format(bytes, ImageFormat::Png)
+            .expect("The fallback image has not been found !");
+        return Texture2D::create_texture_from_dynamic_image(image, "missing_texture".to_string());
     }
 
-    fn create_texture_from_dynamic_image(dynamic_image: DynamicImage) -> Texture2D {
+    fn create_texture_from_dynamic_image(dynamic_image: DynamicImage, path: String) -> Texture2D {
         let image = dynamic_image.to_rgba8();
         let width = image.width() as u16;
         let height = image.height() as u16;
-        let bytes = image::imageops::flip_vertical(&image).into_raw();
-        Texture2D{ bytes, width, height }
+        let bytes = image.into_raw();
+        Texture2D {
+            bytes,
+            width,
+            height,
+            path,
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/src/renderer/bidimensional/mod.rs b/src/renderer/bidimensional/mod.rs
index 83f88e3..23781ff 100644
--- a/src/renderer/bidimensional/mod.rs
+++ b/src/renderer/bidimensional/mod.rs
@@ -1,5 +1,5 @@
-pub mod renderer;
+pub(crate) mod gl_representations;
 pub mod material;
-pub mod triangle;
+pub mod scion2d;
 pub mod transform;
-pub(crate) mod gl_representations;
\ No newline at end of file
+pub mod triangle;
diff --git a/src/renderer/bidimensional/renderer.rs b/src/renderer/bidimensional/renderer.rs
deleted file mode 100644
index a1d7b16..0000000
--- a/src/renderer/bidimensional/renderer.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use crate::renderer::ScionRenderer;
-use miniquad::Context;
-use legion::{Resources, World, Entity, IntoQuery};
-use crate::renderer::bidimensional::triangle::Triangle;
-use crate::renderer::bidimensional::material::Material2D;
-use crate::renderer::bidimensional::transform::Transform2D;
-use log::info;
-
-pub trait Renderable2D {
-    fn render(&self,
-              context: &mut Context,
-              material: Option<&Material2D>,
-              transform: &Transform2D);
-}
-
-pub struct Scion2D;
-
-impl ScionRenderer for Scion2D {
-    fn draw(&mut self, context: &mut Context, world: &mut World, _resource: &mut Resources) {
-        context.begin_default_pass(Default::default());
-        let mut query_triangles = <(Entity, &Triangle, &Material2D, &Transform2D)>::query();
-        query_triangles.for_each(world, |(_e, triangle, material, transform)| {
-            info!(
-                "rendering triangle {:?}", transform
-            );
-            triangle.render(context, Some(material), transform)
-        });
-        context.end_render_pass();
-        context.commit_frame();
-    }
-}
\ No newline at end of file
diff --git a/src/renderer/bidimensional/scion2d.rs b/src/renderer/bidimensional/scion2d.rs
new file mode 100644
index 0000000..095f73e
--- /dev/null
+++ b/src/renderer/bidimensional/scion2d.rs
@@ -0,0 +1,322 @@
+use std::collections::HashMap;
+
+use legion::{Entity, IntoQuery, World};
+use wgpu::util::DeviceExt;
+use wgpu::{
+    BindGroup, BindGroupLayout, Buffer, CommandEncoder, Device, Queue,
+    RenderPassColorAttachmentDescriptor, RenderPipeline, SwapChainDescriptor, SwapChainTexture,
+};
+
+use crate::renderer::bidimensional::gl_representations::{
+    GlUniform, GlVec2, GlVec3, TexturedGlVertex,
+};
+use crate::renderer::bidimensional::material::{Material2D, Texture2D};
+use crate::renderer::bidimensional::transform::Transform2D;
+use crate::renderer::bidimensional::triangle::{triangle_pipeline, Triangle};
+use crate::renderer::ScionRenderer;
+
+const VERTICES: &[TexturedGlVertex] = &[
+    TexturedGlVertex {
+        position: GlVec3 {
+            x: -0.5,
+            y: -0.5,
+            z: 0.0,
+        },
+        tex_coords: GlVec2 { x: 0.0, y: 1. },
+    },
+    TexturedGlVertex {
+        position: GlVec3 {
+            x: 0.5,
+            y: -0.5,
+            z: 0.0,
+        },
+        tex_coords: GlVec2 { x: 1.0, y: 1.0 },
+    },
+    TexturedGlVertex {
+        position: GlVec3 {
+            x: 0.0,
+            y: 0.5,
+            z: 0.0,
+        },
+        tex_coords: GlVec2 { x: 0.5, y: 0.0 },
+    },
+];
+
+pub trait Renderable2D {
+    fn render(&self, material: Option<&Material2D>, transform: &Transform2D);
+}
+
+#[derive(Default)]
+pub struct Scion2D {
+    vertex_buffers: HashMap<Entity, wgpu::Buffer>,
+    render_pipelines: HashMap<String, RenderPipeline>,
+    diffuse_bind_groups: HashMap<String, (BindGroupLayout, BindGroup)>,
+    transform_uniform_bind_groups: HashMap<Entity, (GlUniform, Buffer, BindGroupLayout, BindGroup)>,
+}
+
+impl ScionRenderer for Scion2D {
+    fn update(
+        &mut self,
+        world: &mut World,
+        device: &Device,
+        sc_desc: &SwapChainDescriptor,
+        queue: &mut Queue,
+    ) {
+        self.load_textures_to_queue(world, device, queue);
+
+        // Inserting of updating the transforms
+        for (entity, transform) in <(Entity, &Transform2D)>::query().iter_mut(world) {
+            if !self.transform_uniform_bind_groups.contains_key(entity) {
+                let (uniform, uniform_buffer, glayout, group) =
+                    create_transform_uniform_bind_group(&device, transform);
+                queue.write_buffer(&uniform_buffer, 0, bytemuck::cast_slice(&[uniform]));
+                self.transform_uniform_bind_groups
+                    .insert(*entity, (uniform, uniform_buffer, glayout, group));
+            } else {
+                let (uniform, uniform_buffer, _, _) = self
+                    .transform_uniform_bind_groups
+                    .get_mut(entity)
+                    .expect("Fatal error, a transform has been marked as found but doesn't exist");
+                uniform.replace_with(GlUniform::from(transform));
+                queue.write_buffer(uniform_buffer, 0, bytemuck::cast_slice(&[*uniform]));
+            }
+        }
+
+        for (entity, _triangle, material, _transform) in
+            <(Entity, &mut Triangle, &Material2D, &Transform2D)>::query().iter_mut(world)
+        {
+            if !self.vertex_buffers.contains_key(entity) {
+                let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                    label: Some("Vertex Buffer"),
+                    contents: bytemuck::cast_slice(VERTICES),
+                    usage: wgpu::BufferUsage::VERTEX,
+                });
+                self.vertex_buffers.insert(*entity, vertex_buffer);
+            }
+
+            match material {
+                Material2D::Color(_) => {}
+                Material2D::Texture(texture) => {
+                    if !self.render_pipelines.contains_key(&texture.path) {
+                        self.render_pipelines.insert(
+                            texture.path.clone(),
+                            triangle_pipeline(
+                                &device,
+                                &sc_desc,
+                                &self.diffuse_bind_groups.get(&texture.path).unwrap().0,
+                                &self.transform_uniform_bind_groups.get(entity).unwrap().2,
+                            ),
+                        );
+                    }
+                }
+            };
+        }
+    }
+
+    fn render(
+        &mut self,
+        world: &mut World,
+        frame: &SwapChainTexture,
+        encoder: &mut CommandEncoder,
+    ) {
+        {
+            let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Scion 2D Render Pass"),
+                color_attachments: &[get_default_color_attachment(frame)],
+                depth_stencil_attachment: None,
+            });
+
+            let mut query_triangles = <(Entity, &mut Triangle, &Material2D, &Transform2D)>::query();
+            let triangles: Vec<(&Entity, &mut Triangle, &Material2D, &Transform2D)> =
+                query_triangles.iter_mut(world).map(|e| e).collect();
+            for (entity, _triangle, material, _transform) in triangles.iter() {
+                match material {
+                    Material2D::Color(_) => {}
+                    Material2D::Texture(texture) => {
+                        render_pass.set_pipeline(
+                            self.render_pipelines.get(&texture.path).as_ref().unwrap(),
+                        );
+                        render_pass.set_bind_group(
+                            0,
+                            &self.diffuse_bind_groups.get(&texture.path).unwrap().1,
+                            &[],
+                        );
+                        render_pass.set_bind_group(
+                            1,
+                            &self.transform_uniform_bind_groups.get(*entity).unwrap().3,
+                            &[],
+                        );
+                        render_pass.set_vertex_buffer(
+                            0,
+                            self.vertex_buffers.get(*entity).as_ref().unwrap().slice(..),
+                        );
+                        render_pass.draw(0..VERTICES.len() as u32, 0..1);
+                    }
+                };
+            }
+        }
+    }
+}
+
+impl Scion2D {
+    /// Loads in the queue materials that are not yet loaded.
+    fn load_textures_to_queue(&mut self, world: &mut World, device: &Device, queue: &mut Queue) {
+        <(Entity, &Material2D)>::query().for_each(world, |(_entity, material)| match material {
+            Material2D::Texture(texture) => {
+                if !self.diffuse_bind_groups.contains_key(&texture.path) {
+                    self.diffuse_bind_groups.insert(
+                        texture.path.clone(),
+                        load_texture_to_queue(&texture, queue, device),
+                    );
+                }
+            }
+            _ => {}
+        });
+    }
+}
+
+fn load_texture_to_queue(
+    texture: &Texture2D,
+    queue: &mut Queue,
+    device: &Device,
+) -> (BindGroupLayout, BindGroup) {
+    let texture_size = wgpu::Extent3d {
+        width: texture.width as u32,
+        height: texture.height as u32,
+        depth: 1,
+    };
+
+    let diffuse_texture = device.create_texture(&wgpu::TextureDescriptor {
+        size: texture_size,
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: wgpu::TextureFormat::Rgba8UnormSrgb,
+        usage: wgpu::TextureUsage::SAMPLED | wgpu::TextureUsage::COPY_DST,
+        label: Some("diffuse_texture"),
+    });
+    queue.write_texture(
+        wgpu::TextureCopyView {
+            texture: &diffuse_texture,
+            mip_level: 0,
+            origin: wgpu::Origin3d::ZERO,
+        },
+        &*texture.bytes,
+        wgpu::TextureDataLayout {
+            offset: 0,
+            bytes_per_row: (4 * texture.width) as u32,
+            rows_per_image: texture.height as u32,
+        },
+        texture_size,
+    );
+    let diffuse_texture_view = diffuse_texture.create_view(&wgpu::TextureViewDescriptor::default());
+    let diffuse_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+        address_mode_u: wgpu::AddressMode::Repeat,
+        address_mode_v: wgpu::AddressMode::Repeat,
+        address_mode_w: wgpu::AddressMode::Repeat,
+        mag_filter: wgpu::FilterMode::Linear,
+        min_filter: wgpu::FilterMode::Linear,
+        mipmap_filter: wgpu::FilterMode::Linear,
+        ..Default::default()
+    });
+    let texture_bind_group_layout =
+        device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStage::FRAGMENT,
+                    ty: wgpu::BindingType::Texture {
+                        multisampled: false,
+                        view_dimension: wgpu::TextureViewDimension::D2,
+                        sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                    },
+                    count: None,
+                },
+                wgpu::BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: wgpu::ShaderStage::FRAGMENT,
+                    ty: wgpu::BindingType::Sampler {
+                        comparison: false,
+                        filtering: true,
+                    },
+                    count: None,
+                },
+            ],
+            label: Some("texture_bind_group_layout"),
+        });
+
+    let diffuse_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        layout: &texture_bind_group_layout,
+        entries: &[
+            wgpu::BindGroupEntry {
+                binding: 0,
+                resource: wgpu::BindingResource::TextureView(&diffuse_texture_view),
+            },
+            wgpu::BindGroupEntry {
+                binding: 1,
+                resource: wgpu::BindingResource::Sampler(&diffuse_sampler),
+            },
+        ],
+        label: Some("diffuse_bind_group"),
+    });
+    (texture_bind_group_layout, diffuse_bind_group)
+}
+
+fn create_transform_uniform_bind_group(
+    device: &Device,
+    transform: &Transform2D,
+) -> (GlUniform, Buffer, BindGroupLayout, BindGroup) {
+    let uniform = GlUniform::from(transform);
+    let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        label: Some("Uniform Buffer"),
+        contents: bytemuck::cast_slice(&[uniform]),
+        usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
+    });
+
+    let uniform_bind_group_layout =
+        device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStage::VERTEX,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            }],
+            label: Some("uniform_bind_group_layout"),
+        });
+
+    let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        layout: &uniform_bind_group_layout,
+        entries: &[wgpu::BindGroupEntry {
+            binding: 0,
+            resource: uniform_buffer.as_entire_binding(),
+        }],
+        label: Some("uniform_bind_group"),
+    });
+
+    (
+        uniform,
+        uniform_buffer,
+        uniform_bind_group_layout,
+        uniform_bind_group,
+    )
+}
+
+fn get_default_color_attachment(frame: &SwapChainTexture) -> RenderPassColorAttachmentDescriptor {
+    wgpu::RenderPassColorAttachmentDescriptor {
+        attachment: &frame.view,
+        resolve_target: None,
+        ops: wgpu::Operations {
+            load: wgpu::LoadOp::Clear(wgpu::Color {
+                r: 0.,
+                g: 0.2,
+                b: 0.7,
+                a: 1.0,
+            }),
+            store: true,
+        },
+    }
+}
diff --git a/src/renderer/bidimensional/shaders/shader.frag b/src/renderer/bidimensional/shaders/shader.frag
new file mode 100644
index 0000000..3a38d4e
--- /dev/null
+++ b/src/renderer/bidimensional/shaders/shader.frag
@@ -0,0 +1,15 @@
+// shader.frag
+#version 450
+
+// Changed
+layout(location=0) in vec2 v_tex_coords;
+layout(location=0) out vec4 f_color;
+
+// NEW!
+layout(set = 0, binding = 0) uniform texture2D t_diffuse;
+layout(set = 0, binding = 1) uniform sampler s_diffuse;
+
+void main() {
+    // Changed
+    f_color = texture(sampler2D(t_diffuse, s_diffuse), v_tex_coords);
+}
\ No newline at end of file
diff --git a/src/renderer/bidimensional/shaders/shader.frag.spv b/src/renderer/bidimensional/shaders/shader.frag.spv
new file mode 100644
index 0000000..d00b289
Binary files /dev/null and b/src/renderer/bidimensional/shaders/shader.frag.spv differ
diff --git a/src/renderer/bidimensional/shaders/shader.vert b/src/renderer/bidimensional/shaders/shader.vert
new file mode 100644
index 0000000..61770e6
--- /dev/null
+++ b/src/renderer/bidimensional/shaders/shader.vert
@@ -0,0 +1,17 @@
+// shader.vert
+#version 450
+
+layout(location=0) in vec3 a_position;
+layout(location=1) in vec2 a_tex_coords;
+layout(location=0) out vec2 v_tex_coords;
+
+layout(set=1, binding=0)
+uniform Uniforms {
+    mat4 trans;
+    mat4 scale;
+};
+
+void main() {
+    v_tex_coords = a_tex_coords;
+    gl_Position = (trans * vec4(a_position, 1.0)) * scale;
+}
\ No newline at end of file
diff --git a/src/renderer/bidimensional/shaders/shader.vert.spv b/src/renderer/bidimensional/shaders/shader.vert.spv
new file mode 100644
index 0000000..880aa06
Binary files /dev/null and b/src/renderer/bidimensional/shaders/shader.vert.spv differ
diff --git a/src/renderer/bidimensional/transform.rs b/src/renderer/bidimensional/transform.rs
index a5a3884..0690d55 100644
--- a/src/renderer/bidimensional/transform.rs
+++ b/src/renderer/bidimensional/transform.rs
@@ -1,33 +1,35 @@
+use crate::renderer::bidimensional::gl_representations::{create_glmat4, GlUniform};
+use ultraviolet::{Isometry3, Rotor3, Similarity3, Vec3};
+
 #[derive(Default, Debug, Copy, Clone)]
 pub struct Position2D {
     pub x: f32,
-    pub y: f32
+    pub y: f32,
 }
 
 #[derive(Debug)]
 pub struct Transform2D {
     pub(crate) position: Position2D,
     pub(crate) scale: f32,
-    pub(crate) angle: f32
+    pub(crate) angle: f32,
 }
 
-impl Default for Transform2D{
+impl Default for Transform2D {
     fn default() -> Self {
         Self {
             position: Default::default(),
             scale: 1.0,
-            angle: 0.0
+            angle: 0.0,
         }
     }
 }
 
 impl Transform2D {
-
-    pub fn new(position: Position2D, scale: f32, angle: f32) -> Self{
+    pub fn new(position: Position2D, scale: f32, angle: f32) -> Self {
         Self {
             position,
             scale,
-            angle
+            angle,
         }
     }
 
@@ -41,4 +43,24 @@ impl Transform2D {
     }
 }
 
+impl From<&Transform2D> for GlUniform {
+    fn from(transform: &Transform2D) -> Self {
+        let mut transform_rotate = Isometry3::identity();
+        transform_rotate.append_translation(Vec3 {
+            x: transform.position.x,
+            y: transform.position.y,
+            z: 1.0,
+        });
+        transform_rotate.prepend_rotation(Rotor3::from_rotation_xy(transform.angle).normalized());
+
+        let mut scale = Similarity3::identity();
+        scale.append_scaling(transform.scale);
 
+        let mut transform_rotate = transform_rotate.into_homogeneous_matrix();
+        let mut scale = scale.into_homogeneous_matrix();
+        GlUniform {
+            trans: create_glmat4(&mut transform_rotate),
+            scale: create_glmat4(&mut scale),
+        }
+    }
+}
diff --git a/src/renderer/bidimensional/triangle.rs b/src/renderer/bidimensional/triangle.rs
index f3df9b6..c541fbe 100644
--- a/src/renderer/bidimensional/triangle.rs
+++ b/src/renderer/bidimensional/triangle.rs
@@ -1,186 +1,60 @@
-use miniquad::{Context, Buffer, BufferType, Bindings, Shader, Pipeline, BufferLayout, VertexAttribute, VertexFormat};
-use crate::renderer::bidimensional::gl_representations::{ColoredGlVertex, GlVec2, GlColor, GlUniform, create_glmat4, TexturedGlVertex};
-use crate::renderer::bidimensional::material::{Material2D, Texture2D};
-use ultraviolet::{Isometry3, Similarity3, Vec4, Vec3, Rotor3, Rotor2, Similarity2, Vec2, Mat4};
-use crate::renderer::bidimensional::renderer::Renderable2D;
-use crate::renderer::bidimensional::transform::{Transform2D, Position2D};
-use image::{GenericImageView};
-use crate::renderer::color::Color;
+use wgpu::{BindGroupLayout, Device, RenderPipeline, SwapChainDescriptor};
+
+use crate::renderer::bidimensional::gl_representations::TexturedGlVertex;
+
+use crate::renderer::bidimensional::transform::Position2D;
 
 pub struct Triangle {
     pub vertices: [Position2D; 3],
     pub uvs: Option<[Position2D; 3]>,
 }
 
-impl Triangle {
-    pub fn render_colored(&self, context: &mut Context, transform: &Transform2D, color: &Color) -> (Pipeline, Bindings){
-        let color: GlColor = color.into();
-        let vertices: [ColoredGlVertex; 3] = [
-            ColoredGlVertex { pos: GlVec2::from(&self.vertices[0]), color: color.clone() },
-            ColoredGlVertex { pos: GlVec2::from(&self.vertices[1]), color: color.clone() },
-            ColoredGlVertex { pos: GlVec2::from(&self.vertices[2]), color },
-        ];
-
-        let vertex_buffer = Buffer::immutable(context, BufferType::VertexBuffer, &vertices);
-        let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
-        let index_buffer = Buffer::immutable(context, BufferType::IndexBuffer, &indices);
-
-        let bindings = Bindings {
-            vertex_buffers: vec![vertex_buffer],
-            index_buffer,
-            images: vec![],
-        };
-
-        let shader = Shader::new(context, shader::VERTEX_COLORED, shader::FRAGMENT_COLORED, shader::meta(vec![])).unwrap();
-
-        let pipeline = Pipeline::new(
-            context,
-            &[BufferLayout::default()],
-            &[
-                VertexAttribute::new("pos", VertexFormat::Float2),
-                VertexAttribute::new("color", VertexFormat::Float4),
-            ],
-            shader,
-        );
-
-        (pipeline, bindings)
-
-    }
-
-    pub fn render_textured(&self, context: &mut Context, transform: &Transform2D, texture: &Texture2D) -> (Pipeline, Bindings){
-        let uvs = self.uvs.unwrap_or_else(|| {
-            log::error!("No uv map found for shape with Texture2D material. Using default positions.");
-            [Position2D { x: 0.0, y: 0.0 }; 3]
-        });
-        let vertices: [TexturedGlVertex; 3] = [
-            TexturedGlVertex { pos: GlVec2::from(&self.vertices[0]), uv: GlVec2::from(&uvs[0]) },
-            TexturedGlVertex { pos: GlVec2::from(&self.vertices[1]), uv: GlVec2::from(&uvs[1]) },
-            TexturedGlVertex { pos: GlVec2::from(&self.vertices[2]), uv: GlVec2::from(&uvs[2]) },
-        ];
-        let vertex_buffer = Buffer::immutable(context, BufferType::VertexBuffer, &vertices);
-        let indices: [u16; 6] = [0, 1, 2, 0, 2, 3];
-        let index_buffer = Buffer::immutable(context, BufferType::IndexBuffer, &indices);
-
-        let bindings = Bindings {
-            vertex_buffers: vec![vertex_buffer],
-            index_buffer,
-            images: vec![miniquad::Texture::from_rgba8(context, texture.width, texture.height, &texture.bytes)],
-        };
-
-        let shader = Shader::new(context, shader::VERTEX_TEXTURED, shader::FRAGMENT_TEXTURED, shader::meta(vec!["tex".to_string()])).unwrap();
-
-        let pipeline = Pipeline::new(
-            context,
-            &[BufferLayout::default()],
-            &[
-                VertexAttribute::new("pos", VertexFormat::Float2),
-                VertexAttribute::new("uv", VertexFormat::Float2),
-            ],
-            shader,
-        );
-
-        (pipeline, bindings)
-    }
-}
-
-impl Renderable2D for Triangle {
-    fn render(&self, context: &mut Context, material: Option<&Material2D>, transform: &Transform2D) {
-        let (pipeline, bindings) = match material.expect("Render function must not be called without a material") {
-            Material2D::Color(color) => self.render_colored(context, transform, &color),
-            Material2D::Texture(texture) => self.render_textured(context, transform, &texture)
-        };
-
-        context.apply_pipeline(&pipeline);
-        context.apply_bindings(&bindings);
-
-        let mut transform_rotate = Isometry3::identity();
-        transform_rotate.append_translation(Vec3 {
-            x: transform.position.x,
-            y: transform.position.y,
-            z: 1.0,
-        });
-        transform_rotate.prepend_rotation(Rotor3::from_rotation_xy(transform.angle).normalized());
-
-        let mut scale = Similarity3::identity();
-        scale.append_scaling(transform.scale);
-
-        let mut transform_rotate = transform_rotate.into_homogeneous_matrix();
-        let mut scale = scale.into_homogeneous_matrix();
-
-        context.apply_uniforms(&GlUniform { offset: (0., 0.), trans: create_glmat4(&mut transform_rotate), scale: create_glmat4(&mut scale) });
-
-        context.draw(0, 3, 1);
-    }
-}
-
-
-mod shader {
-    use miniquad::*;
-
-    pub const VERTEX_TEXTURED: &str =
-        r#"
-            #version 330 core
-            in vec2 pos;
-            in vec2 uv;
-
-            uniform mat4 trans;
-            uniform mat4 scale;
-            uniform vec2 offset;
-
-            out lowp vec2 texcoord;
-            void main() {
-                gl_Position = (trans * vec4(pos, 0, 1)) * scale;
-                texcoord = uv;
-            }
-        "#;
-
-    pub const VERTEX_COLORED: &str =
-        r#"
-            #version 330 core
-            in vec2 pos;
-            in vec4 color;
-
-            uniform mat4 trans;
-            uniform mat4 scale;
-            uniform vec2 offset;
-
-            out lowp vec4 color_lowp;
-            void main() {
-                gl_Position = (trans * vec4(pos, 0, 1)) * scale;
-                color_lowp = color;
-            }
-        "#;
-
-    pub const FRAGMENT_COLORED: &str =
-        r#"
-            #version 330 core
-            in lowp vec4 color_lowp;
-            out vec4 FragColor;
-            void main() {
-                FragColor = color_lowp;
-            }
-        "#;
-
-    pub const FRAGMENT_TEXTURED: &str =
-        r#"
-            #version 330 core
-            in lowp vec2 texcoord;
-            out vec4 FragColor;
-            uniform sampler2D tex;
-            void main() {
-                FragColor = texture(tex, texcoord);
-            }
-        "#;
-
-    pub fn meta(images: Vec<String>) -> ShaderMeta {
-        ShaderMeta {
-            images,
-            uniforms: UniformBlockLayout {
-                uniforms: vec![
-                    UniformDesc::new("offset", UniformType::Float2),
-                    UniformDesc::new("trans", UniformType::Mat4),
-                    UniformDesc::new("scale", UniformType::Mat4)],
-            },
-        }
-    }
+pub(crate) fn triangle_pipeline(
+    device: &Device,
+    sc_desc: &SwapChainDescriptor,
+    texture_bind_group_layout: &BindGroupLayout,
+    transform_bind_group_layout: &BindGroupLayout,
+) -> RenderPipeline {
+    let vs_module = device.create_shader_module(&wgpu::include_spirv!("shaders/shader.vert.spv"));
+    let fs_module = device.create_shader_module(&wgpu::include_spirv!("shaders/shader.frag.spv"));
+
+    let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: Some("Basic triangle pipeline layout"),
+        bind_group_layouts: &[texture_bind_group_layout, transform_bind_group_layout],
+        push_constant_ranges: &[],
+    });
+
+    let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: Some("Triangle render pipeline"),
+        layout: Some(&render_pipeline_layout),
+        vertex: wgpu::VertexState {
+            module: &vs_module,
+            entry_point: "main",
+            buffers: &[TexturedGlVertex::desc()],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: &fs_module,
+            entry_point: "main",
+            targets: &[wgpu::ColorTargetState {
+                format: sc_desc.format,
+                alpha_blend: wgpu::BlendState::REPLACE,
+                color_blend: wgpu::BlendState::REPLACE,
+                write_mask: wgpu::ColorWrite::ALL,
+            }],
+        }),
+        primitive: wgpu::PrimitiveState {
+            topology: wgpu::PrimitiveTopology::TriangleList,
+            strip_index_format: None,
+            front_face: wgpu::FrontFace::Ccw,
+            cull_mode: wgpu::CullMode::Back,
+            polygon_mode: wgpu::PolygonMode::Fill,
+        },
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState {
+            count: 1,
+            mask: !0,
+            alpha_to_coverage_enabled: false,
+        },
+    });
+    render_pipeline
 }
diff --git a/src/renderer/color.rs b/src/renderer/color.rs
index 08da577..8fb5a56 100644
--- a/src/renderer/color.rs
+++ b/src/renderer/color.rs
@@ -9,13 +9,16 @@ pub struct Color {
     /// Blue value of the color
     b: u8,
     /// Alpha value of the color
-    a: f32
+    a: f32,
 }
 
 impl Color {
     pub fn new(r: u8, g: u8, b: u8, a: f32) -> Self {
-        assert!(a <= 1. && a >= 0., "Alpha value must be between 0.0 and 1.0");
-        Self { r,g,b,a }
+        assert!(
+            a <= 1. && a >= 0.,
+            "Alpha value must be between 0.0 and 1.0"
+        );
+        Self { r, g, b, a }
     }
 
     pub fn new_rgb(r: u8, g: u8, b: u8) -> Self {
@@ -46,13 +49,13 @@ impl Color {
     }
 }
 
-impl Into<GlColor> for &Color{
+impl Into<GlColor> for &Color {
     fn into(self) -> GlColor {
-        GlColor{
+        GlColor {
             r: self.r as f32 / 255.,
             g: self.g as f32 / 255.,
             b: self.b as f32 / 255.,
-            a: self.a
+            a: self.a,
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/renderer/mod.rs b/src/renderer/mod.rs
index fd65c3a..157ca9c 100644
--- a/src/renderer/mod.rs
+++ b/src/renderer/mod.rs
@@ -1,33 +1,41 @@
 pub mod bidimensional;
 pub mod color;
-use miniquad::Context;
-use legion::{World, Resources};
+pub mod renderer_state;
+use legion::World;
 
+use crate::renderer::bidimensional::scion2d::Scion2D;
 
+use wgpu::{CommandEncoder, Device, Queue, SwapChainDescriptor, SwapChainTexture};
 
 /// Trait to implement in order to create a renderer to use in a `Scion` application
 pub trait ScionRenderer {
-    /// The draw method is called each frame
-    fn draw(&mut self, context: &mut Context, world: &mut World, resource: &mut Resources);
+    fn update(
+        &mut self,
+        world: &mut World,
+        device: &Device,
+        sc_desc: &SwapChainDescriptor,
+        queue: &mut Queue,
+    );
+    fn render(&mut self, world: &mut World, frame: &SwapChainTexture, encoder: &mut CommandEncoder);
 }
 
 /// Type of renderer to use to render the game.
 pub enum RendererType {
     Scion2D,
-    Custom(Box<dyn ScionRenderer>)
+    Custom(Box<dyn ScionRenderer>),
 }
 
-impl Default for RendererType{
+impl Default for RendererType {
     fn default() -> Self {
         RendererType::Scion2D
     }
 }
 
-impl RendererType{
-    pub(crate) fn into_boxed_renderer(self) -> Box<dyn ScionRenderer>{
-        match self{
-            RendererType::Scion2D => { Box::new(bidimensional::renderer::Scion2D) }
-            RendererType::Custom(boxed) => { boxed }
+impl RendererType {
+    pub(crate) fn into_boxed_renderer(self) -> Box<dyn ScionRenderer> {
+        match self {
+            RendererType::Scion2D => Box::new(Scion2D::default()),
+            RendererType::Custom(boxed) => boxed,
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/renderer/renderer_state.rs b/src/renderer/renderer_state.rs
new file mode 100644
index 0000000..84edb9c
--- /dev/null
+++ b/src/renderer/renderer_state.rs
@@ -0,0 +1,96 @@
+use winit::event::WindowEvent;
+use winit::window::Window;
+
+use crate::renderer::ScionRenderer;
+use legion::{Resources, World};
+
+pub struct RendererState {
+    surface: wgpu::Surface,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    sc_desc: wgpu::SwapChainDescriptor,
+    swap_chain: wgpu::SwapChain,
+    size: winit::dpi::PhysicalSize<u32>,
+    scion_renderer: Box<dyn ScionRenderer>,
+}
+
+impl RendererState {
+    pub(crate) async fn new(window: &Window, scion_renderer: Box<dyn ScionRenderer>) -> Self {
+        let size = window.inner_size();
+        let instance = wgpu::Instance::new(wgpu::BackendBit::PRIMARY);
+        let surface = unsafe { instance.create_surface(window) };
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::default(),
+                compatible_surface: Some(&surface),
+            })
+            .await
+            .unwrap();
+
+        let (device, queue) = adapter
+            .request_device(
+                &wgpu::DeviceDescriptor {
+                    features: wgpu::Features::empty(),
+                    limits: wgpu::Limits::default(),
+                    label: None,
+                },
+                None, // Trace path
+            )
+            .await
+            .unwrap();
+
+        let sc_desc = wgpu::SwapChainDescriptor {
+            usage: wgpu::TextureUsage::RENDER_ATTACHMENT,
+            format: adapter.get_swap_chain_preferred_format(&surface),
+            width: size.width,
+            height: size.height,
+            present_mode: wgpu::PresentMode::Fifo,
+        };
+        let swap_chain = device.create_swap_chain(&surface, &sc_desc);
+
+        Self {
+            surface,
+            device,
+            queue,
+            sc_desc,
+            swap_chain,
+            size,
+            scion_renderer,
+        }
+    }
+
+    pub(crate) fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+        self.size = new_size;
+        self.sc_desc.width = new_size.width;
+        self.sc_desc.height = new_size.height;
+        self.swap_chain = self.device.create_swap_chain(&self.surface, &self.sc_desc);
+    }
+
+    pub(crate) fn _input(&mut self, _event: &WindowEvent) -> bool {
+        //todo!()
+        false
+    }
+
+    pub(crate) fn update(&mut self, world: &mut World) {
+        self.scion_renderer
+            .update(world, &self.device, &self.sc_desc, &mut self.queue);
+    }
+
+    pub(crate) fn render(
+        &mut self,
+        world: &mut World,
+        _resources: &mut Resources,
+    ) -> Result<(), wgpu::SwapChainError> {
+        let frame = self.swap_chain.get_current_frame()?.output;
+        let mut encoder = self
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                label: Some("Render Encoder"),
+            });
+
+        self.scion_renderer.render(world, &frame, &mut encoder);
+        self.queue.submit(std::iter::once(encoder.finish()));
+
+        Ok(())
+    }
+}
diff --git a/src/utils/file.rs b/src/utils/file.rs
index c86bd80..6a26d10 100644
--- a/src/utils/file.rs
+++ b/src/utils/file.rs
@@ -1,23 +1,29 @@
 use std::fs::File;
-use std::path::{Path};
-use std::io::{Read};
-use std::{path, io, env};
+use std::io::Read;
+use std::path::Path;
+use std::{env, io, path};
 
 pub struct FileReaderError {
-    msg: String
+    _msg: String,
 }
 
-pub fn read_file(path: &Path) -> Result<Vec<u8>, FileReaderError>{
+pub fn read_file(path: &Path) -> Result<Vec<u8>, FileReaderError> {
     let mut file = match File::open(path) {
         Ok(file) => file,
-        Err(e) => return Err(FileReaderError{ msg: e.to_string() })
+        Err(e) => {
+            return Err(FileReaderError {
+                _msg: e.to_string(),
+            })
+        }
     };
     let mut buffer = Vec::new();
     let read_result = file.read_to_end(&mut buffer);
     return match read_result {
         Ok(_) => Ok(buffer),
-        Err(e) => Err(FileReaderError{ msg: e.to_string()})
-    }
+        Err(e) => Err(FileReaderError {
+            _msg: e.to_string(),
+        }),
+    };
 }
 
 pub fn app_base_path() -> Result<path::PathBuf, io::Error> {
@@ -25,8 +31,11 @@ pub fn app_base_path() -> Result<path::PathBuf, io::Error> {
         return Ok(path::PathBuf::from(manifest_dir));
     }
 
-    return match env::current_exe(){
+    return match env::current_exe() {
         Ok(path) => Ok(path),
-        Err(_) => Err(io::Error::new(io::ErrorKind::Other, "Failed to find an application root"))
-    }
+        Err(_) => Err(io::Error::new(
+            io::ErrorKind::Other,
+            "Failed to find an application root",
+        )),
+    };
 }
diff --git a/src/utils/logger.rs b/src/utils/logger.rs
index e15281b..ccf4611 100644
--- a/src/utils/logger.rs
+++ b/src/utils/logger.rs
@@ -1,8 +1,8 @@
 use log::debug;
 use std::io;
 
-use fern::colors::ColoredLevelConfig;
 use crate::config::logger_config::LoggerConfig;
+use fern::colors::ColoredLevelConfig;
 
 /// Logging utility provided by Scion
 pub(crate) struct Logger;
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 4b4347e..11e3560 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -1,4 +1,4 @@
+pub mod file;
 pub mod logger;
 pub mod time;
 pub mod window;
-pub mod file;
diff --git a/src/utils/window.rs b/src/utils/window.rs
index 880af5b..48292e3 100644
--- a/src/utils/window.rs
+++ b/src/utils/window.rs
@@ -3,14 +3,14 @@
 #[derive(Default, Debug)]
 pub struct WindowDimensions {
     width: f32,
-    height: f32
+    height: f32,
 }
 
 impl WindowDimensions {
-    pub fn new(screen_size: (f32, f32)) -> Self{
-        Self{
+    pub fn new(screen_size: (f32, f32)) -> Self {
+        Self {
             width: screen_size.0,
-            height: screen_size.1
+            height: screen_size.1,
         }
     }
 
@@ -30,4 +30,4 @@ impl WindowDimensions {
     pub fn height(self) -> f32 {
         self.height
     }
-}
\ No newline at end of file
+}