diff --git a/examples/decode.rs b/examples/decode.rs
index 366f69b2e..6a4e4edcd 100644
--- a/examples/decode.rs
+++ b/examples/decode.rs
@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 use serde::Deserialize;
 use std::collections::HashMap;
 
diff --git a/examples/decode_file.rs b/examples/decode_file.rs
index a49cb3fba..724d91c07 100644
--- a/examples/decode_file.rs
+++ b/examples/decode_file.rs
@@ -1,4 +1,4 @@
-use ron::de::from_reader;
+use ron::from_reader;
 use serde::Deserialize;
 use std::{collections::HashMap, fs::File};
 
diff --git a/examples/encode.rs b/examples/encode.rs
index ad1a237ba..d0ce07a85 100644
--- a/examples/encode.rs
+++ b/examples/encode.rs
@@ -1,4 +1,4 @@
-use ron::ser::{to_string_pretty, PrettyConfig};
+use ron::{to_string_pretty, PrettyConfig};
 use serde::Serialize;
 use std::{collections::HashMap, iter::FromIterator};
 
diff --git a/src/lib.rs b/src/lib.rs
index d9bf34ae5..0e9bed712 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -59,17 +59,17 @@ Serializing / Deserializing is as simple as calling `to_string` / `from_str`.
 
 #![doc(html_root_url = "https://docs.rs/ron/0.6.0")]
 
-pub mod de;
-pub mod ser;
+mod de;
+mod ser;
 
 pub mod error;
 pub mod value;
 
 pub mod extensions;
 
-pub use de::{from_str, Deserializer};
+pub use de::{from_bytes, from_reader, from_str, Deserializer};
 pub use error::{Error, Result};
-pub use ser::{to_string, Serializer};
+pub use ser::{to_string, to_string_pretty, to_writer, to_writer_pretty, PrettyConfig, Serializer};
 pub use value::{Map, Number, Value};
 
 mod parse;
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
index 24d3bf9b7..d6288ebac 100644
--- a/src/ser/mod.rs
+++ b/src/ser/mod.rs
@@ -62,7 +62,7 @@ struct Pretty {
 /// # Examples
 ///
 /// ```
-/// use ron::ser::PrettyConfig;
+/// use ron::PrettyConfig;
 ///
 /// let my_config = PrettyConfig::new()
 ///     .depth_limit(4)
diff --git a/tests/117_untagged_tuple_variant.rs b/tests/117_untagged_tuple_variant.rs
index 6d98deb65..d394c3cfc 100644
--- a/tests/117_untagged_tuple_variant.rs
+++ b/tests/117_untagged_tuple_variant.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)]
diff --git a/tests/123_enum_representation.rs b/tests/123_enum_representation.rs
index 3f82b08cd..6c4ecdc5f 100644
--- a/tests/123_enum_representation.rs
+++ b/tests/123_enum_representation.rs
@@ -1,4 +1,4 @@
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 use std::{cmp::PartialEq, fmt::Debug};
 
diff --git a/tests/147_empty_sets_serialisation.rs b/tests/147_empty_sets_serialisation.rs
index a3fab4624..12af9b07e 100644
--- a/tests/147_empty_sets_serialisation.rs
+++ b/tests/147_empty_sets_serialisation.rs
@@ -41,10 +41,10 @@ fn empty_sets_arrays() {
             .collect(),
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .enumerate_arrays(true)
         .new_line("\n".to_string());
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
@@ -63,7 +63,7 @@ fn empty_sets_arrays() {
         serial
     );
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
diff --git a/tests/240_array_pretty.rs b/tests/240_array_pretty.rs
index 5402ba93e..2a53c299b 100644
--- a/tests/240_array_pretty.rs
+++ b/tests/240_array_pretty.rs
@@ -1,4 +1,4 @@
-use ron::ser::{to_string_pretty, PrettyConfig};
+use ron::{to_string_pretty, PrettyConfig};
 
 #[test]
 fn small_array() {
diff --git a/tests/big_struct.rs b/tests/big_struct.rs
index 40583606f..340b4c541 100644
--- a/tests/big_struct.rs
+++ b/tests/big_struct.rs
@@ -75,5 +75,5 @@ const CONFIG: &str = "(
 
 #[test]
 fn deserialize_big_struct() {
-    ron::de::from_str::<ImGuiStyleSave>(CONFIG).unwrap();
+    ron::from_str::<ImGuiStyleSave>(CONFIG).unwrap();
 }
diff --git a/tests/borrowed_str.rs b/tests/borrowed_str.rs
index f01eeb141..65e7122e4 100644
--- a/tests/borrowed_str.rs
+++ b/tests/borrowed_str.rs
@@ -10,7 +10,7 @@ const BORROWED: &str = "Borrowed(value: \"test\")";
 #[test]
 fn borrowed_str() {
     assert_eq!(
-        ron::de::from_str(BORROWED).ok(),
+        ron::from_str(BORROWED).ok(),
         Some(Borrowed { value: "test" })
     );
 }
diff --git a/tests/comments.rs b/tests/comments.rs
index f5d6f73c1..db7e85fdc 100644
--- a/tests/comments.rs
+++ b/tests/comments.rs
@@ -1,4 +1,4 @@
-use ron::de::{from_str, Error as RonErr, ErrorCode, Position};
+use ron::{from_str, Error as RonErr, ErrorCode, Position};
 
 #[test]
 fn test_simple() {
diff --git a/tests/depth_limit.rs b/tests/depth_limit.rs
index 543c922ec..3eea05d8d 100644
--- a/tests/depth_limit.rs
+++ b/tests/depth_limit.rs
@@ -48,12 +48,12 @@ fn depth_limit() {
         array: vec![(); 3],
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .depth_limit(1)
         .separate_tuple_members(true)
         .enumerate_arrays(true)
         .new_line("\n".to_string());
-    let s = ron::ser::to_string_pretty(&data, pretty);
+    let s = ron::to_string_pretty(&data, pretty);
 
     assert_eq!(s, Ok(EXPECTED.to_string()));
 }
diff --git a/tests/escape.rs b/tests/escape.rs
index 20cc87ee1..14518d815 100644
--- a/tests/escape.rs
+++ b/tests/escape.rs
@@ -1,4 +1,4 @@
-use ron::{de::from_str, ser::to_string};
+use ron::{from_str, to_string};
 use serde::{Deserialize, Serialize};
 use std::{char::from_u32, fmt::Debug};
 
diff --git a/tests/extensions.rs b/tests/extensions.rs
index 81157257a..8cd83669a 100644
--- a/tests/extensions.rs
+++ b/tests/extensions.rs
@@ -47,7 +47,7 @@ const CONFIG_U_NT: &str = "
 
 #[test]
 fn unwrap_newtypes() {
-    let d: Struct = ron::de::from_str(&CONFIG_U_NT).expect("Failed to deserialize");
+    let d: Struct = ron::from_str(&CONFIG_U_NT).expect("Failed to deserialize");
 
     println!("unwrap_newtypes: {:#?}", d);
 }
@@ -75,7 +75,7 @@ const CONFIG_I_S: &str = "
 
 #[test]
 fn implicit_some() {
-    let d: Struct = ron::de::from_str(&CONFIG_I_S).expect("Failed to deserialize");
+    let d: Struct = ron::from_str(&CONFIG_I_S).expect("Failed to deserialize");
 
     println!("implicit_some: {:#?}", d);
 }
diff --git a/tests/floats.rs b/tests/floats.rs
index 5a16f65b3..bcafa3bec 100644
--- a/tests/floats.rs
+++ b/tests/floats.rs
@@ -1,7 +1,4 @@
-use ron::{
-    de::from_str,
-    ser::{to_string_pretty, PrettyConfig},
-};
+use ron::{from_str, to_string_pretty, PrettyConfig};
 
 #[test]
 fn test_inf_and_nan() {
diff --git a/tests/large_number.rs b/tests/large_number.rs
index c8ae49f0b..ce935db3b 100644
--- a/tests/large_number.rs
+++ b/tests/large_number.rs
@@ -3,8 +3,8 @@ use ron::value::{Number, Value};
 #[test]
 fn test_large_number() {
     let test_var = Value::Number(Number::new(10000000000000000000000.0f64));
-    let test_ser = ron::ser::to_string(&test_var).unwrap();
-    let test_deser = ron::de::from_str::<Value>(&test_ser);
+    let test_ser = ron::to_string(&test_var).unwrap();
+    let test_deser = ron::from_str::<Value>(&test_ser);
 
     assert_eq!(
         test_deser.unwrap(),
@@ -17,9 +17,9 @@ fn test_large_integer_to_float() {
     use ron::value::Float;
     let test_var = std::i64::MAX as u64 + 1;
     let expected = test_var as f64; // Is exactly representable by f64
-    let test_ser = ron::ser::to_string(&test_var).unwrap();
+    let test_ser = ron::to_string(&test_var).unwrap();
     assert_eq!(test_ser, test_var.to_string());
-    let test_deser = ron::de::from_str::<Value>(&test_ser);
+    let test_deser = ron::from_str::<Value>(&test_ser);
 
     assert_eq!(
         test_deser.unwrap(),
diff --git a/tests/min_max.rs b/tests/min_max.rs
index f53bcb2cf..81efe4d46 100644
--- a/tests/min_max.rs
+++ b/tests/min_max.rs
@@ -1,4 +1,4 @@
-use ron::{de::*, ser::*};
+use ron::*;
 
 #[test]
 fn test_i32_min() {
diff --git a/tests/numbers.rs b/tests/numbers.rs
index 26b97a53d..7b2216d73 100644
--- a/tests/numbers.rs
+++ b/tests/numbers.rs
@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 
 #[test]
 fn test_hex() {
diff --git a/tests/preserve_sequence.rs b/tests/preserve_sequence.rs
index 9bb1d4899..773b828e0 100644
--- a/tests/preserve_sequence.rs
+++ b/tests/preserve_sequence.rs
@@ -1,7 +1,4 @@
-use ron::{
-    de::from_str,
-    ser::{to_string_pretty, PrettyConfig},
-};
+use ron::{from_str, to_string_pretty, PrettyConfig};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
diff --git a/tests/roundtrip.rs b/tests/roundtrip.rs
index 78517d9e8..ec80c22c5 100644
--- a/tests/roundtrip.rs
+++ b/tests/roundtrip.rs
@@ -44,11 +44,11 @@ fn roundtrip() {
         .collect(),
     };
 
-    let serial = ron::ser::to_string(&value).unwrap();
+    let serial = ron::to_string(&value).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
@@ -68,14 +68,14 @@ fn roundtrip_pretty() {
         .collect(),
     };
 
-    let pretty = ron::ser::PrettyConfig::new()
+    let pretty = ron::PrettyConfig::new()
         .enumerate_arrays(true)
         .extensions(Extensions::IMPLICIT_SOME);
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
@@ -110,12 +110,12 @@ fn roundtrip_sep_tuple_members() {
 
     let value = Both { a, b };
 
-    let pretty = ron::ser::PrettyConfig::new().separate_tuple_members(true);
-    let serial = ron::ser::to_string_pretty(&value, pretty).unwrap();
+    let pretty = ron::PrettyConfig::new().separate_tuple_members(true);
+    let serial = ron::to_string_pretty(&value, pretty).unwrap();
 
     println!("Serialized: {}", serial);
 
-    let deserial = ron::de::from_str(&serial);
+    let deserial = ron::from_str(&serial);
 
     assert_eq!(Ok(value), deserial);
 }
diff --git a/tests/struct_integers.rs b/tests/struct_integers.rs
index c7f80a0a5..33c24702b 100644
--- a/tests/struct_integers.rs
+++ b/tests/struct_integers.rs
@@ -28,8 +28,8 @@ fn roundtrip() {
         i: std::u64::MAX,
         j: std::u128::MAX,
     };
-    let serialized = ron::ser::to_string(&s).unwrap();
+    let serialized = ron::to_string(&s).unwrap();
     dbg!(&serialized);
-    let deserialized = ron::de::from_str(&serialized).unwrap();
+    let deserialized = ron::from_str(&serialized).unwrap();
     assert_eq!(s, deserialized,);
 }
diff --git a/tests/unicode.rs b/tests/unicode.rs
index 0617eeed1..a3dd32982 100644
--- a/tests/unicode.rs
+++ b/tests/unicode.rs
@@ -1,4 +1,4 @@
-use ron::de::from_str;
+use ron::from_str;
 
 #[test]
 fn test_char() {
diff --git a/tests/value.rs b/tests/value.rs
index 1e1ff5b99..8bf36df7e 100644
--- a/tests/value.rs
+++ b/tests/value.rs
@@ -91,7 +91,7 @@ struct Scene2 {
 
 #[test]
 fn roundtrip() {
-    use ron::{de::from_str, ser::to_string};
+    use ron::{from_str, to_string};
 
     {
         let s = to_string(&Scene2 {