diff --git a/Cargo.toml b/Cargo.toml
index da3ebd4..3288d9e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,5 +8,7 @@ edition = "2018"
 legion = "0.4.0"
 winit = "0.24.0"
 
+spin_sleep = "1.0.0"
+
 serde = "1.0.124"
 toml = "0.5.8"
\ No newline at end of file
diff --git a/examples/hello-world/main.rs b/examples/hello-world/main.rs
index e4eef33..8f9fb9c 100644
--- a/examples/hello-world/main.rs
+++ b/examples/hello-world/main.rs
@@ -1,9 +1,10 @@
 use scion::application::Scion;
-use scion::legion::system;
+use scion::legion::{system};
+use scion::utils::time::Time;
 
 #[system]
-fn hello(){
-    println!("Hello from system")
+fn hello(#[resource] time: &Time){
+    println!("Hello from system {:?}", time.delta_duration());
 }
 
 fn main() {
diff --git a/src/application.rs b/src/application.rs
index e8e1da9..9116103 100644
--- a/src/application.rs
+++ b/src/application.rs
@@ -6,6 +6,8 @@ use crate::config::scion_config::{ScionConfig, ScionConfigReader};
 use winit::window::{Window, WindowBuilder};
 use winit::event_loop::{EventLoop, ControlFlow};
 use winit::event::{Event, WindowEvent};
+use crate::utils::time::Time;
+use crate::utils::frame_limiter::{FRAME_LOCKED, FrameLimiter, FrameLimiterStrategy};
 
 /// `Scion` is the entry point of any application made with Scion engine.
 pub struct Scion{
@@ -27,7 +29,10 @@ impl Scion {
     }
 
     fn setup(&mut self) {
-        // TODO : Add needed resources
+        self.resources.insert(Time::default());
+        self.resources.insert(FrameLimiter::new(
+            self.config.frame_limiter.clone().unwrap_or(Default::default())
+        ));
     }
 
     fn run (mut self) {
@@ -50,9 +55,20 @@ impl Scion {
                 }
                 _ => (),
             }
-            self.schedule.execute(&mut self.world, &mut self.resources);
+            self.next_frame();
         });
     }
+
+    fn next_frame(&mut self) {
+        let locked_ecs = unsafe { FRAME_LOCKED };
+        if !locked_ecs {
+            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.resources.get_mut::<FrameLimiter>().unwrap().end_frame();
+        }
+    }
 }
 pub struct ScionBuilder{
     config: ScionConfig,
diff --git a/src/config/scion_config.rs b/src/config/scion_config.rs
index a45ef71..61c3950 100644
--- a/src/config/scion_config.rs
+++ b/src/config/scion_config.rs
@@ -3,26 +3,31 @@ use std::path::Path;
 use std::fs::File;
 use serde::{Serialize, Deserialize};
 use crate::config::window_config::WindowConfig;
+use crate::utils::frame_limiter::{FrameLimiterStrategy, FrameLimiterConfig};
 
 /// Main configuration used by `crate::Scion` to configure the game.
 #[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct ScionConfig{
+pub(crate) struct ScionConfig {
     /// Name of the application
     pub(crate) app_name: String,
     /// Configuration for the game window
-    pub(crate) window_config: Option<WindowConfig>
+    pub(crate) window_config: Option<WindowConfig>,
+    /// `FrameLimiterStrategy` to use while running the main loop. Will use Sleep{fps:60} by default
+    pub(crate) frame_limiter: Option<FrameLimiterConfig>,
 }
 
-impl Default for ScionConfig{
+impl Default for ScionConfig {
     fn default() -> Self {
-        Self{
+        Self {
             app_name: "Scion game".to_string(),
-            window_config: Some(Default::default())
+            window_config: Some(Default::default()),
+            frame_limiter: Some(Default::default()),
         }
     }
 }
 
 pub struct ScionConfigReader;
+
 impl ScionConfigReader {
     pub(crate) fn read_or_create_scion_toml() -> Result<ScionConfig, Error> {
         let path = Path::new("Scion.toml");
@@ -34,7 +39,7 @@ impl ScionConfigReader {
             let mut file = File::create(path)?;
             file.write_all(toml::to_vec(&config).unwrap().as_slice())?;
             config
-        }else{
+        } else {
             let mut scion_config = File::open(path)?;
             let mut bytes = Vec::new();
             scion_config.read_to_end(&mut bytes)?;
@@ -47,6 +52,7 @@ impl ScionConfigReader {
 #[cfg(test)]
 mod tests {
     use super::*;
+
     #[test]
     fn test_read_crystal_toml() {
 
diff --git a/src/lib.rs b/src/lib.rs
index 13a6556..fe15b40 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,4 +2,5 @@
 pub use legion as legion;
 
 pub mod application;
+pub mod utils;
 mod config;
\ No newline at end of file
diff --git a/src/utils/frame_limiter.rs b/src/utils/frame_limiter.rs
new file mode 100644
index 0000000..0e6fc6b
--- /dev/null
+++ b/src/utils/frame_limiter.rs
@@ -0,0 +1,90 @@
+use std::time::{Duration, Instant};
+use std::thread;
+use serde::{Serialize, Deserialize};
+
+pub(crate) static mut FRAME_LOCKED : bool = false ;
+
+/// In order to reduce the cpu usage, the `FrameLimiter` will handle an
+/// ecs Lock if a frame used less time than expected.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) enum FrameLimiterStrategy {
+    /// The `FrameLimiter` won't try to sleep and will launch the next ecs frame
+    /// immediately after the previous one.
+    Unlimited,
+    /// The `FrameLimiter` will compute the expected duration of a frame and
+    /// do a background sleep, locking the ecs, but not the rendering or window events.
+    /// usize is the maximum expected fps number
+    Sleep
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct FrameLimiterConfig{
+    strategy: FrameLimiterStrategy,
+    fps: Option<u32>
+}
+
+impl Default for FrameLimiterConfig{
+    fn default() -> Self {
+        Self{
+            strategy: FrameLimiterStrategy::Sleep,
+            fps: Some(60)
+        }
+    }
+}
+
+pub(crate) struct FrameLimiter{
+    strategy: FrameLimiterStrategy,
+    target_frame_duration: Duration,
+    frame_start: Instant
+}
+
+impl FrameLimiter{
+    pub fn new(config: FrameLimiterConfig) -> FrameLimiter{
+        let target_frame_duration = {
+            match config.strategy {
+                FrameLimiterStrategy::Unlimited => Duration::from_secs(0),
+                FrameLimiterStrategy::Sleep => {
+                    let fps = config.fps.unwrap_or(60);
+                    assert!(fps > 0, "FrameLimiter::config parameter `fps` is {}. This parameter must be greater than zero!", fps);
+                    Duration::from_secs(1) / fps
+                }
+            }
+        };
+
+        Self {
+            strategy: config.strategy,
+            target_frame_duration,
+            frame_start: Instant::now()
+        }
+    }
+
+    pub fn start_frame(&mut self){
+        self.frame_start = Instant::now();
+    }
+
+    pub fn end_frame(&mut self) {
+        match self.strategy{
+            FrameLimiterStrategy::Unlimited => {
+                // Just continue
+            }
+            FrameLimiterStrategy::Sleep => {
+                let frame_start = self.frame_start;
+                let target_frame_duration = self.target_frame_duration;
+                unsafe {
+                    FRAME_LOCKED = true;
+                };
+                thread::spawn(move || {
+                    let elapsed = Instant::now() - frame_start;
+                    if elapsed < target_frame_duration {
+                        spin_sleep::sleep(target_frame_duration - elapsed);
+                    }
+                    unsafe {
+                        FRAME_LOCKED = false;
+                    }
+                });
+            }
+        }
+    }
+}
+
+
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
new file mode 100644
index 0000000..ed54d3a
--- /dev/null
+++ b/src/utils/mod.rs
@@ -0,0 +1,2 @@
+pub mod time;
+pub mod frame_limiter;
\ No newline at end of file
diff --git a/src/utils/time.rs b/src/utils/time.rs
new file mode 100644
index 0000000..fe5a822
--- /dev/null
+++ b/src/utils/time.rs
@@ -0,0 +1,32 @@
+use std::time::{Duration, Instant};
+
+/// Resource dedicated to compute the time durations between frames and keep a track of
+/// frame number
+pub struct Time {
+    delta_duration: Duration,
+    frame_number: u64,
+    measure_start: Instant
+}
+
+impl Default for Time{
+    fn default() -> Self {
+        Self{
+            delta_duration: Default::default(),
+            frame_number: 0,
+            measure_start: Instant::now()
+        }
+    }
+}
+
+impl Time {
+    pub(crate) fn frame(&mut self) {
+        self.frame_number += 1;
+        self.delta_duration = self.measure_start.elapsed();
+        self.measure_start = Instant::now();
+    }
+
+    /// Returns the duration of the last ran frame
+    pub fn delta_duration(&self) -> Duration {
+        self.delta_duration
+    }
+}
\ No newline at end of file