diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 7af499a..155290c 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -5,6 +5,7 @@
       "label": "Launch",
       "type": "cargo",
       "command": "run",
+	  "args": ["--", "--seed", "gargamel"],
       "options": {
         "env": {
           "RUST_BACKTRACE": "full"
diff --git a/src/game/mod.rs b/src/game/mod.rs
new file mode 100644
index 0000000..370d386
--- /dev/null
+++ b/src/game/mod.rs
@@ -0,0 +1,4 @@
+pub mod objects;
+pub mod runtime;
+pub mod seed;
+pub mod setup;
diff --git a/src/game/objects.rs b/src/game/objects.rs
new file mode 100644
index 0000000..2ba8d60
--- /dev/null
+++ b/src/game/objects.rs
@@ -0,0 +1,18 @@
+use avian2d::prelude::*;
+use bevy::prelude::*;
+
+#[derive(Component, Default)]
+#[require(Collider, Mesh2d, MeshMaterial2d<ColorMaterial>, Restitution = Restitution::new(1.0), RigidBody, TransformInterpolation, Transform)]
+struct GameObject;
+
+#[derive(Component, Default)]
+#[require(GameObject, RigidBody = RigidBody::Dynamic)]
+pub struct Ball;
+
+#[derive(Component, Default)]
+#[require(Ball)]
+pub struct Player;
+
+#[derive(Component, Default)]
+#[require(GameObject, RigidBody = RigidBody::Static)]
+pub struct Wall;
diff --git a/src/game/runtime.rs b/src/game/runtime.rs
new file mode 100644
index 0000000..a0ab185
--- /dev/null
+++ b/src/game/runtime.rs
@@ -0,0 +1,58 @@
+use avian2d::prelude::*;
+use bevy::{
+    input::mouse::{AccumulatedMouseScroll, MouseScrollUnit},
+    prelude::*,
+};
+
+use super::objects::Player;
+
+pub fn move_player(
+    time: Res<Time>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut velocity: Single<&mut LinearVelocity, With<Player>>,
+) -> Result {
+    let acceleration = 500.0;
+
+    let delta_time = time.delta_secs();
+
+    if keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]) {
+        velocity.y += acceleration * delta_time;
+    }
+    if keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]) {
+        velocity.y -= acceleration * delta_time;
+    }
+    if keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]) {
+        velocity.x -= acceleration * delta_time;
+    }
+    if keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]) {
+        velocity.x += acceleration * delta_time;
+    }
+
+    Ok(())
+}
+
+pub fn quit(mut exit: EventWriter<AppExit>) {
+    exit.write(AppExit::Success);
+}
+
+pub fn move_camera(
+    mut camera: Single<&mut Transform, (Without<Player>, With<IsDefaultUiCamera>)>,
+    player: Single<&Transform, (With<Player>, Without<IsDefaultUiCamera>)>,
+) {
+    camera.translation = camera.translation.lerp(player.translation, 0.05);
+}
+
+pub fn zoom_camera(
+    mut camera: Single<&mut Projection, With<IsDefaultUiCamera>>,
+    scroll: Res<AccumulatedMouseScroll>,
+) -> Result {
+    let Projection::Orthographic(ref mut projection) = **camera else {
+        return Err("Default camera was not orthographic".into());
+    };
+    let scroll_type_multiplier = match scroll.unit {
+        MouseScrollUnit::Line => 0.01,
+        MouseScrollUnit::Pixel => 0.001,
+    };
+    projection.scale = (projection.scale - scroll.delta.y * scroll_type_multiplier).clamp(0.1, 2.5);
+    Ok(())
+}
diff --git a/src/game/seed.rs b/src/game/seed.rs
new file mode 100644
index 0000000..1467ee9
--- /dev/null
+++ b/src/game/seed.rs
@@ -0,0 +1,22 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+
+use bevy::prelude::*;
+
+#[derive(Clone, Resource)]
+pub struct Seed(u64);
+
+impl From<String> for Seed {
+    fn from(value: String) -> Self {
+        Self(value.parse::<u64>().unwrap_or_else(|_| {
+            let mut state = DefaultHasher::new();
+            value.hash(&mut state);
+            state.finish()
+        }))
+    }
+}
+
+impl From<Seed> for [u8; 8] {
+    fn from(value: Seed) -> Self {
+        value.0.to_le_bytes()
+    }
+}
diff --git a/src/game/setup.rs b/src/game/setup.rs
new file mode 100644
index 0000000..f1f0770
--- /dev/null
+++ b/src/game/setup.rs
@@ -0,0 +1,110 @@
+use std::{f32::consts::PI, ops::Range};
+
+use avian2d::prelude::*;
+use bevy::{
+    color::palettes::{
+        css::WHITE,
+        tailwind::{LIME_400, RED_400},
+    },
+    prelude::*,
+};
+use bevy_rand::prelude::{GlobalEntropy, WyRand};
+use rand::Rng;
+use wyrand::WyRand as LocalRng;
+
+use super::objects::{Ball, Player, Wall};
+
+const BALL_COUNT: u8 = 32;
+const BALL_SIZES: Range<f32> = 10.0..25.0;
+const DIMENSION_SIZES: Range<f32> = 500.0..2000.0;
+
+#[derive(Resource)]
+pub struct PlayableArea(f32, f32);
+
+#[derive(Resource)]
+pub struct PlayerSize(f32);
+
+pub fn setup_pseudo_random(mut commands: Commands, mut rng: GlobalEntropy<WyRand>) {
+    commands.insert_resource(PlayerSize(rng.random_range(BALL_SIZES)));
+    commands.insert_resource(PlayableArea(
+        rng.random_range(DIMENSION_SIZES),
+        rng.random_range(DIMENSION_SIZES),
+    ));
+}
+
+pub fn setup_ui(mut commands: Commands) {
+    commands.spawn((Name::new("Camera"), Camera2d, IsDefaultUiCamera));
+}
+
+pub fn setup_player(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    radius: Res<PlayerSize>,
+) {
+    let circle = Circle::new(radius.0);
+    commands.spawn((
+        Player,
+        Collider::from(circle),
+        Mesh2d(meshes.add(circle)),
+        MeshMaterial2d(materials.add(Color::from(LIME_400))),
+    ));
+}
+
+pub fn setup_balls(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    region: Res<PlayableArea>,
+) {
+    let mut random = LocalRng::new(Default::default());
+    for _ in 0..BALL_COUNT {
+        let circle = Circle::new(random.random_range(BALL_SIZES));
+        commands.spawn((
+            Ball,
+            Collider::from(circle),
+            Mesh2d(meshes.add(circle)),
+            MeshMaterial2d(materials.add(Color::from(RED_400))),
+            Transform::from_xyz(
+                random.random_range(
+                    (-region.0 / 2.0 + circle.radius)..(region.0 / 2.0 - circle.radius),
+                ),
+                random.random_range(
+                    (-region.1 / 2.0 + circle.radius)..(region.1 / 2.0 - circle.radius),
+                ),
+                0.0,
+            ),
+        ));
+    }
+}
+
+pub fn setup_walls(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    region: Res<PlayableArea>,
+) {
+    let thickness = 20.0;
+
+    for i in 0..4 {
+        let (offset, length) = if i % 2 == 0 {
+            (region.0, region.1 + thickness)
+        } else {
+            (region.1, region.0 + thickness)
+        };
+
+        let mut transform = Transform::from_xyz(0.0, offset / 2.0, 0.0);
+        transform.rotate_around(
+            Vec3::ZERO,
+            Quat::from_rotation_z(((i + 1) as f32) * PI / 2.0),
+        );
+
+        commands.spawn((
+            Wall,
+            Collider::rectangle(length, thickness),
+            Mesh2d(meshes.add(Rectangle::new(length, thickness))),
+            MeshMaterial2d(materials.add(Color::from(WHITE))),
+            transform,
+        ));
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..2b74344
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,55 @@
+use avian2d::{math::Vector, prelude::*};
+use bevy::{input::common_conditions::input_pressed, prelude::*};
+use bevy_rand::prelude::{EntropyPlugin, WyRand};
+use clap::Parser;
+
+mod game;
+use game::{
+    runtime::{move_camera, move_player, quit, zoom_camera},
+    seed::Seed,
+    setup::{setup_balls, setup_player, setup_pseudo_random, setup_ui, setup_walls},
+};
+
+#[derive(Parser)]
+#[command(version, about)]
+pub struct AppSettings {
+    #[arg(short, long, default_value = ":)")]
+    pub seed: Seed,
+}
+
+impl Plugin for AppSettings {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(Gravity(Vector::ZERO))
+            .insert_resource(self.seed.clone())
+            .add_plugins((
+                DefaultPlugins.set(WindowPlugin {
+                    primary_window: Window {
+                        title: "Distributed physics test".into(),
+                        fit_canvas_to_parent: true,
+                        ..default()
+                    }
+                    .into(),
+                    ..default()
+                }),
+                PhysicsPlugins::default().with_length_unit(50.0),
+                EntropyPlugin::<WyRand>::with_seed(self.seed.clone().into()),
+            ))
+            .add_systems(
+                Startup,
+                (
+                    setup_pseudo_random,
+                    setup_ui,
+                    (setup_player, setup_balls, setup_walls).after(setup_pseudo_random),
+                ),
+            )
+            .add_systems(
+                Update,
+                (
+                    move_player,
+                    quit.run_if(input_pressed(KeyCode::KeyQ)),
+                    zoom_camera,
+                ),
+            )
+            .add_systems(PostUpdate, move_camera);
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 78bfd8f..ffb5f8a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,224 +1,8 @@
-use std::{
-    f32::consts::PI,
-    hash::{DefaultHasher, Hash, Hasher},
-    ops::Range,
-};
-
-use avian2d::{math::Vector, prelude::*};
-use bevy::{
-    color::palettes::{
-        css::WHITE,
-        tailwind::{LIME_400, RED_400},
-    },
-    input::common_conditions::input_pressed,
-    prelude::*,
-};
-use bevy_rand::prelude::{EntropyPlugin, GlobalEntropy, WyRand};
+use bevy::prelude::{App, AppExit};
 use clap::Parser;
-use rand::Rng;
-use wyrand::WyRand as LocalRng;
 
-#[derive(Parser)]
-#[command(version, about)]
-struct AppSettings {
-    #[arg(short, long, default_value = "")]
-    seed: String,
-}
+use distributed_physics_test::AppSettings;
 
 fn main() -> AppExit {
-    run_app(AppSettings::parse())
-}
-
-const BALL_COUNT: u8 = 32;
-const BALL_SIZES: Range<f32> = 10.0..25.0;
-const DIMENSION_SIZES: Range<f32> = 500.0..2000.0;
-
-#[derive(Clone, Resource)]
-struct Seed(u64);
-
-impl From<String> for Seed {
-    fn from(value: String) -> Self {
-        Self(value.parse::<u64>().unwrap_or_else(|_| {
-            let mut state = DefaultHasher::new();
-            value.hash(&mut state);
-            state.finish()
-        }))
-    }
-}
-
-#[derive(Resource)]
-struct PlayableArea(f32, f32);
-
-#[derive(Resource)]
-struct PlayerSize(f32);
-
-fn run_app(settings: AppSettings) -> AppExit {
-    let seed = Seed::from(settings.seed);
-    App::new()
-        .add_plugins((
-            DefaultPlugins.set(WindowPlugin {
-                primary_window: Window {
-                    title: "Distributed physics test".into(),
-                    fit_canvas_to_parent: true,
-                    ..default()
-                }
-                .into(),
-                ..default()
-            }),
-            PhysicsPlugins::default().with_length_unit(50.0),
-            EntropyPlugin::<WyRand>::with_seed(seed.0.to_le_bytes()), // TODO: Tried to make an Into<[u8; 8]> for this but it wants to consume the value
-        ))
-        .add_systems(
-            Startup,
-            (
-                setup_pseudo_random,
-                setup_ui,
-                (setup_player, setup_balls, setup_walls).after(setup_pseudo_random),
-            ),
-        )
-        .add_systems(
-            Update,
-            (move_player, quit.run_if(input_pressed(KeyCode::KeyQ))),
-        )
-        .add_systems(PostUpdate, move_camera)
-        .insert_resource(Gravity(Vector::ZERO))
-        .insert_resource(seed)
-        .run()
-}
-
-fn setup_pseudo_random(mut commands: Commands, mut rng: GlobalEntropy<WyRand>) {
-    commands.insert_resource(PlayerSize(rng.random_range(BALL_SIZES)));
-    commands.insert_resource(PlayableArea(
-        rng.random_range(DIMENSION_SIZES),
-        rng.random_range(DIMENSION_SIZES),
-    ));
-}
-
-fn setup_ui(mut commands: Commands) {
-    commands.spawn((Name::new("Camera"), Camera2d, IsDefaultUiCamera));
-}
-
-#[derive(Component, Default)]
-#[require(Collider, Mesh2d, MeshMaterial2d<ColorMaterial>, Restitution = Restitution::new(1.0), RigidBody, TransformInterpolation, Transform)]
-struct GameObject;
-
-#[derive(Component, Default)]
-#[require(GameObject, RigidBody = RigidBody::Dynamic)]
-struct Ball;
-
-#[derive(Component, Default)]
-#[require(Ball)]
-struct Player;
-
-fn setup_player(
-    mut commands: Commands,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    radius: Res<PlayerSize>,
-) {
-    let circle = Circle::new(radius.0);
-    commands.spawn((
-        Player,
-        Collider::from(circle),
-        Mesh2d(meshes.add(circle)),
-        MeshMaterial2d(materials.add(Color::from(LIME_400))),
-    ));
-}
-
-fn setup_balls(
-    mut commands: Commands,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    region: Res<PlayableArea>,
-) {
-    let mut random = LocalRng::new(Default::default());
-    for _ in 0..BALL_COUNT {
-        let circle = Circle::new(random.random_range(BALL_SIZES));
-        commands.spawn((
-            Ball,
-            Collider::from(circle),
-            Mesh2d(meshes.add(circle)),
-            MeshMaterial2d(materials.add(Color::from(RED_400))),
-            Transform::from_xyz(
-                random.random_range(
-                    (-region.0 / 2.0 + circle.radius)..(region.0 / 2.0 - circle.radius),
-                ),
-                random.random_range(
-                    (-region.1 / 2.0 + circle.radius)..(region.1 / 2.0 - circle.radius),
-                ),
-                0.0,
-            ),
-        ));
-    }
-}
-
-#[derive(Component, Default)]
-#[require(GameObject, RigidBody = RigidBody::Static)]
-struct Wall;
-
-fn setup_walls(
-    mut commands: Commands,
-    mut materials: ResMut<Assets<ColorMaterial>>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    region: Res<PlayableArea>,
-) {
-    let thickness = 20.0;
-
-    for i in 0..4 {
-        let (offset, length) = if i % 2 == 0 {
-            (region.0, region.1 + thickness)
-        } else {
-            (region.1, region.0 + thickness)
-        };
-
-        let mut transform = Transform::from_xyz(0.0, offset / 2.0, 0.0);
-        transform.rotate_around(
-            Vec3::ZERO,
-            Quat::from_rotation_z(((i + 1) as f32) * PI / 2.0),
-        );
-
-        commands.spawn((
-            Wall,
-            Collider::rectangle(length, thickness),
-            Mesh2d(meshes.add(Rectangle::new(length, thickness))),
-            MeshMaterial2d(materials.add(Color::from(WHITE))),
-            transform,
-        ));
-    }
-}
-
-fn move_player(
-    time: Res<Time>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut velocity: Single<&mut LinearVelocity, With<Player>>,
-) -> Result {
-    let acceleration = 500.0;
-
-    let delta_time = time.delta_secs();
-
-    if keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]) {
-        velocity.y += acceleration * delta_time;
-    }
-    if keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]) {
-        velocity.y -= acceleration * delta_time;
-    }
-    if keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]) {
-        velocity.x -= acceleration * delta_time;
-    }
-    if keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]) {
-        velocity.x += acceleration * delta_time;
-    }
-
-    Ok(())
-}
-
-fn quit(mut exit: EventWriter<AppExit>) {
-    exit.write(AppExit::Success);
-}
-
-fn move_camera(
-    mut camera: Single<&mut Transform, (Without<Player>, With<IsDefaultUiCamera>)>,
-    player: Single<&Transform, (With<Player>, Without<IsDefaultUiCamera>)>,
-) {
-    camera.translation = camera.translation.lerp(player.translation, 0.05);
+    App::new().add_plugins(AppSettings::parse()).run()
 }