Merge branch 'main' into chunk-decoding

21 files changed, 373 insertions, 647 deletions

diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
index d50817fb..a61ad3c3 100755
--- a/azalea-protocol/src/mc_buf/mod.rs
+++ b/azalea-protocol/src/mc_buf/mod.rs
@@ -4,7 +4,7 @@ mod read;
 mod write;
 
 use packet_macros::{McBufReadable, McBufWritable};
-pub use read::{McBufReadable, McBufVarintReadable, Readable};
+pub use read::{read_varint_async, McBufReadable, McBufVarintReadable, Readable};
 use std::ops::{Deref, Index};
 pub use write::{McBufVarintWritable, McBufWritable, Writable};
 
@@ -56,7 +56,6 @@ mod tests {
     use super::*;
     use azalea_core::resource_location::ResourceLocation;
     use std::{collections::HashMap, io::Cursor};
-    use tokio::io::BufReader;
 
     #[test]
     fn test_write_varint() {
@@ -105,91 +104,91 @@ mod tests {
         assert_eq!(buf, vec![128, 128, 128, 128, 8]);
     }
 
-    #[tokio::test]
-    async fn test_read_varint() {
-        let mut buf = BufReader::new(Cursor::new(vec![0]));
-        assert_eq!(buf.read_varint().await.unwrap(), 0);
+    #[test]
+    fn test_read_varint() {
+        let mut buf = Cursor::new(vec![0]);
+        assert_eq!(buf.read_varint().unwrap(), 0);
         assert_eq!(buf.get_varint_size(0), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 1);
+        let mut buf = Cursor::new(vec![1]);
+        assert_eq!(buf.read_varint().unwrap(), 1);
         assert_eq!(buf.get_varint_size(1), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![2]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2);
+        let mut buf = Cursor::new(vec![2]);
+        assert_eq!(buf.read_varint().unwrap(), 2);
         assert_eq!(buf.get_varint_size(2), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![127]));
-        assert_eq!(buf.read_varint().await.unwrap(), 127);
+        let mut buf = Cursor::new(vec![127]);
+        assert_eq!(buf.read_varint().unwrap(), 127);
         assert_eq!(buf.get_varint_size(127), 1);
 
-        let mut buf = BufReader::new(Cursor::new(vec![128, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 128);
+        let mut buf = Cursor::new(vec![128, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 128);
         assert_eq!(buf.get_varint_size(128), 2);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 255);
+        let mut buf = Cursor::new(vec![255, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 255);
         assert_eq!(buf.get_varint_size(255), 2);
 
-        let mut buf = BufReader::new(Cursor::new(vec![221, 199, 1]));
-        assert_eq!(buf.read_varint().await.unwrap(), 25565);
+        let mut buf = Cursor::new(vec![221, 199, 1]);
+        assert_eq!(buf.read_varint().unwrap(), 25565);
         assert_eq!(buf.get_varint_size(25565), 3);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 127]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2097151);
+        let mut buf = Cursor::new(vec![255, 255, 127]);
+        assert_eq!(buf.read_varint().unwrap(), 2097151);
         assert_eq!(buf.get_varint_size(2097151), 3);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 255, 255, 7]));
-        assert_eq!(buf.read_varint().await.unwrap(), 2147483647);
+        let mut buf = Cursor::new(vec![255, 255, 255, 255, 7]);
+        assert_eq!(buf.read_varint().unwrap(), 2147483647);
         assert_eq!(buf.get_varint_size(2147483647), 5);
 
-        let mut buf = BufReader::new(Cursor::new(vec![255, 255, 255, 255, 15]));
-        assert_eq!(buf.read_varint().await.unwrap(), -1);
+        let mut buf = Cursor::new(vec![255, 255, 255, 255, 15]);
+        assert_eq!(buf.read_varint().unwrap(), -1);
         assert_eq!(buf.get_varint_size(-1), 5);
 
-        let mut buf = BufReader::new(Cursor::new(vec![128, 128, 128, 128, 8]));
-        assert_eq!(buf.read_varint().await.unwrap(), -2147483648);
+        let mut buf = Cursor::new(vec![128, 128, 128, 128, 8]);
+        assert_eq!(buf.read_varint().unwrap(), -2147483648);
         assert_eq!(buf.get_varint_size(-2147483648), 5);
     }
 
-    #[tokio::test]
-    async fn test_read_varint_longer() {
-        let mut buf = BufReader::new(Cursor::new(vec![138, 56, 0, 135, 56, 123]));
-        assert_eq!(buf.read_varint().await.unwrap(), 7178);
+    #[test]
+    fn test_read_varint_longer() {
+        let mut buf = Cursor::new(vec![138, 56, 0, 135, 56, 123]);
+        assert_eq!(buf.read_varint().unwrap(), 7178);
     }
 
-    #[tokio::test]
-    async fn test_list() {
+    #[test]
+    fn test_list() {
         let mut buf = Vec::new();
         buf.write_list(&vec!["a", "bc", "def"], |buf, s| buf.write_utf(s))
             .unwrap();
 
         // there's no read_list because idk how to do it in rust
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         let mut result = Vec::new();
-        let length = buf.read_varint().await.unwrap();
+        let length = buf.read_varint().unwrap();
         for _ in 0..length {
-            result.push(buf.read_utf().await.unwrap());
+            result.push(buf.read_utf().unwrap());
         }
 
         assert_eq!(result, vec!["a", "bc", "def"]);
     }
 
-    #[tokio::test]
-    async fn test_int_id_list() {
+    #[test]
+    fn test_int_id_list() {
         let mut buf = Vec::new();
         buf.write_list(&vec![1, 2, 3], |buf, i| buf.write_varint(*i))
             .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        let result = buf.read_int_id_list().await.unwrap();
+        let result = buf.read_int_id_list().unwrap();
         assert_eq!(result, vec![1, 2, 3]);
     }
 
-    #[tokio::test]
-    async fn test_map() {
+    #[test]
+    fn test_map() {
         let mut buf = Vec::new();
         buf.write_map(
             vec![("a", 1), ("bc", 23), ("def", 456)],
@@ -198,15 +197,12 @@ mod tests {
         )
         .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         let mut result = Vec::new();
-        let length = buf.read_varint().await.unwrap();
+        let length = buf.read_varint().unwrap();
         for _ in 0..length {
-            result.push((
-                buf.read_utf().await.unwrap(),
-                buf.read_varint().await.unwrap(),
-            ));
+            result.push((buf.read_utf().unwrap(), buf.read_varint().unwrap()));
         }
 
         assert_eq!(
@@ -219,8 +215,8 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_nbt() {
+    #[test]
+    fn test_nbt() {
         let mut buf = Vec::new();
         buf.write_nbt(&azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
             "hello world".to_string(),
@@ -231,9 +227,9 @@ mod tests {
         )])))
         .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        let result = buf.read_nbt().await.unwrap();
+        let result = buf.read_nbt().unwrap();
         assert_eq!(
             result,
             azalea_nbt::Tag::Compound(HashMap::from_iter(vec![(
@@ -246,26 +242,26 @@ mod tests {
         );
     }
 
-    #[tokio::test]
-    async fn test_long() {
+    #[test]
+    fn test_long() {
         let mut buf = Vec::new();
         buf.write_long(123456).unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
-        assert_eq!(buf.read_long().await.unwrap(), 123456);
+        assert_eq!(buf.read_long().unwrap(), 123456);
     }
 
-    #[tokio::test]
-    async fn test_resource_location() {
+    #[test]
+    fn test_resource_location() {
         let mut buf = Vec::new();
         buf.write_resource_location(&ResourceLocation::new("minecraft:dirt").unwrap())
             .unwrap();
 
-        let mut buf = BufReader::new(Cursor::new(buf));
+        let mut buf = Cursor::new(buf);
 
         assert_eq!(
-            buf.read_resource_location().await.unwrap(),
+            buf.read_resource_location().unwrap(),
             ResourceLocation::new("minecraft:dirt").unwrap()
         );
     }
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index 53c137b3..68c9cb3f 100755
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -1,60 +1,57 @@
-use async_trait::async_trait;
+use super::{BitSet, UnsizedByteArray, MAX_STRING_LENGTH};
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
     serializable_uuid::SerializableUuid, BlockPos, Direction, Slot, SlotData,
 };
+use byteorder::{ReadBytesExt, WriteBytesExt, BE};
 use serde::Deserialize;
+use std::io::Read;
 use tokio::io::{AsyncRead, AsyncReadExt};
 use uuid::Uuid;
 
-use super::{BitSet, UnsizedByteArray, MAX_STRING_LENGTH};
-
-#[async_trait]
 pub trait Readable {
-    async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String>;
-    async fn read_varint(&mut self) -> Result<i32, String>;
+    fn read_int_id_list(&mut self) -> Result<Vec<i32>, String>;
+    fn read_varint(&mut self) -> Result<i32, String>;
     fn get_varint_size(&mut self, value: i32) -> u8;
     fn get_varlong_size(&mut self, value: i32) -> u8;
-    async fn read_byte_array(&mut self) -> Result<Vec<u8>, String>;
-    async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String>;
-    async fn read_bytes(&mut self) -> Result<Vec<u8>, String>;
-    async fn read_utf(&mut self) -> Result<String, String>;
-    async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String>;
-    async fn read_byte(&mut self) -> Result<u8, String>;
-    async fn read_int(&mut self) -> Result<i32, String>;
-    async fn read_boolean(&mut self) -> Result<bool, String>;
-    async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String>;
-    async fn read_long(&mut self) -> Result<i64, String>;
-    async fn read_resource_location(&mut self) -> Result<ResourceLocation, String>;
-    async fn read_short(&mut self) -> Result<i16, String>;
-    async fn read_float(&mut self) -> Result<f32, String>;
-    async fn read_double(&mut self) -> Result<f64, String>;
-    async fn read_uuid(&mut self) -> Result<Uuid, String>;
-}
-
-#[async_trait]
+    fn read_byte_array(&mut self) -> Result<Vec<u8>, String>;
+    fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String>;
+    fn read_bytes(&mut self) -> Result<Vec<u8>, String>;
+    fn read_utf(&mut self) -> Result<String, String>;
+    fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String>;
+    fn read_byte(&mut self) -> Result<u8, String>;
+    fn read_int(&mut self) -> Result<i32, String>;
+    fn read_boolean(&mut self) -> Result<bool, String>;
+    fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String>;
+    fn read_long(&mut self) -> Result<i64, String>;
+    fn read_resource_location(&mut self) -> Result<ResourceLocation, String>;
+    fn read_short(&mut self) -> Result<i16, String>;
+    fn read_float(&mut self) -> Result<f32, String>;
+    fn read_double(&mut self) -> Result<f64, String>;
+    fn read_uuid(&mut self) -> Result<Uuid, String>;
+}
+
 impl<R> Readable for R
 where
-    R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    R: Read,
 {
-    async fn read_int_id_list(&mut self) -> Result<Vec<i32>, String> {
-        let len = self.read_varint().await?;
+    fn read_int_id_list(&mut self) -> Result<Vec<i32>, String> {
+        let len = self.read_varint()?;
         let mut list = Vec::with_capacity(len as usize);
         for _ in 0..len {
-            list.push(self.read_varint().await?);
+            list.push(self.read_varint()?);
         }
         Ok(list)
     }
 
     // fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67
     /// Read a single varint from the reader and return the value, along with the number of bytes read
-    async fn read_varint(&mut self) -> Result<i32, String> {
+    fn read_varint(&mut self) -> Result<i32, String> {
         let mut buffer = [0];
         let mut ans = 0;
         for i in 0..5 {
             self.read_exact(&mut buffer)
-                .await
                 .map_err(|_| "Invalid VarInt".to_string())?;
             ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
             if buffer[0] & 0b1000_0000 == 0 {
@@ -84,34 +81,32 @@ where
         10
     }
 
-    async fn read_byte_array(&mut self) -> Result<Vec<u8>, String> {
-        let length = self.read_varint().await? as usize;
-        self.read_bytes_with_len(length).await
+    fn read_byte_array(&mut self) -> Result<Vec<u8>, String> {
+        let length = self.read_varint()? as usize;
+        self.read_bytes_with_len(length)
     }
 
-    async fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String> {
-        let mut bytes = vec![0; n];
-        match AsyncReadExt::read_exact(self, &mut bytes).await {
-            Ok(_) => Ok(bytes),
-            Err(_) => Err("Error reading bytes".to_string()),
-        }
+    fn read_bytes_with_len(&mut self, n: usize) -> Result<Vec<u8>, String> {
+        let mut buffer = vec![0; n];
+        self.read_exact(&mut buffer)
+            .map_err(|_| "Error reading bytes".to_string())?;
+        Ok(buffer)
     }
 
-    async fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
+    fn read_bytes(&mut self) -> Result<Vec<u8>, String> {
         // read to end of the buffer
         let mut bytes = vec![];
-        AsyncReadExt::read_to_end(self, &mut bytes)
-            .await
+        self.read_to_end(&mut bytes)
             .map_err(|_| "Error reading bytes".to_string())?;
         Ok(bytes)
     }
 
-    async fn read_utf(&mut self) -> Result<String, String> {
-        self.read_utf_with_len(MAX_STRING_LENGTH.into()).await
+    fn read_utf(&mut self) -> Result<String, String> {
+        self.read_utf_with_len(MAX_STRING_LENGTH.into())
     }
 
-    async fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String> {
-        let length = self.read_varint().await?;
+    fn read_utf_with_len(&mut self, max_length: u32) -> Result<String, String> {
+        let length = self.read_varint()?;
         // i don't know why it's multiplied by 4 but it's like that in mojang's code so
         if length < 0 {
             return Err(
@@ -131,7 +126,6 @@ where
         let mut string = String::new();
         let mut buffer = vec![0; length as usize];
         self.read_exact(&mut buffer)
-            .await
             .map_err(|_| "Invalid UTF-8".to_string())?;
         string.push_str(std::str::from_utf8(&buffer).unwrap());
         if string.len() > length as usize {
@@ -145,342 +139,263 @@ where
     }
 
     /// Read a single byte from the reader
-    async fn read_byte(&mut self) -> Result<u8, String> {
-        match AsyncReadExt::read_u8(self).await {
-            Ok(r) => Ok(r),
-            Err(_) => Err("Error reading byte".to_string()),
-        }
+    fn read_byte(&mut self) -> Result<u8, String> {
+        self.read_u8().map_err(|_| "Error reading byte".to_string())
     }
 
-    async fn read_int(&mut self) -> Result<i32, String> {
-        match AsyncReadExt::read_i32(self).await {
+    fn read_int(&mut self) -> Result<i32, String> {
+        match self.read_i32::<BE>() {
             Ok(r) => Ok(r),
             Err(_) => Err("Error reading int".to_string()),
         }
     }
 
-    async fn read_boolean(&mut self) -> Result<bool, String> {
-        match self.read_byte().await {
-            Ok(0) => Ok(false),
-            Ok(1) => Ok(true),
+    fn read_boolean(&mut self) -> Result<bool, String> {
+        match self.read_byte()? {
+            0 => Ok(false),
+            1 => Ok(true),
             _ => Err("Error reading boolean".to_string()),
         }
     }
 
-    async fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String> {
-        match azalea_nbt::Tag::read(self).await {
+    fn read_nbt(&mut self) -> Result<azalea_nbt::Tag, String> {
+        match azalea_nbt::Tag::read(self) {
             Ok(r) => Ok(r),
             // Err(e) => Err(e.to_string()),
             Err(e) => Err(e.to_string()).unwrap(),
         }
     }
 
-    async fn read_long(&mut self) -> Result<i64, String> {
-        match AsyncReadExt::read_i64(self).await {
+    fn read_long(&mut self) -> Result<i64, String> {
+        match self.read_i64::<BE>() {
             Ok(r) => Ok(r),
             Err(_) => Err("Error reading long".to_string()),
         }
     }
 
-    async fn read_resource_location(&mut self) -> Result<ResourceLocation, String> {
+    fn read_resource_location(&mut self) -> Result<ResourceLocation, String> {
         // get the resource location from the string
-        let location_string = self.read_utf().await?;
+        let location_string = self.read_utf()?;
         let location = ResourceLocation::new(&location_string)?;
         Ok(location)
     }
 
-    async fn read_short(&mut self) -> Result<i16, String> {
-        match AsyncReadExt::read_i16(self).await {
+    fn read_short(&mut self) -> Result<i16, String> {
+        match self.read_i16::<BE>() {
             Ok(r) => Ok(r),
             Err(_) => Err("Error reading short".to_string()),
         }
     }
 
-    async fn read_float(&mut self) -> Result<f32, String> {
-        match AsyncReadExt::read_f32(self).await {
+    fn read_float(&mut self) -> Result<f32, String> {
+        match self.read_f32::<BE>() {
             Ok(r) => Ok(r),
             Err(_) => Err("Error reading float".to_string()),
         }
     }
 
-    async fn read_double(&mut self) -> Result<f64, String> {
-        match AsyncReadExt::read_f64(self).await {
+    fn read_double(&mut self) -> Result<f64, String> {
+        match self.read_f64::<BE>() {
             Ok(r) => Ok(r),
             Err(_) => Err("Error reading double".to_string()),
         }
     }
 
-    async fn read_uuid(&mut self) -> Result<Uuid, String> {
+    fn read_uuid(&mut self) -> Result<Uuid, String> {
         Ok(Uuid::from_int_array([
-            self.read_int().await? as u32,
-            self.read_int().await? as u32,
-            self.read_int().await? as u32,
-            self.read_int().await? as u32,
+            Readable::read_int(self)? as u32,
+            Readable::read_int(self)? as u32,
+            Readable::read_int(self)? as u32,
+            Readable::read_int(self)? as u32,
         ]))
     }
 }
 
-#[async_trait]
+// fast varints modified from https://github.com/luojia65/mc-varint/blob/master/src/lib.rs#L67
+/// Read a single varint from the reader and return the value, along with the number of bytes read
+pub async fn read_varint_async(reader: &mut (dyn AsyncRead + Unpin + Send)) -> Result<i32, String> {
+    let mut buffer = [0];
+    let mut ans = 0;
+    for i in 0..5 {
+        reader
+            .read_exact(&mut buffer)
+            .await
+            .map_err(|_| "Invalid VarInt".to_string())?;
+        ans |= ((buffer[0] & 0b0111_1111) as i32) << (7 * i);
+        if buffer[0] & 0b1000_0000 == 0 {
+            return Ok(ans);
+        }
+    }
+    Ok(ans)
+}
+
 pub trait McBufReadable
 where
     Self: Sized,
 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String>;
 }
 
-#[async_trait]
 pub trait McBufVarintReadable
 where
     Self: Sized,
 {
-    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send;
+    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String>;
 }
 
-#[async_trait]
 impl McBufReadable for i32 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_int().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        Readable::read_int(buf)
     }
 }
 
-#[async_trait]
 impl McBufVarintReadable for i32 {
-    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_varint().await
+    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_varint()
     }
 }
 
-#[async_trait]
 impl McBufReadable for UnsizedByteArray {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        Ok(UnsizedByteArray(buf.read_bytes().await?))
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        Ok(UnsizedByteArray(buf.read_bytes()?))
     }
 }
 
-#[async_trait]
 impl<T: McBufReadable + Send> McBufReadable for Vec<T> {
-    default async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let length = buf.read_varint().await? as usize;
+    default fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let length = buf.read_varint()? as usize;
         let mut contents = Vec::with_capacity(length);
         for _ in 0..length {
-            contents.push(T::read_into(buf).await?);
+            contents.push(T::read_into(buf)?);
         }
         Ok(contents)
     }
 }
 
-#[async_trait]
 impl McBufReadable for Vec<u8> {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_byte_array().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_byte_array()
     }
 }
 
 // string
-#[async_trait]
 impl McBufReadable for String {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_utf().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_utf()
     }
 }
 
 // ResourceLocation
-#[async_trait]
 impl McBufReadable for ResourceLocation {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_resource_location().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_resource_location()
     }
 }
 
 // u32
-#[async_trait]
 impl McBufReadable for u32 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_int().await.map(|i| i as u32)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        Readable::read_int(buf).map(|i| i as u32)
     }
 }
 
 // u32 varint
-#[async_trait]
 impl McBufVarintReadable for u32 {
-    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_varint().await.map(|i| i as u32)
+    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_varint().map(|i| i as u32)
     }
 }
 
 // u16
-#[async_trait]
 impl McBufReadable for u16 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_short().await.map(|i| i as u16)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_short().map(|i| i as u16)
     }
 }
 
 // i16
-#[async_trait]
 impl McBufReadable for i16 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_short().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_short()
     }
 }
 
 // u16 varint
-#[async_trait]
 impl McBufVarintReadable for u16 {
-    async fn varint_read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_varint().await.map(|i| i as u16)
+    fn varint_read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_varint().map(|i| i as u16)
     }
 }
 
 // i64
-#[async_trait]
 impl McBufReadable for i64 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_long().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_long()
     }
 }
 
 // u64
-#[async_trait]
 impl McBufReadable for u64 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        i64::read_into(buf).await.map(|i| i as u64)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        i64::read_into(buf).map(|i| i as u64)
     }
 }
 
 // bool
-#[async_trait]
 impl McBufReadable for bool {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_boolean().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_boolean()
     }
 }
 
 // u8
-#[async_trait]
 impl McBufReadable for u8 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_byte().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_byte()
     }
 }
 
 // i8
-#[async_trait]
 impl McBufReadable for i8 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_byte().await.map(|i| i as i8)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_byte().map(|i| i as i8)
     }
 }
 
 // f32
-#[async_trait]
 impl McBufReadable for f32 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_float().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_float()
     }
 }
 
 // f64
-#[async_trait]
 impl McBufReadable for f64 {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_double().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_double()
     }
 }
 
 // GameType
-#[async_trait]
 impl McBufReadable for GameType {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        GameType::from_id(buf.read_byte().await?)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        GameType::from_id(buf.read_byte()?)
     }
 }
 
 // Option<GameType>
-#[async_trait]
 impl McBufReadable for Option<GameType> {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        GameType::from_optional_id(buf.read_byte().await? as i8)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        GameType::from_optional_id(buf.read_byte()? as i8)
     }
 }
 
 // Option<String>
-#[async_trait]
 impl<T: McBufReadable> McBufReadable for Option<T> {
-    default async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let present = buf.read_boolean().await?;
+    default fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let present = buf.read_boolean()?;
         Ok(if present {
-            Some(T::read_into(buf).await?)
+            Some(T::read_into(buf)?)
         } else {
             None
         })
@@ -488,35 +403,23 @@ impl<T: McBufReadable> McBufReadable for Option<T> {
 }
 
 // azalea_nbt::Tag
-#[async_trait]
 impl McBufReadable for azalea_nbt::Tag {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_nbt().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_nbt()
     }
 }
 
 // Difficulty
-#[async_trait]
 impl McBufReadable for Difficulty {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        Ok(Difficulty::by_id(u8::read_into(buf).await?))
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        Ok(Difficulty::by_id(u8::read_into(buf)?))
     }
 }
 
 // Component
-#[async_trait]
 impl McBufReadable for Component {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let string = buf.read_utf().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let string = buf.read_utf()?;
         let json: serde_json::Value = serde_json::from_str(string.as_str())
             .map_err(|e| "Component isn't valid JSON".to_string())?;
         let component = Component::deserialize(json).map_err(|e| e.to_string())?;
@@ -525,42 +428,30 @@ impl McBufReadable for Component {
 }
 
 // Slot
-#[async_trait]
 impl McBufReadable for Slot {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let present = buf.read_boolean().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let present = buf.read_boolean()?;
         if !present {
             return Ok(Slot::Empty);
         }
-        let id = buf.read_varint().await?;
-        let count = buf.read_byte().await?;
-        let nbt = buf.read_nbt().await?;
+        let id = buf.read_varint()?;
+        let count = buf.read_byte()?;
+        let nbt = buf.read_nbt()?;
         Ok(Slot::Present(SlotData { id, count, nbt }))
     }
 }
 
 // Uuid
-#[async_trait]
 impl McBufReadable for Uuid {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        buf.read_uuid().await
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        buf.read_uuid()
     }
 }
 
 // BlockPos
-#[async_trait]
 impl McBufReadable for BlockPos {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let val = u64::read_into(buf).await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let val = u64::read_into(buf)?;
         let x = (val >> 38) as i32;
         let y = (val & 0xFFF) as i32;
         let z = ((val >> 12) & 0x3FFFFFF) as i32;
@@ -569,13 +460,9 @@ impl McBufReadable for BlockPos {
 }
 
 // Direction
-#[async_trait]
 impl McBufReadable for Direction {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        match buf.read_varint().await? {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        match buf.read_varint()? {
             0 => Ok(Self::Down),
             1 => Ok(Self::Up),
             2 => Ok(Self::North),
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
index e5437ae8..57ec3a48 100755
--- a/azalea-protocol/src/mc_buf/write.rs
+++ b/azalea-protocol/src/mc_buf/write.rs
@@ -1,5 +1,4 @@
 use super::{UnsizedByteArray, MAX_STRING_LENGTH};
-use async_trait::async_trait;
 use azalea_chat::component::Component;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
@@ -9,7 +8,6 @@ use byteorder::{BigEndian, WriteBytesExt};
 use std::io::Write;
 use uuid::Uuid;
 
-#[async_trait]
 pub trait Writable {
     fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
     where
@@ -48,7 +46,6 @@ pub trait Writable {
     fn write_uuid(&mut self, uuid: &Uuid) -> Result<(), std::io::Error>;
 }
 
-#[async_trait]
 impl Writable for Vec<u8> {
     fn write_list<F, T>(&mut self, list: &[T], writer: F) -> Result<(), std::io::Error>
     where
@@ -363,9 +360,8 @@ impl McBufWritable for Difficulty {
 }
 
 // Component
-#[async_trait]
 impl McBufWritable for Component {
-    // async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    // async fn read_into(buf: &mut impl Read) -> Result<Self, String>
     // where
     //     R: AsyncRead + std::marker::Unpin + std::marker::Send,
     // {
diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
index afaa7fdd..703811c0 100755
--- a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
@@ -1,9 +1,7 @@
 use super::GamePacket;
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
-use async_trait::async_trait;
 use azalea_core::resource_location::ResourceLocation;
-use std::hash::Hash;
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt};
+use std::{hash::Hash, io::Read};
 
 #[derive(Hash, Clone, Debug)]
 pub struct ClientboundDeclareCommandsPacket {
@@ -20,16 +18,14 @@ impl ClientboundDeclareCommandsPacket {
         panic!("ClientboundDeclareCommandsPacket::write not implemented")
     }
 
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut T,
-    ) -> Result<GamePacket, String> {
-        let node_count = buf.read_varint().await?;
+    pub fn read<T: Read>(buf: &mut T) -> Result<GamePacket, String> {
+        let node_count = buf.read_varint()?;
         let mut nodes = Vec::with_capacity(node_count as usize);
         for _ in 0..node_count {
-            let node = BrigadierNodeStub::read_into(buf).await?;
+            let node = BrigadierNodeStub::read_into(buf)?;
             nodes.push(node);
         }
-        let root_index = buf.read_varint().await?;
+        let root_index = buf.read_varint()?;
         Ok(GamePacket::ClientboundDeclareCommandsPacket(
             ClientboundDeclareCommandsPacket {
                 entries: nodes,
@@ -47,20 +43,16 @@ pub struct BrigadierNumber<T> {
     min: Option<T>,
     max: Option<T>,
 }
-#[async_trait]
-impl<T: McBufReadable + Send> McBufReadable for BrigadierNumber<T> {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let flags = buf.read_byte().await?;
+impl<T: McBufReadable> McBufReadable for BrigadierNumber<T> {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let flags = buf.read_byte()?;
         let min = if flags & 0x01 != 0 {
-            Some(T::read_into(buf).await?)
+            Some(T::read_into(buf)?)
         } else {
             None
         };
         let max = if flags & 0x02 != 0 {
-            Some(T::read_into(buf).await?)
+            Some(T::read_into(buf)?)
         } else {
             None
         };
@@ -97,13 +89,9 @@ pub enum BrigadierString {
     GreedyPhrase = 2,
 }
 
-#[async_trait]
 impl McBufReadable for BrigadierString {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let id = buf.read_byte().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let id = buf.read_byte()?;
         Ok(match id {
             0 => BrigadierString::SingleWord,
             1 => BrigadierString::QuotablePhrase,
@@ -171,38 +159,24 @@ pub enum BrigadierParser {
     Resource { registry_key: ResourceLocation },
 }
 
-#[async_trait]
 impl McBufReadable for BrigadierParser {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let parser = buf.read_resource_location().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let parser = buf.read_resource_location()?;
 
         if parser == ResourceLocation::new("brigadier:bool")? {
             Ok(BrigadierParser::Bool)
         } else if parser == ResourceLocation::new("brigadier:double")? {
-            Ok(BrigadierParser::Double(
-                BrigadierNumber::read_into(buf).await?,
-            ))
+            Ok(BrigadierParser::Double(BrigadierNumber::read_into(buf)?))
         } else if parser == ResourceLocation::new("brigadier:float")? {
-            Ok(BrigadierParser::Float(
-                BrigadierNumber::read_into(buf).await?,
-            ))
+            Ok(BrigadierParser::Float(BrigadierNumber::read_into(buf)?))
         } else if parser == ResourceLocation::new("brigadier:integer")? {
-            Ok(BrigadierParser::Integer(
-                BrigadierNumber::read_into(buf).await?,
-            ))
+            Ok(BrigadierParser::Integer(BrigadierNumber::read_into(buf)?))
         } else if parser == ResourceLocation::new("brigadier:long")? {
-            Ok(BrigadierParser::Long(
-                BrigadierNumber::read_into(buf).await?,
-            ))
+            Ok(BrigadierParser::Long(BrigadierNumber::read_into(buf)?))
         } else if parser == ResourceLocation::new("brigadier:string")? {
-            Ok(BrigadierParser::String(
-                BrigadierString::read_into(buf).await?,
-            ))
+            Ok(BrigadierParser::String(BrigadierString::read_into(buf)?))
         } else if parser == ResourceLocation::new("minecraft:entity")? {
-            let flags = buf.read_byte().await?;
+            let flags = buf.read_byte()?;
             Ok(BrigadierParser::Entity {
                 single: flags & 0x01 != 0,
                 players_only: flags & 0x02 != 0,
@@ -250,7 +224,7 @@ impl McBufReadable for BrigadierParser {
         } else if parser == ResourceLocation::new("minecraft:scoreboard_slot")? {
             Ok(BrigadierParser::ScoreboardSlot)
         } else if parser == ResourceLocation::new("minecraft:score_holder")? {
-            let flags = buf.read_byte().await?;
+            let flags = buf.read_byte()?;
             Ok(BrigadierParser::ScoreHolder {
                 allows_multiple: flags & 0x01 != 0,
             })
@@ -270,7 +244,7 @@ impl McBufReadable for BrigadierParser {
             Ok(BrigadierParser::EntityAnchor)
         } else if parser == ResourceLocation::new("minecraft:range")? {
             Ok(BrigadierParser::Range {
-                decimals_allowed: buf.read_boolean().await?,
+                decimals_allowed: buf.read_boolean()?,
             })
         } else if parser == ResourceLocation::new("minecraft:int_range")? {
             Ok(BrigadierParser::IntRange)
@@ -292,11 +266,11 @@ impl McBufReadable for BrigadierParser {
             Ok(BrigadierParser::Time)
         } else if parser == ResourceLocation::new("minecraft:resource_or_tag")? {
             Ok(BrigadierParser::ResourceOrTag {
-                registry_key: buf.read_resource_location().await?,
+                registry_key: buf.read_resource_location()?,
             })
         } else if parser == ResourceLocation::new("minecraft:resource")? {
             Ok(BrigadierParser::Resource {
-                registry_key: buf.read_resource_location().await?,
+                registry_key: buf.read_resource_location()?,
             })
         } else {
             panic!("Unknown Brigadier parser: {}", parser)
@@ -305,13 +279,9 @@ impl McBufReadable for BrigadierParser {
 }
 
 // azalea_brigadier::tree::CommandNode
-#[async_trait]
 impl McBufReadable for BrigadierNodeStub {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let flags = u8::read_into(buf).await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let flags = u8::read_into(buf)?;
         if flags > 31 {
             println!(
                 "Warning: The flags from a Brigadier node are over 31. This is probably a bug."
@@ -323,21 +293,17 @@ impl McBufReadable for BrigadierNodeStub {
         let has_redirect = flags & 0x08 != 0;
         let has_suggestions_type = flags & 0x10 != 0;
 
-        let children = buf.read_int_id_list().await?;
-        let redirect_node = if has_redirect {
-            buf.read_varint().await?
-        } else {
-            0
-        };
+        let children = buf.read_int_id_list()?;
+        let redirect_node = if has_redirect { buf.read_varint()? } else { 0 };
 
         // argument node
         if node_type == 2 {
-            let name = buf.read_utf().await?;
+            let name = buf.read_utf()?;
 
-            let parser = BrigadierParser::read_into(buf).await?;
+            let parser = BrigadierParser::read_into(buf)?;
 
             let suggestions_type = if has_suggestions_type {
-                Some(buf.read_resource_location().await?)
+                Some(buf.read_resource_location()?)
             } else {
                 None
             };
@@ -345,7 +311,7 @@ impl McBufReadable for BrigadierNodeStub {
         }
         // literal node
         if node_type == 1 {
-            let name = buf.read_utf().await?;
+            let name = buf.read_utf()?;
             return Ok(BrigadierNodeStub {});
         }
         Ok(BrigadierNodeStub {})
diff --git a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
index f4f528cf..3ca1ac85 100755
--- a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
@@ -1,9 +1,7 @@
-// i don't know the actual name of this packet, i couldn't find it in the source code
+use std::io::Read;
 
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable};
-use async_trait::async_trait;
 use packet_macros::GamePacket;
-use tokio::io::AsyncRead;
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundPlayerAbilitiesPacket {
@@ -21,13 +19,9 @@ pub struct PlayerAbilitiesFlags {
     pub instant_break: bool,
 }
 
-#[async_trait]
 impl McBufReadable for PlayerAbilitiesFlags {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let byte = buf.read_byte().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let byte = buf.read_byte()?;
         Ok(PlayerAbilitiesFlags {
             invulnerable: byte & 1 != 0,
             flying: byte & 2 != 0,
diff --git a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
index 3d4c3ac7..97b68259 100644
--- a/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_info_packet.rs
@@ -1,10 +1,7 @@
-// i don't know the actual name of this packet, i couldn't find it in the source code
-
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
-use async_trait::async_trait;
 use azalea_chat::component::Component;
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
-use tokio::io::AsyncRead;
+use std::io::Read;
 use uuid::Uuid;
 
 #[derive(Clone, Debug, GamePacket)]
@@ -64,19 +61,15 @@ pub struct RemovePlayer {
     uuid: Uuid,
 }
 
-#[async_trait]
 impl McBufReadable for Action {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let id = buf.read_byte().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let id = buf.read_byte()?;
         Ok(match id {
-            0 => Action::AddPlayer(Vec::<AddPlayer>::read_into(buf).await?),
-            1 => Action::UpdateGameMode(Vec::<UpdateGameMode>::read_into(buf).await?),
-            2 => Action::UpdateLatency(Vec::<UpdateLatency>::read_into(buf).await?),
-            3 => Action::UpdateDisplayName(Vec::<UpdateDisplayName>::read_into(buf).await?),
-            4 => Action::RemovePlayer(Vec::<RemovePlayer>::read_into(buf).await?),
+            0 => Action::AddPlayer(Vec::<AddPlayer>::read_into(buf)?),
+            1 => Action::UpdateGameMode(Vec::<UpdateGameMode>::read_into(buf)?),
+            2 => Action::UpdateLatency(Vec::<UpdateLatency>::read_into(buf)?),
+            3 => Action::UpdateDisplayName(Vec::<UpdateDisplayName>::read_into(buf)?),
+            4 => Action::RemovePlayer(Vec::<RemovePlayer>::read_into(buf)?),
             _ => panic!("Unknown player info action id: {}", id),
         })
     }
diff --git a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
index 5bb40d84..e47ca9e1 100644
--- a/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_player_position_packet.rs
@@ -1,9 +1,7 @@
-// i don't know the actual name of this packet, i couldn't find it in the source code
+use std::io::Read;
 
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable};
-use async_trait::async_trait;
 use packet_macros::GamePacket;
-use tokio::io::AsyncRead;
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundPlayerPositionPacket {
@@ -29,13 +27,9 @@ pub struct RelativeArguments {
     pub x_rot: bool,
 }
 
-#[async_trait]
 impl McBufReadable for RelativeArguments {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let byte = buf.read_byte().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let byte = buf.read_byte()?;
         Ok(RelativeArguments {
             x: byte & 0b1 != 0,
             y: byte & 0b10 != 0,
diff --git a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
index 69f26ddc..4847bbf8 100644
--- a/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_recipe_packet.rs
@@ -1,8 +1,6 @@
-use async_trait::async_trait;
-use azalea_chat::component::Component;
 use azalea_core::{resource_location::ResourceLocation, Slot};
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
-use tokio::io::AsyncRead;
+use std::io::Read;
 
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 
@@ -42,13 +40,9 @@ impl McBufWritable for State {
         Ok(())
     }
 }
-#[async_trait]
 impl McBufReadable for State {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let state = buf.read_varint().await?.try_into().unwrap();
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let state = buf.read_varint()?.try_into().unwrap();
         Ok(match state {
             0 => State::Init,
             1 => State::Add,
diff --git a/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
index 4cc456f3..302d832a 100644
--- a/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_set_entity_data_packet.rs
@@ -1,12 +1,12 @@
+use std::io::Read;
+
 use crate::{
     mc_buf::{Readable, Writable},
     packets::{McBufReadable, McBufWritable},
 };
-use async_trait::async_trait;
 use azalea_chat::component::Component;
 use azalea_core::{BlockPos, Direction, Slot};
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
-use tokio::io::AsyncRead;
 use uuid::Uuid;
 
 #[derive(Clone, Debug, GamePacket)]
@@ -24,19 +24,15 @@ pub struct EntityDataItem {
     pub value: EntityDataValue,
 }
 
-#[async_trait]
 impl McBufReadable for Vec<EntityDataItem> {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
         let mut metadata = Vec::new();
         loop {
-            let index = buf.read_byte().await?;
+            let index = buf.read_byte()?;
             if index == 0xff {
                 break;
             }
-            let value = EntityDataValue::read_into(buf).await?;
+            let value = EntityDataValue::read_into(buf)?;
             metadata.push(EntityDataItem { index, value });
         }
         Ok(metadata)
@@ -81,51 +77,47 @@ pub enum EntityDataValue {
     Pose(Pose),
 }
 
-#[async_trait]
 impl McBufReadable for EntityDataValue {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let type_ = buf.read_varint().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let type_ = buf.read_varint()?;
         Ok(match type_ {
-            0 => EntityDataValue::Byte(buf.read_byte().await?),
-            1 => EntityDataValue::Int(buf.read_varint().await?),
-            2 => EntityDataValue::Float(buf.read_float().await?),
-            3 => EntityDataValue::String(buf.read_utf().await?),
-            4 => EntityDataValue::Component(Component::read_into(buf).await?),
-            5 => EntityDataValue::OptionalComponent(Option::<Component>::read_into(buf).await?),
-            6 => EntityDataValue::ItemStack(Slot::read_into(buf).await?),
-            7 => EntityDataValue::Boolean(buf.read_boolean().await?),
+            0 => EntityDataValue::Byte(buf.read_byte()?),
+            1 => EntityDataValue::Int(buf.read_varint()?),
+            2 => EntityDataValue::Float(buf.read_float()?),
+            3 => EntityDataValue::String(buf.read_utf()?),
+            4 => EntityDataValue::Component(Component::read_into(buf)?),
+            5 => EntityDataValue::OptionalComponent(Option::<Component>::read_into(buf)?),
+            6 => EntityDataValue::ItemStack(Slot::read_into(buf)?),
+            7 => EntityDataValue::Boolean(buf.read_boolean()?),
             8 => EntityDataValue::Rotations {
-                x: buf.read_float().await?,
-                y: buf.read_float().await?,
-                z: buf.read_float().await?,
+                x: buf.read_float()?,
+                y: buf.read_float()?,
+                z: buf.read_float()?,
             },
-            9 => EntityDataValue::BlockPos(BlockPos::read_into(buf).await?),
-            10 => EntityDataValue::OptionalBlockPos(Option::<BlockPos>::read_into(buf).await?),
-            11 => EntityDataValue::Direction(Direction::read_into(buf).await?),
-            12 => EntityDataValue::OptionalUuid(Option::<Uuid>::read_into(buf).await?),
+            9 => EntityDataValue::BlockPos(BlockPos::read_into(buf)?),
+            10 => EntityDataValue::OptionalBlockPos(Option::<BlockPos>::read_into(buf)?),
+            11 => EntityDataValue::Direction(Direction::read_into(buf)?),
+            12 => EntityDataValue::OptionalUuid(Option::<Uuid>::read_into(buf)?),
             13 => EntityDataValue::OptionalBlockState({
-                let val = i32::read_into(buf).await?;
+                let val = i32::read_into(buf)?;
                 if val == 0 {
                     None
                 } else {
                     Some(val)
                 }
             }),
-            14 => EntityDataValue::CompoundTag(azalea_nbt::Tag::read_into(buf).await?),
-            15 => EntityDataValue::Particle(Particle::read_into(buf).await?),
-            16 => EntityDataValue::VillagerData(VillagerData::read_into(buf).await?),
+            14 => EntityDataValue::CompoundTag(azalea_nbt::Tag::read_into(buf)?),
+            15 => EntityDataValue::Particle(Particle::read_into(buf)?),
+            16 => EntityDataValue::VillagerData(VillagerData::read_into(buf)?),
             17 => EntityDataValue::OptionalUnsignedInt({
-                let val = buf.read_varint().await?;
+                let val = buf.read_varint()?;
                 if val == 0 {
                     None
                 } else {
                     Some((val - 1) as u32)
                 }
             }),
-            18 => EntityDataValue::Pose(Pose::read_into(buf).await?),
+            18 => EntityDataValue::Pose(Pose::read_into(buf)?),
             _ => return Err(format!("Unknown entity data type: {}", type_)),
         })
     }
@@ -309,18 +301,14 @@ pub struct VibrationParticle {
     pub ticks: u32,
 }
 
-#[async_trait]
 impl McBufReadable for ParticleData {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let id = buf.read_varint().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let id = buf.read_varint()?;
         Ok(match id {
             0 => ParticleData::AmbientEntityEffect,
             1 => ParticleData::AngryVillager,
-            2 => ParticleData::Block(BlockParticle::read_into(buf).await?),
-            3 => ParticleData::BlockMarker(BlockParticle::read_into(buf).await?),
+            2 => ParticleData::Block(BlockParticle::read_into(buf)?),
+            3 => ParticleData::BlockMarker(BlockParticle::read_into(buf)?),
             4 => ParticleData::Bubble,
             5 => ParticleData::Cloud,
             6 => ParticleData::Crit,
@@ -331,10 +319,8 @@ impl McBufReadable for ParticleData {
             11 => ParticleData::LandingLava,
             12 => ParticleData::DrippingWater,
             13 => ParticleData::FallingWater,
-            14 => ParticleData::Dust(DustParticle::read_into(buf).await?),
-            15 => ParticleData::DustColorTransition(
-                DustColorTransitionParticle::read_into(buf).await?,
-            ),
+            14 => ParticleData::Dust(DustParticle::read_into(buf)?),
+            15 => ParticleData::DustColorTransition(DustColorTransitionParticle::read_into(buf)?),
             16 => ParticleData::Effect,
             17 => ParticleData::ElderGuardian,
             18 => ParticleData::EnchantedHit,
@@ -343,7 +329,7 @@ impl McBufReadable for ParticleData {
             21 => ParticleData::EntityEffect,
             22 => ParticleData::ExplosionEmitter,
             23 => ParticleData::Explosion,
-            24 => ParticleData::FallingDust(BlockParticle::read_into(buf).await?),
+            24 => ParticleData::FallingDust(BlockParticle::read_into(buf)?),
             25 => ParticleData::Firework,
             26 => ParticleData::Fishing,
             27 => ParticleData::Flame,
@@ -354,8 +340,8 @@ impl McBufReadable for ParticleData {
             32 => ParticleData::Composter,
             33 => ParticleData::Heart,
             34 => ParticleData::InstantEffect,
-            35 => ParticleData::Item(ItemParticle::read_into(buf).await?),
-            36 => ParticleData::Vibration(VibrationParticle::read_into(buf).await?),
+            35 => ParticleData::Item(ItemParticle::read_into(buf)?),
+            36 => ParticleData::Vibration(VibrationParticle::read_into(buf)?),
             37 => ParticleData::ItemSlime,
             38 => ParticleData::ItemSnowball,
             39 => ParticleData::LargeSmoke,
diff --git a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
index d7f86931..6e0aae29 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_attributes_packet.rs
@@ -1,11 +1,9 @@
-use async_trait::async_trait;
-use azalea_core::{game_type::GameType, resource_location::ResourceLocation};
+use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
+use azalea_core::resource_location::ResourceLocation;
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
-use tokio::io::AsyncRead;
+use std::io::Read;
 use uuid::Uuid;
 
-use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
-
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundUpdateAttributesPacket {
     #[varint]
@@ -34,13 +32,9 @@ enum Operation {
     MultiplyTotal = 2,
 }
 
-#[async_trait]
 impl McBufReadable for Operation {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        match buf.read_byte().await? {
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        match buf.read_byte()? {
             0 => Ok(Operation::Addition),
             1 => Ok(Operation::MultiplyBase),
             2 => Ok(Operation::MultiplyTotal),
diff --git a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
index 5ae06a6f..4b1a322a 100644
--- a/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_recipes_packet.rs
@@ -1,8 +1,7 @@
-use async_trait::async_trait;
-use azalea_chat::component::Component;
+use std::io::Read;
+
 use azalea_core::{resource_location::ResourceLocation, Slot};
 use packet_macros::{GamePacket, McBufReadable, McBufWritable};
-use tokio::io::AsyncRead;
 
 use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 
@@ -48,20 +47,16 @@ impl McBufWritable for ShapedRecipe {
         Ok(())
     }
 }
-#[async_trait]
 impl McBufReadable for ShapedRecipe {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let width = buf.read_varint().await?.try_into().unwrap();
-        let height = buf.read_varint().await?.try_into().unwrap();
-        let group = buf.read_utf().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let width = buf.read_varint()?.try_into().unwrap();
+        let height = buf.read_varint()?.try_into().unwrap();
+        let group = buf.read_utf()?;
         let mut ingredients = Vec::with_capacity(width * height);
         for _ in 0..width * height {
-            ingredients.push(Ingredient::read_into(buf).await?);
+            ingredients.push(Ingredient::read_into(buf)?);
         }
-        let result = Slot::read_into(buf).await?;
+        let result = Slot::read_into(buf)?;
 
         Ok(ShapedRecipe {
             width,
@@ -132,22 +127,18 @@ impl McBufWritable for Recipe {
     }
 }
 
-#[async_trait]
 impl McBufReadable for Recipe {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let recipe_type = buf.read_resource_location().await?;
-        let identifier = buf.read_resource_location().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let recipe_type = buf.read_resource_location()?;
+        let identifier = buf.read_resource_location()?;
 
         // rust doesn't let us match ResourceLocation so we have to do a big
         // if-else chain :(
         let data = if recipe_type == ResourceLocation::new("minecraft:crafting_shapeless").unwrap()
         {
-            RecipeData::CraftingShapeless(ShapelessRecipe::read_into(buf).await?)
+            RecipeData::CraftingShapeless(ShapelessRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:crafting_shaped").unwrap() {
-            RecipeData::CraftingShaped(ShapedRecipe::read_into(buf).await?)
+            RecipeData::CraftingShaped(ShapedRecipe::read_into(buf)?)
         } else if recipe_type
             == ResourceLocation::new("minecraft:crafting_special_armordye").unwrap()
         {
@@ -205,17 +196,17 @@ impl McBufReadable for Recipe {
         {
             RecipeData::CraftingSpecialSuspiciousStew
         } else if recipe_type == ResourceLocation::new("minecraft:smelting").unwrap() {
-            RecipeData::Smelting(CookingRecipe::read_into(buf).await?)
+            RecipeData::Smelting(CookingRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:blasting").unwrap() {
-            RecipeData::Blasting(CookingRecipe::read_into(buf).await?)
+            RecipeData::Blasting(CookingRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:smoking").unwrap() {
-            RecipeData::Smoking(CookingRecipe::read_into(buf).await?)
+            RecipeData::Smoking(CookingRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:campfire_cooking").unwrap() {
-            RecipeData::CampfireCooking(CookingRecipe::read_into(buf).await?)
+            RecipeData::CampfireCooking(CookingRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:stonecutting").unwrap() {
-            RecipeData::Stonecutting(StoneCuttingRecipe::read_into(buf).await?)
+            RecipeData::Stonecutting(StoneCuttingRecipe::read_into(buf)?)
         } else if recipe_type == ResourceLocation::new("minecraft:smithing").unwrap() {
-            RecipeData::Smithing(SmithingRecipe::read_into(buf).await?)
+            RecipeData::Smithing(SmithingRecipe::read_into(buf)?)
         } else {
             panic!("Unknown recipe type sent by server: {}", recipe_type);
         };
diff --git a/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
index b6046948..4646c2d3 100755
--- a/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
@@ -1,11 +1,7 @@
-use std::collections::HashMap;
-
-use async_trait::async_trait;
+use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
 use azalea_core::resource_location::ResourceLocation;
 use packet_macros::GamePacket;
-use tokio::io::AsyncRead;
-
-use crate::mc_buf::{McBufReadable, McBufWritable, Readable, Writable};
+use std::{collections::HashMap, io::Read};
 
 #[derive(Clone, Debug, GamePacket)]
 pub struct ClientboundUpdateTagsPacket {
@@ -18,20 +14,16 @@ pub struct Tags {
     pub elements: Vec<i32>,
 }
 
-#[async_trait]
 impl McBufReadable for HashMap<ResourceLocation, Vec<Tags>> {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let length = buf.read_varint().await? as usize;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let length = buf.read_varint()? as usize;
         let mut data = HashMap::with_capacity(length);
         for _ in 0..length {
-            let tag_type = buf.read_resource_location().await?;
-            let tags_count = buf.read_varint().await? as usize;
+            let tag_type = buf.read_resource_location()?;
+            let tags_count = buf.read_varint()? as usize;
             let mut tags_vec = Vec::with_capacity(tags_count);
             for _ in 0..tags_count {
-                let tags = Tags::read_into(buf).await?;
+                let tags = Tags::read_into(buf)?;
                 tags_vec.push(tags);
             }
             data.insert(tag_type, tags_vec);
@@ -50,14 +42,10 @@ impl McBufWritable for HashMap<ResourceLocation, Vec<Tags>> {
         Ok(())
     }
 }
-#[async_trait]
 impl McBufReadable for Tags {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        let name = buf.read_resource_location().await?;
-        let elements = buf.read_int_id_list().await?;
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        let name = buf.read_resource_location()?;
+        let elements = buf.read_int_id_list()?;
         Ok(Tags { name, elements })
     }
 }
diff --git a/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs
index 8301c089..1f988fe5 100755
--- a/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs
@@ -1,5 +1,3 @@
-// i don't know the actual name of this packet, i couldn't find it in the source code
-
 use packet_macros::GamePacket;
 
 #[derive(Clone, Debug, GamePacket)]
diff --git a/azalea-protocol/src/packets/game/serverbound_custom_payload_packet.rs b/azalea-protocol/src/packets/game/serverbound_custom_payload_packet.rs
index 43ddb700..eefafdd1 100644
--- a/azalea-protocol/src/packets/game/serverbound_custom_payload_packet.rs
+++ b/azalea-protocol/src/packets/game/serverbound_custom_payload_packet.rs
@@ -1,5 +1,3 @@
-// i don't know the actual name of this packet, i couldn't find it in the source code
-
 use crate::mc_buf::UnsizedByteArray;
 use azalea_core::resource_location::ResourceLocation;
 use packet_macros::GamePacket;
diff --git a/azalea-protocol/src/packets/handshake/client_intention_packet.rs b/azalea-protocol/src/packets/handshake/client_intention_packet.rs
index a92d65f6..6216ddc4 100755
--- a/azalea-protocol/src/packets/handshake/client_intention_packet.rs
+++ b/azalea-protocol/src/packets/handshake/client_intention_packet.rs
@@ -1,9 +1,7 @@
-use crate::{mc_buf::Writable, packets::ConnectionProtocol};
+use crate::packets::ConnectionProtocol;
 use packet_macros::HandshakePacket;
 use std::hash::Hash;
 
-use super::HandshakePacket;
-
 #[derive(Hash, Clone, Debug, HandshakePacket)]
 pub struct ClientIntentionPacket {
     #[varint]
@@ -12,23 +10,3 @@ pub struct ClientIntentionPacket {
     pub port: u16,
     pub intention: ConnectionProtocol,
 }
-
-// impl ClientIntentionPacket {
-//     pub fn get(self) -> HandshakePacket {
-//         HandshakePacket::ClientIntentionPacket(self)
-//     }
-
-//     pub fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-//         buf.write_varint(self.protocol_version as i32)?;
-//         buf.write_utf(&self.hostname)?;
-//         buf.write_short(self.port as i16)?;
-//         buf.write_varint(self.intention as i32)?;
-//         Ok(())
-//     }
-
-//     pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-//         buf: &mut T,
-//     ) -> Result<HandshakePacket, String> {
-//         todo!()
-//     }
-// }
diff --git a/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs b/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs
index ccf0f482..bcdcd105 100755
--- a/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs
+++ b/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs
@@ -1,3 +1,5 @@
+use std::io::Read;
+
 use super::LoginPacket;
 use crate::mc_buf::{Readable, Writable};
 use azalea_auth::game_profile::GameProfile;
@@ -23,17 +25,15 @@ impl ClientboundGameProfilePacket {
         Ok(())
     }
 
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut T,
-    ) -> Result<LoginPacket, String> {
+    pub fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
         // TODO: we have a thing to read from the uuid now
         let uuid = Uuid::from_int_array([
-            buf.read_int().await? as u32,
-            buf.read_int().await? as u32,
-            buf.read_int().await? as u32,
-            buf.read_int().await? as u32,
+            buf.read_int()? as u32,
+            buf.read_int()? as u32,
+            buf.read_int()? as u32,
+            buf.read_int()? as u32,
         ]);
-        let name = buf.read_utf_with_len(16).await?;
+        let name = buf.read_utf_with_len(16)?;
         Ok(ClientboundGameProfilePacket {
             game_profile: GameProfile::new(uuid, name),
         }
diff --git a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
index 20af1bec..06f346c2 100755
--- a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
+++ b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
@@ -1,4 +1,4 @@
-use std::hash::Hash;
+use std::{hash::Hash, io::Read};
 
 use super::LoginPacket;
 use crate::mc_buf::Readable;
@@ -19,12 +19,10 @@ impl ClientboundHelloPacket {
         panic!("ClientboundHelloPacket::write not implemented")
     }
 
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut T,
-    ) -> Result<LoginPacket, String> {
-        let server_id = buf.read_utf_with_len(20).await?;
-        let public_key = buf.read_byte_array().await?;
-        let nonce = buf.read_byte_array().await?;
+    pub  fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
+        let server_id = buf.read_utf_with_len(20)?;
+        let public_key = buf.read_byte_array()?;
+        let nonce = buf.read_byte_array()?;
 
         Ok(ClientboundHelloPacket {
             server_id,
diff --git a/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs b/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
index a88c6cbf..a5ab78bb 100755
--- a/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
+++ b/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
@@ -1,4 +1,4 @@
-use std::hash::Hash;
+use std::{hash::Hash, io::Read};
 
 use crate::mc_buf::{Readable, Writable};
 
@@ -19,10 +19,8 @@ impl ClientboundLoginCompressionPacket {
         Ok(())
     }
 
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut T,
-    ) -> Result<LoginPacket, String> {
-        let compression_threshold = buf.read_varint().await?;
+    pub  fn read(buf: &mut impl Read) -> Result<LoginPacket, String> {
+        let compression_threshold = buf.read_varint()?;
 
         Ok(ClientboundLoginCompressionPacket {
             compression_threshold,
diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs
index 98741a75..67fa92e9 100755
--- a/azalea-protocol/src/packets/mod.rs
+++ b/azalea-protocol/src/packets/mod.rs
@@ -3,14 +3,14 @@ pub mod handshake;
 pub mod login;
 pub mod status;
 
+use std::io::Read;
+
 use crate::{
     connect::PacketFlow,
     mc_buf::{McBufReadable, McBufWritable, Readable, Writable},
 };
-use async_trait::async_trait;
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
-use tokio::io::AsyncRead;
 
 pub const PROTOCOL_VERSION: u32 = 758;
 
@@ -31,7 +31,6 @@ pub enum Packet {
 }
 
 /// An enum of packets for a certain protocol
-#[async_trait]
 pub trait ProtocolPacket
 where
     Self: Sized,
@@ -39,24 +38,14 @@ where
     fn id(&self) -> u32;
 
     /// Read a packet by its id, ConnectionProtocol, and flow
-    async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        id: u32,
-        flow: &PacketFlow,
-        buf: &mut T,
-    ) -> Result<Self, String>
-    where
-        Self: Sized;
+    fn read(id: u32, flow: &PacketFlow, buf: &mut impl Read) -> Result<Self, String>;
 
     fn write(&self, buf: &mut Vec<u8>) -> Result<(), std::io::Error>;
 }
 
-#[async_trait]
 impl McBufReadable for ConnectionProtocol {
-    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
-    where
-        R: AsyncRead + std::marker::Unpin + std::marker::Send,
-    {
-        ConnectionProtocol::from_i32(buf.read_varint().await?)
+    fn read_into(buf: &mut impl Read) -> Result<Self, String> {
+        ConnectionProtocol::from_i32(buf.read_varint()?)
             .ok_or_else(|| "Invalid intention".to_string())
     }
 }
diff --git a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
index 884cf408..f5789ae3 100755
--- a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
+++ b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
@@ -1,3 +1,5 @@
+use std::io::Read;
+
 use azalea_chat::component::Component;
 use serde::Deserialize;
 use serde_json::Value;
@@ -43,10 +45,8 @@ impl ClientboundStatusResponsePacket {
         Ok(())
     }
 
-    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-        buf: &mut T,
-    ) -> Result<StatusPacket, String> {
-        let status_string = buf.read_utf().await?;
+    pub fn read(buf: &mut impl Read) -> Result<StatusPacket, String> {
+        let status_string = buf.read_utf()?;
         let status_json: Value =
             serde_json::from_str(status_string.as_str()).expect("Server status isn't valid JSON");
 
diff --git a/azalea-protocol/src/read.rs b/azalea-protocol/src/read.rs
index 9afdb0e9..b4ba17ea 100755
--- a/azalea-protocol/src/read.rs
+++ b/azalea-protocol/src/read.rs
@@ -1,12 +1,16 @@
+use crate::{
+    connect::PacketFlow,
+    mc_buf::{read_varint_async, Readable},
+    packets::ProtocolPacket,
+};
+use azalea_crypto::Aes128CfbDec;
+use flate2::read::ZlibDecoder;
 use std::{
     cell::Cell,
+    io::Read,
     pin::Pin,
     task::{Context, Poll},
 };
-
-use crate::{connect::PacketFlow, mc_buf::Readable, packets::ProtocolPacket};
-use async_compression::tokio::bufread::ZlibDecoder;
-use azalea_crypto::Aes128CfbDec;
 use tokio::io::{AsyncRead, AsyncReadExt};
 
 async fn frame_splitter<R: ?Sized>(mut stream: &mut R) -> Result<Vec<u8>, String>
@@ -14,7 +18,7 @@ where
     R: AsyncRead + std::marker::Unpin + std::marker::Send,
 {
     // Packet Length
-    let length_result = stream.read_varint().await;
+    let length_result = read_varint_async(&mut stream).await;
     match length_result {
         Ok(length) => {
             let mut buf = vec![0; length as usize];
@@ -30,16 +34,13 @@ where
     }
 }
 
-async fn packet_decoder<P: ProtocolPacket, R>(
-    stream: &mut R,
+fn packet_decoder<P: ProtocolPacket>(
+    stream: &mut impl Read,
     flow: &PacketFlow,
-) -> Result<P, String>
-where
-    R: AsyncRead + std::marker::Unpin + std::marker::Send,
-{
+) -> Result<P, String> {
     // Packet ID
-    let packet_id = stream.read_varint().await?;
-    P::read(packet_id.try_into().unwrap(), flow, stream).await
+    let packet_id = stream.read_varint()?;
+    P::read(packet_id.try_into().unwrap(), flow, stream)
 }
 
 // this is always true in multiplayer, false in singleplayer
@@ -47,22 +48,16 @@ static VALIDATE_DECOMPRESSED: bool = true;
 
 pub static MAXIMUM_UNCOMPRESSED_LENGTH: u32 = 2097152;
 
-async fn compression_decoder<R>(
-    stream: &mut R,
+fn compression_decoder(
+    stream: &mut impl Read,
     compression_threshold: u32,
-) -> Result<Vec<u8>, String>
-where
-    R: AsyncRead + std::marker::Unpin + std::marker::Send,
-{
+) -> Result<Vec<u8>, String> {
     // Data Length
-    let n: u32 = stream.read_varint().await?.try_into().unwrap();
+    let n: u32 = stream.read_varint()?.try_into().unwrap();
     if n == 0 {
         // no data size, no compression
         let mut buf = vec![];
-        stream
-            .read_to_end(&mut buf)
-            .await
-            .map_err(|e| e.to_string())?;
+        stream.read_to_end(&mut buf).map_err(|e| e.to_string())?;
         return Ok(buf);
     }
 
@@ -81,17 +76,10 @@ where
         }
     }
 
-    let mut buf = vec![];
-    stream
-        .read_to_end(&mut buf)
-        .await
-        .map_err(|e| e.to_string())?;
-
     let mut decoded_buf = vec![];
-    let mut decoder = ZlibDecoder::new(buf.as_slice());
+    let mut decoder = ZlibDecoder::new(stream);
     decoder
         .read_to_end(&mut decoded_buf)
-        .await
         .map_err(|e| e.to_string())?;
 
     Ok(decoded_buf)
@@ -161,11 +149,11 @@ where
         //     "decompressing packet ({}ms)",
         //     start_time.elapsed().as_millis()
         // );
-        buf = compression_decoder(&mut buf.as_slice(), compression_threshold).await?;
+        buf = compression_decoder(&mut buf.as_slice(), compression_threshold)?;
     }
 
     // println!("decoding packet ({}ms)", start_time.elapsed().as_millis());
-    let packet = packet_decoder(&mut buf.as_slice(), flow).await?;
+    let packet = packet_decoder(&mut buf.as_slice(), flow)?;
     // println!("decoded packet ({}ms)", start_time.elapsed().as_millis());
 
     Ok(packet)