diff --git a/Cargo.lock b/Cargo.lock
index 1bc917a..2dfb645 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -297,7 +297,7 @@ dependencies = [
 
 [[package]]
 name = "blue_engine"
-version = "0.5.6"
+version = "0.5.7"
 dependencies = [
  "android_logger",
  "bytemuck",
diff --git a/Cargo.toml b/Cargo.toml
index 72e9d5f..fb8c314 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "blue_engine"
-version = "0.5.6"
+version = "0.5.7"
 authors = ["Elham Aryanpur <elhamaryanpur5@gmail.com>"]
 edition = "2021"
 description = "General-Purpose, Easy-to-use, Fast, and Portable graphics engine"
diff --git a/examples/dev/dev.rs b/examples/dev/dev.rs
index 4758df3..d494a3f 100644
--- a/examples/dev/dev.rs
+++ b/examples/dev/dev.rs
@@ -85,8 +85,20 @@ fn main() {
         .set_position(-0.2f32, 0f32, 0.001f32);
 
     let speed = -0.05;
+
+    let mut last_time = std::time::Instant::now();
+    let mut frames = 0;
     engine
         .update_loop(move |renderer, _window, objects, input, camera, plugins| {
+            // calculate FPS
+            let current_time = std::time::Instant::now();
+            frames += 1;
+            if current_time - last_time >= std::time::Duration::from_secs(1) {
+                println!("{}ms/frame", 1000f32 / frames as f32);
+                frames = 0;
+                last_time = current_time;
+            }
+
             let sprite = objects.get_mut("alt").unwrap();
 
             if input.key_held(blue_engine::KeyCode::ArrowUp) {
diff --git a/src/header.rs b/src/header.rs
index 849e6fb..c3fedf4 100644
--- a/src/header.rs
+++ b/src/header.rs
@@ -289,6 +289,14 @@ pub struct WindowDescriptor {
     pub backends: crate::Backends,
     /// The features to be enabled on a backend
     pub features: crate::wgpu::Features,
+    /// Controls how the events are processed
+    pub control_flow: crate::winit::event_loop::ControlFlow,
+    /// The presentation mode of renderer for things like VSync
+    pub present_mode: crate::wgpu::PresentMode,
+    /// The alpha mode which specifies how the alpha channel of the textures should be handled during compositing.
+    pub alpha_mode: crate::wgpu::CompositeAlphaMode,
+    /// The desired frame latency, check [wgpu::SurfaceConfiguration::desired_maximum_frame_latency]
+    pub desired_maximum_frame_latency: u32,
 }
 impl std::default::Default for WindowDescriptor {
     /// Will quickly create a window with default settings
@@ -311,6 +319,10 @@ impl std::default::Default for WindowDescriptor {
             } else {
                 wgpu::Features::empty()
             },
+            control_flow: crate::winit::event_loop::ControlFlow::Poll,
+            present_mode: crate::wgpu::PresentMode::AutoNoVsync,
+            alpha_mode: crate::wgpu::CompositeAlphaMode::Auto,
+            desired_maximum_frame_latency: 2,
         }
     }
 }
diff --git a/src/render.rs b/src/render.rs
index ce5fe0d..061d9d1 100644
--- a/src/render.rs
+++ b/src/render.rs
@@ -9,7 +9,6 @@ use crate::{
     utils::default_resources::{DEFAULT_COLOR, DEFAULT_MATRIX_4, DEFAULT_SHADER, DEFAULT_TEXTURE},
     ObjectStorage, PipelineData,
 };
-use wgpu::Features;
 use winit::window::Window;
 
 impl Renderer {
@@ -20,15 +19,13 @@ impl Renderer {
     /// * `power_preference` - The power preference to use.
     pub(crate) async fn new(
         window: &Window,
-        power_preference: crate::PowerPreference,
-        backends: crate::Backends,
-        features: Features,
+        settings: crate::WindowDescriptor,
     ) -> color_eyre::Result<Self> {
         let size = window.inner_size();
 
         // The instance is a handle to our GPU
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
-            backends,
+            backends: settings.backends,
             ..Default::default()
         });
         #[cfg(not(feature = "android"))]
@@ -40,7 +37,7 @@ impl Renderer {
 
         let adapter = instance
             .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: power_preference,
+                power_preference: settings.power_preference,
                 #[cfg(not(feature = "android"))]
                 compatible_surface: Some(&surface.as_ref().unwrap()),
                 #[cfg(feature = "android")]
@@ -54,7 +51,7 @@ impl Renderer {
             .request_device(
                 &wgpu::DeviceDescriptor {
                     label: Some("Device"),
-                    required_features: features,
+                    required_features: settings.features,
                     required_limits: wgpu::Limits::default(),
                 },
                 None, // Trace path
@@ -82,10 +79,10 @@ impl Renderer {
             #[cfg(feature = "android")]
             present_mode: wgpu::PresentMode::Mailbox,
             #[cfg(not(feature = "android"))]
-            present_mode: wgpu::PresentMode::Fifo,
-            alpha_mode: wgpu::CompositeAlphaMode::Auto,
+            present_mode: settings.present_mode,
+            alpha_mode: settings.alpha_mode,
             view_formats: vec![tex_format],
-            desired_maximum_frame_latency: 2,
+            desired_maximum_frame_latency: settings.desired_maximum_frame_latency,
         };
         #[cfg(not(feature = "android"))]
         surface.as_ref().unwrap().configure(&device, &config);
diff --git a/src/window.rs b/src/window.rs
index 323ace9..9880396 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -55,6 +55,7 @@ impl Engine {
         // and will contain all the callbacks and button press
         // also will allow graphics API
         let event_loop = EventLoop::new()?;
+        event_loop.set_control_flow(settings.control_flow);
 
         // bind the loop to window
         #[cfg(not(feature = "android"))]
@@ -63,12 +64,7 @@ impl Engine {
         let window = Window::new(&event_loop).unwrap();
 
         // The renderer init on current window
-        let mut renderer = futures::executor::block_on(Renderer::new(
-            &window,
-            settings.power_preference,
-            settings.backends,
-            settings.features,
-        ))?;
+        let mut renderer = futures::executor::block_on(Renderer::new(&window, settings))?;
 
         let camera = Camera::new(window.inner_size(), &mut renderer)?;