diff --git a/src/auth.rs b/src/auth.rs
index d5e5f07..578abf0 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -55,9 +55,9 @@ Used to identify this client vs others."#,
     default: &|| "".to_owned(),
 };
 
-pub fn register_vars(console: &mut console::Console) {
-    console.register(CL_USERNAME);
-    console.register(CL_UUID);
-    console.register(AUTH_TOKEN);
-    console.register(AUTH_CLIENT_TOKEN);
+pub fn register_vars(vars: &mut console::Vars) {
+    vars.register(CL_USERNAME);
+    vars.register(CL_UUID);
+    vars.register(AUTH_TOKEN);
+    vars.register(AUTH_CLIENT_TOKEN);
 }
diff --git a/src/console/mod.rs b/src/console/mod.rs
index ea8ef73..d94b402 100644
--- a/src/console/mod.rs
+++ b/src/console/mod.rs
@@ -15,6 +15,7 @@
 use std::marker::PhantomData;
 use std::collections::HashMap;
 use std::any::Any;
+use std::cell::{RefCell, Ref};
 use std::sync::{Arc, Mutex};
 use std::fs;
 use std::io::{BufWriter, Write, BufRead, BufReader};
@@ -98,32 +99,18 @@ pub trait Var {
     fn can_serialize(&self) -> bool;
 }
 
-pub struct Console {
+pub struct Vars {
     names: HashMap<String, &'static str>,
     vars: HashMap<&'static str, Box<Var>>,
-    var_values: HashMap<&'static str, Box<Any>>,
-
-    history: Vec<Component>,
-
-    collection: ui::Collection,
-    active: bool,
-    position: f64,
+    var_values: HashMap<&'static str, RefCell<Box<Any>>>,
 }
 
-unsafe impl Send for Console {}
-
-impl Console {
-    pub fn new() -> Console {
-        Console {
+impl Vars {
+    pub fn new() -> Vars {
+        Vars {
             names: HashMap::new(),
             vars: HashMap::new(),
             var_values: HashMap::new(),
-
-            history: vec![Component::Text(TextComponent::new("")); 200],
-
-            collection: ui::Collection::new(),
-            active: false,
-            position: -220.0,
         }
     }
 
@@ -134,24 +121,84 @@ impl Console {
             panic!("Key registered twice {}", var.name);
         }
         self.names.insert(var.name.to_owned(), var.name);
-        self.var_values.insert(var.name, Box::new((var.default)()));
+        self.var_values.insert(var.name, RefCell::new(Box::new((var.default)())));
         self.vars.insert(var.name, Box::new(var));
     }
 
-    pub fn get<T: Sized + Any>(&self, var: CVar<T>) -> &T
+    pub fn get<'a, T: Sized + Any>(&'a self, var: CVar<T>) -> Ref<'a, T>
         where CVar<T>: Var
     {
         // Should never fail
-        self.var_values.get(var.name).unwrap().downcast_ref::<T>().unwrap()
+        let var = self.var_values.get(var.name).unwrap().borrow();
+        Ref::map(var, |v| v.downcast_ref::<T>().unwrap())
     }
 
-    pub fn set<T: Sized + Any>(&mut self, var: CVar<T>, val: T)
+    pub fn set<T: Sized + Any>(&self, var: CVar<T>, val: T)
         where CVar<T>: Var
     {
-        self.var_values.insert(var.name, Box::new(val));
+        // self.var_values.insert(var.name, Box::new(val));
+        *self.var_values.get(var.name).unwrap().borrow_mut() = Box::new(val);
         self.save_config();
     }
 
+    pub fn load_config(&mut self) {
+        if let Ok(file) = fs::File::open("conf.cfg") {
+            let reader = BufReader::new(file);
+            for line in reader.lines() {
+                let line = line.unwrap();
+                if line.starts_with('#') || line.is_empty() {
+                    continue;
+                }
+                let parts = line.splitn(2, ' ').map(|v| v.to_owned()).collect::<Vec<String>>();
+                let (name, arg) = (&parts[0], &parts[1]);
+                if let Some(var_name) = self.names.get(name) {
+                    let var = self.vars.get(var_name).unwrap();
+                    let val = var.deserialize(&arg);
+                    if var.can_serialize() {
+                        self.var_values.insert(var_name, RefCell::new(val));
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn save_config(&self) {
+        let mut file = BufWriter::new(fs::File::create("conf.cfg").unwrap());
+        for (name, var) in &self.vars {
+            if !var.can_serialize() {
+                continue;
+            }
+            for line in var.description().lines() {
+                write!(file, "# {}\n", line).unwrap();
+            }
+            write!(file,
+                   "{} {}\n\n",
+                   name,
+                   var.serialize(&self.var_values.get(name).unwrap().borrow()))
+                .unwrap();
+        }
+    }
+}
+
+pub struct Console {
+    history: Vec<Component>,
+
+    collection: ui::Collection,
+    active: bool,
+    position: f64,
+}
+
+impl Console {
+    pub fn new() -> Console {
+        Console {
+            history: vec![Component::Text(TextComponent::new("")); 200],
+
+            collection: ui::Collection::new(),
+            active: false,
+            position: -220.0,
+        }
+    }
+
     pub fn is_active(&self) -> bool {
         self.active
     }
@@ -188,20 +235,12 @@ impl Console {
             ui::Mode::Unscaled(scale) => 854.0 / scale,
         };
 
-        let mut background =
-            ui::Image::new(render::Renderer::get_texture(renderer.get_textures_ref(),
-                                                         "steven:solid"),
-                           0.0,
-                           self.position,
-                           w,
-                           220.0,
-                           0.0,
-                           0.0,
-                           1.0,
-                           1.0,
-                           0,
-                           0,
-                           0);
+        let mut background = ui::Image::new(
+            render::Renderer::get_texture(renderer.get_textures_ref(), "steven:solid"),
+            0.0, self.position, w, 220.0,
+            0.0, 0.0, 1.0, 1.0,
+            0, 0, 0
+        );
         background.set_a(180);
         let background = self.collection.add(ui_container.add(background));
 
@@ -211,11 +250,12 @@ impl Console {
             if offset >= 210.0 {
                 break;
             }
-            let mut fmt = ui::Formatted::with_width_limit(renderer,
-                                                          line.clone(),
-                                                          5.0,
-                                                          5.0 + offset,
-                                                          w - 1.0);
+            let mut fmt = ui::Formatted::with_width_limit(
+                renderer,
+                line.clone(),
+                5.0, 5.0 + offset,
+                w - 1.0
+            );
             fmt.set_parent(&background);
             fmt.set_v_attach(ui::VAttach::Bottom);
             offset += fmt.get_height();
@@ -226,46 +266,6 @@ impl Console {
         }
     }
 
-    pub fn load_config(&mut self) {
-        if let Ok(file) = fs::File::open("conf.cfg") {
-            let reader = BufReader::new(file);
-            for line in reader.lines() {
-                let line = line.unwrap();
-                if line.starts_with('#') || line.is_empty() {
-                    continue;
-                }
-                let parts = line.splitn(2, ' ').map(|v| v.to_owned()).collect::<Vec<String>>();
-                let (name, arg) = (&parts[0], &parts[1]);
-                if let Some(var_name) = self.names.get(name) {
-                    let var = self.vars.get(var_name).unwrap();
-                    let val = var.deserialize(&arg);
-                    if var.can_serialize() {
-                        self.var_values.insert(var_name, val);
-                    }
-                } else {
-                    println!("Missing prop");
-                }
-            }
-        }
-    }
-
-    pub fn save_config(&self) {
-        let mut file = BufWriter::new(fs::File::create("conf.cfg").unwrap());
-        for (name, var) in &self.vars {
-            if !var.can_serialize() {
-                continue;
-            }
-            for line in var.description().lines() {
-                write!(file, "# {}\n", line).unwrap();
-            }
-            write!(file,
-                   "{} {}\n\n",
-                   name,
-                   var.serialize(self.var_values.get(name).unwrap()))
-                .unwrap();
-        }
-    }
-
     fn log(&mut self, record: &log::LogRecord) {
         for filtered in FILTERED_CRATES {
             if record.location().module_path().starts_with(filtered) {
diff --git a/src/main.rs b/src/main.rs
index e0ce4fa..f02d5d9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -59,9 +59,11 @@ pub mod model;
 pub mod entity;
 
 use std::sync::{Arc, RwLock, Mutex};
+use std::rc::Rc;
 use std::marker::PhantomData;
 use std::thread;
 use std::sync::mpsc;
+use protocol::mojang;
 
 const CL_BRAND: console::CVar<String> = console::CVar {
     ty: PhantomData,
@@ -78,6 +80,7 @@ pub struct Game {
     screen_sys: screen::ScreenSystem,
     resource_manager: Arc<RwLock<resources::Manager>>,
     console: Arc<Mutex<console::Console>>,
+    vars: Rc<console::Vars>,
     should_close: bool,
 
     server: server::Server,
@@ -93,9 +96,13 @@ impl Game {
         self.connect_reply = Some(rx);
         let address = address.to_owned();
         let resources = self.resource_manager.clone();
-        let console = self.console.clone();
+        let profile = mojang::Profile {
+            username: self.vars.get(auth::CL_USERNAME).clone(),
+            id: self.vars.get(auth::CL_UUID).clone(),
+            access_token: self.vars.get(auth::AUTH_TOKEN).clone(),
+        };
         thread::spawn(move || {
-            tx.send(server::Server::connect(resources, console, &address)).unwrap();
+            tx.send(server::Server::connect(resources, profile, &address)).unwrap();
         });
     }
 
@@ -151,14 +158,15 @@ impl Game {
 
 fn main() {
     let con = Arc::new(Mutex::new(console::Console::new()));
-    let mut vsync = {
-        let mut con = con.lock().unwrap();
-        con.register(CL_BRAND);
-        auth::register_vars(&mut con);
-        settings::register_vars(&mut con);
-        con.load_config();
-        con.save_config();
-        *con.get(settings::R_VSYNC)
+    let (vars, mut vsync) = {
+        let mut vars = console::Vars::new();
+        vars.register(CL_BRAND);
+        auth::register_vars(&mut vars);
+        settings::register_vars(&mut vars);
+        vars.load_config();
+        vars.save_config();
+        let vsync = *vars.get(settings::R_VSYNC);
+        (Rc::new(vars), vsync)
     };
 
     let proxy = console::ConsoleProxy::new(con.clone());
@@ -204,16 +212,17 @@ fn main() {
     let frame_time = (time::Duration::seconds(1).num_nanoseconds().unwrap() as f64) / 60.0;
 
     let mut screen_sys = screen::ScreenSystem::new();
-    screen_sys.add_screen(Box::new(screen::Login::new(con.clone())));
+    screen_sys.add_screen(Box::new(screen::Login::new(vars.clone())));
 
     let textures = renderer.get_textures();
     let mut game = Game {
-        server: server::Server::dummy_server(resource_manager.clone(), con.clone()),
+        server: server::Server::dummy_server(resource_manager.clone()),
         focused: false,
         renderer: renderer,
         screen_sys: screen_sys,
         resource_manager: resource_manager.clone(),
         console: con,
+        vars: vars,
         should_close: false,
         chunk_builder: chunk_builder::ChunkBuilder::new(resource_manager, textures),
         connect_reply: None,
@@ -234,15 +243,13 @@ fn main() {
         let delta = (diff.num_nanoseconds().unwrap() as f64) / frame_time;
         let (width, height) = window.drawable_size();
 
-        let fps_cap = {
-            let console = game.console.lock().unwrap();
-            let vsync_changed = *console.get(settings::R_VSYNC);
-            if vsync != vsync_changed {
-                vsync = vsync_changed;
-                sdl_video.gl_set_swap_interval(if vsync { 1 } else { 0 });
-            }
-            *console.get(settings::R_MAX_FPS)
-        };
+
+        let vsync_changed = *game.vars.get(settings::R_VSYNC);
+        if vsync != vsync_changed {
+            vsync = vsync_changed;
+            sdl_video.gl_set_swap_interval(if vsync { 1 } else { 0 });
+        }
+        let fps_cap = *game.vars.get(settings::R_MAX_FPS);
 
         game.tick(delta);
         game.server.tick(&mut game.renderer, delta);
@@ -339,7 +346,7 @@ fn handle_window_event(window: &sdl2::video::Window,
             if game.focused {
                 mouse.set_relative_mouse_mode(false);
                 game.focused = false;
-                game.screen_sys.replace_screen(Box::new(screen::SettingsMenu::new(game.console.clone(), true)));
+                game.screen_sys.replace_screen(Box::new(screen::SettingsMenu::new(game.vars.clone(), true)));
             } else if game.screen_sys.is_current_closable() {
                 mouse.set_relative_mouse_mode(true);
                 game.focused = true;
@@ -351,8 +358,7 @@ fn handle_window_event(window: &sdl2::video::Window,
         }
         Event::KeyDown{keycode: Some(key), ..} => {
             if game.focused {
-                let console = game.console.lock().unwrap();
-                if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &console) {
+                if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &game.vars) {
                     game.server.key_press(true, steven_key);
                 }
             } else {
@@ -361,8 +367,7 @@ fn handle_window_event(window: &sdl2::video::Window,
         }
         Event::KeyUp{keycode: Some(key), ..} => {
             if game.focused {
-                let console = game.console.lock().unwrap();
-                if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &console) {
+                if let Some(steven_key) = settings::Stevenkey::get_by_keycode(key, &game.vars) {
                     game.server.key_press(false, steven_key);
                 }
             } else {
diff --git a/src/screen/login.rs b/src/screen/login.rs
index 379dbd0..6aab9f8 100644
--- a/src/screen/login.rs
+++ b/src/screen/login.rs
@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::{Arc, Mutex};
-
 use std::cell::Cell;
 use std::rc::Rc;
 use std::sync::mpsc;
@@ -30,7 +28,7 @@ use auth;
 
 pub struct Login {
     elements: Option<UIElements>,
-    console: Arc<Mutex<console::Console>>,
+    vars: Rc<console::Vars>,
 }
 
 struct UIElements {
@@ -51,8 +49,8 @@ struct UIElements {
 
 
 impl Login {
-    pub fn new(console: Arc<Mutex<console::Console>>) -> Login {
-        Login { elements: None, console: console }
+    pub fn new(vars: Rc<console::Vars>) -> Login {
+        Login { elements: None, vars: vars }
     }
 }
 
@@ -126,11 +124,10 @@ impl super::Screen for Login {
         warn.set_h_attach(ui::HAttach::Right);
         elements.add(ui_container.add(warn));
 
-        let console = self.console.lock().unwrap();
         let profile = mojang::Profile {
-            username: console.get(auth::CL_USERNAME).clone(),
-            id: console.get(auth::CL_UUID).clone(),
-            access_token: console.get(auth::AUTH_TOKEN).clone(),
+            username: self.vars.get(auth::CL_USERNAME).clone(),
+            id: self.vars.get(auth::CL_UUID).clone(),
+            access_token: self.vars.get(auth::AUTH_TOKEN).clone(),
         };
         let refresh = profile.is_complete();
         try_login.set(refresh);
@@ -178,13 +175,12 @@ impl super::Screen for Login {
                 let txt = ui_container.get_mut(&elements.login_btn_text);
                 txt.set_text(renderer, "Logging in...");
             }
-            let mut console = self.console.lock().unwrap();
-            let mut client_token = console.get(auth::AUTH_CLIENT_TOKEN).clone();
+            let mut client_token = self.vars.get(auth::AUTH_CLIENT_TOKEN).clone();
             if client_token.is_empty() {
                 client_token = rand::thread_rng().gen_ascii_chars().take(20).collect::<String>();
-                console.set(auth::AUTH_CLIENT_TOKEN, client_token);
+                self.vars.set(auth::AUTH_CLIENT_TOKEN, client_token);
             }
-            let client_token = console.get(auth::AUTH_CLIENT_TOKEN).clone();
+            let client_token = self.vars.get(auth::AUTH_CLIENT_TOKEN).clone();
             let username = {
                 let txt = ui_container.get(&elements.username_txt);
                 txt.get_input()
@@ -217,10 +213,9 @@ impl super::Screen for Login {
                 }
                 match res {
                     Ok(val) => {
-                        let mut console = self.console.lock().unwrap();
-                        console.set(auth::CL_USERNAME, val.username.clone());
-                        console.set(auth::CL_UUID, val.id.clone());
-                        console.set(auth::AUTH_TOKEN, val.access_token.clone());
+                        self.vars.set(auth::CL_USERNAME, val.username.clone());
+                        self.vars.set(auth::CL_UUID, val.id.clone());
+                        self.vars.set(auth::AUTH_TOKEN, val.access_token.clone());
                         elements.profile = val;
                         return Some(Box::new(super::ServerList::new(None)));
                     },
diff --git a/src/screen/server_list.rs b/src/screen/server_list.rs
index 900403b..2a21330 100644
--- a/src/screen/server_list.rs
+++ b/src/screen/server_list.rs
@@ -388,7 +388,7 @@ impl super::Screen for ServerList {
         cog.set_v_attach(ui::VAttach::Middle);
         cog.set_h_attach(ui::HAttach::Center);
         super::button_action(ui_container, re.clone(), None, | game, _ | {
-            game.screen_sys.add_screen(Box::new(super::SettingsMenu::new(game.console.clone(), false)));
+            game.screen_sys.add_screen(Box::new(super::SettingsMenu::new(game.vars.clone(), false)));
         });
         elements.add(re);
         elements.add(ui_container.add(cog));
diff --git a/src/screen/settings_menu.rs b/src/screen/settings_menu.rs
index 7c0c9b8..566b81b 100644
--- a/src/screen/settings_menu.rs
+++ b/src/screen/settings_menu.rs
@@ -3,7 +3,7 @@ use render;
 use ui;
 use settings;
 
-use std::sync::{Arc, Mutex};
+use std::rc::Rc;
 
 pub fn new_submenu_button(text: &str, renderer: &mut render::Renderer, ui_container: &mut ui::Container, x: f64, y: f64) -> (ui::ElementRef<ui::Button>, ui::ElementRef<ui::Text>) {
     let (mut btn, mut txt) = super::new_button_text(renderer, text, x, y, 300.0, 40.0);
@@ -47,15 +47,15 @@ pub struct UIElements {
 }
 
 pub struct SettingsMenu {
-    console: Arc<Mutex<console::Console>>,
+    vars: Rc<console::Vars>,
     elements: Option<UIElements>,
     show_disconnect_button: bool
 }
 
 impl SettingsMenu {
-    pub fn new(console: Arc<Mutex<console::Console>>, show_disconnect_button: bool) -> SettingsMenu {
+    pub fn new(vars: Rc<console::Vars>, show_disconnect_button: bool) -> SettingsMenu {
         SettingsMenu {
-            console: console,
+            vars: vars,
             elements: None,
             show_disconnect_button: show_disconnect_button
         }
@@ -78,14 +78,14 @@ impl super::Screen for SettingsMenu {
         // From top and down
         let (btn_audio_settings, txt_audio_settings) = new_submenu_button("Audio settings...", renderer, ui_container, -160.0, -50.0);
         super::button_action(ui_container, btn_audio_settings.clone(), Some(txt_audio_settings.clone()), move |game, _| {
-            game.screen_sys.add_screen(Box::new(AudioSettingsMenu::new(game.console.clone())));
+            game.screen_sys.add_screen(Box::new(AudioSettingsMenu::new(game.vars.clone())));
         });
         elements.add(btn_audio_settings);
         elements.add(txt_audio_settings);
 
         let (btn_video_settings, txt_video_settings) = new_submenu_button("Video settings...", renderer, ui_container, 160.0, -50.0);
         super::button_action(ui_container, btn_video_settings.clone(), Some(txt_video_settings.clone()), move |game, _| {
-            game.screen_sys.add_screen(Box::new(VideoSettingsMenu::new(game.console.clone())));
+            game.screen_sys.add_screen(Box::new(VideoSettingsMenu::new(game.vars.clone())));
         });
         elements.add(btn_video_settings);
         elements.add(txt_video_settings);
@@ -166,14 +166,14 @@ impl super::Screen for SettingsMenu {
 }
 
 pub struct VideoSettingsMenu {
-    console: Arc<Mutex<console::Console>>,
+    vars: Rc<console::Vars>,
     elements: Option<UIElements>,
 }
 
 impl VideoSettingsMenu {
-    pub fn new(console: Arc<Mutex<console::Console>>) -> VideoSettingsMenu {
+    pub fn new(vars: Rc<console::Vars>) -> VideoSettingsMenu {
         VideoSettingsMenu {
-            console: console,
+            vars: vars,
             elements: None,
         }
     }
@@ -193,14 +193,9 @@ impl super::Screen for VideoSettingsMenu {
         let background = elements.add(ui_container.add(background));
 
         // Load defaults
-        let (r_max_fps, r_fov, r_vsync) = {
-            let console = self.console.lock().unwrap();
-            (
-                console.get(settings::R_MAX_FPS).clone(),
-                console.get(settings::R_FOV).clone(),
-                console.get(settings::R_VSYNC).clone()
-            )
-        };
+        let r_max_fps = *self.vars.get(settings::R_MAX_FPS);
+        let r_fov = *self.vars.get(settings::R_FOV);
+        let r_vsync = *self.vars.get(settings::R_VSYNC);
 
         // Setting buttons
         // TODO: Slider
@@ -211,11 +206,10 @@ impl super::Screen for VideoSettingsMenu {
         let (btn_vsync, txt_vsync) = new_submenu_button(get_bool_str!("VSync: {}", r_vsync, "Enabled", "Disabled"), renderer, ui_container, -160.0, 0.0);
         elements.add(txt_vsync.clone());
         super::button_action(ui_container, btn_vsync.clone(), Some(txt_vsync.clone()), move | game, ui_container | {
-            let mut console = game.console.lock().unwrap();
-            let r_vsync = !console.get(settings::R_VSYNC);
+            let r_vsync = !*game.vars.get(settings::R_VSYNC);
             let txt_vsync = ui_container.get_mut(&txt_vsync);
             txt_vsync.set_text(&game.renderer, get_bool_str!("VSync: {}", r_vsync, "Enabled", "Disabled"));
-            console.set(settings::R_VSYNC, r_vsync);
+            game.vars.set(settings::R_VSYNC, r_vsync);
         });
         elements.add(btn_vsync);
 
@@ -273,14 +267,14 @@ impl super::Screen for VideoSettingsMenu {
 }
 
 pub struct AudioSettingsMenu {
-    console: Arc<Mutex<console::Console>>,
+    vars: Rc<console::Vars>,
     elements: Option<UIElements>
 }
 
 impl AudioSettingsMenu {
-    pub fn new(console: Arc<Mutex<console::Console>>) -> AudioSettingsMenu {
+    pub fn new(vars: Rc<console::Vars>) -> AudioSettingsMenu {
         AudioSettingsMenu {
-            console: console,
+            vars: vars,
             elements: None
         }
     }
@@ -299,12 +293,9 @@ impl super::Screen for AudioSettingsMenu {
         background.set_a(100);
         let background = elements.add(ui_container.add(background));
 
-        let master_volume = {
-            let console = self.console.lock().unwrap();
-            (console.get(settings::CL_MASTER_VOLUME).clone())
-        };
+        let master_volume = *self.vars.get(settings::CL_MASTER_VOLUME);
 
-        let (btn_master_volume, txt_master_volume) = new_centered_button(master_volume.to_string().as_ref(), renderer, ui_container, -150.0, ui::VAttach::Middle);
+        let (btn_master_volume, txt_master_volume) = new_centered_button(&master_volume.to_string(), renderer, ui_container, -150.0, ui::VAttach::Middle);
         elements.add(btn_master_volume);
         elements.add(txt_master_volume);
 
diff --git a/src/server/mod.rs b/src/server/mod.rs
index f3f7eb6..4facb76 100644
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -16,17 +16,15 @@ use protocol::{self, mojang, packet};
 use world;
 use world::block;
 use rand::{self, Rng};
-use std::sync::{Arc, RwLock, Mutex};
+use std::sync::{Arc, RwLock};
 use std::sync::mpsc;
 use std::thread;
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use types::hash::FNVHash;
 use resources;
-use console;
 use render;
 use settings::Stevenkey;
-use auth;
 use ecs;
 use entity;
 use cgmath;
@@ -54,7 +52,6 @@ pub struct Server {
     tick_time: bool,
 
     resources: Arc<RwLock<resources::Manager>>,
-    console: Arc<Mutex<console::Console>>,
     version: usize,
 
     // Entity accessors
@@ -104,20 +101,11 @@ macro_rules! handle_packet {
 
 impl Server {
 
-    pub fn connect(resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>, address: &str) -> Result<Server, protocol::Error> {
+    pub fn connect(resources: Arc<RwLock<resources::Manager>>, profile: mojang::Profile, address: &str) -> Result<Server, protocol::Error> {
         use openssl::crypto::pkey;
         use openssl::crypto::rand::rand_bytes;
         let mut conn = try!(protocol::Conn::new(address));
 
-        let profile = {
-            let console = console.lock().unwrap();
-            mojang::Profile {
-                username: console.get(auth::CL_USERNAME).clone(),
-                id: console.get(auth::CL_UUID).clone(),
-                access_token: console.get(auth::AUTH_TOKEN).clone(),
-            }
-        };
-
         let host = conn.host.clone();
         let port = conn.port;
         try!(conn.write_packet(protocol::packet::handshake::serverbound::Handshake {
@@ -149,7 +137,7 @@ impl Server {
                     read.state = protocol::State::Play;
                     write.state = protocol::State::Play;
                     let rx = Self::spawn_reader(read);
-                    return Ok(Server::new(val.username, protocol::UUID::from_str(&val.uuid), resources, console, Some(write), Some(rx)));
+                    return Ok(Server::new(val.username, protocol::UUID::from_str(&val.uuid), resources, Some(write), Some(rx)));
                 }
                 protocol::packet::Packet::LoginDisconnect(val) => return Err(protocol::Error::Disconnect(val.reason)),
                 val => return Err(protocol::Error::Err(format!("Wrong packet: {:?}", val))),
@@ -199,7 +187,7 @@ impl Server {
 
         let rx = Self::spawn_reader(read);
 
-        Ok(Server::new(username, protocol::UUID::from_str(&uuid), resources, console, Some(write), Some(rx)))
+        Ok(Server::new(username, protocol::UUID::from_str(&uuid), resources, Some(write), Some(rx)))
     }
 
     fn spawn_reader(mut read: protocol::Conn) -> mpsc::Receiver<Result<packet::Packet, protocol::Error>> {
@@ -219,8 +207,8 @@ impl Server {
         rx
     }
 
-    pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>) -> Server {
-        let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, console, None, None);
+    pub fn dummy_server(resources: Arc<RwLock<resources::Manager>>) -> Server {
+        let mut server = Server::new("dummy".to_owned(), protocol::UUID::default(), resources, None, None);
         let mut rng = rand::thread_rng();
         for x in -7*16 .. 7*16 {
             for z in -7*16 .. 7*16 {
@@ -257,7 +245,7 @@ impl Server {
 
     fn new(
         username: String, uuid: protocol::UUID,
-        resources: Arc<RwLock<resources::Manager>>, console: Arc<Mutex<console::Console>>,
+        resources: Arc<RwLock<resources::Manager>>,
         conn: Option<protocol::Conn>, read_queue: Option<mpsc::Receiver<Result<packet::Packet, protocol::Error>>>
     ) -> Server {
         let mut entities = ecs::Manager::new();
@@ -284,7 +272,6 @@ impl Server {
 
             version: version,
             resources: resources,
-            console: console,
 
             // Entity accessors
             game_info: game_info,
diff --git a/src/settings.rs b/src/settings.rs
index f6a00ce..0d4c41e 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -59,19 +59,19 @@ pub const CL_KEYBIND_SNEAK: console::CVar<i64> = create_keybind!(LShift, "cl_key
 pub const CL_KEYBIND_SPRINT: console::CVar<i64> = create_keybind!(LCtrl, "cl_keybind_sprint", "Keybinding for sprinting");
 pub const CL_KEYBIND_JUMP: console::CVar<i64> = create_keybind!(Space, "cl_keybind_jump", "Keybinding for jumping");
 
-pub fn register_vars(console: &mut console::Console) {
-    console.register(R_MAX_FPS);
-    console.register(R_FOV);
-    console.register(R_VSYNC);
-    console.register(CL_MASTER_VOLUME);
-    console.register(CL_KEYBIND_FORWARD);
-    console.register(CL_KEYBIND_BACKWARD);
-    console.register(CL_KEYBIND_LEFT);
-    console.register(CL_KEYBIND_RIGHT);
-    console.register(CL_KEYBIND_OPEN_INV);
-    console.register(CL_KEYBIND_SNEAK);
-    console.register(CL_KEYBIND_SPRINT);
-    console.register(CL_KEYBIND_JUMP);
+pub fn register_vars(vars: &mut console::Vars) {
+    vars.register(R_MAX_FPS);
+    vars.register(R_FOV);
+    vars.register(R_VSYNC);
+    vars.register(CL_MASTER_VOLUME);
+    vars.register(CL_KEYBIND_FORWARD);
+    vars.register(CL_KEYBIND_BACKWARD);
+    vars.register(CL_KEYBIND_LEFT);
+    vars.register(CL_KEYBIND_RIGHT);
+    vars.register(CL_KEYBIND_OPEN_INV);
+    vars.register(CL_KEYBIND_SNEAK);
+    vars.register(CL_KEYBIND_SPRINT);
+    vars.register(CL_KEYBIND_JUMP);
 }
 
 #[derive(Hash, PartialEq, Eq)]
@@ -93,9 +93,9 @@ impl Stevenkey {
             Stevenkey::Sprint, Stevenkey::Jump)
     }
 
-    pub fn get_by_keycode(keycode: Keycode, console: &console::Console) -> Option<Stevenkey> {
+    pub fn get_by_keycode(keycode: Keycode, vars: &console::Vars) -> Option<Stevenkey> {
         for steven_key in Stevenkey::values() {
-            if keycode as i64 == *console.get(steven_key.get_cvar()) {
+            if keycode as i64 == *vars.get(steven_key.get_cvar()) {
                 return Some(steven_key)
             }
         }