diff --git a/examples/basic.rs b/examples/basic.rs
index eef73d4..e9ac0fa 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,32 +1,34 @@
-use std::time::Duration;
-
-use bevy::prelude::*;
+use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
 use corentin::prelude::*;
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Executor::new())
-        .add_systems(Startup, setup_coroutines)
-        .add_systems(Update, run_coroutines)
+        .add_plugins((DefaultPlugins, CorentinPlugin))
+        .add_systems(Startup, setup_scene)
         .run();
 }
 
-fn setup_coroutines(mut executor: ResMut<Executor>) {
-    executor.add(|mut fib| async move {
-        let mut i = 0;
-        loop {
-            let dt = fib.next_tick().await;
-            println!("Last frame lasted for {}", dt.as_secs_f32());
-            fib.duration(Duration::from_secs(1)).await;
-            i += 1;
-            println!("This coroutine has started since {} seconds", i);
-        }
-    });
-}
+fn setup_scene(
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut commands: Commands,
+) {
+    commands.spawn(Camera2dBundle::default());
 
-fn run_coroutines(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        exec.tick(w);
-    })
+    // Circle
+    commands
+        .spawn(MaterialMesh2dBundle {
+            mesh: meshes.add(shape::Circle::new(50.).into()).into(),
+            material: materials.add(ColorMaterial::from(Color::PURPLE)),
+            transform: Transform::from_translation(Vec3::new(-150., 0., 0.)),
+            ..default()
+        })
+        .add(coroutine(
+            |fib: Fib, mut transform: Wr<Transform>| async move {
+                loop {
+                    let dt = fib.next_tick().await;
+                    transform.get_mut().translation.x += 100.0 * dt.as_secs_f32();
+                }
+            },
+        ));
 }
diff --git a/examples/read_write.rs b/examples/read_write.rs
index ebd63cd..d24ade7 100644
--- a/examples/read_write.rs
+++ b/examples/read_write.rs
@@ -1,46 +1,30 @@
-use std::time::Duration;
-
-use bevy::prelude::*;
-use corentin::{coroutine::PrimitiveVoid, prelude::*};
-
-#[derive(Component)]
-struct ExampleComponent(u32);
-
 fn main() {
-    App::new()
-        .add_plugins(DefaultPlugins)
-        .insert_resource(Executor::new())
-        .add_systems(Startup, setup_access)
-        .add_systems(Update, run_coroutines)
-        .run();
+    //App::new()
+    //    .add_plugins((DefaultPlugins, CorentinPlugin))
+    //    .add_systems(Startup, setup_access)
+    //    .run();
 }
 
-fn setup_access(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        let e = w.spawn(ExampleComponent(0)).id();
-        exec.add_to_entity(e, move |mut fib, this| async move {
-            loop {
-                let mut b = fib
-                    .duration(Duration::from_secs(1))
-                    .then_grab::<&mut ExampleComponent>(this)
-                    .await;
-                b.0 += 1;
-            }
-        });
-        exec.add(|mut fib| async move {
-            loop {
-                let c = fib
-                    .change::<ExampleComponent>(e)
-                    .then_grab::<&ExampleComponent>(e)
-                    .await;
-                println!("Change detected, value is now {}", c.0);
-            }
-        });
-    })
-}
-
-fn run_coroutines(world: &mut World) {
-    world.resource_scope(|w, mut exec: Mut<Executor>| {
-        exec.tick(w);
-    })
-}
+//fn setup_scene(
+//    mut meshes: ResMut<Assets<Mesh>>,
+//    mut materials: ResMut<Assets<ColorMaterial>>,
+//    mut commands: Commands,
+//) {
+//    commands.spawn(Camera2dBundle::default());
+//    let e = world.spawn((IsClicked(0))).id();
+//    coroutine(|fib: Fib, mut ex: R<IsClicked>| async move {
+//        loop {
+//            ex.on_change().await;
+//
+//        }
+//    })
+//    .apply(e, world);
+//
+//    coroutine(|_: Fib, ex: R<ExampleComponent>| async move {
+//        loop {
+//            ex.on_change().await;
+//            println!("Change detected, value is now {}", ex.get().0);
+//        }
+//    })
+//    .apply(e, world);
+//}
diff --git a/src/commands.rs b/src/commands.rs
new file mode 100644
index 0000000..904a9d8
--- /dev/null
+++ b/src/commands.rs
@@ -0,0 +1,39 @@
+use bevy::ecs::system::EntityCommand;
+use bevy::utils::synccell::SyncCell;
+use std::marker::PhantomData;
+
+use bevy::prelude::{Entity, World};
+
+use crate::coroutine::UninitCoroutine;
+use crate::executor::Executor;
+
+pub struct AddCoroutine<Marker, C> {
+    coro: C,
+    _phantom: PhantomData<Marker>,
+}
+
+impl<Marker: Send + 'static, C: Send + 'static> EntityCommand for AddCoroutine<Marker, C>
+where
+    C: UninitCoroutine<Marker>,
+{
+    fn apply(self, id: Entity, world: &mut World) {
+        world.resource_scope::<Executor, ()>(|w, mut executor| {
+            if let Some(coroutine) = self.coro.init(id, w) {
+                executor.add(SyncCell::new(Box::pin(coroutine)));
+            }
+        });
+    }
+}
+
+pub fn coroutine<M, C>(coro: C) -> AddCoroutine<M, C> {
+    AddCoroutine::new(coro)
+}
+
+impl<M, C> AddCoroutine<M, C> {
+    pub fn new(coro: C) -> Self {
+        Self {
+            coro,
+            _phantom: PhantomData,
+        }
+    }
+}
diff --git a/src/coroutine/coro_param/component.rs b/src/coroutine/coro_param/component.rs
new file mode 100644
index 0000000..2c2687c
--- /dev/null
+++ b/src/coroutine/coro_param/component.rs
@@ -0,0 +1,156 @@
+use std::marker::PhantomData;
+
+use bevy::prelude::{Component, Entity, World};
+
+use crate::coroutine::{
+    observable::{ObservableId, OnChange},
+    CoroAccess, CoroWrites, SourceId,
+};
+
+use super::{CoroParam, ParamContext, RdGuard, WrGuard};
+
+/// A readonly reference to a [`Component`] from the owning [`Entity`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
+/// relevent component.
+pub struct Rd<T: Component> {
+    context: ParamContext,
+    _phantom: PhantomData<T>,
+}
+
+impl<T: Component> CoroParam for Rd<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let id = world
+            .component_id::<T>()
+            .unwrap_or(world.init_component::<T>());
+
+        if !access.add_read(SourceId::Entity(context.owner), id) {
+            return None;
+        }
+
+        Some(Self {
+            context,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
+}
+
+impl<T: Component> Rd<T> {
+    /// Return the current value of the [`Component`]. The result ([`InGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, T> {
+        unsafe {
+            RdGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_entity(self.context.owner)
+                    .unwrap()
+                    .get::<T>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Yields and resume when the `Component` is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
+
+/// A read-write exclusive reference to a [`Component`] from the owning [`Entity`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the entity does not have the
+/// relevent component.
+pub struct Wr<T: Component> {
+    _phantom: PhantomData<T>,
+    context: ParamContext,
+}
+
+impl<T: Component> CoroParam for Wr<T> {
+    fn init(context: ParamContext, w: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let id = w.component_id::<T>().unwrap_or(w.init_component::<T>());
+
+        if !access.add_write(SourceId::Entity(context.owner), id) {
+            return None;
+        }
+
+        Some(Self {
+            _phantom: PhantomData,
+            context,
+        })
+    }
+
+    fn is_valid(owner: Entity, world: &World) -> bool {
+        match world.get_entity(owner) {
+            Some(e) => e.contains::<T>(),
+            _ => false,
+        }
+    }
+}
+
+impl<T: Component> Wr<T> {
+    pub fn get(&self) -> RdGuard<'_, T> {
+        let value = unsafe {
+            self.context
+                .world_window
+                .world_cell()
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get::<T>()
+                .unwrap()
+        };
+
+        RdGuard::new(value)
+    }
+
+    pub fn get_mut(&mut self) -> WrGuard<'_, T> {
+        unsafe {
+            let cell = self.context.world_window.world_cell();
+            let c_id = cell.components().component_id::<T>().unwrap();
+            cell.get_resource_mut::<CoroWrites>()
+                .unwrap()
+                .0
+                // TODO fix write
+                .push_back((self.context.owner, c_id));
+
+            let value = cell
+                .get_entity(self.context.owner)
+                .unwrap()
+                .get_mut::<T>()
+                .unwrap();
+
+            WrGuard::new(value)
+        }
+    }
+
+    pub fn on_change(&self) -> OnChange<'_> {
+        unsafe {
+            OnChange::new(
+                &self.context,
+                ObservableId::Component(
+                    self.context.owner,
+                    self.context.world_window.component_id::<T>(),
+                ),
+            )
+        }
+    }
+}
diff --git a/src/coroutine/coro_param/mod.rs b/src/coroutine/coro_param/mod.rs
new file mode 100644
index 0000000..4e97cdf
--- /dev/null
+++ b/src/coroutine/coro_param/mod.rs
@@ -0,0 +1,223 @@
+use std::{
+    cell::Cell,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
+
+use super::{CoroAccess, WaitingReason};
+use bevy::{
+    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeWorldCell},
+    prelude::{Component, Entity, Mut, World},
+    utils::all_tuples,
+};
+
+pub mod component;
+pub mod resource;
+
+/// Any async function that takes only [`CoroParam`] as arguments can
+/// automatically be turned into a [`Coroutine`].
+pub trait CoroParam: Sized + Send + 'static {
+    /// Initialize the parameter and register any access, if it is invalid (for instance
+    /// conflicting accesses) it will return None.
+    ///
+    /// Note: `world_window` is not yet open at that point, `world` should be used instead.
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self>;
+
+    /// Returns true if the parameter is still valid.
+    fn is_valid(owner: Entity, world: &World) -> bool;
+}
+
+/// A shared ref to a [`World`], it is "open" (meaning it points to a valid world with exclusive
+/// access) when the Coroutine is resumed. It is shared to all [`CoroParam`]s.
+#[derive(Clone)]
+pub struct WorldWindow(Rc<Cell<*mut World>>);
+
+// Safety: The window is only shared whith the coroutine itself, As with other similar construct,
+// if you start spawning thread inside a coroutine, or sending coroutine parameters via channels,
+// you may break the safety, therefore please don't do that. (thanks UwU)
+unsafe impl Send for WorldWindow {}
+unsafe impl Sync for WorldWindow {}
+
+impl WorldWindow {
+    pub fn closed_window() -> Self {
+        WorldWindow(Rc::new(Cell::new(std::ptr::null_mut())))
+    }
+
+    pub fn scope<T>(&mut self, world: &mut World, f: impl FnOnce() -> T) -> T {
+        self.0.replace(world as *mut _);
+        let res = f();
+        self.0.replace(std::ptr::null_mut());
+        res
+    }
+
+    /// Returns the world as an [`UnsafeWorldCell`].
+    ///
+    /// # Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open").
+    pub unsafe fn world_cell(&self) -> UnsafeWorldCell<'_> {
+        (*self.0.get()).as_unsafe_world_cell()
+    }
+
+    /// Return the appropriate ComponentId, and initialize it if not present in the world
+    ///
+    /// # Safety
+    /// The caller must ensure that the pointer points to a valid value. (the window should be
+    /// "open").
+    pub unsafe fn component_id<T: Component>(&self) -> ComponentId {
+        let cell = self.world_cell();
+        cell.components()
+            .component_id::<T>()
+            .unwrap_or_else(|| cell.world_mut().init_component::<T>())
+    }
+}
+
+/// The channel throught each [`CoroParam`] can yield back to the coroutine.
+/// Which can then return the reason to the caller (the [`Executor`]).
+#[derive(Default, Clone)]
+pub struct YieldChannel(Rc<Cell<Option<WaitingReason>>>);
+
+impl YieldChannel {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub(crate) fn receive(&self) -> Option<WaitingReason> {
+        self.0.replace(None)
+    }
+
+    pub(crate) fn send(&self, val: WaitingReason) {
+        self.0.replace(Some(val));
+    }
+}
+
+// Safety: Same as [`WorldWindow`].
+unsafe impl Send for YieldChannel {}
+unsafe impl Sync for YieldChannel {}
+
+/// All relevent values a [`CoroParam`] might need.
+#[derive(Clone)]
+pub struct ParamContext {
+    pub(crate) owner: Entity,
+    pub(crate) world_window: WorldWindow,
+    pub(crate) yield_channel: YieldChannel,
+}
+
+/// A guarded readonly reference, cannot be held accros awaiting points.
+pub struct RdGuard<'a, T> {
+    value: &'a T,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T> RdGuard<'a, T> {
+    pub fn new(value: &'a T) -> Self {
+        Self {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a, T> Deref for RdGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+/// A guarded exclusive write reference, cannot be held accros awaiting points.
+pub struct WrGuard<'a, T> {
+    value: Mut<'a, T>,
+    _phantom: PhantomData<*const T>,
+}
+
+impl<'a, T> WrGuard<'a, T> {
+    pub fn new(value: Mut<'a, T>) -> Self {
+        Self {
+            value,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<'a, T> Deref for WrGuard<'a, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
+impl<'a, T> DerefMut for WrGuard<'a, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value.deref_mut()
+    }
+}
+
+pub struct Opt<T> {
+    context: ParamContext,
+    inner: T,
+}
+
+impl<T: CoroParam> Opt<T> {
+    pub fn get(&self) -> Option<&T> {
+        unsafe {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
+                Some(&self.inner)
+            } else {
+                None
+            }
+        }
+    }
+
+    pub fn get_mut(&mut self) -> Option<&mut T> {
+        unsafe {
+            if T::is_valid(
+                self.context.owner,
+                self.context.world_window.world_cell().world(),
+            ) {
+                Some(&mut self.inner)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+impl<T: CoroParam> CoroParam for Opt<T> {
+    fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+        let t = T::init(context.clone(), world, access)?;
+
+        Some(Self { context, inner: t })
+    }
+
+    fn is_valid(_owner: Entity, _world: &World) -> bool {
+        true
+    }
+}
+
+macro_rules! impl_coro_param {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_parens, unused_variables)]
+        impl<$($param: CoroParam),*> CoroParam for ($($param,)*) {
+            fn init(context: ParamContext, world: &mut World, access: &mut CoroAccess) -> Option<Self> {
+                $(let $param = $param::init(context.clone(), world, access)?;)*
+
+                Some(($($param,)*))
+
+            }
+
+            fn is_valid(owner: Entity, world: &World) -> bool {
+                true $(&& $param::is_valid(owner, world))*
+            }
+        }
+
+    };
+}
+
+all_tuples!(impl_coro_param, 0, 16, P);
diff --git a/src/coroutine/coro_param/resource.rs b/src/coroutine/coro_param/resource.rs
new file mode 100644
index 0000000..38869dd
--- /dev/null
+++ b/src/coroutine/coro_param/resource.rs
@@ -0,0 +1,139 @@
+use std::marker::PhantomData;
+
+use bevy::{
+    ecs::component::ComponentId,
+    prelude::{self, Resource, World},
+};
+
+use crate::coroutine::{
+    observable::{ObservableId, OnChange},
+    SourceId,
+};
+
+use super::{CoroParam, ParamContext, RdGuard, WrGuard};
+
+/// A readonly reference to a [`Resource`] in the [`World`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the resource is removed.
+pub struct RdRes<R: Resource> {
+    context: ParamContext,
+    id: ComponentId,
+    _phantom: PhantomData<R>,
+}
+
+impl<R: Resource> CoroParam for RdRes<R> {
+    fn init(
+        context: ParamContext,
+        world: &mut World,
+        access: &mut crate::coroutine::CoroAccess,
+    ) -> Option<Self> {
+        let id = world.components().resource_id::<R>()?;
+        if access.add_read(SourceId::World, id) {
+            return None;
+        }
+
+        Some(RdRes {
+            context,
+            id,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(_owner: prelude::Entity, world: &World) -> bool {
+        world.contains_resource::<R>()
+    }
+}
+
+impl<R: Resource> RdRes<R> {
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, R> {
+        unsafe {
+            RdGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Yields and resume when the [`Resource`] is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        OnChange::new(&self.context, ObservableId::Resource(self.id))
+    }
+}
+
+/// A read-write exclusive reference to a [`Resource`] in the [`World`].
+///
+/// Note that a Coroutine with such parameter will be canceled if the resource is removed.
+pub struct WrRes<R: Resource> {
+    context: ParamContext,
+    id: ComponentId,
+    _phantom: PhantomData<R>,
+}
+
+impl<R: Resource> CoroParam for WrRes<R> {
+    fn init(
+        context: ParamContext,
+        world: &mut World,
+        access: &mut crate::coroutine::CoroAccess,
+    ) -> Option<Self> {
+        let id = world.components().resource_id::<R>()?;
+        if access.add_write(SourceId::World, id) {
+            return None;
+        }
+
+        Some(WrRes {
+            context,
+            id,
+            _phantom: PhantomData,
+        })
+    }
+
+    fn is_valid(_owner: prelude::Entity, world: &World) -> bool {
+        world.contains_resource::<R>()
+    }
+}
+
+impl<R: Resource> WrRes<R> {
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get(&self) -> RdGuard<'_, R> {
+        unsafe {
+            RdGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Return the current value of the [`Resource`]. The result ([`RdGuard`]) cannot be held
+    /// accros any await.
+    pub fn get_mut(&mut self) -> WrGuard<'_, R> {
+        unsafe {
+            WrGuard::new(
+                self.context
+                    .world_window
+                    .world_cell()
+                    .get_resource_mut::<R>()
+                    .unwrap(),
+            )
+        }
+    }
+
+    /// Yields and resume when the [`Resource`] is mutated.
+    ///
+    /// Note that it integrates with the regular change detection of Bevy, meaning that the
+    /// coroutine will be resumed, if a [`System`] mutates the value.
+    pub fn on_change(&self) -> OnChange<'_> {
+        OnChange::new(&self.context, ObservableId::Resource(self.id))
+    }
+}
diff --git a/src/coroutine/duration.rs b/src/coroutine/duration.rs
index 1895a60..4fc630f 100644
--- a/src/coroutine/duration.rs
+++ b/src/coroutine/duration.rs
@@ -1,36 +1,33 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use crate::coroutine::WaitingReason;
 
 use bevy::time::Time;
 use bevy::time::Timer;
 use bevy::time::TimerMode;
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 use std::time::Duration;
 
-use super::Primitive;
-use super::PrimitiveVoid;
+use super::coro_param::ParamContext;
+use super::CoroState;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct NextTick<'a> {
-    fib: &'a Fib,
+pub struct NextTick {
+    context: ParamContext,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a> NextTick<'a> {
-    pub(crate) fn new(fib: &'a Fib) -> Self {
+impl NextTick {
+    pub(crate) fn new(context: ParamContext) -> Self {
         NextTick {
-            fib,
+            context,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
 
-impl<'a> Future for NextTick<'a> {
+impl Future for NextTick {
     type Output = Duration;
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -41,47 +38,40 @@ impl<'a> Future for NextTick<'a> {
 
                 // SAFETY: None lmao
                 let dt = unsafe {
-                    (*self.fib.world_window.get().unwrap())
-                        .resource::<Time>()
+                    (self.context.world_window.world_cell())
+                        .get_resource::<Time>()
+                        .unwrap()
                         .delta()
                 };
                 Poll::Ready(dt)
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib.yield_sender.send(WaitingReason::Tick);
+                self.context.yield_channel.send(WaitingReason::Tick);
                 Poll::Pending
             }
         }
     }
 }
 
-impl<'cx> Primitive<'cx, Duration> for NextTick<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
-
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct DurationFuture<'a> {
-    fib: &'a Fib,
+pub struct DurationFuture {
+    context: ParamContext,
     duration: Duration,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a> DurationFuture<'a> {
-    pub(crate) fn new(fib: &'a Fib, duration: Duration) -> Self {
+impl DurationFuture {
+    pub(crate) fn new(context: ParamContext, duration: Duration) -> Self {
         DurationFuture {
-            fib,
+            context,
             duration,
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
 }
 
-impl<'a> Future for DurationFuture<'a> {
+impl Future for DurationFuture {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -93,8 +83,8 @@ impl<'a> Future for DurationFuture<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                self.fib
-                    .yield_sender
+                self.context
+                    .yield_channel
                     .send(WaitingReason::Duration(Timer::new(
                         self.duration,
                         TimerMode::Once,
@@ -104,9 +94,3 @@ impl<'a> Future for DurationFuture<'a> {
         }
     }
 }
-
-impl<'cx> PrimitiveVoid<'cx> for DurationFuture<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/coroutine/function_coroutine.rs b/src/coroutine/function_coroutine.rs
new file mode 100644
index 0000000..74a6d6f
--- /dev/null
+++ b/src/coroutine/function_coroutine.rs
@@ -0,0 +1,181 @@
+use std::time::Duration;
+
+use bevy::prelude::Entity;
+use bevy::prelude::World;
+use bevy::utils::all_tuples;
+use pin_project::pin_project;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+
+use super::coro_param::ParamContext;
+use super::coro_param::WorldWindow;
+use super::coro_param::{CoroParam, YieldChannel};
+use super::duration::DurationFuture;
+use super::duration::NextTick;
+use super::par_and::ParAnd;
+use super::par_or::ParOr;
+use super::CoroAccess;
+use super::UninitCoroutine;
+use super::{waker, Coroutine, CoroutineResult, WaitingReason};
+
+#[pin_project]
+pub struct FunctionCoroutine<Marker, F>
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    #[pin]
+    future: F::Future,
+    yield_channel: YieldChannel,
+    world_window: WorldWindow,
+    owner: Entity,
+    access: CoroAccess,
+}
+
+unsafe impl<Marker, F> Send for FunctionCoroutine<Marker, F> where F: CoroutineParamFunction<Marker> {}
+
+const ERR_WRONGAWAIT: &str = "A coroutine yielded without notifying the executor
+the reason. That is most likely because it awaits a
+future which is not part of this library.";
+
+impl<Marker: 'static, F> Coroutine for FunctionCoroutine<Marker, F>
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    fn resume(self: Pin<&mut Self>, world: &mut World) -> CoroutineResult<WaitingReason, ()> {
+        let waker = waker::create();
+        // Dummy context
+        let mut cx = Context::from_waker(&waker);
+
+        let this = self.project();
+        let res = this.world_window.scope(world, || this.future.poll(&mut cx));
+
+        match res {
+            Poll::Ready(_) => CoroutineResult::Done(()),
+            Poll::Pending => {
+                CoroutineResult::Yield(this.yield_channel.receive().expect(ERR_WRONGAWAIT))
+            }
+        }
+    }
+
+    fn is_valid(self: Pin<&mut Self>, world: &World) -> bool {
+        F::Params::is_valid(self.owner, world)
+    }
+
+    fn access(&self) -> &CoroAccess {
+        &self.access
+    }
+}
+
+pub trait CoroutineParamFunction<Marker>: Send + 'static {
+    type Future: Future<Output = ()> + Send + 'static;
+    type Params: CoroParam;
+
+    fn init(self, params: Self::Params) -> Self::Future;
+}
+
+impl<Marker: 'static, F> UninitCoroutine<Marker> for F
+where
+    F: CoroutineParamFunction<Marker>,
+{
+    type Coroutine = FunctionCoroutine<Marker, F>;
+
+    fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine> {
+        let yield_channel = YieldChannel::new();
+        let world_window = WorldWindow::closed_window();
+
+        let context = ParamContext {
+            owner,
+            world_window: world_window.clone(),
+            yield_channel: yield_channel.clone(),
+        };
+
+        let mut access = CoroAccess::default();
+
+        let params = F::Params::init(context.clone(), world, &mut access)?;
+
+        Some(FunctionCoroutine {
+            future: self.init(params),
+            yield_channel,
+            world_window,
+            owner,
+            access,
+        })
+    }
+}
+
+/// The fib is a parameter througth which a coroutine can wait on various elementary construct.
+/// such as waiting until the next tick, waiting on multiple sub-coroutines.
+pub struct Fib {
+    pub(crate) context: ParamContext,
+}
+
+impl Fib {
+    /// Returns coroutine that resolve the next time the [`Executor`] is ticked (via
+    /// [`run`][crate::executor::Executor::run] for instance). It returns the duration
+    /// of the last frame (delta time).
+    ///
+    /// [`Executor`]: crate::executor::Executor
+    pub fn next_tick(&self) -> NextTick {
+        NextTick::new(self.context.clone())
+    }
+
+    ///// Returns a coroutine that resolve after a certain [`Duration`]. Note that if the duration
+    ///// is smaller than the time between two tick of the [`Executor`] it won't be compensated.
+    /////
+    ///// [`Executor`]: crate::executor::Executor
+    pub fn duration(&self, duration: Duration) -> DurationFuture {
+        DurationFuture::new(self.context.clone(), duration)
+    }
+
+    ///// Returns a coroutine that resolve once any of the underlying coroutine finishes. Note that
+    ///// once this is done, all the others are dropped. The coroutines are resumed from top to
+    ///// bottom, in case multiple of them are ready to make progress at the same time.
+    pub fn par_or<C, Marker>(&self, coro: C) -> ParOr
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        ParOr::new(self.context.clone()).with(coro)
+    }
+
+    ///// Returns a coroutine that resolve once all of the underlying coroutine finishes.
+    pub fn par_and<C, Marker>(&self, coro: C) -> ParAnd
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        ParAnd::new(self.context.clone()).with(coro)
+    }
+}
+
+impl CoroParam for Fib {
+    fn init(context: ParamContext, _world: &mut World, _access: &mut CoroAccess) -> Option<Self> {
+        Some(Self { context })
+    }
+
+    fn is_valid(_owner: Entity, _world: &World) -> bool {
+        true
+    }
+}
+
+macro_rules! impl_coro_function {
+    ($($param: ident),*) => {
+        #[allow(non_snake_case, unused_mut, unused_variables, unused_parens)]
+        impl<Func, Fut, $($param: CoroParam),*> CoroutineParamFunction<fn($($param,)*) -> Fut> for Func
+        where
+            Func: FnOnce($($param),*) -> Fut + Send + 'static,
+            Fut: Future<Output = ()> + Send + 'static,
+        {
+
+            type Future = Fut;
+            type Params = ($($param),*);
+
+            fn init(self, params: Self::Params) -> Self::Future {
+                let ($(($param)),*) = params;
+                self($($param),*)
+            }
+        }
+    };
+}
+
+all_tuples!(impl_coro_function, 0, 16, P);
diff --git a/src/coroutine/grab.rs b/src/coroutine/grab.rs
deleted file mode 100644
index 7dbd52e..0000000
--- a/src/coroutine/grab.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-use std::{
-    future::Future,
-    marker::PhantomData,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use bevy::{
-    ecs::{component::ComponentId, world::unsafe_world_cell::UnsafeEntityCell},
-    prelude::{Component, Entity, Mut, Ref, World},
-    utils::all_tuples,
-};
-use pin_project::pin_project;
-use tinyset::SetUsize;
-
-use super::Fib;
-
-/// Describe what world access will be perform by a coroutine once resumed
-/// TODO: Benchmark and probably use something like tiny set or whatnot
-pub(crate) enum GrabReason {
-    Single(GrabAccess),
-    Multi(Vec<GrabAccess>),
-}
-
-impl GrabReason {
-    pub fn writes(&self) -> Vec<(Entity, ComponentId)> {
-        match self {
-            GrabReason::Single(s) => s
-                .writes
-                .iter()
-                .map(|c| (s.from, ComponentId::new(c)))
-                .collect(),
-            GrabReason::Multi(m) => m
-                .iter()
-                .flat_map(|s| s.writes.iter().map(|c| (s.from, ComponentId::new(c))))
-                .collect(),
-        }
-    }
-
-    pub(crate) fn is_valid(&self, world: &World) -> bool {
-        match self {
-            GrabReason::Single(a) => a.is_valid(world),
-            GrabReason::Multi(accesses) => accesses.iter().all(|a| a.is_valid(world)),
-        }
-    }
-}
-
-/// A world access from a single [`Entity`].
-pub struct GrabAccess {
-    pub(crate) from: Entity,
-    pub(crate) writes: SetUsize,
-    pub(crate) reads: SetUsize,
-    pub(crate) optional: SetUsize,
-}
-
-impl GrabAccess {
-    fn is_valid(&self, world: &World) -> bool {
-        if let Some(e) = world.get_entity(self.from) {
-            for c in self.writes.iter() {
-                if !e.contains_id(ComponentId::new(c)) && !self.optional.contains(c) {
-                    return false;
-                }
-            }
-            for c in self.reads.iter() {
-                if !e.contains_id(ComponentId::new(c)) && !self.optional.contains(c) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        false
-    }
-}
-
-pub trait GrabParam {
-    type Fetch<'w>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess;
-
-    fn update_access(world: &World, access: &mut GrabAccess);
-
-    /// Fetch the required data from the world.
-    /// # Safety
-    /// While the access itself check that no internal conficlts exist, the caller must ensure that
-    /// nothing will do an incompatible access at the same time (according to the regular Rust
-    /// rules).
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_>;
-}
-
-impl<T: Component> GrabParam for &T {
-    type Fetch<'w> = Ref<'w, T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut reads = SetUsize::new();
-        reads.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        GrabAccess {
-            from,
-            writes: SetUsize::new(),
-            reads,
-            optional: SetUsize::new(),
-        }
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        let c_id = world
-            .component_id::<T>()
-            .expect("Component should have been initialized");
-        if access.writes.contains(c_id.index()) {
-            panic!("Conflicting access detected");
-        }
-        access.reads.insert(c_id.index());
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_ref::<T>().unwrap()
-    }
-}
-
-impl<T: Component> GrabParam for &mut T {
-    type Fetch<'w> = Mut<'w, T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut writes = SetUsize::new();
-        writes.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        GrabAccess {
-            from,
-            writes,
-            reads: SetUsize::new(),
-            optional: SetUsize::new(),
-        }
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        let c_id = world
-            .component_id::<T>()
-            .expect("Component should have been initialized");
-        if access.reads.contains(c_id.index()) {
-            panic!("Conflicting access detected");
-        }
-        access.writes.insert(c_id.index());
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_mut::<T>().unwrap()
-    }
-}
-
-impl<T: Component> GrabParam for Option<&T> {
-    type Fetch<'w> = Option<&'w T>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut res = <&T as GrabParam>::get_access(world, from);
-        res.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        res
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        <&T as GrabParam>::update_access(world, access);
-        access.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get::<T>()
-    }
-}
-
-impl<T: Component> GrabParam for Option<&mut T> {
-    type Fetch<'w> = Option<Mut<'w, T>>;
-
-    fn get_access(world: &World, from: Entity) -> GrabAccess {
-        let mut res = <&mut T as GrabParam>::get_access(world, from);
-        res.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-        res
-    }
-
-    fn update_access(world: &World, access: &mut GrabAccess) {
-        <&mut T as GrabParam>::update_access(world, access);
-        access.optional.insert(
-            world
-                .component_id::<T>()
-                .expect("Component should have been initialized")
-                .index(),
-        );
-    }
-
-    unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-        entity.get_mut::<T>()
-    }
-}
-
-macro_rules! impl_tuple_grab {
-    ($param1: ident, $($param2: ident),*) => {
-        impl<$param1: GrabParam, $($param2: GrabParam),+> GrabParam for ($param1, $($param2),*)
-        {
-            type Fetch<'w> = ($param1::Fetch<'w>, $($param2::Fetch<'w>),*);
-
-            fn get_access(world: &World, from: Entity) -> GrabAccess {
-                let mut access = $param1::get_access(world, from);
-                $($param2::update_access(world, &mut access));*;
-                access
-            }
-
-            fn update_access(world: &World, access: &mut GrabAccess) {
-                $param1::update_access(world, access);
-                $($param2::update_access(world, access));*;
-            }
-
-            unsafe fn fetch(entity: UnsafeEntityCell<'_>) -> Self::Fetch<'_> {
-                ($param1::fetch(entity), $($param2::fetch(entity)),*)
-            }
-
-        }
-    };
-}
-
-all_tuples!(impl_tuple_grab, 2, 15, G);
-
-#[pin_project]
-pub struct GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    from: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom: PhantomData<P>,
-    _phantom2: PhantomData<&'a ()>,
-}
-
-impl<'a, P, F> GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    pub fn new(fib: Fib, from: Entity, inner: F) -> Self {
-        GrabCoroutineVoid {
-            from,
-            fib,
-            _phantom: PhantomData,
-            inner,
-            _phantom2: PhantomData,
-        }
-    }
-
-    pub fn and<P2: GrabParam>(self, from: Entity) -> GrabCoroutineVoid2<'a, P, P2, F> {
-        GrabCoroutineVoid2::new(self.fib, self.from, from, self.inner)
-    }
-}
-
-/// A wrapper around another coroutine that returns the requested
-/// data, once the underlying coroutine has finished.
-impl<'a, P, F> Future for GrabCoroutineVoid<'a, P, F>
-where
-    P: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    type Output = P::Fetch<'a>;
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access = P::get_access(world, *this.from);
-                    this.fib.grab_sender.send(GrabReason::Single(access));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(_) => {
-                let entity = this.from;
-
-                // Safety: The executor takes care of not executing two conflicting coroutines
-                // at the same time.
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result = P::fetch(world.get_entity(*entity).unwrap());
-                    Poll::Ready(result)
-                }
-            }
-        }
-    }
-}
-
-// TODO: Generalize with a macro instead
-#[pin_project]
-pub struct GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    from1: Entity,
-    from2: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom1: PhantomData<P1>,
-    _phantom2: PhantomData<P2>,
-    _phantoma: PhantomData<&'a ()>,
-}
-
-impl<'a, P1, P2, F> GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    pub fn new(fib: Fib, from1: Entity, from2: Entity, inner: F) -> Self {
-        assert_ne!(from1, from2, "Conficting grab access detected");
-        GrabCoroutineVoid2 {
-            from1,
-            from2,
-            fib,
-            inner,
-            _phantom1: PhantomData,
-            _phantom2: PhantomData,
-            _phantoma: PhantomData,
-        }
-    }
-}
-
-/// A wrapper around another coroutine that returns the requested
-/// data, once the underlying coroutine has finished.
-impl<'a, P1, P2, F> Future for GrabCoroutineVoid2<'a, P1, P2, F>
-where
-    P1: GrabParam,
-    P2: GrabParam,
-    F: Future<Output = ()> + Send + Sync,
-{
-    type Output = (P1::Fetch<'a>, P2::Fetch<'a>);
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access1 = P1::get_access(world, *this.from1);
-                    let access2 = P2::get_access(world, *this.from2);
-                    this.fib
-                        .grab_sender
-                        .send(GrabReason::Multi(vec![access1, access2]));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(_) => {
-                let entity1 = this.from1;
-                let entity2 = this.from2;
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result1 = P1::fetch(world.get_entity(*entity1).unwrap());
-                    let result2 = P2::fetch(world.get_entity(*entity2).unwrap());
-                    Poll::Ready((result1, result2))
-                }
-            }
-        }
-    }
-}
-
-/// Same as [`GrabCoroutineVoid`], but where the underlying coroutine
-/// can return a value.
-#[pin_project]
-pub struct GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    from: Entity,
-    fib: Fib,
-    #[pin]
-    inner: F,
-    _phantom: PhantomData<P>,
-    _phantom2: PhantomData<&'a ()>,
-}
-
-//
-impl<'a, P, F, O> GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    pub fn new(fib: Fib, from: Entity, inner: F) -> Self {
-        GrabCoroutine {
-            from,
-            fib,
-            _phantom: PhantomData,
-            inner,
-            _phantom2: PhantomData,
-        }
-    }
-}
-
-impl<'a, P, F, O> Future for GrabCoroutine<'a, P, F, O>
-where
-    P: GrabParam,
-    F: Future<Output = O> + Send + Sync,
-{
-    type Output = (O, P::Fetch<'a>);
-
-    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        match this.inner.poll(_cx) {
-            Poll::Pending => {
-                unsafe {
-                    let world = this.fib.world_window().world();
-                    let access = P::get_access(world, *this.from);
-                    this.fib.grab_sender.send(GrabReason::Single(access));
-                }
-                Poll::Pending
-            }
-            Poll::Ready(r) => {
-                let entity = this.from;
-                unsafe {
-                    let world =
-                        &mut *this.fib.world_window.get().expect(
-                            "This function should have been called when a coroutine is polled",
-                        );
-                    let world = world.as_unsafe_world_cell();
-                    let result = P::fetch(world.get_entity(*entity).unwrap());
-                    Poll::Ready((r, result))
-                }
-            }
-        }
-    }
-}
diff --git a/src/coroutine/mod.rs b/src/coroutine/mod.rs
index bdd13db..2a120df 100644
--- a/src/coroutine/mod.rs
+++ b/src/coroutine/mod.rs
@@ -1,304 +1,137 @@
-use std::cell::Cell;
-use std::future::Future;
-use std::rc::Rc;
-use std::time::Duration;
+use std::collections::VecDeque;
+use std::pin::Pin;
 
 use bevy::ecs::component::ComponentId;
-use bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell;
-use bevy::prelude::Component;
 use bevy::prelude::Entity;
+use bevy::prelude::Resource;
 use bevy::prelude::Timer;
 use bevy::prelude::World;
+use bevy::utils::synccell::SyncCell;
+use bevy::utils::HashMap;
+use tinyset::SetUsize;
 
-use crate::executor::msg_channel::Sender;
-use crate::executor::CoroObject;
-
-use duration::{DurationFuture, NextTick};
-use on::On;
-use par_and::ParAnd;
-use par_or::ParOr;
-use when::Change;
-
-use self::grab::GrabCoroutine;
-use self::grab::GrabCoroutineVoid;
-use self::grab::GrabParam;
-use self::grab::GrabReason;
+use self::observable::ObservableId;
 
+pub mod coro_param;
 pub mod duration;
-pub mod grab;
-mod on;
-mod par_and;
-mod par_or;
-mod when;
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub(crate) enum CoroState {
-    Halted,
-    Running,
+pub mod function_coroutine;
+pub mod observable;
+pub mod on;
+pub mod par_and;
+pub mod par_or;
+mod waker;
+
+/// A coroutine that can be added to an [`Entity`](bevy::prelude::Entity)
+///
+pub trait Coroutine: Send + 'static {
+    /// Resume execution of this coroutine.
+    ///
+    /// It will returns [`CoroutineResult::Yield`] if it can be resumed once again
+    /// or [`CoroutineResult::Done`] if it is done executing. Note that resuming a coroutine which
+    /// has terminate execution will panic.
+    fn resume(self: Pin<&mut Self>, world: &mut World) -> CoroutineResult<WaitingReason, ()>;
+
+    /// Return true, if this coroutine is still valid. If it is not, it should be despawned. Should
+    /// be called before [`resume`], to avoid any panic.
+    fn is_valid(self: Pin<&mut Self>, world: &World) -> bool;
+
+    /// Returns which part of the [`World`] are accessed by this [`Coroutine`].
+    /// Useful if the [`Executor`] is multithreaded.
+    fn access(&self) -> &CoroAccess;
 }
 
-pub(crate) enum WaitingReason {
-    Tick,
-    Duration(Timer),
-    Changed {
-        from: Entity,
-        component: ComponentId,
-    },
-    ParOr {
-        coroutines: Vec<CoroObject>,
-    },
-    ParAnd {
-        coroutines: Vec<CoroObject>,
-    },
-}
+/// A shared list of modified values (observable), to easily notify the apropriate observers.
+/// TODO: Find something better
+#[derive(Resource, Default)]
+pub(crate) struct CoroWrites(pub VecDeque<(Entity, ComponentId)>);
 
-/// A "Fiber" object, througth which a coroutine
-/// can interact with the rest of the world.
-pub struct Fib {
-    // Maybe replace by a real sender receiver channel at some point
-    pub(crate) yield_sender: Sender<WaitingReason>,
-    pub(crate) owner: Option<Entity>,
-    pub(crate) world_window: Rc<Cell<Option<*mut World>>>,
-    pub(crate) grab_sender: Sender<GrabReason>,
+#[derive(Default, Clone)]
+pub struct CoroAccess {
+    this_reads: HashMap<SourceId, SetUsize>,
+    this_writes: HashMap<SourceId, SetUsize>,
 }
 
-impl Fib {
-    /// Done like so, to avoid user code to be able to clone the Fiber (can lead to UB)
-    pub(crate) fn clone(&self) -> Self {
-        Self {
-            yield_sender: self.yield_sender.clone(),
-            owner: self.owner,
-            world_window: self.world_window.clone(),
-            grab_sender: self.grab_sender.clone(),
+impl CoroAccess {
+    /// Add a write access. Returns false if there is a conflict.
+    /// The access is updated only when no conflicts are found.
+    pub fn add_write(&mut self, to: SourceId, component: ComponentId) -> bool {
+        if let Some(reads) = self.this_reads.get(&to) {
+            if reads.contains(component.index()) {
+                return false;
+            }
         }
+
+        self.this_writes
+            .entry(to)
+            .or_default()
+            .insert(component.index())
     }
-}
 
-impl Fib {
-    fn component_id<T: Component>(&self) -> ComponentId {
-        // SAFETY: We are in the polling phase, therefore the coroutine is the only one running.
-        unsafe {
-            let w = &mut *self
-                .world_window
-                .get()
-                .expect("This function should have been called when a coroutine is polled");
-            w.component_id::<T>()
-                .expect("Component should have been initialized in the world")
+    /// Add a read access. Returns false if there is a conflict.
+    /// The access is updated only when no conflicts are found.
+    pub fn add_read(&mut self, to: SourceId, component: ComponentId) -> bool {
+        if let Some(reads) = self.this_writes.get(&to) {
+            if reads.contains(component.index()) {
+                return false;
+            }
         }
-    }
 
-    pub(crate) unsafe fn world_window(&self) -> UnsafeWorldCell<'_> {
-        let a = &mut *self
-            .world_window
-            .get()
-            .expect("This function should have been called when a coroutine is polled");
-        a.as_unsafe_world_cell()
+        self.this_reads
+            .entry(to)
+            .or_default()
+            .insert(component.index());
+        true
     }
 }
 
-// SAFETY: Same as Executor, the sender field is only accessed when polled,
-// which is done in a single threaded context.
-unsafe impl Send for Fib {}
-unsafe impl Sync for Fib {}
-
-impl Fib {
-    /// Returns coroutine that resolve the next time the [`Executor`] is ticked (via
-    /// [`run`][crate::executor::Executor::run] for instance). It returns the duration
-    /// of the last frame (delta time).
-    ///
-    /// [`Executor`]: crate::executor::Executor
-    pub fn next_tick(&mut self) -> NextTick<'_> {
-        NextTick::new(self)
-    }
-
-    /// Returns a coroutine that resolve after a certain [`Duration`]. Note that if the duration
-    /// is smaller than the time between two tick of the [`Executor`] it won't be compensated.
-    ///
-    /// [`Executor`]: crate::executor::Executor
-    pub fn duration(&mut self, duration: Duration) -> DurationFuture<'_> {
-        DurationFuture::new(self, duration)
-    }
-
-    /// Returns a coroutine that resolve once the [`Component`] of type `T` from a particular
-    /// [`Entity`] has changed. Note that if the entity or the components is removed,
-    /// this coroutine is dropped.
-    pub fn change<T: Component + Unpin>(&mut self, from: Entity) -> Change<'_, T> {
-        Change::new(self, from)
-    }
+#[derive(PartialEq, Eq, Clone, Copy, Hash)]
+pub enum SourceId {
+    Entity(Entity),
+    AllEntities,
+    World,
+}
 
-    /// Returns a coroutine that resolve once any of the underlying coroutine finishes. Note that
-    /// once this is done, all the others are dropped. The coroutines are resumed from top to
-    /// bottom, in case multiple of them are ready to make progress at the same time.
-    pub fn par_or<C, F>(&mut self, closure: C) -> ParOr<'_>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = Box::pin(closure(fib));
-        ParOr::new(self, vec![fut])
-    }
+/// A heap allocated Coroutine
+pub(crate) type CoroObject = SyncCell<Pin<Box<dyn Coroutine>>>;
 
-    /// Returns a coroutine that resolve once the underlying coroutine finishes,
-    /// in order to reuse coroutines, because the following won't compile:
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///async fn sub_coro(mut fib: Fib) { }
-    ///async fn main_coro(mut fib: Fib) {
-    ///  sub_coro(fib).await;
-    ///  sub_coro(fib).await;
-    ///}
-    ///```
-    /// But the following will:
-    ///```
-    ///# use corentin::prelude::*;
-    ///async fn sub_coro(mut fib: Fib) { }
-    ///async fn main_coro(mut fib: Fib) {
-    ///  fib.on(sub_coro).await;
-    ///  fib.on(sub_coro).await;
-    ///}
-    ///```
-    pub fn on<C, F>(&mut self, closure: C) -> On<F>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = closure(fib);
-        On::new(self, fut)
-    }
+/// The result after resuming a `Coroutine`. Either it yields an intermediate value, or return the
+/// final result.
+pub enum CoroutineResult<Y, R> {
+    Yield(Y),
+    Done(R),
+}
 
-    /// Same as [`Self::on()`] but with a coroutine that expect
-    /// an owner entity as a parameter.
-    pub fn on_self<C, F>(&mut self, closure: C) -> On<F>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib, Entity) -> F,
-    {
-        let fib = self.clone();
-        let fut = closure(
-            fib,
-            self.owner
-                .expect("Cannot call on_self if the coroutine is not owned by any entity."),
-        );
-        On::new(self, fut)
-    }
+pub trait IntoCoroutine<Marker> {
+    type Coroutine: Coroutine;
 
-    /// Returns a coroutine that resolve once all of the underlying coroutine finishes. The
-    /// coroutines are resumed from top to bottom, in case multiple of them are ready to make
-    /// progress at the same time.
-    pub fn par_and<C, F>(&mut self, closure: C) -> ParAnd<'_>
-    where
-        F: Coroutine<'static>,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.clone();
-        let fut = Box::pin(closure(fib));
-        ParAnd::new(self, vec![fut])
-    }
-
-    pub fn owner(&self) -> Option<Entity> {
-        self.owner
-    }
+    fn into_coroutine(self, owner: Entity) -> Self::Coroutine;
 }
 
-/// Traits defined on all primitive (next_tick, par_and, ...)
-pub trait Primitive<'cx, O>: Future<Output = O> + 'cx + Send + Sync + Sized {
-    fn get_context(&self) -> &Fib;
+/// Any type that can be turned into a [`Coroutine`], given an access to the [`World`], to run
+/// arbitrary setup logic, such as registering [`Component`].
+pub trait UninitCoroutine<Marker> {
+    type Coroutine: Coroutine;
 
-    /// Returns a set of component from an entity, once this coroutine
-    /// has finished. For instance:
-    ///```
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (dt, (mut foo, bar)) = fib.next_tick().then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         foo.0 += bar.0 * dt.as_secs();
-    ///     }
-    ///}
-    ///```
-    /// Note that the data is lifetime bounded to the Context, meaning it cannot outlive
-    /// accross awaiting points, for instance this will not compile
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
+    /// Initialize the Coroutine, or return None if it is invalid.
     ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (dt, (mut foo, bar)) = fib.next_tick().then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         fib.next_tick().await;
-    ///         foo.0 += bar.0 * dt.as_secs();
-    ///     }
-    ///}
-    ///```
-    fn then_grab<'cx2, P: GrabParam>(self, from: Entity) -> GrabCoroutine<'cx2, P, Self, O>
-    where
-        'cx: 'cx2,
-    {
-        let fib = self.get_context().clone();
-        GrabCoroutine::new(fib, from, self)
-    }
+    /// The world should be used to initialize any accesses, such as registering any
+    /// [`Component`](bevy::prelude::Component).
+    fn init(self, owner: Entity, world: &mut World) -> Option<Self::Coroutine>;
 }
 
-pub trait PrimitiveVoid<'cx>: Future<Output = ()> + 'cx + Send + Sync + Sized {
-    fn get_context(&self) -> &Fib;
-
-    /// Returns a set of component from an entity, once this coroutine
-    /// has finished. For instance:
-    ///```
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///# use std::time::Duration;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (mut foo, bar) = fib.duration(Duration::from_secs(1)).then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         foo.0 += bar.0;
-    ///     }
-    ///}
-    ///```
-    /// Note that the data is lifetime bounded to the Context, meaning it cannot outlive
-    /// accross awaiting points, for instance this will not compile
-    /// ```compile_fail
-    ///# use corentin::prelude::*;
-    ///# use bevy::prelude::*;
-    ///# use std::time::Duration;
-    ///#[derive(Component)]
-    ///struct Foo(u64);
-    ///#[derive(Component)]
-    ///struct Bar(u64);
-    ///
-    ///async fn coroutine(mut fib: Fib, e: Entity) {
-    ///     loop {
-    ///         let (mut foo, bar) = fib.duration(Duration::from_secs(1)).then_grab::<(&mut Foo, &Bar)>(e).await;
-    ///         fib.next_tick().await;
-    ///         foo.0 += bar.0;
-    ///     }
-    ///}
-    ///```
-    fn then_grab<'cx2, P: GrabParam>(self, from: Entity) -> GrabCoroutineVoid<'cx2, P, Self>
-    where
-        'cx: 'cx2,
-    {
-        let fib = self.get_context().clone();
-        GrabCoroutineVoid::new(fib, from, self)
-    }
+/// A [`Coroutine`] can only yield one of these messages Used by the [`Executor`] to know when to
+/// resume a coroutine.
+pub enum WaitingReason {
+    Tick,
+    Duration(Timer),
+    Changed(ObservableId),
+    ParOr { coroutines: Vec<CoroObject> },
+    ParAnd { coroutines: Vec<CoroObject> },
 }
 
-/// Shorthand notation
-pub trait Coroutine<'cx, O = ()>: Future<Output = O> + 'cx + Send + Sync {}
-impl<'cx, O, T> Coroutine<'cx, O> for T where T: Future<Output = O> + 'cx + Send + Sync {}
+// TODO put that somewhere else
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub(crate) enum CoroState {
+    Halted,
+    Running,
+}
diff --git a/src/coroutine/observable.rs b/src/coroutine/observable.rs
new file mode 100644
index 0000000..dd1196f
--- /dev/null
+++ b/src/coroutine/observable.rs
@@ -0,0 +1,56 @@
+use std::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use bevy::{ecs::component::ComponentId, prelude::Entity};
+
+use crate::coroutine::WaitingReason;
+
+use super::{coro_param::ParamContext, CoroState};
+
+/// Anything we can observe in the world will have one specific id
+#[derive(Copy, Clone)]
+pub enum ObservableId {
+    Entity(Entity),
+    Component(Entity, ComponentId),
+    Resource(ComponentId),
+}
+
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct OnChange<'a> {
+    state: CoroState,
+    id: ObservableId,
+    context: &'a ParamContext,
+}
+
+impl<'a> OnChange<'a> {
+    pub(crate) fn new(context: &'a ParamContext, id: ObservableId) -> Self {
+        Self {
+            state: CoroState::Running,
+            id,
+            context,
+        }
+    }
+}
+
+impl<'a> Future for OnChange<'a> {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.state {
+            CoroState::Halted => {
+                self.state = CoroState::Running;
+                Poll::Ready(())
+            }
+            CoroState::Running => {
+                self.state = CoroState::Halted;
+                self.context
+                    .yield_channel
+                    .send(WaitingReason::Changed(self.id));
+                Poll::Pending
+            }
+        }
+    }
+}
diff --git a/src/coroutine/on.rs b/src/coroutine/on.rs
index 55b83d9..152d250 100644
--- a/src/coroutine/on.rs
+++ b/src/coroutine/on.rs
@@ -1,47 +1,47 @@
-use pin_project::pin_project;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
-
-use super::Coroutine;
-use super::Fib;
-use super::PrimitiveVoid;
-
-#[pin_project]
-pub struct On<'a, F>
-where
-    F: Future<Output = ()> + 'static + Send + Sync,
-{
-    fib: &'a Fib,
-    #[pin]
-    coroutine: F,
-}
-
-impl<'a, F> On<'a, F>
-where
-    F: Future<Output = ()> + 'static + Send + Sync,
-{
-    pub(crate) fn new(fib: &'a Fib, coroutine: F) -> Self {
-        On { fib, coroutine }
-    }
-}
-
-impl<'a, F> Future for On<'a, F>
-where
-    F: Coroutine<'static>,
-{
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        let this = self.project();
-
-        this.coroutine.poll(cx)
-    }
-}
-
-impl<'cx, F: Coroutine<'static>> PrimitiveVoid<'cx> for On<'cx, F> {
-    fn get_context(&self) -> &super::Fib {
-        self.fib
-    }
-}
+//use pin_project::pin_project;
+//use std::future::Future;
+//use std::pin::Pin;
+//use std::task::Context;
+//use std::task::Poll;
+//
+//use crate::prelude::Fib;
+//
+//use super::Coroutine;
+//
+//#[pin_project]
+//pub struct On<'a, F>
+//where
+//    F: Future<Output = ()> + 'static + Send + Sync,
+//{
+//    fib: &'a Fib,
+//    #[pin]
+//    coroutine: F,
+//}
+//
+//impl<'a, F> On<'a, F>
+//where
+//    F: Future<Output = ()> + 'static + Send + Sync,
+//{
+//    pub(crate) fn new(fib: &'a Fib, coroutine: F) -> Self {
+//        On { fib, coroutine }
+//    }
+//}
+//
+//impl<'a, F> Future for On<'a, F>
+//where
+//    F: Coroutine<'static>,
+//{
+//    type Output = ();
+//
+//    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+//        let this = self.project();
+//
+//        this.coroutine.poll(cx)
+//    }
+//}
+//
+//impl<'cx, F: Coroutine<'static>> PrimitiveVoid<'cx> for On<'cx, F> {
+//    fn get_context(&self) -> &super::Fib {
+//        self.fib
+//    }
+//}
diff --git a/src/coroutine/par_and.rs b/src/coroutine/par_and.rs
index e974e10..8eb7036 100644
--- a/src/coroutine/par_and.rs
+++ b/src/coroutine/par_and.rs
@@ -1,36 +1,50 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use bevy::utils::synccell::SyncCell;
+
+use crate::coroutine::{CoroState, WaitingReason};
 
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::PrimitiveVoid;
+use super::coro_param::ParamContext;
+use super::{CoroObject, UninitCoroutine};
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct ParAnd<'a> {
-    fib: &'a Fib,
-    coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
+pub struct ParAnd {
+    context: ParamContext,
+    coroutines: Vec<CoroObject>,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a> ParAnd<'a> {
-    pub(crate) fn new(
-        fib: &'a Fib,
-        coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
-    ) -> Self {
+impl ParAnd {
+    pub(crate) fn new(context: ParamContext) -> Self {
         ParAnd {
-            fib,
-            coroutines,
+            context,
+            coroutines: vec![],
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
+
+    /// Add a new coroutine to this [`ParAnd`].
+    pub fn with<C, Marker>(mut self, coro: C) -> Self
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
+        self
+    }
 }
 
-impl<'a> Future for ParAnd<'a> {
+impl Future for ParAnd {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -42,36 +56,12 @@ impl<'a> Future for ParAnd<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                // TODO: Will care about performance later, maybe find a way to inline the coroutines
-                // instead of allocating them on the heap ?
-                let temp: Vec<Pin<Box<dyn Future<Output = ()> + Send + Sync>>> =
-                    self.coroutines.drain(..).collect();
-                self.fib
-                    .yield_sender
-                    .send(WaitingReason::ParAnd { coroutines: temp });
+                let coroutines = std::mem::take(&mut self.coroutines);
+                self.context
+                    .yield_channel
+                    .send(WaitingReason::ParAnd { coroutines });
                 Poll::Pending
             }
         }
     }
 }
-
-impl<'a> ParAnd<'a> {
-    /// Add a new coroutine to this [`ParAnd`]. It will have a lower priority than those defined
-    /// above.
-    pub fn with<C, F>(&mut self, closure: C) -> &mut Self
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.fib.clone();
-        let fut = Box::pin(closure(fib));
-        self.coroutines.push(fut);
-        self
-    }
-}
-
-impl<'cx> PrimitiveVoid<'cx> for ParAnd<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/coroutine/par_or.rs b/src/coroutine/par_or.rs
index 9579723..87fb116 100644
--- a/src/coroutine/par_or.rs
+++ b/src/coroutine/par_or.rs
@@ -1,36 +1,51 @@
-use crate::coroutine::{CoroState, Fib, WaitingReason};
+use bevy::utils::synccell::SyncCell;
+
+use crate::coroutine::{CoroState, WaitingReason};
 
 use std::future::Future;
-use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
 
-use super::PrimitiveVoid;
+use super::coro_param::ParamContext;
+use super::CoroObject;
+use super::UninitCoroutine;
 
 #[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct ParOr<'a> {
-    fib: &'a Fib,
-    coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
+pub struct ParOr {
+    context: ParamContext,
+    coroutines: Vec<CoroObject>,
     state: CoroState,
-    _phantom: PhantomData<&'a ()>,
 }
 
-impl<'a> ParOr<'a> {
-    pub(crate) fn new(
-        fib: &'a Fib,
-        coroutines: Vec<Pin<Box<(dyn Future<Output = ()> + 'static + Send + Sync)>>>,
-    ) -> Self {
+impl ParOr {
+    pub(crate) fn new(context: ParamContext) -> Self {
         ParOr {
-            fib,
-            coroutines,
+            context,
+            coroutines: vec![],
             state: CoroState::Running,
-            _phantom: PhantomData,
         }
     }
+
+    /// Add a new coroutine to this [`ParOr`].
+    pub fn with<C, Marker>(mut self, coro: C) -> Self
+    where
+        C: UninitCoroutine<Marker>,
+    {
+        // Safety: We are getting polled right now, therefore we have exclusive world access.
+        unsafe {
+            if let Some(c) = coro.init(
+                self.context.owner,
+                self.context.world_window.world_cell().world_mut(),
+            ) {
+                self.coroutines.push(SyncCell::new(Box::pin(c)));
+            }
+        }
+        self
+    }
 }
 
-impl<'a> Future for ParOr<'a> {
+impl Future for ParOr {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
@@ -42,36 +57,12 @@ impl<'a> Future for ParOr<'a> {
             }
             CoroState::Running => {
                 self.state = CoroState::Halted;
-                // TODO: Will care about performance later, maybe find a way to inline the coroutines
-                // instead of allocating them on the heap ?
-                let temp: Vec<Pin<Box<dyn Future<Output = ()> + Send + Sync>>> =
-                    self.coroutines.drain(..).collect();
-                self.fib
-                    .yield_sender
-                    .send(WaitingReason::ParOr { coroutines: temp });
+                let coroutines = std::mem::take(&mut self.coroutines);
+                self.context
+                    .yield_channel
+                    .send(WaitingReason::ParOr { coroutines });
                 Poll::Pending
             }
         }
     }
 }
-
-impl<'a> ParOr<'a> {
-    /// Add a new coroutine to this [`ParOr`]. It will have a lower priority than those defined
-    /// above.
-    pub fn with<C, F>(&mut self, closure: C) -> &mut Self
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = self.fib.clone();
-        let fut = Box::pin(closure(fib));
-        self.coroutines.push(fut);
-        self
-    }
-}
-
-impl<'cx> PrimitiveVoid<'cx> for ParOr<'cx> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
diff --git a/src/waker.rs b/src/coroutine/waker.rs
similarity index 100%
rename from src/waker.rs
rename to src/coroutine/waker.rs
diff --git a/src/coroutine/when.rs b/src/coroutine/when.rs
deleted file mode 100644
index 6769661..0000000
--- a/src/coroutine/when.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-use bevy::prelude::Component;
-use bevy::prelude::Entity;
-
-use crate::coroutine::{CoroState, Fib, WaitingReason};
-
-use std::future::Future;
-use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
-
-use super::PrimitiveVoid;
-
-#[must_use = "futures do nothing unless you `.await` or poll them"]
-pub struct Change<'a, T: Component> {
-    fib: &'a Fib,
-    from: Entity,
-    _phantom: PhantomData<T>,
-    state: CoroState,
-}
-
-impl<'a, T: Component + Unpin> Change<'a, T> {
-    pub(crate) fn new(fib: &'a Fib, from: Entity) -> Self {
-        Change {
-            fib,
-            from,
-            _phantom: PhantomData,
-            state: CoroState::Running,
-        }
-    }
-}
-
-impl<'a, T: Component + Unpin> Future for Change<'a, T> {
-    type Output = ();
-
-    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
-        match self.state {
-            // We assume the executor will only poll it once the component changed
-            CoroState::Halted => {
-                self.state = CoroState::Running;
-                Poll::Ready(())
-            }
-            CoroState::Running => {
-                let c_id = self.fib.component_id::<T>();
-                self.state = CoroState::Halted;
-                self.fib.yield_sender.send(WaitingReason::Changed {
-                    from: self.from,
-                    component: c_id,
-                });
-                Poll::Pending
-            }
-        }
-    }
-}
-
-impl<'a, T: Component + Unpin> PrimitiveVoid<'a> for Change<'a, T> {
-    fn get_context(&self) -> &Fib {
-        self.fib
-    }
-}
-
-//impl<'a, T: Component> Change<'a, T> {
-//    pub fn with<C: 'static>(self) -> ChangeWith<'a, T> {
-//        ChangeWith {
-//            fib: self.fib,
-//            from: self.from,
-//            _phantom: PhantomData,
-//            with: vec![TypeId::of::<C>()],
-//            without: Vec::new(),
-//            state: self.state,
-//        }
-//    }
-//
-//    pub fn without<C: 'static>(self) -> ChangeWith<'a, T> {
-//        ChangeWith {
-//            fib: self.fib,
-//            from: self.from,
-//            _phantom: PhantomData,
-//            with: Vec::new(),
-//            without: vec![TypeId::of::<C>()],
-//            state: self.state,
-//        }
-//    }
-//}
-//
-//#[must_use = "futures do nothing unless you `.await` or poll them"]
-//pub struct ChangeWith<'a, T: Component> {
-//    fib: Fib,
-//    from: Entity,
-//    _phantom: PhantomData<T>,
-//    // TODO: make that more efficient and more robust (and not rely on TypeId)
-//    with: Vec<TypeId>,
-//    without: Vec<TypeId>,
-//    state: CoroState,
-//    _phantom2: PhantomData<&'a ()>,
-//}
-//
-//impl<'a, T: Component> ChangeWith<'a, T> {
-//   pub(crate) fn new(fib: Fib, from: Entity, with:)
-//}
-//
-//impl<'a, T: Component + Unpin> Future for ChangeWith<'a, T> {
-//    type Output = ();
-//
-//    fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
-//        match self.state {
-//            CoroState::Halted => {
-//                self.state = CoroState::Running;
-//                Poll::Ready(())
-//            }
-//            CoroState::Running => {
-//                let c_id = self.fib.component_id::<T>();
-//                let with: Vec<ComponentId> = self
-//                    .with
-//                    .iter()
-//                    .map(|tid| self.fib.get_component_id(*tid))
-//                    .collect();
-//                let without: Vec<ComponentId> = self
-//                    .without
-//                    .iter()
-//                    .map(|tid| self.fib.get_component_id(*tid))
-//                    .collect();
-//                self.state = CoroState::Halted;
-//                self.fib.yield_sender.send(WaitingReason::ChangedWith {
-//                    from: self.from,
-//                    component: c_id,
-//                    with,
-//                    without,
-//                });
-//                Poll::Pending
-//            }
-//        }
-//    }
-//}
-//
-//impl<'a, T: Component> ChangeWith<'a, T> {
-//    pub fn with<C: 'static>(&mut self) -> &mut Self {
-//        self.with.push(TypeId::of::<C>());
-//        self
-//    }
-//
-//    pub fn without<C: 'static>(&mut self) -> &mut Self {
-//        self.without.push(TypeId::of::<C>());
-//        self
-//    }
-//}
diff --git a/src/executor/mod.rs b/src/executor/mod.rs
index 0ba5835..94a84a7 100644
--- a/src/executor/mod.rs
+++ b/src/executor/mod.rs
@@ -1,70 +1,50 @@
 use bevy::utils::HashMap;
 use bevy::{ecs::component::ComponentId, prelude::*};
-use core::task::Context;
-use coroutine::{Fib, WaitingReason};
-use std::cell::Cell;
+use coroutine::WaitingReason;
 use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::task::Poll;
-use waker::create;
 
-use crate::{coroutine, waker};
-use coroutine::grab::GrabReason;
-use msg_channel::Receiver;
+use crate::coroutine;
+use crate::coroutine::observable::ObservableId;
+use crate::coroutine::{CoroObject, CoroWrites, Coroutine, CoroutineResult};
 
-pub(crate) type CoroObject = Pin<Box<dyn Future<Output = ()> + Send + Sync>>;
-
-pub(crate) mod msg_channel;
 mod run_ctx;
-use run_ctx::RunContext;
-
-use self::run_ctx::SuspendedCoro;
+pub(crate) use run_ctx::RunContext;
 
 type CoroId = u32;
 
 #[derive(Resource)]
 pub struct Executor {
     coroutines: HashMap<CoroId, CoroObject>,
-    yield_msg: Receiver<WaitingReason>,
-    grab_msg: Receiver<GrabReason>,
     waiting_on_tick: VecDeque<CoroId>,
     waiting_on_duration: VecDeque<(Timer, CoroId)>,
     waiting_on_change: HashMap<(Entity, ComponentId), Vec<CoroId>>,
     waiting_on_par_or: HashMap<CoroId, Vec<CoroId>>,
     waiting_on_par_and: HashMap<CoroId, Vec<CoroId>>,
     is_awaited_by: HashMap<CoroId, CoroId>,
-    own: HashMap<Entity, Vec<CoroId>>,
-    world_window: Rc<Cell<Option<*mut World>>>,
-    accesses: HashMap<CoroId, GrabReason>,
     next_id: CoroId,
 }
 
+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 // SAFETY: This is safe because the only !Send and !Sync field (receiver) is only accessed
 // when calling run(), which is done in a single threaded context.
 unsafe impl Send for Executor {}
 unsafe impl Sync for Executor {}
 
-const ERR_WRONGAWAIT: &str = "A coroutine yielded without notifying the executor
-the reason. That is most likely because it awaits a
-future which is not part of this library.";
-
 impl Executor {
     pub fn new() -> Self {
         Executor {
             coroutines: HashMap::new(),
-            yield_msg: Receiver::new(),
-            grab_msg: Receiver::new(),
             waiting_on_tick: VecDeque::new(),
             waiting_on_duration: VecDeque::new(),
             waiting_on_change: HashMap::new(),
             waiting_on_par_or: HashMap::new(),
             waiting_on_par_and: HashMap::new(),
             is_awaited_by: HashMap::new(),
-            own: HashMap::new(),
-            world_window: Rc::new(Cell::new(None)),
-            accesses: HashMap::new(),
             next_id: 0,
         }
     }
@@ -77,41 +57,12 @@ impl Executor {
     }
 
     /// Add a coroutine to the executor.
-    pub fn add<C, F>(&mut self, closure: C)
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib) -> F,
-    {
-        let fib = Fib {
-            yield_sender: self.yield_msg.sender(),
-            grab_sender: self.grab_msg.sender(),
-            owner: None,
-            world_window: Rc::clone(&self.world_window),
-        };
+    pub fn add(&mut self, coroutine: CoroObject) {
         let id = self.next_id();
-        self.coroutines.insert(id, Box::pin(closure(fib)));
+        self.coroutines.insert(id, coroutine);
         self.waiting_on_tick.push_back(id);
     }
 
-    /// Add a coroutine owned by an [`Entity`] to the executor.
-    /// If the entity is removed, the coroutine is dropped.
-    pub fn add_to_entity<C, F>(&mut self, entity: Entity, closure: C)
-    where
-        F: Future<Output = ()> + 'static + Send + Sync,
-        C: FnOnce(Fib, Entity) -> F,
-    {
-        let fib = Fib {
-            yield_sender: self.yield_msg.sender(),
-            grab_sender: self.grab_msg.sender(),
-            owner: None,
-            world_window: Rc::clone(&self.world_window),
-        };
-        let id = self.next_id();
-        self.coroutines.insert(id, Box::pin(closure(fib, entity)));
-        self.waiting_on_tick.push_back(id);
-        self.own.entry(entity).or_default().push(id);
-    }
-
     /// Drop a coroutine from the executor.
     pub fn cancel(&mut self, coroutine: CoroId) {
         self.coroutines.remove(&coroutine);
@@ -161,7 +112,6 @@ impl Executor {
             self.waiting_on_change.retain(|(e, c), coro| {
                 if let Some(e) = w.get_entity(*e) {
                     if let Some(t) = e.get_change_ticks_by_id(*c) {
-                        // TODO: Make sure this is correct, I'm really not that confident, even though it works with a simple example
                         if t.is_changed(w.last_change_tick(), w.change_tick()) {
                             for c in coro {
                                 root_coros.push_back(*c);
@@ -180,107 +130,63 @@ impl Executor {
             }
         });
 
-        let mut run_cx: RunContext = RunContext::new();
-        let waker = create();
-        let mut context = Context::from_waker(&waker);
-
-        // TODO: Find maybe a safer abstraction ?
-        self.world_window.replace(Some(world as *mut _));
-
-        while let Some(coro) = root_coros.pop_front() {
-            let node = run_cx.parent_table.add_root();
-            self.run(coro, node, false, &mut run_cx, &mut context);
-        }
+        let mut run_cx = RunContext::new();
+        let mut ready_coro: VecDeque<(CoroId, usize)> = root_coros
+            .into_iter()
+            .map(|c_id| (c_id, run_cx.parent_table.add_root()))
+            .collect();
 
-        while let Some(SuspendedCoro { coro_id, node }) = run_cx.delayed.pop_front() {
-            self.run(coro_id, node, true, &mut run_cx, &mut context);
+        while let Some((c_id, node)) = ready_coro.pop_front() {
+            self.run(c_id, node, &mut run_cx, &mut ready_coro, world);
         }
     }
 
     /// Run a specific coroutine and it's children.
     fn run(
         &mut self,
-        coro: CoroId,
+        coro_id: CoroId,
         this_node: usize,
-        resumed: bool,
         run_cx: &mut RunContext,
-        cx: &mut Context,
+        ready_coro: &mut VecDeque<(CoroId, usize)>,
+        world: &mut World,
     ) {
-        if !self.coroutines.contains_key(&coro) {
+        if !self.coroutines.contains_key(&coro_id) {
             return;
         }
 
-        let accesses = self.accesses.get(&coro);
-        if let Some(accesses) = accesses {
-            {
-                let world = unsafe { &mut *self.world_window.get().unwrap() };
-                if !accesses.is_valid(world) {
-                    self.cancel(coro);
-                    return;
-                }
-            }
+        let coro = self.coroutines.get_mut(&coro_id).unwrap().get();
+        if !coro.as_mut().is_valid(world) {
+            self.cancel(coro_id);
+            return;
+        }
 
-            let mut has_conflicts = false;
-            let conflicters = run_cx.write_table.conflicts(accesses.writes());
-            for c in conflicters {
-                if !resumed || !run_cx.parent_table.is_parent(*c, this_node) {
-                    run_cx.parent_table.add_parent(*c, this_node);
-                    has_conflicts = true;
-                }
-            }
+        let result = Coroutine::resume(coro.as_mut(), world);
 
-            if has_conflicts {
-                run_cx
-                    .delayed
-                    .push_back(SuspendedCoro::new(coro, this_node));
+        let mut writes = world.resource_mut::<CoroWrites>();
 
-                return;
+        while let Some((to_entity, component)) = writes.0.pop_front() {
+            if let Some(prev_writer) = run_cx.write_table.insert((to_entity, component), this_node)
+            {
+                run_cx.parent_table.add_parent(prev_writer, this_node);
             }
-        }
-        // To make sure we can detect changes that just happened
-        {
-            let world = unsafe { &mut *self.world_window.get().unwrap() };
-            world.increment_change_tick();
-        }
-
-        let result = self.coroutines.get_mut(&coro).unwrap().as_mut().poll(cx);
-        let yield_msg = self.yield_msg.receive();
-        let next_access = self.grab_msg.receive();
-
-        if let Some(accesses) = accesses {
-            // SAFETY: No other coroutines a running right now, we have exclusive world access
-            let world = unsafe { &mut *self.world_window.get().unwrap() };
-            // TODO: Should probably find a better way
-            for write in accesses.writes().iter().filter(|(e, cid)| {
-                let tick = match world.get_entity(*e).unwrap().get_change_ticks_by_id(*cid) {
-                    Some(t) => t,
-                    None => {
-                        // The access was valid so that must be an optional field
-                        return false;
-                    }
-                };
-                tick.last_changed_tick() == world.change_tick()
-            }) {
-                run_cx.write_table.insert(*write, this_node);
-                if let Some(nexts) = self.waiting_on_change.remove(write) {
-                    for c in nexts {
-                        let node = match run_cx.current_node_map.remove(&c) {
-                            Some(n) => {
-                                run_cx.parent_table.add_parent(this_node, n);
-                                n
-                            }
-                            None => run_cx.parent_table.add_child(this_node),
-                        };
-                        self.run(c, node, false, run_cx, cx);
-                    }
+            if let Some(nexts) = self.waiting_on_change.remove(&(to_entity, component)) {
+                for c in nexts {
+                    let node = match run_cx.current_node_map.remove(&c) {
+                        Some(n) => {
+                            run_cx.parent_table.add_parent(this_node, n);
+                            n
+                        }
+                        None => run_cx.parent_table.add_child(this_node),
+                    };
+                    ready_coro.push_back((c, node));
                 }
             }
         }
 
         match result {
-            Poll::Ready(_) => {
-                self.coroutines.remove(&coro);
-                if let Some(parent) = self.is_awaited_by.remove(&coro) {
+            CoroutineResult::Done(_) => {
+                self.coroutines.remove(&coro_id);
+                if let Some(parent) = self.is_awaited_by.remove(&coro_id) {
                     if let Some(others) = self.waiting_on_par_or.remove(&parent) {
                         // coro is the "winner", all the others are cancelled
                         for o in others {
@@ -291,7 +197,7 @@ impl Executor {
                         self.waiting_on_tick.push_back(parent);
                     }
                     if let Some(others) = self.waiting_on_par_and.get_mut(&parent) {
-                        let index = others.iter().position(|c| *c == coro).unwrap();
+                        let index = others.iter().position(|c| *c == coro_id).unwrap();
                         others.remove(index);
                         if others.is_empty() {
                             // TODO: should run immediatly
@@ -301,75 +207,74 @@ impl Executor {
                     }
                 }
             }
-            Poll::Pending => {
-                if let Some(grab) = next_access {
-                    self.accesses.insert(coro, grab);
-                }
-                match yield_msg.expect(ERR_WRONGAWAIT) {
-                    WaitingReason::Tick => self.waiting_on_tick.push_back(coro),
-                    WaitingReason::Duration(d) => self.waiting_on_duration.push_back((d, coro)),
-                    WaitingReason::Changed { from, component } => {
+            CoroutineResult::Yield(yield_msg) => match yield_msg {
+                WaitingReason::Tick => self.waiting_on_tick.push_back(coro_id),
+                WaitingReason::Duration(d) => self.waiting_on_duration.push_back((d, coro_id)),
+                WaitingReason::Changed(change_id) => match change_id {
+                    ObservableId::Component(from, component) => {
                         let next_node = run_cx.parent_table.add_child(this_node);
                         match run_cx.can_execute_now(next_node, &(from, component)) {
                             Some(writer) => {
                                 run_cx.parent_table.add_parent(writer, next_node);
-                                self.run(coro, next_node, false, run_cx, cx);
+                                ready_coro.push_back((coro_id, next_node));
                             }
                             None => {
                                 self.waiting_on_change
                                     .entry((from, component))
                                     .or_default()
-                                    .push(coro);
-                                run_cx.current_node_map.insert(coro, next_node);
+                                    .push(coro_id);
+                                run_cx.current_node_map.insert(coro_id, next_node);
                             }
                         }
                     }
-                    WaitingReason::ParOr { coroutines } => {
-                        let parent = coro;
-                        let mut all_ids = Vec::with_capacity(coroutines.len());
-                        for coroutine in coroutines {
-                            let id = self.next_id();
-                            self.coroutines.insert(id, coroutine);
-                            self.is_awaited_by.insert(id, parent);
-                            all_ids.push(id);
-                        }
+                    _ => todo!(),
+                },
+                WaitingReason::ParOr { coroutines } => {
+                    let parent = coro_id;
+                    let mut all_ids = Vec::with_capacity(coroutines.len());
+                    for coroutine in coroutines {
+                        let id = self.next_id();
+                        self.coroutines.insert(id, coroutine);
+                        self.is_awaited_by.insert(id, parent);
+                        all_ids.push(id);
+                    }
 
-                        self.waiting_on_par_or.insert(parent, all_ids.clone());
+                    self.waiting_on_par_or.insert(parent, all_ids.clone());
 
-                        for id in all_ids {
-                            let node = run_cx.parent_table.add_child(this_node);
-                            self.run(id, node, false, run_cx, cx);
-                        }
+                    for id in all_ids {
+                        let node = run_cx.parent_table.add_child(this_node);
+                        ready_coro.push_back((id, node));
+                    }
+                }
+                WaitingReason::ParAnd { coroutines } => {
+                    let parent = coro_id;
+                    let mut all_ids = Vec::with_capacity(coroutines.len());
+                    for coroutine in coroutines {
+                        let id = self.next_id();
+                        self.coroutines.insert(id, coroutine);
+                        self.is_awaited_by.insert(id, parent);
+                        all_ids.push(id);
                     }
-                    WaitingReason::ParAnd { coroutines } => {
-                        let parent = coro;
-                        let mut all_ids = Vec::with_capacity(coroutines.len());
-                        for coroutine in coroutines {
-                            let id = self.next_id();
-                            self.coroutines.insert(id, coroutine);
-                            self.is_awaited_by.insert(id, parent);
-                            all_ids.push(id);
-                        }
 
-                        self.waiting_on_par_and.insert(parent, all_ids.clone());
+                    self.waiting_on_par_and.insert(parent, all_ids.clone());
 
-                        for id in all_ids {
-                            let node = run_cx.parent_table.add_child(this_node);
-                            self.run(id, node, false, run_cx, cx);
-                        }
+                    for id in all_ids {
+                        let node = run_cx.parent_table.add_child(this_node);
+                        ready_coro.push_back((id, node));
                     }
                 }
-            }
+            },
         };
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::coroutine::Primitive;
+    use crate::{coroutine::CoroWrites, prelude::*};
 
     use super::Executor;
     use bevy::{
+        ecs::system::EntityCommand,
         prelude::{Component, Mut, World},
         time::Time,
     };
@@ -384,31 +289,35 @@ mod tests {
     #[test]
     fn par_or_despawn_correctly() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        let e = world.spawn_empty().id();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                fib.par_or(|mut fib| async move {
-                    fib.par_or(|mut fib| async move {
-                        loop {
-                            fib.next_tick().await;
-                        }
-                    })
-                    .with(|mut fib| async move {
-                        loop {
-                            fib.next_tick().await;
-                        }
-                    })
-                    .await;
+
+        coroutine(|fib: Fib| async move {
+            fib.par_or(|fib: Fib| async move {
+                fib.par_or(|fib: Fib| async move {
+                    loop {
+                        fib.next_tick().await;
+                    }
                 })
-                .with(|mut fib| async move {
-                    for _ in 0..4 {
+                .with(|fib: Fib| async move {
+                    loop {
                         fib.next_tick().await;
                     }
                 })
                 .await;
-            });
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..4 {
+                    fib.next_tick().await;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
 
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             assert_eq!(executor.is_awaited_by.len(), 0);
             assert_eq!(executor.waiting_on_par_or.len(), 0);
             assert_eq!(executor.coroutines.len(), 1);
@@ -432,21 +341,26 @@ mod tests {
     #[test]
     fn waiting_on_change_cancel_when_components_not_present() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
         let e = world.spawn((ExampleComponent, ExampleComponentBar)).id();
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib.next_tick().then_grab::<&ExampleComponentBar>(e).await;
-                }
-            });
 
+        coroutine(|fib: Fib, _ex: Rd<ExampleComponent>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
+
+        coroutine(|fib: Fib, _ex: Rd<ExampleComponentBar>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             assert_eq!(executor.coroutines.len(), 2);
             executor.tick(w);
             assert_eq!(executor.coroutines.len(), 2);
@@ -462,19 +376,17 @@ mod tests {
     #[test]
     fn waiting_on_change_dont_cancel_on_optional() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
         let e = world.spawn(ExampleComponent).id();
+        coroutine(|fib: Fib, _ex: Opt<Rd<ExampleComponent>>| async move {
+            loop {
+                fib.next_tick().await;
+            }
+        })
+        .apply(e, &mut world);
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(|mut fib| async move {
-                loop {
-                    let _ex = fib
-                        .next_tick()
-                        .then_grab::<Option<&ExampleComponent>>(e)
-                        .await;
-                }
-            });
-
             assert_eq!(executor.coroutines.len(), 1);
             executor.tick(w);
             assert_eq!(executor.coroutines.len(), 1);
@@ -484,9 +396,3 @@ mod tests {
         });
     }
 }
-
-impl Default for Executor {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/src/executor/msg_channel.rs b/src/executor/msg_channel.rs
deleted file mode 100644
index 6826df3..0000000
--- a/src/executor/msg_channel.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-// A simple single receiver, multiple sender channel (will probably change later)
-// with a capacity of 1 (Mostly here for code clarity)
-
-pub(crate) struct Receiver<T> {
-    channel: Rc<Cell<Option<T>>>,
-}
-
-impl<T> Default for Receiver<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-pub(crate) struct Sender<T> {
-    channel: Rc<Cell<Option<T>>>,
-}
-
-impl<T> Clone for Sender<T> {
-    fn clone(&self) -> Self {
-        Self {
-            channel: Rc::clone(&self.channel),
-        }
-    }
-}
-
-impl<T> Receiver<T> {
-    pub(crate) fn new() -> Self {
-        Self {
-            channel: Rc::new(Cell::new(None)),
-        }
-    }
-
-    pub(crate) fn receive(&self) -> Option<T> {
-        self.channel.replace(None)
-    }
-
-    pub(crate) fn sender(&self) -> Sender<T> {
-        Sender {
-            channel: Rc::clone(&self.channel),
-        }
-    }
-}
-
-impl<T> Sender<T> {
-    pub(crate) fn send(&self, val: T) {
-        self.channel.replace(Some(val));
-    }
-}
diff --git a/src/executor/run_ctx.rs b/src/executor/run_ctx.rs
index ab7a2b6..10c4827 100644
--- a/src/executor/run_ctx.rs
+++ b/src/executor/run_ctx.rs
@@ -1,5 +1,3 @@
-use std::collections::VecDeque;
-
 use bevy::{ecs::component::ComponentId, prelude::Entity, utils::HashMap};
 use tinyset::SetUsize;
 
@@ -20,14 +18,6 @@ impl<T> WriteTable<T> {
     pub(crate) fn insert(&mut self, location: (Entity, ComponentId), writer: T) -> Option<T> {
         self.table.insert(location, writer)
     }
-
-    /// Return all conflicters
-    pub(crate) fn conflicts<I>(&self, vals: I) -> impl Iterator<Item = &'_ T>
-    where
-        I: IntoIterator<Item = (Entity, ComponentId)>,
-    {
-        vals.into_iter().filter_map(|k| self.table.get(&k))
-    }
 }
 
 pub(crate) struct ParentTable {
@@ -52,8 +42,8 @@ impl ParentTable {
     }
 
     /// Return true if (and only if) `parent` is a parent of `child`.
-    /// It is useful to know if a write perform in a can
-    /// be reacted by b, which is the case if this returns
+    /// It is useful to know if a write performed by coroutine A can
+    /// be observed by coroutine B, which is the case if this returns
     /// false.
     pub(crate) fn is_parent(&self, parent: usize, child: usize) -> bool {
         self.table.get(child).unwrap().contains(parent)
@@ -67,21 +57,9 @@ impl ParentTable {
     }
 }
 
-pub(crate) struct SuspendedCoro {
-    pub(crate) coro_id: CoroId,
-    pub(crate) node: usize,
-}
-
-impl SuspendedCoro {
-    pub(crate) fn new(coro_id: CoroId, node: usize) -> Self {
-        Self { coro_id, node }
-    }
-}
-
 pub(crate) struct RunContext {
     pub(crate) write_table: WriteTable<usize>,
     pub(crate) parent_table: ParentTable,
-    pub(crate) delayed: VecDeque<SuspendedCoro>,
     pub(crate) current_node_map: HashMap<CoroId, usize>,
 }
 
@@ -90,7 +68,6 @@ impl RunContext {
         RunContext {
             write_table: WriteTable::new(),
             parent_table: ParentTable::new(),
-            delayed: VecDeque::new(),
             current_node_map: HashMap::new(),
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index 017e2d3..c4a3f6c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,17 +1,24 @@
 //! A coroutine library for the [bevy](https://github.com/bevyengine/bevy) game engine.
 //!
 //! TODO: Show example
+pub mod commands;
 pub mod coroutine;
 pub mod executor;
-
-mod waker;
-mod world_window;
+pub mod plugin;
 
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::coroutine::{Fib, Primitive, PrimitiveVoid};
+    pub use crate::commands::{coroutine, AddCoroutine};
+    #[doc(hidden)]
+    pub use crate::coroutine::coro_param::{
+        component::Rd, component::Wr, resource::RdRes, resource::WrRes, Opt,
+    };
+    #[doc(hidden)]
+    pub use crate::coroutine::function_coroutine::Fib;
     #[doc(hidden)]
     pub use crate::executor::Executor;
+    #[doc(hidden)]
+    pub use crate::plugin::CorentinPlugin;
 }
 
 #[cfg(test)]
@@ -22,11 +29,12 @@ mod tests {
     };
 
     use bevy::{
+        ecs::system::EntityCommand,
         prelude::{Component, Mut, World},
         time::Time,
     };
 
-    use crate::{coroutine::Primitive, prelude::*};
+    use crate::{commands::coroutine, coroutine::CoroWrites, prelude::*};
 
     #[derive(Component)]
     struct ExampleComponent(u32);
@@ -34,75 +42,56 @@ mod tests {
     #[test]
     fn wait_on_tick() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        let e = world.spawn_empty().id();
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                *b.lock().unwrap() += 1;
-                fib.next_tick().await;
-                *b.lock().unwrap() += 1;
-                fib.next_tick().await;
-                *b.lock().unwrap() += 1;
-            });
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 1);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 2);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 3);
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 3);
-        });
-    }
 
-    #[test]
-    fn wait_on_sub_coroutine() {
-        async fn sub_coro(mut fib: Fib) {
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+        coroutine(|fib: Fib| async move {
+            *b.lock().unwrap() += 1;
             fib.next_tick().await;
+            *b.lock().unwrap() += 1;
             fib.next_tick().await;
-        }
+            *b.lock().unwrap() += 1;
+        })
+        .apply(e, &mut world);
 
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                *b.lock().unwrap() += 1;
-                fib.on(sub_coro).await;
-                *b.lock().unwrap() += 1;
-            });
-            executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 1);
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 1);
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 2);
             executor.tick(w);
-            assert_eq!(*a.lock().unwrap(), 2);
+            assert_eq!(*a.lock().unwrap(), 3);
+            executor.tick(w);
+            assert_eq!(*a.lock().unwrap(), 3);
         });
     }
 
     #[test]
-    fn wait_on_change() {
+    fn wait_on_external_change() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
+        let e = world.spawn(ExampleComponent(0)).id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+
+        coroutine(move |fib: Fib, ex: Rd<ExampleComponent>| async move {
+            fib.next_tick().await;
+            ex.on_change().await;
+            *b.lock().unwrap() += 1;
+        })
+        .apply(e, &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let e = w.spawn(ExampleComponent(0)).id();
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.next_tick().await;
-                fib.change::<ExampleComponent>(e).await;
-                *b.lock().unwrap() += 1;
-            });
+            w.clear_trackers();
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 0);
-            w.clear_trackers();
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 0);
             executor.tick(w);
@@ -122,12 +111,16 @@ mod tests {
             std::future::pending::<()>().await;
         }
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
+        coroutine(|| async move {
+            external_future().await;
+        })
+        .apply(world.spawn_empty().id(), &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |_| async move {
-                external_future().await;
-            });
             executor.tick(w);
         });
     }
@@ -135,26 +128,31 @@ mod tests {
     #[test]
     fn waiting_on_par_or() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.par_or(|mut fib| async move {
-                    loop {
-                        fib.next_tick().await;
-                        *b.lock().unwrap() += 1;
-                    }
-                })
-                .with(|mut fib| async move {
-                    for _ in 0..4 {
-                        fib.next_tick().await;
-                    }
-                })
-                .await;
-            });
 
+        let e = world.spawn_empty().id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+
+        coroutine(move |fib: Fib| async move {
+            fib.par_or(|fib: Fib| async move {
+                loop {
+                    fib.next_tick().await;
+                    *b.lock().unwrap() += 1;
+                }
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..4 {
+                    fib.next_tick().await;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
+
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             for i in 0..5 {
                 // Note that it works because the coroutine on the the top of the par_or,
                 // has priority over the one on the bottom, meaning its side effect will be
@@ -168,26 +166,31 @@ mod tests {
     #[test]
     fn waiting_on_par_and() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            let a = Arc::new(Mutex::new(0));
-            let b = Arc::clone(&a);
-            let c = Arc::clone(&a);
-            executor.add(move |mut fib| async move {
-                fib.par_and(|mut fib| async move {
+
+        let e = world.spawn_empty().id();
+        let a = Arc::new(Mutex::new(0));
+        let b = Arc::clone(&a);
+        let c = Arc::clone(&a);
+
+        coroutine(|fib: Fib| async move {
+            fib.par_and(|fib: Fib| async move {
+                fib.next_tick().await;
+                *b.lock().unwrap() += 1;
+            })
+            .with(|fib: Fib| async move {
+                for _ in 0..2 {
                     fib.next_tick().await;
-                    *b.lock().unwrap() += 1;
-                })
-                .with(|mut fib| async move {
-                    for _ in 0..2 {
-                        fib.next_tick().await;
-                        *c.lock().unwrap() += 1;
-                    }
-                })
-                .await;
-            });
+                    *c.lock().unwrap() += 1;
+                }
+            })
+            .await;
+        })
+        .apply(e, &mut world);
 
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             executor.tick(w);
             assert_eq!(*a.lock().unwrap(), 0);
             executor.tick(w);
@@ -202,16 +205,21 @@ mod tests {
     #[test]
     fn reading_components() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
         let e = world.spawn(ExampleComponent(0)).id();
+
+        coroutine(|fib: Fib, example: Rd<ExampleComponent>| async move {
+            for i in 0..5 {
+                fib.next_tick().await;
+                assert_eq!(example.get().0, i);
+            }
+        })
+        .apply(e, &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for i in 0..5 {
-                    let (_, example) = fib.next_tick().then_grab::<&ExampleComponent>(e).await;
-                    assert_eq!(example.0, i);
-                }
-            });
             executor.tick(w);
             for _ in 0..5 {
                 executor.tick(w);
@@ -223,17 +231,21 @@ mod tests {
     #[test]
     fn writing_components() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
         let e = world.spawn(ExampleComponent(0)).id();
+
+        coroutine(|fib: Fib, mut example: Wr<ExampleComponent>| async move {
+            for _ in 0..5 {
+                fib.next_tick().await;
+                example.get_mut().0 += 1;
+            }
+        })
+        .apply(e, &mut world);
+
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
             for i in 0..5 {
                 executor.tick(w);
                 assert_eq!(w.entity_mut(e).get::<ExampleComponent>().unwrap().0, i)
@@ -244,190 +256,72 @@ mod tests {
     #[test]
     fn waiting_on_internal_change() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
+
         let e = world.spawn(ExampleComponent(0)).id();
+
         let a = Arc::new(Mutex::new(0));
         let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
 
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i);
-                w.clear_trackers();
+        coroutine(|fib: Fib, mut example: Wr<ExampleComponent>| async move {
+            for _ in 0..5 {
+                fib.next_tick().await;
+                example.get_mut().0 += 1;
             }
-        });
-    }
+        })
+        .apply(e, &mut world);
 
-    #[test]
-    fn multiple_write_dont_override_too_soon() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
-                w.clear_trackers();
+        coroutine(|example: Rd<ExampleComponent>| async move {
+            for _ in 0..5 {
+                example.on_change().await;
+                *b.lock().unwrap() += 1;
             }
-        });
-    }
+        })
+        .apply(e, &mut world);
 
-    #[test]
-    fn waiting_on_internal_change_do_not_consume_twice_events() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e1 = world.spawn(ExampleComponent(0)).id();
-        let e2 = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
         world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e1).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e2).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e1).await;
-                    *a.lock().unwrap() += 1;
-                    fib.change::<ExampleComponent>(e2).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
-
             for i in 0..5 {
                 executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
+                assert_eq!(*a.lock().unwrap(), i);
                 w.clear_trackers();
             }
         });
     }
 
     #[test]
-    fn not_writing_to_mut_component_has_no_effect() {
+    fn waiting_on_internal_and_external_change_is_correct() {
         let mut world = World::new();
-        world.insert_resource(Executor::new());
+        world.init_resource::<Executor>();
+        world.init_resource::<CoroWrites>();
         world.insert_resource(Time::new(Instant::now()));
         let e = world.spawn(ExampleComponent(0)).id();
+
         let a = Arc::new(Mutex::new(0));
         let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    if false {
-                        example.0 += 1;
-                    }
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
 
-            for i in 0..5 {
-                executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i);
-                w.clear_trackers();
+        coroutine(|ex: Rd<ExampleComponent>| async move {
+            loop {
+                ex.on_change().await;
+                *b.lock().unwrap() += 1;
             }
-        });
-    }
+        })
+        .apply(e, &mut world);
 
-    #[test]
-    fn waiting_on_internal_and_external_change_is_correct() {
-        let mut world = World::new();
-        world.insert_resource(Executor::new());
-        world.insert_resource(Time::new(Instant::now()));
-        let e = world.spawn(ExampleComponent(0)).id();
-        let a = Arc::new(Mutex::new(0));
-        let b = Arc::clone(&a);
-        world.resource_scope(|w, mut executor: Mut<Executor>| {
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-                    example.0 += 1;
-                }
-            });
-            executor.add(move |mut fib| async move {
-                for _ in 0..5 {
-                    let (_, mut example) =
-                        fib.next_tick().then_grab::<&mut ExampleComponent>(e).await;
-
-                    if false {
-                        example.0 += 1;
-                    }
-                }
-            });
-            executor.add(|mut fib| async move {
-                loop {
-                    fib.change::<ExampleComponent>(e).await;
-                    *a.lock().unwrap() += 1;
-                }
-            });
+        coroutine(|fib: Fib, mut ex: Wr<ExampleComponent>| async move {
+            loop {
+                fib.next_tick().await;
+                ex.get_mut().0 += 1;
+            }
+        })
+        .apply(e, &mut world);
 
+        world.resource_scope(|w, mut executor: Mut<Executor>| {
             for i in 0..5 {
                 w.entity_mut(e).get_mut::<ExampleComponent>().unwrap().0 += 1;
                 executor.tick(w);
-                assert_eq!(*b.lock().unwrap(), i * 2);
+                assert_eq!(*a.lock().unwrap(), i * 2);
                 w.clear_trackers();
             }
         });
diff --git a/src/plugin.rs b/src/plugin.rs
new file mode 100644
index 0000000..030ce3f
--- /dev/null
+++ b/src/plugin.rs
@@ -0,0 +1,19 @@
+use bevy::prelude::{Mut, Plugin, Update, World};
+
+use crate::{coroutine::CoroWrites, prelude::Executor};
+
+pub struct CorentinPlugin;
+
+impl Plugin for CorentinPlugin {
+    fn build(&self, app: &mut bevy::prelude::App) {
+        app.init_resource::<Executor>()
+            .init_resource::<CoroWrites>()
+            .add_systems(Update, run_coroutines);
+    }
+}
+
+fn run_coroutines(world: &mut World) {
+    world.resource_scope(|w, mut exec: Mut<Executor>| {
+        exec.tick(w);
+    })
+}
diff --git a/src/world_window.rs b/src/world_window.rs
deleted file mode 100644
index 099fab5..0000000
--- a/src/world_window.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//use std::ops::{Deref, DerefMut};
-//
-//use bevy::prelude::Component;
-//
-//// TODO change detection (isn't this what Mut is already doing in Bevy ? Damn looks like I'm tired...)
-//pub struct ComponentGuard<'a, T: Component>(&'a T);
-//
-//impl<'a, T: Component> Deref for ComponentGuard<'a, T> {
-//    type Target = T;
-//
-//    fn deref(&self) -> &Self::Target {
-//        self.0
-//    }
-//}
-//
-//pub struct ComponentGuardMut<'a, T: Component>(&'a mut T);
-//
-//impl<'a, T: Component> Deref for ComponentGuardMut<'a, T> {
-//    type Target = T;
-//
-//    fn deref(&self) -> &Self::Target {
-//        self.0
-//    }
-//}
-//
-//impl<'a, T: Component> DerefMut for ComponentGuardMut<'a, T> {
-//    fn deref_mut(&mut self) -> &mut Self::Target {
-//        self.0
-//    }
-//}