diff --git a/Cargo.lock b/Cargo.lock
index 03f77a2e..a7082fe4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -685,20 +685,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "bot"
-version = "0.2.0"
-dependencies = [
- "anyhow",
- "azalea",
- "azalea-protocol",
- "env_logger 0.9.3",
- "parking_lot",
- "rand",
- "tokio",
- "uuid",
-]
-
 [[package]]
 name = "bstr"
 version = "0.2.17"
diff --git a/Cargo.toml b/Cargo.toml
index 6c3ed34c..febe6517 100755
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,5 @@
 [workspace]
 members = [
-  "bot",
   "azalea",
   "azalea-client",
   "azalea-protocol",
diff --git a/bot/Cargo.toml b/bot/Cargo.toml
deleted file mode 100644
index b3eeaf22..00000000
--- a/bot/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-edition = "2021"
-name = "bot"
-publish = false
-release = false
-version = "0.2.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-anyhow = "1.0.65"
-azalea = {path = "../azalea"}
-azalea-protocol = {path = "../azalea-protocol"}
-env_logger = "0.9.1"
-parking_lot = {version = "^0.12.1", features = ["deadlock_detection"]}
-rand = "0.8.5"
-tokio = "1.24.2"
-uuid = "1.1.2"
diff --git a/bot/src/main.rs b/bot/src/main.rs
deleted file mode 100644
index f748de0b..00000000
--- a/bot/src/main.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-#![feature(type_alias_impl_trait)]
-
-use azalea::ecs::query::With;
-use azalea::entity::metadata::Player;
-use azalea::entity::Position;
-use azalea::pathfinder::BlockPosGoal;
-// use azalea::ClientInformation;
-use azalea::{prelude::*, BlockPos, GameProfileComponent, Swarm, SwarmEvent, WalkDirection};
-use azalea::{Account, Client, Event};
-use azalea_protocol::packets::game::serverbound_client_command_packet::ServerboundClientCommandPacket;
-use std::time::Duration;
-
-#[derive(Default, Clone, Component)]
-struct State {}
-
-#[derive(Default, Clone, Component)]
-struct SwarmState {}
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    env_logger::init();
-
-    {
-        use parking_lot::deadlock;
-        use std::thread;
-        use std::time::Duration;
-
-        // Create a background thread which checks for deadlocks every 10s
-        thread::spawn(move || loop {
-            thread::sleep(Duration::from_secs(10));
-            let deadlocks = deadlock::check_deadlock();
-            if deadlocks.is_empty() {
-                continue;
-            }
-
-            println!("{} deadlocks detected", deadlocks.len());
-            for (i, threads) in deadlocks.iter().enumerate() {
-                println!("Deadlock #{i}");
-                for t in threads {
-                    println!("Thread Id {:#?}", t.thread_id());
-                    println!("{:#?}", t.backtrace());
-                }
-            }
-        });
-    }
-
-    let mut accounts = Vec::new();
-    let mut states = Vec::new();
-
-    for i in 0..1 {
-        accounts.push(Account::offline(&format!("bot{i}")));
-        states.push(State::default());
-    }
-
-    loop {
-        let e = azalea::SwarmBuilder::new()
-            .add_accounts(accounts.clone())
-            .set_handler(handle)
-            .set_swarm_handler(swarm_handle)
-            .join_delay(Duration::from_millis(1000))
-            .start("localhost")
-            .await;
-        // let e = azalea::ClientBuilder::new()
-        //     .set_handler(handle)
-        //     .start(Account::offline("bot"), "localhost")
-        //     .await;
-        println!("{e:?}");
-    }
-}
-
-async fn handle(mut bot: Client, event: Event, _state: State) -> anyhow::Result<()> {
-    match event {
-        Event::Init => {
-            println!("bot init");
-            // bot.set_client_information(ClientInformation {
-            //     view_distance: 2,
-            //     ..Default::default()
-            // })
-            // .await?;
-        }
-        Event::Login => {
-            bot.chat("Hello world");
-        }
-        Event::Chat(m) => {
-            println!("client chat message: {}", m.content());
-            if m.content() == bot.profile.name {
-                bot.chat("Bye");
-                tokio::time::sleep(Duration::from_millis(50)).await;
-                bot.disconnect();
-            }
-            let Some(sender) = m.username() else {
-                return Ok(())
-            };
-            // let mut ecs = bot.ecs.lock();
-            // let entity = bot
-            //     .ecs
-            //     .lock()
-            //     .query::<&Player>()
-            //     .iter(&mut ecs)
-            //     .find(|e| e.name() == Some(sender));
-            // let entity = bot.entity_by::<With<Player>>(|name: &Name| name == sender);
-            let entity = bot.entity_by::<With<Player>, (&GameProfileComponent,)>(
-                |profile: &&GameProfileComponent| {
-                    println!("entity {profile:?}");
-                    profile.name == sender
-                },
-            );
-            println!("sender entity: {entity:?}");
-            if let Some(entity) = entity {
-                match m.content().as_str() {
-                    "whereami" => {
-                        let pos = bot.entity_component::<Position>(entity);
-                        bot.chat(&format!("You're at {pos:?}",));
-                    }
-                    "whereareyou" => {
-                        let pos = bot.component::<Position>();
-                        bot.chat(&format!("I'm at {pos:?}",));
-                    }
-                    "goto" => {
-                        let entity_pos = bot.entity_component::<Position>(entity);
-                        let target_pos: BlockPos = entity_pos.into();
-                        println!("going to {target_pos:?}");
-                        bot.goto(BlockPosGoal::from(target_pos));
-                    }
-                    "look" => {
-                        let entity_pos = bot.entity_component::<Position>(entity);
-                        let target_pos: BlockPos = entity_pos.into();
-                        println!("target_pos: {target_pos:?}");
-                        bot.look_at(target_pos.center());
-                    }
-                    "jump" => {
-                        bot.set_jumping(true);
-                    }
-                    "walk" => {
-                        bot.walk(WalkDirection::Forward);
-                    }
-                    "stop" => {
-                        bot.set_jumping(false);
-                        bot.walk(WalkDirection::None);
-                    }
-                    "lag" => {
-                        std::thread::sleep(Duration::from_millis(1000));
-                    }
-                    _ => {}
-                }
-            }
-        }
-        Event::Death(_) => {
-            bot.write_packet(ServerboundClientCommandPacket {
-                action: azalea_protocol::packets::game::serverbound_client_command_packet::Action::PerformRespawn,
-            }.get());
-        }
-        _ => {}
-    }
-
-    Ok(())
-}
-
-async fn swarm_handle(
-    mut swarm: Swarm,
-    event: SwarmEvent,
-    _state: SwarmState,
-) -> anyhow::Result<()> {
-    match &event {
-        SwarmEvent::Disconnect(account) => {
-            println!("bot got kicked! {}", account.username);
-            tokio::time::sleep(Duration::from_secs(5)).await;
-            swarm.add(account, State::default()).await?;
-        }
-        SwarmEvent::Chat(m) => {
-            println!("swarm chat message: {}", m.message().to_ansi());
-            if m.message().to_string() == "<py5> world" {
-                for (name, world) in &swarm.world_container.read().worlds {
-                    println!("world name: {name}");
-                    if let Some(w) = world.upgrade() {
-                        for chunk_pos in w.read().chunks.chunks.values() {
-                            println!("chunk: {chunk_pos:?}");
-                        }
-                    } else {
-                        println!("nvm world is gone");
-                    }
-                }
-            }
-            if m.message().to_string() == "<py5> hi" {
-                for bot in swarm {
-                    bot.chat("hello");
-                }
-            }
-        }
-        _ => {}
-    }
-    Ok(())
-}