diff --git a/cpp/csp/cppnodes/baselibimpl.cpp b/cpp/csp/cppnodes/baselibimpl.cpp
index 52a5537d9..0c9179ec9 100644
--- a/cpp/csp/cppnodes/baselibimpl.cpp
+++ b/cpp/csp/cppnodes/baselibimpl.cpp
@@ -705,6 +705,9 @@ DECLARE_CPPNODE( struct_fromts )
                 );
         }
 
+        if( unlikely( !out.get() -> validate() ) )
+            CSP_THROW( ValueError, "Struct " << cls.value() -> name() << " is not valid; required fields " << out -> formatAllUnsetStrictFields() << " did not tick" );
+
         CSP_OUTPUT( std::move( out ) );
     }
 
@@ -758,6 +761,9 @@ DECLARE_CPPNODE( struct_collectts )
                            }
                 );
         }
+        
+        if( unlikely( !out.get() -> validate() ) )
+            CSP_THROW( ValueError, "Struct " << cls.value() -> name() << " is not valid; required fields " << out -> formatAllUnsetStrictFields() << " did not tick" );
 
         CSP_OUTPUT( std::move( out ) );
     }
diff --git a/cpp/csp/engine/InputAdapter.h b/cpp/csp/engine/InputAdapter.h
index f992d6ff2..e1e9d0a0e 100644
--- a/cpp/csp/engine/InputAdapter.h
+++ b/cpp/csp/engine/InputAdapter.h
@@ -4,6 +4,7 @@
 #include <csp/core/Time.h>
 #include <csp/engine/Enums.h>
 #include <csp/engine/RootEngine.h>
+#include <csp/engine/Struct.h>
 #include <csp/engine/TimeSeriesProvider.h>
 
 namespace csp
@@ -22,6 +23,8 @@ class InputAdapter : public TimeSeriesProvider, public EngineOwned
     virtual void start( DateTime start, DateTime end ) {}
     virtual void stop() {}
 
+    virtual const char * name() const { return "InputAdapter"; }
+
     template< typename T > void outputTickTyped( DateTime timestamp, const T & value )
     {
         outputTickTyped( rootEngine() -> cycleCount(), timestamp, value );
@@ -55,6 +58,13 @@ class InputAdapter : public TimeSeriesProvider, public EngineOwned
 template<typename T>
 bool InputAdapter::consumeTick( const T & value )
 {
+    if constexpr( CspType::Type::fromCType<T>::type == CspType::TypeTraits::STRUCT )
+    {
+        if( unlikely( !( value -> validate() ) ) )
+            CSP_THROW( ValueError, "Struct " << value -> meta() -> name() << " from adapter type " << name() 
+                << " is not valid; required fields " << value -> formatAllUnsetStrictFields() << " were not set on init" );
+    }
+    
     switch( pushMode() )
     {
         case PushMode::LAST_VALUE:
diff --git a/cpp/csp/engine/Struct.cpp b/cpp/csp/engine/Struct.cpp
index 42830357e..b1def5c94 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -1,20 +1,26 @@
 #include <csp/core/System.h>
 #include <csp/engine/Struct.h>
 #include <algorithm>
+#include <ranges>
+#include <string>
+#include <sstream>
 
 namespace csp
 {
 
 StructField::StructField( CspTypePtr type, const std::string & fieldname, 
-                          size_t size, size_t alignment ) :
+                          size_t size, size_t alignment, bool isOptional ) :
     m_fieldname( fieldname ),
     m_offset( 0 ),
     m_size( size ),
     m_alignment( alignment ),
     m_maskOffset( 0 ),
     m_maskBit( 0 ),
+    m_noneMaskBit( 0 ),
     m_maskBitMask( 0 ),
-    m_type( type )
+    m_noneMaskBitMask( 0 ),
+    m_type( type ),
+    m_isOptional( isOptional )
 {
 }
 
@@ -33,13 +39,13 @@ and adjustments required for the hidden fields
 
 */
 
-StructMeta::StructMeta( const std::string & name, const Fields & fields,
-                        std::shared_ptr<StructMeta> base ) : m_name( name ), m_base( base ), m_fields( fields ),
+StructMeta::StructMeta( const std::string & name, const Fields & fields, bool isStrict,
+                        std::shared_ptr<StructMeta> base ) : m_name( name ), m_base( base ), m_fields( fields ), m_optionalFieldsBitMasks(),
                                                              m_size( 0 ), m_partialSize( 0 ), m_partialStart( 0 ), m_nativeStart( 0 ), m_basePadding( 0 ),
                                                              m_maskLoc( 0 ), m_maskSize( 0 ), m_firstPartialField( 0 ), m_firstNativePartialField( 0 ),
-                                                             m_isPartialNative( true ), m_isFullyNative( true )
+                                                             m_isPartialNative( true ), m_isFullyNative( true ), m_isStrict( isStrict )
 {
-    if( m_fields.empty() && !m_base)
+    if( m_fields.empty() && !m_base )
         CSP_THROW( TypeError, "Struct types must define at least 1 field" );
 
     //sort by sizes, biggest first, to get proper alignment
@@ -95,25 +101,64 @@ StructMeta::StructMeta( const std::string & name, const Fields & fields,
     //Setup masking bits for our fields
     //NOTE we can be more efficient by sticking masks into any potential alignment gaps, dont want to spend time on it 
     //at this point
-    m_maskSize     = !m_fields.empty() ? 1 + ( ( m_fields.size() - 1 ) / 8 ) : 0;
+
+    size_t optionalFieldCount = std::count_if( m_fields.begin(), m_fields.end(), []( const auto & f ) { return f -> isOptional(); } );
+    
+    m_maskSize     = !m_fields.empty() ? 1 + ( ( m_fields.size() + optionalFieldCount - 1 ) / 8 ) : 0;
     m_size         = offset + m_maskSize;
     m_partialSize  = m_size - baseSize;
     m_maskLoc      = m_size - m_maskSize;
+    
+    uint8_t numRemainingBits = ( m_fields.size() + optionalFieldCount ) % 8;
+    m_lastByteMask = ( 1u << numRemainingBits ) - 1;
 
     size_t  maskLoc = m_maskLoc;
     uint8_t maskBit = 0;
-    for( auto & f : m_fields )
+
+    // Set optional fields first so that their 2-bits never cross a byte boundary
+    // Put both the set bits and none bits in the same vector to avoid fragmentation
+    m_optionalFieldsBitMasks.resize( 2 * m_maskSize );
+    for( size_t i = 0; i < m_fields.size(); ++i )
+    {
+        auto & f = m_fields[ i ];
+        if( f -> isOptional() )
+        {
+            f -> setMaskOffset( maskLoc, maskBit );
+            optionalSetBitMask( maskLoc - m_maskLoc ) |= ( 1 << maskBit ); // set bits for this byte
+            optionalNoneBitMask( maskLoc - m_maskLoc ) |= ( 1 << ++maskBit ); // none bits for this byte
+            if( ++maskBit == 8 )
+            {
+                maskBit = 0;
+                ++maskLoc;
+            }
+        }
+    }
+
+    for( size_t i = 0; i < m_fields.size(); ++i )
     {
-        f -> setMaskOffset( maskLoc, maskBit );
-        if( ++maskBit == 8 )
+        auto & f = m_fields[ i ];
+        if( !f -> isOptional() )
         {
-            maskBit = 0;
-            ++maskLoc;
+            f -> setMaskOffset( maskLoc, maskBit );
+            if( ++maskBit == 8 )
+            {
+                maskBit = 0;
+                ++maskLoc;
+            }
         }
     }
 
     if( m_base )
     {
+        // The complete inheritance hierarchy must agree on strict/non-strict
+        if( m_isStrict != m_base -> isStrict() )
+        {
+            CSP_THROW( ValueError, 
+                    "Struct " << m_name << " was declared " << ( m_isStrict ? "strict" : "non-strict" ) << " but derives from "
+                    << m_base -> name() << " which is " << ( m_base -> isStrict() ? "strict" : "non-strict" )
+            );
+        }
+
         m_fields.insert( m_fields.begin(), m_base -> m_fields.begin(), m_base -> m_fields.end() );
         m_fieldnames.insert( m_fieldnames.begin(), m_base -> m_fieldnames.begin(), m_base -> m_fieldnames.end() );
         
@@ -453,23 +498,60 @@ void StructMeta::clear( Struct * s ) const
         m_base -> clear( s );
 }
 
+std::string StructMeta::formatAllUnsetStrictFields( const Struct * s ) const
+{
+    bool first = true;
+    std::stringstream ss;
+    ss << "["; 
+    
+    for( size_t i = 0; i < m_fields.size(); ++i )
+    {
+        const auto & f = m_fields[ i ];
+        if( !f -> isSet( s ) && !f -> isNone( s ) )
+        {
+            if( !first )
+                ss << ", ";
+            else
+                first = false;
+            ss << f -> fieldname();
+        }
+    }
+    ss << "]";
+    return ss.str();
+}
+
 bool StructMeta::allFieldsSet( const Struct * s ) const
 {
-    size_t  numLocalFields = m_fields.size() - m_firstPartialField;
-    uint8_t numRemainingBits = numLocalFields % 8;
+    /*
+    We can use bit operations to validate the struct. 
+        1. Let M1 be the bitmask with 1s that align with the set bit of optional fields and 
+        2. Let M2 be the bitmask with 1s that align with the none bit of optional fields. 
+            -- Both M1 and M2 are computed trivially when we create the meta.
+        3. Let M1* = M1 & mask. M1* now is the bitmask of all set optional fields.
+        4. Similarly, let M2* = M2 & mask, such that M2* is the bitmask of all none optional fields.
+        5. Let M3 = mask | (M1* << 1) | (M2* >> 1). Since the shifted set/none bitsets will fill in that optional fields other bit,
+            the struct can validate iff M3 is all 1s.
+
+    Notes:
+        1) We do this on a byte by byte basis currently. If we add 32/64 bit padding to the struct mask, we could do this as one single step for most structs.
+        2) There is an edge condition if a) the set bit of an optional field is the last bit of a byte or b) the none bit of an optional field is the first bit of a byte.
+            So, when we create the meta, we ensure this never happens by being smart about the ordering of fields in the mask.
+    */
 
     const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_maskLoc;
-    const uint8_t * e = m + m_maskSize - bool( numRemainingBits );
-    for( ; m < e; ++m )
+    const uint8_t * e = m + m_maskSize - bool( m_lastByteMask );
+
+    size_t i = 0;
+    for( ; m < e; ++m, ++i )
     {
-        if( *m != 0xFF )
+        if( ( *m | ( ( *m & optionalSetBitMask( i ) ) << 1 ) | ( ( *m & optionalNoneBitMask( i ) ) >> 1 ) ) != 0xFF )
             return false;
     }
 
-    if( numRemainingBits > 0 )
+    if( m_lastByteMask )
     {
-        uint8_t bitmask = ( 1u << numRemainingBits ) - 1;
-        if( ( *m & bitmask ) != bitmask )
+        uint8_t masked = *m & m_lastByteMask;
+        if( ( masked | ( ( ( masked & optionalSetBitMask( i ) ) << 1 ) & m_lastByteMask ) | ( ( masked & optionalNoneBitMask( i ) ) >> 1 ) ) != m_lastByteMask )
             return false;
     }
 
@@ -494,6 +576,11 @@ void StructMeta::destroy( Struct * s ) const
         m_base -> destroy( s );
 }
 
+[[nodiscard]] bool StructMeta::validate( const Struct * s ) const
+{   
+    return !isStrict() || allFieldsSet( s );
+}
+
 Struct::Struct( const std::shared_ptr<const StructMeta> & meta )
 {
     //Initialize meta shared_ptr
diff --git a/cpp/csp/engine/Struct.h b/cpp/csp/engine/Struct.h
index 64b51ecae..54ed071a4 100644
--- a/cpp/csp/engine/Struct.h
+++ b/cpp/csp/engine/Struct.h
@@ -22,6 +22,8 @@ class StructField
 {
 public:
 
+    static constexpr uint8_t BITS_PER_BYTE = 8;
+
     virtual ~StructField() {}
 
     const std::string & fieldname() const { return m_fieldname; }
@@ -29,20 +31,30 @@ class StructField
     size_t  offset() const                { return m_offset; }      //offset to start of field's memory from start of struct mem
     size_t  size() const                  { return m_size; }        //size of field in bytes
     size_t  alignment() const             { return m_alignment; }   //alignment of the field
-    size_t  maskOffset() const            { return m_maskOffset; }  //offset to location of the mask byte fo this field from start of struct mem
-    uint8_t maskBit() const               { return m_maskBit; }     //bit within mask byte associated with this field
+    size_t  maskOffset() const            { return m_maskOffset; }  //offset to location of the mask byte of this field from start of struct mem. Note that set/none bits always live on same byte
+    uint8_t maskBit() const               { return m_maskBit; }     //bit within mask byte associated with this field. Just used for debugging
     uint8_t maskBitMask() const           { return m_maskBitMask; } //same as maskBit but as a mask ( 1 << bit
+    uint8_t noneMaskBit() const           { return m_noneMaskBit; }     
+    uint8_t noneMaskBitMask() const       { return m_noneMaskBitMask; }
 
     bool isNative() const                 { return m_type -> type() <= CspType::Type::MAX_NATIVE_TYPE; }
+    bool isOptional() const               { return m_isOptional; }
 
     void setOffset( size_t off )          { m_offset = off; }
-    void setMaskOffset( size_t off, uint8_t bit  )
+    void setMaskOffset( size_t off, uint8_t bit )
     {
-        CSP_ASSERT( bit < 8 );
+        CSP_ASSERT( bit < BITS_PER_BYTE );
 
         m_maskOffset  = off;
         m_maskBit     = bit;
-        m_maskBitMask = 1 << bit;
+        m_maskBitMask = 1 << m_maskBit;
+        if( m_isOptional )
+        {
+            // None mask bit is always adjacent and on the same byte as the set bit
+            CSP_ASSERT( bit + 1 < BITS_PER_BYTE );
+            m_noneMaskBit = bit + 1;
+            m_noneMaskBitMask = 1 << m_noneMaskBit;            
+        }
     }
 
     bool isSet( const Struct * s ) const
@@ -51,6 +63,20 @@ class StructField
         return (*m ) & m_maskBitMask;
     }
 
+    bool isNone( const Struct * s ) const
+    {
+        const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_maskOffset;
+        return ( *m ) & m_noneMaskBitMask;
+    }
+
+    void setNone( Struct * s ) const
+    {
+        CSP_ASSERT( m_isOptional );
+
+        uint8_t * m = reinterpret_cast<uint8_t *>( s ) + m_maskOffset;
+        (*m) |= m_noneMaskBitMask;
+    }
+
     //copy methods need not deal with mask set/unset, only copy values
     virtual void copyFrom( const Struct * src, Struct * dest ) const = 0;
 
@@ -75,12 +101,14 @@ class StructField
 protected:
 
     StructField( CspTypePtr type, const std::string & fieldname,
-                 size_t size, size_t alignment );
+                 size_t size, size_t alignment, bool optional );
 
     void setIsSet( Struct * s ) const
     {
         uint8_t * m = reinterpret_cast<uint8_t *>( s ) + m_maskOffset;
         (*m) |= m_maskBitMask;
+
+        clearIsNone( s ); // no-op if not an optional field, as m_noneMaskBitMask is initialized to 0 in the constructor
     }
 
     const void * valuePtr( const Struct * s ) const
@@ -99,6 +127,12 @@ class StructField
         (*m) &= ~m_maskBitMask;
     }
 
+    void clearIsNone( Struct * s ) const
+    {
+        uint8_t * m = reinterpret_cast<uint8_t *>( s ) + m_maskOffset;
+        (*m) &= ~m_noneMaskBitMask;
+    }
+
 private:
     std::string  m_fieldname;
     size_t       m_offset;
@@ -106,8 +140,11 @@ class StructField
     const size_t m_alignment;
     size_t       m_maskOffset;
     uint8_t      m_maskBit;
+    uint8_t      m_noneMaskBit;
     uint8_t      m_maskBitMask;
+    uint8_t      m_noneMaskBitMask;
     CspTypePtr   m_type;
+    bool         m_isOptional;
 };
 
 using StructFieldPtr = std::shared_ptr<StructField>;
@@ -120,7 +157,7 @@ class NativeStructField : public StructField
 
 public:
     NativeStructField() {}
-    NativeStructField( const std::string & fieldname ) : NativeStructField( CspType::fromCType<T>::type(), fieldname )
+    NativeStructField( const std::string & fieldname, bool optional ) : NativeStructField( CspType::fromCType<T>::type(), fieldname, optional )
     {
     }
 
@@ -157,7 +194,8 @@ class NativeStructField : public StructField
     }
 
 protected:
-    NativeStructField( CspTypePtr type, const std::string & fieldname ) : StructField( type, fieldname, sizeof( T ), alignof( T ) )
+    NativeStructField( CspTypePtr type, const std::string & fieldname, bool optional ) 
+        : StructField( type, fieldname, sizeof( T ), alignof( T ), optional )
     {}
 };
 
@@ -179,7 +217,7 @@ using TimeStructField      = NativeStructField<Time>;
 class CspEnumStructField final : public NativeStructField<CspEnum>
 {
 public:
-    CspEnumStructField( CspTypePtr type, const std::string & fieldname ) : NativeStructField( type, fieldname )
+    CspEnumStructField( CspTypePtr type, const std::string & fieldname, bool optional ) : NativeStructField( type, fieldname, optional )
     {}
 };
 
@@ -218,8 +256,8 @@ class NotImplementedStructField : public StructField
 class NonNativeStructField : public StructField
 {
 public:
-    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment ) :
-        StructField( type, fieldname, size, alignment )
+    NonNativeStructField( CspTypePtr type, const std::string &fieldname, size_t size, size_t alignment, bool optional ) :
+        StructField( type, fieldname, size, alignment, optional )
     {}
 
     virtual void initialize( Struct * s ) const = 0;
@@ -244,8 +282,8 @@ class StringStructField final : public NonNativeStructField
 public:
     using CType = csp::CspType::StringCType;
 
-    StringStructField( CspTypePtr type, const std::string & fieldname ) :
-        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ) )
+    StringStructField( CspTypePtr type, const std::string & fieldname, bool optional ) :
+        NonNativeStructField( type, fieldname, sizeof( CType ), alignof( CType ), optional )
     {}
 
     void initialize( Struct * s ) const override
@@ -343,8 +381,8 @@ class ArrayStructField : public NonNativeStructField
     }
 
 public:
-    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname ) :
-        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ) )
+    ArrayStructField( CspTypePtr arrayType, const std::string & fieldname, bool optional ) :
+        NonNativeStructField( arrayType, fieldname, sizeof( CType ), alignof( CType ), optional )
     {}
 
     const CType & value( const Struct * s ) const
@@ -421,8 +459,8 @@ class ArrayStructField : public NonNativeStructField
 class DialectGenericStructField : public NonNativeStructField
 {
 public:
-    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment ) :
-        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment )
+    DialectGenericStructField( const std::string & fieldname, size_t size, size_t alignment, bool optional ) :
+        NonNativeStructField( CspType::DIALECT_GENERIC(), fieldname, size, alignment, optional )
     {}
 
     const DialectGenericType & value( const Struct * s ) const
@@ -587,7 +625,7 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     using FieldNames = std::vector<std::string>;
 
     //Fields will be re-arranged and assigned their offsets in StructMeta for optimal performance
-    StructMeta( const std::string & name, const Fields & fields, std::shared_ptr<StructMeta> base = nullptr );
+    StructMeta( const std::string & name, const Fields & fields, bool isStrict, std::shared_ptr<StructMeta> base = nullptr );
     virtual ~StructMeta();
 
     const std::string & name() const          { return m_name; }
@@ -595,6 +633,7 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t partialSize() const                { return m_partialSize; }
 
     bool isNative() const                     { return m_isFullyNative; }
+    bool isStrict() const                     { return m_isStrict; }
 
     const Fields & fields() const             { return m_fields; }
     const FieldNames & fieldNames() const     { return m_fieldnames; }
@@ -602,6 +641,8 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t maskLoc() const                    { return m_maskLoc; }
     size_t maskSize() const                   { return m_maskSize; }
 
+    [[nodiscard]] bool validate( const Struct * s ) const;
+
     const StructFieldPtr & field( const char * name ) const
     {
         static StructFieldPtr s_empty;
@@ -629,6 +670,9 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     void   clear( Struct * s ) const;
     bool   allFieldsSet( const Struct * s ) const;
 
+    // used for error messages / debugging
+    std::string formatAllUnsetStrictFields( const Struct * s ) const;
+
     //for debugging layout of types
     std::string layout() const;
 
@@ -653,10 +697,17 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     StructPtr                   m_default;
     FieldMap                    m_fieldMap;
 
+    const uint8_t & optionalSetBitMask( size_t byte ) const  { return m_optionalFieldsBitMasks[ 2 * byte ]; }
+    const uint8_t & optionalNoneBitMask( size_t byte ) const { return m_optionalFieldsBitMasks[ 2 * byte + 1 ]; }
+
+    uint8_t & optionalSetBitMask( size_t byte )     { return m_optionalFieldsBitMasks[ 2 * byte ]; }
+    uint8_t & optionalNoneBitMask( size_t byte )    { return m_optionalFieldsBitMasks[ 2 * byte + 1 ]; }
+    
     //fields in order, memory owners of field objects which in turn own the key memory
     //m_fields includes all base fields as well. m_fieldnames maintains the proper iteration order of fields
     Fields                      m_fields;
     FieldNames                  m_fieldnames;
+    std::vector<uint8_t>        m_optionalFieldsBitMasks; // masks (per-byte, for now) of the set bits and none bits of optional fields. Each byte has its set and none mask adjacent in the vector
     size_t                      m_size;              // full size of struct including base classes - NOTE this does not include refcount and meta ptr on Struct
     size_t                      m_partialSize;       // size of data in this level of the hierarchy
     size_t                      m_partialStart;      // offset into mem where data for this level starts
@@ -666,8 +717,10 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     size_t                      m_maskSize;          // number of bytes used for mask
     size_t                      m_firstPartialField; // index into m_fields of first field of this level
     size_t                      m_firstNativePartialField; // index into m_fields of first native field of this level
+    uint8_t                     m_lastByteMask;      // mask of remaining bits in the last byte of our mask
     bool                        m_isPartialNative;   // true if this level is all native
     bool                        m_isFullyNative;     // true if this level and all bases are fully native
+    bool                        m_isStrict;          // true if this is a strict struct
 };
 
 template<typename T>
@@ -738,6 +791,16 @@ class Struct
         return meta() -> allFieldsSet( this );
     }
 
+    [[nodiscard]] bool validate() const
+    {
+        return meta() -> validate( this );
+    }
+
+    std::string formatAllUnsetStrictFields() const
+    {
+        return meta() -> formatAllUnsetStrictFields( this );
+    }
+
 
     //used to cache dialect representations of this struct, if needed
     void * dialectPtr() const      { return hidden() -> dialectPtr; }
@@ -822,8 +885,8 @@ bool TypedStructPtr<T>::operator==( const TypedStructPtr<T> & rhs ) const
 class StructStructField final : public NonNativeStructField
 {
 public:
-    StructStructField( CspTypePtr cspType, const std::string &fieldname ) :
-        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ) )
+    StructStructField( CspTypePtr cspType, const std::string &fieldname, bool optional ) :
+        NonNativeStructField( cspType, fieldname, sizeof( StructPtr ), alignof( StructPtr ), optional )
     {
         CSP_ASSERT( cspType -> type() == CspType::Type::STRUCT );
         m_meta = std::static_pointer_cast<const CspStructType>( cspType ) -> meta();
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index dd89cc9c6..de1137e1b 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -20,8 +20,8 @@ class PyObjectStructField final : public DialectGenericStructField
 public:
     using BASE = DialectGenericStructField;
     PyObjectStructField( const std::string & name,
-                         PyTypeObjectPtr pytype ) : DialectGenericStructField( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ) ),
-                                                    m_pytype( pytype )
+                         PyTypeObjectPtr pytype, bool optional ) : BASE( name, sizeof( PyObjectPtr ), alignof( PyObjectPtr ), optional ),
+                                             m_pytype( pytype )
     {}
 
 
@@ -29,7 +29,7 @@ class PyObjectStructField final : public DialectGenericStructField
 
     void setValue( Struct * s, const DialectGenericType & obj ) const override
     {
-        auto& pyobj = reinterpret_cast<const PyObjectPtr &>(obj);
+        auto & pyobj = reinterpret_cast<const PyObjectPtr &>( obj );
         if( !PyObject_IsInstance( pyobj.ptr(), ( PyObject * ) m_pytype.ptr() ) )
             CSP_THROW( TypeError, "Invalid " << m_pytype -> tp_name << " type, expected " << m_pytype -> tp_name << " got " <<
                        Py_TYPE( pyobj.ptr() ) -> tp_name << " for field '" << fieldname() << "'" );
@@ -42,8 +42,8 @@ class PyObjectStructField final : public DialectGenericStructField
 };
 
 DialectStructMeta::DialectStructMeta( PyTypeObject * pyType, const std::string & name,
-                                      const Fields & flds, std::shared_ptr<StructMeta> base ) :
-    StructMeta( name, flds, base ),
+                                      const Fields & flds, bool isStrict, std::shared_ptr<StructMeta> base ) :
+    StructMeta( name, flds, isStrict, base ),
     m_pyType( PyTypeObjectPtr::incref( pyType ) )
 {
 }
@@ -106,16 +106,27 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
     if( !metadata )
         CSP_THROW( KeyError, "StructMeta missing __metadata__" );
 
+    PyObject * optFields = PyDict_GetItemString( dict, "__optional_fields__" );
+    if( !optFields ) 
+        CSP_THROW( TypeError, "StructMeta missing __optional_fields__" );
+
     StructMeta::Fields fields;
     {
         PyObject *key, *type;
         Py_ssize_t pos = 0;
+        bool optional;
+
         while( PyDict_Next( metadata, &pos, &key, &type ) )
         {
             const char * keystr = PyUnicode_AsUTF8( key );
             if( !keystr )
                 CSP_THROW( PythonPassthrough, "" );
 
+            int rv = PySet_Contains( optFields, key );
+            if( rv == -1 )
+                CSP_THROW( PythonPassthrough, "" );
+            optional = rv;
+                
             if( !PyType_Check( type ) && !PyList_Check( type ) )
                 CSP_THROW( TypeError, "Struct metadata for key " << keystr << " expected a type, got " << PyObjectPtr::incref( type ) );
 
@@ -124,30 +135,30 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
 
             switch( csptype -> type() )
             {
-                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr ); break;
-                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr ); break;
-                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr ); break;
-                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr ); break;
-                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr ); break;
-                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr ); break;
-                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr ); break;
-                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr ); break;
-                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr ); break;
-                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr ); break;
+                case csp::CspType::Type::BOOL:      field = std::make_shared<BoolStructField>( keystr, optional ); break;
+                case csp::CspType::Type::INT64:     field = std::make_shared<Int64StructField>( keystr, optional ); break;
+                case csp::CspType::Type::DOUBLE:    field = std::make_shared<DoubleStructField>( keystr, optional ); break;
+                case csp::CspType::Type::DATETIME:  field = std::make_shared<DateTimeStructField>( keystr, optional ); break;
+                case csp::CspType::Type::TIMEDELTA: field = std::make_shared<TimeDeltaStructField>( keystr, optional ); break;
+                case csp::CspType::Type::DATE:      field = std::make_shared<DateStructField>( keystr, optional ); break;
+                case csp::CspType::Type::TIME:      field = std::make_shared<TimeStructField>( keystr, optional ); break;
+                case csp::CspType::Type::STRING:    field = std::make_shared<StringStructField>( csptype, keystr, optional ); break;
+                case csp::CspType::Type::ENUM:      field = std::make_shared<CspEnumStructField>( csptype, keystr, optional ); break;
+                case csp::CspType::Type::STRUCT:    field = std::make_shared<StructStructField>( csptype, keystr, optional ); break;
                 case csp::CspType::Type::ARRAY:
                 {
                     const CspArrayType & arrayType = static_cast<const CspArrayType&>( *csptype );
-                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr]( auto tag ) -> std::shared_ptr<StructField>
+                    field = ArraySubTypeSwitch::invoke( arrayType.elemType(), [csptype,keystr,optional]( auto tag ) -> std::shared_ptr<StructField>
                     {
                         using CElemType = typename decltype(tag)::type;
                         using CType = typename CspType::Type::toCArrayType<CElemType>::type;
-                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr );
+                        return std::make_shared<ArrayStructField<CType>>( csptype, keystr, optional );
                     } );
 
                     break;
                 }
 
-                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ) ); break;
+                case csp::CspType::Type::DIALECT_GENERIC: field = std::make_shared<PyObjectStructField>( keystr, PyTypeObjectPtr::incref( ( PyTypeObject * ) type ), optional ); break;
                 default:
                     CSP_THROW( ValueError, "Unexpected csp type " << csptype -> type() << " on struct " << name );
             }
@@ -189,7 +200,12 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
                                   |                              |
                               PyStruct  --------------------------
     */
-    auto structMeta = std::make_shared<DialectStructMeta>( ( PyTypeObject * ) pymeta, name, fields, metabase );
+    
+    PyObject * strict_enabled = PyDict_GetItemString( dict, "__strict_enabled__" );
+    if( !strict_enabled )
+        CSP_THROW( KeyError, "StructMeta missing __strict_enabled__" );
+    bool isStrict = strict_enabled == Py_True;
+    auto structMeta = std::make_shared<DialectStructMeta>( ( PyTypeObject * ) pymeta, name, fields, isStrict, metabase );
 
     //Setup fast attr dict lookup
     pymeta -> attrDict = PyObjectPtr::own( PyDict_New() );
@@ -210,7 +226,6 @@ static PyObject * PyStructMeta_new( PyTypeObject *subtype, PyObject *args, PyObj
     if( PyDict_Size( defaults ) > 0 )
     {
         StructPtr defaultStruct = structMeta -> create();
-
         PyObject *key, *value;
         Py_ssize_t pos = 0;
         while( PyDict_Next( defaults, &pos, &key, &value ) )
@@ -437,6 +452,9 @@ PyObject * PyStruct::getattr( PyObject * attr )
 
     if( !field -> isSet( struct_.get() ) )
     {
+        if( field -> isNone( struct_.get() ) )
+            return Py_None;
+        
         //For efficiency reasons we set err here rather than rely on exceptions, since this
         //can get called pretty regularly, ie getattr( s, "f", default ) or hasattr checks
         //we also pass the attribute as the exception for efficiency, expensive to format a nice error here
@@ -468,10 +486,23 @@ void PyStruct::setattr( Struct * s, PyObject * attr, PyObject * value )
             auto *typedField = static_cast<const fieldType *>( field );
 
             if( value )
-                typedField -> setValue( struct_, fromPython<CType>( value, *field -> type() ) );
+            {
+                if( typedField -> isOptional() && value == Py_None )
+                {
+                    typedField -> setNone( struct_ );
+                    typedField -> clearValue( struct_ );
+                }
+                else
+                    typedField -> setValue( struct_, fromPython<CType>( value, *field -> type() ) );
+            }
             else
+            {
+                if( unlikely( struct_ -> meta() -> isStrict() ) )
+                    CSP_THROW( AttributeError, "Strict struct " << struct_ -> meta() -> name() << " does not allow the deletion of field " << field -> fieldname() );
                 typedField -> clearValue( struct_ );
+            }
         } );
+        
     }
     catch( const TypeError & err )
     {
@@ -653,7 +684,8 @@ void repr_struct( const Struct * struct_, std::string & tl_repr, bool show_unset
     for( auto & fieldname : meta -> fieldNames() )
     {
         auto & field = meta -> field( fieldname );
-        if( !( field -> isSet( struct_ ) ) && !show_unset )
+        bool isUnset = !( field -> isSet( struct_ ) || field -> isNone( struct_ ) );
+        if( isUnset && !show_unset )
             continue;
 
         if( unlikely( first ) ) first = false;
@@ -661,8 +693,10 @@ void repr_struct( const Struct * struct_, std::string & tl_repr, bool show_unset
 
         tl_repr += fieldname;
         tl_repr += "=";
-        if( !( field -> isSet( struct_ ) ) )
+        if( isUnset )
             tl_repr += "<unset>";
+        else if( field -> isNone( struct_ ) )
+            tl_repr += "None";
         else
             repr_field( struct_, field, tl_repr, show_unset );
     }
@@ -796,6 +830,8 @@ int PyStruct_init( PyStruct * self, PyObject * args, PyObject * kwargs )
     CSP_BEGIN_METHOD;
 
     PyStruct_setattrs( self, args, kwargs, "__init__" );
+    if( unlikely( !self -> struct_ -> validate() ) )
+        CSP_THROW( ValueError, "Struct " << self -> struct_ -> meta() -> name() << " is not valid; required fields " << self -> struct_ -> formatAllUnsetStrictFields() << " were not set on init" );
 
     CSP_RETURN_INT;
 }
diff --git a/cpp/csp/python/PyStruct.h b/cpp/csp/python/PyStruct.h
index 10fed6627..0121ca59e 100644
--- a/cpp/csp/python/PyStruct.h
+++ b/cpp/csp/python/PyStruct.h
@@ -25,7 +25,7 @@ class CSPTYPESIMPL_EXPORT DialectStructMeta : public StructMeta
 {
 public:
     DialectStructMeta( PyTypeObject * pyType, const std::string & name, 
-                       const Fields & fields, std::shared_ptr<StructMeta> base = nullptr );
+                       const Fields & fields, bool isStrict, std::shared_ptr<StructMeta> base = nullptr );
     ~DialectStructMeta() {}
 
     PyTypeObject * pyType() const { return m_pyType.get(); }
diff --git a/cpp/csp/python/PyStructToDict.cpp b/cpp/csp/python/PyStructToDict.cpp
index 3ad224b0b..faf354312 100644
--- a/cpp/csp/python/PyStructToDict.cpp
+++ b/cpp/csp/python/PyStructToDict.cpp
@@ -153,19 +153,27 @@ PyObjectPtr StructToDictHelper::parseStructToDictRecursive( const StructPtr& sel
     auto new_dict = PyObjectPtr::own( PyDict_New() );
     auto& fields = meta -> fields();
 
-    for( const auto& field: fields )
+    for( const auto & field: fields )
     {
         // NOTE: Add customization parameter to skip fields starting with underscore("_")
-        if( !field -> isSet( struct_ptr ) )
+        if( !field -> isSet( struct_ptr ) && !field -> isNone( struct_ptr ) )
             continue;
 
-        auto& key = field -> fieldname();
-        auto py_obj = switchCspType( field -> type(), [field, struct_ptr, this]( auto tag )
-            {
-                using CType = typename decltype( tag )::type;
-                auto * typedField = static_cast<const typename StructField::upcast<CType>::type *>( field.get() );
-                return this -> parseCspToPython( typedField -> value( struct_ptr ), *field -> type() );
-            } );
+        auto & key = field -> fieldname();
+
+        PyObjectPtr py_obj;
+        if( field -> isNone( struct_ptr ) )
+            py_obj = PyObjectPtr::incref( Py_None );
+        else
+        {
+            py_obj = switchCspType( field -> type(), [field, struct_ptr, this]( auto tag )
+                {
+                    using CType = typename decltype( tag )::type;
+                    auto * typedField = static_cast<const typename StructField::upcast<CType>::type *>( field.get() );
+                    return this -> parseCspToPython( typedField -> value( struct_ptr ), *field -> type() );
+                } );
+        }
+
         PyDict_SetItemString( new_dict.get(), key.c_str(), py_obj.get() );
     }
 
diff --git a/cpp/csp/python/PyStructToJson.cpp b/cpp/csp/python/PyStructToJson.cpp
index 3201d3161..65cfac308 100644
--- a/cpp/csp/python/PyStructToJson.cpp
+++ b/cpp/csp/python/PyStructToJson.cpp
@@ -180,19 +180,24 @@ rapidjson::Value toJsonRecursive( const StructPtr& self, rapidjson::Document& do
     new_dict.SetObject();
 
     auto& fields = meta -> fields();
-    for( const auto& field: fields )
+    for( const auto & field: fields )
     {
-        if( !field -> isSet( struct_ptr ) )
+        if( !field -> isSet( struct_ptr ) && !field -> isNone( struct_ptr ) )
         {
             continue;
         }
-        auto& key = field -> fieldname();
-        auto sub_json = switchCspType( field -> type(), [field, struct_ptr, callable, &doc]( auto tag )
-            {
-            using CType = typename decltype( tag )::type;
-            auto *typedField = static_cast<const typename StructField::upcast<CType>::type *>( field.get() );
-            return toJson( typedField -> value( struct_ptr ), *field -> type(), doc, callable );
-            } );
+        auto & key = field -> fieldname();
+
+        rapidjson::Value sub_json; // default is null
+        if( !field -> isNone( struct_ptr ) )
+        {
+            sub_json = switchCspType( field -> type(), [field, struct_ptr, callable, &doc]( auto tag )
+                {
+                    using CType = typename decltype( tag )::type;
+                    auto *typedField = static_cast<const typename StructField::upcast<CType>::type *>( field.get() );
+                    return toJson( typedField -> value( struct_ptr ), *field -> type(), doc, callable );
+                } );
+        }
         new_dict.AddMember( rapidjson::StringRef( key ), sub_json, doc.GetAllocator() );
     }
     return new_dict;
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 30b201285..05979ac6b 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -15,7 +15,7 @@
 
 
 class StructMeta(_csptypesimpl.PyStructMeta):
-    def __new__(cls, name, bases, dct):
+    def __new__(cls, name, bases, dct, strict=False):
         full_metadata = {}
         full_metadata_typed = {}
         metadata = {}
@@ -29,16 +29,21 @@ def __new__(cls, name, bases, dct):
                 defaults.update(base.__defaults__)
 
         annotations = dct.get("__annotations__", None)
+        optional_fields = set()
         if annotations:
             for k, v in annotations.items():
                 actual_type = v
                 # Lists need to be normalized too as potentially we need to add a boolean flag to use FastList
                 if v == FastList:
                     raise TypeError(f"{v} annotation is not supported without args")
+
+                if CspTypingUtils.is_optional_type(v) and strict:
+                    optional_fields.add(k)
+                    actual_type = typing.get_args(v)[0]
                 if (
-                    CspTypingUtils.is_generic_container(v)
-                    or CspTypingUtils.is_union_type(v)
-                    or CspTypingUtils.is_literal_type(v)
+                    CspTypingUtils.is_generic_container(actual_type)
+                    or CspTypingUtils.is_union_type(actual_type)
+                    or CspTypingUtils.is_literal_type(actual_type)
                 ):
                     actual_type = ContainerTypeNormalizer.normalized_type_to_actual_python_type(v)
                     if CspTypingUtils.is_generic_container(actual_type):
@@ -72,6 +77,8 @@ def __new__(cls, name, bases, dct):
         dct["__full_metadata_typed__"] = full_metadata_typed
         dct["__metadata__"] = metadata
         dct["__defaults__"] = defaults
+        dct["__optional_fields__"] = optional_fields
+        dct["__strict_enabled__"] = strict
 
         res = super().__new__(cls, name, bases, dct)
         # This is how we make sure we construct the pydantic schema from the new class
@@ -113,14 +120,16 @@ def _get_pydantic_core_schema(cls, _source_type, handler):
                 field_schema = core_schema.with_default_schema(
                     schema=field_schema, default=cls.__defaults__[field_name]
                 )
+
+            required = cls.__strict_enabled__ and field_name not in cls.__defaults__
             fields[field_name] = core_schema.typed_dict_field(
                 schema=field_schema,
-                required=False,  # Make all fields optional
+                required=required,
             )
         # Schema for dictionary inputs
         fields_schema = core_schema.typed_dict_schema(
             fields=fields,
-            total=False,  # Allow missing fields
+            total=False,  # Allow missing fields that start with underscore
             extra_behavior="allow",  # let csp catch extra attributes, allows underscore fields to pass through
         )
 
@@ -174,6 +183,14 @@ def metadata(cls, typed=False):
         else:
             return cls.__full_metadata__
 
+    @classmethod
+    def optional_fields(cls):
+        return cls.__optional_fields__
+
+    @classmethod
+    def is_strict(cls):
+        return cls.__strict_enabled__
+
     @classmethod
     def fromts(cls, trigger=None, /, **kwargs):
         """convert valid inputs into ts[ struct ]
@@ -237,12 +254,13 @@ def _obj_from_python(cls, json, obj_type):
         elif issubclass(obj_type, Struct):
             if not isinstance(json, dict):
                 raise TypeError("Representation of struct as json is expected to be of dict type")
-            res = obj_type()
+            obj_args = {}
             for k, v in json.items():
                 expected_type = obj_type.__full_metadata_typed__.get(k, None)
                 if expected_type is None:
                     raise KeyError(f"Unexpected key {k} for type {obj_type}")
-                setattr(res, k, cls._obj_from_python(v, expected_type))
+                obj_args[k] = cls._obj_from_python(v, expected_type)
+            res = obj_type(**obj_args)
             return res
         else:
             if isinstance(json, obj_type):
@@ -322,12 +340,12 @@ def __dir__(self):
         return sorted(super().__dir__() + list(self.__full_metadata_typed__.keys()))
 
 
-def define_struct(name, metadata: dict, defaults: dict = {}, base=Struct):
+def define_struct(name, metadata: dict, defaults: dict = {}, base=Struct, strict: bool = False):
     """Helper method to dynamically create struct types"""
 
     dct = deepcopy(defaults)
     dct["__annotations__"] = metadata
-    clazz = StructMeta(name, (base,), dct)
+    clazz = StructMeta(name, (base,), dct, strict=strict)
     return clazz
 
 
diff --git a/csp/impl/types/typing_utils.py b/csp/impl/types/typing_utils.py
index 27e227709..722626946 100644
--- a/csp/impl/types/typing_utils.py
+++ b/csp/impl/types/typing_utils.py
@@ -85,6 +85,13 @@ def is_union_type(cls, typ):
             typ, types.UnionType
         )
 
+    @classmethod
+    def is_optional_type(cls, typ):
+        if cls.is_union_type(typ):
+            args = typing.get_args(typ)
+            return type(None) in args
+        return False
+
     @classmethod
     def is_literal_type(cls, typ):
         return isinstance(typ, typing._GenericAlias) and typ.__origin__ is typing.Literal
diff --git a/csp/impl/wiring/edge.py b/csp/impl/wiring/edge.py
index 072b0a424..7cefed37b 100644
--- a/csp/impl/wiring/edge.py
+++ b/csp/impl/wiring/edge.py
@@ -202,6 +202,11 @@ def __getattr__(self, key):
             elemtype = typ.metadata(typed=True).get(key)
             if elemtype is None:
                 raise AttributeError("'%s' object has no attribute '%s'" % (self.tstype.typ.__name__, key))
+            if typ.is_strict() and key in typ.optional_fields():
+                raise AttributeError(
+                    "Cannot access optional field '%s' on strict struct object '%s' at graph time"
+                    % (key, self.tstype.typ.__name__)
+                )
             return csp.struct_field(self, key, elemtype)
 
         raise AttributeError("'Edge' object has no attribute '%s'" % (key))
diff --git a/csp/tests/impl/test_struct.py b/csp/tests/impl/test_struct.py
index e8e4509a9..8e1d46024 100644
--- a/csp/tests/impl/test_struct.py
+++ b/csp/tests/impl/test_struct.py
@@ -4263,6 +4263,31 @@ def foo2():
         del s
         gc.collect(0)
 
+    def test_pydantic_validation_strict_structs(self):
+        """Test Pydantic validation with strict structs"""
+
+        class StrictStruct(csp.Struct, strict=True):
+            a: int
+            b: str = "abc"
+            c: bool | None = None
+            d: int | None
+
+        good_schemas = [{"a": 1, "d": 2}, {"a": 1, "b": "abcd", "c": None, "d": None}]
+
+        bad_schemas = [
+            {"d": 2},  # missing a
+            {"a": 1},  # missing d
+            {"a": None, "d": None},  # wrong type for a
+            {"a": 1, "b": None, "d": None},  # wrong type for b
+        ]
+
+        for schema in good_schemas:
+            TypeAdapter(StrictStruct).validate_python(schema)
+
+        for schema in bad_schemas:
+            with self.assertRaises(ValidationError):
+                TypeAdapter(StrictStruct).validate_python(schema)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/csp/tests/test_strict_structs.py b/csp/tests/test_strict_structs.py
new file mode 100644
index 000000000..a96f17af3
--- /dev/null
+++ b/csp/tests/test_strict_structs.py
@@ -0,0 +1,454 @@
+import string
+import unittest
+from datetime import datetime, timedelta
+from typing import Optional
+
+import csp
+from csp.impl.struct import define_struct
+
+
+class TestStrictStructs(unittest.TestCase):
+    def test_backwards_compatibility(self):
+        """quick test that existing struct behavior is unchanged"""
+
+        class OldStruct(csp.Struct, strict=False):
+            a: int
+            b: str
+
+        s = OldStruct(a=5)
+        self.assertFalse(hasattr(s, "b"))
+        with self.assertRaisesRegex(AttributeError, "b"):
+            _ = s.b
+        del s.a
+        self.assertFalse(hasattr(s, "a"))
+
+    def test_strict_struct_initialization(self):
+        """test initialization rules for strict structs.
+
+        notably,
+        * Setting fields works as expected
+        * Initialize all non-default fields (including Optional)
+        * Missing required fields fail
+        """
+
+        class MyStrictStruct(csp.Struct, strict=True):
+            req_int: int
+            opt_str: str | None = None
+            def_int: int = 123
+            opt_bool: Optional[bool]  # no default
+
+        # Valid initialization
+        s1 = MyStrictStruct(req_int=10, opt_bool=True)
+        self.assertEqual(s1.req_int, 10)
+        self.assertEqual(s1.opt_bool, True)
+        self.assertEqual(s1.def_int, 123)
+        self.assertIsNone(s1.opt_str)
+
+        meta = s1.metadata()
+        self.assertEqual(meta["opt_str"], str)
+        self.assertEqual(meta["opt_bool"], bool)
+
+        with self.assertRaisesRegex(
+            ValueError,
+            r"Struct MyStrictStruct is not valid; required fields \[req_int, opt_bool\] were not set on init",
+        ):
+            MyStrictStruct()
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct MyStrictStruct is not valid; required fields \[opt_bool\] were not set on init"
+        ):
+            MyStrictStruct(req_int=10)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct MyStrictStruct is not valid; required fields \[req_int\] were not set on init"
+        ):
+            MyStrictStruct(opt_bool=None)
+
+    def test_strict_struct_hasattr_delattr(self):
+        """test hasattr and delattr behavior for strict structs"""
+
+        class MyStrictStruct(csp.Struct, strict=True):
+            req_int: int
+            opt_str: Optional[str] = None
+
+        s = MyStrictStruct(req_int=10, opt_str="hello")
+        r = MyStrictStruct(req_int=5)
+
+        # hasattr will always be True for all defined fields
+        self.assertTrue(hasattr(s, "req_int"))
+        self.assertTrue(hasattr(s, "opt_str"))
+        self.assertTrue(hasattr(r, "req_int"))
+        self.assertTrue(hasattr(r, "opt_str"))
+        self.assertIsNone(r.opt_str)
+
+        # delattr is forbidden
+        with self.assertRaisesRegex(
+            AttributeError, "Strict struct MyStrictStruct does not allow the deletion of field req_int"
+        ):
+            del s.req_int
+
+        with self.assertRaisesRegex(
+            AttributeError, "Strict struct MyStrictStruct does not allow the deletion of field opt_str"
+        ):
+            del s.opt_str
+
+    def test_strict_struct_set_none(self):
+        class MyStrictStruct(csp.Struct):
+            f1: int | None = None
+            f2: bool
+
+        mss = MyStrictStruct(f2=True)
+        self.assertIsNone(mss.f1)
+        self.assertTrue(mss.f2)
+
+        mss.f1 = 42
+        self.assertEqual(mss.f1, 42)
+
+        mss.f2 = False
+        mss.f1 = None
+        self.assertIsNone(mss.f1)
+        self.assertFalse(mss.f2)  # other field is not affected
+
+    def test_strict_struct_serialization(self):
+        """test to_dict, from_dict, to_json behavior"""
+
+        # to_dict , to_json
+        class MyStrictStruct(csp.Struct, strict=True):
+            req_int: int
+            opt_str: Optional[str] = None
+            def_int: int = 100
+            opt_str2: Optional[str]
+
+        s = MyStrictStruct(req_int=50, opt_str2="AStr")
+        expected_dict = {"req_int": 50, "opt_str": None, "def_int": 100, "opt_str2": "AStr"}
+        self.assertEqual(s.to_dict(), expected_dict)
+        expected_json = '{"opt_str":null,"opt_str2":"AStr","req_int":50,"def_int":100}'
+        self.assertEqual(s.to_json(), expected_json)
+
+        # from_dict
+        with self.assertRaisesRegex(
+            ValueError,
+            r"Struct MyStrictStruct is not valid; required fields \[opt_str2, req_int\] were not set on init",
+        ):
+            MyStrictStruct.from_dict({"opt_str": "hello", "def_int": 13})
+
+        MyStrictStruct.from_dict({"req_int": 60, "opt_str": None, "opt_str2": None})
+        s2 = MyStrictStruct.from_dict({"def_int": 72, "req_int": 60, "opt_str2": None})
+
+        meta = s2.metadata()
+        self.assertEqual(meta["req_int"], int)
+        self.assertEqual(meta["opt_str"], str)
+        self.assertEqual(meta["def_int"], int)
+        self.assertEqual(meta["opt_str2"], str)
+
+        self.assertIsNone(s2.opt_str)
+        self.assertIsNone(s2.opt_str2)
+        self.assertEqual(s2.req_int, 60)
+        self.assertEqual(s2.def_int, 72)
+
+    def test_strict_struct_wiring_access_1(self):
+        """test accessing fields on a time series at graph wiring time"""
+
+        class MyStrictStruct(csp.Struct, strict=True):
+            req_int: int
+            opt_str: Optional[str] = None
+
+        # check that at graph and wire time we are able to access required fields just fine
+        @csp.node
+        def ok_node(x: csp.ts[MyStrictStruct]) -> csp.ts[str]:
+            int_val = x.req_int
+            str_val = x.opt_str
+            return str(int_val) + ";" + str(str_val)
+
+        @csp.graph
+        def g():
+            s_ts = csp.const(MyStrictStruct(req_int=1))
+            req_ts = s_ts.req_int
+            csp.add_graph_output("req_ts", req_ts)
+            y = ok_node(s_ts)
+            csp.add_graph_output("y", y)
+
+        res = csp.run(g, starttime=datetime(2023, 1, 1))
+        self.assertEqual(res["req_ts"][0][1], 1)
+        self.assertEqual(res["y"][0][1], "1;None")
+
+        # check that at graph time we cannot access optional fields:
+        @csp.graph
+        def g_fail() -> csp.ts[str]:
+            s_ts = csp.const(MyStrictStruct(req_int=1))
+            opt_ts = s_ts.opt_str
+            return opt_ts
+
+        with self.assertRaisesRegex(
+            AttributeError,
+            "Cannot access optional field 'opt_str' on strict struct object 'MyStrictStruct' at graph time",
+        ):
+            csp.run(g_fail, starttime=datetime(2023, 1, 1))
+
+        # ensure you can return a strict struct from a user-defined node and access required fields correctly
+        class Test(csp.Struct, strict=True):
+            name: str
+            age: int
+            is_active: Optional[bool] = None
+
+            def greet(self):
+                return f"Hello, my name is {self.name} and I am {self.age} years old."
+
+        @csp.node
+        def test() -> csp.ts[Test]:
+            return Test(name="John", age=30, is_active=True)
+
+        @csp.graph
+        def main_graph():
+            res = test().is_active
+            csp.print("", res)
+
+        with self.assertRaisesRegex(
+            AttributeError, "Cannot access optional field 'is_active' on strict struct object 'Test' at graph time"
+        ):
+            csp.build_graph(main_graph)
+
+    def test_strict_struct_fromts_collectts(self):
+        """fromts requires all non-defaulted fields to be valid, collectts requires them to tick together"""
+
+        st = datetime(2023, 1, 1)
+
+        class MyStrictStruct(csp.Struct, strict=True):
+            req_int1: int
+            req_int2: int
+            opt_str: Optional[str] = None
+            req_default_str: str = "default"
+            opt_array_type: list[int] | None
+
+        def test_and_check_values(g):
+            res = csp.run(g, starttime=st)
+            print(res)
+            mss = res[0][0][1]
+            self.assertEqual(mss.req_int1, 1)
+            self.assertEqual(mss.req_int2, 2)
+            self.assertIsNone(mss.opt_str)
+            self.assertEqual(mss.req_default_str, "default")
+            self.assertIsNone(mss.opt_array_type)
+
+        @csp.graph
+        def fromts_invalid() -> csp.ts[MyStrictStruct]:
+            ts1 = csp.const(1)
+            ts2 = csp.const(2, delay=timedelta(seconds=1))
+
+            # ts2 is not valid when ts1 ticks
+            return MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct MyStrictStruct is not valid; required fields \[opt_array_type, req_int2\] did not tick"
+        ):
+            csp.run(fromts_invalid, starttime=st)
+
+        @csp.graph
+        def fromts_valid() -> csp.ts[MyStrictStruct]:
+            ts1 = csp.const(1)
+            ts2 = csp.const(2, delay=timedelta(seconds=1))
+            ts3 = csp.const(None, delay=timedelta(seconds=1))
+
+            # all are now valid when trigger ticks
+            trigger = csp.const(True, delay=timedelta(seconds=1))
+            return MyStrictStruct.fromts(trigger, req_int1=ts1, req_int2=ts2, opt_array_type=ts3)
+
+        test_and_check_values(fromts_valid)
+
+        @csp.graph
+        def collectts_invalid() -> csp.ts[MyStrictStruct]:
+            ts1 = csp.const(1)
+            ts2 = csp.const(2, delay=timedelta(seconds=1))
+            ts3 = csp.const(None, delay=timedelta(seconds=1))
+
+            # ts1 ticks out of seq with ts2, ts3
+            return MyStrictStruct.collectts(req_int1=ts1, req_int2=ts2, opt_array_type=ts3)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct MyStrictStruct is not valid; required fields \[opt_array_type, req_int2\] did not tick"
+        ):
+            csp.run(collectts_invalid, starttime=st)
+
+        @csp.graph
+        def collectts_valid() -> csp.ts[MyStrictStruct]:
+            ts1 = csp.const(1, delay=timedelta(seconds=1))
+            ts2 = csp.const(2, delay=timedelta(seconds=1))
+            ts3 = csp.const(None, delay=timedelta(seconds=1))
+
+            # all tick together, collectts is valid
+            return MyStrictStruct.collectts(req_int1=ts1, req_int2=ts2, opt_array_type=ts3)
+
+        test_and_check_values(collectts_valid)
+
+    def test_strict_struct_inheritance_and_nested(self):
+        class BaseStrict(csp.Struct, strict=True):
+            base_req: int
+
+        class DerivedStrict(BaseStrict, strict=True):
+            derived_req: int
+
+        d_ok = DerivedStrict(base_req=1, derived_req=2)
+        self.assertEqual(d_ok.base_req, 1)
+        self.assertEqual(d_ok.derived_req, 2)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct DerivedStrict is not valid; required fields \[derived_req\] were not set on init"
+        ):
+            DerivedStrict(base_req=10)
+        with self.assertRaisesRegex(
+            ValueError, r"Struct DerivedStrict is not valid; required fields \[base_req\] were not set on init"
+        ):
+            DerivedStrict(derived_req=20)
+
+        # nested struct fields:
+        class InnerStrict(csp.Struct, strict=True):
+            val: int
+            val2: float
+
+        class OuterStrict(csp.Struct, strict=True):
+            inner: InnerStrict
+
+        os_ok = OuterStrict(inner=InnerStrict(val=42, val2=43))
+        self.assertEqual(os_ok.inner.val, 42)
+        self.assertEqual(os_ok.inner.val2, 43)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct InnerStrict is not valid; required fields \[val, val2\] were not set on init"
+        ):
+            OuterStrict(inner=InnerStrict())
+        with self.assertRaisesRegex(
+            ValueError, r"Struct InnerStrict is not valid; required fields \[val2\] were not set on init"
+        ):
+            OuterStrict(inner=InnerStrict(val=42))
+
+        # nested loose struct inside strict:
+        class InnerLoose(csp.Struct):
+            val: int
+
+        class OuterStrict2(csp.Struct, strict=True):
+            inner: InnerLoose
+
+        ol_ok = OuterStrict2(inner=InnerLoose())
+        self.assertIsInstance(ol_ok.inner, InnerLoose)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct OuterStrict2 is not valid; required fields \[inner\] were not set on init"
+        ):
+            OuterStrict2()
+
+    def test_no_mixed_inheritance(self):
+        """non-strict structs inheriting from strict bases should raise, and vice versa"""
+
+        class StrictBase(csp.Struct, strict=True):
+            base_val: int
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct NonStrictChild1 was declared non-strict but derives from StrictBase which is strict"
+        ):
+
+            class NonStrictChild1(StrictBase):
+                child_val1: Optional[int] = None
+
+            _ = NonStrictChild1
+
+        class NonStrictBase(csp.Struct):
+            base_val: int
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct StrictChild1 was declared strict but derives from NonStrictBase which is non-strict"
+        ):
+
+            class StrictChild1(NonStrictBase, strict=True):
+                child_val1: Optional[int] = None
+
+            _ = StrictChild1
+
+    def test_nested_struct_serialization(self):
+        """to_dict / from_dict work with nested strict & non-strict structs"""
+
+        class InnerStrict(csp.Struct, strict=True):
+            x: int
+
+        class InnerLoose(csp.Struct):
+            y: Optional[int] = None
+
+        class OuterStruct(csp.Struct, strict=True):
+            strict_inner: InnerStrict
+            loose_inner: InnerLoose
+
+        o = OuterStruct(strict_inner=InnerStrict(x=5), loose_inner=InnerLoose())
+        expected_dict = {"strict_inner": {"x": 5}, "loose_inner": {"y": None}}
+        self.assertEqual(o.to_dict(), expected_dict)
+
+        o2 = OuterStruct.from_dict({"strict_inner": {"x": 10}, "loose_inner": {"y": 20}})
+        self.assertEqual(o2.strict_inner.x, 10)
+        self.assertIsNotNone(o2.loose_inner)
+        self.assertEqual(o2.loose_inner.y, 20)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct OuterStruct is not valid; required fields \[strict_inner\] were not set on init"
+        ):
+            OuterStruct.from_dict({"loose_inner": {"y": 1}})
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct InnerStrict is not valid; required fields \[x\] were not set on init"
+        ):
+            OuterStruct.from_dict({"strict_inner": {}, "loose_inner": {"y": None}})
+
+    def test_str_repr(self):
+        class StrictStruct(csp.Struct, strict=True):
+            a: int | None = None
+            b: bool
+            c: str | None = None
+
+        ss1 = StrictStruct(b=True, c="abc")
+        ss2 = StrictStruct(a=42, b=False)
+        self.assertEqual(repr(ss1), "StrictStruct( a=None, b=True, c=abc )")
+        self.assertEqual(str(ss2), "StrictStruct( a=42, b=False, c=None )")
+
+    def test_bitmask_edge_cases(self):
+        # 4 optional fields mean we have a full byte of optional fields
+        A = define_struct(
+            "A",
+            {c: Optional[int] for c in string.ascii_lowercase[:4]},
+            {c: None for c in string.ascii_lowercase[:4]},
+            strict=True,
+        )
+
+        def verify_first_byte(a):
+            self.assertEqual(a.a, 1)
+            self.assertIsNone(a.b)
+            self.assertEqual(a.c, 3)
+            self.assertIsNone(a.d)
+
+        def verify_second_byte(a, is_e_none):
+            if is_e_none:
+                self.assertIsNone(a.e)
+            else:
+                self.assertEqual(a.e, 5)
+            self.assertEqual(a.f, 6)
+            self.assertEqual(a.g, 7)
+
+        a = A(a=1, c=3)
+        verify_first_byte(a)
+
+        # 5 optional fields and 2 non-optional mean we have a full byte of optional fields, then a partial byte with 1 opt and 2 non-opt (4 bits)
+        A = define_struct(
+            "A",
+            {c: Optional[int] for c in string.ascii_lowercase[:5]} | {c: int for c in string.ascii_lowercase[5:7]},
+            {c: None for c in string.ascii_lowercase[:4]},  # do not default last field
+            strict=True,
+        )
+
+        # test with last opt field set, none, or neither
+        a = A(a=1, c=3, e=5, f=6, g=7)
+        verify_first_byte(a)
+        verify_second_byte(a, False)
+        a = A(e=None, f=6, g=7)
+        verify_second_byte(a, True)
+        with self.assertRaisesRegex(ValueError, r"Struct A is not valid; required fields \[e\] were not set on init"):
+            a = A(f=6, g=7)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/docs/wiki/api-references/csp.Struct-API.md b/docs/wiki/api-references/csp.Struct-API.md
index 3df8970d7..38769d35c 100644
--- a/docs/wiki/api-references/csp.Struct-API.md
+++ b/docs/wiki/api-references/csp.Struct-API.md
@@ -147,6 +147,45 @@ print(f"Using FastList field: value {s.a}, type {type(s.a)}, is Python list: {is
 - **`to_json(self, callback=lambda x: x)`**: convert struct instance to a json string, callback is invoked for any values encountered when processing the struct that are not basic Python types, datetime types, tuples, lists, dicts, csp.Structs, or csp.Enums. The callback should convert the unhandled type to a combination of the known types.
 - **`all_fields_set(self)`**: returns `True` if all the fields on the struct are set. Note that this will not recursively check sub-struct fields
 
-# Note on inheritance
+## Note on inheritance
 
 `csp.Struct` types may inherit from each other, but **multiple inheritance is not supported**. Composition is usually a good choice in absence of multiple inheritance.
+
+## "Strict" Structs
+
+By default, CSP Struct objects allow any field to be unset. This means that accessing fields without checking `hasattr` first can cause an `AttributeError` at runtime. To improve safety, CSP Structs provide the `strict` metaclass parameter that can be set to `True` to enable "strict struct" semantics.
+
+### `strict` Parameter
+
+- **Default:** `False` (for backwards compatibility)
+- **When set to `True`:** Enforces *strict struct semantics* — required fields must be set at initialization.
+
+### Semantics when `strict=True`
+
+1. **Required Fields**
+
+   - Any field with a non‑optional type (e.g., `x: int`) **must be set** upon struct creation.
+   - If no value is passed and no default is provided for a required field, a `ValueError` is raised with the missing fields.
+
+1. **Optional Fields**
+
+   - Fields declared as `Optional[T]` or `T | None` may be set to `None`; internally, the data will still be stored as its native type.
+   - Fields must either have a default value, which can be `None`, or they must be initialized explicitly (but can be set to `None`).
+
+1. **Additional Constraints**
+
+- Note that `del struct.field` is not allowed for strict structs — this will raise an error. As a result, for any strict struct, `hasattr(struct, field)` always returns True for any defined field and never needs to be checked.
+- A non-strict struct may not inherit (directly or indirectly) from a strict base, and vice versa.
+
+1. **Example**
+
+   ```python
+   class MyStruct(csp.Struct, strict=True):
+       x: int                   # required
+       y: Optional[str] = None  # optional
+       z: bool | None           # optional (alternate syntax, and no default)
+
+   MyStruct(x=3, z=None) # good: y defaults to None
+   MyStruct(y="hello") # bad: required fields x and z are not set
+   MyStruct(x=None, z=None) # bad: cannot set field x to None as its not optional
+   ```