diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..b3be999
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  # Run cargo test
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    name: Test `cargo test` on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+      - name: Cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ matrix.os }}-cargo-test-${{ hashFiles('**/Cargo.toml') }}
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Install Dependencies
+        if: matrix.os == 'ubuntu-latest'
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libopenxr-loader1 libopenxr-dev
+      - name: Run cargo test
+        run: cargo test
+
+  # Run cargo clippy -- -D warnings
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+      - name: Cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.toml') }}
+      - name: Add clippy to rustup
+        run: rustup component add clippy
+      - name: Install Dependencies
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
+      - name: Run clippy
+        run: cargo clippy -- -D warnings
+
+  # Run cargo fmt --all -- --check
+  format:
+    name: Format
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+      - name: Add rustfmt to rustup
+        run: rustup component add rustfmt
+      - name: Run cargo fmt
+        run: cargo fmt --all -- --check
diff --git a/.gitignore b/.gitignore
index 9dc9aae..7d80a30 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
-
 **/.DS_Store
-assets/**
+/assets
 Cargo.lock
-target/**
+/target
diff --git a/Cargo.toml b/Cargo.toml
index 3e5893b..393c226 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,26 +1,30 @@
 [package]
-name = "osmeta" # OSMeta ???  `#[warn(non_snake_case)]` on by default
+name = "osmeta"   # OSMeta ???  `#[warn(non_snake_case)]` on by default
 version = "0.1.0"
 edition = "2021"
 
 
 # Enable a small amount of optimization in debug mode
-#[profile.dev]
-#opt-level = 1
+[profile.dev]
+opt-level = 1
 
 # Enable high optimizations for dependencies (incl. Bevy), but not for our code:
-#[profile.dev.package."*"]
-#opt-level = 3
+[profile.dev.package."*"]
+opt-level = 3
 
 
 [dependencies]
-bevy = { version = "0.12", features = ["jpeg"] } ## NOT the local file bevy, the one from the net
-bevy_flycam = { git = "https://github.com/sburris0/bevy_flycam" }  ## control
+bevy = { version = "0.12", features = [
+    "jpeg",
+] } ## NOT the local file bevy, the one from the net
+bevy_flycam = { git = "https://github.com/sburris0/bevy_flycam" } ## control
+bevy_oxr = { git = "https://github.com/awtterpip/bevy_openxr" }
 ## bevy_config_cam = { git = "https://github.com/BlackPhlox/bevy_config_cam" } ## { version = "0.3.0"}
 glam = "0"
 
 
-#[features]
+[features]
+#xr = ["bevy_oxr"]
 #jpeg = ["bevy_internal/jpeg"]
 
 
diff --git a/rust-toolchain b/rust-toolchain
new file mode 100644
index 0000000..dc87e8a
--- /dev/null
+++ b/rust-toolchain
@@ -0,0 +1 @@
+1.74.0
diff --git a/src/main.rs b/src/main.rs
index 4c42965..14c0377 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,36 +1,44 @@
+//! Loads and renders a glTF file as a scene.
+
 use bevy::{
     pbr::{CascadeShadowConfigBuilder, DirectionalLightShadowMap},
     prelude::*,
 };
 use std::f32::consts::*;
+use tilemap::TileMap;
+use xr::XRPlugin;
 
 use bevy_flycam::prelude::*;
+use bevy_oxr::DefaultXrPlugins;
 
-//mod geopos;
-//use geopos::*;
-
-
+mod tilemap;
+mod xr;
 
 fn main() {
-
-    App::new()
-        .insert_resource(DirectionalLightShadowMap { size: 4096 })
+    let mut app = App::new();
+    if std::env::args().any(|arg| arg == "xr") {
+        app.add_plugins(DefaultXrPlugins).add_plugins(XRPlugin);
+    } else {
+        app.add_plugins(DefaultPlugins);
+    }
+    app.insert_resource(DirectionalLightShadowMap { size: 4096 })
         .insert_resource(Msaa::Sample4) // Msaa::Sample4  Msaa::default()   -- Todo: tut nichts?
-        .add_plugins(DefaultPlugins)
-
         .add_plugins(bevy::diagnostic::LogDiagnosticsPlugin::default())
-        .add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin::default())
+        .add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
         .add_systems(Startup, setup)
-        .add_systems(Update, animate_light_direction)
-      //.add_systems(Update, _animate_camera_position)
-
+        .add_systems(
+            Update,
+            (
+                animate_light_direction,
+                update_active_tile_zone,
+                tilemap::update,
+            ),
+        )
         .add_plugins(NoCameraPlayerPlugin) // https://github.com/sburris0/bevy_flycam (bevy_config_cam dies not work wiht Bevy 12)
-
         .run();
 }
 
-fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
-
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut meshes: ResMut<Assets<Mesh>>) {
     commands.spawn((
         Camera3dBundle {
             transform: Transform::from_xyz(3., 100., 400.)
@@ -56,48 +64,31 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
         // only using a single cascade.
         cascade_shadow_config: CascadeShadowConfigBuilder {
             num_cascades: 1,
-          //maximum_distance: 1.6,
+            //maximum_distance: 1.6,
             ..default()
         }
         .into(),
         ..default()
     });
 
-    add_tile(&mut commands, &asset_server,17429, 11369);
-    add_tile(&mut commands, &asset_server,17429, 11370);
-    add_tile(&mut commands, &asset_server,17429, 11371);
-
-    add_tile(&mut commands, &asset_server,17430, 11369);
-    add_tile(&mut commands, &asset_server,17430, 11370);
-    add_tile(&mut commands, &asset_server,17430, 11371);
-
-    add_tile(&mut commands, &asset_server,17431, 11369);
-    add_tile(&mut commands, &asset_server,17431, 11370);
-    add_tile(&mut commands, &asset_server,17431, 11371);
-
+    commands.spawn(TileMap::new(&mut meshes));
 }
 
+fn update_active_tile_zone(mut commands: Commands, mut tilemap: Query<&mut TileMap>) {
+    let mut tilemap = tilemap.single_mut();
+    tilemap.load(&mut commands, 17429, 11369);
+    tilemap.load(&mut commands, 17429, 11370);
+    tilemap.load(&mut commands, 17429, 11371);
 
-fn add_tile(commands: &mut Commands, asset_server: &Res<AssetServer>,x: u32, y: u32) {
-    // https://gltiles.osm2world.org/glb/lod1/15/17388/11332.glb#Scene0"
-
-    // Just for testing:
-    const TILE_SIZE: f32 = 814.5;
-    const X0: u32 = 17430;
-    const Y0: u32 = 11370;
-
-    let name: String = format!( "models/{}_{}.glb#Scene0",x,y);   //format!("hello {}", "world!");
-    commands.spawn(SceneBundle {
-        scene: asset_server.load(name), // "models/17430_11371.glb#Scene0"
-        transform: Transform::from_xyz(
-            (x-X0) as f32 *  TILE_SIZE, 0.,
-            (y-Y0) as f32 *  TILE_SIZE),  // OSM y => GPU z
-        ..default()
-    });
+    tilemap.load(&mut commands, 17430, 11369);
+    tilemap.load(&mut commands, 17430, 11370);
+    tilemap.load(&mut commands, 17430, 11371);
 
+    tilemap.load(&mut commands, 17431, 11369);
+    tilemap.load(&mut commands, 17431, 11370);
+    tilemap.load(&mut commands, 17431, 11371);
 }
 
-
 fn animate_light_direction(
     time: Res<Time>,
     mut query: Query<&mut Transform, With<DirectionalLight>>,
@@ -111,17 +102,3 @@ fn animate_light_direction(
         );
     }
 }
-
-fn _animate_camera_position(
-    time: Res<Time>,
-    mut query: Query<&mut Transform, With<FlyCam>>,
-) {
-    for mut transform in &mut query {
-        transform.rotation = Quat::from_euler(
-            EulerRot::ZYX,
-            0.0, // Looping
-            time.elapsed_seconds() * PI / 10.0, // Komnpas
-            -35. / 180. * PI, // Auf-Ab
-        );
-    }
-}
diff --git a/src/tilemap.rs b/src/tilemap.rs
new file mode 100644
index 0000000..5176abf
--- /dev/null
+++ b/src/tilemap.rs
@@ -0,0 +1,105 @@
+use std::collections::{BTreeMap, VecDeque};
+
+use bevy::prelude::*;
+
+#[derive(Component, Default)]
+pub struct TileMap {
+    tiles: BTreeMap<i32, BTreeMap<i32, Entity>>,
+    to_load: VecDeque<(i32, i32)>,
+    loading: Option<(i32, i32, Handle<Scene>)>,
+    dummy: Handle<Mesh>,
+}
+
+#[derive(Component)]
+pub struct Tile;
+
+impl TileMap {
+    pub fn load(&mut self, commands: &mut Commands, x: i32, y: i32) {
+        self.tiles
+            .entry(x)
+            .or_default()
+            .entry(y)
+            .or_insert_with(|| {
+                self.to_load.push_front((x, y));
+                let transform = test_transform(x, y);
+
+                commands
+                    .spawn(PbrBundle {
+                        mesh: self.dummy.clone(),
+                        transform,
+                        ..default()
+                    })
+                    .id()
+            });
+    }
+}
+
+pub fn update(mut commands: Commands, server: Res<AssetServer>, mut tilemap: Query<&mut TileMap>) {
+    for mut tilemap in &mut tilemap {
+        if let Some((x, y, scene)) = tilemap.loading.take() {
+            use bevy::asset::LoadState::*;
+            match server.get_load_state(&scene).unwrap() {
+                NotLoaded | Loading => {
+                    tilemap.loading = Some((x, y, scene));
+                    return;
+                }
+                Loaded => {
+                    let entity = tilemap.tiles.entry(x).or_default().get_mut(&y).unwrap();
+
+                    let transform = test_transform(x, y);
+                    let tile = commands
+                        .spawn((
+                            SceneBundle {
+                                scene, // "models/17430_11371.glb#Scene0"
+                                transform,
+                                ..default()
+                            },
+                            Tile,
+                        ))
+                        .id();
+                    let dummy = std::mem::replace(entity, tile);
+                    commands.entity(dummy).despawn();
+                }
+                Failed => todo!(),
+            }
+        }
+
+        assert!(tilemap.loading.is_none());
+        let Some((x, y)) = tilemap.to_load.pop_back() else {
+            return;
+        };
+
+        // https://gltiles.osm2world.org/glb/lod1/15/17388/11332.glb#Scene0"
+        let name: String = format!("models/{}_{}.glb#Scene0", x, y);
+        tilemap.loading = Some((x, y, server.load(name))); // "models/17430_11371.glb#Scene0"
+    }
+}
+
+impl TileMap {
+    pub fn new(meshes: &mut Assets<Mesh>) -> Self {
+        Self {
+            dummy: meshes.add(
+                shape::Box {
+                    min_x: 0.0,
+                    max_x: 814.5,
+                    min_y: 0.0,
+                    max_y: 1.0,
+                    min_z: 0.0,
+                    max_z: 814.5,
+                }
+                .into(),
+            ),
+            ..default()
+        }
+    }
+}
+
+fn test_transform(x: i32, y: i32) -> Transform {
+    // Just for testing:
+    const TILE_SIZE: f32 = 814.5;
+    const X0: i32 = 17430;
+    const Y0: i32 = 11370;
+
+    // OSM y => GPU z
+    Transform::from_xyz((x - X0) as f32 * TILE_SIZE, 0., (y - Y0) as f32 * TILE_SIZE)
+}
diff --git a/src/xr.rs b/src/xr.rs
new file mode 100644
index 0000000..07a1f58
--- /dev/null
+++ b/src/xr.rs
@@ -0,0 +1,157 @@
+use bevy::pbr::build_directional_light_cascades;
+use bevy::prelude::*;
+use bevy_oxr::input::XrInput;
+use bevy_oxr::resources::{XrFrameState, XrSession};
+use bevy_oxr::xr_input::actions::XrActionSets;
+use bevy_oxr::xr_input::interactions::{
+    draw_interaction_gizmos, draw_socket_gizmos, interactions, socket_interactions,
+    update_interactable_states, InteractionEvent, XRDirectInteractor, XRInteractorState,
+    XRRayInteractor,
+};
+use bevy_oxr::xr_input::oculus_touch::OculusController;
+use bevy_oxr::xr_input::prototype_locomotion::{proto_locomotion, PrototypeLocomotionConfig};
+use bevy_oxr::xr_input::trackers::{
+    AimPose, OpenXRController, OpenXRLeftController, OpenXRRightController, OpenXRTracker,
+};
+use bevy_oxr::xr_input::Hand;
+use bevy_oxr::xr_input::{
+    hand::{HandInputDebugRenderer, OpenXrHandInput},
+    xr_camera::XRProjection,
+};
+
+pub struct XRPlugin;
+
+impl Plugin for XRPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, proto_locomotion)
+            .insert_resource(PrototypeLocomotionConfig::default())
+            .add_systems(Startup, spawn_controllers_example)
+            .add_plugins(OpenXrHandInput)
+            .add_plugins(HandInputDebugRenderer)
+            .add_systems(
+                Update,
+                draw_interaction_gizmos.after(update_interactable_states),
+            )
+            .add_systems(Update, draw_socket_gizmos.after(update_interactable_states))
+            .add_systems(Update, interactions.before(update_interactable_states))
+            .add_systems(
+                Update,
+                socket_interactions.before(update_interactable_states),
+            )
+            .add_systems(Update, prototype_interaction_input)
+            .add_systems(Update, update_interactable_states)
+            .add_systems(Update, update_grabbables.after(update_interactable_states))
+            // Ensure that the XR cameras are registered with light cascades (otherwise we'll get a panic)
+            .add_systems(
+                PostUpdate,
+                build_directional_light_cascades::<XRProjection>
+                    .after(build_directional_light_cascades::<Projection>),
+            )
+            .add_event::<InteractionEvent>();
+    }
+}
+
+fn spawn_controllers_example(mut commands: Commands) {
+    //left hand
+    commands.spawn((
+        OpenXRLeftController,
+        OpenXRController,
+        OpenXRTracker,
+        SpatialBundle::default(),
+        XRRayInteractor,
+        AimPose(Transform::default()),
+        XRInteractorState::default(),
+    ));
+    //right hand
+    commands.spawn((
+        OpenXRRightController,
+        OpenXRController,
+        OpenXRTracker,
+        SpatialBundle::default(),
+        XRDirectInteractor,
+        XRInteractorState::default(),
+    ));
+}
+
+#[allow(clippy::type_complexity)]
+fn prototype_interaction_input(
+    oculus_controller: Res<OculusController>,
+    frame_state: Res<XrFrameState>,
+    xr_input: Res<XrInput>,
+    session: Res<XrSession>,
+    mut right_interactor_query: Query<
+        &mut XRInteractorState,
+        (
+            With<XRDirectInteractor>,
+            With<OpenXRRightController>,
+            Without<OpenXRLeftController>,
+        ),
+    >,
+    mut left_interactor_query: Query<
+        &mut XRInteractorState,
+        (
+            With<XRRayInteractor>,
+            With<OpenXRLeftController>,
+            Without<OpenXRRightController>,
+        ),
+    >,
+    action_sets: Res<XrActionSets>,
+) {
+    //lock frame
+    let frame_state = *frame_state.lock().unwrap();
+    //get controller
+    let controller = oculus_controller.get_ref(&session, &frame_state, &xr_input, &action_sets);
+    //get controller triggers
+    let left_trigger = controller.trigger(Hand::Left);
+    let right_trigger = controller.trigger(Hand::Right);
+    //get the interactors and do state stuff
+    let mut left_state = left_interactor_query.single_mut();
+    if left_trigger > 0.8 {
+        *left_state = XRInteractorState::Selecting;
+    } else {
+        *left_state = XRInteractorState::Idle;
+    }
+    let mut right_state = right_interactor_query.single_mut();
+    if right_trigger > 0.8 {
+        *right_state = XRInteractorState::Selecting;
+    } else {
+        *right_state = XRInteractorState::Idle;
+    }
+}
+
+#[derive(Component)]
+struct Grabbable;
+
+fn update_grabbables(
+    mut events: EventReader<InteractionEvent>,
+    mut grabbable_query: Query<(&mut Transform, With<Grabbable>, Without<XRDirectInteractor>)>,
+    interactor_query: Query<(&GlobalTransform, &XRInteractorState, Without<Grabbable>)>,
+) {
+    //so basically the idea is to try all the events?
+    for event in events.read() {
+        // info!("some event");
+        match grabbable_query.get_mut(event.interactable) {
+            Ok(mut grabbable_transform) => {
+                // info!("we got a grabbable");
+                //now we need the location of our interactor
+                match interactor_query.get(event.interactor) {
+                    Ok(interactor_transform) => {
+                        match interactor_transform.1 {
+                            XRInteractorState::Idle => (),
+                            XRInteractorState::Selecting => {
+                                // info!("its a direct interactor?");
+                                *grabbable_transform.0 = interactor_transform.0.compute_transform();
+                            }
+                        }
+                    }
+                    Err(_) => {
+                        // info!("not a direct interactor")
+                    }
+                }
+            }
+            Err(_) => {
+                // info!("not a grabbable?")
+            }
+        }
+    }
+}