diff --git a/Cargo.lock b/Cargo.lock
index 35333ba..0ff0bbb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2701,6 +2701,7 @@ name = "pix_space"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "bytes 1.3.0",
  "rand 0.8.5",
  "vrpn",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index ccb17a4..85f84a9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,8 @@
 name = "pix_space"
 version = "0.1.0"
 edition = "2021"
+authors = ["Hartmut Seichter <hartmut@technotecture.com>"]
+readme = "README.md"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -11,6 +13,7 @@ bevy = { version = "0.9.1", features = ["dynamic"] }
 rand = "0.8.4" 
 # vrpn = "0.1.0" # not compatible with 2021
 vrpn = { git = "https://github.com/seichter/vrpn-rs" }
+bytes = "1.3.0"
 
 [profile.release]
 opt-level = 3
\ No newline at end of file
diff --git a/src/tracker.rs b/src/tracker.rs
index 0e42f3b..1419fa9 100644
--- a/src/tracker.rs
+++ b/src/tracker.rs
@@ -1,52 +1,79 @@
 use bevy::prelude::*;
 
 extern crate vrpn;
+extern crate bytes;
+
 // extern crate tokio;
 
-use std::sync::Arc;
-
+use bytes::Bytes;
+use std::net::{SocketAddr, TcpStream};
 use vrpn::{
-    async_io::{ping, ConnectionIp, ConnectionIpStream},
+    constants::MAGIC_DATA,
+    cookie::check_ver_nonfile_compatible,
     handler::{HandlerCode, TypedHandler},
-    ping::Server,
-    prelude::*,
+    sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
     tracker::PoseReport,
-    Message, Result, ServerInfo, StaticSenderName,
+    CookieData, Message, Result, TypeDispatcher, Unbuffer,
 };
 
 #[derive(Component)]
 pub struct Tracker {
-    stream: ConnectionIpStream,
-    connection: Arc<ConnectionIp>
+    // stream: ConnectionIpStream,
+    // connection: Arc<ConnectionIp>
 }
 
-impl Tracker {
-    pub fn from_info(server_ip: &str, port: u16) -> Self {
-        let server = format!("tcp://{}:{}", server_ip, port)
-            .parse::<ServerInfo>()
-            .unwrap();
-
-        let connection = ConnectionIp::new_client(server, None, None).expect("msg");
-
-        let sender = connection
-            .register_sender(StaticSenderName(b"Tracker0"))
-            .expect("should be able to register sender");
-
-        let ping_client = ping::Client::new(sender, Arc::clone(&connection))
-            .expect("should be able to create ping client");
-
-        Self {
-            stream: ConnectionIpStream::new(Arc::clone(&connection)),
-            connection
-        }
-    }
+#[derive(Debug)]
+struct TrackerHandler {}
 
+impl TypedHandler for TrackerHandler {
+    type Item = PoseReport;
     fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
         info!("{:?}\n   {:?}", msg.header, msg.body);
         Ok(HandlerCode::ContinueProcessing)
     }
 }
 
+impl Tracker {
+    pub fn from_info(server_ip: &str, port: u16) -> Result<()> {
+        // let server = format!("tcp://{}:{}", server_ip, port)
+        //     .parse::<ServerInfo>()
+        //     .unwrap();
+
+        // let connection = ConnectionIp::new_client(server, None, None).expect("msg");
+
+        // let sender = connection
+        //     .register_sender(StaticSenderName(b"Tracker0"))
+        //     .expect("should be able to register sender");
+
+        // let ping_client = ping::Client::new(sender, Arc::clone(&connection))
+        //     .expect("should be able to create ping client");
+
+
+        let addr: SocketAddr = "127.0.0.1:3883".parse().unwrap();
+        let mut stream = TcpStream::connect(addr)?;
+        stream.set_nodelay(true)?;
+    
+        // We first write our cookie, then read and check the server's cookie, before the loop.
+        write_cookie(&mut stream, CookieData::from(MAGIC_DATA))?;
+        let cookie_buf = read_cookie(&mut stream)?;
+        let mut cookie_buf = Bytes::from(&cookie_buf[..]);
+    
+        // CookieData::unbuffer_ref(&mut cookie_buf)
+        //     .and_then(|msg| check_ver_nonfile_compatible(msg.version))?;
+    
+        let mut endpoint = EndpointSyncTcp::new(stream);
+        let mut dispatcher = TypeDispatcher::new();
+        let _ = dispatcher.add_typed_handler(Box::new(TrackerHandler {}), None)?;
+
+        // Ok(Self {
+        //     // stream: ConnectionIpStream::new(Arc::clone(&connection)),
+        //     // connection
+        // })
+    }
+
+
+}
+
 pub fn setup_tracker(mut commands: Commands)
 {
     commands.spawn(Tracker::from_info("127.0.0.1",3883));