diff --git a/bevy_examples/Cargo.toml b/bevy_examples/Cargo.toml
index 49d31a3..a2bdd6f 100644
--- a/bevy_examples/Cargo.toml
+++ b/bevy_examples/Cargo.toml
@@ -8,15 +8,15 @@ exclude = ["assets/"]
 [dependencies]
 # ----- Internal dependencies
 bevy_ghx_proc_gen = { path = "../bevy_ghx_proc_gen", default-features = true }
-bevy_ghx_utils = { version = "0.3.0", default-features = true }
+bevy_ghx_utils = { version = "0.4", default-features = true }
 
 # ----- External dependencies
 tracing-subscriber = "0.3.18"
 rand = "0.8.5"
-bevy = { version = "0.13.0", default-features = false, features = [
+bevy = { version = "0.14", default-features = false, features = [
 	# Default features:
 
-	"multi-threaded",     # Run with multithreading
+	"multi_threaded",     # Run with multithreading
 	"bevy_asset",         # Assets management
 	"bevy_scene",         # Scenes management
 	"bevy_render",        # Rendering framework core
@@ -43,7 +43,7 @@ bevy = { version = "0.13.0", default-features = false, features = [
 	# Development/Debug features:
 	"dynamic_linking", # Dynamic linking for faster compile-times
 ] }
-bevy_mod_picking = { version = "0.18.0", default-features = false, features = [
+bevy_mod_picking = { version = "0.20.0", default-features = false, features = [
 	"backend_raycast",
 	"backend_bevy_ui",
 	"backend_sprite",
diff --git a/bevy_examples/canyon/canyon.rs b/bevy_examples/canyon/canyon.rs
index dafefa5..3cd2868 100644
--- a/bevy_examples/canyon/canyon.rs
+++ b/bevy_examples/canyon/canyon.rs
@@ -1,6 +1,11 @@
 use std::f32::consts::PI;
 
-use bevy::{log::LogPlugin, pbr::DirectionalLightShadowMap, prelude::*};
+use bevy::{
+    color::palettes::css::{GRAY, ORANGE_RED},
+    log::LogPlugin,
+    pbr::DirectionalLightShadowMap,
+    prelude::*,
+};
 
 use bevy_examples::{
     anim::SpawningScaleAnimation, plugin::ProcGenExamplesPlugin, utils::load_assets,
@@ -8,7 +13,7 @@ use bevy_examples::{
 use bevy_ghx_proc_gen::{
     bevy_ghx_grid::{
         debug_plugin::{view::DebugGridView, DebugGridView3dBundle},
-        ghx_grid::{coordinate_system::Cartesian3D, grid::GridDefinition},
+        ghx_grid::{cartesian::{coordinates::Cartesian3D, grid::CartesianGrid}, grid::GridData},
     },
     gen::{
         assets::AssetSpawner,
@@ -20,7 +25,7 @@ use bevy_ghx_proc_gen::{
     },
     GeneratorBundle,
 };
-use bevy_ghx_utils::camera::{update_pan_orbit_camera, PanOrbitCamera};
+use bevy_ghx_utils::camera::{update_pan_orbit_camera, PanOrbitCameraBundle, PanOrbitState};
 
 use rand::Rng;
 use rules::{CustomComponents, RotationRandomizer, ScaleRandomizer, WindRotation};
@@ -56,28 +61,29 @@ fn setup_scene(mut commands: Commands) {
     let camera_position = Vec3::new(0., 1.5 * GRID_HEIGHT as f32, 1.5 * GRID_Z as f32 / 2.);
     let look_target = Vec3::new(0., -10., 0.);
     let radius = (look_target - camera_position).length();
-    commands.spawn((
-        Camera3dBundle {
+    commands.spawn((PanOrbitCameraBundle {
+        camera: Camera3dBundle {
             transform: Transform::from_translation(camera_position)
                 .looking_at(look_target, Vec3::Y),
             ..default()
         },
-        PanOrbitCamera {
+        state: PanOrbitState {
             radius,
-            ..Default::default()
+            ..default()
         },
-    ));
+        ..Default::default()
+    },));
 
     // Scene lights
     commands.insert_resource(AmbientLight {
-        color: Color::ORANGE_RED,
+        color: ORANGE_RED.into(),
         brightness: 0.05,
     });
     commands.spawn(DirectionalLightBundle {
         directional_light: DirectionalLight {
             shadows_enabled: true,
             illuminance: 4000.,
-            color: Color::rgb(1.0, 0.85, 0.65),
+            color: Color::srgb(1.0, 0.85, 0.65).into(),
             ..default()
         },
         transform: Transform {
@@ -91,7 +97,7 @@ fn setup_scene(mut commands: Commands) {
         directional_light: DirectionalLight {
             shadows_enabled: false,
             illuminance: 2000.,
-            color: Color::ORANGE_RED,
+            color: ORANGE_RED.into(),
             ..default()
         },
         transform: Transform {
@@ -118,9 +124,13 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
     let rules = RulesBuilder::new_cartesian_3d(models, socket_collection)
         .build()
         .unwrap();
-    let grid = GridDefinition::new_cartesian_3d(GRID_X, GRID_HEIGHT, GRID_Z, false, false, false);
+    let grid = CartesianGrid::new_cartesian_3d(GRID_X, GRID_HEIGHT, GRID_Z, false, false, false);
+
+    let grid_size = (grid.size_xy() * grid.size_z()) as usize;
 
-    let mut initial_constraints = grid.new_grid_data(None);
+
+    //let mut initial_constraints = grid.new_grid_data(None);
+    let mut initial_constraints: GridData<Cartesian3D, _, CartesianGrid<Cartesian3D>> = GridData::new(grid.clone(), vec![None; grid_size]);
     // Force void nodes on the upmost layer
     let void_ref = Some(void_instance);
     initial_constraints.set_all_y(GRID_HEIGHT - 1, void_ref);
@@ -137,9 +147,10 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
     initial_constraints.set_all_yz(0, GRID_Z - 1, sand_ref);
     // Let's force a small lake at the center
     let water_ref = Some(water_instance);
-    for x in 2 * GRID_X / 5..3 * GRID_X / 5 {
+    // TODO! Fix this code
+    /*for x in 2 * GRID_X / 5..3 * GRID_X / 5 {
         for z in 2 * GRID_Z / 5..3 * GRID_Z / 5 {
-            initial_constraints.set((x, 0, z), water_ref);
+            initial_constraints.set((x as usize, 0 as usize, z as usize), water_ref);
         }
     }
     // We could hope for a water bridge, or force one !
@@ -147,7 +158,7 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
         (GRID_X / 2, GRID_HEIGHT / 2, GRID_Z / 2),
         Some(bridge_instance),
     );
-
+    */
     let mut gen_builder = GeneratorBuilder::new()
         .with_rules(rules)
         .with_grid(grid.clone())
@@ -187,7 +198,7 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
         },
         observer,
         DebugGridView3dBundle {
-            view: DebugGridView::new(false, true, Color::GRAY, NODE_SIZE),
+            view: DebugGridView::new(false, true, GRAY.into(), NODE_SIZE),
             ..default()
         },
     ));
diff --git a/bevy_examples/canyon/rules.rs b/bevy_examples/canyon/rules.rs
index 5e5afa2..342e8e8 100644
--- a/bevy_examples/canyon/rules.rs
+++ b/bevy_examples/canyon/rules.rs
@@ -1,7 +1,7 @@
 use bevy::{ecs::component::Component, math::Vec3};
 use bevy_examples::utils::AssetDef;
 use bevy_ghx_proc_gen::{
-    bevy_ghx_grid::ghx_grid::{coordinate_system::Cartesian3D, direction::GridDelta},
+    bevy_ghx_grid::ghx_grid::cartesian::coordinates::{Cartesian3D, GridDelta},
     gen::assets::ComponentSpawner,
     proc_gen::generator::{
         model::{ModelCollection, ModelInstance, ModelRotation},
diff --git a/bevy_examples/chessboard/chessboard.rs b/bevy_examples/chessboard/chessboard.rs
index 9702d3c..d0c647b 100644
--- a/bevy_examples/chessboard/chessboard.rs
+++ b/bevy_examples/chessboard/chessboard.rs
@@ -1,10 +1,7 @@
 use bevy::prelude::*;
 
 use bevy_ghx_proc_gen::{
-    bevy_ghx_grid::ghx_grid::{
-        coordinate_system::Cartesian2D,
-        grid::{GridDefinition, GridPosition},
-    },
+    bevy_ghx_grid::ghx_grid::cartesian::{coordinates::Cartesian2D, grid::CartesianGrid},
     gen::{
         assets::{AssetSpawner, RulesModelsAssets},
         default_bundles::PbrMesh,
@@ -65,14 +62,15 @@ fn setup_generator(
         .unwrap();
 
     // Like a chess board, let's do an 8x8 2d grid
-    let grid = GridDefinition::new_cartesian_2d(8, 8, false, false);
+    let grid = CartesianGrid::new_cartesian_2d(8, 8, false, false);
+    let initial_nodes = vec![(grid.index_from_coords(0, 0, 0), black_model)];
 
     // There many more parameters you can tweak on a Generator before building it, explore the API.
     let generator = GeneratorBuilder::new()
         .with_rules(rules)
         .with_grid(grid.clone())
         // Let's ensure that we make a chessboard, with a black square bottom-left
-        .with_initial_nodes(vec![(GridPosition::new_xy(0, 0), black_model)])
+        .with_initial_nodes(initial_nodes)
         .unwrap()
         .build()
         .unwrap();
diff --git a/bevy_examples/pillars/pillars.rs b/bevy_examples/pillars/pillars.rs
index 187636d..0fddcf3 100644
--- a/bevy_examples/pillars/pillars.rs
+++ b/bevy_examples/pillars/pillars.rs
@@ -1,13 +1,18 @@
 use std::{f32::consts::PI, sync::Arc};
 
-use bevy::{log::LogPlugin, pbr::DirectionalLightShadowMap, prelude::*};
+use bevy::{
+    color::palettes::{basic::GRAY, css::ORANGE_RED},
+    log::LogPlugin,
+    pbr::DirectionalLightShadowMap,
+    prelude::*,
+};
 
 use bevy_examples::{plugin::ProcGenExamplesPlugin, utils::load_assets};
 
 use bevy_ghx_proc_gen::{
     bevy_ghx_grid::{
         debug_plugin::{view::DebugGridView, DebugGridView3dBundle},
-        ghx_grid::{coordinate_system::Cartesian3D, grid::GridDefinition},
+        ghx_grid::cartesian::{coordinates::Cartesian3D, grid::CartesianGrid},
     },
     gen::{
         assets::{AssetSpawner, RulesModelsAssets},
@@ -16,7 +21,7 @@ use bevy_ghx_proc_gen::{
     proc_gen::generator::{builder::GeneratorBuilder, rules::RulesBuilder},
     GeneratorBundle,
 };
-use bevy_ghx_utils::camera::{update_pan_orbit_camera, PanOrbitCamera};
+use bevy_ghx_utils::camera::{update_pan_orbit_camera, PanOrbitCameraBundle, PanOrbitState};
 
 use crate::rules::rules_and_assets;
 
@@ -48,16 +53,19 @@ fn setup_scene(
     let camera_position = Vec3::new(0., 3. * GRID_HEIGHT as f32, 0.75 * GRID_Z as f32);
     let radius = camera_position.length();
     commands.spawn((
-        Camera3dBundle {
-            transform: Transform::from_translation(camera_position).looking_at(Vec3::ZERO, Vec3::Y),
+        PanOrbitCameraBundle {
+            camera: Camera3dBundle {
+                transform: Transform::from_translation(camera_position).looking_at(Vec3::ZERO, Vec3::Y),
+                ..default()
+            },
+            state: PanOrbitState {
+                radius,
+                ..default()
+            },
             ..default()
         },
-        PanOrbitCamera {
-            radius,
-            ..Default::default()
-        },
         FogSettings {
-            color: Color::rgba(0.2, 0.15, 0.1, 1.0),
+            color: Color::srgba(0.2, 0.15, 0.1, 1.0).into(),
             falloff: FogFalloff::Linear {
                 start: 55.0,
                 end: 145.0,
@@ -69,7 +77,7 @@ fn setup_scene(
         PbrBundle {
             mesh: meshes.add(Mesh::from(Plane3d::default())),
             material: materials.add(StandardMaterial {
-                base_color: Color::hex("888888").unwrap(),
+                base_color: Color::srgb_u8(136, 136, 136).into(),
                 ..default()
             }),
             transform: Transform::from_scale(Vec3::splat(10000.0)).with_translation(Vec3::new(
@@ -84,14 +92,14 @@ fn setup_scene(
 
     // Scene lights
     commands.insert_resource(AmbientLight {
-        color: Color::ORANGE_RED,
+        color: ORANGE_RED.into(),
         brightness: 0.05,
     });
     commands.spawn(DirectionalLightBundle {
         directional_light: DirectionalLight {
             shadows_enabled: true,
             illuminance: 3000.,
-            color: Color::rgb(1.0, 0.85, 0.65),
+            color: Color::srgb(1.0, 0.85, 0.65).into(),
             ..default()
         },
         transform: Transform {
@@ -105,7 +113,7 @@ fn setup_scene(
         directional_light: DirectionalLight {
             shadows_enabled: false,
             illuminance: 1250.,
-            color: Color::rgb(1.0, 0.85, 0.65),
+            color: Color::srgb(1.0, 0.85, 0.65).into(),
             ..default()
         },
         transform: Transform {
@@ -126,7 +134,7 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
             .build()
             .unwrap(),
     );
-    let grid = GridDefinition::new_cartesian_3d(GRID_X, GRID_HEIGHT, GRID_Z, false, false, false);
+    let grid = CartesianGrid::new_cartesian_3d(GRID_X, GRID_HEIGHT, GRID_Z, false, false, false);
     let gen_builder = GeneratorBuilder::new()
         // We share the Rules between all the generators
         .with_shared_rules(rules.clone())
@@ -160,7 +168,7 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
             },
             observer,
             DebugGridView3dBundle {
-                view: DebugGridView::new(false, true, Color::GRAY, NODE_SIZE),
+                view: DebugGridView::new(false, true, GRAY.into(), NODE_SIZE),
                 ..default()
             },
             Name::new(format!("Grid_{}", i)),
diff --git a/bevy_examples/pillars/rules.rs b/bevy_examples/pillars/rules.rs
index 67781e8..93b04a3 100644
--- a/bevy_examples/pillars/rules.rs
+++ b/bevy_examples/pillars/rules.rs
@@ -1,6 +1,6 @@
 use bevy_examples::utils::AssetDef;
 use bevy_ghx_proc_gen::{
-    bevy_ghx_grid::ghx_grid::coordinate_system::Cartesian3D,
+    bevy_ghx_grid::ghx_grid::cartesian::coordinates::Cartesian3D,
     proc_gen::generator::{
         model::ModelCollection,
         socket::{SocketCollection, SocketsCartesian3D},
diff --git a/bevy_examples/src/fps.rs b/bevy_examples/src/fps.rs
index b9b9cb5..0c545a1 100644
--- a/bevy_examples/src/fps.rs
+++ b/bevy_examples/src/fps.rs
@@ -1,5 +1,9 @@
 use bevy::{
     app::{App, Plugin, Startup, Update},
+    color::{
+        palettes::basic::{BLACK, WHITE},
+        Color,
+    },
     diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
     ecs::{
         component::Component,
@@ -7,7 +11,8 @@ use bevy::{
         system::{Commands, Query, Res},
     },
     hierarchy::BuildChildren,
-    render::{color::Color, view::Visibility},
+    prelude::Alpha,
+    render::view::Visibility,
     text::{Text, TextSection, TextStyle},
     ui::{
         node_bundles::{NodeBundle, TextBundle},
@@ -45,7 +50,7 @@ pub fn setup_fps_counter(mut commands: Commands) {
             FpsRoot,
             NodeBundle {
                 // give it a dark background for readability
-                background_color: BackgroundColor(Color::BLACK.with_a(0.5)),
+                background_color: BackgroundColor(BLACK.with_alpha(0.5).into()),
                 // make it "always on top" by setting the Z index to maximum
                 // we want it to be displayed over all other UI
                 z_index: ZIndex::Global(i32::MAX),
@@ -79,7 +84,7 @@ pub fn setup_fps_counter(mut commands: Commands) {
                         value: "FPS: ".into(),
                         style: TextStyle {
                             font_size: DEFAULT_EXAMPLES_FONT_SIZE,
-                            color: Color::WHITE,
+                            color: WHITE.into(),
                             // if you want to use your game's font asset,
                             // uncomment this and provide the handle:
                             // font: my_font_handle
@@ -90,7 +95,7 @@ pub fn setup_fps_counter(mut commands: Commands) {
                         value: " N/A".into(),
                         style: TextStyle {
                             font_size: DEFAULT_EXAMPLES_FONT_SIZE,
-                            color: Color::WHITE,
+                            color: WHITE.into(),
                             // if you want to use your game's font asset,
                             // uncomment this and provide the handle:
                             // font: my_font_handle
@@ -124,22 +129,22 @@ pub fn fps_text_update_system(
             // text according to the FPS value:
             text.sections[1].style.color = if value >= 120.0 {
                 // Above 120 FPS, use green color
-                Color::rgb(0.0, 1.0, 0.0)
+                Color::srgb(0.0, 1.0, 0.0)
             } else if value >= 60.0 {
                 // Between 60-120 FPS, gradually transition from yellow to green
-                Color::rgb((1.0 - (value - 60.0) / (120.0 - 60.0)) as f32, 1.0, 0.0)
+                Color::srgb((1.0 - (value - 60.0) / (120.0 - 60.0)) as f32, 1.0, 0.0)
             } else if value >= 30.0 {
                 // Between 30-60 FPS, gradually transition from red to yellow
-                Color::rgb(1.0, ((value - 30.0) / (60.0 - 30.0)) as f32, 0.0)
+                Color::srgb(1.0, ((value - 30.0) / (60.0 - 30.0)) as f32, 0.0)
             } else {
                 // Below 30 FPS, use red color
-                Color::rgb(1.0, 0.0, 0.0)
+                Color::srgb(1.0, 0.0, 0.0)
             }
         } else {
             // display "N/A" if we can't get a FPS measurement
             // add an extra space to preserve alignment
             text.sections[1].value = " N/A".into();
-            text.sections[1].style.color = Color::WHITE;
+            text.sections[1].style.color = WHITE.into();
         }
     }
 }
diff --git a/bevy_examples/src/plugin.rs b/bevy_examples/src/plugin.rs
index 07b4dbf..ae6d9b9 100644
--- a/bevy_examples/src/plugin.rs
+++ b/bevy_examples/src/plugin.rs
@@ -2,6 +2,10 @@ use std::marker::PhantomData;
 
 use bevy::{
     app::{App, Plugin, PreUpdate, Startup, Update},
+    color::{
+        palettes::css::{GREEN, YELLOW_GREEN},
+        Color,
+    },
     diagnostic::FrameTimeDiagnosticsPlugin,
     ecs::{
         component::Component,
@@ -19,8 +23,7 @@ use bevy::{
         ButtonInput,
     },
     math::Vec3,
-    prelude::default,
-    render::color::Color,
+    prelude::{default, Alpha},
     text::{BreakLineOn, Text, TextSection, TextStyle},
     ui::{
         node_bundles::{NodeBundle, TextBundle},
@@ -34,7 +37,9 @@ use bevy_ghx_proc_gen::{
             markers::MarkersGroup, toggle_debug_grids_visibilities,
             toggle_grid_markers_visibilities, GridDebugPlugin,
         },
-        ghx_grid::coordinate_system::CoordinateSystem,
+        ghx_grid::{
+            cartesian::coordinates::CartesianCoordinates, coordinate_system::CoordinateSystem,
+        },
     },
     gen::{
         assets::{AssetsBundleSpawner, ComponentSpawner, NoComponents},
@@ -80,7 +85,7 @@ impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner>
 const DEFAULT_SPAWN_ANIMATION_DURATION: f32 = 0.6;
 const FAST_SPAWN_ANIMATION_DURATION: f32 = 0.1;
 
-impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
+impl<C: CoordinateSystem + CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
     for ProcGenExamplesPlugin<C, A, T>
 {
     fn build(&self, app: &mut App) {
@@ -126,7 +131,7 @@ impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
             PreUpdate,
             absorb_egui_inputs
                 .after(bevy_egui::systems::process_input_system)
-                .before(bevy_egui::EguiSet::BeginFrame),
+                .before(bevy_egui::EguiSet::BeginPass),
         );
     }
 }
@@ -197,7 +202,7 @@ pub fn setup_ui(mut commands: Commands, view_mode: Res<GenerationViewMode>) {
         .spawn((
             Pickable::IGNORE,
             NodeBundle {
-                background_color: Color::BLACK.with_a(0.6).into(),
+                background_color: Color::BLACK.with_alpha(0.6).into(),
                 style: Style {
                     position_type: PositionType::Absolute,
                     top: Val::Percent(1.),
@@ -298,9 +303,9 @@ pub fn update_generation_control_ui(
     for mut text in &mut query {
         let status_section = &mut text.sections[GENERATION_CONTROL_STATUS_TEXT_SECTION_ID];
         (status_section.value, status_section.style.color) = match gen_control.status {
-            GenerationControlStatus::Ongoing => ("Ongoing ('Space' to pause)".into(), Color::GREEN),
+            GenerationControlStatus::Ongoing => ("Ongoing ('Space' to pause)".into(), GREEN.into()),
             GenerationControlStatus::Paused => {
-                ("Paused ('Space' to unpause)".into(), Color::YELLOW_GREEN)
+                ("Paused ('Space' to unpause)".into(), YELLOW_GREEN.into())
             }
         };
 
diff --git a/bevy_examples/src/utils.rs b/bevy_examples/src/utils.rs
index 0a7d36f..88dc542 100644
--- a/bevy_examples/src/utils.rs
+++ b/bevy_examples/src/utils.rs
@@ -5,7 +5,7 @@ use bevy::{
 };
 
 use bevy_ghx_proc_gen::{
-    bevy_ghx_grid::ghx_grid::direction::GridDelta,
+    bevy_ghx_grid::ghx_grid::cartesian::coordinates::GridDelta,
     gen::assets::{
         AssetsBundleSpawner, ComponentSpawner, ModelAsset, NoComponents, RulesModelsAssets,
     },
diff --git a/bevy_examples/tile-layers/rules.rs b/bevy_examples/tile-layers/rules.rs
index 7c473c7..349906b 100644
--- a/bevy_examples/tile-layers/rules.rs
+++ b/bevy_examples/tile-layers/rules.rs
@@ -2,8 +2,8 @@ use bevy_examples::utils::AssetDef;
 
 use bevy_ghx_proc_gen::{
     bevy_ghx_grid::ghx_grid::{
-        coordinate_system::Cartesian3D,
-        direction::{Direction, GridDelta},
+        cartesian::coordinates::{Cartesian3D, GridDelta},
+        direction::Direction,
     },
     proc_gen::generator::{
         model::{ModelCollection, ModelRotation},
diff --git a/bevy_examples/tile-layers/tile-layers.rs b/bevy_examples/tile-layers/tile-layers.rs
index 5212fa0..b37bede 100644
--- a/bevy_examples/tile-layers/tile-layers.rs
+++ b/bevy_examples/tile-layers/tile-layers.rs
@@ -1,15 +1,13 @@
 use bevy::{
     app::{App, PluginGroup, Startup},
     asset::{AssetServer, Handle},
+    color::Color,
     core_pipeline::core_2d::Camera2dBundle,
     ecs::system::{Commands, Res},
     log::LogPlugin,
     math::Vec3,
     prelude::SpatialBundle,
-    render::{
-        color::Color,
-        texture::{Image, ImagePlugin},
-    },
+    render::texture::{Image, ImagePlugin},
     transform::components::Transform,
     utils::default,
     DefaultPlugins,
@@ -19,7 +17,10 @@ use bevy_examples::{plugin::ProcGenExamplesPlugin, utils::load_assets};
 use bevy_ghx_proc_gen::{
     bevy_ghx_grid::{
         debug_plugin::{view::DebugGridView, DebugGridView2dBundle},
-        ghx_grid::{coordinate_system::Cartesian3D, direction::Direction, grid::GridDefinition},
+        ghx_grid::{
+            cartesian::{coordinates::Cartesian3D, grid::CartesianGrid},
+            direction::Direction,
+        },
     },
     gen::{
         assets::{AssetSpawner, RulesModelsAssets},
@@ -74,7 +75,7 @@ fn setup_generator(mut commands: Commands, asset_server: Res<AssetServer>) {
         .with_rotation_axis(Direction::ZForward)
         .build()
         .unwrap();
-    let grid = GridDefinition::new_cartesian_3d(GRID_X, GRID_Y, GRID_Z, false, false, false);
+    let grid = CartesianGrid::new_cartesian_3d(GRID_X, GRID_Y, GRID_Z, false, false, false);
     let mut gen_builder = GeneratorBuilder::new()
         .with_rules(rules)
         .with_grid(grid.clone())
diff --git a/bevy_ghx_proc_gen/Cargo.toml b/bevy_ghx_proc_gen/Cargo.toml
index 24d3903..13ddb9a 100644
--- a/bevy_ghx_proc_gen/Cargo.toml
+++ b/bevy_ghx_proc_gen/Cargo.toml
@@ -47,15 +47,17 @@ ghx_proc_gen = { path = "../ghx_proc_gen", version = "0.2.0", features = [
 ] }
 
 # ----- External dependencies
-bevy = { version = "0.13.0", default-features = false, features = [
+bevy = { version = "0.14", default-features = false, features = [
     "bevy_render", # Rendering framework core
+    "bevy_winit",
+    "wayland", # Needed for some reason
 ] }
 
 # ----- Optional dependencies
-bevy_ghx_grid = { version = "0.2.1", optional = true, features = [] }
+bevy_ghx_grid = { version = "0.4", optional = true, features = [] }
 # Only enabled when the "picking" feature is enabled
-bevy_mod_picking = { version = "0.18.0", optional = true, default-features = false }
+bevy_mod_picking = { version = "0.20", optional = true, default-features = false }
 # Bevy_mod_picking depends on this version of bevy_egui
-bevy_egui = { version = "0.25.0", optional = true, default-features = false, features = [
+bevy_egui = { version = "0.30", optional = true, default-features = false, features = [
     "default_fonts",
 ] }
diff --git a/bevy_ghx_proc_gen/src/gen.rs b/bevy_ghx_proc_gen/src/gen.rs
index d5dae74..aea8dd6 100644
--- a/bevy_ghx_proc_gen/src/gen.rs
+++ b/bevy_ghx_proc_gen/src/gen.rs
@@ -9,8 +9,11 @@ use bevy::{
     hierarchy::BuildChildren,
     math::Vec3,
 };
-use bevy_ghx_grid::ghx_grid::{coordinate_system::CoordinateSystem, grid::GridDefinition};
-use ghx_proc_gen::{generator::model::ModelInstance, NodeIndex};
+use bevy_ghx_grid::ghx_grid::cartesian::{coordinates::GridDelta, grid::CartesianGrid};
+use ghx_proc_gen::{
+    generator::model::ModelInstance, ghx_grid::cartesian::coordinates::CartesianCoordinates,
+    NodeIndex,
+};
 
 use self::assets::{AssetSpawner, AssetsBundleSpawner, ComponentSpawner};
 
@@ -112,10 +115,10 @@ pub fn insert_bundle_from_resource_to_spawned_nodes<B: Bundle + Resource + Clone
 /// ```ignore
 /// spawn_node::<Cartesian3D, Handle<Image>>(...);
 /// ```
-pub fn spawn_node<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner>(
+pub fn spawn_node<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner>(
     commands: &mut Commands,
     gen_entity: Entity,
-    grid: &GridDefinition<C>,
+    grid: &CartesianGrid<C>,
     asset_spawner: &AssetSpawner<A, T>,
     instance: &ModelInstance,
     node_index: NodeIndex,
diff --git a/bevy_ghx_proc_gen/src/gen/assets.rs b/bevy_ghx_proc_gen/src/gen/assets.rs
index 9e281b9..5fb87ce 100644
--- a/bevy_ghx_proc_gen/src/gen/assets.rs
+++ b/bevy_ghx_proc_gen/src/gen/assets.rs
@@ -4,11 +4,11 @@ use std::{
     sync::Arc,
 };
 
+use crate::gen::GridDelta;
 use bevy::{
     ecs::{component::Component, system::EntityCommands},
     math::Vec3,
 };
-use bevy_ghx_grid::ghx_grid::direction::GridDelta;
 use ghx_proc_gen::generator::model::{ModelIndex, ModelRotation};
 
 /// Defines a struct which can spawn an assets [`bevy::prelude::Bundle`] (for example, a [`bevy::prelude::SpriteBundle`], a [`bevy::prelude::PbrBundle`], a [`bevy::prelude::SceneBundle`], ...).
diff --git a/bevy_ghx_proc_gen/src/gen/debug_plugin.rs b/bevy_ghx_proc_gen/src/gen/debug_plugin.rs
index 645d58d..d5f05d6 100644
--- a/bevy_ghx_proc_gen/src/gen/debug_plugin.rs
+++ b/bevy_ghx_proc_gen/src/gen/debug_plugin.rs
@@ -1,13 +1,14 @@
+use crate::gen::CartesianCoordinates;
 use std::{marker::PhantomData, time::Duration};
 
 use bevy::{
     app::{App, Plugin, PostStartup, PostUpdate, PreUpdate, Startup, Update},
+    color::Color,
     ecs::{schedule::IntoSystemConfigs, system::Resource},
     input::keyboard::KeyCode,
-    render::color::Color,
+    prelude::Alpha,
     time::{Timer, TimerMode},
 };
-use bevy_ghx_grid::ghx_grid::coordinate_system::CoordinateSystem;
 
 use self::{
     cursor::{
@@ -86,7 +87,7 @@ impl Default for GridCursorsUiSettings {
     fn default() -> Self {
         Self {
             font_size: 16.0,
-            background_color: Color::BLACK.with_a(0.45),
+            background_color: Color::BLACK.with_alpha(0.45),
             text_color: Color::WHITE,
         }
     }
@@ -98,7 +99,7 @@ impl Default for GridCursorsUiSettings {
 ///
 /// It also uses the following `Resources`: [`ProcGenKeyBindings`] and [`GenerationControl`] (and will init them to their defaults if not inserted by the user).
 pub struct ProcGenDebugPlugin<
-    C: CoordinateSystem,
+    C: CartesianCoordinates,
     A: AssetsBundleSpawner,
     T: ComponentSpawner = NoComponents,
 > {
@@ -107,7 +108,9 @@ pub struct ProcGenDebugPlugin<
     typestate: PhantomData<(C, A, T)>,
 }
 
-impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> ProcGenDebugPlugin<C, A, T> {
+impl<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner>
+    ProcGenDebugPlugin<C, A, T>
+{
     /// Plugin constructor
     pub fn new(generation_view_mode: GenerationViewMode, cursor_ui_mode: CursorUiMode) -> Self {
         Self {
@@ -118,7 +121,7 @@ impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> ProcGenDe
     }
 }
 
-impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
+impl<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
     for ProcGenDebugPlugin<C, A, T>
 {
     // TODO Clean: Split into multiple plugins
diff --git a/bevy_ghx_proc_gen/src/gen/debug_plugin/cursor.rs b/bevy_ghx_proc_gen/src/gen/debug_plugin/cursor.rs
index 434d6ee..52ef3f0 100644
--- a/bevy_ghx_proc_gen/src/gen/debug_plugin/cursor.rs
+++ b/bevy_ghx_proc_gen/src/gen/debug_plugin/cursor.rs
@@ -1,6 +1,8 @@
+use crate::gen::CartesianCoordinates;
 use std::{fmt, time::Duration};
 
 use bevy::{
+    color::Color,
     core::Name,
     ecs::{
         component::Component,
@@ -12,7 +14,8 @@ use bevy::{
     hierarchy::BuildChildren,
     input::{keyboard::KeyCode, ButtonInput},
     log::warn,
-    render::{camera::Camera, color::Color},
+    prelude::Srgba,
+    render::camera::Camera,
     text::{BreakLineOn, Text, TextSection, TextStyle},
     time::{Time, Timer, TimerMode},
     transform::components::GlobalTransform,
@@ -25,9 +28,9 @@ use bevy::{
 use bevy_ghx_grid::{
     debug_plugin::markers::{spawn_marker, GridMarker, MarkerDespawnEvent},
     ghx_grid::{
+        cartesian::{coordinates::CartesianPosition, grid::CartesianGrid},
         coordinate_system::CoordinateSystem,
         direction::Direction,
-        grid::{GridDefinition, GridPosition},
     },
 };
 use ghx_proc_gen::{
@@ -70,7 +73,7 @@ pub struct TargetedNode {
     /// Index of the node in its grid
     pub node_index: NodeIndex,
     /// Position of the node in its grid
-    pub position: GridPosition,
+    pub position: CartesianPosition,
     /// Marker entity for this targeted node
     pub marker: Entity,
 }
@@ -126,7 +129,7 @@ pub trait CursorMarkerSettings: Resource {
 pub struct SelectionCursorMarkerSettings(pub Color);
 impl Default for SelectionCursorMarkerSettings {
     fn default() -> Self {
-        Self(Color::GREEN)
+        Self(Srgba::rgb(0.0, 0.5019608, 0.0).into())
     }
 }
 impl CursorMarkerSettings for SelectionCursorMarkerSettings {
@@ -218,7 +221,7 @@ pub fn setup_cursors_overlays(mut commands: Commands) {
 }
 
 /// Setup system to spawn a cursor and its overlay
-pub fn setup_cursor<C: CoordinateSystem, CI: CursorBehavior>(
+pub fn setup_cursor<C: CoordinateSystem + CartesianCoordinates, CI: CursorBehavior>(
     mut commands: Commands,
     overlays_root: Query<Entity, With<CursorsOverlaysRoot>>,
 ) {
@@ -248,7 +251,7 @@ pub fn setup_cursor<C: CoordinateSystem, CI: CursorBehavior>(
 }
 
 /// System updating all the [CursorInfo] components when [Cursor] components are changed
-pub fn update_cursors_info_on_cursors_changes<C: CoordinateSystem>(
+pub fn update_cursors_info_on_cursors_changes<C: CoordinateSystem + CartesianCoordinates>(
     mut moved_cursors: Query<(&mut CursorInfo, &Cursor), Changed<Cursor>>,
     generators: Query<&Generator<C>>,
 ) {
@@ -268,7 +271,7 @@ pub fn update_cursors_info_on_cursors_changes<C: CoordinateSystem>(
 }
 
 /// System updating all the [CursorInfo] based on [GenerationEvent]
-pub fn update_cursors_info_from_generation_events<C: CoordinateSystem>(
+pub fn update_cursors_info_from_generation_events<C: CoordinateSystem + CartesianCoordinates>(
     mut cursors_events: EventReader<GenerationEvent>,
     generators: Query<&Generator<C>>,
     mut cursors: Query<(&Cursor, &mut CursorInfo)>,
@@ -375,7 +378,7 @@ impl EntityProvider {
 }
 
 /// System that listens to the generation switch [KeyCode] to switch the current active generation grid
-pub fn switch_generation_selection_from_keybinds<C: CoordinateSystem>(
+pub fn switch_generation_selection_from_keybinds<C: CoordinateSystem + CartesianCoordinates>(
     mut local_grid_cycler: Local<EntityProvider>,
     mut commands: Commands,
     mut active_generation: ResMut<ActiveGeneration>,
@@ -384,7 +387,7 @@ pub fn switch_generation_selection_from_keybinds<C: CoordinateSystem>(
     proc_gen_key_bindings: Res<ProcGenKeyBindings>,
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     mut selection_cursor: Query<&mut Cursor, With<SelectCursor>>,
-    generators: Query<Entity, (With<Generator<C>>, With<GridDefinition<C>>)>,
+    generators: Query<Entity, (With<Generator<C>>, With<CartesianGrid<C>>)>,
 ) {
     if keys.just_pressed(proc_gen_key_bindings.switch_grid) {
         let Ok(mut cursor) = selection_cursor.get_single_mut() else {
@@ -402,7 +405,7 @@ pub fn switch_generation_selection_from_keybinds<C: CoordinateSystem>(
         cursor.0 = Some(spawn_marker_and_create_cursor(
             &mut commands,
             grid_entity,
-            GridPosition::new(0, 0, 0),
+            CartesianPosition::new(0, 0, 0),
             0,
             selection_marker_settings.color(),
         ));
@@ -462,7 +465,7 @@ impl Default for CursorKeyboardMovement {
 }
 
 /// System handling movements of the selection cursor from the keyboard
-pub fn move_selection_from_keybinds<C: CoordinateSystem>(
+pub fn move_selection_from_keybinds<C: CoordinateSystem + CartesianCoordinates>(
     mut commands: Commands,
     keys: Res<ButtonInput<KeyCode>>,
     time: Res<Time>,
@@ -472,7 +475,7 @@ pub fn move_selection_from_keybinds<C: CoordinateSystem>(
     key_mvmt_values: Res<CursorKeyboardMovementSettings>,
     mut key_mvmt: ResMut<CursorKeyboardMovement>,
     mut selection_cursor: Query<&mut Cursor, With<SelectCursor>>,
-    grids: Query<(Entity, &GridDefinition<C>)>,
+    grids: Query<(Entity, &CartesianGrid<C>)>,
 ) {
     let Ok(mut cursor) = selection_cursor.get_single_mut() else {
         return;
@@ -566,7 +569,7 @@ pub fn move_selection_from_keybinds<C: CoordinateSystem>(
                     let Some((grid_entity, _grid)) = grids.iter().last() else {
                         return;
                     };
-                    Some((grid_entity, 0, GridPosition::new(0, 0, 0)))
+                    Some((grid_entity, 0, CartesianPosition::new(0, 0, 0)))
                 }
             };
 
@@ -590,7 +593,7 @@ pub fn move_selection_from_keybinds<C: CoordinateSystem>(
 pub fn spawn_marker_and_create_cursor(
     commands: &mut Commands,
     grid_entity: Entity,
-    position: GridPosition,
+    position: CartesianPosition,
     node_index: NodeIndex,
     color: Color,
 ) -> TargetedNode {
diff --git a/bevy_ghx_proc_gen/src/gen/debug_plugin/egui_editor.rs b/bevy_ghx_proc_gen/src/gen/debug_plugin/egui_editor.rs
index b2cad7c..0801471 100644
--- a/bevy_ghx_proc_gen/src/gen/debug_plugin/egui_editor.rs
+++ b/bevy_ghx_proc_gen/src/gen/debug_plugin/egui_editor.rs
@@ -1,3 +1,5 @@
+use crate::gen::CartesianCoordinates;
+
 use bevy::{
     ecs::{
         event::{Event, EventReader, EventWriter},
@@ -79,7 +81,7 @@ pub fn toggle_editor(mut editor_config: ResMut<EditorConfig>) {
 }
 
 /// System used to draw the editor egui window
-pub fn draw_edition_panel<C: CoordinateSystem>(
+pub fn draw_edition_panel<C: CoordinateSystem + CartesianCoordinates>(
     editor_context: ResMut<EditorContext>,
     mut contexts: EguiContexts,
     active_generation: Res<ActiveGeneration>,
@@ -251,7 +253,7 @@ pub fn update_painting_state(
 }
 
 /// System issuing the generation requests to the geenrator based on the painting state
-pub fn paint<C: CoordinateSystem>(
+pub fn paint<C: CoordinateSystem + CartesianCoordinates>(
     editor_context: ResMut<EditorContext>,
     active_generation: Res<ActiveGeneration>,
     mut node_over_events: EventReader<NodeOverEvent>,
diff --git a/bevy_ghx_proc_gen/src/gen/debug_plugin/generation.rs b/bevy_ghx_proc_gen/src/gen/debug_plugin/generation.rs
index bb34903..e1c3cb6 100644
--- a/bevy_ghx_proc_gen/src/gen/debug_plugin/generation.rs
+++ b/bevy_ghx_proc_gen/src/gen/debug_plugin/generation.rs
@@ -1,6 +1,8 @@
+use crate::gen::CartesianCoordinates;
 use std::collections::HashSet;
 
 use bevy::{
+    color::palettes::basic::RED,
     ecs::{
         component::Component,
         entity::Entity,
@@ -12,12 +14,11 @@ use bevy::{
     input::{keyboard::KeyCode, ButtonInput},
     log::{info, warn},
     prelude::{Deref, DerefMut},
-    render::color::Color,
     time::Time,
 };
 use bevy_ghx_grid::{
     debug_plugin::markers::{spawn_marker, MarkerDespawnEvent},
-    ghx_grid::{coordinate_system::CoordinateSystem, grid::GridDefinition},
+    ghx_grid::{cartesian::grid::CartesianGrid, coordinate_system::CoordinateSystem},
 };
 use ghx_proc_gen::{
     generator::{
@@ -60,7 +61,7 @@ pub struct ActiveGeneration(pub Option<Entity>);
 
 /// Simple system that calculates and add a [`VoidNodes`] component for generator entites which don't have one yet.
 pub fn insert_void_nodes_to_new_generations<
-    C: CoordinateSystem,
+    C: CoordinateSystem + CartesianCoordinates,
     A: AssetsBundleSpawner,
     T: ComponentSpawner,
 >(
@@ -82,7 +83,7 @@ pub fn insert_void_nodes_to_new_generations<
 }
 
 /// System used to insert an empty [ErrorMarkers] component into new generation entities
-pub fn insert_error_markers_to_new_generations<C: CoordinateSystem>(
+pub fn insert_error_markers_to_new_generations<C: CoordinateSystem + CartesianCoordinates>(
     mut commands: Commands,
     mut new_generations: Query<Entity, (With<Generator<C>>, Without<ErrorMarkers>)>,
 ) {
@@ -92,7 +93,7 @@ pub fn insert_error_markers_to_new_generations<C: CoordinateSystem>(
 }
 
 /// System that will update the currenty active generation if it was [None]
-pub fn update_active_generation<C: CoordinateSystem>(
+pub fn update_active_generation<C: CoordinateSystem + CartesianCoordinates>(
     mut active_generation: ResMut<ActiveGeneration>,
     generations: Query<Entity, With<Generator<C>>>,
 ) {
@@ -123,7 +124,7 @@ pub fn update_generation_control(
 
 /// - reinitializes the generator if needed
 /// - returns `true` if the generation operation should continue, and `false` if it should stop
-pub fn handle_reinitialization_and_continue<C: CoordinateSystem>(
+pub fn handle_reinitialization_and_continue<C: CoordinateSystem + CartesianCoordinates>(
     generation_control: &mut ResMut<GenerationControl>,
     generator: &mut Generator<C>,
 ) -> bool {
@@ -154,7 +155,7 @@ pub fn handle_reinitialization_and_continue<C: CoordinateSystem>(
 
 /// Function used to display some info about a generation that finished,
 /// as well as to properly handle reinitialization status and pause.
-pub fn handle_generation_done<C: CoordinateSystem>(
+pub fn handle_generation_done<C: CoordinateSystem + CartesianCoordinates>(
     generation_control: &mut ResMut<GenerationControl>,
     generator: &mut Generator<C>,
     gen_entity: Entity,
@@ -175,7 +176,7 @@ pub fn handle_generation_done<C: CoordinateSystem>(
 
 /// Function used to display some info about a generation that failed,
 /// as well as to properly handle reinitialization status and pause.
-pub fn handle_generation_error<C: CoordinateSystem>(
+pub fn handle_generation_error<C: CoordinateSystem + CartesianCoordinates>(
     generation_control: &mut ResMut<GenerationControl>,
     generator: &mut Generator<C>,
     gen_entity: Entity,
@@ -195,7 +196,7 @@ pub fn handle_generation_error<C: CoordinateSystem>(
 }
 
 /// This system request the full generation to a [`Generator`] component, if it is observed through a [`QueuedObserver`] component, if the current control status is [`GenerationControlStatus::Ongoing`] and if it is currently the [`ActiveGeneration`]
-pub fn generate_all<C: CoordinateSystem>(
+pub fn generate_all<C: CoordinateSystem + CartesianCoordinates>(
     mut generation_control: ResMut<GenerationControl>,
     active_generation: Res<ActiveGeneration>,
     mut observed_generatiors: Query<&mut Generator<C>, With<QueuedObserver>>,
@@ -236,7 +237,7 @@ pub fn generate_all<C: CoordinateSystem>(
 /// This system steps a [`Generator`] component if it is  observed through a [`QueuedObserver`] component, if the current control status is [`GenerationControlStatus::Ongoing`], if it is currently the [`ActiveGeneration`] and if the appropriate keys are pressed.
 ///
 /// The keybinds are read from the [`ProcGenKeyBindings`] `Resource`
-pub fn step_by_step_input_update<C: CoordinateSystem>(
+pub fn step_by_step_input_update<C: CoordinateSystem + CartesianCoordinates>(
     keys: Res<ButtonInput<KeyCode>>,
     proc_gen_key_bindings: Res<ProcGenKeyBindings>,
     mut generation_control: ResMut<GenerationControl>,
@@ -263,7 +264,7 @@ pub fn step_by_step_input_update<C: CoordinateSystem>(
 }
 
 /// This system steps a [`Generator`] component if it is observed through a [`QueuedObserver`] component, if the current control status is [`GenerationControlStatus::Ongoing`] if it is currently the [`ActiveGeneration`] and if the timer in the [`StepByStepTimed`] `Resource` has finished.
-pub fn step_by_step_timed_update<C: CoordinateSystem>(
+pub fn step_by_step_timed_update<C: CoordinateSystem + CartesianCoordinates>(
     mut generation_control: ResMut<GenerationControl>,
     mut steps_and_timer: ResMut<StepByStepTimed>,
     time: Res<Time>,
@@ -295,13 +296,17 @@ pub fn step_by_step_timed_update<C: CoordinateSystem>(
 }
 
 /// System used to spawn nodes, emit [GenerationEvent] and despawn markers, based on data read from a [QueuedObserver] on a generation entity
-pub fn update_generation_view<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner>(
+pub fn update_generation_view<
+    C: CoordinateSystem + CartesianCoordinates,
+    A: AssetsBundleSpawner,
+    T: ComponentSpawner,
+>(
     mut commands: Commands,
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     mut generation_events: EventWriter<GenerationEvent>,
     mut generators: Query<(
         Entity,
-        &GridDefinition<C>,
+        &CartesianGrid<C>,
         &AssetSpawner<A, T>,
         &mut QueuedObserver,
         Option<&Children>,
@@ -328,7 +333,7 @@ pub fn update_generation_view<C: CoordinateSystem, A: AssetsBundleSpawner, T: Co
                         error_markers.push(spawn_marker(
                             &mut commands,
                             grid_entity,
-                            Color::RED,
+                            bevy::prelude::Color::Srgba(RED),
                             grid.pos_from_index(node_index),
                         ));
                     }
@@ -369,7 +374,7 @@ pub fn update_generation_view<C: CoordinateSystem, A: AssetsBundleSpawner, T: Co
     }
 }
 
-fn step_generation<C: CoordinateSystem>(
+fn step_generation<C: CoordinateSystem + CartesianCoordinates>(
     generator: &mut Generator<C>,
     gen_entity: Entity,
     void_nodes: &VoidNodes,
diff --git a/bevy_ghx_proc_gen/src/gen/debug_plugin/picking.rs b/bevy_ghx_proc_gen/src/gen/debug_plugin/picking.rs
index 7d2bfbe..77ac0c1 100644
--- a/bevy_ghx_proc_gen/src/gen/debug_plugin/picking.rs
+++ b/bevy_ghx_proc_gen/src/gen/debug_plugin/picking.rs
@@ -1,5 +1,8 @@
+use crate::gen::CartesianCoordinates;
+
 use bevy::{
     asset::{Assets, Handle},
+    color::Color,
     ecs::{
         component::Component,
         entity::Entity,
@@ -10,9 +13,9 @@ use bevy::{
     hierarchy::{BuildChildren, DespawnRecursiveExt, Parent},
     input::{keyboard::KeyCode, ButtonInput},
     math::{primitives::Cuboid, Vec2, Vec3},
-    pbr::{AlphaMode, NotShadowCaster, PbrBundle, StandardMaterial},
-    prelude::{Deref, DerefMut},
-    render::{color::Color, mesh::Mesh},
+    pbr::{NotShadowCaster, PbrBundle, StandardMaterial},
+    prelude::{Alpha, AlphaMode, Deref, DerefMut},
+    render::mesh::Mesh,
     sprite::{Sprite, SpriteBundle},
     text::Text,
     transform::components::Transform,
@@ -25,7 +28,9 @@ use bevy_ghx_grid::{
         markers::{GridMarker, MarkerDespawnEvent},
         view::{DebugGridView, DebugGridView2d, DebugGridView3d},
     },
-    ghx_grid::{coordinate_system::CoordinateSystem, direction::Direction, grid::GridDefinition},
+    ghx_grid::{
+        cartesian::grid::CartesianGrid, coordinate_system::CoordinateSystem, direction::Direction,
+    },
 };
 use bevy_mod_picking::{
     events::Out,
@@ -50,7 +55,7 @@ use super::{
 pub struct OverCursorMarkerSettings(pub Color);
 impl Default for OverCursorMarkerSettings {
     fn default() -> Self {
-        Self(Color::rgb(0.85, 0.85, 0.73))
+        Self(Color::srgb(0.85, 0.85, 0.73))
     }
 }
 impl CursorMarkerSettings for OverCursorMarkerSettings {
@@ -94,7 +99,7 @@ impl From<ListenerInput<Pointer<Out>>> for NodeOutEvent {
 pub struct NodeSelectedEvent(pub Entity);
 
 /// System that inserts picking event handlers to entites with an added [GridNode] component
-pub fn insert_cursor_picking_handlers_to_grid_nodes<C: CoordinateSystem>(
+pub fn insert_cursor_picking_handlers_to_grid_nodes<C: CoordinateSystem + CartesianCoordinates>(
     mut commands: Commands,
     spawned_nodes: Query<Entity, Added<GridNode>>,
 ) {
@@ -140,7 +145,7 @@ pub fn update_over_cursor_panel_text(
 /// System updating the Over [Cursor] by reading all the [GenerationEvent]
 ///
 /// Should run after update_cursors_info_on_cursors_changes and before update_cursors_info_from_generation_events
-pub fn update_over_cursor_from_generation_events<C: CoordinateSystem>(
+pub fn update_over_cursor_from_generation_events<C: CoordinateSystem + CartesianCoordinates>(
     mut cursors_events: EventReader<GenerationEvent>,
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     mut over_cursor: Query<&mut Cursor, With<OverCursor>>,
@@ -164,7 +169,7 @@ pub fn update_over_cursor_from_generation_events<C: CoordinateSystem>(
 
 /// System used to update cursor positions from picking events
 pub fn picking_update_cursors_position<
-    C: CoordinateSystem,
+    C: CoordinateSystem + CartesianCoordinates,
     CS: CursorMarkerSettings,
     CB: CursorBehavior,
     PE: Event + std::ops::DerefMut<Target = Entity>,
@@ -176,7 +181,7 @@ pub fn picking_update_cursors_position<
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     grid_nodes: Query<(&GridNode, &Parent)>,
     mut cursor: Query<&mut Cursor, With<CB>>,
-    generations: Query<(Entity, &GridDefinition<C>), With<Generator<C>>>,
+    generations: Query<(Entity, &CartesianGrid<C>), With<Generator<C>>>,
 ) {
     if let Some(event) = events.read().last() {
         let Ok(mut cursor) = cursor.get_single_mut() else {
@@ -225,7 +230,7 @@ pub fn picking_update_cursors_position<
 }
 
 /// System used to remove an Over cursor on a [NodeOutEvent]
-pub fn picking_remove_previous_over_cursor<C: CoordinateSystem>(
+pub fn picking_remove_previous_over_cursor<C: CoordinateSystem + CartesianCoordinates>(
     mut out_events: EventReader<NodeOutEvent>,
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     mut nodes: Query<&GridNode>,
@@ -262,7 +267,7 @@ pub fn setup_picking_assets(
     mut standard_materials: ResMut<Assets<StandardMaterial>>,
     mut cursor_target_assets: ResMut<CursorTargetAssets>,
 ) {
-    cursor_target_assets.color = Color::WHITE.with_a(0.15);
+    cursor_target_assets.color = Color::WHITE.with_alpha(0.15);
     cursor_target_assets.base_size = 0.9;
     cursor_target_assets.target_mesh_3d = meshes.add(Mesh::from(Cuboid {
         half_size: Vec3::splat(cursor_target_assets.base_size / 2.),
@@ -289,7 +294,7 @@ pub struct ActiveCursorTargets {
 }
 
 /// System that spawn & depsanw the cursor targets
-pub fn update_cursor_targets_nodes<C: CoordinateSystem>(
+pub fn update_cursor_targets_nodes<C: CoordinateSystem + CartesianCoordinates>(
     mut local_active_cursor_targets: Local<Option<ActiveCursorTargets>>,
     mut commands: Commands,
     keys: Res<ButtonInput<KeyCode>>,
@@ -298,9 +303,9 @@ pub fn update_cursor_targets_nodes<C: CoordinateSystem>(
     mut marker_events: EventWriter<MarkerDespawnEvent>,
     selection_cursor: Query<&Cursor, With<SelectCursor>>,
     mut over_cursor: Query<&mut Cursor, (With<OverCursor>, Without<SelectCursor>)>,
-    grids_with_cam3d: Query<(&GridDefinition<C>, &DebugGridView), With<DebugGridView3d>>,
+    grids_with_cam3d: Query<(&CartesianGrid<C>, &DebugGridView), With<DebugGridView3d>>,
     grids_with_cam2d: Query<
-        (&GridDefinition<C>, &DebugGridView),
+        (&CartesianGrid<C>, &DebugGridView),
         (With<DebugGridView2d>, Without<DebugGridView3d>),
     >,
     cursor_targets: Query<Entity, With<CursorTarget>>,
@@ -389,14 +394,14 @@ pub fn despawn_cursor_targets(
 }
 
 /// Function used to spawn cursor targets
-pub fn spawn_cursor_targets<C: CoordinateSystem>(
+pub fn spawn_cursor_targets<C: CoordinateSystem + CartesianCoordinates>(
     commands: &mut Commands,
     cursor_target_assets: &Res<CursorTargetAssets>,
     selected_node: &TargetedNode,
     axis: Direction,
-    grids_with_cam3d: &Query<(&GridDefinition<C>, &DebugGridView), With<DebugGridView3d>>,
+    grids_with_cam3d: &Query<(&CartesianGrid<C>, &DebugGridView), With<DebugGridView3d>>,
     grids_with_cam2d: &Query<
-        (&GridDefinition<C>, &DebugGridView),
+        (&CartesianGrid<C>, &DebugGridView),
         (With<DebugGridView2d>, Without<DebugGridView3d>),
     >,
 ) {
@@ -422,12 +427,12 @@ pub fn spawn_cursor_targets<C: CoordinateSystem>(
 }
 
 /// Function used to spawn cursor targets when using a 3d camera
-pub fn spawn_cursor_targets_3d<C: CoordinateSystem>(
+pub fn spawn_cursor_targets_3d<C: CoordinateSystem + CartesianCoordinates>(
     commands: &mut Commands,
     cursor_target_assets: &Res<CursorTargetAssets>,
     axis: Direction,
     selected_node: &TargetedNode,
-    grid: &GridDefinition<C>,
+    grid: &CartesianGrid<C>,
     node_size: &Vec3,
 ) {
     let mut spawn_cursor_target = |x: u32, y: u32, z: u32| {
@@ -486,12 +491,12 @@ pub fn spawn_cursor_targets_3d<C: CoordinateSystem>(
 }
 
 /// Function used to spawn cursor targets when using a 2d camera
-pub fn spawn_cursor_targets_2d<C: CoordinateSystem>(
+pub fn spawn_cursor_targets_2d<C: CoordinateSystem + CartesianCoordinates>(
     commands: &mut Commands,
     cursor_target_assets: &Res<CursorTargetAssets>,
     axis: Direction,
     selected_node: &TargetedNode,
-    grid: &GridDefinition<C>,
+    grid: &CartesianGrid<C>,
     node_size: &Vec3,
 ) {
     let mut spawn_cursor_target = |x: u32, y: u32, z: u32| {
diff --git a/bevy_ghx_proc_gen/src/gen/simple_plugin.rs b/bevy_ghx_proc_gen/src/gen/simple_plugin.rs
index 7ee6dcc..702a941 100644
--- a/bevy_ghx_proc_gen/src/gen/simple_plugin.rs
+++ b/bevy_ghx_proc_gen/src/gen/simple_plugin.rs
@@ -1,3 +1,4 @@
+use crate::gen::CartesianCoordinates;
 use std::marker::PhantomData;
 
 use bevy::{
@@ -11,7 +12,6 @@ use bevy::{
     log::{info, warn},
     utils::HashSet,
 };
-use bevy_ghx_grid::ghx_grid::coordinate_system::CoordinateSystem;
 use ghx_proc_gen::{generator::Generator, GeneratorError};
 
 use crate::gen::spawn_node;
@@ -22,14 +22,14 @@ use super::{assets::NoComponents, AssetSpawner, AssetsBundleSpawner, ComponentSp
 ///
 /// Once the generation is successful, the plugin will spawn the generated nodes assets.
 pub struct ProcGenSimplePlugin<
-    C: CoordinateSystem,
+    C: CartesianCoordinates,
     A: AssetsBundleSpawner,
     T: ComponentSpawner = NoComponents,
 > {
     typestate: PhantomData<(C, A, T)>,
 }
 
-impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
+impl<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
     for ProcGenSimplePlugin<C, A, T>
 {
     fn build(&self, app: &mut App) {
@@ -41,7 +41,7 @@ impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> Plugin
     }
 }
 
-impl<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner>
+impl<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner>
     ProcGenSimplePlugin<C, A, T>
 {
     /// Constructor
@@ -67,7 +67,7 @@ impl Default for PendingGenerations {
 }
 
 /// System used by [`ProcGenSimplePlugin`] to track entities with newly added [`Generator`] components
-pub fn register_new_generations<C: CoordinateSystem>(
+pub fn register_new_generations<C: CartesianCoordinates>(
     mut pending_generations: ResMut<PendingGenerations>,
     mut new_generations: Query<Entity, Added<Generator<C>>>,
 ) {
@@ -77,7 +77,7 @@ pub fn register_new_generations<C: CoordinateSystem>(
 }
 
 /// System used by [`ProcGenSimplePlugin`] to run generators and spawn their node's assets
-pub fn generate_and_spawn<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner>(
+pub fn generate_and_spawn<C: CartesianCoordinates, A: AssetsBundleSpawner, T: ComponentSpawner>(
     mut commands: Commands,
     mut pending_generations: ResMut<PendingGenerations>,
     mut generations: Query<(&mut Generator<C>, &AssetSpawner<A, T>)>,
@@ -94,7 +94,7 @@ pub fn generate_and_spawn<C: CoordinateSystem, A: AssetsBundleSpawner, T: Compon
                         generation.seed(),
                         generation.grid()
                     );
-                    for (node_index, node) in grid_data.nodes().iter().enumerate() {
+                    for (node_index, node) in grid_data.iter().enumerate() {
                         spawn_node(
                             &mut commands,
                             gen_entity,
diff --git a/bevy_ghx_proc_gen/src/lib.rs b/bevy_ghx_proc_gen/src/lib.rs
index 4ee72ac..efabcf3 100644
--- a/bevy_ghx_proc_gen/src/lib.rs
+++ b/bevy_ghx_proc_gen/src/lib.rs
@@ -16,7 +16,9 @@ pub use bevy_mod_picking;
 pub use bevy_egui;
 
 use bevy::{ecs::bundle::Bundle, prelude::SpatialBundle};
-use bevy_ghx_grid::ghx_grid::{coordinate_system::CoordinateSystem, grid::GridDefinition};
+use bevy_ghx_grid::ghx_grid::{
+    cartesian::grid::CartesianGrid, coordinate_system::CoordinateSystem,
+};
 use gen::assets::{AssetSpawner, AssetsBundleSpawner, ComponentSpawner};
 use proc_gen::generator::Generator;
 
@@ -27,8 +29,8 @@ use proc_gen::generator::Generator;
 pub struct GeneratorBundle<C: CoordinateSystem, A: AssetsBundleSpawner, T: ComponentSpawner> {
     /// For positional rendering of the grid
     pub spatial: SpatialBundle,
-    /// Grid definition (Should be the same [`bevy_ghx_grid::ghx_grid::grid::GridDefinition`] as in the generator)
-    pub grid: GridDefinition<C>,
+    /// Grid definition (Should be the same [`bevy_ghx_grid::ghx_grid::grid::CartesianGrid`] as in the generator)
+    pub grid: CartesianGrid<C>,
     /// Generator
     pub generator: Generator<C>,
     /// Assets information used when spawning nodes
diff --git a/examples/chessboard.rs b/examples/chessboard.rs
index 4e52de6..996acaa 100644
--- a/examples/chessboard.rs
+++ b/examples/chessboard.rs
@@ -6,10 +6,7 @@ use ghx_proc_gen::{
         rules::RulesBuilder,
         socket::{SocketCollection, SocketsCartesian2D},
     },
-    ghx_grid::{
-        coordinate_system::Cartesian2D,
-        grid::{GridDefinition, GridPosition},
-    },
+    ghx_grid::cartesian::{coordinates::Cartesian2D, grid::CartesianGrid},
 };
 
 use ghx_proc_gen::generator::builder::GeneratorBuilder;
@@ -36,14 +33,16 @@ fn main() -> Result<(), Box<dyn Error>> {
         .unwrap();
 
     // Like a chess board, let's do an 8x8 2d grid
-    let grid = GridDefinition::new_cartesian_2d(8, 8, false, false);
+    let grid = CartesianGrid::new_cartesian_2d(8, 8, false, false);
+    let initial_nodes = vec![(grid.index_from_coords(0, 0, 0), black_model)];
 
     // There many more parameters you can tweak on a Generator before building it, explore the API.
     let mut generator = GeneratorBuilder::new()
         .with_rules(rules)
         .with_grid(grid)
         // Let's ensure that we make a chessboard, with a black square bottom-left
-        .with_initial_nodes(vec![(GridPosition::new_xy(0, 0), black_model)])?
+        //.with_initial_nodes(vec![(CartesianPosition::new_xy(0, 0), black_model)])?
+        .with_initial_nodes(initial_nodes)?
         .build()?;
 
     // Here we directly generate the whole grid, and ask for the result to be returned.
diff --git a/examples/unicode-terrain.rs b/examples/unicode-terrain.rs
index e5f5b79..7a2afdc 100644
--- a/examples/unicode-terrain.rs
+++ b/examples/unicode-terrain.rs
@@ -13,8 +13,8 @@ use ghx_proc_gen::{
         GenerationStatus, ModelSelectionHeuristic,
     },
     ghx_grid::{
-        coordinate_system::Cartesian2D,
-        grid::{GridData, GridDefinition},
+        cartesian::{coordinates::Cartesian2D, grid::CartesianGrid},
+        grid::GridData,
     },
 };
 
@@ -85,7 +85,7 @@ fn main() {
     let rules = RulesBuilder::new_cartesian_2d(models, sockets)
         .build()
         .unwrap();
-    let grid = GridDefinition::new_cartesian_2d(35, 12, false, false);
+    let grid = CartesianGrid::new_cartesian_2d(35, 12, false, false);
     let mut generator = GeneratorBuilder::new()
         .with_rules(rules)
         .with_grid(grid)
@@ -132,7 +132,7 @@ fn main() {
 }
 
 fn display_grid(
-    data_grid: &GridData<Cartesian2D, Option<ModelInstance>>,
+    data_grid: &GridData<Cartesian2D, Option<ModelInstance>, CartesianGrid<Cartesian2D>>,
     icons: &Vec<&'static str>,
 ) {
     for y in (0..data_grid.grid().size_y()).rev() {
diff --git a/ghx_proc_gen/Cargo.toml b/ghx_proc_gen/Cargo.toml
index f0c728c..cc48e11 100644
--- a/ghx_proc_gen/Cargo.toml
+++ b/ghx_proc_gen/Cargo.toml
@@ -23,7 +23,7 @@ reflect = ["bevy", "ghx_grid/reflect"]
 
 [dependencies]
 # Internal dependencies
-ghx_grid = { version = "0.2.0", features = [] }
+ghx_grid = { version = "0.4", features = [] }
 
 # External dependencies
 bitvec = "1.0.1"
@@ -36,4 +36,8 @@ tracing = "0.1.40"
 # Optional dependencies
 
 # Only enabled when the "bevy" feature is enabled
-bevy = { version = "0.13.0", optional = true, default-features = false }
+bevy = { version = "0.14", optional = true, default-features = false, features = [ 
+    "bevy_winit", 
+    "bevy_render",
+    "wayland",
+]}
diff --git a/ghx_proc_gen/src/generator.rs b/ghx_proc_gen/src/generator.rs
index 45d996a..b6a3791 100644
--- a/ghx_proc_gen/src/generator.rs
+++ b/ghx_proc_gen/src/generator.rs
@@ -5,8 +5,12 @@ use std::{collections::HashMap, sync::Arc};
 use bevy::ecs::component::Component;
 
 use ghx_grid::{
-    coordinate_system::{Cartesian2D, CoordinateSystem},
-    grid::{GridData, GridDefinition, NodeRef},
+    cartesian::{
+        coordinates::{Cartesian2D, CartesianCoordinates},
+        grid::CartesianGrid,
+    },
+    coordinate_system::CoordinateSystem,
+    grid::{GridData, NodeRef},
 };
 
 use crate::{GeneratorError, NodeIndex, NodeSetError};
@@ -71,7 +75,7 @@ pub enum GenerationStatus {
     Done,
 }
 
-/// Output of a [`Generator`] in the context of its [`ghx_grid::grid::GridDefinition`].
+/// Output of a [`Generator`] in the context of its [`ghx_grid::grid::CartesianGrid`].
 #[derive(Clone, Copy, Debug)]
 pub struct GeneratedNode {
     /// Index of the node in the grid
@@ -106,7 +110,7 @@ pub struct Generator<C: CoordinateSystem> {
     internal: InternalGenerator<C>,
 }
 
-impl<C: CoordinateSystem> Generator<C> {
+impl<C: CartesianCoordinates> Generator<C> {
     /// Returns a new `GeneratorBuilder`
     pub fn builder() -> GeneratorBuilder<Unset, Unset, Cartesian2D> {
         GeneratorBuilder::new()
@@ -114,7 +118,7 @@ impl<C: CoordinateSystem> Generator<C> {
 
     fn create(
         rules: Arc<Rules<C>>,
-        grid: GridDefinition<C>,
+        grid: CartesianGrid<C>,
         initial_nodes: Vec<(NodeIndex, ModelVariantIndex)>,
         max_retry_count: u32,
         node_selection_heuristic: NodeSelectionHeuristic,
@@ -144,12 +148,12 @@ impl<C: CoordinateSystem> Generator<C> {
         }
     }
 
-    /// Returns the `max_retry_count`: how many time the [`Generator`] should retry to generate the [`GridDefinition`] when a contradiction is encountered
+    /// Returns the `max_retry_count`: how many time the [`Generator`] should retry to generate the [`CartesianGrid`] when a contradiction is encountered
     pub fn max_retry_count(&self) -> u32 {
         self.max_retry_count
     }
 
-    /// Specifies how many time the [`Generator`] should retry to generate the [`GridDefinition`] when a contradiction is encountered
+    /// Specifies how many time the [`Generator`] should retry to generate the [`CartesianGrid`] when a contradiction is encountered
     pub fn set_max_retry_count(&mut self, max_retry_count: u32) {
         self.max_retry_count = max_retry_count;
     }
@@ -159,8 +163,8 @@ impl<C: CoordinateSystem> Generator<C> {
         self.internal.seed
     }
 
-    /// Returns the [`GridDefinition`] used by the generator
-    pub fn grid(&self) -> &GridDefinition<C> {
+    /// Returns the [`CartesianGrid`] used by the generator
+    pub fn grid(&self) -> &CartesianGrid<C> {
         &self.internal.grid
     }
 
@@ -177,7 +181,7 @@ impl<C: CoordinateSystem> Generator<C> {
     /// Returns a [`GridData`] of [`ModelInstance`] with all the nodes generated if the generation is done
     ///
     /// Returns `None` if the generation is still ongoing or currently failed
-    pub fn to_grid_data(&self) -> Option<GridData<C, ModelInstance>> {
+    pub fn to_grid_data(&self) -> Option<GridData<C, ModelInstance, CartesianGrid<C>>> {
         match self.internal.status {
             InternalGeneratorStatus::Ongoing => None,
             InternalGeneratorStatus::Failed(_) => None,
@@ -192,7 +196,7 @@ impl<C: CoordinateSystem> Generator<C> {
     /// If the generation was already started by previous calls to [`Generator::set_and_propagate`] or [`Generator::select_and_propagate`], this will simply continue the current generation.
     pub fn generate_grid(
         &mut self,
-    ) -> Result<(GenInfo, GridData<C, ModelInstance>), GeneratorError> {
+    ) -> Result<(GenInfo, GridData<C, ModelInstance, CartesianGrid<C>>), GeneratorError> {
         let gen_info =
             self.internal
                 .generate(&mut None, self.max_retry_count, &self.initial_nodes)?;
diff --git a/ghx_proc_gen/src/generator/builder.rs b/ghx_proc_gen/src/generator/builder.rs
index a14aff3..525c671 100644
--- a/ghx_proc_gen/src/generator/builder.rs
+++ b/ghx_proc_gen/src/generator/builder.rs
@@ -1,8 +1,9 @@
 use std::{marker::PhantomData, sync::Arc};
 
 use ghx_grid::{
+    cartesian::{coordinates::CartesianCoordinates, grid::CartesianGrid},
     coordinate_system::CoordinateSystem,
-    grid::{GridData, GridDefinition, NodeRef},
+    grid::{GridData, NodeRef},
 };
 
 use crate::{GeneratorBuilderError, NodeIndex};
@@ -18,23 +19,23 @@ use super::{
 /// Default retry count for the generator
 pub const DEFAULT_RETRY_COUNT: u32 = 50;
 
-/// Internal type used to provide a type-safe builder with compatible [`GridDefinition`] and [`Rules`]
+/// Internal type used to provide a type-safe builder with compatible [`CartesianGrid`] and [`Rules`]
 #[derive(Copy, Clone)]
 pub struct Set;
-/// Internal type used to provide a type-safe builder with compatible [`GridDefinition`] and [`Rules`]
+/// Internal type used to provide a type-safe builder with compatible [`CartesianGrid`] and [`Rules`]
 #[derive(Copy, Clone)]
 pub struct Unset;
 
 /// Used to instantiate a new [`Generator`].
 ///
-/// [`Rules`] and [`GridDefinition`] are the two non-optionnal structs that are needed before being able to call `build`.
+/// [`Rules`] and [`CartesianGrid`] are the two non-optionnal structs that are needed before being able to call `build`.
 ///
 /// ### Example
 ///
 /// Create a `Generator` from a `GeneratorBuilder`.
 /// ```
 /// use ghx_proc_gen::{generator::{builder::GeneratorBuilder, rules::{Rules, RulesBuilder}, socket::{SocketsCartesian2D, SocketCollection}, model::ModelCollection}};
-/// use ghx_grid::grid::GridDefinition;
+/// use ghx_grid::grid::CartesianGrid;
 ///
 /// let mut sockets = SocketCollection::new();
 /// let a = sockets.create();
@@ -45,7 +46,7 @@ pub struct Unset;
 ///
 /// let rules = RulesBuilder::new_cartesian_2d(models,sockets).build().unwrap();
 ///
-/// let grid = GridDefinition::new_cartesian_2d(10, 10, false, false);
+/// let grid = CartesianGrid::new_cartesian_2d(10, 10, false, false);
 /// let mut generator = GeneratorBuilder::new()
 ///    .with_rules(rules)
 ///    .with_grid(grid)
@@ -54,7 +55,7 @@ pub struct Unset;
 #[derive(Clone)]
 pub struct GeneratorBuilder<G, R, C: CoordinateSystem> {
     rules: Option<Arc<Rules<C>>>,
-    grid: Option<GridDefinition<C>>,
+    grid: Option<CartesianGrid<C>>,
     max_retry_count: u32,
     node_selection_heuristic: NodeSelectionHeuristic,
     model_selection_heuristic: ModelSelectionHeuristic,
@@ -118,8 +119,8 @@ impl<C: CoordinateSystem> GeneratorBuilder<Unset, Unset, C> {
 }
 
 impl<C: CoordinateSystem> GeneratorBuilder<Unset, Set, C> {
-    /// Sets the [`GridDefinition`] to be used by the [`Generator`].
-    pub fn with_grid(self, grid: GridDefinition<C>) -> GeneratorBuilder<Set, Set, C> {
+    /// Sets the [`CartesianGrid`] to be used by the [`Generator`].
+    pub fn with_grid(self, grid: CartesianGrid<C>) -> GeneratorBuilder<Set, Set, C> {
         GeneratorBuilder {
             grid: Some(grid),
 
@@ -137,7 +138,7 @@ impl<C: CoordinateSystem> GeneratorBuilder<Unset, Set, C> {
 }
 
 impl<G, R, C: CoordinateSystem> GeneratorBuilder<G, R, C> {
-    /// Specifies how many time the [`Generator`] should retry to generate the [`GridDefinition`] when a contradiction is encountered. Set to [`DEFAULT_RETRY_COUNT`] by default.
+    /// Specifies how many time the [`Generator`] should retry to generate the [`CartesianGrid`] when a contradiction is encountered. Set to [`DEFAULT_RETRY_COUNT`] by default.
     pub fn with_max_retry_count(mut self, max_retry_count: u32) -> Self {
         self.max_retry_count = max_retry_count;
         self
@@ -171,7 +172,7 @@ impl<G, R, C: CoordinateSystem> GeneratorBuilder<G, R, C> {
 }
 
 // For functions in this impl, we know that self.grid is `Some` thanks to the typing.
-impl<C: CoordinateSystem, R> GeneratorBuilder<Set, R, C> {
+impl<C: CartesianCoordinates, R> GeneratorBuilder<Set, R, C> {
     /// Adds a [`QueuedStatefulObserver`] to the [`Generator`] that will be built, and returns it.
     ///
     /// Adding the observer before building the generator allows the observer to see the nodes than *can* be generated during a generator's initialization.
@@ -196,7 +197,7 @@ impl<C: CoordinateSystem, R> GeneratorBuilder<Set, R, C> {
     /// See [`GeneratorBuilder::with_initial_grid`] for a more versatile and easy to use method (at the price of a bit of performances during the method call).
     pub fn with_initial_grid_raw<M: ModelVariantRef<C>>(
         mut self,
-        data: GridData<C, Option<ModelVariantIndex>>,
+        data: GridData<C, Option<ModelVariantIndex>, CartesianGrid<C>>,
     ) -> Result<Self, GeneratorBuilderError> {
         let grid = self.grid.as_ref().unwrap();
         if grid.size() != data.grid().size() {
@@ -205,7 +206,7 @@ impl<C: CoordinateSystem, R> GeneratorBuilder<Set, R, C> {
                 grid.size(),
             ));
         } else {
-            for (node_index, node) in data.nodes().iter().enumerate() {
+            for (node_index, node) in data.iter().enumerate() {
                 match node {
                     Some(model_var_index) => {
                         self.initial_nodes.push((node_index, *model_var_index))
@@ -219,7 +220,7 @@ impl<C: CoordinateSystem, R> GeneratorBuilder<Set, R, C> {
 }
 
 // For functions in this impl, we know that self.rules and self.grid are `Some` thanks to the typing.
-impl<C: CoordinateSystem> GeneratorBuilder<Set, Set, C> {
+impl<C: CartesianCoordinates> GeneratorBuilder<Set, Set, C> {
     /// Registers some [`NodeRef`] [`ModelVariantRef`] pairs to be spawned initially by the [`Generator`]. These nodes will be spawned when the generator reinitializes too.
     ///
     /// See [`GeneratorBuilder::with_initial_nodes_raw`] for a bit more performant but more constrained method. The performance difference only matters during this method call in the `GeneratorBuilder`, during generation all the initial nodes are already converted to their raw format.
@@ -241,7 +242,7 @@ impl<C: CoordinateSystem> GeneratorBuilder<Set, Set, C> {
     /// See [`GeneratorBuilder::with_initial_grid_raw`] for a bit more performant but more constrained method. The performance difference only matters during this method call in the `GeneratorBuilder`, during generation all the initial nodes are already converted to their raw format.
     pub fn with_initial_grid<M: ModelVariantRef<C>>(
         mut self,
-        data: GridData<C, Option<M>>,
+        data: GridData<C, Option<M>, CartesianGrid<C>>,
     ) -> Result<Self, GeneratorBuilderError> {
         let grid = self.grid.as_ref().unwrap();
         let rules = self.rules.as_ref().unwrap();
@@ -251,7 +252,7 @@ impl<C: CoordinateSystem> GeneratorBuilder<Set, Set, C> {
                 grid.size(),
             ));
         } else {
-            for (node_index, node) in data.nodes().iter().enumerate() {
+            for (node_index, node) in data.iter().enumerate() {
                 match node {
                     Some(model_ref) => self
                         .initial_nodes
diff --git a/ghx_proc_gen/src/generator/internal_generator.rs b/ghx_proc_gen/src/generator/internal_generator.rs
index 83e5cc1..b84b2b9 100644
--- a/ghx_proc_gen/src/generator/internal_generator.rs
+++ b/ghx_proc_gen/src/generator/internal_generator.rs
@@ -2,8 +2,10 @@ use std::sync::Arc;
 
 use bitvec::{bitvec, order::LocalBits, slice::IterOnes, vec::BitVec};
 use ghx_grid::{
+    cartesian::{coordinates::CartesianCoordinates, grid::CartesianGrid},
     coordinate_system::CoordinateSystem,
-    grid::{GridData, GridDefinition},
+    direction::DirectionTrait,
+    grid::GridData,
 };
 use ndarray::{Array, Ix3};
 use rand::{
@@ -44,7 +46,7 @@ struct PropagationEntry {
 
 pub(crate) struct InternalGenerator<C: CoordinateSystem> {
     // === Read-only configuration ===
-    pub(crate) grid: GridDefinition<C>,
+    pub(crate) grid: CartesianGrid<C>,
     pub(crate) rules: Arc<Rules<C>>,
 
     // === Generation state ===
@@ -68,18 +70,19 @@ pub(crate) struct InternalGenerator<C: CoordinateSystem> {
     supports_count: Array<usize, Ix3>,
 }
 
-impl<C: CoordinateSystem> InternalGenerator<C> {
+impl<C: CartesianCoordinates> InternalGenerator<C> {
     pub(crate) fn new(
         rules: Arc<Rules<C>>,
-        grid: GridDefinition<C>,
+        grid: CartesianGrid<C>,
         node_selection_heuristic: NodeSelectionHeuristic,
         model_selection_heuristic: ModelSelectionHeuristic,
         rng_mode: RngMode,
         observers: Vec<crossbeam_channel::Sender<GenerationUpdate>>,
     ) -> Self {
         let models_count = rules.models_count();
-        let nodes_count = grid.total_size();
-        let direction_count = grid.directions().len();
+        //let nodes_count = grid.total_size();
+        let nodes_count: usize = (grid.size_xy() * grid.size_z()) as usize;
+        let direction_count = grid.coord_system().directions_count() as usize;
 
         let seed = match rng_mode {
             RngMode::Seeded(seed) => seed,
@@ -89,7 +92,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
         let node_selection_heuristic = InternalNodeSelectionHeuristic::from_external(
             node_selection_heuristic,
             &rules,
-            grid.total_size(),
+            nodes_count,
         );
 
         Self {
@@ -115,7 +118,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
     }
 }
 
-impl<C: CoordinateSystem> InternalGenerator<C> {
+impl<C: CartesianCoordinates> InternalGenerator<C> {
     #[inline]
     fn is_model_possible(&self, node: NodeIndex, model: ModelVariantIndex) -> bool {
         self.nodes[node * self.rules.models_count() + model] == true
@@ -159,7 +162,8 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
 
         self.status = InternalGeneratorStatus::Ongoing;
 
-        let nodes_count = self.grid.total_size();
+        //let nodes_count = self.grid.total_size();
+        let nodes_count = (self.grid.size_xy() * self.grid.size_z()) as usize;
         self.nodes = bitvec![1;self.rules.models_count() * nodes_count ];
         self.nodes_left_to_generate = nodes_count;
         self.possible_models_counts = vec![self.rules.models_count(); nodes_count];
@@ -203,17 +207,19 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
         #[cfg(feature = "debug-traces")]
         debug!("Initializing support counts");
 
-        let mut neighbours = vec![None; self.grid.directions().len()];
-        for node in 0..self.grid.total_size() {
+        let mut neighbours = vec![None; self.grid.coord_system().directions_count()];
+        let total_size: usize = (self.grid.size_xy() * self.grid.size_z()) as usize;
+        //for node in 0..self.grid.total_size() {
+        for node in 0..total_size {
             // For a given `node`, `neighbours[direction]` will hold the optionnal index of the neighbour node in `direction`
-            for direction in self.grid.directions() {
+            for direction in self.grid.coord_system().directions() {
                 let grid_pos = self.grid.pos_from_index(node);
                 neighbours[*direction as usize] =
                     self.grid.get_next_index_in_direction(&grid_pos, *direction);
             }
 
             for model in 0..self.rules.models_count() {
-                for direction in self.grid.directions() {
+                for direction in self.grid.coord_system().directions() {
                     let opposite_dir = direction.opposite();
                     // During initialization, the support count for a model "from" a direction is simply the count of allowed adjacent models when looking in the opposite direction, or 0 for a non-looping border (no neighbour from this direction).
                     match neighbours[opposite_dir as usize] {
@@ -528,7 +534,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
             self.enqueue_removal_to_propagate(node_index, model_index);
 
             // None of these model are possible on this node now, set their support to 0
-            for dir in self.grid.directions() {
+            for dir in self.grid.coord_system().directions() {
                 self.supports_count[(node_index, model_index, *dir as usize)] = 0;
             }
         }
@@ -558,7 +564,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
         collector: &mut Collector,
     ) -> Result<(), GeneratorError> {
         // Update the supports
-        for dir in self.grid.directions() {
+        for dir in self.grid.coord_system().directions() {
             let supports_count = &mut self.supports_count[(node_index, model, *dir as usize)];
             *supports_count = 0;
         }
@@ -633,7 +639,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
     /// Does not modify the generator internal status.
     fn propagate(&mut self, collector: &mut Collector) -> Result<(), GeneratorError> {
         // Clone the ref to allow for mutability of other members in the interior loops
-        let rules = Arc::clone(&self.rules);
+        let rules: Arc<Rules<C>> = Arc::clone(&self.rules);
 
         while let Some(from) = self.propagation_stack.pop() {
             let from_position = self.grid.pos_from_index(from.node_index);
@@ -647,7 +653,7 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
             );
 
             // We want to update all the adjacent nodes (= in all directions)
-            for dir in self.grid.directions() {
+            for dir in self.grid.coord_system().directions() {
                 // Get the adjacent node in this direction, it may not exist.
                 if let Some(to_node_index) =
                     self.grid.get_next_index_in_direction(&from_position, *dir)
@@ -702,10 +708,12 @@ impl<C: CoordinateSystem> InternalGenerator<C> {
     }
 
     /// Should only be called when the nodes are fully generated
-    pub(crate) fn to_grid_data(&self) -> GridData<C, ModelInstance> {
+    pub(crate) fn to_grid_data(&self) -> GridData<C, ModelInstance, CartesianGrid<C>> {
+        let total_size: usize = (self.grid.size_xy() * self.grid.size_z()) as usize;
         let mut generated_nodes = Vec::with_capacity(self.nodes.len());
-        for node_index in 0..self.grid.total_size() {
-            let model_index = self.get_model_index(node_index);
+        //for node_index in 0..self.grid.total_size() {
+        for node_index in 0..total_size {
+            let model_index = self.get_model_index(node_index.try_into().unwrap());
             generated_nodes.push(self.rules.model(model_index).clone())
         }
 
diff --git a/ghx_proc_gen/src/generator/model.rs b/ghx_proc_gen/src/generator/model.rs
index c4baf89..c684838 100644
--- a/ghx_proc_gen/src/generator/model.rs
+++ b/ghx_proc_gen/src/generator/model.rs
@@ -1,8 +1,9 @@
 use std::{borrow::Cow, collections::HashSet, fmt, marker::PhantomData};
 
 use ghx_grid::{
-    coordinate_system::{Cartesian2D, Cartesian3D, CoordinateSystem},
-    direction::Direction,
+    cartesian::coordinates::{Cartesian2D, Cartesian3D},
+    coordinate_system::CoordinateSystem,
+    direction::{Direction, DirectionTrait},
 };
 #[cfg(feature = "debug-traces")]
 use tracing::warn;
diff --git a/ghx_proc_gen/src/generator/observer.rs b/ghx_proc_gen/src/generator/observer.rs
index 882634f..e2631a5 100644
--- a/ghx_proc_gen/src/generator/observer.rs
+++ b/ghx_proc_gen/src/generator/observer.rs
@@ -3,8 +3,9 @@ use super::{model::ModelInstance, GeneratedNode, Generator};
 #[cfg(feature = "bevy")]
 use bevy::ecs::component::Component;
 use ghx_grid::{
+    cartesian::{coordinates::CartesianCoordinates, grid::CartesianGrid},
     coordinate_system::CoordinateSystem,
-    grid::{GridData, GridDefinition},
+    grid::GridData,
 };
 
 /// Update sent by a [`crate::generator::Generator`]
@@ -22,30 +23,31 @@ pub enum GenerationUpdate {
 ///
 /// Can be used in a different thread than the generator's thread.
 #[cfg_attr(feature = "bevy", derive(Component))]
-pub struct QueuedStatefulObserver<T: CoordinateSystem> {
-    grid_data: GridData<T, Option<ModelInstance>>,
+pub struct QueuedStatefulObserver<C: CartesianCoordinates> {
+    grid_data: GridData<C, Option<ModelInstance>, CartesianGrid<C>>,
     receiver: crossbeam_channel::Receiver<GenerationUpdate>,
 }
 
-impl<T: CoordinateSystem> QueuedStatefulObserver<T> {
+impl<C: CartesianCoordinates> QueuedStatefulObserver<C> {
     /// Creates a new [`QueuedStatefulObserver`] for a given [`crate::generator::Generator`]
-    pub fn new(generator: &mut Generator<T>) -> Self {
+    pub fn new(generator: &mut Generator<C>) -> Self {
         let receiver = generator.create_observer_queue();
         QueuedStatefulObserver::create(receiver, generator.grid())
     }
 
     pub(crate) fn create(
         receiver: crossbeam_channel::Receiver<GenerationUpdate>,
-        grid: &GridDefinition<T>,
+        grid: &CartesianGrid<C>,
     ) -> Self {
+        let total_size = (grid.size_xy() * grid.size_z()) as usize;
         QueuedStatefulObserver {
-            grid_data: GridData::new(grid.clone(), vec![None; grid.total_size()]),
+            grid_data: GridData::new(grid.clone(), vec![None; total_size]),
             receiver,
         }
     }
 
     /// Returns a ref to the observer's [`GridData`]
-    pub fn grid_data(&self) -> &GridData<T, Option<ModelInstance>> {
+    pub fn grid_data(&self) -> &GridData<C, Option<ModelInstance>, CartesianGrid<C>> {
         &self.grid_data
     }
 
@@ -92,7 +94,7 @@ pub struct QueuedObserver {
 
 impl QueuedObserver {
     /// Creates a new [`QueuedObserver`] for a given [`crate::generator::Generator`]
-    pub fn new<T: CoordinateSystem>(generator: &mut Generator<T>) -> Self {
+    pub fn new<T: CoordinateSystem + CartesianCoordinates>(generator: &mut Generator<T>) -> Self {
         let receiver = generator.create_observer_queue();
         QueuedObserver { receiver }
     }
diff --git a/ghx_proc_gen/src/generator/rules.rs b/ghx_proc_gen/src/generator/rules.rs
index 45b6207..1e18621 100644
--- a/ghx_proc_gen/src/generator/rules.rs
+++ b/ghx_proc_gen/src/generator/rules.rs
@@ -5,8 +5,9 @@ use std::{
 };
 
 use ghx_grid::{
-    coordinate_system::{Cartesian2D, Cartesian3D, CoordinateSystem},
-    direction::Direction,
+    cartesian::coordinates::{Cartesian2D, Cartesian3D},
+    coordinate_system::CoordinateSystem,
+    direction::{Direction, DirectionTrait},
 };
 use ndarray::{Array, Ix1, Ix2};
 
@@ -226,8 +227,8 @@ impl<C: CoordinateSystem> Rules<C> {
             Array::from_elem(coord_system.directions().len(), BTreeSet::new());
         for (model_index, model) in model_variations.iter().enumerate() {
             for &direction in coord_system.directions() {
-                let opposite_dir = direction.opposite() as usize;
-                for socket in &model.sockets()[direction as usize] {
+                let opposite_dir = usize::try_from(direction.opposite()).unwrap();
+                for socket in &model.sockets()[usize::try_from(direction).unwrap()] {
                     let compatible_models = sockets_to_models
                         .entry(socket)
                         .or_insert(empty_in_all_directions.clone());
@@ -245,16 +246,19 @@ impl<C: CoordinateSystem> Rules<C> {
                 // We filter unique models with a Set, but waht we want in the Rules is a Vec for access speed, caching, and iteration determinism.
                 let mut unique_models = HashSet::new();
                 // For each socket of the model in this direction: get all the sockets that are compatible for connection
-                for socket in &model.sockets()[direction as usize] {
+                for socket in &model.sockets()[usize::try_from(direction).unwrap()] {
                     if let Some(compatible_sockets) = socket_collection.get_compatibles(*socket) {
                         for compatible_socket in compatible_sockets {
                             // For each of those: get all the models that have this socket from direction
                             // `sockets_to_models` may not have an entry for `compatible_socket` depending on user input data (socket present in sockets_connections but not in a model)
                             if let Some(allowed_models) = sockets_to_models.get(&compatible_socket)
                             {
-                                for allowed_model in &allowed_models[direction as usize] {
+                                for allowed_model in
+                                    &allowed_models[usize::try_from(direction).unwrap()]
+                                {
                                     if unique_models.insert(*allowed_model) {
-                                        allowed_neighbours[(model_index, direction as usize)]
+                                        allowed_neighbours
+                                            [(model_index, usize::try_from(direction).unwrap())]
                                             .push(*allowed_model);
                                     }
                                 }
diff --git a/ghx_proc_gen/src/generator/socket.rs b/ghx_proc_gen/src/generator/socket.rs
index d7b2a23..c25dc41 100644
--- a/ghx_proc_gen/src/generator/socket.rs
+++ b/ghx_proc_gen/src/generator/socket.rs
@@ -1,6 +1,6 @@
 use std::collections::{HashMap, HashSet};
 
-use ghx_grid::coordinate_system::{Cartesian2D, Cartesian3D};
+use ghx_grid::cartesian::coordinates::{Cartesian2D, Cartesian3D};
 
 use super::model::{ModelRotation, ModelTemplate, ALL_MODEL_ROTATIONS};