diff --git a/cpp/csp/python/CMakeLists.txt b/cpp/csp/python/CMakeLists.txt
index 45f265534..13f934f12 100644
--- a/cpp/csp/python/CMakeLists.txt
+++ b/cpp/csp/python/CMakeLists.txt
@@ -3,7 +3,8 @@ set(CSPTYPESIMPL_PUBLIC_HEADERS
         CspTypeFactory.h
         PyCspEnum.h
         PyCspType.h
-        PyStruct.h)
+        PyStruct.h
+        PyStructList.h)
 
 add_library(csptypesimpl
             csptypesimpl.cpp
@@ -11,7 +12,8 @@ add_library(csptypesimpl
             PyCspEnum.cpp
             PyCspType.cpp
             PyStruct.cpp
-            PyStructToJson.cpp)
+            PyStructToJson.cpp
+            PyStructList.hi)
 set_target_properties(csptypesimpl PROPERTIES PUBLIC_HEADER "${CSPTYPESIMPL_PUBLIC_HEADERS}")
 target_compile_definitions(csptypesimpl PUBLIC RAPIDJSON_HAS_STDSTRING=1)
 target_link_libraries(csptypesimpl csp_core csp_types)
@@ -39,7 +41,8 @@ set(CSPIMPL_PUBLIC_HEADERS
         PyOutputAdapterWrapper.h
         PyOutputProxy.h
         PyConstants.h
-        PyStructToJson.h)
+        PyStructToJson.h
+        PyStructList.h)
 
 add_library(cspimpl SHARED
         cspimpl.cpp
@@ -70,6 +73,7 @@ add_library(cspimpl SHARED
         PyManagedSimInputAdapter.cpp
         PyTimerAdapter.cpp
         PyConstants.cpp
+        PyStructList.hi
         ${CSPIMPL_PUBLIC_HEADERS})
 
 set_target_properties(cspimpl PROPERTIES PUBLIC_HEADER "${CSPIMPL_PUBLIC_HEADERS}")
diff --git a/cpp/csp/python/Conversions.h b/cpp/csp/python/Conversions.h
index 891bfe3f6..31d473be9 100644
--- a/cpp/csp/python/Conversions.h
+++ b/cpp/csp/python/Conversions.h
@@ -12,6 +12,7 @@
 #include <csp/python/PyCspType.h>
 #include <csp/python/PyObjectPtr.h>
 #include <csp/python/PyStruct.h>
+#include <csp/python/PyStructList.h>
 #include <datetime.h>
 #include <Python.h>
 #include <string>
@@ -762,6 +763,29 @@ inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & typ
     return list.release();
 }
 
+template<typename StorageT>
+inline PyObject * toPython( const std::vector<StorageT> & v, const CspType & type, const PyStruct * pystruct )
+{
+    assert( type.type() == CspType::Type::ARRAY );
+
+    const CspTypePtr elemType = static_cast<const CspArrayType &>( type ).elemType();
+    using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
+    size_t sz = v.size();
+
+    // TODO: Implement more efficient list allocation by pre-allocating the space and filling it using PyList_SET_ITEM.
+    // As of now, the problem is that Python is not allowing to resize the list via API, and it cannot allocate the list at the base of PyStructList, it can only allocate it somewhere in memory not under control.
+    PyObject * psl = PyStructList<StorageT>::PyType.tp_alloc( &PyStructList<StorageT>::PyType, 0 );
+    new ( psl ) PyStructList<StorageT>( const_cast<PyStruct *>( pystruct ), const_cast<std::vector<StorageT> &>( v ), *elemType );
+
+    for( size_t index = 0; index < sz; ++index )
+    {
+        PyObjectPtr element = PyObjectPtr::own( toPython<ElemT>( v[ index ], *elemType ) );
+        PyList_Append( ( PyObject * ) psl, element.get() );
+    }
+    
+    return psl;
+}
+
 template<typename StorageT>
 struct FromPython<std::vector<StorageT>>
 {
diff --git a/cpp/csp/python/InitHelper.h b/cpp/csp/python/InitHelper.h
index 3023919ec..5df1ed956 100644
--- a/cpp/csp/python/InitHelper.h
+++ b/cpp/csp/python/InitHelper.h
@@ -20,7 +20,7 @@ class __attribute__ ((visibility ("hidden"))) InitHelper
 
     bool registerCallback( InitCallback cb );
 
-    static InitCallback typeInitCallback( PyTypeObject * pyType, std::string name );
+    static InitCallback typeInitCallback( PyTypeObject * pyType, std::string name, PyTypeObject * baseType = nullptr );
     static InitCallback moduleMethodsCallback( PyMethodDef * methods );
     static InitCallback moduleMethod( const char * name, PyCFunction func, int flags, const char * doc );
 
@@ -50,9 +50,11 @@ inline InitHelper & InitHelper::instance()
     return s_instance;
 }
 
-inline InitHelper::InitCallback InitHelper::typeInitCallback( PyTypeObject * pyType, std::string name )
+inline InitHelper::InitCallback InitHelper::typeInitCallback( PyTypeObject * pyType, std::string name, PyTypeObject * baseType )
 {
-    InitCallback cb = [pyType,name]( PyObject * module ) {
+    InitCallback cb = [pyType,name,baseType]( PyObject * module ) {
+        if( baseType )
+            pyType -> tp_base = baseType;
         if( PyType_Ready( pyType ) < 0 )
             return false;
 
diff --git a/cpp/csp/python/PyStruct.cpp b/cpp/csp/python/PyStruct.cpp
index 4e5f031de..ccb821311 100644
--- a/cpp/csp/python/PyStruct.cpp
+++ b/cpp/csp/python/PyStruct.cpp
@@ -3,8 +3,8 @@
 #include <csp/python/InitHelper.h>
 #include <csp/python/PyObjectPtr.h>
 #include <csp/python/PyStruct.h>
+#include <csp/python/PyStructList.hi>
 #include <csp/python/PyStructToJson.h>
-
 #include <unordered_set>
 #include <type_traits>
 
@@ -395,8 +395,10 @@ PyTypeObject PyStructMeta::PyType = {
 
 
 //PyStruct
-PyObject * getattr_( const StructField* field, const Struct * struct_ )
+PyObject * getattr_( const StructField * field, const Struct * struct_ )
 {
+    assert( field -> type() -> type() != CspType::Type::ARRAY );
+
     PyObject *v = switchCspType( field -> type(), [ field, struct_ ]( auto tag )
     {
         using CType = typename decltype(tag)::type;
@@ -407,6 +409,21 @@ PyObject * getattr_( const StructField* field, const Struct * struct_ )
     return v;
 }
 
+PyObject * getarrayattr_( const StructField * field, const PyStruct * pystruct )
+{
+    assert( field -> type() -> type() == CspType::Type::ARRAY );
+    
+    const CspArrayType * arrayType = static_cast<const CspArrayType *>( field -> type().get() );
+    PyObject *v = ArraySubTypeSwitch::invoke( arrayType -> elemType(), [ field, pystruct ]( auto tag )
+    {
+        using StorageT  = typename CspType::Type::toCArrayStorageType<typename decltype(tag)::type>::type;
+        using ArrayT    = typename StructField::upcast<std::vector<StorageT>>::type;
+        auto * typedField = static_cast<const ArrayT *>( field );
+        return toPython( typedField -> value( pystruct -> struct_.get()  ), *field -> type(), pystruct );
+    } );
+    return v;
+}
+
 PyObject * PyStruct::getattr( PyObject * attr )
 {
     auto * field = structMeta() -> field( attr );
@@ -424,7 +441,9 @@ PyObject * PyStruct::getattr( PyObject * attr )
         return nullptr;
     }
 
-    return getattr_( field, ( const Struct *)struct_.get() );
+    if( field -> type() -> type() == CspType::Type::ARRAY )
+        return getarrayattr_( field, this );
+    return getattr_( field, ( const Struct * ) struct_.get() );
 }
 
 void PyStruct::setattr( Struct * s, PyObject * attr, PyObject * value )
@@ -997,4 +1016,24 @@ PyTypeObject PyStruct::PyType = {
 REGISTER_TYPE_INIT( &PyStructMeta::PyType, "PyStructMeta" )
 REGISTER_TYPE_INIT( &PyStruct::PyType,     "PyStruct" )
 
+// Instantiate all templates for PyStructList class
+template struct PyStructList<bool>;
+template struct PyStructList<int8_t>;
+template struct PyStructList<uint8_t>;
+template struct PyStructList<int16_t>;
+template struct PyStructList<uint16_t>;
+template struct PyStructList<int32_t>;
+template struct PyStructList<uint32_t>;
+template struct PyStructList<int64_t>;
+template struct PyStructList<uint64_t>;
+template struct PyStructList<double>;
+template struct PyStructList<DateTime>;
+template struct PyStructList<TimeDelta>;
+template struct PyStructList<Date>;
+template struct PyStructList<Time>;
+template struct PyStructList<std::string>;
+template struct PyStructList<DialectGenericType>;
+template struct PyStructList<StructPtr>;
+template struct PyStructList<CspEnum>;
+
 }
diff --git a/cpp/csp/python/PyStructList.h b/cpp/csp/python/PyStructList.h
new file mode 100644
index 000000000..b26116c06
--- /dev/null
+++ b/cpp/csp/python/PyStructList.h
@@ -0,0 +1,36 @@
+#ifndef _IN_CSP_PYTHON_PYSTRUCTLIST_H
+#define _IN_CSP_PYTHON_PYSTRUCTLIST_H
+
+#include <csp/python/InitHelper.h>
+#include <csp/python/PyStruct.h>
+#include <Python.h>
+#include <vector>
+
+namespace csp::python
+{
+
+template<typename StorageT>
+struct PyStructList : public PyObject
+{
+    using ElemT = typename CspType::Type::toCArrayElemType<StorageT>::type;
+
+    PyStructList<StorageT>( PyStruct * p, std::vector<StorageT> & v, const CspType & type ) : pystruct( p ), vector( v ), field_type( type )
+    {
+        Py_INCREF( pystruct );
+    }
+
+    PyListObject base;                // Inherit from PyListObject
+    PyStruct * pystruct;             // Pointer to PyStruct for proper reference counting
+    std::vector<StorageT> & vector;  // Reference to field value for modifying
+
+    const CspType & field_type;       // We require the type information of any non-primitive type, i.e. Struct or Enum, since they contain a meta
+    static PyTypeObject PyType;
+    static bool s_typeRegister;
+};
+
+template<typename StorageT> bool PyStructList<StorageT>::s_typeRegister = InitHelper::instance().registerCallback( 
+    InitHelper::typeInitCallback( &PyStructList<StorageT>::PyType, "", &PyList_Type ) );
+
+}
+
+#endif
\ No newline at end of file
diff --git a/cpp/csp/python/PyStructList.hi b/cpp/csp/python/PyStructList.hi
new file mode 100644
index 000000000..bf829ea6c
--- /dev/null
+++ b/cpp/csp/python/PyStructList.hi
@@ -0,0 +1,446 @@
+#ifndef _IN_CSP_PYTHON_PYSTRUCTLIST_HI
+#define _IN_CSP_PYTHON_PYSTRUCTLIST_HI
+
+#include <csp/engine/PartialSwitchCspType.h>
+#include <csp/python/Conversions.h>
+#include <csp/python/InitHelper.h>
+#include <csp/python/PyCspType.h>
+#include <csp/python/PyStructList.h>
+#include <algorithm>
+
+namespace csp::python
+{
+
+template<typename StorageT> inline StorageT convertValue( PyStructList<StorageT> * self, PyObject * value )
+{
+    return static_cast<StorageT>( fromPython<typename PyStructList<StorageT>::ElemT>( value, self -> field_type ) );
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Append( PyStructList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O", &value ) )
+        return NULL;
+    
+    if( PyList_Append( ( PyObject * ) self, value ) < 0 )
+        return NULL;
+
+    // Append the value to the vector stored in the struct field
+    self -> vector.emplace_back( convertValue( self, value ) );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Insert( PyStructList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    Py_ssize_t index;
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "nO", &index, &value ) )
+        return NULL;
+
+    if( PyList_Insert( ( PyObject * ) self, index, value ) < 0 )
+        return NULL;
+
+    // Insert the value in the vector stored in the struct field
+    // Deal with Python list indices that can be negative or point outside of the array
+    // Python allows indices for insert to be past the array boundaries, in which case the element is added to the beginning or end of the array
+    int sz = self -> vector.size();
+    if( index < 0 )
+        index += sz;
+    // Insert the value in the vector stored in the struct field
+    auto it = self -> vector.begin() + std::max( 0, std::min( sz, ( int ) index ) );
+    self -> vector.insert( it, convertValue( self, value ) );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Pop( PyStructList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    Py_ssize_t index = -1;
+    if( !PyArg_ParseTuple( args, "|n", &index) )
+        return NULL;
+
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "pop" ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunction( func.ptr(), "On", self, index ) );   
+    if( !result.ptr() )
+        return NULL;
+
+    // Deal with Python list indices that can be negative
+    int sz = self -> vector.size();
+    if( index < 0 )
+        index += sz;
+    // Pop the value from the vector stored in the struct field
+    // Python doesn't allow indices for pop to be past the array boundaries, so it is safe
+    assert( index >= 0 && index < sz );
+    auto it = self -> vector.begin() + ( int ) index;
+    self -> vector.erase( it );
+
+    return result.release();
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Reverse( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+
+    if( PyList_Reverse( ( PyObject * ) self ) < 0 )
+        return NULL;
+
+    // Reverse the vector stored in the struct field
+    std::reverse( self -> vector.begin(), self -> vector.end() );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Sort( PyStructList<StorageT> * self, PyObject * args, PyObject * kwargs )
+{
+    CSP_BEGIN_METHOD;
+
+    if( PyObject_Length( args ) > 0 )
+    {
+        PyErr_SetString( PyExc_TypeError, "sort() takes no positional arguments" );
+        return NULL;
+    }
+
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "sort" ) );
+    PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 1, ( PyObject * ) self ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), kwargs ) );   
+    if( !result.ptr() )
+        return NULL;
+
+    // Copy sorted list into the vector stored in the struct field
+    size_t sz = self -> vector.size();
+
+    for( size_t index = 0; index < sz; ++index )
+    {
+        PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
+        self -> vector[ index ] = convertValue( self, value );
+    }
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Extend( PyStructList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+
+    PyObject * iterable;
+    if( !PyArg_ParseTuple( args, "O", &iterable ) )
+        return NULL;
+
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "extend" ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, iterable, NULL ) );
+    if( !result.ptr() )
+        return NULL;
+
+    // Copy new elements of the extended list into the vector stored in the struct field
+    size_t new_sz = ( size_t ) PyObject_Length( ( PyObject * ) self );
+    size_t old_sz = self -> vector.size();
+
+    // Check that all elements of a modified vector are of correct type
+    std::vector<StorageT> v = self -> vector;
+    v.resize( new_sz );
+    for( size_t index = old_sz; index < new_sz; ++index )
+    {
+        PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
+        v[ index ] = convertValue( self, value );
+    }
+
+    self -> vector.swap( v );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Remove( PyStructList<StorageT> * self, PyObject * args )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyObject * value;
+    if( !PyArg_ParseTuple( args, "O", &value) )
+        return NULL;
+
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "remove" ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, value, NULL ) );   
+    if( !result.ptr() )
+        return NULL;
+
+    // Remove the value from the vector stored in the struct field
+    // The find always succeeds, as otherwise the above Python method call would have failed
+    auto it = std::find( self -> vector.begin(), self -> vector.end(), convertValue( self, value ) );
+    assert( it != self -> vector.end() );
+    self -> vector.erase( it );
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static PyObject *
+PyStructList_Clear( PyStructList<StorageT> * self, PyObject * Py_UNUSED( ignored ) )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "clear" ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunctionObjArgs( func.ptr(), self, NULL ) );   
+    if( !result.ptr() )
+        return NULL;
+
+    // Clear the vector stored in the struct field
+    self -> vector.clear();
+
+    CSP_RETURN_NONE;
+}
+
+template<typename StorageT>
+static int
+py_struct_list_ass_item( PyObject * sself, Py_ssize_t index, PyObject * value )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
+
+    // Deal with Python list indices that can be negative
+    int sz = self -> vector.size();
+    if( index < 0 )
+        index += sz;
+    
+    PyObjectPtr result;
+    // The value is not NULL -> assign it to vector[ index ]
+    if( value != NULL )
+    {
+        Py_INCREF( value );
+        if( PyList_SetItem( ( PyObject * ) self, index, value ) < 0 )
+            return -1;
+    }
+    // The value is NULL -> erase vector[ index ]
+    else
+    {
+        PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__delitem__" ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, ( PyObject * ) self, PyLong_FromSsize_t( index ) ) );
+        result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
+        if( !result.ptr() )
+            return -1;
+    }
+
+    // Set the value in the vector stored in the struct field
+    // Python doesn't allow indices for set_item to be past the array boundaries, so it is safe
+    // The value is not NULL -> assign it to vector[ index ]
+    assert( index >= 0 && index < sz );
+    if( value != NULL )
+    {
+        self -> vector[ index ] = convertValue( self, value );
+    }
+    // The value is NULL -> erase vector[ index ]
+    else
+    {
+        auto it = self -> vector.begin() + ( int ) index;
+        self -> vector.erase( it );
+    }
+    
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static int
+py_struct_list_ass_subscript( PyObject * sself, PyObject * item, PyObject * value )
+{
+    CSP_BEGIN_METHOD;
+    
+    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
+    // The item is the individual index
+    if( !PySlice_Check( item ) )
+    {
+        Py_ssize_t index = PyNumber_AsSsize_t( item, PyExc_IndexError );
+        if( index == -1 && PyErr_Occurred() )
+            return -1;
+
+        return py_struct_list_ass_item<StorageT>( ( PyObject * ) self, index, value );
+    }
+
+    // The item is a slice
+    PyObjectPtr result;
+    // The value is not NULL -> assign it to vector[ slice ]
+    if( value != NULL )
+    {
+        PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__setitem__" ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 3, ( PyObject * ) self, item, value ) );
+        result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
+    }
+    // The value is NULL -> erase vector[ slice ]
+    else
+    {
+        PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__delitem__" ) );
+        PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 2, ( PyObject * ) self, item ) );
+        result = PyObjectPtr::own( PyObject_Call( func.ptr(), arguments.ptr(), NULL ) );
+    }
+    if( !result.ptr() )
+        return -1;
+
+    // Copy modified list into the vector stored in the struct field
+    size_t sz = ( size_t ) PyObject_Length( ( PyObject * ) self );
+
+    // Check that all elements of a modified vector are of correct type
+    std::vector<StorageT> v( sz ); 
+    for( size_t index = 0; index < sz; ++index )
+    {
+        PyObject * value = PyList_GET_ITEM( ( PyObject * ) self, index );
+        v[ index ] = convertValue( self, value );
+    }
+
+    self -> vector.swap( v );
+
+    CSP_RETURN_INT;
+}
+
+template<typename StorageT>
+static PyObject *
+py_struct_list_inplace_concat( PyObject * sself, PyObject * other )
+{    
+    CSP_BEGIN_METHOD;
+    
+    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
+    PyObjectPtr arguments = PyObjectPtr::own( PyTuple_Pack( 1, other ) );
+    PyObjectPtr result = PyObjectPtr::own( PyStructList_Extend<StorageT>( self, arguments.ptr() ) );
+    if( !result.ptr() )
+        return NULL;
+    Py_INCREF( self );
+    return self;
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyObject *
+py_struct_list_inplace_repeat( PyObject * sself, Py_ssize_t n )
+{    
+    CSP_BEGIN_METHOD;
+    
+    PyStructList<StorageT> * self = ( PyStructList<StorageT> * ) sself;
+    
+    PyObjectPtr func = PyObjectPtr::own( PyObject_GetAttrString( ( PyObject * ) &PyList_Type, "__imul__" ) );
+    PyObjectPtr result = PyObjectPtr::own( PyObject_CallFunction( func.ptr(), "On", self, n ) );   
+    if( !result.ptr() )
+        return NULL;
+
+    // Emulate repeating on the vector stored in the struct field
+    if( n <= 0 )
+        self -> vector.clear();
+    else
+    {
+        int sz = self -> vector.size();
+        self -> vector.resize( sz * n );
+        for( int i = 1; i < n; ++i )
+            for( int j = 0; j < sz; ++j )
+                self -> vector[ i * sz + j ] = self -> vector[ j ];
+    }
+    
+    Py_INCREF( self );
+    return self;
+
+    CSP_RETURN_NULL;
+}
+
+template<typename StorageT>
+static PyMethodDef PyStructList_methods[] = {
+    {"append", ( PyCFunction ) PyStructList_Append<StorageT>, METH_VARARGS, NULL},
+    {"insert", ( PyCFunction ) PyStructList_Insert<StorageT>, METH_VARARGS, NULL},
+    {"pop", ( PyCFunction ) PyStructList_Pop<StorageT>, METH_VARARGS, NULL},
+    {"reverse", ( PyCFunction ) PyStructList_Reverse<StorageT>, METH_NOARGS, NULL},
+    {"sort", ( PyCFunction ) PyStructList_Sort<StorageT>, METH_VARARGS | METH_KEYWORDS, NULL},
+    {"extend", ( PyCFunction ) PyStructList_Extend<StorageT>, METH_VARARGS, NULL},
+    {"remove", ( PyCFunction ) PyStructList_Remove<StorageT>, METH_VARARGS, NULL},
+    {"clear", ( PyCFunction ) PyStructList_Clear<StorageT>, METH_NOARGS, NULL},
+    {NULL},
+};
+
+template<typename StorageT>
+static PySequenceMethods py_struct_list_as_sequence = {
+    PyList_Type.tp_as_sequence -> sq_length,                                /* sq_length */
+    PyList_Type.tp_as_sequence -> sq_concat,                                /* sq_concat */
+    PyList_Type.tp_as_sequence -> sq_repeat,                                /* sq_repeat */
+    PyList_Type.tp_as_sequence -> sq_item,                                  /* sq_item */
+    0,                                          /* sq_slice */
+    py_struct_list_ass_item<StorageT>,                              /* sq_ass_item */
+    0,                                          /* sq_ass_slice */
+    PyList_Type.tp_as_sequence -> sq_contains,                              /* sq_contains */
+    py_struct_list_inplace_concat<StorageT>,                        /* sq_inplace_concat */
+    py_struct_list_inplace_repeat<StorageT>                        /* sq_inplace_repeat */
+};
+
+template<typename StorageT>
+static PyMappingMethods py_struct_list_as_mapping = {
+    PyList_Type.tp_as_mapping -> mp_length,
+    PyList_Type.tp_as_mapping -> mp_subscript,
+    py_struct_list_ass_subscript<StorageT>
+};
+
+template<typename StorageT>
+static int
+PyStructList_tp_clear( PyStructList<StorageT> * self )
+{
+    Py_CLEAR( self -> pystruct );
+    PyObject * pself = ( PyObject * ) self;
+    Py_TYPE( pself )-> tp_base -> tp_clear( pself );
+    return 0;
+}
+
+template<typename StorageT>
+static int
+PyStructList_traverse( PyStructList<StorageT> * self, visitproc visit, void * arg )
+{
+    Py_VISIT( self -> pystruct );
+    PyObject * pself = ( PyObject * ) self;
+    Py_TYPE( pself ) -> tp_base -> tp_traverse( pself, visit, arg );
+    return 0;
+}
+
+template<typename StorageT>
+static void
+PyStructList_dealloc( PyStructList<StorageT> * self )
+{    
+    PyObject_GC_UnTrack( self );
+    Py_CLEAR( self -> pystruct );
+    PyObject * pself = ( PyObject * ) self;
+    Py_TYPE( pself ) -> tp_base -> tp_dealloc( pself );
+}
+
+template<typename StorageT> PyTypeObject PyStructList<StorageT>::PyType = {
+    PyVarObject_HEAD_INIT( NULL, 0 )
+    .tp_name = "_cspimpl.PyStructList",
+    .tp_basicsize = sizeof( PyStructList<StorageT> ),
+    .tp_itemsize = 0,
+    .tp_dealloc = ( destructor ) PyStructList_dealloc<StorageT>,
+    .tp_as_sequence = &py_struct_list_as_sequence<StorageT>,
+    .tp_as_mapping = &py_struct_list_as_mapping<StorageT>,
+    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_LIST_SUBCLASS,
+    .tp_traverse = ( traverseproc ) PyStructList_traverse<StorageT>,
+    .tp_clear = ( inquiry ) PyStructList_tp_clear<StorageT>,
+    .tp_methods = PyStructList_methods<StorageT>,
+    .tp_alloc = PyType_GenericAlloc,
+    .tp_new   = PyType_GenericNew,
+    .tp_free  = PyObject_GC_Del,
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/csp/impl/struct.py b/csp/impl/struct.py
index 89eaa254b..bf2206aa5 100644
--- a/csp/impl/struct.py
+++ b/csp/impl/struct.py
@@ -108,7 +108,9 @@ def _obj_to_python(cls, obj):
             )
         elif isinstance(obj, dict):
             return {k: cls._obj_to_python(v) for k, v in obj.items()}
-        elif isinstance(obj, (list, tuple, set)):
+        elif isinstance(obj, list):
+            return list(cls._obj_to_python(v) for v in obj)
+        elif isinstance(obj, (tuple, set)):
             return type(obj)(cls._obj_to_python(v) for v in obj)
         elif isinstance(obj, csp.Enum):
             return obj.name  # handled in _obj_from_python
diff --git a/csp/tests/impl/test_struct.py b/csp/tests/impl/test_struct.py
index 0f0c97e9b..02caacf89 100644
--- a/csp/tests/impl/test_struct.py
+++ b/csp/tests/impl/test_struct.py
@@ -141,6 +141,53 @@ class AllTypes(csp.Struct):
     o: object = {"k": "v"}
 
 
+class SimpleStruct(csp.Struct):
+    a: int
+
+
+class AnotherSimpleStruct(csp.Struct):
+    b: str
+
+
+class SimpleEnum(csp.Enum):
+    A = 1
+    B = 2
+    C = 3
+
+
+class AnotherSimpleEnum(csp.Enum):
+    D = 5
+
+
+class SimpleClass:
+    x: int
+
+    def __init__(self, x: int):
+        self.x = x
+
+
+# Common set of values for PyStructList tests
+# For each type:
+# items[:-2] are normal values of the given type that should be handled,
+# items[-2] is a normal value for non-generic and non-str types and None for generic and str types (the purpose is to test the raise of TypeError if a single object instead of a sequence is passed),
+# items[-1] is a value of a different type that is not convertible to the give type for non-generic types and None for generic types (the purpose is to test the raise of TypeError if an object of the wrong type is passed).
+pystruct_list_test_values = { 
+    int : [4, 2, 3, 5, 6, 7, 8, 's'],
+    bool: [True, True, True, False, True, False, True, 2],
+    float: [1.4, 3.2, 2.7, 1.0, -4.5, -6.0, -2.0, 's'],
+    datetime: [datetime(2022, 12, 6, 1, 2, 3), datetime(2022, 12, 7, 2, 2, 3), datetime(2022, 12, 8, 3, 2, 3), datetime(2022, 12, 9, 4, 2, 3), datetime(2022, 12, 10, 5, 2, 3), datetime(2022, 12, 11, 6, 2, 3), datetime(2022, 12, 13, 7, 2, 3), timedelta(seconds=.123)],
+    timedelta: [timedelta(seconds=.123), timedelta(seconds=12), timedelta(seconds=1), timedelta(seconds=.5), timedelta(seconds=123), timedelta(seconds=70), timedelta(seconds=700), datetime(2022, 12, 8, 3, 2, 3)],
+    date: [date(2022, 12, 6), date(2022, 12, 7), date(2022, 12, 8), date(2022, 12, 9), date(2022, 12, 10), date(2022, 12, 11), date(2022, 12, 13), timedelta(seconds=.123)],
+    time: [time(1, 2, 3), time(2, 2, 3), time(3, 2, 3), time(4, 2, 3), time(5, 2, 3), time(6, 2, 3), time(7, 2, 3), timedelta(seconds=.123)],
+    str : ['s', 'pqr', 'masd', 'wes', 'as', 'm', None, 5],
+    csp.Struct: [SimpleStruct(a = 1), AnotherSimpleStruct(b = 'sd'), SimpleStruct(a = 3), AnotherSimpleStruct(b = 'sdf'), SimpleStruct(a = -4), SimpleStruct(a = 5), SimpleStruct(a = 7), 4],  # untyped struct list
+    SimpleStruct: [SimpleStruct(a = 1), SimpleStruct(a = 3), SimpleStruct(a = -1), SimpleStruct(a = -4), SimpleStruct(a = 5), SimpleStruct(a = 100), SimpleStruct(a = 1200), AnotherSimpleStruct(b = 'sd')],
+    SimpleEnum: [SimpleEnum.A, SimpleEnum.C, SimpleEnum.B, SimpleEnum.B, SimpleEnum.B, SimpleEnum.C, SimpleEnum.C, AnotherSimpleEnum.D],
+    list: [[1], [1, 2, 1], [6], [8, 3, 5], [3], [11, 8], None, None],  # generic type list
+    SimpleClass: [SimpleClass(x = 1), SimpleClass(x = 5), SimpleClass(x = 9), SimpleClass(x = -1), SimpleClass(x = 2), SimpleClass(x = 3), None, None],  # generic type user-defined
+}
+
+
 class TestCspStruct(unittest.TestCase):
     def test_basic(self):
         s = StructNoDefaults(i=123, s="456", bt=b"ab\001\000c", a4=[b"ab\001\000c"])
@@ -1691,6 +1738,362 @@ def custom_jsonifier(obj):
         with self.assertRaises(TypeError):
             json.loads(test_struct.to_json(custom_jsonifier))
 
+    def test_list_field_append(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+            
+            s = A( a = [] )
+            s.a.append(v[0])
+            
+            self.assertEqual(s.a, [v[0]])
+
+            s.a.append(v[1])
+            s.a.append(v[2])
+
+            self.assertEqual(s.a, [v[0], v[1], v[2]])
+
+            # Check if not generic type
+            if v[-1] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a.append(v[-1])
+
+    def test_list_field_insert(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+            
+            s = A( a = [] )
+            s.a.insert(0, v[0])
+            
+            self.assertEqual(s.a, [v[0]])
+
+            s.a.insert(1, v[1])
+            s.a.insert(1, v[2])
+
+            self.assertEqual(s.a, [v[0], v[2], v[1]])
+
+            s.a.insert(-1, v[3])
+
+            self.assertEqual(s.a, [v[0], v[2], v[3], v[1]])
+
+            s.a.insert(100, v[4])
+            s.a.insert(-100, v[5])
+
+            self.assertEqual(s.a, [v[5], v[0], v[2], v[3], v[1], v[4]])
+
+            # Check if not generic type
+            if v[-1] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a.insert(-1, v[-1])
+
+    def test_list_field_pop(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A(a = [v[0], v[1], v[2], v[3], v[4]])
+            b = s.a.pop()
+            
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+            self.assertEqual(b, v[4])
+
+            b = s.a.pop(-1)
+            
+            self.assertEqual(s.a, [v[0], v[1], v[2]])
+            self.assertEqual(b, v[3])
+
+            b = s.a.pop(1)
+
+            self.assertEqual(s.a, [v[0], v[2]])
+            self.assertEqual(b, v[1])
+            
+            with self.assertRaises(IndexError) as e:
+                s.a.pop()
+                s.a.pop()
+                s.a.pop()
+            
+            s = A(a = [v[0], v[1], v[2], v[3], v[4]])
+
+            b = s.a.pop(-3)
+
+            self.assertEqual(s.a, [v[0], v[1], v[3], v[4]])
+            self.assertEqual(b, v[2])
+
+            with self.assertRaises(IndexError) as e:
+                s.a.pop(-5)
+
+            with self.assertRaises(IndexError) as e:
+                s.a.pop(4)
+
+    def test_list_field_set_item(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+                    
+            s = A( a = [v[0], v[1], v[2]] )
+            s.a.__setitem__(0, v[3])
+            
+            self.assertEqual(s.a, [v[3], v[1], v[2]])
+
+            s.a[1] = v[4]
+
+            self.assertEqual(s.a, [v[3], v[4], v[2]])
+
+            s.a[-1] = v[5]
+
+            self.assertEqual(s.a, [v[3], v[4], v[5]])
+
+            with self.assertRaises(IndexError) as e:
+                s.a[100] = v[0]
+
+            with self.assertRaises(IndexError) as e:
+                s.a[-100] = v[0]
+            
+            s.a[5:6] = [v[0], v[1], v[2]]
+
+            self.assertEqual(s.a, [v[3], v[4], v[5], v[0], v[1], v[2]])
+
+            s.a[2:4] = [v[2]]
+
+            self.assertEqual(s.a, [v[3], v[4], v[2], v[1], v[2]])
+
+            s.a[3:5] = [v[0], v[5]]
+
+            self.assertEqual(s.a, [v[3], v[4], v[2], v[0], v[5]])
+
+            s.a[1:10:2] = [v[1], v[2]]
+
+            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+
+            # Check if not str or generic type (as str is a sequence of str) 
+            if v[-2] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a[1:4] = v[-2]
+
+            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+
+            # Check if not generic type
+            if v[-1] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a[1:4] = [v[-1]]
+
+            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+
+            with self.assertRaises(ValueError) as e:
+                s.a[1:10:2] = [v[0]]
+
+            self.assertEqual(s.a, [v[3], v[1], v[2], v[2], v[5]])
+
+    def test_list_field_reverse(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[2], v[3]] )
+            s.a.reverse()
+            
+            self.assertEqual(s.a, [v[3], v[2], v[1], v[0]])
+    
+    def test_list_field_sort(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        # Not using pystruct_list_test_values, as sort() tests are of different semantics (order and sorting key existance matters).
+        values = { 
+            int : [1, 5, 2, 2, -1, -5, 's'],
+            float: [1.4, 5.2, 2.7, 2.7, -1.4, -5.2, 's'],
+            datetime: [datetime(2022, 12, 6, 1, 2, 3), datetime(2022, 12, 8, 3, 2, 3), datetime(2022, 12, 7, 2, 2, 3), datetime(2022, 12, 7, 2, 2, 3), datetime(2022, 12, 5, 2, 2, 3), datetime(2022, 12, 3, 2, 2, 3), None],
+            timedelta: [timedelta(seconds=1), timedelta(seconds=123), timedelta(seconds=12), timedelta(seconds=12), timedelta(seconds=.1), timedelta(seconds=.01), None],
+            date: [date(2022, 12, 6), date(2022, 12, 8), date(2022, 12, 7), date(2022, 12, 7), date(2022, 12, 5), date(2022, 12, 3), None],
+            time: [time(5, 2, 3), time(7, 2, 3), time(6, 2, 3), time(6, 2, 3), time(4, 2, 3), time(3, 2, 3), None],
+            str : ['s', 'xyz', 'w', 'w', 'bds', 'a', None],
+        }
+
+        for typ, v in values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[2], v[3], v[4], v[5]] )
+            
+            s.a.sort()
+            
+            self.assertEqual(s.a, [v[5], v[4], v[0], v[2], v[3], v[1]])
+
+            s.a.sort(reverse=True)
+            
+            self.assertEqual(s.a, [v[1], v[2], v[3], v[0], v[4], v[5]])
+
+            with self.assertRaises(TypeError) as e:
+                s.a.sort(1)
+
+            with self.assertRaises(TypeError) as e:
+                s.a.sort(key=abs, a=3)
+
+            # Check if sorting key abs() is defined
+            if v[6] is not None:
+                s.a.sort(key=abs)
+
+                self.assertEqual(s.a, [v[0], v[4], v[2], v[3], v[1], v[5]])
+    
+    def test_list_field_extend(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[2]] )
+            s.a.extend([v[3]])
+            
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+
+            s.a.extend([])
+            s.a.extend((v[4], v[5]))
+
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+
+            # Check if not str or generic type (as str is a sequence of str) 
+            if v[-2] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a.extend(v[-2])
+            
+            # Check if not generic type 
+            if v[-1] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a.extend([v[-1]])
+    
+    def test_list_field_remove(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[0], v[2]] )
+            s.a.remove(v[0])
+            
+            self.assertEqual(s.a, [v[1], v[0], v[2]])
+
+            s.a.remove(v[2])
+
+            self.assertEqual(s.a, [v[1], v[0]])
+
+            with self.assertRaises(ValueError) as e:
+                s.a.remove(v[3])
+
+    def test_list_field_clear(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[2], v[3]] )
+            s.a.clear()
+            
+            self.assertEqual(s.a, [])
+    
+    def test_list_field_del(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1], v[2], v[3]] )
+            del s.a[0]
+            
+            self.assertEqual(s.a, [v[1], v[2], v[3]])
+
+            del s.a[1]
+
+            self.assertEqual(s.a, [v[1], v[3]])
+
+            s = A( a = [v[0], v[1], v[2], v[3]] )
+            del s.a[1:3]
+
+            self.assertEqual(s.a, [v[0], v[3]])
+
+            del s.a[5:100]
+
+            self.assertEqual(s.a, [v[0], v[3]])
+
+            with self.assertRaises(IndexError) as e:
+                del s.a[5]
+    
+    def test_list_field_inplace_concat(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1]] )
+            s.a.__iadd__([v[2], v[3]])
+            
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3]])
+
+            s.a += (v[4], v[5])
+
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+
+            s.a += []
+
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+
+            with self.assertRaises(TypeError) as e:
+                s.a += v[-1]
+
+             # Check if not generic type
+            if v[-1] is not None:
+                with self.assertRaises(TypeError) as e:
+                    s.a += [v[-1]]
+            
+            self.assertEqual(s.a, [v[0], v[1], v[2], v[3], v[4], v[5]])
+    
+    def test_list_field_inplace_repeat(self):
+        ''' Was a BUG when the struct with list field was not recognizing changes made to this field in python'''
+        for typ, v in pystruct_list_test_values.items():
+            class A(csp.Struct):
+                a: [typ]
+        
+            s = A( a = [v[0], v[1]] )
+            s.a.__imul__(1)
+            
+            self.assertEqual(s.a, [v[0], v[1]])
+
+            s.a *= 2
+
+            self.assertEqual(s.a, [v[0], v[1], v[0], v[1]])
+
+            with self.assertRaises(TypeError) as e:
+                s.a *= [3]
+
+            with self.assertRaises(TypeError) as e:
+                s.a *= 's'
+            
+            s.a *= 0
+            
+            self.assertEqual(s.a, [])
+
+            s.a += [v[2], v[3]]
+
+            self.assertEqual(s.a, [v[2], v[3]])
+
+            s.a *= -1
+            
+            self.assertEqual(s.a, [])
+    
+    def test_list_field_lifetime(self):
+        '''Ensure that the lifetime of PyStructList field exceeds the lifetime of struct holding it'''
+        class A(csp.Struct):
+            a: [int]
+    
+        s = A( a = [1, 2, 3] )
+        l = s.a
+        del s
+        
+        self.assertEqual(l, [1, 2, 3])
+
 
 if __name__ == "__main__":
     unittest.main()