diff --git a/res/shaders/lib/Scene.slang b/res/shaders/lib/Scene.slang
index 0e37c04..3567f00 100644
--- a/res/shaders/lib/Scene.slang
+++ b/res/shaders/lib/Scene.slang
@@ -39,7 +39,7 @@ struct Scene
 	StructuredBuffer<MeshData> meshData;
 	StructuredBuffer<MeshletDescription> meshletInfos;
 	StructuredBuffer<uint8_t> primitiveIndices;
-	StructuredBuffer<uint16_t> vertexIndices;
+	StructuredBuffer<uint32_t> vertexIndices;
 };
 
 ParameterBlock<Scene> pScene;
diff --git a/src/Editor/Asset/MeshLoader.cpp b/src/Editor/Asset/MeshLoader.cpp
index 2a00cb6..c871ec8 100644
--- a/src/Editor/Asset/MeshLoader.cpp
+++ b/src/Editor/Asset/MeshLoader.cpp
@@ -258,12 +258,9 @@ void MeshLoader::loadGlobalMeshes(const aiScene* scene, const Array<PMaterialIns
         vertexData->loadBiTangents(id, biTangents);
         vertexData->loadColors(id, colors);
 
-        Array<uint16> indices(mesh->mNumFaces * 3);
+        Array<uint32> indices(mesh->mNumFaces * 3);
         for (size_t faceIndex = 0; faceIndex < mesh->mNumFaces; ++faceIndex)
         {
-            assert(mesh->mFaces[faceIndex].mIndices[0] < std::numeric_limits<uint16>::max());
-            assert(mesh->mFaces[faceIndex].mIndices[1] < std::numeric_limits<uint16>::max());
-            assert(mesh->mFaces[faceIndex].mIndices[2] < std::numeric_limits<uint16>::max());
             indices[faceIndex * 3 + 0] = mesh->mFaces[faceIndex].mIndices[0];
             indices[faceIndex * 3 + 1] = mesh->mFaces[faceIndex].mIndices[1];
             indices[faceIndex * 3 + 2] = mesh->mFaces[faceIndex].mIndices[2];
diff --git a/src/Engine/Component/ShapeBase.cpp b/src/Engine/Component/ShapeBase.cpp
index 8ccbe46..229eefd 100644
--- a/src/Engine/Component/ShapeBase.cpp
+++ b/src/Engine/Component/ShapeBase.cpp
@@ -127,7 +127,7 @@ void computeFaceIntegrals(Face& f, ComputationState& state)
         + w * (2 * (n[state.A] * state.Paa + n[state.B] * state.Pab) + w * state.Pa));
 }
 
-void computeVolumeIntegrals(const Array<Vector> vertices, const Array<uint16>& indices, ComputationState& state)
+void computeVolumeIntegrals(const Array<Vector> vertices, const Array<uint32>& indices, ComputationState& state)
 {
     std::memset(&state, 0, sizeof(ComputationState));
     for (size_t i = 0; i < indices.size(); i+=3)
@@ -172,7 +172,7 @@ void computeVolumeIntegrals(const Array<Vector> vertices, const Array<uint16>& i
     state.TP /= 2.0f;
 }
 
-void computePhysicsParamsForMesh(Array<Vector>& vertices, const Array<uint16>& indices, Matrix3& bodyInertia, Vector& centerOfMass, float& mass)
+void computePhysicsParamsForMesh(Array<Vector>& vertices, const Array<uint32>& indices, Matrix3& bodyInertia, Vector& centerOfMass, float& mass)
 {
     ComputationState state;
     computeVolumeIntegrals(vertices, indices, state);
@@ -200,7 +200,7 @@ ShapeBase::ShapeBase()
     
 }
 
-ShapeBase::ShapeBase(Array<Vector> vertices, Array<uint16> indices)
+ShapeBase::ShapeBase(Array<Vector> vertices, Array<uint32> indices)
     : vertices(vertices)
     , indices(indices)
 {
@@ -217,7 +217,7 @@ ShapeBase ShapeBase::transform(const Component::Transform& transform) const
     return result;
 }
 
-void ShapeBase::addCollider(Array<Vector> verts, Array<uint16> inds, Matrix4 matrix)
+void ShapeBase::addCollider(Array<Vector> verts, Array<uint32> inds, Matrix4 matrix)
 {
     size_t indOffset = vertices.size();
     for(auto vert : verts)
diff --git a/src/Engine/Component/ShapeBase.h b/src/Engine/Component/ShapeBase.h
index 5f3b748..a036c2a 100644
--- a/src/Engine/Component/ShapeBase.h
+++ b/src/Engine/Component/ShapeBase.h
@@ -10,15 +10,15 @@ namespace Component
 struct ShapeBase
 {
     ShapeBase();
-    ShapeBase(Array<Vector> vertices, Array<uint16> indices);
+    ShapeBase(Array<Vector> vertices, Array<uint32> indices);
     ShapeBase transform(const Component::Transform& transform) const;
-    void addCollider(Array<Vector> vertices, Array<uint16> indices, Matrix4 matrix);
+    void addCollider(Array<Vector> vertices, Array<uint32> indices, Matrix4 matrix);
     void visualize() const;
     Vector centerOfMass;
     float mass;
     Matrix3 bodyInertia;
     Array<Vector> vertices;
-    Array<uint16> indices;
+    Array<uint32> indices;
 };
 } // namespace Component
 } // namespace Seele
diff --git a/src/Engine/Graphics/Mesh.h b/src/Engine/Graphics/Mesh.h
index d49a09c..90a4c03 100644
--- a/src/Engine/Graphics/Mesh.h
+++ b/src/Engine/Graphics/Mesh.h
@@ -15,7 +15,7 @@ public:
     MeshId id;
     uint64 vertexCount;
     PMaterialInstanceAsset referencedMaterial;
-    Array<uint16> indices;
+    Array<uint32> indices;
     Array<Meshlet> meshlets;
     void save(ArchiveBuffer& buffer) const;
     void load(ArchiveBuffer& buffer);
diff --git a/src/Engine/Graphics/Meshlet.cpp b/src/Engine/Graphics/Meshlet.cpp
index 585e838..aad824a 100644
--- a/src/Engine/Graphics/Meshlet.cpp
+++ b/src/Engine/Graphics/Meshlet.cpp
@@ -61,20 +61,26 @@ void addTriangle(Array<Meshlet>& meshlets, Meshlet& current, Triangle tri)
     }
 }
 
-void Meshlet::build(const Array<Vector>& positions, const Array<uint16>& indices, Array<Meshlet>& meshlets)
+void Meshlet::build(const Array<Vector>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets)
 {
     Meshlet current = {
         .numVertices = 0,
         .numPrimitives = 0,
     };
-    for (size_t i = 0; i < indices.size() / 3; ++i)
+    Array<Triangle> triangles(indices.size() / 3);
+    for (size_t i = 0; i < triangles.size(); ++i)
     {
-        addTriangle(meshlets, current, Triangle{
+        triangles.add(Triangle{
             .indices = {
                 indices[i * 3 + 0],
                 indices[i * 3 + 1],
                 indices[i * 3 + 2],
             },
             });
+
+    }
+    if (current.numVertices > 0)
+    {
+        completeMeshlet(meshlets, current);
     }
 }
diff --git a/src/Engine/Graphics/Meshlet.h b/src/Engine/Graphics/Meshlet.h
index 3acf913..88afea2 100644
--- a/src/Engine/Graphics/Meshlet.h
+++ b/src/Engine/Graphics/Meshlet.h
@@ -7,10 +7,10 @@ namespace Seele
 struct Meshlet
 {
     AABB boundingBox;
-    uint16 uniqueVertices[Gfx::numVerticesPerMeshlet]; // unique vertiex indices in the vertex data
+    uint32 uniqueVertices[Gfx::numVerticesPerMeshlet]; // unique vertiex indices in the vertex data
     uint8 primitiveLayout[Gfx::numPrimitivesPerMeshlet * 3]; // indices into the uniqueVertices array, only uint8 needed
     uint32 numVertices;
     uint32 numPrimitives;
-    static void build(const Array<Vector>& positions, const Array<uint16>& indices, Array<Meshlet>& meshlets);
+    static void build(const Array<Vector>& positions, const Array<uint32>& indices, Array<Meshlet>& meshlets);
 };
 } // namespace Seele
\ No newline at end of file
diff --git a/src/Engine/Graphics/VertexData.cpp b/src/Engine/Graphics/VertexData.cpp
index 87ac929..bf0df23 100644
--- a/src/Engine/Graphics/VertexData.cpp
+++ b/src/Engine/Graphics/VertexData.cpp
@@ -142,7 +142,7 @@ void VertexData::createDescriptors()
     }
 }
 
-void VertexData::loadMesh(MeshId id, Array<uint16> loadedIndices, Array<Meshlet> loadedMeshlets)
+void VertexData::loadMesh(MeshId id, Array<uint32> loadedIndices, Array<Meshlet> loadedMeshlets)
 {
     meshlets.reserve(meshlets.size() + loadedMeshlets.size());
     vertexIndices.reserve(vertexIndices.size() + loadedMeshlets.size() * Gfx::numVerticesPerMeshlet);
@@ -183,13 +183,13 @@ void VertexData::loadMesh(MeshId id, Array<uint16> loadedIndices, Array<Meshlet>
     meshData[id][0].firstIndex = indices.size();
     meshData[id][0].numIndices = loadedIndices.size();
     indices.resize(indices.size() + loadedIndices.size());
-    std::memcpy(indices.data() + meshData[id][0].firstIndex, loadedIndices.data(), loadedIndices.size() * sizeof(uint16));
+    std::memcpy(indices.data() + meshData[id][0].firstIndex, loadedIndices.data(), loadedIndices.size() * sizeof(uint32));
     indexBuffer = graphics->createIndexBuffer(IndexBufferCreateInfo{
         .sourceData = {
-            .size = sizeof(uint16) * indices.size(),
+            .size = sizeof(uint32) * indices.size(),
             .data = (uint8*)indices.data(),
         },
-        .indexType = Gfx::SE_INDEX_TYPE_UINT16,
+        .indexType = Gfx::SE_INDEX_TYPE_UINT32,
     });
     meshletBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData = {
@@ -201,7 +201,7 @@ void VertexData::loadMesh(MeshId id, Array<uint16> loadedIndices, Array<Meshlet>
     });
     vertexIndicesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
         .sourceData = {
-            .size = sizeof(uint16) * vertexIndices.size(),
+            .size = sizeof(uint32) * vertexIndices.size(),
             .data = (uint8*)vertexIndices.data(),
         },
         .numElements = vertexIndices.size(),
diff --git a/src/Engine/Graphics/VertexData.h b/src/Engine/Graphics/VertexData.h
index 06ff082..95d7c91 100644
--- a/src/Engine/Graphics/VertexData.h
+++ b/src/Engine/Graphics/VertexData.h
@@ -61,7 +61,7 @@ public:
     void resetMeshData();
     void updateMesh(PMesh mesh, Component::Transform& transform);
     void createDescriptors();
-    void loadMesh(MeshId id, Array<uint16> indices, Array<Meshlet> meshlets);
+    void loadMesh(MeshId id, Array<uint32> indices, Array<Meshlet> meshlets);
     MeshId allocateVertexData(uint64 numVertices);
     uint64 getMeshOffset(MeshId id);
     uint64 getMeshVertexCount(MeshId id);
@@ -100,8 +100,8 @@ protected:
     Map<MeshId, uint64> meshVertexCounts;
     Array<MeshletDescription> meshlets;
     Array<uint8> primitiveIndices;
-    Array<uint16> vertexIndices;
-    Array<uint16> indices;
+    Array<uint32> vertexIndices;
+    Array<uint32> indices;
     Gfx::PGraphics graphics;
     Gfx::ODescriptorLayout instanceDataLayout;
     // for mesh shading