diff --git a/Cargo.toml b/Cargo.toml
index a72208a81..bf2aa5f09 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,12 +36,13 @@ exclude = [
 bench = false
 
 [features]
-default = ["prost-derive"]
+default = ["prost-derive", "std"]
 no-recursion-limit = []
+std = [] # When std is disabled, we provide no_std support in prost
 
 [dependencies]
-bytes = "0.5"
-prost-derive = { version = "0.6.1", path = "prost-derive", optional = true }
+bytes = { version = "0.5", default-features = false }
+prost-derive = { version = "0.6.1", path = "prost-derive", default-features = false, optional = true }
 
 [dev-dependencies]
 criterion = "0.3"
diff --git a/conformance/Cargo.toml b/conformance/Cargo.toml
index 7783eb5c5..562ffbad6 100644
--- a/conformance/Cargo.toml
+++ b/conformance/Cargo.toml
@@ -6,7 +6,7 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = "0.5"
+bytes = { version = "0.5", default-features = false }
 env_logger = { version = "0.7", default-features = false }
 log = "0.4"
 prost = { path = ".." }
diff --git a/prost-build/Cargo.toml b/prost-build/Cargo.toml
index ebc0083a7..7978ac296 100644
--- a/prost-build/Cargo.toml
+++ b/prost-build/Cargo.toml
@@ -10,14 +10,14 @@ description = "A Protocol Buffers implementation for the Rust Language."
 edition = "2018"
 
 [dependencies]
-bytes = "0.5"
+bytes = { version = "0.5", default-features = false }
 heck = "0.3"
 itertools = "0.8"
 log = "0.4"
 multimap = { version = "0.8", default-features = false }
 petgraph = { version = "0.5", default-features = false }
-prost = { version = "0.6.1", path = ".." }
-prost-types = { version = "0.6.1", path = "../prost-types" }
+prost = { version = "0.6.1", path = "..", default-features = false }
+prost-types = { version = "0.6.1", path = "../prost-types", default-features = false }
 tempfile = "3"
 
 [build-dependencies]
diff --git a/prost-build/src/code_generator.rs b/prost-build/src/code_generator.rs
index eaa735cf6..b042cf228 100644
--- a/prost-build/src/code_generator.rs
+++ b/prost-build/src/code_generator.rs
@@ -330,6 +330,7 @@ impl<'a> CodeGenerator<'a> {
         if boxed {
             self.buf.push_str(", boxed");
         }
+
         self.buf.push_str(", tag=\"");
         self.buf.push_str(&field.number().to_string());
 
@@ -374,12 +375,12 @@ impl<'a> CodeGenerator<'a> {
         self.buf.push_str(&to_snake(field.name()));
         self.buf.push_str(": ");
         if repeated {
-            self.buf.push_str("::std::vec::Vec<");
+            self.buf.push_str("prost::alloc::vec::Vec<");
         } else if optional {
-            self.buf.push_str("::std::option::Option<");
+            self.buf.push_str("core::option::Option<");
         }
         if boxed {
-            self.buf.push_str("::std::boxed::Box<");
+            self.buf.push_str("prost::alloc::boxed::Box<");
         }
         self.buf.push_str(&ty);
         if boxed {
@@ -416,10 +417,10 @@ impl<'a> CodeGenerator<'a> {
             .btree_map
             .iter()
             .any(|matcher| match_ident(matcher, msg_name, Some(field.name())));
-        let (annotation_ty, rust_ty) = if btree_map {
-            ("btree_map", "BTreeMap")
+        let (annotation_ty, lib_name, rust_ty) = if btree_map {
+            ("btree_map", "prost::alloc::collections", "BTreeMap")
         } else {
-            ("map", "HashMap")
+            ("map", "std::collections", "HashMap")
         };
 
         let key_tag = self.field_type_tag(key);
@@ -434,8 +435,9 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(msg_name, field.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: ::std::collections::{}<{}, {}>,\n",
+            "pub {}: {}::{}<{}, {}>,\n",
             to_snake(field.name()),
+            lib_name,
             rust_ty,
             key_ty,
             value_ty
@@ -467,7 +469,7 @@ impl<'a> CodeGenerator<'a> {
         self.append_field_attributes(fq_message_name, oneof.name());
         self.push_indent();
         self.buf.push_str(&format!(
-            "pub {}: ::std::option::Option<{}>,\n",
+            "pub {}: core::option::Option<{}>,\n",
             to_snake(oneof.name()),
             name
         ));
@@ -528,8 +530,11 @@ impl<'a> CodeGenerator<'a> {
             );
 
             if boxed {
-                self.buf
-                    .push_str(&format!("{}(Box<{}>),\n", to_upper_camel(field.name()), ty));
+                self.buf.push_str(&format!(
+                    "{}(prost::alloc::boxed::Box<{}>),\n",
+                    to_upper_camel(field.name()),
+                    ty
+                ));
             } else {
                 self.buf
                     .push_str(&format!("{}({}),\n", to_upper_camel(field.name()), ty));
@@ -721,8 +726,8 @@ impl<'a> CodeGenerator<'a> {
             Type::Int32 | Type::Sfixed32 | Type::Sint32 | Type::Enum => String::from("i32"),
             Type::Int64 | Type::Sfixed64 | Type::Sint64 => String::from("i64"),
             Type::Bool => String::from("bool"),
-            Type::String => String::from("std::string::String"),
-            Type::Bytes => String::from("std::vec::Vec<u8>"),
+            Type::String => String::from("prost::alloc::string::String"),
+            Type::Bytes => String::from("prost::alloc::vec::Vec<u8>"),
             Type::Group | Type::Message => self.resolve_ident(field.type_name()),
         }
     }
diff --git a/prost-build/src/lib.rs b/prost-build/src/lib.rs
index c0c572462..73a4a9c84 100644
--- a/prost-build/src/lib.rs
+++ b/prost-build/src/lib.rs
@@ -547,7 +547,10 @@ impl Config {
         }
 
         let buf = fs::read(descriptor_set)?;
-        let descriptor_set = FileDescriptorSet::decode(&*buf)?;
+        // Manually map error, because in no_std mode, prost::DecodeError will not implement
+        // Into<io::Error>
+        let descriptor_set = FileDescriptorSet::decode(&buf[..])
+            .map_err(|error| Error::new(ErrorKind::InvalidData, format!("{}", error)))?;
 
         let modules = self.generate(descriptor_set.file)?;
         for (module, content) in modules {
diff --git a/prost-derive/src/field/group.rs b/prost-derive/src/field/group.rs
index 11fc237db..b72100d9f 100644
--- a/prost-derive/src/field/group.rs
+++ b/prost-derive/src/field/group.rs
@@ -126,7 +126,7 @@ impl Field {
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
         match self.label {
-            Label::Optional => quote!(#ident = ::std::option::Option::None),
+            Label::Optional => quote!(#ident = ::core::option::Option::None),
             Label::Required => quote!(#ident.clear()),
             Label::Repeated => quote!(#ident.clear()),
         }
diff --git a/prost-derive/src/field/map.rs b/prost-derive/src/field/map.rs
index 0bb4a56e4..760ae413e 100644
--- a/prost-derive/src/field/map.rs
+++ b/prost-derive/src/field/map.rs
@@ -272,11 +272,11 @@ impl Field {
             let insert_doc = format!("Inserts a key value pair into `{}`.", ident);
             Some(quote! {
                 #[doc=#get_doc]
-                pub fn #get(&self, key: #key_ref_ty) -> ::std::option::Option<#ty> {
+                pub fn #get(&self, key: #key_ref_ty) -> ::core::option::Option<#ty> {
                     self.#ident.get(#take_ref key).cloned().and_then(#ty::from_i32)
                 }
                 #[doc=#insert_doc]
-                pub fn #insert(&mut self, key: #key_ty, value: #ty) -> ::std::option::Option<#ty> {
+                pub fn #insert(&mut self, key: #key_ty, value: #ty) -> ::core::option::Option<#ty> {
                     self.#ident.insert(key, value as i32).and_then(#ty::from_i32)
                 }
             })
@@ -294,12 +294,18 @@ impl Field {
             MapTy::HashMap => Ident::new("HashMap", Span::call_site()),
             MapTy::BTreeMap => Ident::new("BTreeMap", Span::call_site()),
         };
+        // HashMap is in std, BTreeMap is in alloc (re-exported as prost::alloc)
+        let libname = match self.map_ty {
+            MapTy::HashMap => quote! { std },
+            MapTy::BTreeMap => quote! { prost::alloc },
+        };
+
         // A fake field for generating the debug wrapper
         let key_wrapper = fake_scalar(self.key_ty.clone()).debug(quote!(KeyWrapper));
         let key = self.key_ty.rust_type();
         let value_wrapper = self.value_ty.debug();
         let fmt = quote! {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 #key_wrapper
                 #value_wrapper
                 let mut builder = f.debug_map();
@@ -313,17 +319,17 @@ impl Field {
             ValueTy::Scalar(ref ty) => {
                 let value = ty.rust_type();
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::std::collections::#type_name<#key, #value>);
-                    impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
+                    struct #wrapper_name<'a>(&'a ::#libname::collections::#type_name<#key, #value>);
+                    impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
                         #fmt
                     }
                 }
             }
             ValueTy::Message => quote! {
-                struct #wrapper_name<'a, V: 'a>(&'a ::std::collections::#type_name<#key, V>);
-                impl<'a, V> ::std::fmt::Debug for #wrapper_name<'a, V>
+                struct #wrapper_name<'a, V: 'a>(&'a ::#libname::collections::#type_name<#key, V>);
+                impl<'a, V> ::core::fmt::Debug for #wrapper_name<'a, V>
                 where
-                    V: ::std::fmt::Debug + 'a,
+                    V: ::core::fmt::Debug + 'a,
                 {
                     #fmt
                 }
diff --git a/prost-derive/src/field/message.rs b/prost-derive/src/field/message.rs
index 26c034aef..4f98f473f 100644
--- a/prost-derive/src/field/message.rs
+++ b/prost-derive/src/field/message.rs
@@ -126,7 +126,7 @@ impl Field {
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
         match self.label {
-            Label::Optional => quote!(#ident = ::std::option::Option::None),
+            Label::Optional => quote!(#ident = ::core::option::Option::None),
             Label::Required => quote!(#ident.clear()),
             Label::Repeated => quote!(#ident.clear()),
         }
diff --git a/prost-derive/src/field/mod.rs b/prost-derive/src/field/mod.rs
index 14b908ecf..df0afbd20 100644
--- a/prost-derive/src/field/mod.rs
+++ b/prost-derive/src/field/mod.rs
@@ -4,8 +4,8 @@ mod message;
 mod oneof;
 mod scalar;
 
-use std::fmt;
-use std::slice;
+use core::fmt;
+use core::slice;
 
 use anyhow::{bail, Error};
 use proc_macro2::TokenStream;
@@ -135,7 +135,7 @@ impl Field {
     pub fn default(&self) -> TokenStream {
         match *self {
             Field::Scalar(ref scalar) => scalar.default(),
-            _ => quote!(::std::default::Default::default()),
+            _ => quote!(::core::default::Default::default()),
         }
     }
 
diff --git a/prost-derive/src/field/oneof.rs b/prost-derive/src/field/oneof.rs
index db4e19076..364c1c9f7 100644
--- a/prost-derive/src/field/oneof.rs
+++ b/prost-derive/src/field/oneof.rs
@@ -94,6 +94,6 @@ impl Field {
     }
 
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
-        quote!(#ident = ::std::option::Option::None)
+        quote!(#ident = ::core::option::Option::None)
     }
 }
diff --git a/prost-derive/src/field/scalar.rs b/prost-derive/src/field/scalar.rs
index 905c060fd..b55b2a8c1 100644
--- a/prost-derive/src/field/scalar.rs
+++ b/prost-derive/src/field/scalar.rs
@@ -131,7 +131,7 @@ impl Field {
                 }
             }
             Kind::Optional(..) => quote! {
-                if let ::std::option::Option::Some(ref value) = #ident {
+                if let ::core::option::Option::Some(ref value) = #ident {
                     #encode_fn(#tag, value, buf);
                 }
             },
@@ -204,7 +204,7 @@ impl Field {
                     _ => quote!(#ident = #default),
                 }
             }
-            Kind::Optional(_) => quote!(#ident = ::std::option::Option::None),
+            Kind::Optional(_) => quote!(#ident = ::core::option::Option::None),
             Kind::Repeated | Kind::Packed => quote!(#ident.clear()),
         }
     }
@@ -213,8 +213,8 @@ impl Field {
     pub fn default(&self) -> TokenStream {
         match self.kind {
             Kind::Plain(ref value) | Kind::Required(ref value) => value.owned(),
-            Kind::Optional(_) => quote!(::std::option::Option::None),
-            Kind::Repeated | Kind::Packed => quote!(::std::vec::Vec::new()),
+            Kind::Optional(_) => quote!(::core::option::Option::None),
+            Kind::Repeated | Kind::Packed => quote!(::prost::alloc::vec::Vec::new()),
         }
     }
 
@@ -223,11 +223,11 @@ impl Field {
         if let Ty::Enumeration(ref ty) = self.ty {
             quote! {
                 struct #wrap_name<'a>(&'a i32);
-                impl<'a> ::std::fmt::Debug for #wrap_name<'a> {
-                    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                impl<'a> ::core::fmt::Debug for #wrap_name<'a> {
+                    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         match #ty::from_i32(*self.0) {
-                            None => ::std::fmt::Debug::fmt(&self.0, f),
-                            Some(en) => ::std::fmt::Debug::fmt(&en, f),
+                            None => ::core::fmt::Debug::fmt(&self.0, f),
+                            Some(en) => ::core::fmt::Debug::fmt(&en, f),
                         }
                     }
                 }
@@ -246,19 +246,19 @@ impl Field {
         match self.kind {
             Kind::Plain(_) | Kind::Required(_) => self.debug_inner(wrapper_name),
             Kind::Optional(_) => quote! {
-                struct #wrapper_name<'a>(&'a ::std::option::Option<#inner_ty>);
-                impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
-                    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                struct #wrapper_name<'a>(&'a ::core::option::Option<#inner_ty>);
+                impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
+                    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                         #wrapper
-                        ::std::fmt::Debug::fmt(&self.0.as_ref().map(Inner), f)
+                        ::core::fmt::Debug::fmt(&self.0.as_ref().map(Inner), f)
                     }
                 }
             },
             Kind::Repeated | Kind::Packed => {
                 quote! {
-                    struct #wrapper_name<'a>(&'a ::std::vec::Vec<#inner_ty>);
-                    impl<'a> ::std::fmt::Debug for #wrapper_name<'a> {
-                        fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                    struct #wrapper_name<'a>(&'a ::prost::alloc::vec::Vec<#inner_ty>);
+                    impl<'a> ::core::fmt::Debug for #wrapper_name<'a> {
+                        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                             let mut vec_builder = f.debug_list();
                             for v in self.0 {
                                 #wrapper
@@ -315,7 +315,7 @@ impl Field {
 
                         #[doc=#set_doc]
                         pub fn #set(&mut self, value: #ty) {
-                            self.#ident = ::std::option::Option::Some(value as i32);
+                            self.#ident = ::core::option::Option::Some(value as i32);
                         }
                     }
                 }
@@ -328,9 +328,9 @@ impl Field {
                     let push_doc = format!("Appends the provided enum value to `{}`.", ident_str);
                     quote! {
                         #[doc=#iter_doc]
-                        pub fn #ident(&self) -> ::std::iter::FilterMap<
-                            ::std::iter::Cloned<::std::slice::Iter<i32>>,
-                            fn(i32) -> ::std::option::Option<#ty>,
+                        pub fn #ident(&self) -> ::core::iter::FilterMap<
+                            ::core::iter::Cloned<::core::slice::Iter<i32>>,
+                            fn(i32) -> ::core::option::Option<#ty>,
                         > {
                             self.#ident.iter().cloned().filter_map(#ty::from_i32)
                         }
@@ -345,9 +345,9 @@ impl Field {
             let ty = self.ty.rust_ref_type();
 
             let match_some = if self.ty.is_numeric() {
-                quote!(::std::option::Option::Some(val) => val,)
+                quote!(::core::option::Option::Some(val) => val,)
             } else {
-                quote!(::std::option::Option::Some(ref val) => &val[..],)
+                quote!(::core::option::Option::Some(ref val) => &val[..],)
             };
 
             let get_doc = format!(
@@ -360,7 +360,7 @@ impl Field {
                 pub fn #ident(&self) -> #ty {
                     match self.#ident {
                         #match_some
-                        ::std::option::Option::None => #default,
+                        ::core::option::Option::None => #default,
                     }
                 }
             })
@@ -497,8 +497,8 @@ impl Ty {
     // TODO: rename to 'owned_type'.
     pub fn rust_type(&self) -> TokenStream {
         match *self {
-            Ty::String => quote!(::std::string::String),
-            Ty::Bytes => quote!(::std::vec::Vec<u8>),
+            Ty::String => quote!(::prost::alloc::string::String),
+            Ty::Bytes => quote!(::prost::alloc::vec::Vec<u8>),
             _ => self.rust_ref_type(),
         }
     }
@@ -643,16 +643,16 @@ impl DefaultValue {
                     match value {
                         "inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f32::INFINITY",
+                                "::core::f32::INFINITY",
                             )?));
                         }
                         "-inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f32::NEG_INFINITY",
+                                "::core::f32::NEG_INFINITY",
                             )?));
                         }
                         "nan" => {
-                            return Ok(DefaultValue::Path(parse_str::<Path>("::std::f32::NAN")?));
+                            return Ok(DefaultValue::Path(parse_str::<Path>("::core::f32::NAN")?));
                         }
                         _ => (),
                     }
@@ -661,16 +661,16 @@ impl DefaultValue {
                     match value {
                         "inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f64::INFINITY",
+                                "::core::f64::INFINITY",
                             )?));
                         }
                         "-inf" => {
                             return Ok(DefaultValue::Path(parse_str::<Path>(
-                                "::std::f64::NEG_INFINITY",
+                                "::core::f64::NEG_INFINITY",
                             )?));
                         }
                         "nan" => {
-                            return Ok(DefaultValue::Path(parse_str::<Path>("::std::f64::NAN")?));
+                            return Ok(DefaultValue::Path(parse_str::<Path>("::core::f64::NAN")?));
                         }
                         _ => (),
                     }
@@ -750,10 +750,12 @@ impl DefaultValue {
     pub fn owned(&self) -> TokenStream {
         match *self {
             DefaultValue::String(ref value) if value.is_empty() => {
-                quote!(::std::string::String::new())
+                quote!(::prost::alloc::string::String::new())
             }
             DefaultValue::String(ref value) => quote!(#value.to_owned()),
-            DefaultValue::Bytes(ref value) if value.is_empty() => quote!(::std::vec::Vec::new()),
+            DefaultValue::Bytes(ref value) if value.is_empty() => {
+                quote!(::prost::alloc::vec::Vec::new())
+            }
             DefaultValue::Bytes(ref value) => {
                 let lit = LitByteStr::new(value, Span::call_site());
                 quote!(#lit.to_owned())
diff --git a/prost-derive/src/lib.rs b/prost-derive/src/lib.rs
index c3596212a..2809e8ce6 100644
--- a/prost-derive/src/lib.rs
+++ b/prost-derive/src/lib.rs
@@ -189,7 +189,7 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
                 wire_type: ::prost::encoding::WireType,
                 buf: &mut B,
                 ctx: ::prost::encoding::DecodeContext,
-            ) -> ::std::result::Result<(), ::prost::DecodeError>
+            ) -> ::core::result::Result<(), ::prost::DecodeError>
             where B: ::prost::bytes::Buf {
                 #struct_name
                 match tag {
@@ -216,8 +216,8 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
             }
         }
 
-        impl ::std::fmt::Debug for #ident {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        impl ::core::fmt::Debug for #ident {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 let mut builder = #debug_builder;
                 #(#debugs;)*
                 builder.finish()
@@ -281,7 +281,7 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
         .iter()
         .map(|&(_, ref value)| quote!(#value => true));
     let from = variants.iter().map(
-        |&(ref variant, ref value)| quote!(#value => ::std::option::Option::Some(#ident::#variant)),
+        |&(ref variant, ref value)| quote!(#value => ::core::option::Option::Some(#ident::#variant)),
     );
 
     let is_valid_doc = format!("Returns `true` if `value` is a variant of `{}`.", ident);
@@ -301,21 +301,21 @@ fn try_enumeration(input: TokenStream) -> Result<TokenStream, Error> {
             }
 
             #[doc=#from_i32_doc]
-            pub fn from_i32(value: i32) -> ::std::option::Option<#ident> {
+            pub fn from_i32(value: i32) -> ::core::option::Option<#ident> {
                 match value {
                     #(#from,)*
-                    _ => ::std::option::Option::None,
+                    _ => ::core::option::Option::None,
                 }
             }
         }
 
-        impl ::std::default::Default for #ident {
+        impl ::core::default::Default for #ident {
             fn default() -> #ident {
                 #ident::#default
             }
         }
 
-        impl ::std::convert::From<#ident> for i32 {
+        impl ::core::convert::From<#ident> for i32 {
             fn from(value: #ident) -> i32 {
                 value as i32
             }
@@ -400,13 +400,13 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         quote! {
             #tag => {
                 match field {
-                    ::std::option::Option::Some(#ident::#variant_ident(ref mut value)) => {
+                    ::core::option::Option::Some(#ident::#variant_ident(ref mut value)) => {
                         #merge
                     },
                     _ => {
-                        let mut owned_value = ::std::default::Default::default();
+                        let mut owned_value = ::core::default::Default::default();
                         let value = &mut owned_value;
-                        #merge.map(|_| *field = ::std::option::Option::Some(#ident::#variant_ident(owned_value)))
+                        #merge.map(|_| *field = ::core::option::Option::Some(#ident::#variant_ident(owned_value)))
                     },
                 }
             }
@@ -437,12 +437,12 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
             }
 
             pub fn merge<B>(
-                field: &mut ::std::option::Option<#ident>,
+                field: &mut ::core::option::Option<#ident>,
                 tag: u32,
                 wire_type: ::prost::encoding::WireType,
                 buf: &mut B,
                 ctx: ::prost::encoding::DecodeContext,
-            ) -> ::std::result::Result<(), ::prost::DecodeError>
+            ) -> ::core::result::Result<(), ::prost::DecodeError>
             where B: ::prost::bytes::Buf {
                 match tag {
                     #(#merge,)*
@@ -458,8 +458,8 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
             }
         }
 
-        impl ::std::fmt::Debug for #ident {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        impl ::core::fmt::Debug for #ident {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                 match *self {
                     #(#debug,)*
                 }
diff --git a/prost-types/Cargo.toml b/prost-types/Cargo.toml
index 59de64452..7a8112f3a 100644
--- a/prost-types/Cargo.toml
+++ b/prost-types/Cargo.toml
@@ -13,6 +13,10 @@ edition = "2018"
 doctest = false
 test = false
 
+[features]
+default = ["std"]
+std = ["prost/std"]
+
 [dependencies]
-bytes = "0.5"
-prost = { version = "0.6.1", path = ".." }
+bytes = { version = "0.5", default-features = false }
+prost = { version = "0.6.1", path = "..", default-features = false }
diff --git a/prost-types/src/compiler.rs b/prost-types/src/compiler.rs
index 421bd78ba..ebae62473 100644
--- a/prost-types/src/compiler.rs
+++ b/prost-types/src/compiler.rs
@@ -2,15 +2,15 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Version {
     #[prost(int32, optional, tag="1")]
-    pub major: ::std::option::Option<i32>,
+    pub major: core::option::Option<i32>,
     #[prost(int32, optional, tag="2")]
-    pub minor: ::std::option::Option<i32>,
+    pub minor: core::option::Option<i32>,
     #[prost(int32, optional, tag="3")]
-    pub patch: ::std::option::Option<i32>,
+    pub patch: core::option::Option<i32>,
     /// A suffix for alpha, beta or rc release, e.g., "alpha-1", "rc2". It should
     /// be empty for mainline stable releases.
     #[prost(string, optional, tag="4")]
-    pub suffix: ::std::option::Option<std::string::String>,
+    pub suffix: core::option::Option<prost::alloc::string::String>,
 }
 /// An encoded CodeGeneratorRequest is written to the plugin's stdin.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -19,10 +19,10 @@ pub struct CodeGeneratorRequest {
     /// code generator should generate code only for these files.  Each file's
     /// descriptor will be included in proto_file, below.
     #[prost(string, repeated, tag="1")]
-    pub file_to_generate: ::std::vec::Vec<std::string::String>,
+    pub file_to_generate: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// The generator parameter passed on the command-line.
     #[prost(string, optional, tag="2")]
-    pub parameter: ::std::option::Option<std::string::String>,
+    pub parameter: core::option::Option<prost::alloc::string::String>,
     /// FileDescriptorProtos for all files in files_to_generate and everything
     /// they import.  The files will appear in topological order, so each file
     /// appears before any file that imports it.
@@ -38,10 +38,10 @@ pub struct CodeGeneratorRequest {
     /// Type names of fields and extensions in the FileDescriptorProto are always
     /// fully qualified.
     #[prost(message, repeated, tag="15")]
-    pub proto_file: ::std::vec::Vec<super::FileDescriptorProto>,
+    pub proto_file: prost::alloc::vec::Vec<super::FileDescriptorProto>,
     /// The version number of protocol compiler.
     #[prost(message, optional, tag="3")]
-    pub compiler_version: ::std::option::Option<Version>,
+    pub compiler_version: core::option::Option<Version>,
 }
 /// The plugin writes an encoded CodeGeneratorResponse to stdout.
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -55,9 +55,9 @@ pub struct CodeGeneratorResponse {
     /// unparseable -- should be reported by writing a message to stderr and
     /// exiting with a non-zero status code.
     #[prost(string, optional, tag="1")]
-    pub error: ::std::option::Option<std::string::String>,
+    pub error: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="15")]
-    pub file: ::std::vec::Vec<code_generator_response::File>,
+    pub file: prost::alloc::vec::Vec<code_generator_response::File>,
 }
 pub mod code_generator_response {
     /// Represents a single generated file.
@@ -75,7 +75,7 @@ pub mod code_generator_response {
         /// this writing protoc does not optimize for this -- it will read the entire
         /// CodeGeneratorResponse before writing files to disk.
         #[prost(string, optional, tag="1")]
-        pub name: ::std::option::Option<std::string::String>,
+        pub name: core::option::Option<prost::alloc::string::String>,
         /// If non-empty, indicates that the named file should already exist, and the
         /// content here is to be inserted into that file at a defined insertion
         /// point.  This feature allows a code generator to extend the output
@@ -114,9 +114,9 @@ pub mod code_generator_response {
         ///
         /// If |insertion_point| is present, |name| must also be present.
         #[prost(string, optional, tag="2")]
-        pub insertion_point: ::std::option::Option<std::string::String>,
+        pub insertion_point: core::option::Option<prost::alloc::string::String>,
         /// The file contents.
         #[prost(string, optional, tag="15")]
-        pub content: ::std::option::Option<std::string::String>,
+        pub content: core::option::Option<prost::alloc::string::String>,
     }
 }
diff --git a/prost-types/src/lib.rs b/prost-types/src/lib.rs
index 26013c5c9..38858fbbe 100644
--- a/prost-types/src/lib.rs
+++ b/prost-types/src/lib.rs
@@ -9,10 +9,11 @@
 //!
 //! [1]: https://developers.google.com/protocol-buffers/docs/reference/google.protobuf
 
-use std::convert::TryFrom;
-use std::i32;
-use std::i64;
-use std::time;
+#![no_std]
+extern crate alloc;
+
+use core::i32;
+use core::i64;
 
 include!("protobuf.rs");
 pub mod compiler {
@@ -23,131 +24,140 @@ pub mod compiler {
 // because the Protobuf versions are signed. To make them easier to work with, `From` conversions
 // are defined in both directions.
 
-const NANOS_PER_SECOND: i32 = 1_000_000_000;
-
-impl Duration {
-    /// Normalizes the duration to a canonical format.
-    ///
-    /// Based on [`google::protobuf::util::CreateNormalized`][1].
-    /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L79-L100
-    fn normalize(&mut self) {
-        // Make sure nanos is in the range.
-        if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
-            self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
-            self.nanos %= NANOS_PER_SECOND;
+#[cfg(feature = "std")]
+mod std_conversions {
+    use super::*;
+    extern crate std;
+
+    use std::time;
+    use core::convert::TryFrom;
+
+    const NANOS_PER_SECOND: i32 = 1_000_000_000;
+
+    impl Duration {
+        /// Normalizes the duration to a canonical format.
+        ///
+        /// Based on [`google::protobuf::util::CreateNormalized`][1].
+        /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L79-L100
+        fn normalize(&mut self) {
+            // Make sure nanos is in the range.
+            if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
+                self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
+                self.nanos %= NANOS_PER_SECOND;
+            }
+
+            // nanos should have the same sign as seconds.
+            if self.seconds < 0 && self.nanos > 0 {
+                self.seconds += 1;
+                self.nanos -= NANOS_PER_SECOND;
+            } else if self.seconds > 0 && self.nanos < 0 {
+                self.seconds -= 1;
+                self.nanos += NANOS_PER_SECOND;
+            }
+            // TODO: should this be checked?
+            // debug_assert!(self.seconds >= -315_576_000_000 && self.seconds <= 315_576_000_000,
+            //               "invalid duration: {:?}", self);
         }
+    }
 
-        // nanos should have the same sign as seconds.
-        if self.seconds < 0 && self.nanos > 0 {
-            self.seconds += 1;
-            self.nanos -= NANOS_PER_SECOND;
-        } else if self.seconds > 0 && self.nanos < 0 {
-            self.seconds -= 1;
-            self.nanos += NANOS_PER_SECOND;
+    /// Converts a `std::time::Duration` to a `Duration`.
+    impl From<time::Duration> for Duration {
+        fn from(duration: time::Duration) -> Duration {
+            let seconds = duration.as_secs();
+            let seconds = if seconds > i64::MAX as u64 {
+                i64::MAX
+            } else {
+                seconds as i64
+            };
+            let nanos = duration.subsec_nanos();
+            let nanos = if nanos > i32::MAX as u32 {
+                i32::MAX
+            } else {
+                nanos as i32
+            };
+            let mut duration = Duration { seconds, nanos };
+            duration.normalize();
+            duration
         }
-        // TODO: should this be checked?
-        // debug_assert!(self.seconds >= -315_576_000_000 && self.seconds <= 315_576_000_000,
-        //               "invalid duration: {:?}", self);
     }
-}
 
-/// Converts a `std::time::Duration` to a `Duration`.
-impl From<time::Duration> for Duration {
-    fn from(duration: time::Duration) -> Duration {
-        let seconds = duration.as_secs();
-        let seconds = if seconds > i64::MAX as u64 {
-            i64::MAX
-        } else {
-            seconds as i64
-        };
-        let nanos = duration.subsec_nanos();
-        let nanos = if nanos > i32::MAX as u32 {
-            i32::MAX
-        } else {
-            nanos as i32
-        };
-        let mut duration = Duration { seconds, nanos };
-        duration.normalize();
-        duration
-    }
-}
+    impl TryFrom<Duration> for time::Duration {
+        type Error = time::Duration;
 
-impl TryFrom<Duration> for time::Duration {
-    type Error = time::Duration;
-
-    /// Converts a `Duration` to a result containing a positive (`Ok`) or negative (`Err`)
-    /// `std::time::Duration`.
-    fn try_from(mut duration: Duration) -> Result<time::Duration, time::Duration> {
-        duration.normalize();
-        if duration.seconds >= 0 {
-            Ok(time::Duration::new(
-                duration.seconds as u64,
-                duration.nanos as u32,
-            ))
-        } else {
-            Err(time::Duration::new(
-                (-duration.seconds) as u64,
-                (-duration.nanos) as u32,
-            ))
+        /// Converts a `Duration` to a result containing a positive (`Ok`) or negative (`Err`)
+        /// `std::time::Duration`.
+        fn try_from(mut duration: Duration) -> Result<time::Duration, time::Duration> {
+            duration.normalize();
+            if duration.seconds >= 0 {
+                Ok(time::Duration::new(
+                    duration.seconds as u64,
+                    duration.nanos as u32,
+                ))
+            } else {
+                Err(time::Duration::new(
+                    (-duration.seconds) as u64,
+                    (-duration.nanos) as u32,
+                ))
+            }
         }
     }
-}
-
-impl Timestamp {
-    /// Normalizes the timestamp to a canonical format.
-    ///
-    /// Based on [`google::protobuf::util::CreateNormalized`][1].
-    /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L59-L77
-    fn normalize(&mut self) {
-        // Make sure nanos is in the range.
-        if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
-            self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
-            self.nanos %= NANOS_PER_SECOND;
-        }
 
-        // For Timestamp nanos should be in the range [0, 999999999].
-        if self.nanos < 0 {
-            self.seconds -= 1;
-            self.nanos += NANOS_PER_SECOND;
+    impl Timestamp {
+        /// Normalizes the timestamp to a canonical format.
+        ///
+        /// Based on [`google::protobuf::util::CreateNormalized`][1].
+        /// [1]: https://github.com/google/protobuf/blob/v3.3.2/src/google/protobuf/util/time_util.cc#L59-L77
+        fn normalize(&mut self) {
+            // Make sure nanos is in the range.
+            if self.nanos <= -NANOS_PER_SECOND || self.nanos >= NANOS_PER_SECOND {
+                self.seconds += (self.nanos / NANOS_PER_SECOND) as i64;
+                self.nanos %= NANOS_PER_SECOND;
+            }
+
+            // For Timestamp nanos should be in the range [0, 999999999].
+            if self.nanos < 0 {
+                self.seconds -= 1;
+                self.nanos += NANOS_PER_SECOND;
+            }
+
+            // TODO: should this be checked?
+            // debug_assert!(self.seconds >= -62_135_596_800 && self.seconds <= 253_402_300_799,
+            //               "invalid timestamp: {:?}", self);
         }
-
-        // TODO: should this be checked?
-        // debug_assert!(self.seconds >= -62_135_596_800 && self.seconds <= 253_402_300_799,
-        //               "invalid timestamp: {:?}", self);
     }
-}
 
-/// Converts a `std::time::SystemTime` to a `Timestamp`.
-impl From<time::SystemTime> for Timestamp {
-    fn from(time: time::SystemTime) -> Timestamp {
-        let duration = Duration::from(time.duration_since(time::UNIX_EPOCH).unwrap());
-        Timestamp {
-            seconds: duration.seconds,
-            nanos: duration.nanos,
+    /// Converts a `std::time::SystemTime` to a `Timestamp`.
+    impl From<time::SystemTime> for Timestamp {
+        fn from(time: time::SystemTime) -> Timestamp {
+            let duration = Duration::from(time.duration_since(time::UNIX_EPOCH).unwrap());
+            Timestamp {
+                seconds: duration.seconds,
+                nanos: duration.nanos,
+            }
         }
     }
-}
 
-impl TryFrom<Timestamp> for time::SystemTime {
-    type Error = time::Duration;
-
-    /// Converts a `Timestamp` to a `SystemTime`, or if the timestamp falls before the Unix epoch,
-    /// a duration containing the difference.
-    fn try_from(mut timestamp: Timestamp) -> Result<time::SystemTime, time::Duration> {
-        timestamp.normalize();
-        if timestamp.seconds >= 0 {
-            Ok(time::UNIX_EPOCH
-                + time::Duration::new(timestamp.seconds as u64, timestamp.nanos as u32))
-        } else {
-            let mut duration = Duration {
-                seconds: -timestamp.seconds,
-                nanos: timestamp.nanos,
-            };
-            duration.normalize();
-            Err(time::Duration::new(
-                duration.seconds as u64,
-                duration.nanos as u32,
-            ))
+    impl TryFrom<Timestamp> for time::SystemTime {
+        type Error = time::Duration;
+
+        /// Converts a `Timestamp` to a `SystemTime`, or if the timestamp falls before the Unix epoch,
+        /// a duration containing the difference.
+        fn try_from(mut timestamp: Timestamp) -> Result<time::SystemTime, time::Duration> {
+            timestamp.normalize();
+            if timestamp.seconds >= 0 {
+                Ok(time::UNIX_EPOCH
+                    + time::Duration::new(timestamp.seconds as u64, timestamp.nanos as u32))
+            } else {
+                let mut duration = Duration {
+                    seconds: -timestamp.seconds,
+                    nanos: timestamp.nanos,
+                };
+                duration.normalize();
+                Err(time::Duration::new(
+                    duration.seconds as u64,
+                    duration.nanos as u32,
+                ))
+            }
         }
     }
 }
diff --git a/prost-types/src/protobuf.rs b/prost-types/src/protobuf.rs
index 1ffde4381..c18b3e836 100644
--- a/prost-types/src/protobuf.rs
+++ b/prost-types/src/protobuf.rs
@@ -3,86 +3,86 @@
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorSet {
     #[prost(message, repeated, tag="1")]
-    pub file: ::std::vec::Vec<FileDescriptorProto>,
+    pub file: prost::alloc::vec::Vec<FileDescriptorProto>,
 }
 /// Describes a complete .proto file.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FileDescriptorProto {
     /// file name, relative to root of source tree
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     /// e.g. "foo", "foo.bar", etc.
     #[prost(string, optional, tag="2")]
-    pub package: ::std::option::Option<std::string::String>,
+    pub package: core::option::Option<prost::alloc::string::String>,
     /// Names of files imported by this file.
     #[prost(string, repeated, tag="3")]
-    pub dependency: ::std::vec::Vec<std::string::String>,
+    pub dependency: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// Indexes of the public imported files in the dependency list above.
     #[prost(int32, repeated, packed="false", tag="10")]
-    pub public_dependency: ::std::vec::Vec<i32>,
+    pub public_dependency: prost::alloc::vec::Vec<i32>,
     /// Indexes of the weak imported files in the dependency list.
     /// For Google-internal migration only. Do not use.
     #[prost(int32, repeated, packed="false", tag="11")]
-    pub weak_dependency: ::std::vec::Vec<i32>,
+    pub weak_dependency: prost::alloc::vec::Vec<i32>,
     /// All top-level definitions in this file.
     #[prost(message, repeated, tag="4")]
-    pub message_type: ::std::vec::Vec<DescriptorProto>,
+    pub message_type: prost::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: prost::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub service: ::std::vec::Vec<ServiceDescriptorProto>,
+    pub service: prost::alloc::vec::Vec<ServiceDescriptorProto>,
     #[prost(message, repeated, tag="7")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
+    pub extension: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, optional, tag="8")]
-    pub options: ::std::option::Option<FileOptions>,
+    pub options: core::option::Option<FileOptions>,
     /// This field contains optional information about the original source code.
     /// You may safely remove this entire field without harming runtime
     /// functionality of the descriptors -- the information is needed only by
     /// development tools.
     #[prost(message, optional, tag="9")]
-    pub source_code_info: ::std::option::Option<SourceCodeInfo>,
+    pub source_code_info: core::option::Option<SourceCodeInfo>,
     /// The syntax of the proto file.
     /// The supported values are "proto2" and "proto3".
     #[prost(string, optional, tag="12")]
-    pub syntax: ::std::option::Option<std::string::String>,
+    pub syntax: core::option::Option<prost::alloc::string::String>,
 }
 /// Describes a message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub field: ::std::vec::Vec<FieldDescriptorProto>,
+    pub field: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="6")]
-    pub extension: ::std::vec::Vec<FieldDescriptorProto>,
+    pub extension: prost::alloc::vec::Vec<FieldDescriptorProto>,
     #[prost(message, repeated, tag="3")]
-    pub nested_type: ::std::vec::Vec<DescriptorProto>,
+    pub nested_type: prost::alloc::vec::Vec<DescriptorProto>,
     #[prost(message, repeated, tag="4")]
-    pub enum_type: ::std::vec::Vec<EnumDescriptorProto>,
+    pub enum_type: prost::alloc::vec::Vec<EnumDescriptorProto>,
     #[prost(message, repeated, tag="5")]
-    pub extension_range: ::std::vec::Vec<descriptor_proto::ExtensionRange>,
+    pub extension_range: prost::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
     #[prost(message, repeated, tag="8")]
-    pub oneof_decl: ::std::vec::Vec<OneofDescriptorProto>,
+    pub oneof_decl: prost::alloc::vec::Vec<OneofDescriptorProto>,
     #[prost(message, optional, tag="7")]
-    pub options: ::std::option::Option<MessageOptions>,
+    pub options: core::option::Option<MessageOptions>,
     #[prost(message, repeated, tag="9")]
-    pub reserved_range: ::std::vec::Vec<descriptor_proto::ReservedRange>,
+    pub reserved_range: prost::alloc::vec::Vec<descriptor_proto::ReservedRange>,
     /// Reserved field names, which may not be used by fields in the same message.
     /// A given name may only be reserved once.
     #[prost(string, repeated, tag="10")]
-    pub reserved_name: ::std::vec::Vec<std::string::String>,
+    pub reserved_name: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 pub mod descriptor_proto {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct ExtensionRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Exclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: core::option::Option<i32>,
         #[prost(message, optional, tag="3")]
-        pub options: ::std::option::Option<super::ExtensionRangeOptions>,
+        pub options: core::option::Option<super::ExtensionRangeOptions>,
     }
     /// Range of reserved tag numbers. Reserved tag numbers may not be used by
     /// fields or extension ranges in the same message. Reserved ranges may
@@ -91,61 +91,61 @@ pub mod descriptor_proto {
     pub struct ReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Exclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ExtensionRangeOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 /// Describes a field within a message.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(int32, optional, tag="3")]
-    pub number: ::std::option::Option<i32>,
+    pub number: core::option::Option<i32>,
     #[prost(enumeration="field_descriptor_proto::Label", optional, tag="4")]
-    pub label: ::std::option::Option<i32>,
+    pub label: core::option::Option<i32>,
     /// If type_name is set, this need not be set.  If both this and type_name
     /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
     #[prost(enumeration="field_descriptor_proto::Type", optional, tag="5")]
-    pub r#type: ::std::option::Option<i32>,
+    pub r#type: core::option::Option<i32>,
     /// For message and enum types, this is the name of the type.  If the name
     /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
     /// rules are used to find the type (i.e. first the nested types within this
     /// message are searched, then within the parent, on up to the root
     /// namespace).
     #[prost(string, optional, tag="6")]
-    pub type_name: ::std::option::Option<std::string::String>,
+    pub type_name: core::option::Option<prost::alloc::string::String>,
     /// For extensions, this is the name of the type being extended.  It is
     /// resolved in the same manner as type_name.
     #[prost(string, optional, tag="2")]
-    pub extendee: ::std::option::Option<std::string::String>,
+    pub extendee: core::option::Option<prost::alloc::string::String>,
     /// For numeric types, contains the original text representation of the value.
     /// For booleans, "true" or "false".
     /// For strings, contains the default text contents (not escaped in any way).
     /// For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
     /// TODO(kenton):  Base-64 encode?
     #[prost(string, optional, tag="7")]
-    pub default_value: ::std::option::Option<std::string::String>,
+    pub default_value: core::option::Option<prost::alloc::string::String>,
     /// If set, gives the index of a oneof in the containing type's oneof_decl
     /// list.  This field is a member of that oneof.
     #[prost(int32, optional, tag="9")]
-    pub oneof_index: ::std::option::Option<i32>,
+    pub oneof_index: core::option::Option<i32>,
     /// JSON name of this field. The value is set by protocol compiler. If the
     /// user has set a "json_name" option on this field, that option's value
     /// will be used. Otherwise, it's deduced from the field's name by converting
     /// it to camelCase.
     #[prost(string, optional, tag="10")]
-    pub json_name: ::std::option::Option<std::string::String>,
+    pub json_name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="8")]
-    pub options: ::std::option::Option<FieldOptions>,
+    pub options: core::option::Option<FieldOptions>,
 }
 pub mod field_descriptor_proto {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -197,28 +197,28 @@ pub mod field_descriptor_proto {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct OneofDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="2")]
-    pub options: ::std::option::Option<OneofOptions>,
+    pub options: core::option::Option<OneofOptions>,
 }
 /// Describes an enum type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub value: ::std::vec::Vec<EnumValueDescriptorProto>,
+    pub value: prost::alloc::vec::Vec<EnumValueDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<EnumOptions>,
+    pub options: core::option::Option<EnumOptions>,
     /// Range of reserved numeric values. Reserved numeric values may not be used
     /// by enum values in the same enum declaration. Reserved ranges may not
     /// overlap.
     #[prost(message, repeated, tag="4")]
-    pub reserved_range: ::std::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
+    pub reserved_range: prost::alloc::vec::Vec<enum_descriptor_proto::EnumReservedRange>,
     /// Reserved enum value names, which may not be reused. A given name may only
     /// be reserved once.
     #[prost(string, repeated, tag="5")]
-    pub reserved_name: ::std::vec::Vec<std::string::String>,
+    pub reserved_name: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 pub mod enum_descriptor_proto {
     /// Range of reserved numeric values. Reserved values may not be used by
@@ -231,51 +231,51 @@ pub mod enum_descriptor_proto {
     pub struct EnumReservedRange {
         /// Inclusive.
         #[prost(int32, optional, tag="1")]
-        pub start: ::std::option::Option<i32>,
+        pub start: core::option::Option<i32>,
         /// Inclusive.
         #[prost(int32, optional, tag="2")]
-        pub end: ::std::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 /// Describes a value within an enum.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(int32, optional, tag="2")]
-    pub number: ::std::option::Option<i32>,
+    pub number: core::option::Option<i32>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<EnumValueOptions>,
+    pub options: core::option::Option<EnumValueOptions>,
 }
 /// Describes a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     #[prost(message, repeated, tag="2")]
-    pub method: ::std::vec::Vec<MethodDescriptorProto>,
+    pub method: prost::alloc::vec::Vec<MethodDescriptorProto>,
     #[prost(message, optional, tag="3")]
-    pub options: ::std::option::Option<ServiceOptions>,
+    pub options: core::option::Option<ServiceOptions>,
 }
 /// Describes a method of a service.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodDescriptorProto {
     #[prost(string, optional, tag="1")]
-    pub name: ::std::option::Option<std::string::String>,
+    pub name: core::option::Option<prost::alloc::string::String>,
     /// Input and output type names.  These are resolved in the same way as
     /// FieldDescriptorProto.type_name, but must refer to a message type.
     #[prost(string, optional, tag="2")]
-    pub input_type: ::std::option::Option<std::string::String>,
+    pub input_type: core::option::Option<prost::alloc::string::String>,
     #[prost(string, optional, tag="3")]
-    pub output_type: ::std::option::Option<std::string::String>,
+    pub output_type: core::option::Option<prost::alloc::string::String>,
     #[prost(message, optional, tag="4")]
-    pub options: ::std::option::Option<MethodOptions>,
+    pub options: core::option::Option<MethodOptions>,
     /// Identifies if client streams multiple client messages
     #[prost(bool, optional, tag="5", default="false")]
-    pub client_streaming: ::std::option::Option<bool>,
+    pub client_streaming: core::option::Option<bool>,
     /// Identifies if server streams multiple server messages
     #[prost(bool, optional, tag="6", default="false")]
-    pub server_streaming: ::std::option::Option<bool>,
+    pub server_streaming: core::option::Option<bool>,
 }
 // ===================================================================
 // Options
@@ -316,14 +316,14 @@ pub struct FileOptions {
     /// inappropriate because proto packages do not normally start with backwards
     /// domain names.
     #[prost(string, optional, tag="1")]
-    pub java_package: ::std::option::Option<std::string::String>,
+    pub java_package: core::option::Option<prost::alloc::string::String>,
     /// If set, all the classes from the .proto file are wrapped in a single
     /// outer class with the given name.  This applies to both Proto1
     /// (equivalent to the old "--one_java_file" option) and Proto2 (where
     /// a .proto always translates to a single class, but you may want to
     /// explicitly choose the class name).
     #[prost(string, optional, tag="8")]
-    pub java_outer_classname: ::std::option::Option<std::string::String>,
+    pub java_outer_classname: core::option::Option<prost::alloc::string::String>,
     /// If set true, then the Java code generator will generate a separate .java
     /// file for each top-level message, enum, and service defined in the .proto
     /// file.  Thus, these types will *not* be nested inside the outer class
@@ -331,11 +331,11 @@ pub struct FileOptions {
     /// generated to contain the file's getDescriptor() method as well as any
     /// top-level extensions defined in the file.
     #[prost(bool, optional, tag="10", default="false")]
-    pub java_multiple_files: ::std::option::Option<bool>,
+    pub java_multiple_files: core::option::Option<bool>,
     /// This option does nothing.
     #[deprecated]
     #[prost(bool, optional, tag="20")]
-    pub java_generate_equals_and_hash: ::std::option::Option<bool>,
+    pub java_generate_equals_and_hash: core::option::Option<bool>,
     /// If set true, then the Java2 code generator will generate code that
     /// throws an exception whenever an attempt is made to assign a non-UTF-8
     /// byte sequence to a string field.
@@ -343,16 +343,16 @@ pub struct FileOptions {
     /// However, an extension field still accepts non-UTF-8 byte sequences.
     /// This option has no effect on when used with the lite runtime.
     #[prost(bool, optional, tag="27", default="false")]
-    pub java_string_check_utf8: ::std::option::Option<bool>,
+    pub java_string_check_utf8: core::option::Option<bool>,
     #[prost(enumeration="file_options::OptimizeMode", optional, tag="9", default="Speed")]
-    pub optimize_for: ::std::option::Option<i32>,
+    pub optimize_for: core::option::Option<i32>,
     /// Sets the Go package where structs generated from this .proto will be
     /// placed. If omitted, the Go package will be derived from the following:
     ///   - The basename of the package import path, if provided.
     ///   - Otherwise, the package statement in the .proto file, if present.
     ///   - Otherwise, the basename of the .proto file, without extension.
     #[prost(string, optional, tag="11")]
-    pub go_package: ::std::option::Option<std::string::String>,
+    pub go_package: core::option::Option<prost::alloc::string::String>,
     /// Should generic services be generated in each language?  "Generic" services
     /// are not specific to any particular RPC system.  They are generated by the
     /// main code generators in each language (without additional plugins).
@@ -364,59 +364,59 @@ pub struct FileOptions {
     /// these default to false.  Old code which depends on generic services should
     /// explicitly set them to true.
     #[prost(bool, optional, tag="16", default="false")]
-    pub cc_generic_services: ::std::option::Option<bool>,
+    pub cc_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="17", default="false")]
-    pub java_generic_services: ::std::option::Option<bool>,
+    pub java_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="18", default="false")]
-    pub py_generic_services: ::std::option::Option<bool>,
+    pub py_generic_services: core::option::Option<bool>,
     #[prost(bool, optional, tag="42", default="false")]
-    pub php_generic_services: ::std::option::Option<bool>,
+    pub php_generic_services: core::option::Option<bool>,
     /// Is this file deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for everything in the file, or it will be completely ignored; in the very
     /// least, this is a formalization for deprecating files.
     #[prost(bool, optional, tag="23", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// Enables the use of arenas for the proto messages in this file. This applies
     /// only to generated classes for C++.
     #[prost(bool, optional, tag="31", default="false")]
-    pub cc_enable_arenas: ::std::option::Option<bool>,
+    pub cc_enable_arenas: core::option::Option<bool>,
     /// Sets the objective c class prefix which is prepended to all objective c
     /// generated classes from this .proto. There is no default.
     #[prost(string, optional, tag="36")]
-    pub objc_class_prefix: ::std::option::Option<std::string::String>,
+    pub objc_class_prefix: core::option::Option<prost::alloc::string::String>,
     /// Namespace for generated classes; defaults to the package.
     #[prost(string, optional, tag="37")]
-    pub csharp_namespace: ::std::option::Option<std::string::String>,
+    pub csharp_namespace: core::option::Option<prost::alloc::string::String>,
     /// By default Swift generators will take the proto package and CamelCase it
     /// replacing '.' with underscore and use that to prefix the types/symbols
     /// defined. When this options is provided, they will use this value instead
     /// to prefix the types/symbols defined.
     #[prost(string, optional, tag="39")]
-    pub swift_prefix: ::std::option::Option<std::string::String>,
+    pub swift_prefix: core::option::Option<prost::alloc::string::String>,
     /// Sets the php class prefix which is prepended to all php generated classes
     /// from this .proto. Default is empty.
     #[prost(string, optional, tag="40")]
-    pub php_class_prefix: ::std::option::Option<std::string::String>,
+    pub php_class_prefix: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the namespace of php generated classes. Default
     /// is empty. When this option is empty, the package name will be used for
     /// determining the namespace.
     #[prost(string, optional, tag="41")]
-    pub php_namespace: ::std::option::Option<std::string::String>,
+    pub php_namespace: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the namespace of php generated metadata classes.
     /// Default is empty. When this option is empty, the proto file name will be
     /// used for determining the namespace.
     #[prost(string, optional, tag="44")]
-    pub php_metadata_namespace: ::std::option::Option<std::string::String>,
+    pub php_metadata_namespace: core::option::Option<prost::alloc::string::String>,
     /// Use this option to change the package of ruby generated classes. Default
     /// is empty. When this option is not set, the package name will be used for
     /// determining the ruby package.
     #[prost(string, optional, tag="45")]
-    pub ruby_package: ::std::option::Option<std::string::String>,
+    pub ruby_package: core::option::Option<prost::alloc::string::String>,
     /// The parser stores options it doesn't recognize here.
     /// See the documentation for the "Options" section above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod file_options {
     /// Generated classes can be optimized for speed or code size.
@@ -454,18 +454,18 @@ pub struct MessageOptions {
     /// Because this is an option, the above two restrictions are not enforced by
     /// the protocol compiler.
     #[prost(bool, optional, tag="1", default="false")]
-    pub message_set_wire_format: ::std::option::Option<bool>,
+    pub message_set_wire_format: core::option::Option<bool>,
     /// Disables the generation of the standard "descriptor()" accessor, which can
     /// conflict with a field of the same name.  This is meant to make migration
     /// from proto1 easier; new code should avoid fields named "descriptor".
     #[prost(bool, optional, tag="2", default="false")]
-    pub no_standard_descriptor_accessor: ::std::option::Option<bool>,
+    pub no_standard_descriptor_accessor: core::option::Option<bool>,
     /// Is this message deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the message, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating messages.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// Whether the message is an automatically generated map entry type for the
     /// maps field.
     ///
@@ -488,10 +488,10 @@ pub struct MessageOptions {
     /// instead. The option should only be implicitly set by the proto compiler
     /// parser.
     #[prost(bool, optional, tag="7")]
-    pub map_entry: ::std::option::Option<bool>,
+    pub map_entry: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FieldOptions {
@@ -500,14 +500,14 @@ pub struct FieldOptions {
     /// options below.  This option is not yet implemented in the open source
     /// release -- sorry, we'll try to include it in a future version!
     #[prost(enumeration="field_options::CType", optional, tag="1", default="String")]
-    pub ctype: ::std::option::Option<i32>,
+    pub ctype: core::option::Option<i32>,
     /// The packed option can be enabled for repeated primitive fields to enable
     /// a more efficient representation on the wire. Rather than repeatedly
     /// writing the tag and type for each element, the entire array is encoded as
     /// a single length-delimited blob. In proto3, only explicit setting it to
     /// false will avoid using packed encoding.
     #[prost(bool, optional, tag="2")]
-    pub packed: ::std::option::Option<bool>,
+    pub packed: core::option::Option<bool>,
     /// The jstype option determines the JavaScript type used for values of the
     /// field.  The option is permitted only for 64 bit integral and fixed types
     /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
@@ -520,7 +520,7 @@ pub struct FieldOptions {
     /// This option is an enum to permit additional types to be added, e.g.
     /// goog.math.Integer.
     #[prost(enumeration="field_options::JsType", optional, tag="6", default="JsNormal")]
-    pub jstype: ::std::option::Option<i32>,
+    pub jstype: core::option::Option<i32>,
     /// Should this field be parsed lazily?  Lazy applies only to message-type
     /// fields.  It means that when the outer message is initially parsed, the
     /// inner message's contents will not be parsed but instead stored in encoded
@@ -550,19 +550,19 @@ pub struct FieldOptions {
     /// check its required fields, regardless of whether or not the message has
     /// been parsed.
     #[prost(bool, optional, tag="5", default="false")]
-    pub lazy: ::std::option::Option<bool>,
+    pub lazy: core::option::Option<bool>,
     /// Is this field deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for accessors, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating fields.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// For Google-internal migration only. Do not use.
     #[prost(bool, optional, tag="10", default="false")]
-    pub weak: ::std::option::Option<bool>,
+    pub weak: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod field_options {
     #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -588,23 +588,23 @@ pub mod field_options {
 pub struct OneofOptions {
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumOptions {
     /// Set this option to true to allow mapping different tag names to the same
     /// value.
     #[prost(bool, optional, tag="2")]
-    pub allow_alias: ::std::option::Option<bool>,
+    pub allow_alias: core::option::Option<bool>,
     /// Is this enum deprecated?
     /// Depending on the target platform, this can emit Deprecated annotations
     /// for the enum, or it will be completely ignored; in the very least, this
     /// is a formalization for deprecating enums.
     #[prost(bool, optional, tag="3", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct EnumValueOptions {
@@ -613,10 +613,10 @@ pub struct EnumValueOptions {
     /// for the enum value, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating enum values.
     #[prost(bool, optional, tag="1", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ServiceOptions {
@@ -630,10 +630,10 @@ pub struct ServiceOptions {
     /// for the service, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating services.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct MethodOptions {
@@ -647,12 +647,12 @@ pub struct MethodOptions {
     /// for the method, or it will be completely ignored; in the very least,
     /// this is a formalization for deprecating methods.
     #[prost(bool, optional, tag="33", default="false")]
-    pub deprecated: ::std::option::Option<bool>,
+    pub deprecated: core::option::Option<bool>,
     #[prost(enumeration="method_options::IdempotencyLevel", optional, tag="34", default="IdempotencyUnknown")]
-    pub idempotency_level: ::std::option::Option<i32>,
+    pub idempotency_level: core::option::Option<i32>,
     /// The parser stores options it doesn't recognize here. See above.
     #[prost(message, repeated, tag="999")]
-    pub uninterpreted_option: ::std::vec::Vec<UninterpretedOption>,
+    pub uninterpreted_option: prost::alloc::vec::Vec<UninterpretedOption>,
 }
 pub mod method_options {
     /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
@@ -677,21 +677,21 @@ pub mod method_options {
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct UninterpretedOption {
     #[prost(message, repeated, tag="2")]
-    pub name: ::std::vec::Vec<uninterpreted_option::NamePart>,
+    pub name: prost::alloc::vec::Vec<uninterpreted_option::NamePart>,
     /// The value of the uninterpreted option, in whatever type the tokenizer
     /// identified it as during parsing. Exactly one of these should be set.
     #[prost(string, optional, tag="3")]
-    pub identifier_value: ::std::option::Option<std::string::String>,
+    pub identifier_value: core::option::Option<prost::alloc::string::String>,
     #[prost(uint64, optional, tag="4")]
-    pub positive_int_value: ::std::option::Option<u64>,
+    pub positive_int_value: core::option::Option<u64>,
     #[prost(int64, optional, tag="5")]
-    pub negative_int_value: ::std::option::Option<i64>,
+    pub negative_int_value: core::option::Option<i64>,
     #[prost(double, optional, tag="6")]
-    pub double_value: ::std::option::Option<f64>,
+    pub double_value: core::option::Option<f64>,
     #[prost(bytes, optional, tag="7")]
-    pub string_value: ::std::option::Option<std::vec::Vec<u8>>,
+    pub string_value: core::option::Option<prost::alloc::vec::Vec<u8>>,
     #[prost(string, optional, tag="8")]
-    pub aggregate_value: ::std::option::Option<std::string::String>,
+    pub aggregate_value: core::option::Option<prost::alloc::string::String>,
 }
 pub mod uninterpreted_option {
     /// The name of the uninterpreted option.  Each string represents a segment in
@@ -702,7 +702,7 @@ pub mod uninterpreted_option {
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct NamePart {
         #[prost(string, required, tag="1")]
-        pub name_part: std::string::String,
+        pub name_part: prost::alloc::string::String,
         #[prost(bool, required, tag="2")]
         pub is_extension: bool,
     }
@@ -758,7 +758,7 @@ pub struct SourceCodeInfo {
     ///   ignore those that it doesn't understand, as more types of locations could
     ///   be recorded in the future.
     #[prost(message, repeated, tag="1")]
-    pub location: ::std::vec::Vec<source_code_info::Location>,
+    pub location: prost::alloc::vec::Vec<source_code_info::Location>,
 }
 pub mod source_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -787,14 +787,14 @@ pub mod source_code_info {
         /// this path refers to the whole field declaration (from the beginning
         /// of the label to the terminating semicolon).
         #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        pub path: prost::alloc::vec::Vec<i32>,
         /// Always has exactly three or four elements: start line, start column,
         /// end line (optional, otherwise assumed same as start line), end column.
         /// These are packed into a single field for efficiency.  Note that line
         /// and column numbers are zero-based -- typically you will want to add
         /// 1 to each before displaying to a user.
         #[prost(int32, repeated, tag="2")]
-        pub span: ::std::vec::Vec<i32>,
+        pub span: prost::alloc::vec::Vec<i32>,
         /// If this SourceCodeInfo represents a complete declaration, these are any
         /// comments appearing before and after the declaration which appear to be
         /// attached to the declaration.
@@ -843,11 +843,11 @@ pub mod source_code_info {
         ///
         ///   // ignored detached comments.
         #[prost(string, optional, tag="3")]
-        pub leading_comments: ::std::option::Option<std::string::String>,
+        pub leading_comments: core::option::Option<prost::alloc::string::String>,
         #[prost(string, optional, tag="4")]
-        pub trailing_comments: ::std::option::Option<std::string::String>,
+        pub trailing_comments: core::option::Option<prost::alloc::string::String>,
         #[prost(string, repeated, tag="6")]
-        pub leading_detached_comments: ::std::vec::Vec<std::string::String>,
+        pub leading_detached_comments: prost::alloc::vec::Vec<prost::alloc::string::String>,
     }
 }
 /// Describes the relationship between generated code and its original source
@@ -858,7 +858,7 @@ pub struct GeneratedCodeInfo {
     /// An Annotation connects some span of text in generated code to an element
     /// of its generating .proto file.
     #[prost(message, repeated, tag="1")]
-    pub annotation: ::std::vec::Vec<generated_code_info::Annotation>,
+    pub annotation: prost::alloc::vec::Vec<generated_code_info::Annotation>,
 }
 pub mod generated_code_info {
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -866,19 +866,19 @@ pub mod generated_code_info {
         /// Identifies the element in the original source .proto file. This field
         /// is formatted the same as SourceCodeInfo.Location.path.
         #[prost(int32, repeated, tag="1")]
-        pub path: ::std::vec::Vec<i32>,
+        pub path: prost::alloc::vec::Vec<i32>,
         /// Identifies the filesystem path to the original source .proto.
         #[prost(string, optional, tag="2")]
-        pub source_file: ::std::option::Option<std::string::String>,
+        pub source_file: core::option::Option<prost::alloc::string::String>,
         /// Identifies the starting offset in bytes in the generated code
         /// that relates to the identified object.
         #[prost(int32, optional, tag="3")]
-        pub begin: ::std::option::Option<i32>,
+        pub begin: core::option::Option<i32>,
         /// Identifies the ending offset in bytes in the generated code that
         /// relates to the identified offset. The end offset should be one past
         /// the last relevant byte (so the length of the text = end - begin).
         #[prost(int32, optional, tag="4")]
-        pub end: ::std::option::Option<i32>,
+        pub end: core::option::Option<i32>,
     }
 }
 /// `Any` contains an arbitrary serialized protocol buffer message along with a
@@ -992,10 +992,10 @@ pub struct Any {
     /// used with implementation specific semantics.
     ///
     #[prost(string, tag="1")]
-    pub type_url: std::string::String,
+    pub type_url: prost::alloc::string::String,
     /// Must be a valid serialized protocol buffer of the above specified type.
     #[prost(bytes, tag="2")]
-    pub value: std::vec::Vec<u8>,
+    pub value: prost::alloc::vec::Vec<u8>,
 }
 /// `SourceContext` represents information about the source of a
 /// protobuf element, like the file in which it is defined.
@@ -1004,26 +1004,26 @@ pub struct SourceContext {
     /// The path-qualified name of the .proto file that contained the associated
     /// protobuf element.  For example: `"google/protobuf/source_context.proto"`.
     #[prost(string, tag="1")]
-    pub file_name: std::string::String,
+    pub file_name: prost::alloc::string::String,
 }
 /// A protocol buffer message type.
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Type {
     /// The fully qualified message name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// The list of fields.
     #[prost(message, repeated, tag="2")]
-    pub fields: ::std::vec::Vec<Field>,
+    pub fields: prost::alloc::vec::Vec<Field>,
     /// The list of types appearing in `oneof` definitions in this type.
     #[prost(string, repeated, tag="3")]
-    pub oneofs: ::std::vec::Vec<std::string::String>,
+    pub oneofs: prost::alloc::vec::Vec<prost::alloc::string::String>,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="4")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="6")]
     pub syntax: i32,
@@ -1042,11 +1042,11 @@ pub struct Field {
     pub number: i32,
     /// The field name.
     #[prost(string, tag="4")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// The field type URL, without the scheme, for message or enumeration
     /// types. Example: `"type.googleapis.com/google.protobuf.Timestamp"`.
     #[prost(string, tag="6")]
-    pub type_url: std::string::String,
+    pub type_url: prost::alloc::string::String,
     /// The index of the field type in `Type.oneofs`, for message or enumeration
     /// types. The first type has index 1; zero means the type is not in the list.
     #[prost(int32, tag="7")]
@@ -1056,13 +1056,13 @@ pub struct Field {
     pub packed: bool,
     /// The protocol buffer options.
     #[prost(message, repeated, tag="9")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The field JSON name.
     #[prost(string, tag="10")]
-    pub json_name: std::string::String,
+    pub json_name: prost::alloc::string::String,
     /// The string value of the default value of this field. Proto2 syntax only.
     #[prost(string, tag="11")]
-    pub default_value: std::string::String,
+    pub default_value: prost::alloc::string::String,
 }
 pub mod field {
     /// Basic field types.
@@ -1127,16 +1127,16 @@ pub mod field {
 pub struct Enum {
     /// Enum type name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// Enum value definitions.
     #[prost(message, repeated, tag="2")]
-    pub enumvalue: ::std::vec::Vec<EnumValue>,
+    pub enumvalue: prost::alloc::vec::Vec<EnumValue>,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source context.
     #[prost(message, optional, tag="4")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// The source syntax.
     #[prost(enumeration="Syntax", tag="5")]
     pub syntax: i32,
@@ -1146,13 +1146,13 @@ pub struct Enum {
 pub struct EnumValue {
     /// Enum value name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// Enum value number.
     #[prost(int32, tag="2")]
     pub number: i32,
     /// Protocol buffer options.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
 }
 /// A protocol buffer option, which can be attached to a message, field,
 /// enumeration, etc.
@@ -1163,13 +1163,13 @@ pub struct Option {
     /// For custom options, it should be the fully-qualified name. For example,
     /// `"google.api.http"`.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// The option's value packed in an Any message. If the value is a primitive,
     /// the corresponding wrapper type defined in google/protobuf/wrappers.proto
     /// should be used. If the value is an enum, it should be stored as an int32
     /// value using the google.protobuf.Int32Value type.
     #[prost(message, optional, tag="2")]
-    pub value: ::std::option::Option<Any>,
+    pub value: core::option::Option<Any>,
 }
 /// The syntax in which a protocol buffer element is defined.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
@@ -1194,13 +1194,13 @@ pub struct Api {
     /// The fully qualified name of this interface, including package name
     /// followed by the interface's simple name.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// The methods of this interface, in unspecified order.
     #[prost(message, repeated, tag="2")]
-    pub methods: ::std::vec::Vec<Method>,
+    pub methods: prost::alloc::vec::Vec<Method>,
     /// Any metadata attached to the interface.
     #[prost(message, repeated, tag="3")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// A version string for this interface. If specified, must have the form
     /// `major-version.minor-version`, as in `1.10`. If the minor version is
     /// omitted, it defaults to zero. If the entire version field is empty, the
@@ -1223,14 +1223,14 @@ pub struct Api {
     ///
     ///
     #[prost(string, tag="4")]
-    pub version: std::string::String,
+    pub version: prost::alloc::string::String,
     /// Source context for the protocol buffer service represented by this
     /// message.
     #[prost(message, optional, tag="5")]
-    pub source_context: ::std::option::Option<SourceContext>,
+    pub source_context: core::option::Option<SourceContext>,
     /// Included interfaces. See [Mixin][].
     #[prost(message, repeated, tag="6")]
-    pub mixins: ::std::vec::Vec<Mixin>,
+    pub mixins: prost::alloc::vec::Vec<Mixin>,
     /// The source syntax of the service.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1240,22 +1240,22 @@ pub struct Api {
 pub struct Method {
     /// The simple name of this method.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// A URL of the input message type.
     #[prost(string, tag="2")]
-    pub request_type_url: std::string::String,
+    pub request_type_url: prost::alloc::string::String,
     /// If true, the request is streamed.
     #[prost(bool, tag="3")]
     pub request_streaming: bool,
     /// The URL of the output message type.
     #[prost(string, tag="4")]
-    pub response_type_url: std::string::String,
+    pub response_type_url: prost::alloc::string::String,
     /// If true, the response is streamed.
     #[prost(bool, tag="5")]
     pub response_streaming: bool,
     /// Any metadata attached to the method.
     #[prost(message, repeated, tag="6")]
-    pub options: ::std::vec::Vec<Option>,
+    pub options: prost::alloc::vec::Vec<Option>,
     /// The source syntax of this method.
     #[prost(enumeration="Syntax", tag="7")]
     pub syntax: i32,
@@ -1342,11 +1342,11 @@ pub struct Method {
 pub struct Mixin {
     /// The fully qualified name of the interface which is included.
     #[prost(string, tag="1")]
-    pub name: std::string::String,
+    pub name: prost::alloc::string::String,
     /// If non-empty specifies a path under which inherited HTTP paths
     /// are rooted.
     #[prost(string, tag="2")]
-    pub root: std::string::String,
+    pub root: prost::alloc::string::String,
 }
 /// A Duration represents a signed, fixed-length span of time represented
 /// as a count of seconds and fractions of seconds at nanosecond
@@ -1627,7 +1627,7 @@ pub struct Duration {
 pub struct FieldMask {
     /// The set of field mask paths.
     #[prost(string, repeated, tag="1")]
-    pub paths: ::std::vec::Vec<std::string::String>,
+    pub paths: prost::alloc::vec::Vec<prost::alloc::string::String>,
 }
 /// `Struct` represents a structured data value, consisting of fields
 /// which map to dynamically typed values. In some languages, `Struct`
@@ -1641,7 +1641,7 @@ pub struct FieldMask {
 pub struct Struct {
     /// Unordered map of dynamically typed values.
     #[prost(btree_map="string, message", tag="1")]
-    pub fields: ::std::collections::BTreeMap<std::string::String, Value>,
+    pub fields: prost::alloc::collections::BTreeMap<prost::alloc::string::String, Value>,
 }
 /// `Value` represents a dynamically typed value which can be either
 /// null, a number, a string, a boolean, a recursive struct value, or a
@@ -1653,7 +1653,7 @@ pub struct Struct {
 pub struct Value {
     /// The kind of value.
     #[prost(oneof="value::Kind", tags="1, 2, 3, 4, 5, 6")]
-    pub kind: ::std::option::Option<value::Kind>,
+    pub kind: core::option::Option<value::Kind>,
 }
 pub mod value {
     /// The kind of value.
@@ -1667,7 +1667,7 @@ pub mod value {
         NumberValue(f64),
         /// Represents a string value.
         #[prost(string, tag="3")]
-        StringValue(std::string::String),
+        StringValue(prost::alloc::string::String),
         /// Represents a boolean value.
         #[prost(bool, tag="4")]
         BoolValue(bool),
@@ -1686,7 +1686,7 @@ pub mod value {
 pub struct ListValue {
     /// Repeated field of dynamically typed values.
     #[prost(message, repeated, tag="1")]
-    pub values: ::std::vec::Vec<Value>,
+    pub values: prost::alloc::vec::Vec<Value>,
 }
 /// `NullValue` is a singleton enumeration to represent the null value for the
 /// `Value` type union.
diff --git a/protobuf/Cargo.toml b/protobuf/Cargo.toml
index e08aa7507..446bd3604 100644
--- a/protobuf/Cargo.toml
+++ b/protobuf/Cargo.toml
@@ -6,9 +6,9 @@ publish = false
 edition = "2018"
 
 [dependencies]
-bytes = "0.5"
-prost = { path = ".." }
-prost-types = { path = "../prost-types" }
+bytes = { version = "0.5", default-features = false }
+prost = { path = "..", default-features = false }
+prost-types = { path = "../prost-types", default-features = false }
 
 [build-dependencies]
 cfg-if = "0.1"
diff --git a/src/encoding.rs b/src/encoding.rs
index 4ed88882e..7510f33e0 100644
--- a/src/encoding.rs
+++ b/src/encoding.rs
@@ -2,12 +2,16 @@
 //!
 //! Meant to be used only from `Message` implementations.
 
-use std::cmp::min;
-use std::convert::TryFrom;
-use std::mem;
-use std::str;
-use std::u32;
-use std::usize;
+use core::cmp::min;
+use core::convert::TryFrom;
+use core::mem;
+use core::str;
+use core::u32;
+use core::usize;
+
+use alloc::format;
+use alloc::string::String;
+use alloc::vec::Vec;
 
 use ::bytes::{buf::ext::BufExt, Buf, BufMut};
 
@@ -381,7 +385,12 @@ where
     Ok(())
 }
 
-pub fn skip_field<B>(wire_type: WireType, tag: u32, buf: &mut B, ctx: DecodeContext) -> Result<(), DecodeError>
+pub fn skip_field<B>(
+    wire_type: WireType,
+    tag: u32,
+    buf: &mut B,
+    ctx: DecodeContext,
+) -> Result<(), DecodeError>
 where
     B: Buf,
 {
@@ -1081,10 +1090,8 @@ pub mod group {
 /// generic over `HashMap` and `BTreeMap`.
 macro_rules! map {
     ($map_ty:ident) => {
-        use std::collections::$map_ty;
-        use std::hash::Hash;
-
         use crate::encoding::*;
+        use core::hash::Hash;
 
         /// Generic protobuf map encode function.
         pub fn encode<K, V, B, KE, KL, VE, VL>(
@@ -1266,11 +1273,14 @@ macro_rules! map {
     };
 }
 
+#[cfg(feature = "std")]
 pub mod hash_map {
+    use std::collections::HashMap;
     map!(HashMap);
 }
 
 pub mod btree_map {
+    use alloc::collections::BTreeMap;
     map!(BTreeMap);
 }
 
@@ -1278,7 +1288,6 @@ pub mod btree_map {
 mod test {
     use std::borrow::Borrow;
     use std::fmt::Debug;
-    use std::io::Cursor;
     use std::u64;
 
     use ::bytes::{Bytes, BytesMut};
@@ -1366,6 +1375,7 @@ mod test {
             &mut buf,
             DecodeContext::default(),
         ) {
+            use alloc::string::ToString;
             return TestResult::error(error.to_string());
         };
 
@@ -1444,6 +1454,7 @@ mod test {
                 &mut buf,
                 DecodeContext::default(),
             ) {
+                use alloc::string::ToString;
                 return TestResult::error(error.to_string());
             };
         }
@@ -1458,7 +1469,7 @@ mod test {
     #[test]
     fn string_merge_invalid_utf8() {
         let mut s = String::new();
-        let mut buf = Cursor::new(b"\x02\x80\x80");
+        let mut buf = &b"\x02\x80\x80"[..];
 
         let r = string::merge(
             WireType::LengthDelimited,
@@ -1488,7 +1499,6 @@ mod test {
             let roundtrip_value = decode_varint(&mut encoded.clone()).expect("decoding failed");
             assert_eq!(value, roundtrip_value);
 
-            println!("encoding {:?}", encoded);
             let roundtrip_value = decode_varint_slow(&mut encoded).expect("slow decoding failed");
             assert_eq!(value, roundtrip_value);
         }
diff --git a/src/error.rs b/src/error.rs
index 02577a53a..9e06e275a 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,9 +1,9 @@
 //! Protobuf encoding and decoding errors.
 
-use std::borrow::Cow;
-use std::error;
-use std::fmt;
-use std::io;
+use alloc::borrow::Cow;
+use alloc::vec::Vec;
+
+use core::fmt;
 
 /// A Protobuf message decoding error.
 ///
@@ -54,14 +54,6 @@ impl fmt::Display for DecodeError {
     }
 }
 
-impl error::Error for DecodeError {}
-
-impl From<DecodeError> for io::Error {
-    fn from(error: DecodeError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidData, error)
-    }
-}
-
 /// A Protobuf message encoding error.
 ///
 /// `EncodeError` always indicates that a message failed to encode because the
@@ -103,10 +95,24 @@ impl fmt::Display for EncodeError {
     }
 }
 
-impl error::Error for EncodeError {}
+#[cfg(feature = "std")]
+mod std_details {
+    use std::{error, io};
+    use super::{DecodeError, EncodeError};
+
+    impl error::Error for DecodeError {}
 
-impl From<EncodeError> for io::Error {
-    fn from(error: EncodeError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidInput, error)
+    impl From<DecodeError> for io::Error {
+        fn from(error: DecodeError) -> io::Error {
+            io::Error::new(io::ErrorKind::InvalidData, error)
+        }
+    }
+
+    impl error::Error for EncodeError {}
+
+    impl From<EncodeError> for io::Error {
+        fn from(error: EncodeError) -> io::Error {
+            io::Error::new(io::ErrorKind::InvalidInput, error)
+        }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index f1674b55a..f4854b8a6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,13 @@
 #![doc(html_root_url = "https://docs.rs/prost/0.6.1")]
+#![no_std]
+
+// This hidden re-export of alloc crate gives prost-derive a way to get alloc types,
+// without forcing users of prost-derive to write `extern crate alloc;`
+#[doc(hidden)]
+pub extern crate alloc;
+
+#[cfg(feature = "std")]
+extern crate std;
 
 mod error;
 mod message;
diff --git a/src/message.rs b/src/message.rs
index 686b01182..e6acae713 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,5 +1,7 @@
-use std::fmt::Debug;
-use std::usize;
+use core::fmt::Debug;
+use core::usize;
+
+use alloc::boxed::Box;
 
 use bytes::{Buf, BufMut};
 
@@ -80,13 +82,13 @@ pub trait Message: Debug + Send + Sync {
     /// Decodes an instance of the message from a buffer.
     ///
     /// The entire buffer will be consumed.
-    fn decode<B>(mut buf: B) -> Result<Self, DecodeError>
+    fn decode<B>(buf: B) -> Result<Self, DecodeError>
     where
         B: Buf,
         Self: Default,
     {
         let mut message = Self::default();
-        Self::merge(&mut message, &mut buf).map(|_| message)
+        Self::merge(&mut message, buf).map(|_| message)
     }
 
     /// Decodes a length-delimited instance of the message from the buffer.
diff --git a/src/types.rs b/src/types.rs
index 43e7355ef..40c1b1617 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -15,6 +15,9 @@ use crate::{
     DecodeError, Message,
 };
 
+use alloc::string::String;
+use alloc::vec::Vec;
+
 /// `google.protobuf.BoolValue`
 impl Message for bool {
     fn encode_raw<B>(&self, buf: &mut B)
diff --git a/tests-2015/Cargo.toml b/tests-2015/Cargo.toml
index 657a98f3b..aaced88c4 100644
--- a/tests-2015/Cargo.toml
+++ b/tests-2015/Cargo.toml
@@ -16,7 +16,7 @@ default = ["edition-2015"]
 edition-2015 = []
 
 [dependencies]
-bytes = "0.5"
+bytes = { version = "0.5", default-features = false }
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
index 3d245b07d..4fbd3fd4f 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -11,7 +11,7 @@ build = "src/build.rs"
 doctest = false
 
 [dependencies]
-bytes = "0.5"
+bytes = { version = "0.5", default-features = false }
 cfg-if = "0.1"
 prost = { path = ".." }
 prost-types = { path = "../prost-types" }
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 00854c611..a137b07af 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -3,7 +3,9 @@ extern crate cfg_if;
 
 cfg_if! {
     if #[cfg(feature = "edition-2015")] {
+        extern crate alloc;
         extern crate bytes;
+        extern crate core;
         extern crate prost;
         extern crate prost_types;
         extern crate protobuf;
@@ -27,6 +29,8 @@ mod deprecated_field;
 #[cfg(test)]
 mod message_encoding;
 #[cfg(test)]
+mod message_encoding_alloc;
+#[cfg(test)]
 mod no_unused_results;
 #[cfg(test)]
 mod well_known_types;
@@ -211,6 +215,8 @@ mod tests {
     use std::collections::{BTreeMap, BTreeSet};
 
     use super::*;
+
+    use prost::Message;
     use protobuf::test_messages::proto3::TestAllTypesProto3;
 
     #[test]
diff --git a/tests/src/message_encoding_alloc.rs b/tests/src/message_encoding_alloc.rs
new file mode 100644
index 000000000..d0f4f4855
--- /dev/null
+++ b/tests/src/message_encoding_alloc.rs
@@ -0,0 +1,369 @@
+// This is the same as message_encoding.rs but all HashMap have been replaced
+// with BTreeMap and items grabbed from alloc namespace
+
+use prost::{Enumeration, Message, Oneof};
+
+use crate::check_message;
+use crate::check_serialize_equivalent;
+
+#[derive(Clone, PartialEq, Message)]
+pub struct RepeatedFloats {
+    #[prost(float, tag = "11")]
+    pub single_float: f32,
+    #[prost(float, repeated, packed = "true", tag = "41")]
+    pub repeated_float: Vec<f32>,
+}
+
+#[test]
+fn check_repeated_floats() {
+    check_message(&RepeatedFloats {
+        single_float: 0.0,
+        repeated_float: vec![
+            0.1,
+            340282300000000000000000000000000000000.0,
+            0.000000000000000000000000000000000000011754944,
+        ],
+    });
+}
+
+#[test]
+fn check_scalar_types() {
+    check_message(&ScalarTypes::default());
+}
+
+/// A protobuf message which contains all scalar types.
+#[derive(Clone, PartialEq, Message)]
+pub struct ScalarTypes {
+    #[prost(int32, tag = "001")]
+    pub int32: i32,
+    #[prost(int64, tag = "002")]
+    pub int64: i64,
+    #[prost(uint32, tag = "003")]
+    pub uint32: u32,
+    #[prost(uint64, tag = "004")]
+    pub uint64: u64,
+    #[prost(sint32, tag = "005")]
+    pub sint32: i32,
+    #[prost(sint64, tag = "006")]
+    pub sint64: i64,
+    #[prost(fixed32, tag = "007")]
+    pub fixed32: u32,
+    #[prost(fixed64, tag = "008")]
+    pub fixed64: u64,
+    #[prost(sfixed32, tag = "009")]
+    pub sfixed32: i32,
+    #[prost(sfixed64, tag = "010")]
+    pub sfixed64: i64,
+    #[prost(float, tag = "011")]
+    pub float: f32,
+    #[prost(double, tag = "012")]
+    pub double: f64,
+    #[prost(bool, tag = "013")]
+    pub _bool: bool,
+    #[prost(string, tag = "014")]
+    pub string: String,
+    #[prost(bytes, tag = "015")]
+    pub bytes: Vec<u8>,
+
+    #[prost(int32, required, tag = "101")]
+    pub required_int32: i32,
+    #[prost(int64, required, tag = "102")]
+    pub required_int64: i64,
+    #[prost(uint32, required, tag = "103")]
+    pub required_uint32: u32,
+    #[prost(uint64, required, tag = "104")]
+    pub required_uint64: u64,
+    #[prost(sint32, required, tag = "105")]
+    pub required_sint32: i32,
+    #[prost(sint64, required, tag = "106")]
+    pub required_sint64: i64,
+    #[prost(fixed32, required, tag = "107")]
+    pub required_fixed32: u32,
+    #[prost(fixed64, required, tag = "108")]
+    pub required_fixed64: u64,
+    #[prost(sfixed32, required, tag = "109")]
+    pub required_sfixed32: i32,
+    #[prost(sfixed64, required, tag = "110")]
+    pub required_sfixed64: i64,
+    #[prost(float, required, tag = "111")]
+    pub required_float: f32,
+    #[prost(double, required, tag = "112")]
+    pub required_double: f64,
+    #[prost(bool, required, tag = "113")]
+    pub required_bool: bool,
+    #[prost(string, required, tag = "114")]
+    pub required_string: String,
+    #[prost(bytes, required, tag = "115")]
+    pub required_bytes: Vec<u8>,
+
+    #[prost(int32, optional, tag = "201")]
+    pub optional_int32: Option<i32>,
+    #[prost(int64, optional, tag = "202")]
+    pub optional_int64: Option<i64>,
+    #[prost(uint32, optional, tag = "203")]
+    pub optional_uint32: Option<u32>,
+    #[prost(uint64, optional, tag = "204")]
+    pub optional_uint64: Option<u64>,
+    #[prost(sint32, optional, tag = "205")]
+    pub optional_sint32: Option<i32>,
+    #[prost(sint64, optional, tag = "206")]
+    pub optional_sint64: Option<i64>,
+
+    #[prost(fixed32, optional, tag = "207")]
+    pub optional_fixed32: Option<u32>,
+    #[prost(fixed64, optional, tag = "208")]
+    pub optional_fixed64: Option<u64>,
+    #[prost(sfixed32, optional, tag = "209")]
+    pub optional_sfixed32: Option<i32>,
+    #[prost(sfixed64, optional, tag = "210")]
+    pub optional_sfixed64: Option<i64>,
+    #[prost(float, optional, tag = "211")]
+    pub optional_float: Option<f32>,
+    #[prost(double, optional, tag = "212")]
+    pub optional_double: Option<f64>,
+    #[prost(bool, optional, tag = "213")]
+    pub optional_bool: Option<bool>,
+    #[prost(string, optional, tag = "214")]
+    pub optional_string: Option<String>,
+    #[prost(bytes, optional, tag = "215")]
+    pub optional_bytes: Option<Vec<u8>>,
+
+    #[prost(int32, repeated, packed = "false", tag = "301")]
+    pub repeated_int32: Vec<i32>,
+    #[prost(int64, repeated, packed = "false", tag = "302")]
+    pub repeated_int64: Vec<i64>,
+    #[prost(uint32, repeated, packed = "false", tag = "303")]
+    pub repeated_uint32: Vec<u32>,
+    #[prost(uint64, repeated, packed = "false", tag = "304")]
+    pub repeated_uint64: Vec<u64>,
+    #[prost(sint32, repeated, packed = "false", tag = "305")]
+    pub repeated_sint32: Vec<i32>,
+    #[prost(sint64, repeated, packed = "false", tag = "306")]
+    pub repeated_sint64: Vec<i64>,
+    #[prost(fixed32, repeated, packed = "false", tag = "307")]
+    pub repeated_fixed32: Vec<u32>,
+    #[prost(fixed64, repeated, packed = "false", tag = "308")]
+    pub repeated_fixed64: Vec<u64>,
+    #[prost(sfixed32, repeated, packed = "false", tag = "309")]
+    pub repeated_sfixed32: Vec<i32>,
+    #[prost(sfixed64, repeated, packed = "false", tag = "310")]
+    pub repeated_sfixed64: Vec<i64>,
+    #[prost(float, repeated, packed = "false", tag = "311")]
+    pub repeated_float: Vec<f32>,
+    #[prost(double, repeated, packed = "false", tag = "312")]
+    pub repeated_double: Vec<f64>,
+    #[prost(bool, repeated, packed = "false", tag = "313")]
+    pub repeated_bool: Vec<bool>,
+    #[prost(string, repeated, packed = "false", tag = "315")]
+    pub repeated_string: Vec<String>,
+    #[prost(bytes, repeated, packed = "false", tag = "316")]
+    pub repeated_bytes: Vec<Vec<u8>>,
+
+    #[prost(int32, repeated, tag = "401")]
+    pub packed_int32: Vec<i32>,
+    #[prost(int64, repeated, tag = "402")]
+    pub packed_int64: Vec<i64>,
+    #[prost(uint32, repeated, tag = "403")]
+    pub packed_uint32: Vec<u32>,
+    #[prost(uint64, repeated, tag = "404")]
+    pub packed_uint64: Vec<u64>,
+    #[prost(sint32, repeated, tag = "405")]
+    pub packed_sint32: Vec<i32>,
+    #[prost(sint64, repeated, tag = "406")]
+    pub packed_sint64: Vec<i64>,
+    #[prost(fixed32, repeated, tag = "407")]
+    pub packed_fixed32: Vec<u32>,
+
+    #[prost(fixed64, repeated, tag = "408")]
+    pub packed_fixed64: Vec<u64>,
+    #[prost(sfixed32, repeated, tag = "409")]
+    pub packed_sfixed32: Vec<i32>,
+    #[prost(sfixed64, repeated, tag = "410")]
+    pub packed_sfixed64: Vec<i64>,
+    #[prost(float, repeated, tag = "411")]
+    pub packed_float: Vec<f32>,
+    #[prost(double, repeated, tag = "412")]
+    pub packed_double: Vec<f64>,
+    #[prost(bool, repeated, tag = "413")]
+    pub packed_bool: Vec<bool>,
+    #[prost(string, repeated, tag = "415")]
+    pub packed_string: Vec<String>,
+    #[prost(bytes, repeated, tag = "416")]
+    pub packed_bytes: Vec<Vec<u8>>,
+}
+
+#[test]
+fn check_tags_inferred() {
+    check_message(&TagsInferred::default());
+    check_serialize_equivalent(&TagsInferred::default(), &TagsQualified::default());
+
+    let tags_inferred = TagsInferred {
+        one: true,
+        two: Some(42),
+        three: vec![0.0, 1.0, 1.0],
+        skip_to_nine: "nine".to_owned(),
+        ten: 0,
+        eleven: Default::default(),
+        back_to_five: vec![1, 0, 1],
+        six: Basic::default(),
+    };
+    check_message(&tags_inferred);
+
+    let tags_qualified = TagsQualified {
+        one: true,
+        two: Some(42),
+        three: vec![0.0, 1.0, 1.0],
+        five: vec![1, 0, 1],
+        six: Basic::default(),
+        nine: "nine".to_owned(),
+        ten: 0,
+        eleven: Default::default(),
+    };
+    check_serialize_equivalent(&tags_inferred, &tags_qualified);
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TagsInferred {
+    #[prost(bool)]
+    pub one: bool,
+    #[prost(int32, optional)]
+    pub two: Option<i32>,
+    #[prost(float, repeated)]
+    pub three: Vec<f32>,
+
+    #[prost(tag = "9", string, required)]
+    pub skip_to_nine: String,
+    #[prost(enumeration = "BasicEnumeration", default = "ONE")]
+    pub ten: i32,
+    #[prost(btree_map = "string, string")]
+    pub eleven: prost::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(tag = "5", bytes)]
+    pub back_to_five: Vec<u8>,
+    #[prost(message, required)]
+    pub six: Basic,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct TagsQualified {
+    #[prost(tag = "1", bool)]
+    pub one: bool,
+    #[prost(tag = "2", int32, optional)]
+    pub two: Option<i32>,
+    #[prost(tag = "3", float, repeated)]
+    pub three: Vec<f32>,
+
+    #[prost(tag = "5", bytes)]
+    pub five: Vec<u8>,
+    #[prost(tag = "6", message, required)]
+    pub six: Basic,
+
+    #[prost(tag = "9", string, required)]
+    pub nine: String,
+    #[prost(tag = "10", enumeration = "BasicEnumeration", default = "ONE")]
+    pub ten: i32,
+    #[prost(tag = "11", btree_map = "string, string")]
+    pub eleven: prost::alloc::collections::BTreeMap<String, String>,
+}
+
+/// A prost message with default value.
+#[derive(Clone, PartialEq, Message)]
+pub struct DefaultValues {
+    #[prost(int32, tag = "1", default = "42")]
+    pub int32: i32,
+
+    #[prost(int32, optional, tag = "2", default = "88")]
+    pub optional_int32: Option<i32>,
+
+    #[prost(string, tag = "3", default = "fourty two")]
+    pub string: String,
+
+    #[prost(enumeration = "BasicEnumeration", tag = "4", default = "ONE")]
+    pub enumeration: i32,
+
+    #[prost(enumeration = "BasicEnumeration", optional, tag = "5", default = "TWO")]
+    pub optional_enumeration: Option<i32>,
+
+    #[prost(enumeration = "BasicEnumeration", repeated, tag = "6")]
+    pub repeated_enumeration: Vec<i32>,
+}
+
+#[test]
+fn check_default_values() {
+    let default = DefaultValues::default();
+    assert_eq!(default.int32, 42);
+    assert_eq!(default.optional_int32, None);
+    assert_eq!(&default.string, "fourty two");
+    assert_eq!(default.enumeration, BasicEnumeration::ONE as i32);
+    assert_eq!(default.optional_enumeration, None);
+    assert_eq!(&default.repeated_enumeration, &[]);
+    assert_eq!(0, default.encoded_len());
+}
+
+/// A protobuf enum.
+#[derive(Clone, Copy, Debug, PartialEq, Enumeration)]
+pub enum BasicEnumeration {
+    ZERO = 0,
+    ONE = 1,
+    TWO = 2,
+    THREE = 3,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct Basic {
+    #[prost(int32, tag = "1")]
+    pub int32: i32,
+
+    #[prost(bool, repeated, packed = "false", tag = "2")]
+    pub bools: Vec<bool>,
+
+    #[prost(string, tag = "3")]
+    pub string: String,
+
+    #[prost(string, optional, tag = "4")]
+    pub optional_string: Option<String>,
+
+    #[prost(enumeration = "BasicEnumeration", tag = "5")]
+    pub enumeration: i32,
+
+    #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "6")]
+    pub enumeration_map: prost::alloc::collections::BTreeMap<i32, i32>,
+
+    #[prost(btree_map = "string, string", tag = "7")]
+    pub string_map: prost::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(btree_map = "int32, enumeration(BasicEnumeration)", tag = "10")]
+    pub enumeration_btree_map: prost::alloc::collections::BTreeMap<i32, i32>,
+
+    #[prost(btree_map = "string, string", tag = "11")]
+    pub string_btree_map: prost::alloc::collections::BTreeMap<String, String>,
+
+    #[prost(oneof = "BasicOneof", tags = "8, 9")]
+    pub oneof: Option<BasicOneof>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+pub struct Compound {
+    #[prost(message, optional, tag = "1")]
+    pub optional_message: Option<Basic>,
+
+    #[prost(message, required, tag = "2")]
+    pub required_message: Basic,
+
+    #[prost(message, repeated, tag = "3")]
+    pub repeated_message: Vec<Basic>,
+
+    #[prost(btree_map = "sint32, message", tag = "4")]
+    pub message_map: prost::alloc::collections::BTreeMap<i32, Basic>,
+
+    #[prost(btree_map = "sint32, message", tag = "5")]
+    pub message_btree_map: prost::alloc::collections::BTreeMap<i32, Basic>,
+}
+
+#[derive(Clone, PartialEq, Oneof)]
+pub enum BasicOneof {
+    #[prost(int32, tag = "8")]
+    Int(i32),
+    #[prost(string, tag = "9")]
+    String(String),
+}