diff --git a/cpp/csp/adapters/websocket/ClientAdapterManager.cpp b/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
index 423f2a234..e472357d8 100644
--- a/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
+++ b/cpp/csp/adapters/websocket/ClientAdapterManager.cpp
@@ -52,8 +52,15 @@ void ClientAdapterManager::start( DateTime starttime, DateTime endtime )
     if( m_inputAdapter ) {
         m_endpoint -> setOnMessage(
             [ this ]( void* c, size_t t ) {
-                PushBatch batch( m_engine -> rootEngine() );
-                m_inputAdapter -> processMessage( c, t, &batch );
+                try
+                {
+                    PushBatch batch( m_engine -> rootEngine() );
+                    m_inputAdapter -> processMessage( c, t, &batch );
+                }
+                catch( csp::Exception & err )
+                {
+                    pushStatus( StatusLevel::ERROR, ClientStatusType::GENERIC_ERROR, err.what() );
+                }
             }
         );
     } else {
diff --git a/cpp/csp/cppnodes/baselibimpl.cpp b/cpp/csp/cppnodes/baselibimpl.cpp
index 52a5537d9..c36393b98 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; some required fields did not tick" );
 
         CSP_OUTPUT( std::move( out ) );
     }
diff --git a/cpp/csp/engine/InputAdapter.h b/cpp/csp/engine/InputAdapter.h
index f992d6ff2..051ca83ea 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
@@ -55,6 +56,12 @@ 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() << " 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..3c327aee7 100644
--- a/cpp/csp/engine/Struct.cpp
+++ b/cpp/csp/engine/Struct.cpp
@@ -1,20 +1,27 @@
 #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_noneMaskOffset( 0 ),
     m_maskBit( 0 ),
+    m_noneMaskBit( 0 ),
     m_maskBitMask( 0 ),
-    m_type( type )
+    m_noneMaskBitMask( 0 ),
+    m_type( type ),
+    m_isOptional( isOptional )
 {
 }
 
@@ -33,11 +40,12 @@ 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_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_optionalFieldsSetBits( nullptr ), m_optionalFieldsNoneBits( nullptr ), m_isPartialNative( true ), 
+                                                             m_isFullyNative( true ), m_isStrict( isStrict )
 {
     if( m_fields.empty() && !m_base)
         CSP_THROW( TypeError, "Struct types must define at least 1 field" );
@@ -95,20 +103,70 @@ 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() - m_firstPartialField + 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
+    m_optionalFieldsSetBits  = new uint8_t[ m_maskSize ]();
+    m_optionalFieldsNoneBits = new uint8_t[ m_maskSize ]();
+    for( size_t i = 0; i < m_fields.size(); ++i )
+    {
+        auto & f = m_fields[ i ];
+        if( f -> isOptional() )
+        {
+            f -> setMaskOffset( maskLoc, maskBit );
+            f -> setNoneMaskOffset( maskLoc, ++maskBit ); // use adjacent bit for None bit
+            if( ++maskBit == 8 )
+            {
+                m_optionalFieldsSetBits[ maskLoc - m_maskLoc ]  = 0xAA;
+                m_optionalFieldsNoneBits[ maskLoc - m_maskLoc ] = 0x55;
+                maskBit = 0;
+                ++maskLoc;
+            }
+        }
+    }
+    // deal with last (partial) byte filled with optional fields
+    auto lastOptIndex = maskLoc - m_maskLoc;
+    switch( maskBit / 2 )
     {
-        f -> setMaskOffset( maskLoc, maskBit );
-        if( ++maskBit == 8 )
+        case 1:
+            m_optionalFieldsSetBits[ lastOptIndex ]  = 0x1;
+            m_optionalFieldsNoneBits[ lastOptIndex ] = 0x2;
+            break;
+        case 2:
+            m_optionalFieldsSetBits[ lastOptIndex ]  = 0x5;
+            m_optionalFieldsNoneBits[ lastOptIndex ] = 0xA;
+            break;
+        case 3:
+            m_optionalFieldsSetBits[ lastOptIndex ]  = 0x15;
+            m_optionalFieldsNoneBits[ lastOptIndex ] = 0x2A;
+            break;
+        default:
+            break; // default initialized to 0
+    }
+
+    for( size_t i = 0; i < m_fields.size(); ++i )
+    {
+        auto & f = m_fields[ i ];
+        if( !f -> isOptional() )
         {
-            maskBit = 0;
-            ++maskLoc;
+            f -> setMaskOffset( maskLoc, maskBit );
+            if( ++maskBit == 8 )
+            {
+                maskBit = 0;
+                ++maskLoc;
+            }
         }
     }
 
@@ -128,11 +186,22 @@ StructMeta::StructMeta( const std::string & name, const Fields & fields,
         if( !rv.second )
             CSP_THROW( ValueError, "csp Struct " << name << " attempted to add existing field " << m_fields[ idx ] -> fieldname() );
     }
+    
+    // The complete inheritance hierarchy must agree on strict/non-strict
+    if( m_base && 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" )
+        );
+    }
 }
 
 StructMeta::~StructMeta()
 {
     m_default.reset();
+    delete[] m_optionalFieldsSetBits;
+    delete[] m_optionalFieldsNoneBits;
 }
 
 Struct * StructMeta::createRaw() const
@@ -453,23 +522,62 @@ 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 );
+
+    const uint8_t * M1 = m_optionalFieldsSetBits;
+    const uint8_t * M2 = m_optionalFieldsNoneBits;
+
+    for( ; m < e; ++m, ++M1, ++M2 )
     {
-        if( *m != 0xFF )
+        if( ( *m | ( ( *m & *M1 ) << 1 ) | ( ( *m & *M2 ) >> 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 & *M1 ) << 1 ) & m_lastByteMask ) | ( ( masked & *M2 ) >> 1 ) ) != m_lastByteMask )
             return false;
     }
 
@@ -494,6 +602,20 @@ void StructMeta::destroy( Struct * s ) const
         m_base -> destroy( s );
 }
 
+[[nodiscard]] bool StructMeta::validate( const Struct * s ) const
+{   
+    if( !s -> meta() -> isStrict() )
+        return true;
+
+    for ( const StructMeta * cur = this; cur; cur = cur -> m_base.get() )
+    {
+        if ( !cur -> allFieldsSet( s ) )
+            return false;
+    }
+
+    return true;
+}
+
 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..3bd312284 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; }
@@ -30,27 +32,55 @@ class StructField
     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
+    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
+    size_t  noneMaskOffset() const        { return m_noneMaskOffset; }  //same fields as above but for the None bit, if this an optional field
+    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  )
     {
-        CSP_ASSERT( bit < 8 );
+        CSP_ASSERT( bit < BITS_PER_BYTE );
 
         m_maskOffset  = off;
         m_maskBit     = bit;
         m_maskBitMask = 1 << bit;
     }
 
+    void setNoneMaskOffset( size_t off, uint8_t bit  )
+    {
+        CSP_ASSERT( m_isOptional );
+        CSP_ASSERT( bit < BITS_PER_BYTE );
+
+        m_noneMaskOffset  = off;
+        m_noneMaskBit     = bit;
+        m_noneMaskBitMask = 1 << bit;
+    }
+
     bool isSet( const Struct * s ) const
     {
         const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_maskOffset;
         return (*m ) & m_maskBitMask;
     }
 
+    bool isNone( const Struct * s ) const
+    {
+        const uint8_t * m = reinterpret_cast<const uint8_t *>( s ) + m_noneMaskOffset;
+        return ( *m ) & m_noneMaskBitMask;
+    }
+
+    void setNone( Struct * s ) const
+    {
+        CSP_ASSERT( m_isOptional );
+
+        uint8_t * m = reinterpret_cast<uint8_t *>( s ) + m_noneMaskOffset;
+        (*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 +105,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
     }
 
     const void * valuePtr( const Struct * s ) const
@@ -99,15 +131,25 @@ class StructField
         (*m) &= ~m_maskBitMask;
     }
 
+    void clearIsNone( Struct * s ) const
+    {
+        uint8_t * m = reinterpret_cast<uint8_t *>( s ) + m_noneMaskOffset;
+        (*m) &= ~m_noneMaskBitMask;
+    }
+
 private:
     std::string  m_fieldname;
     size_t       m_offset;
     const size_t m_size;
     const size_t m_alignment;
     size_t       m_maskOffset;
+    size_t       m_noneMaskOffset;
     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 +162,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 +199,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 +222,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 +261,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 +287,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 +386,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 +464,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 +630,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 +638,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 +646,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 +675,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;
 
@@ -652,7 +701,8 @@ class StructMeta : public std::enable_shared_from_this<StructMeta>
     std::shared_ptr<StructMeta> m_base;
     StructPtr                   m_default;
     FieldMap                    m_fieldMap;
-
+              
+    
     //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;
@@ -666,8 +716,12 @@ 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_optionalFieldsSetBits; // mask (per-byte, for now) of the set bits of optional fields
+    uint8_t *                   m_optionalFieldsNoneBits; // mask (per-byte, for now) of the none bits of optional fields
+    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 +792,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 +886,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..529def95f 100644
--- a/cpp/csp/python/PyStructToDict.cpp
+++ b/cpp/csp/python/PyStructToDict.cpp
@@ -153,19 +153,25 @@ 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..53812c18d 100644
--- a/cpp/csp/python/PyStructToJson.cpp
+++ b/cpp/csp/python/PyStructToJson.cpp
@@ -180,19 +180,22 @@ 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..51621f497 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
@@ -174,6 +181,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 +252,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):
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/test_strict_structs.py b/csp/tests/test_strict_structs.py
new file mode 100644
index 000000000..a88660f88
--- /dev/null
+++ b/csp/tests/test_strict_structs.py
@@ -0,0 +1,385 @@
+import unittest
+from datetime import datetime
+from typing import Optional
+
+import csp
+
+
+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))
+
+    def test_strict_struct_fromts(self):
+        """fromts requires all non-defaulted fields to tick together"""
+
+        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
+
+        @csp.node
+        def make_ts(x: csp.ts[int]) -> csp.ts[int]:
+            if x % 2 == 0:
+                return x
+
+        @csp.graph
+        def g():
+            ts1 = make_ts(csp.const(2))
+            ts2 = make_ts(csp.const(1))
+
+            # ts1 and ts2 don't tick together
+            s_ts = MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2)
+            csp.add_graph_output("output", s_ts)
+
+        with self.assertRaisesRegex(
+            ValueError, r"Struct MyStrictStruct is not valid; required fields \[opt_array_type, req_int2\] did not tick"
+        ):
+            csp.run(g, starttime=datetime(2023, 1, 1))
+
+        @csp.graph
+        def g_ok():
+            ts1 = csp.const(2)
+            ts2 = csp.const(4)
+            ts3 = csp.const(None)
+
+            # ts1 and ts2 tick together
+            s_ts = MyStrictStruct.fromts(req_int1=ts1, req_int2=ts2, opt_array_type=ts3)
+            csp.add_graph_output("output", s_ts)
+
+        res = csp.run(g_ok, starttime=datetime(2023, 1, 1))
+        mss = res["output"][0][1]
+        self.assertEqual(mss.req_int1, 2)
+        self.assertEqual(mss.req_int2, 4)
+        self.assertIsNone(mss.opt_str)
+        self.assertEqual(mss.req_default_str, "default")
+        self.assertIsNone(mss.opt_array_type)
+
+    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_strict_struct_wiring_access_2(self):
+        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_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 )")
+
+
+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..766d5ef81 100644
--- a/docs/wiki/api-references/csp.Struct-API.md
+++ b/docs/wiki/api-references/csp.Struct-API.md
@@ -147,6 +147,42 @@ 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.
+  - 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.
+  - A non-strict struct may not inherit (directly or indirectly) from a strict base, and vice versa.
+
+### 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. **Example**
+
+   ```python
+   class MyStruct(csp.Struct, allow_unset=False):
+       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
+   ```