diff --git a/src/modules/autolink.rs b/src/modules/autolink.rs
index 083ab0c..1394d80 100644
--- a/src/modules/autolink.rs
+++ b/src/modules/autolink.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -19,12 +19,8 @@ use regex::Regex;
 pub struct AutolinkModule {}
 
 impl AutolinkModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
-        Module {
-            event_loop: Box::new(AutolinkModule {}),
-            module_type: String::from("autolink"),
-            config: config.clone()
-        }
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
+        Box::new(AutolinkModule {})
     }
 }
 
diff --git a/src/modules/discord.rs b/src/modules/discord.rs
index 308341f..2cbaefc 100644
--- a/src/modules/discord.rs
+++ b/src/modules/discord.rs
@@ -2,12 +2,10 @@ use discord;
 use discord::Discord;
 use discord::model::{Event, PossibleServer};
 
-use modules::Module;
 use modules::EventLoop;
 use toml::value::Table;
 
 use event;
-use event::Envelope;
 
 use std::sync::Arc;
 use std::sync::mpsc::Receiver;
@@ -26,7 +24,7 @@ pub struct DiscordModule {
 const DEFAULT_PLAYING: &'static str = "tenquestionmarks 0.0.2";
 
 impl DiscordModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let token = configuration.get("token")
                                  .and_then(|value| value.as_str())
                                  .unwrap_or("");
@@ -35,14 +33,10 @@ impl DiscordModule {
                                    .and_then(|value| value.as_str())
                                    .unwrap_or(DEFAULT_PLAYING);
 
-        Module {
-            module_type: String::from("Discord"),
-            event_loop: Box::new(DiscordModule {
-                token: String::from(token),
-                playing: String::from(playing)
-            }),
-            config: configuration.clone()
-        }
+        Box::new(DiscordModule {
+            token: String::from(token),
+            playing: String::from(playing)
+        })
     }
 }
 
diff --git a/src/modules/echo.rs b/src/modules/echo.rs
index 711a840..cd03e2e 100644
--- a/src/modules/echo.rs
+++ b/src/modules/echo.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -13,18 +13,14 @@ pub struct EchoModule {
 }
 
 impl EchoModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("!echo");
 
-        Module {
-            module_type: String::from("echo"),
-            event_loop: Box::new(EchoModule {
-                prefix: String::from(prefix)
-            }),
-            config: configuration.clone()
-        }
+        Box::new(EchoModule {
+            prefix: String::from(prefix)
+        })
     }
 }
 
diff --git a/src/modules/echobox.rs b/src/modules/echobox.rs
index 4aaa0ba..10a22e9 100644
--- a/src/modules/echobox.rs
+++ b/src/modules/echobox.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -15,7 +15,7 @@ pub struct EchoboxModule {
 }
 
 impl EchoboxModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("?echobox");
@@ -24,14 +24,10 @@ impl EchoboxModule {
                                 .and_then(|value| value.as_str())
                                 .unwrap_or("echobox.db");
 
-        Module {
-            module_type: String::from("echo"),
-            event_loop: Box::new(EchoboxModule {
-                prefix: String::from(prefix),
-                file: String::from(file)
-            }),
-            config: configuration.clone()
-        }
+        Box::new(EchoboxModule {
+            prefix: String::from(prefix),
+            file: String::from(file)
+        })
     }
 }
 
diff --git a/src/modules/loader.rs b/src/modules/loader.rs
index 1562c29..4739cce 100644
--- a/src/modules/loader.rs
+++ b/src/modules/loader.rs
@@ -4,7 +4,7 @@ use std::fmt;
 
 use toml::value::Table;
 
-use modules::Module;
+use modules::{Module, EventLoop};
 use modules::discord::DiscordModule;
 use modules::lua::LuaModule;
 use modules::stdin::StdinModule;
@@ -16,21 +16,21 @@ use modules::autolink::AutolinkModule;
 use modules::logger::LoggerModule;
 
 pub struct ModuleLoader {
-    types: BTreeMap<&'static str, fn(&Table, &Table) -> Module>
+    types: BTreeMap<&'static str, fn(&Table, &Table) -> Box<EventLoop>>
 }
 
 impl ModuleLoader {
     pub fn new () -> ModuleLoader {
         let mut types = BTreeMap::new();
-        types.insert("discord", DiscordModule::new as fn(&Table, &Table) -> Module);
-        types.insert("lua", LuaModule::new as fn(&Table, &Table) -> Module);
-        types.insert("stdin", StdinModule::new as fn(&Table, &Table) -> Module);
-        types.insert("echo", EchoModule::new as fn(&Table, &Table) -> Module);
-        types.insert("random", RandomModule::new as fn(&Table, &Table) -> Module);
-        types.insert("pvn", PvnModule::new as fn(&Table, &Table) -> Module);
-        types.insert("echobox", EchoboxModule::new as fn(&Table, &Table) -> Module);
-        types.insert("autolink", AutolinkModule::new as fn(&Table, &Table) -> Module);
-        types.insert("logger", LoggerModule::new as fn(&Table, &Table) -> Module);
+        types.insert("discord", DiscordModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("lua", LuaModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("stdin", StdinModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("echo", EchoModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("random", RandomModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("pvn", PvnModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("echobox", EchoboxModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("autolink", AutolinkModule::new as fn(&Table, &Table) -> Box<EventLoop>);
+        types.insert("logger", LoggerModule::new as fn(&Table, &Table) -> Box<EventLoop>);
         ModuleLoader {
             types: types
         }
@@ -65,7 +65,11 @@ impl ModuleLoader {
                                              .unwrap_or(name);
 
         match self.types.get(module_type) {
-           Some(constructor) => Result::Ok(constructor(general_configuration, module_configuration)),
+           Some(constructor) => Result::Ok(Module {
+               module_type: module_type.to_owned(),
+               config: module_configuration.clone(),
+               event_loop: constructor(general_configuration, module_configuration)
+           }),
            None => Result::Err(ModuleLoaderError { message: format!("No such module type: {}", module_type) })
         }
     }
diff --git a/src/modules/logger.rs b/src/modules/logger.rs
index ada47fd..21ac457 100644
--- a/src/modules/logger.rs
+++ b/src/modules/logger.rs
@@ -1,22 +1,17 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
 use std::sync::mpsc::Receiver;
 use transformable_channels::mpsc::ExtSender;
 
-use helpers::command::split_command;
 use event::{Event, Envelope};
 
 pub struct LoggerModule {}
 
 impl LoggerModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
-        Module {
-            module_type: String::from("logger"),
-            event_loop: Box::new(LoggerModule {}),
-            config: configuration.clone()
-        }
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
+        Box::new(LoggerModule {})
     }
 }
 
diff --git a/src/modules/lua.rs b/src/modules/lua.rs
index 6819e01..14d445d 100644
--- a/src/modules/lua.rs
+++ b/src/modules/lua.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 
 use toml::Value;
 use toml::value::Table;
@@ -23,16 +23,12 @@ pub struct LuaModule {
 }
 
 impl LuaModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
-        Module {
-            module_type: String::from("lua"),
-            event_loop: Box::new(LuaModule {
-                code: config.get("code").and_then(|value| value.as_str()).map(String::from),
-                file: config.get("file").and_then(|value| value.as_str()).map(String::from),
-                variables: config.clone()
-            }),
-            config: config.clone()
-        }
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
+        Box::new(LuaModule {
+            code: config.get("code").and_then(|value| value.as_str()).map(String::from),
+            file: config.get("file").and_then(|value| value.as_str()).map(String::from),
+            variables: config.clone()
+        })
     }
 }
 
diff --git a/src/modules/pvn.rs b/src/modules/pvn.rs
index df636e4..761d0db 100644
--- a/src/modules/pvn.rs
+++ b/src/modules/pvn.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -17,12 +17,8 @@ use pvn::ninjas::{Ninja, Ninjas};
 pub struct PvnModule {}
 
 impl PvnModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
-        Module {
-            module_type: String::from("pvn"),
-            event_loop: Box::new(PvnModule {}),
-            config: configuration.clone()
-        }
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
+        Box::new(PvnModule {})
     }
 }
 
diff --git a/src/modules/random.rs b/src/modules/random.rs
index 3fd19a6..19a259a 100644
--- a/src/modules/random.rs
+++ b/src/modules/random.rs
@@ -1,4 +1,4 @@
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use std::sync::Arc;
@@ -15,7 +15,7 @@ pub struct RandomModule {
 }
 
 impl RandomModule {
-    pub fn new (_: &Table, configuration: &Table) -> Module {
+    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
         let prefix = configuration.get("prefix")
                                   .and_then(|value| value.as_str())
                                   .unwrap_or("?random");
@@ -28,14 +28,10 @@ impl RandomModule {
                                      .map(|value| { String::from(value.as_str().unwrap()) })
                                      .collect();
 
-        Module {
-            module_type: String::from("random"),
-            event_loop: Box::new(RandomModule {
-                prefix: String::from(prefix),
-                responses: responses
-            }),
-            config: configuration.clone()
-        }
+        Box::new(RandomModule {
+            prefix: String::from(prefix),
+            responses: responses
+        })
     }
 }
 
diff --git a/src/modules/stdin.rs b/src/modules/stdin.rs
index ff33bab..51d4596 100644
--- a/src/modules/stdin.rs
+++ b/src/modules/stdin.rs
@@ -1,6 +1,6 @@
 use std::io;
 
-use modules::{Module, EventLoop};
+use modules::EventLoop;
 use toml::value::Table;
 
 use {MessageSender, Message, User};
@@ -26,12 +26,8 @@ impl MessageSender for StdinMessageSender {
 }
 
 impl StdinModule {
-    pub fn new (_: &Table, config: &Table) -> Module {
-        Module {
-            module_type: String::from("stdin"),
-            event_loop: Box::new(StdinModule {}),
-            config: config.clone()
-        }
+    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
+        Box::new(StdinModule {})
     }
 }