diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0833fd9..16da6f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,8 @@
 ### Changed
 - `build.rs` implements symbol name scraping natively, and no longer relies on
   BoringSSL's `read_symbols.go`.
+- Minimum required Rust version raised to 1.36
+- Minimum required Go version lowered to 1.10
 
 ### Fixed
 - `build.rs` no longer respects `$GOPATH`, instead it always uses the
diff --git a/README.md b/README.md
index 0ac5ed6..7c9a9cc 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,8 @@
 
 ## Dependencies
 
+Rust 1.36 or newer is required.
+
 Mundane vendors a copy of the BoringSSL source, so BoringSSL does not need to be
 installed locally in order to build. However, the BoringSSL build system has the
 following dependencies:
@@ -29,7 +31,7 @@
   makes compilation significantly faster; if both are present, Ninja will be
   used. On Windows, Ninja is required.
 - A C++ compiler
-- Go 1.11 or later
+- Go 1.10 or later
 - To build the x86 and x86_64 assembly, your assembler must support AVX2
   instructions and `MOVBE`. If using GNU binutils, you must have 2.22 or later.
 
diff --git a/build/obj.rs b/build/obj.rs
index 9df92a2..98feddf 100644
--- a/build/obj.rs
+++ b/build/obj.rs
@@ -15,13 +15,13 @@
 use std::error;
 
 /// List symbols exported by the file (expected to be either a static library or an object file).
-pub fn exported_symbols(file: &str) -> Result<BTreeSet<String>, Box<error::Error>> {
+pub fn exported_symbols(file: &str) -> Result<BTreeSet<String>, Box<dyn error::Error>> {
     let mut bytes = Vec::new();
     File::open(file)?.read_to_end(&mut bytes)?;
     binary_exported_symbols(&bytes)
 }
 
-fn binary_exported_symbols(bytes: &[u8]) -> Result<BTreeSet<String>, Box<error::Error>> {
+fn binary_exported_symbols(bytes: &[u8]) -> Result<BTreeSet<String>, Box<dyn error::Error>> {
     let mut symbols = BTreeSet::new();
     match goblin::Object::parse(bytes)? {
         goblin::Object::Archive(archive) => {
diff --git a/src/boringssl/mod.rs b/src/boringssl/mod.rs
index 4ae02f6..b51a979 100644
--- a/src/boringssl/mod.rs
+++ b/src/boringssl/mod.rs
@@ -98,7 +98,8 @@
 use std::fmt::{self, Debug, Display, Formatter};
 use std::num::NonZeroUsize;
 use std::os::raw::{c_char, c_int, c_uint, c_void};
-use std::{mem, ptr, slice};
+use std::mem::MaybeUninit;
+use std::{ptr, slice};
 
 use boringssl::abort::UnwrapAbort;
 use boringssl::raw::{
@@ -130,9 +131,9 @@
     #[must_use]
     pub fn cbb_new(initial_capacity: usize) -> Result<CStackWrapper<CBB>, BoringError> {
         unsafe {
-            let mut cbb = mem::uninitialized();
-            CBB_init(&mut cbb, initial_capacity)?;
-            Ok(CStackWrapper::new(cbb))
+            let mut cbb = MaybeUninit::uninit();
+            CBB_init(cbb.as_mut_ptr(), initial_capacity)?;
+            Ok(CStackWrapper::new(cbb.assume_init()))
         }
     }
 
@@ -184,9 +185,9 @@
         with_cbs: F,
     ) -> O {
         unsafe {
-            let mut cbs = mem::uninitialized();
-            CBS_init(&mut cbs, bytes.as_ptr(), bytes.len());
-            let mut cbs = CStackWrapper::new(cbs);
+            let mut cbs = MaybeUninit::uninit();
+            CBS_init(cbs.as_mut_ptr(), bytes.as_ptr(), bytes.len());
+            let mut cbs = CStackWrapper::new(cbs.assume_init());
             with_cbs(&mut cbs)
         }
     }
@@ -475,9 +476,9 @@
     #[must_use]
     pub fn sha384_new() -> CStackWrapper<SHA512_CTX> {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            SHA384_Init(&mut ctx);
-            CStackWrapper::new(ctx)
+            let mut ctx = MaybeUninit::uninit();
+            SHA384_Init(ctx.as_mut_ptr());
+            CStackWrapper::new(ctx.assume_init())
         }
     }
 }
@@ -527,10 +528,10 @@
         md: &CRef<'static, EVP_MD>,
     ) -> Result<CStackWrapper<HMAC_CTX>, BoringError> {
         unsafe {
-            let mut ctx = mem::uninitialized();
-            HMAC_CTX_init(&mut ctx);
-            HMAC_Init_ex(&mut ctx, key.as_ptr() as *const c_void, key.len(), md.as_const())?;
-            Ok(CStackWrapper::new(ctx))
+            let mut ctx = MaybeUninit::uninit();
+            HMAC_CTX_init(ctx.as_mut_ptr());
+            HMAC_Init_ex(ctx.as_mut_ptr(), key.as_ptr() as *const c_void, key.len(), md.as_const())?;
+            Ok(CStackWrapper::new(ctx.assume_init()))
         }
     }
 
@@ -762,7 +763,7 @@
                 &mut self,
             ) -> [u8; ::boringssl::ffi::$digest_len as usize] {
                 unsafe {
-                    let mut md: [u8; ::boringssl::ffi::$digest_len as usize] = mem::uninitialized();
+                    let mut md = MaybeUninit::<[u8; ::boringssl::ffi::$digest_len as usize]>::uninit();
                     // SHA1_Final promises to return 1. SHA256_Final,
                     // SHA384_Final, and SHA512_Final all document that they
                     // only fail due to programmer error. The only input to the
@@ -773,8 +774,8 @@
                     // here.
                     //
                     // TODO(joshlf): Figure out how XXX_Final can fail.
-                    ::boringssl::raw::$final_raw((&mut md[..]).as_mut_ptr(), self.as_mut()).unwrap_abort();
-                    md
+                    ::boringssl::raw::$final_raw(md.as_mut_ptr() as _, self.as_mut()).unwrap_abort();
+                    md.assume_init()
                 }
             }
         }
diff --git a/src/boringssl/wrapper.rs b/src/boringssl/wrapper.rs
index 3b6ac46..a6953b9 100644
--- a/src/boringssl/wrapper.rs
+++ b/src/boringssl/wrapper.rs
@@ -5,7 +5,7 @@
 // https://opensource.org/licenses/MIT.
 
 use std::marker::PhantomData;
-use std::mem;
+use std::mem::{self, MaybeUninit};
 use std::ptr::NonNull;
 
 /// A trait that can be used to ensure that users of the boringssl module can't
@@ -338,9 +338,9 @@
     // CStackWrapper::new).
     fn default() -> CStackWrapper<C> {
         unsafe {
-            let mut obj: C = mem::uninitialized();
-            C::init(&mut obj);
-            CStackWrapper { obj, _no_sync: PhantomData }
+            let mut obj = MaybeUninit::<C>::uninit();
+            C::init(obj.as_mut_ptr());
+            CStackWrapper { obj: obj.assume_init(), _no_sync: PhantomData }
         }
     }
 }