diff --git a/client/Cargo.toml b/client/Cargo.toml
deleted file mode 100644
index c36c13a..0000000
--- a/client/Cargo.toml
+++ /dev/null
@@ -1,22 +0,0 @@
-[package]
-name = "client"
-version = "0.1.0"
-authors = ["michael-bailey <mickyb18a@gmail.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cursive = "0.17"
-uuid = {version = "1.1.2", features = ["serde", "v4"]}
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-crossbeam = "0.8.0"
-crossbeam-channel = "0.5.0"
-tokio = { version = "1.9.0", features = ["full"] }
-futures = "0.3.16"
-
-async-trait = "0.1.52"
-
-server = {path = '../server'}
-foundation = {path = '../foundation'}
diff --git a/client/src/main.rs b/client/src/main.rs
deleted file mode 100644
index f88edec..0000000
--- a/client/src/main.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-mod managers;
-mod worker;
-mod worker_message;
-
-use cursive::{
-	menu::{Item, Tree},
-	traits::Nameable,
-	views::{Dialog, TextView},
-	Cursive,
-	CursiveExt,
-};
-use worker::Worker;
-
-fn main() {
-	let mut app = Cursive::default();
-	let worker_stream = Worker::new(app.cb_sink().clone()).start();
-
-	app.set_user_data(worker_stream);
-	app.add_layer(
-		Dialog::new()
-			.content(TextView::new("Hello world").with_name("TextView"))
-			.button("close", |s| s.quit()),
-	);
-	app.menubar().autohide = false;
-	app.menubar().add_subtree(
-		"Application",
-		Tree::new()
-			.item(Item::leaf("About", |s| s.quit()))
-			.delimiter()
-			.item(Item::leaf("Quit", |s| s.quit())),
-	);
-	app.set_fps(30);
-	app.run();
-}
diff --git a/client/src/managers/Network.rs b/client/src/managers/Network.rs
deleted file mode 100644
index ceb6f1b..0000000
--- a/client/src/managers/Network.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use std::{
-	io::{Error, ErrorKind},
-	mem,
-	sync::{atomic::AtomicBool, Arc},
-};
-
-use async_trait::async_trait;
-use foundation::{
-	connection::Connection,
-	messages::{
-		client::{ClientStreamIn, ClientStreamOut},
-		network::{NetworkSockIn, NetworkSockOut},
-	},
-	prelude::IManager,
-};
-use tokio::{
-	net::ToSocketAddrs,
-	sync::{mpsc::Sender, Mutex},
-};
-use uuid::Uuid;
-
-use crate::managers::NetworkManagerMessage;
-
-pub struct NetworkManager<M>
-where
-	M: From<NetworkManagerMessage>,
-{
-	#[allow(unused)]
-	server_connection: Mutex<Option<Arc<Connection>>>,
-
-	#[allow(unused)]
-	cursive: Sender<M>,
-
-	is_logged_in: AtomicBool,
-}
-
-impl<M> NetworkManager<M>
-where
-	M: From<NetworkManagerMessage>,
-{
-	pub fn new(sender: Sender<M>) -> Arc<Self> {
-		Arc::new(NetworkManager {
-			server_connection: Mutex::new(None),
-			cursive: sender,
-			is_logged_in: AtomicBool::new(false),
-		})
-	}
-
-	#[allow(unused)]
-	pub async fn info<T: ToSocketAddrs>(
-		self: &Arc<Self>,
-		host: T,
-	) -> Result<NetworkManagerMessage, Error> {
-		let connection = Connection::new();
-		println!("Created connection");
-		connection.connect(host).await?;
-		let req = connection.read().await?;
-
-		println!("request: {:?}", req);
-
-		if let NetworkSockOut::Request = req {
-			connection
-				.write::<NetworkSockIn>(NetworkSockIn::Info)
-				.await?;
-			return Ok(connection.read::<NetworkSockOut>().await?.into());
-		} else {
-			Err(Error::new(
-				ErrorKind::ConnectionAborted,
-				"Request not received",
-			))
-		}
-	}
-
-	#[allow(unused)]
-	pub async fn login(
-		self: &Arc<Self>,
-		host: String,
-		uuid: Uuid,
-		username: String,
-		address: String,
-	) -> Result<(), Error> {
-		let connection = Connection::new();
-
-		let _ = connection.connect(host).await?;
-
-		println!("created connection");
-
-		let req = connection.read().await?;
-
-		println!("read request");
-
-		return if let NetworkSockOut::Request = req {
-			println!("got request");
-
-			connection
-				.write(NetworkSockIn::Connect {
-					username,
-					uuid,
-					address,
-				})
-				.await?;
-			let res = connection.read().await?;
-
-			// switch over to ClientStreamOut
-			if let ClientStreamOut::Connected = res {
-				let mut connection_lock = self.server_connection.lock().await;
-				let _ = mem::replace(&mut *connection_lock, Some(connection));
-				Ok(())
-			} else {
-				Err(Error::new(
-					ErrorKind::ConnectionRefused,
-					format!("expected connecting received: {:?}", res),
-				))
-			}
-		} else {
-			println!("request not found");
-			Err(Error::new(
-				ErrorKind::ConnectionAborted,
-				"Server did not send request",
-			))
-		};
-	}
-
-	#[allow(unused)]
-	pub async fn logout(self: &Arc<Self>) -> Result<(), Error> {
-		let mut connection_lock = self.server_connection.lock().await;
-		let connection = mem::replace(&mut *connection_lock, None).unwrap();
-
-		connection.write(ClientStreamIn::Disconnect).await?;
-
-		return if let ClientStreamOut::Disconnected = connection.read().await? {
-			Ok(())
-		} else {
-			Err(Error::new(
-				ErrorKind::InvalidData,
-				"disconnect failed, forcing disconnect",
-			))
-		};
-	}
-}
-
-#[async_trait]
-impl<M: 'static> IManager for NetworkManager<M>
-where
-	M: From<NetworkManagerMessage> + Send,
-{
-	async fn run(self: &Arc<Self>) {
-		println!("networkManager tick")
-	}
-}
-
-#[cfg(test)]
-mod test {
-	use std::future::Future;
-
-	use serverlib::Server;
-	use tokio::sync::mpsc::channel;
-	use uuid::Uuid;
-
-	use crate::managers::{network::NetworkManagerMessage, NetworkManager};
-
-	async fn wrap_setup<T, F>(test: T)
-	where
-		T: FnOnce(u16) -> F,
-		F: Future,
-	{
-		let server = Server::new().await.unwrap();
-		let port = server.port().await;
-
-		tokio::spawn(async move {
-			server.start().await;
-		});
-		test(port).await;
-	}
-	#[tokio::test]
-	async fn test_fetch_server_info() {
-		use NetworkManagerMessage::Info;
-		#[allow(unused)]
-		let (tx, rx) = channel::<NetworkManagerMessage>(16);
-
-		wrap_setup(|port| async move {
-			let network = NetworkManager::new(tx);
-			let info = network
-				.info(format!("localhost:{}", port))
-				.await
-				.expect("Failed to fetch info");
-			assert_eq!(
-				info,
-				Info {
-					server_name: "oof".to_string(),
-					server_owner: "michael".to_string()
-				}
-			);
-		})
-		.await;
-	}
-	#[tokio::test]
-	async fn test_login_and_logout_to_server() {
-		#[allow(unused)]
-		let (tx, rx) = channel::<NetworkManagerMessage>(16);
-
-		let network = NetworkManager::new(tx);
-
-		println!("created network manger");
-
-		wrap_setup(|port| async move {
-			network
-				.login(
-					format!("localhost:{}", port),
-					Uuid::default(),
-					"user1".to_string(),
-					"localhost".to_string(),
-				)
-				.await
-				.expect("login failed");
-
-			network.logout().await.expect("logout failed");
-		})
-		.await;
-	}
-}
diff --git a/client/src/managers/message.rs b/client/src/managers/message.rs
deleted file mode 100644
index 39c43af..0000000
--- a/client/src/managers/message.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use foundation::{messages::network::NetworkSockOut, ClientDetails};
-
-#[derive(Debug)]
-pub enum NetworkManagerMessage {
-	#[allow(unused)]
-	Users(Vec<ClientDetails>),
-	Info {
-		server_name: String,
-		server_owner: String,
-	},
-	Error(&'static str),
-}
-
-impl From<NetworkSockOut> for NetworkManagerMessage {
-	fn from(other: NetworkSockOut) -> Self {
-		use NetworkManagerMessage::{Error, Info as NewInfo};
-		use NetworkSockOut::GotInfo as OldInfo;
-		match other {
-			OldInfo {
-				server_name,
-				server_owner,
-			} => NewInfo {
-				server_name,
-				server_owner,
-			},
-			_ => Error("Error occurred with conversion"),
-		}
-	}
-}
-
-impl PartialEq for NetworkManagerMessage {
-	fn eq(&self, other: &Self) -> bool {
-		use NetworkManagerMessage::Info;
-		match self {
-			Info {
-				server_owner,
-				server_name,
-			} => {
-				if let Info {
-					server_owner: other_owner,
-					server_name: other_name,
-				} = other
-				{
-					return server_owner == other_owner && server_name == other_name;
-				}
-				false
-			}
-			_ => false,
-		}
-	}
-}
diff --git a/client/src/managers/mod.rs b/client/src/managers/mod.rs
deleted file mode 100644
index 52b3057..0000000
--- a/client/src/managers/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-mod network;
-
-#[path = "message.rs"]
-mod message;
-
-pub use message::NetworkManagerMessage;
-pub use network::NetworkManager;
diff --git a/client/src/managers/network.rs b/client/src/managers/network.rs
deleted file mode 100644
index ceb6f1b..0000000
--- a/client/src/managers/network.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use std::{
-	io::{Error, ErrorKind},
-	mem,
-	sync::{atomic::AtomicBool, Arc},
-};
-
-use async_trait::async_trait;
-use foundation::{
-	connection::Connection,
-	messages::{
-		client::{ClientStreamIn, ClientStreamOut},
-		network::{NetworkSockIn, NetworkSockOut},
-	},
-	prelude::IManager,
-};
-use tokio::{
-	net::ToSocketAddrs,
-	sync::{mpsc::Sender, Mutex},
-};
-use uuid::Uuid;
-
-use crate::managers::NetworkManagerMessage;
-
-pub struct NetworkManager<M>
-where
-	M: From<NetworkManagerMessage>,
-{
-	#[allow(unused)]
-	server_connection: Mutex<Option<Arc<Connection>>>,
-
-	#[allow(unused)]
-	cursive: Sender<M>,
-
-	is_logged_in: AtomicBool,
-}
-
-impl<M> NetworkManager<M>
-where
-	M: From<NetworkManagerMessage>,
-{
-	pub fn new(sender: Sender<M>) -> Arc<Self> {
-		Arc::new(NetworkManager {
-			server_connection: Mutex::new(None),
-			cursive: sender,
-			is_logged_in: AtomicBool::new(false),
-		})
-	}
-
-	#[allow(unused)]
-	pub async fn info<T: ToSocketAddrs>(
-		self: &Arc<Self>,
-		host: T,
-	) -> Result<NetworkManagerMessage, Error> {
-		let connection = Connection::new();
-		println!("Created connection");
-		connection.connect(host).await?;
-		let req = connection.read().await?;
-
-		println!("request: {:?}", req);
-
-		if let NetworkSockOut::Request = req {
-			connection
-				.write::<NetworkSockIn>(NetworkSockIn::Info)
-				.await?;
-			return Ok(connection.read::<NetworkSockOut>().await?.into());
-		} else {
-			Err(Error::new(
-				ErrorKind::ConnectionAborted,
-				"Request not received",
-			))
-		}
-	}
-
-	#[allow(unused)]
-	pub async fn login(
-		self: &Arc<Self>,
-		host: String,
-		uuid: Uuid,
-		username: String,
-		address: String,
-	) -> Result<(), Error> {
-		let connection = Connection::new();
-
-		let _ = connection.connect(host).await?;
-
-		println!("created connection");
-
-		let req = connection.read().await?;
-
-		println!("read request");
-
-		return if let NetworkSockOut::Request = req {
-			println!("got request");
-
-			connection
-				.write(NetworkSockIn::Connect {
-					username,
-					uuid,
-					address,
-				})
-				.await?;
-			let res = connection.read().await?;
-
-			// switch over to ClientStreamOut
-			if let ClientStreamOut::Connected = res {
-				let mut connection_lock = self.server_connection.lock().await;
-				let _ = mem::replace(&mut *connection_lock, Some(connection));
-				Ok(())
-			} else {
-				Err(Error::new(
-					ErrorKind::ConnectionRefused,
-					format!("expected connecting received: {:?}", res),
-				))
-			}
-		} else {
-			println!("request not found");
-			Err(Error::new(
-				ErrorKind::ConnectionAborted,
-				"Server did not send request",
-			))
-		};
-	}
-
-	#[allow(unused)]
-	pub async fn logout(self: &Arc<Self>) -> Result<(), Error> {
-		let mut connection_lock = self.server_connection.lock().await;
-		let connection = mem::replace(&mut *connection_lock, None).unwrap();
-
-		connection.write(ClientStreamIn::Disconnect).await?;
-
-		return if let ClientStreamOut::Disconnected = connection.read().await? {
-			Ok(())
-		} else {
-			Err(Error::new(
-				ErrorKind::InvalidData,
-				"disconnect failed, forcing disconnect",
-			))
-		};
-	}
-}
-
-#[async_trait]
-impl<M: 'static> IManager for NetworkManager<M>
-where
-	M: From<NetworkManagerMessage> + Send,
-{
-	async fn run(self: &Arc<Self>) {
-		println!("networkManager tick")
-	}
-}
-
-#[cfg(test)]
-mod test {
-	use std::future::Future;
-
-	use serverlib::Server;
-	use tokio::sync::mpsc::channel;
-	use uuid::Uuid;
-
-	use crate::managers::{network::NetworkManagerMessage, NetworkManager};
-
-	async fn wrap_setup<T, F>(test: T)
-	where
-		T: FnOnce(u16) -> F,
-		F: Future,
-	{
-		let server = Server::new().await.unwrap();
-		let port = server.port().await;
-
-		tokio::spawn(async move {
-			server.start().await;
-		});
-		test(port).await;
-	}
-	#[tokio::test]
-	async fn test_fetch_server_info() {
-		use NetworkManagerMessage::Info;
-		#[allow(unused)]
-		let (tx, rx) = channel::<NetworkManagerMessage>(16);
-
-		wrap_setup(|port| async move {
-			let network = NetworkManager::new(tx);
-			let info = network
-				.info(format!("localhost:{}", port))
-				.await
-				.expect("Failed to fetch info");
-			assert_eq!(
-				info,
-				Info {
-					server_name: "oof".to_string(),
-					server_owner: "michael".to_string()
-				}
-			);
-		})
-		.await;
-	}
-	#[tokio::test]
-	async fn test_login_and_logout_to_server() {
-		#[allow(unused)]
-		let (tx, rx) = channel::<NetworkManagerMessage>(16);
-
-		let network = NetworkManager::new(tx);
-
-		println!("created network manger");
-
-		wrap_setup(|port| async move {
-			network
-				.login(
-					format!("localhost:{}", port),
-					Uuid::default(),
-					"user1".to_string(),
-					"localhost".to_string(),
-				)
-				.await
-				.expect("login failed");
-
-			network.logout().await.expect("logout failed");
-		})
-		.await;
-	}
-}
diff --git a/client/src/worker.rs b/client/src/worker.rs
deleted file mode 100644
index a5ef6ac..0000000
--- a/client/src/worker.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use std::{sync::Arc, thread::spawn, time::Duration};
-
-use crossbeam_channel::Sender as CrossSender;
-use foundation::ClientDetails;
-use tokio::{
-	runtime::Runtime,
-	sync::{
-		mpsc::{channel, Sender as TokioSender},
-		Mutex,
-	},
-	time::sleep,
-};
-
-use crate::{
-	managers::NetworkManager,
-	worker_message::WorkerMessage,
-	Cursive,
-	TextView,
-};
-
-pub type CursiveSender = CrossSender<Box<dyn FnOnce(&mut Cursive) + Send>>;
-
-pub struct Worker {
-	cursive_sender: CursiveSender,
-
-	network_manager: Arc<NetworkManager<WorkerMessage>>,
-
-	number: Arc<Mutex<usize>>,
-
-	#[allow(unused)]
-	user_details: Mutex<Option<ClientDetails>>,
-}
-
-impl Worker {
-	pub fn new(sender: CursiveSender) -> Worker {
-		#[allow(unused)]
-		let (tx, rx) = channel::<WorkerMessage>(16);
-
-		Worker {
-			network_manager: NetworkManager::new(tx.clone()),
-			number: Arc::new(Mutex::new(0)),
-			user_details: Mutex::new(None),
-			cursive_sender: sender,
-		}
-	}
-
-	pub fn start(self) -> TokioSender<WorkerMessage> {
-		#[allow(unused)]
-		let (tx, rx) = channel::<WorkerMessage>(16);
-		spawn(move || {
-			let sender = self.cursive_sender.clone();
-			let rt = Runtime::new().unwrap();
-			let tmp_num = self.number.clone();
-			#[allow(unused)]
-			let network_manager = self.network_manager.clone();
-			rt.block_on(async move {
-				let a = &tmp_num;
-				loop {
-					let num = Arc::clone(&a);
-					sleep(Duration::new(1, 0)).await;
-					let _ = sender.send(Box::new(move |s| {
-						let num = &num.clone();
-						let mut num_lock = num.blocking_lock();
-						*num_lock += 1;
-						let a = *num_lock;
-						s.find_name::<TextView>("TextView")
-							.unwrap()
-							.set_content(a.to_string());
-					}));
-				}
-			})
-		});
-		tx
-	}
-}
diff --git a/client/src/worker_message.rs b/client/src/worker_message.rs
deleted file mode 100644
index 485dece..0000000
--- a/client/src/worker_message.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use crate::managers::NetworkManagerMessage;
-
-pub enum WorkerMessage {
-	Info {
-		server_name: String,
-		server_owner: String,
-	},
-	#[allow(unused)]
-	Error(String),
-}
-
-impl From<NetworkManagerMessage> for WorkerMessage {
-	fn from(other: NetworkManagerMessage) -> Self {
-		#[allow(unused)]
-		use NetworkManagerMessage::{Error, Info as OldInfo};
-		#[allow(unused)]
-		use WorkerMessage::{Error as NewError, Info as NewInfo};
-		match other {
-			OldInfo {
-				server_name,
-				server_owner,
-			} => NewInfo {
-				server_owner,
-				server_name,
-			},
-			_ => todo!(),
-		}
-	}
-}