diff --git a/pdl-compiler/src/backends.rs b/pdl-compiler/src/backends.rs
index 89257f5..478a44b 100644
--- a/pdl-compiler/src/backends.rs
+++ b/pdl-compiler/src/backends.rs
@@ -20,4 +20,4 @@ pub mod json;
 pub mod rust;
 pub mod rust_legacy;
 
-mod common;
+pub mod common;
diff --git a/pdl-compiler/src/backends/common/alignment.rs b/pdl-compiler/src/backends/common/alignment.rs
index 7145326..5609ca5 100644
--- a/pdl-compiler/src/backends/common/alignment.rs
+++ b/pdl-compiler/src/backends/common/alignment.rs
@@ -60,7 +60,7 @@ pub enum Chunk<S: Symbol> {
 }
 
 /// Packs symbols of various sizes, which may not be byte-aligned, into a sequence of byte-aligned chunks.
-#[derive(Debug, Clone)]
+#[derive(Default, Debug, Clone)]
 pub struct ByteAligner<S: Symbol> {
     /// Staged fields, waiting to be packed into a chunk.
     staged_fields: Vec<Field<S>>,
diff --git a/pdl-compiler/src/backends/rust/mod.rs b/pdl-compiler/src/backends/rust/mod.rs
index 3711d2a..6e67175 100644
--- a/pdl-compiler/src/backends/rust/mod.rs
+++ b/pdl-compiler/src/backends/rust/mod.rs
@@ -210,6 +210,23 @@ fn constraint_value_str(fields: &[&'_ ast::Field], constraint: &ast::Constraint)
     }
 }
 
+/// Return the default value for a field.
+/// Only concrete data fields are considered for inclusion,
+/// other kinds will yield an unreachable! error.
+fn data_field_default(field: &ast::Field) -> proc_macro2::TokenStream {
+    match &field.desc {
+        _ if field.cond.is_some() => quote! { None },
+        ast::FieldDesc::Scalar { .. } => quote! { 0 },
+        ast::FieldDesc::Typedef { .. } => quote! { Default::default() },
+        ast::FieldDesc::Array { width: Some(_), size: Some(size), .. } => quote! { [0; #size] },
+        ast::FieldDesc::Array { size: Some(_), .. } => {
+            quote! { std::array::from_fn(|_| Default::default()) }
+        }
+        ast::FieldDesc::Array { .. } => quote! { vec![] },
+        _ => unreachable!(),
+    }
+}
+
 fn implements_copy(scope: &analyzer::Scope<'_>, field: &ast::Field) -> bool {
     match &field.desc {
         ast::FieldDesc::Scalar { .. } => true,
@@ -454,7 +471,10 @@ fn generate_root_packet_decl(
             }
         })
         .collect::<Vec<_>>();
+    let data_field_defaults =
+        data_fields.iter().copied().map(data_field_default).collect::<Vec<_>>();
     let payload_field = decl.payload().map(|_| quote! { pub payload: Vec<u8>, });
+    let payload_default = decl.payload().map(|_| quote! { payload: vec![], });
     let payload_accessor =
         decl.payload().map(|_| quote! { pub fn payload(&self) -> &[u8] { &self.payload } });
 
@@ -519,6 +539,21 @@ fn generate_root_packet_decl(
         }
     });
 
+    // Provide the implementation of the default trait.
+    // #[derive(Default)] unfortunately does not support fixed sized arrays of length larger
+    // than 32, which forces us to write a manual implementation.
+    // https://github.com/rust-lang/rust/issues/61415
+    let default_impl = quote! {
+        impl Default for #name {
+            fn default() -> #name {
+                #name {
+                    #( #data_field_ids: #data_field_defaults, )*
+                    #payload_default
+                }
+            }
+        }
+    };
+
     // Provide the implementation of the specialization function.
     // The specialization function is only provided for declarations that have
     // child packets.
@@ -526,7 +561,7 @@ fn generate_root_packet_decl(
         .then(|| generate_specialize_impl(scope, schema, decl, id, &data_fields).unwrap());
 
     quote! {
-        #[derive(Default, Debug, Clone, PartialEq, Eq)]
+        #[derive(Debug, Clone, PartialEq, Eq)]
         #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
         pub struct #name {
             #( pub #data_field_ids: #data_field_types, )*
@@ -546,6 +581,8 @@ fn generate_root_packet_decl(
             )*
         }
 
+        #default_impl
+
         impl Packet for #name {
             #encoded_len
             #encode
@@ -594,7 +631,10 @@ fn generate_derived_packet_decl(
             }
         })
         .collect::<Vec<_>>();
+    let data_field_defaults =
+        data_fields.iter().copied().map(data_field_default).collect::<Vec<_>>();
     let payload_field = decl.payload().map(|_| quote! { pub payload: Vec<u8>, });
+    let payload_default = decl.payload().map(|_| quote! { payload: vec![], });
     let payload_accessor =
         decl.payload().map(|_| quote! { pub fn payload(&self) -> &[u8] { &self.payload } });
 
@@ -866,8 +906,23 @@ fn generate_derived_packet_decl(
     let specialize = (!children_decl.is_empty())
         .then(|| generate_specialize_impl(scope, schema, decl, id, &data_fields).unwrap());
 
+    // Provide the implementation of the default trait.
+    // #[derive(Default)] unfortunately does not support fixed sized arrays of length larger
+    // than 32, which forces us to write a manual implementation.
+    // https://github.com/rust-lang/rust/issues/61415
+    let default_impl = quote! {
+        impl Default for #name {
+            fn default() -> #name {
+                #name {
+                    #( #data_field_ids: #data_field_defaults, )*
+                    #payload_default
+                }
+            }
+        }
+    };
+
     quote! {
-        #[derive(Default, Debug, Clone, PartialEq, Eq)]
+        #[derive(Debug, Clone, PartialEq, Eq)]
         #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
         pub struct #name {
             #( pub #data_field_ids: #data_field_types, )*
@@ -900,6 +955,8 @@ fn generate_derived_packet_decl(
             )*
         }
 
+        #default_impl
+
         impl Packet for #name {
             #encoded_len
             #encode
@@ -1005,6 +1062,27 @@ fn generate_enum_decl(id: &str, tags: &[ast::Tag], width: usize) -> proc_macro2:
         }
     }
 
+    // Generate the default enum value.
+    // The default value is the first tag of the enum.
+    // If the first tag identifies a range, then the first value
+    // of the range is used.
+    let default_value = match &tags[0] {
+        ast::Tag::Value(ast::TagValue { id, .. }) => {
+            let id = format_tag_ident(id);
+            quote! { #name::#id }
+        }
+        ast::Tag::Range(ast::TagRange { tags, .. }) if !tags.is_empty() => {
+            let id = format_tag_ident(&tags[0].id);
+            quote! { #name::#id }
+        }
+        ast::Tag::Range(ast::TagRange { id, range, .. }) => {
+            let id = format_tag_ident(id);
+            let value = format_value(*range.start());
+            quote! { #name::#id(Private(#value)) }
+        }
+        ast::Tag::Other(_) => todo!(),
+    };
+
     // Generate the cases for parsing the enum value from an integer.
     let mut from_cases = vec![];
     for tag in tags.iter() {
@@ -1080,15 +1158,19 @@ fn generate_enum_decl(id: &str, tags: &[ast::Tag], width: usize) -> proc_macro2:
 
     quote! {
         #repr_u64
-        #[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+        #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
         #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
         #[cfg_attr(feature = "serde", serde(try_from = #backing_type_str, into = #backing_type_str))]
         pub enum #name {
-            // No specific value => use the first one as default
-            #[default]
             #(#variants,)*
         }
 
+        impl Default for #name {
+            fn default() -> #name {
+                #default_value
+            }
+        }
+
         impl TryFrom<#backing_type> for #name {
             type Error = #backing_type;
             fn try_from(value: #backing_type) -> Result<Self, Self::Error> {
diff --git a/pdl-compiler/src/main.rs b/pdl-compiler/src/main.rs
index 40bce03..4cf734b 100644
--- a/pdl-compiler/src/main.rs
+++ b/pdl-compiler/src/main.rs
@@ -14,8 +14,6 @@
 
 //! PDL parser and analyzer.
 
-use std::path::Path;
-
 use argh::FromArgs;
 use codespan_reporting::term::{self, termcolor};
 
@@ -80,11 +78,13 @@ struct Opt {
     /// For the rust backend this is a path e.g. "module::CustomField" or "super::CustomField".
     custom_field: Vec<String>,
 
+    #[cfg(feature = "java")]
     #[argh(option)]
     /// directory where generated files should go. This only works when 'output_format' is 'java'.
     /// If omitted, the generated code will be printed to stdout.
     output_dir: Option<String>,
 
+    #[cfg(feature = "java")]
     #[argh(option)]
     /// java package to contain the generated classes.
     java_package: Option<String>,
@@ -149,7 +149,7 @@ fn generate_backend(opt: &Opt) -> Result<(), String> {
                         &sources,
                         &analyzed_file,
                         &opt.custom_field,
-                        Path::new(output_dir),
+                        std::path::Path::new(output_dir),
                         package,
                     )
                 }
@@ -167,7 +167,8 @@ fn generate_backend(opt: &Opt) -> Result<(), String> {
         Err(err) => {
             let writer = termcolor::StandardStream::stderr(termcolor::ColorChoice::Always);
             let config = term::Config::default();
-            term::emit_to_write_style(&mut writer.lock(), &config, &sources, &err).expect("Could not print error");
+            term::emit_to_write_style(&mut writer.lock(), &config, &sources, &err)
+                .expect("Could not print error");
             Err(String::from("Error while parsing input"))
         }
     }
@@ -196,7 +197,7 @@ fn generate_tests(opt: &Opt, test_file: &str) -> Result<(), String> {
 
             backends::java::test::generate_tests(
                 test_file,
-                Path::new(output_dir),
+                std::path::Path::new(output_dir),
                 package.clone(),
                 &opt.input_file,
                 &opt.exclude_declaration,
diff --git a/pdl-compiler/src/parser.rs b/pdl-compiler/src/parser.rs
index b1b6d0f..463353b 100644
--- a/pdl-compiler/src/parser.rs
+++ b/pdl-compiler/src/parser.rs
@@ -649,8 +649,7 @@ pub fn parse_inline(
 ) -> Result<ast::File, Diagnostic<ast::FileId>> {
     let root = PDLParser::parse(Rule::file, &source)
         .map_err(|e| {
-            Diagnostic::error()
-                .with_message(format!("failed to parse input file '{name}': {e}"))
+            Diagnostic::error().with_message(format!("failed to parse input file '{name}': {e}"))
         })?
         .next()
         .unwrap();
diff --git a/pdl-compiler/tests/generated/rust/enum_declaration_big_endian.rs b/pdl-compiler/tests/generated/rust/enum_declaration_big_endian.rs
index fd49e18..60572a7 100644
--- a/pdl-compiler/tests/generated/rust/enum_declaration_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/enum_declaration_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedClosed {
-    #[default]
     A = 0x0,
     B = 0x1,
 }
+impl Default for IncompleteTruncatedClosed {
+    fn default() -> IncompleteTruncatedClosed {
+        IncompleteTruncatedClosed::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedClosed {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -90,15 +94,19 @@ impl From<IncompleteTruncatedClosed> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedOpen {
-    #[default]
     A,
     B,
     Unknown(Private<u8>),
 }
+impl Default for IncompleteTruncatedOpen {
+    fn default() -> IncompleteTruncatedOpen {
+        IncompleteTruncatedOpen::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedOpen {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -159,16 +167,20 @@ impl From<IncompleteTruncatedOpen> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedClosedWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
 }
+impl Default for IncompleteTruncatedClosedWithRange {
+    fn default() -> IncompleteTruncatedClosedWithRange {
+        IncompleteTruncatedClosedWithRange::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedClosedWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -231,17 +243,21 @@ impl From<IncompleteTruncatedClosedWithRange> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedOpenWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
     Unknown(Private<u8>),
 }
+impl Default for IncompleteTruncatedOpenWithRange {
+    fn default() -> IncompleteTruncatedOpenWithRange {
+        IncompleteTruncatedOpenWithRange::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedOpenWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -307,11 +323,10 @@ impl From<IncompleteTruncatedOpenWithRange> for u64 {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteTruncated {
-    #[default]
     A = 0x0,
     B = 0x1,
     C = 0x2,
@@ -321,6 +336,11 @@ pub enum CompleteTruncated {
     G = 0x6,
     H = 0x7,
 }
+impl Default for CompleteTruncated {
+    fn default() -> CompleteTruncated {
+        CompleteTruncated::A
+    }
+}
 impl TryFrom<u8> for CompleteTruncated {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -391,16 +411,20 @@ impl From<CompleteTruncated> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteTruncatedWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
 }
+impl Default for CompleteTruncatedWithRange {
+    fn default() -> CompleteTruncatedWithRange {
+        CompleteTruncatedWithRange::A
+    }
+}
 impl TryFrom<u8> for CompleteTruncatedWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -463,15 +487,19 @@ impl From<CompleteTruncatedWithRange> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteWithRange {
-    #[default]
     A,
     B,
     C(Private<u8>),
 }
+impl Default for CompleteWithRange {
+    fn default() -> CompleteWithRange {
+        CompleteWithRange::A
+    }
+}
 impl TryFrom<u8> for CompleteWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
diff --git a/pdl-compiler/tests/generated/rust/enum_declaration_little_endian.rs b/pdl-compiler/tests/generated/rust/enum_declaration_little_endian.rs
index fd49e18..60572a7 100644
--- a/pdl-compiler/tests/generated/rust/enum_declaration_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/enum_declaration_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedClosed {
-    #[default]
     A = 0x0,
     B = 0x1,
 }
+impl Default for IncompleteTruncatedClosed {
+    fn default() -> IncompleteTruncatedClosed {
+        IncompleteTruncatedClosed::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedClosed {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -90,15 +94,19 @@ impl From<IncompleteTruncatedClosed> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedOpen {
-    #[default]
     A,
     B,
     Unknown(Private<u8>),
 }
+impl Default for IncompleteTruncatedOpen {
+    fn default() -> IncompleteTruncatedOpen {
+        IncompleteTruncatedOpen::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedOpen {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -159,16 +167,20 @@ impl From<IncompleteTruncatedOpen> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedClosedWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
 }
+impl Default for IncompleteTruncatedClosedWithRange {
+    fn default() -> IncompleteTruncatedClosedWithRange {
+        IncompleteTruncatedClosedWithRange::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedClosedWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -231,17 +243,21 @@ impl From<IncompleteTruncatedClosedWithRange> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum IncompleteTruncatedOpenWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
     Unknown(Private<u8>),
 }
+impl Default for IncompleteTruncatedOpenWithRange {
+    fn default() -> IncompleteTruncatedOpenWithRange {
+        IncompleteTruncatedOpenWithRange::A
+    }
+}
 impl TryFrom<u8> for IncompleteTruncatedOpenWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -307,11 +323,10 @@ impl From<IncompleteTruncatedOpenWithRange> for u64 {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteTruncated {
-    #[default]
     A = 0x0,
     B = 0x1,
     C = 0x2,
@@ -321,6 +336,11 @@ pub enum CompleteTruncated {
     G = 0x6,
     H = 0x7,
 }
+impl Default for CompleteTruncated {
+    fn default() -> CompleteTruncated {
+        CompleteTruncated::A
+    }
+}
 impl TryFrom<u8> for CompleteTruncated {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -391,16 +411,20 @@ impl From<CompleteTruncated> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteTruncatedWithRange {
-    #[default]
     A,
     X,
     Y,
     B(Private<u8>),
 }
+impl Default for CompleteTruncatedWithRange {
+    fn default() -> CompleteTruncatedWithRange {
+        CompleteTruncatedWithRange::A
+    }
+}
 impl TryFrom<u8> for CompleteTruncatedWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -463,15 +487,19 @@ impl From<CompleteTruncatedWithRange> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum CompleteWithRange {
-    #[default]
     A,
     B,
     C(Private<u8>),
 }
+impl Default for CompleteWithRange {
+    fn default() -> CompleteWithRange {
+        CompleteWithRange::A
+    }
+}
 impl TryFrom<u8> for CompleteWithRange {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_big_endian.rs
index adbf773..1ac1d0e 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u32> for Foo {
     type Error = u32;
     fn try_from(value: u32) -> Result<Self, Self::Error> {
@@ -70,7 +74,7 @@ impl From<Foo> for u64 {
         u32::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 5],
@@ -80,6 +84,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_little_endian.rs
index 28b2627..cca3332 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_array_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u32> for Foo {
     type Error = u32;
     fn try_from(value: u32) -> Result<Self, Self::Error> {
@@ -70,7 +74,7 @@ impl From<Foo> for u64 {
         u32::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 5],
@@ -80,6 +84,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_big_endian.rs
index 40151c3..fc99d1b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u32> for Foo {
     type Error = u32;
     fn try_from(value: u32) -> Result<Self, Self::Error> {
@@ -70,7 +74,7 @@ impl From<Foo> for u64 {
         u32::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -80,6 +84,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_little_endian.rs
index 4dd43b9..b399a34 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_enum_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u32", into = "u32"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u32> for Foo {
     type Error = u32;
     fn try_from(value: u32) -> Result<Self, Self::Error> {
@@ -70,7 +74,7 @@ impl From<Foo> for u64 {
         u32::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -80,6 +84,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_big_endian.rs
index 4c6275c..8777291 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u32; 5],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 5usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_little_endian.rs
index bc95f45..5cd29d9 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_array_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u32; 5],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 5usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_big_endian.rs
index 5897bd1..cedde10 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u32,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_little_endian.rs
index ad4c41a..a02cd4e 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_24bit_scalar_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u32,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_big_endian.rs
index fb18faf..a6640b3 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u64", into = "u64"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u64> for Foo {
     type Error = u64;
     fn try_from(value: u64) -> Result<Self, Self::Error> {
@@ -55,7 +59,7 @@ impl From<Foo> for u64 {
         (&value).into()
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 7],
@@ -65,6 +69,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 8)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_little_endian.rs
index 9165f82..578e871 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_array_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u64", into = "u64"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u64> for Foo {
     type Error = u64;
     fn try_from(value: u64) -> Result<Self, Self::Error> {
@@ -55,7 +59,7 @@ impl From<Foo> for u64 {
         (&value).into()
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 7],
@@ -65,6 +69,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 8)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_big_endian.rs
index 589f75c..51f2047 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u64", into = "u64"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u64> for Foo {
     type Error = u64;
     fn try_from(value: u64) -> Result<Self, Self::Error> {
@@ -55,7 +59,7 @@ impl From<Foo> for u64 {
         (&value).into()
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -65,6 +69,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_little_endian.rs
index fe9af33..380d78a 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_enum_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u64", into = "u64"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u64> for Foo {
     type Error = u64;
     fn try_from(value: u64) -> Result<Self, Self::Error> {
@@ -55,7 +59,7 @@ impl From<Foo> for u64 {
         (&value).into()
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -65,6 +69,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_big_endian.rs
index a238f7e..3d5f926 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u64; 7],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 7usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 8)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_little_endian.rs
index adc0ab0..77f4f4d 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_array_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u64; 7],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 7usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         (self.x.len() * 8)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_big_endian.rs
index 50927c3..b1219dd 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u64,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_little_endian.rs
index f2d8eb8..2d8c8e0 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_64bit_scalar_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u64,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_big_endian.rs
index 333dcb9..ddeb57b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u8> for Foo {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -85,7 +89,7 @@ impl From<Foo> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 3],
@@ -95,6 +99,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         self.x.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_little_endian.rs
index 333dcb9..ddeb57b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_array_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Foo {
-    #[default]
     FooBar = 0x1,
     Baz = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::FooBar
+    }
+}
 impl TryFrom<u8> for Foo {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -85,7 +89,7 @@ impl From<Foo> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: [Foo; 3],
@@ -95,6 +99,13 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         self.x.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_big_endian.rs
index b79098d..2f58ef5 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u8> for Foo {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -85,7 +89,7 @@ impl From<Foo> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -95,6 +99,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_little_endian.rs
index b79098d..2f58ef5 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_enum_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Foo {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo::A
+    }
+}
 impl TryFrom<u8> for Foo {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -85,7 +89,7 @@ impl From<Foo> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Foo,
@@ -95,6 +99,11 @@ impl Bar {
         self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_big_endian.rs
index 8dddcc3..8f3b785 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u8; 3],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 3usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.x.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_little_endian.rs
index 8dddcc3..8f3b785 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_array_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: [u8; 3],
@@ -33,6 +33,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: [0; 3usize] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.x.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_big_endian.rs
index fb8c4fa..27e1642 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u8,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_little_endian.rs
index fb8c4fa..27e1642 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_8bit_scalar_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u8,
@@ -33,6 +33,11 @@ impl Foo {
         self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_big_endian.rs
index fa307d1..fa6dd5f 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub padding: u8,
@@ -37,6 +37,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1 + (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_little_endian.rs
index 6e015fd..db61324 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_count_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub padding: u8,
@@ -37,6 +37,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1 + (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_big_endian.rs
index c5f4b07..930dfcb 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_big_endian.rs
index 612e3a7..4646c5b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -61,6 +66,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_little_endian.rs
index 612e3a7..4646c5b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_count_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -61,6 +66,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_big_endian.rs
index 7854cd8..3e1e655 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -61,6 +66,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_little_endian.rs
index 7854cd8..3e1e655 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_dynamic_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -61,6 +66,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_little_endian.rs
index c5f4b07..930dfcb 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_big_endian.rs
index 43171d6..316bd3c 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,14 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            padding: 0,
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_little_endian.rs
index 43171d6..316bd3c 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_1_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,14 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            padding: 0,
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_big_endian.rs
index a7229ef..fdfd003 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,14 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            padding: 0,
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_little_endian.rs
index a7229ef..fdfd003 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_element_size_static_count_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub inner: Vec<u8>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.inner
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { inner: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         self.inner.len()
@@ -51,7 +56,7 @@ impl Packet for Foo {
         Ok((Self { inner }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub padding: u8,
@@ -65,6 +70,14 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar {
+            padding: 0,
+            x: std::array::from_fn(|_| Default::default()),
+        }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         1 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_big_endian.rs
index ed399ff..85e3915 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub padding: u8,
@@ -37,6 +37,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1 + (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_little_endian.rs
index 8237922..2deefa7 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_dynamic_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub padding: u8,
@@ -37,6 +37,11 @@ impl Foo {
         &self.x
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { padding: 0, x: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         1 + (self.x.len() * 3)
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
index 9dc9e4a..d4be35d 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
index 840734d..5853656 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_count_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
index 19550dd..a633a73 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
index beafbfa..500cdcd 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_unknown_element_width_dynamic_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.x
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5 + self.x.iter().map(Packet::encoded_len).sum::<usize>()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_big_endian.rs
index dc91367..51f21b8 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub a: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.a
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { a: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         128
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_little_endian.rs
index 4c0cd0e..c958b24 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_array_with_padding_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Vec<u16>,
@@ -33,6 +33,11 @@ impl Foo {
         &self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5 + (self.a.len() * 2)
@@ -74,7 +79,7 @@ impl Packet for Foo {
         Ok((Self { a }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub a: Vec<Foo>,
@@ -84,6 +89,11 @@ impl Bar {
         &self.a
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { a: vec![] }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         128
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_child_packets_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_child_packets_big_endian.rs
index 7d5ac20..76b8195 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_child_packets_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_child_packets_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -110,6 +114,15 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
@@ -172,7 +185,7 @@ impl Packet for Foo {
         Ok((Self { payload, a, b }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: u8,
@@ -247,6 +260,11 @@ impl Bar {
         100
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: 0, b: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5
@@ -272,7 +290,7 @@ impl Packet for Bar {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     pub y: u16,
@@ -347,6 +365,11 @@ impl Baz {
         Enum16::B
     }
 }
+impl Default for Baz {
+    fn default() -> Baz {
+        Baz { y: 0, a: 0 }
+    }
+}
 impl Packet for Baz {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_child_packets_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_child_packets_little_endian.rs
index fb7770a..8b0cc72 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_child_packets_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_child_packets_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -110,6 +114,15 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
@@ -172,7 +185,7 @@ impl Packet for Foo {
         Ok((Self { payload, a, b }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: u8,
@@ -247,6 +260,11 @@ impl Bar {
         100
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: 0, b: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5
@@ -272,7 +290,7 @@ impl Packet for Bar {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     pub y: u16,
@@ -347,6 +365,11 @@ impl Baz {
         Enum16::B
     }
 }
+impl Default for Baz {
+    fn default() -> Baz {
+        Baz { y: 0, a: 0 }
+    }
+}
 impl Packet for Baz {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_big_endian.rs
index 8276556..b832535 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -53,6 +53,18 @@ impl Foo {
         self.f
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: 0,
+            c: 0,
+            d: 0,
+            e: 0,
+            f: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         7
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_little_endian.rs
index 6d565d1..a2f3787 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_complex_scalars_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -53,6 +53,18 @@ impl Foo {
         self.f
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: 0,
+            c: 0,
+            d: 0,
+            e: 0,
+            f: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         7
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_custom_field_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_custom_field_big_endian.rs
index a9aaea8..7d89ee1 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_custom_field_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_custom_field_big_endian.rs
@@ -138,7 +138,7 @@ impl From<u64> for Bar3 {
         Bar3(value)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Bar1,
@@ -156,6 +156,15 @@ impl Foo {
         self.c
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: Default::default(),
+            b: Default::default(),
+            c: Default::default(),
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         15
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_custom_field_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_custom_field_little_endian.rs
index 70addaa..ac4e3bb 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_custom_field_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_custom_field_little_endian.rs
@@ -138,7 +138,7 @@ impl From<u64> for Bar3 {
         Bar3(value)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: Bar1,
@@ -156,6 +156,15 @@ impl Foo {
         self.c
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: Default::default(),
+            b: Default::default(),
+            c: Default::default(),
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         15
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_empty_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_empty_big_endian.rs
index dad3ddc..bb7c405 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_empty_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_empty_big_endian.rs
@@ -23,10 +23,15 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {}
 impl Foo {}
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {}
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         0
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_empty_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_empty_little_endian.rs
index dad3ddc..bb7c405 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_empty_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_empty_little_endian.rs
@@ -23,10 +23,15 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {}
 impl Foo {}
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {}
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         0
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_big_endian.rs
index 2d94b3d..9d13908 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum7 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum7 {
+    fn default() -> Enum7 {
+        Enum7::A
+    }
+}
 impl TryFrom<u8> for Enum7 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -90,7 +94,7 @@ impl From<Enum7> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub b: u64,
@@ -100,6 +104,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { b: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_little_endian.rs
index d9fa1af..17622ea 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_fixed_enum_field_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum7 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum7 {
+    fn default() -> Enum7 {
+        Enum7::A
+    }
+}
 impl TryFrom<u8> for Enum7 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -90,7 +94,7 @@ impl From<Enum7> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub b: u64,
@@ -100,6 +104,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { b: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_big_endian.rs
index 2dfc24e..0d7e20a 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub b: u64,
@@ -33,6 +33,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { b: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_little_endian.rs
index b7b0982..a2cb575 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_fixed_scalar_field_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub b: u64,
@@ -33,6 +33,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { b: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         8
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_grand_children_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_grand_children_big_endian.rs
index 79153c7..42e4482 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_grand_children_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_grand_children_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub foo: Enum16,
@@ -116,6 +120,16 @@ impl Parent {
         self.baz
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            foo: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         7 + self.payload.len()
@@ -199,7 +213,7 @@ impl Packet for Parent {
         Ok((Self { payload, foo, bar, baz }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     pub quux: Enum16,
@@ -314,6 +328,16 @@ impl Child {
         Enum16::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {
+            quux: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -340,7 +364,7 @@ impl Packet for Child {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     pub baz: Enum16,
@@ -463,6 +487,14 @@ impl GrandChild {
         Enum16::A
     }
 }
+impl Default for GrandChild {
+    fn default() -> GrandChild {
+        GrandChild {
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for GrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -490,7 +522,7 @@ impl Packet for GrandChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     pub payload: Vec<u8>,
@@ -611,6 +643,11 @@ impl GrandGrandChild {
         Enum16::A
     }
 }
+impl Default for GrandGrandChild {
+    fn default() -> GrandGrandChild {
+        GrandGrandChild { payload: vec![] }
+    }
+}
 impl Packet for GrandGrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_grand_children_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_grand_children_little_endian.rs
index cae5b0b..31406d6 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_grand_children_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_grand_children_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub foo: Enum16,
@@ -116,6 +120,16 @@ impl Parent {
         self.baz
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            foo: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         7 + self.payload.len()
@@ -199,7 +213,7 @@ impl Packet for Parent {
         Ok((Self { payload, foo, bar, baz }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     pub quux: Enum16,
@@ -314,6 +328,16 @@ impl Child {
         Enum16::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {
+            quux: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -340,7 +364,7 @@ impl Packet for Child {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     pub baz: Enum16,
@@ -463,6 +487,14 @@ impl GrandChild {
         Enum16::A
     }
 }
+impl Default for GrandChild {
+    fn default() -> GrandChild {
+        GrandChild {
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for GrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -490,7 +522,7 @@ impl Packet for GrandChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     pub payload: Vec<u8>,
@@ -611,6 +643,11 @@ impl GrandGrandChild {
         Enum16::A
     }
 }
+impl Default for GrandGrandChild {
+    fn default() -> GrandGrandChild {
+        GrandGrandChild { payload: vec![] }
+    }
+}
 impl Packet for GrandGrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_big_endian.rs
index 9a05491..7c242ba 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.c
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, b: 0, c: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_little_endian.rs
index 2724f2c..bca8204 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_mask_scalar_value_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.c
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, b: 0, c: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_big_endian.rs
index 3011e72..562427d 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum7 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum7 {
+    fn default() -> Enum7 {
+        Enum7::A
+    }
+}
 impl TryFrom<u8> for Enum7 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -91,14 +95,18 @@ impl From<Enum7> for u64 {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum9 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum9 {
+    fn default() -> Enum9 {
+        Enum9::A
+    }
+}
 impl TryFrom<u16> for Enum9 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -147,7 +155,7 @@ impl From<Enum9> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: Enum7,
@@ -169,6 +177,16 @@ impl Foo {
         self.w
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            x: Default::default(),
+            y: 0,
+            z: Default::default(),
+            w: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_little_endian.rs
index 22485ea..f8bd088 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_mixed_scalars_enums_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum7 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum7 {
+    fn default() -> Enum7 {
+        Enum7::A
+    }
+}
 impl TryFrom<u8> for Enum7 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -91,14 +95,18 @@ impl From<Enum7> for u64 {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum9 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum9 {
+    fn default() -> Enum9 {
+        Enum9::A
+    }
+}
 impl TryFrom<u16> for Enum9 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -147,7 +155,7 @@ impl From<Enum9> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: Enum7,
@@ -169,6 +177,16 @@ impl Foo {
         self.w
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            x: Default::default(),
+            y: 0,
+            z: Default::default(),
+            w: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_big_endian.rs
index a323fd8..2f7a09f 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_big_endian.rs
@@ -24,15 +24,19 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum8 {
-    #[default]
     A = 0x0,
     B = 0x1,
     C = 0x2,
 }
+impl Default for Enum8 {
+    fn default() -> Enum8 {
+        Enum8::A
+    }
+}
 impl TryFrom<u8> for Enum8 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -88,7 +92,7 @@ impl From<Enum8> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub v: Enum8,
@@ -119,6 +123,14 @@ impl Parent {
         self.v
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            v: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
@@ -148,7 +160,7 @@ impl Packet for Parent {
         Ok((Self { payload, v }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct AliasChild {
     pub v: Enum8,
@@ -219,6 +231,14 @@ impl AliasChild {
         self.v
     }
 }
+impl Default for AliasChild {
+    fn default() -> AliasChild {
+        AliasChild {
+            v: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for AliasChild {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
@@ -234,7 +254,7 @@ impl Packet for AliasChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalChild {}
 impl TryFrom<&NormalChild> for Parent {
@@ -283,6 +303,11 @@ impl NormalChild {
         Enum8::A
     }
 }
+impl Default for NormalChild {
+    fn default() -> NormalChild {
+        NormalChild {}
+    }
+}
 impl Packet for NormalChild {
     fn encoded_len(&self) -> usize {
         1
@@ -298,7 +323,7 @@ impl Packet for NormalChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild1 {}
 impl TryFrom<&NormalGrandChild1> for AliasChild {
@@ -371,6 +396,11 @@ impl NormalGrandChild1 {
         Enum8::B
     }
 }
+impl Default for NormalGrandChild1 {
+    fn default() -> NormalGrandChild1 {
+        NormalGrandChild1 {}
+    }
+}
 impl Packet for NormalGrandChild1 {
     fn encoded_len(&self) -> usize {
         1
@@ -386,7 +416,7 @@ impl Packet for NormalGrandChild1 {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild2 {
     pub payload: Vec<u8>,
@@ -471,6 +501,13 @@ impl NormalGrandChild2 {
         Enum8::C
     }
 }
+impl Default for NormalGrandChild2 {
+    fn default() -> NormalGrandChild2 {
+        NormalGrandChild2 {
+            payload: vec![],
+        }
+    }
+}
 impl Packet for NormalGrandChild2 {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_little_endian.rs
index a323fd8..2f7a09f 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_alias_child_little_endian.rs
@@ -24,15 +24,19 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum8 {
-    #[default]
     A = 0x0,
     B = 0x1,
     C = 0x2,
 }
+impl Default for Enum8 {
+    fn default() -> Enum8 {
+        Enum8::A
+    }
+}
 impl TryFrom<u8> for Enum8 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -88,7 +92,7 @@ impl From<Enum8> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub v: Enum8,
@@ -119,6 +123,14 @@ impl Parent {
         self.v
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            v: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
@@ -148,7 +160,7 @@ impl Packet for Parent {
         Ok((Self { payload, v }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct AliasChild {
     pub v: Enum8,
@@ -219,6 +231,14 @@ impl AliasChild {
         self.v
     }
 }
+impl Default for AliasChild {
+    fn default() -> AliasChild {
+        AliasChild {
+            v: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for AliasChild {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
@@ -234,7 +254,7 @@ impl Packet for AliasChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalChild {}
 impl TryFrom<&NormalChild> for Parent {
@@ -283,6 +303,11 @@ impl NormalChild {
         Enum8::A
     }
 }
+impl Default for NormalChild {
+    fn default() -> NormalChild {
+        NormalChild {}
+    }
+}
 impl Packet for NormalChild {
     fn encoded_len(&self) -> usize {
         1
@@ -298,7 +323,7 @@ impl Packet for NormalChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild1 {}
 impl TryFrom<&NormalGrandChild1> for AliasChild {
@@ -371,6 +396,11 @@ impl NormalGrandChild1 {
         Enum8::B
     }
 }
+impl Default for NormalGrandChild1 {
+    fn default() -> NormalGrandChild1 {
+        NormalGrandChild1 {}
+    }
+}
 impl Packet for NormalGrandChild1 {
     fn encoded_len(&self) -> usize {
         1
@@ -386,7 +416,7 @@ impl Packet for NormalGrandChild1 {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NormalGrandChild2 {
     pub payload: Vec<u8>,
@@ -471,6 +501,13 @@ impl NormalGrandChild2 {
         Enum8::C
     }
 }
+impl Default for NormalGrandChild2 {
+    fn default() -> NormalGrandChild2 {
+        NormalGrandChild2 {
+            payload: vec![],
+        }
+    }
+}
 impl Packet for NormalGrandChild2 {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_big_endian.rs
index ea55e7d..7f3f9d4 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_big_endian.rs
@@ -24,13 +24,17 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum8 {
-    #[default]
     A = 0x0,
 }
+impl Default for Enum8 {
+    fn default() -> Enum8 {
+        Enum8::A
+    }
+}
 impl TryFrom<u8> for Enum8 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -82,7 +86,7 @@ impl From<Enum8> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub v: Enum8,
@@ -107,6 +111,11 @@ impl Parent {
         self.v
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent { v: Default::default() }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         1
@@ -133,7 +142,7 @@ impl Packet for Parent {
         Ok((Self { v }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {}
 impl From<&Child> for Parent {
@@ -177,6 +186,11 @@ impl Child {
         Enum8::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {}
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_little_endian.rs
index ea55e7d..7f3f9d4 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_parent_with_no_payload_little_endian.rs
@@ -24,13 +24,17 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u8", into = "u8"))]
 pub enum Enum8 {
-    #[default]
     A = 0x0,
 }
+impl Default for Enum8 {
+    fn default() -> Enum8 {
+        Enum8::A
+    }
+}
 impl TryFrom<u8> for Enum8 {
     type Error = u8;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
@@ -82,7 +86,7 @@ impl From<Enum8> for u64 {
         u8::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub v: Enum8,
@@ -107,6 +111,11 @@ impl Parent {
         self.v
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent { v: Default::default() }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         1
@@ -133,7 +142,7 @@ impl Packet for Parent {
         Ok((Self { v }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {}
 impl From<&Child> for Parent {
@@ -177,6 +186,11 @@ impl Child {
         Enum8::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {}
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_big_endian.rs
index b4d4205..e12e8f3 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u32,
@@ -37,6 +37,11 @@ impl Foo {
         self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_little_endian.rs
index 64e396b..4570ed9 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u32,
@@ -37,6 +37,11 @@ impl Foo {
         self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
index ea52174..c3e6d8b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u32,
@@ -37,6 +37,11 @@ impl Foo {
         self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
index c439660..b1c39e2 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_unknown_size_terminal_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u32,
@@ -37,6 +37,11 @@ impl Foo {
         self.a
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         3 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_big_endian.rs
index fa2a4db..3a6ec2b 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, b: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_little_endian.rs
index 766e3d0..e409761 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_payload_field_variable_size_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { a: 0, b: 0, payload: vec![] }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_big_endian.rs
index 9e9c665..42e365a 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_big_endian.rs
@@ -23,10 +23,15 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {}
 impl Foo {}
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {}
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_little_endian.rs
index 9e9c665..42e365a 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_reserved_field_little_endian.rs
@@ -23,10 +23,15 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {}
 impl Foo {}
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {}
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         5
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_big_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_big_endian.rs
index 49ccebe..b175953 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.z
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0, y: 0, z: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_little_endian.rs b/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_little_endian.rs
index 1f28c8a..ab87026 100644
--- a/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/packet_decl_simple_scalars_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub x: u8,
@@ -41,6 +41,11 @@ impl Foo {
         self.z
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo { x: 0, y: 0, z: 0 }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/payload_with_size_modifier_big_endian.rs b/pdl-compiler/tests/generated/rust/payload_with_size_modifier_big_endian.rs
index b3c11f1..b91f55d 100644
--- a/pdl-compiler/tests/generated/rust/payload_with_size_modifier_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/payload_with_size_modifier_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Test {
     pub payload: Vec<u8>,
@@ -33,6 +33,11 @@ impl Test {
         &self.payload
     }
 }
+impl Default for Test {
+    fn default() -> Test {
+        Test { payload: vec![] }
+    }
+}
 impl Packet for Test {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/payload_with_size_modifier_little_endian.rs b/pdl-compiler/tests/generated/rust/payload_with_size_modifier_little_endian.rs
index b3c11f1..b91f55d 100644
--- a/pdl-compiler/tests/generated/rust/payload_with_size_modifier_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/payload_with_size_modifier_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Test {
     pub payload: Vec<u8>,
@@ -33,6 +33,11 @@ impl Test {
         &self.payload
     }
 }
+impl Default for Test {
+    fn default() -> Test {
+        Test { payload: vec![] }
+    }
+}
 impl Packet for Test {
     fn encoded_len(&self) -> usize {
         1 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/reserved_identifier_big_endian.rs b/pdl-compiler/tests/generated/rust/reserved_identifier_big_endian.rs
index b8d82f9..f855ca1 100644
--- a/pdl-compiler/tests/generated/rust/reserved_identifier_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/reserved_identifier_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Test {
     pub r#type: u8,
@@ -33,6 +33,11 @@ impl Test {
         self.r#type
     }
 }
+impl Default for Test {
+    fn default() -> Test {
+        Test { r#type: 0 }
+    }
+}
 impl Packet for Test {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/reserved_identifier_little_endian.rs b/pdl-compiler/tests/generated/rust/reserved_identifier_little_endian.rs
index b8d82f9..f855ca1 100644
--- a/pdl-compiler/tests/generated/rust/reserved_identifier_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/reserved_identifier_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Test {
     pub r#type: u8,
@@ -33,6 +33,11 @@ impl Test {
         self.r#type
     }
 }
+impl Default for Test {
+    fn default() -> Test {
+        Test { r#type: 0 }
+    }
+}
 impl Packet for Test {
     fn encoded_len(&self) -> usize {
         1
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_child_structs_big_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_child_structs_big_endian.rs
index 4d77861..4a84b24 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_child_structs_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_child_structs_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -110,6 +114,15 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
@@ -173,7 +186,7 @@ impl Packet for Foo {
         Ok((Self { payload, a, b }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: u8,
@@ -248,6 +261,11 @@ impl Bar {
         100
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: 0, b: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5
@@ -273,7 +291,7 @@ impl Packet for Bar {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     pub y: u16,
@@ -348,6 +366,11 @@ impl Baz {
         Enum16::B
     }
 }
+impl Default for Baz {
+    fn default() -> Baz {
+        Baz { y: 0, a: 0 }
+    }
+}
 impl Packet for Baz {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_child_structs_little_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_child_structs_little_endian.rs
index d5379eb..60fe257 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_child_structs_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_child_structs_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -110,6 +114,15 @@ impl Foo {
         self.b
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         4 + self.payload.len()
@@ -173,7 +186,7 @@ impl Packet for Foo {
         Ok((Self { payload, a, b }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Bar {
     pub x: u8,
@@ -248,6 +261,11 @@ impl Bar {
         100
     }
 }
+impl Default for Bar {
+    fn default() -> Bar {
+        Bar { x: 0, b: Default::default() }
+    }
+}
 impl Packet for Bar {
     fn encoded_len(&self) -> usize {
         5
@@ -273,7 +291,7 @@ impl Packet for Bar {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Baz {
     pub y: u16,
@@ -348,6 +366,11 @@ impl Baz {
         Enum16::B
     }
 }
+impl Default for Baz {
+    fn default() -> Baz {
+        Baz { y: 0, a: 0 }
+    }
+}
 impl Packet for Baz {
     fn encoded_len(&self) -> usize {
         6
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_big_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_big_endian.rs
index 8276556..b832535 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_big_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -53,6 +53,18 @@ impl Foo {
         self.f
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: 0,
+            c: 0,
+            d: 0,
+            e: 0,
+            f: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         7
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_little_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_little_endian.rs
index 6d565d1..a2f3787 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_complex_scalars_little_endian.rs
@@ -23,7 +23,7 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
         T::fmt(&self.0, f)
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Foo {
     pub a: u8,
@@ -53,6 +53,18 @@ impl Foo {
         self.f
     }
 }
+impl Default for Foo {
+    fn default() -> Foo {
+        Foo {
+            a: 0,
+            b: 0,
+            c: 0,
+            d: 0,
+            e: 0,
+            f: 0,
+        }
+    }
+}
 impl Packet for Foo {
     fn encoded_len(&self) -> usize {
         7
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_grand_children_big_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_grand_children_big_endian.rs
index dd5597c..0c8d373 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_grand_children_big_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_grand_children_big_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub foo: Enum16,
@@ -116,6 +120,16 @@ impl Parent {
         self.baz
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            foo: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         7 + self.payload.len()
@@ -200,7 +214,7 @@ impl Packet for Parent {
         Ok((Self { payload, foo, bar, baz }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     pub quux: Enum16,
@@ -316,6 +330,16 @@ impl Child {
         Enum16::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {
+            quux: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -342,7 +366,7 @@ impl Packet for Child {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     pub baz: Enum16,
@@ -466,6 +490,14 @@ impl GrandChild {
         Enum16::A
     }
 }
+impl Default for GrandChild {
+    fn default() -> GrandChild {
+        GrandChild {
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for GrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -493,7 +525,7 @@ impl Packet for GrandChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     pub payload: Vec<u8>,
@@ -615,6 +647,11 @@ impl GrandGrandChild {
         Enum16::A
     }
 }
+impl Default for GrandGrandChild {
+    fn default() -> GrandGrandChild {
+        GrandGrandChild { payload: vec![] }
+    }
+}
 impl Packet for GrandGrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
diff --git a/pdl-compiler/tests/generated/rust/struct_decl_grand_children_little_endian.rs b/pdl-compiler/tests/generated/rust/struct_decl_grand_children_little_endian.rs
index 5fdd147..982252c 100644
--- a/pdl-compiler/tests/generated/rust/struct_decl_grand_children_little_endian.rs
+++ b/pdl-compiler/tests/generated/rust/struct_decl_grand_children_little_endian.rs
@@ -24,14 +24,18 @@ impl<T: std::fmt::Debug> std::fmt::Debug for Private<T> {
     }
 }
 #[repr(u64)]
-#[derive(Default, Debug, Clone, Copy, Hash, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serde", serde(try_from = "u16", into = "u16"))]
 pub enum Enum16 {
-    #[default]
     A = 0x1,
     B = 0x2,
 }
+impl Default for Enum16 {
+    fn default() -> Enum16 {
+        Enum16::A
+    }
+}
 impl TryFrom<u16> for Enum16 {
     type Error = u16;
     fn try_from(value: u16) -> Result<Self, Self::Error> {
@@ -75,7 +79,7 @@ impl From<Enum16> for u64 {
         u16::from(value) as Self
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Parent {
     pub foo: Enum16,
@@ -116,6 +120,16 @@ impl Parent {
         self.baz
     }
 }
+impl Default for Parent {
+    fn default() -> Parent {
+        Parent {
+            foo: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Parent {
     fn encoded_len(&self) -> usize {
         7 + self.payload.len()
@@ -200,7 +214,7 @@ impl Packet for Parent {
         Ok((Self { payload, foo, bar, baz }, buf))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Child {
     pub quux: Enum16,
@@ -316,6 +330,16 @@ impl Child {
         Enum16::A
     }
 }
+impl Default for Child {
+    fn default() -> Child {
+        Child {
+            quux: Default::default(),
+            bar: Default::default(),
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for Child {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -342,7 +366,7 @@ impl Packet for Child {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandChild {
     pub baz: Enum16,
@@ -466,6 +490,14 @@ impl GrandChild {
         Enum16::A
     }
 }
+impl Default for GrandChild {
+    fn default() -> GrandChild {
+        GrandChild {
+            baz: Default::default(),
+            payload: vec![],
+        }
+    }
+}
 impl Packet for GrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
@@ -493,7 +525,7 @@ impl Packet for GrandChild {
         Ok((packet, trailing_bytes))
     }
 }
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct GrandGrandChild {
     pub payload: Vec<u8>,
@@ -615,6 +647,11 @@ impl GrandGrandChild {
         Enum16::A
     }
 }
+impl Default for GrandGrandChild {
+    fn default() -> GrandGrandChild {
+        GrandGrandChild { payload: vec![] }
+    }
+}
 impl Packet for GrandGrandChild {
     fn encoded_len(&self) -> usize {
         9 + self.payload.len()
diff --git a/pdl-tests/tests/traits.rs b/pdl-tests/tests/traits.rs
new file mode 100644
index 0000000..9c66bec
--- /dev/null
+++ b/pdl-tests/tests/traits.rs
@@ -0,0 +1,67 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use pdl_derive::pdl_inline;
+
+#[pdl_inline(
+    r#"
+little_endian_packets
+
+enum TestEnum : 8 {
+    A = 1,
+    B = 2,
+    OTHER = ..,
+}
+
+enum TestEnumRanges : 8 {
+    A = 1 .. 10,
+    B = 11 .. 20,
+    OTHER = ..,
+}
+
+struct TestStruct {
+    _count_(a) : 8,
+    a: TestEnum[],
+}
+
+packet TestPacket {
+  a: 8,
+  b: 1,
+  _reserved_ : 7,
+  c: TestEnum,
+  d: 8[40],
+  e: TestStruct,
+  f: 16 if b = 0,
+  _payload_
+}
+"#
+)]
+#[cfg(test)]
+mod default_trait {
+    #[test]
+    fn test() {
+        assert_eq!(TestEnum::default(), TestEnum::A);
+        assert_eq!(TestEnumRanges::default(), TestEnumRanges::try_from(1).unwrap());
+
+        let default_struct = TestStruct::default();
+        assert_eq!(default_struct.a.len(), 0);
+
+        let default_packet = TestPacket::default();
+        assert_eq!(default_packet.a, 0);
+        assert_eq!(default_packet.c, TestEnum::A);
+        assert_eq!(default_packet.d, [0; 40]);
+        assert_eq!(default_packet.e, default_struct);
+        assert_eq!(default_packet.f, None);
+    }
+}