diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -2,6 +2,12 @@
 
 ## WIP
 
+## [3.11.0.2] - 2021-06-26
+- Tweak cabal file to please `cabal check`
+
+## [3.11.0.1] - 2021-06-26
+- Use allocaBytes over allocaBytesAligned where possible
+
 ## [3.11] - 2021-06-21
 - Bump API version to v1.2.182
 
diff --git a/package.yaml b/package.yaml
--- a/package.yaml
+++ b/package.yaml
@@ -1,100 +1,117 @@
 name: vulkan
-version: "3.11"
+version: "3.11.0.2"
 synopsis: Bindings to the Vulkan graphics API.
+description: Please see [the readme](https://github.com/expipiplus1/vulkan/#readme)
 category: Graphics
 maintainer: Joe Hermaszewski <live.long.and.prosper@monoid.al>
 github: expipiplus1/vulkan
 extra-source-files:
-  - readme.md
-  - changelog.md
-  - package.yaml
+- readme.md
+- changelog.md
+- package.yaml
 license: BSD-3-Clause
 
 library:
   source-dirs:
-    - src
-    - src-manual
+  - src
+  - src-manual
   verbatim:
     other-modules:
   dependencies:
-    - base <5
-    - bytestring
-    - transformers
-    - vector
+  - base <5
+  - bytestring
+  - transformers
+  - vector
   when:
-    - condition: os(windows)
-      extra-libraries: vulkan-1
-    - condition: os(darwin)
-      extra-libraries: vulkan
-    - condition: "!os(windows) && !os(darwin)"
-      pkg-config-dependencies: vulkan
-    - condition: flag(safe-foreign-calls)
-      cpp-options: -DSAFE_FOREIGN_CALLS
-    - condition: flag(generic-instances)
-      cpp-options: -DGENERIC_INSTANCES
-    - condition: flag(trace-calls)
-      cpp-options: -DTRACE_CALLS
+  - condition: os(windows)
+    extra-libraries: vulkan-1
+  - condition: os(darwin)
+    extra-libraries: vulkan
+  - condition: '!os(windows) && !os(darwin)'
+    pkg-config-dependencies: vulkan
+  - condition: flag(safe-foreign-calls)
+    cpp-options: -DSAFE_FOREIGN_CALLS
+  - condition: flag(generic-instances)
+    cpp-options: -DGENERIC_INSTANCES
+  - condition: flag(trace-calls)
+    cpp-options: -DTRACE_CALLS
   ghc-options:
-    - -Wall
-    - -Wno-unticked-promoted-constructors
-    - -Wno-missing-pattern-synonym-signatures
-    - -Wno-unused-imports
-    - -Wno-missing-signatures
-    - -Wno-partial-type-signatures
+  - -Wall
+  - -Wno-unticked-promoted-constructors
+  - -Wno-missing-pattern-synonym-signatures
+  - -Wno-unused-imports
+  - -Wno-missing-signatures
+  - -Wno-partial-type-signatures
 
 flags:
   safe-foreign-calls:
-    description:
-      Do not mark foreign imports as 'unsafe'. This means that
-      callbacks from Vulkan to Haskell will work. If you are using
-      these then make sure this flag is enabled.
+    description: Do not mark foreign imports as 'unsafe'. This means that callbacks
+      from Vulkan to Haskell will work. If you are using these then make sure this
+      flag is enabled.
     default: no
     manual: yes
 
   generic-instances:
-    description:
-      Derive Generic instances for all structs. Disabled by default because of
-      code size and compile time impact.
+    description: Derive Generic instances for all structs. Disabled by default because
+      of code size and compile time impact.
     default: no
     manual: yes
 
   trace-calls:
-    description:
-      Inserts calls to Debug.Trace.traceEventIO around every Vulkan call.
+    description: Inserts calls to Debug.Trace.traceEventIO around every Vulkan call.
     default: no
     manual: yes
 
+tests:
+  test:
+    main: Driver.hs
+    source-dirs:
+    - test
+    dependencies:
+    - base
+    - containers
+    - inline-c
+    - tasty
+    - tasty-hunit
+    - template-haskell
+    - vulkan
+    build-tools:
+    - tasty-discover:tasty-discover
+    when:
+    - condition: false
+      other-modules: Paths_vulkan
+
 default-extensions:
-  - AllowAmbiguousTypes
-  - CPP
-  - DataKinds
-  - DefaultSignatures
-  - DeriveAnyClass
-  - DeriveGeneric
-  - DerivingStrategies
-  - DuplicateRecordFields
-  - FlexibleContexts
-  - FlexibleInstances
-  - GADTs
-  - GeneralizedNewtypeDeriving
-  - InstanceSigs
-  - LambdaCase
-  - MagicHash
-  - NoMonomorphismRestriction
-  - OverloadedStrings
-  - PartialTypeSignatures
-  - PatternSynonyms
-  - PolyKinds
-  - QuantifiedConstraints
-  - RankNTypes
-  - RecordWildCards
-  - RoleAnnotations
-  - ScopedTypeVariables
-  - StandaloneDeriving
-  - Strict
-  - TypeApplications
-  - TypeFamilyDependencies
-  - TypeOperators
-  - TypeSynonymInstances
-  - UndecidableInstances
-  - ViewPatterns
+- AllowAmbiguousTypes
+- CPP
+- DataKinds
+- DefaultSignatures
+- DeriveAnyClass
+- DeriveGeneric
+- DerivingStrategies
+- DuplicateRecordFields
+- FlexibleContexts
+- FlexibleInstances
+- GADTs
+- GeneralizedNewtypeDeriving
+- InstanceSigs
+- LambdaCase
+- MagicHash
+- NoMonomorphismRestriction
+- OverloadedStrings
+- PartialTypeSignatures
+- PatternSynonyms
+- PolyKinds
+- QuantifiedConstraints
+- RankNTypes
+- RecordWildCards
+- RoleAnnotations
+- ScopedTypeVariables
+- StandaloneDeriving
+- Strict
+- TypeApplications
+- TypeFamilyDependencies
+- TypeOperators
+- TypeSynonymInstances
+- UndecidableInstances
+- ViewPatterns
diff --git a/src/Vulkan/CStruct/Extends.hs b/src/Vulkan/CStruct/Extends.hs
--- a/src/Vulkan/CStruct/Extends.hs
+++ b/src/Vulkan/CStruct/Extends.hs
@@ -21,7 +21,7 @@
 
 import Data.Maybe (fromMaybe)
 import Type.Reflection (typeRep)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (join)
 import GHC.IO (throwIO)
 import GHC.Ptr (castPtr)
@@ -698,7 +698,7 @@
 deriving instance Show BaseOutStructure
 
 instance ToCStruct BaseOutStructure where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BaseOutStructure{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (sType)
     poke ((p `plusPtr` 8 :: Ptr (Ptr BaseOutStructure))) (next)
@@ -752,7 +752,7 @@
 deriving instance Show BaseInStructure
 
 instance ToCStruct BaseInStructure where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BaseInStructure{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (sType)
     poke ((p `plusPtr` 8 :: Ptr (Ptr BaseInStructure))) (next)
diff --git a/src/Vulkan/Core10/AllocationCallbacks.hs b/src/Vulkan/Core10/AllocationCallbacks.hs
--- a/src/Vulkan/Core10/AllocationCallbacks.hs
+++ b/src/Vulkan/Core10/AllocationCallbacks.hs
@@ -2,7 +2,7 @@
 -- No documentation found for Chapter "AllocationCallbacks"
 module Vulkan.Core10.AllocationCallbacks  (AllocationCallbacks(..)) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
 import Vulkan.CStruct (FromCStruct(..))
@@ -186,7 +186,7 @@
 deriving instance Show AllocationCallbacks
 
 instance ToCStruct AllocationCallbacks where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AllocationCallbacks{..} f = do
     poke ((p `plusPtr` 0 :: Ptr (Ptr ()))) (userData)
     poke ((p `plusPtr` 8 :: Ptr PFN_vkAllocationFunction)) (pfnAllocation)
diff --git a/src/Vulkan/Core10/Buffer.hs b/src/Vulkan/Core10/Buffer.hs
--- a/src/Vulkan/Core10/Buffer.hs
+++ b/src/Vulkan/Core10/Buffer.hs
@@ -17,7 +17,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -439,7 +439,7 @@
     | otherwise = Nothing
 
 instance (Extendss BufferCreateInfo es, PokeChain es) => ToCStruct (BufferCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -449,7 +449,7 @@
     lift $ poke ((p `plusPtr` 32 :: Ptr BufferUsageFlags)) (usage)
     lift $ poke ((p `plusPtr` 36 :: Ptr SharingMode)) (sharingMode)
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueFamilyIndices)) :: Word32))
-    pPQueueFamilyIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4) 4
+    pPQueueFamilyIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPQueueFamilyIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (queueFamilyIndices)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr Word32))) (pPQueueFamilyIndices')
     lift $ f
diff --git a/src/Vulkan/Core10/BufferView.hs b/src/Vulkan/Core10/BufferView.hs
--- a/src/Vulkan/Core10/BufferView.hs
+++ b/src/Vulkan/Core10/BufferView.hs
@@ -12,7 +12,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -369,7 +369,7 @@
 deriving instance Show BufferViewCreateInfo
 
 instance ToCStruct BufferViewCreateInfo where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferViewCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core10/CommandBuffer.hs b/src/Vulkan/Core10/CommandBuffer.hs
--- a/src/Vulkan/Core10/CommandBuffer.hs
+++ b/src/Vulkan/Core10/CommandBuffer.hs
@@ -25,7 +25,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -294,7 +294,7 @@
   lift $ unless (vkFreeCommandBuffersPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkFreeCommandBuffers is null" Nothing Nothing
   let vkFreeCommandBuffers' = mkVkFreeCommandBuffers vkFreeCommandBuffersPtr
-  pPCommandBuffers <- ContT $ allocaBytesAligned @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8) 8
+  pPCommandBuffers <- ContT $ allocaBytes @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPCommandBuffers `plusPtr` (8 * (i)) :: Ptr (Ptr CommandBuffer_T)) (commandBufferHandle (e))) (commandBuffers)
   lift $ traceAroundEvent "vkFreeCommandBuffers" (vkFreeCommandBuffers' (deviceHandle (device)) (commandPool) ((fromIntegral (Data.Vector.length $ (commandBuffers)) :: Word32)) (pPCommandBuffers))
   pure $ ()
@@ -608,7 +608,7 @@
 deriving instance Show CommandBufferAllocateInfo
 
 instance ToCStruct CommandBufferAllocateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferAllocateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -785,7 +785,7 @@
     | otherwise = Nothing
 
 instance (Extendss CommandBufferInheritanceInfo es, PokeChain es) => ToCStruct (CommandBufferInheritanceInfo es) where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferInheritanceInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -903,7 +903,7 @@
     | otherwise = Nothing
 
 instance (Extendss CommandBufferBeginInfo es, PokeChain es) => ToCStruct (CommandBufferBeginInfo es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferBeginInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/CommandBufferBuilding.hs b/src/Vulkan/Core10/CommandBufferBuilding.hs
--- a/src/Vulkan/Core10/CommandBufferBuilding.hs
+++ b/src/Vulkan/Core10/CommandBufferBuilding.hs
@@ -71,7 +71,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.IO (throwIO)
@@ -528,7 +528,7 @@
   lift $ unless (vkCmdSetViewportPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetViewport is null" Nothing Nothing
   let vkCmdSetViewport' = mkVkCmdSetViewport vkCmdSetViewportPtr
-  pPViewports <- ContT $ allocaBytesAligned @Viewport ((Data.Vector.length (viewports)) * 24) 4
+  pPViewports <- ContT $ allocaBytes @Viewport ((Data.Vector.length (viewports)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPViewports `plusPtr` (24 * (i)) :: Ptr Viewport) (e)) (viewports)
   lift $ traceAroundEvent "vkCmdSetViewport" (vkCmdSetViewport' (commandBufferHandle (commandBuffer)) (firstViewport) ((fromIntegral (Data.Vector.length $ (viewports)) :: Word32)) (pPViewports))
   pure $ ()
@@ -646,7 +646,7 @@
   lift $ unless (vkCmdSetScissorPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetScissor is null" Nothing Nothing
   let vkCmdSetScissor' = mkVkCmdSetScissor vkCmdSetScissorPtr
-  pPScissors <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (scissors)) * 16) 4
+  pPScissors <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (scissors)) * 16)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPScissors `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (scissors)
   lift $ traceAroundEvent "vkCmdSetScissor" (vkCmdSetScissor' (commandBufferHandle (commandBuffer)) (firstScissor) ((fromIntegral (Data.Vector.length $ (scissors)) :: Word32)) (pPScissors))
   pure $ ()
@@ -928,7 +928,7 @@
   lift $ unless (vkCmdSetBlendConstantsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetBlendConstants is null" Nothing Nothing
   let vkCmdSetBlendConstants' = mkVkCmdSetBlendConstants vkCmdSetBlendConstantsPtr
-  pBlendConstants <- ContT $ allocaBytesAligned @(FixedArray 4 CFloat) 16 4
+  pBlendConstants <- ContT $ allocaBytes @(FixedArray 4 CFloat) 16
   let pBlendConstants' = lowerArrayPtr pBlendConstants
   lift $ case (blendConstants) of
     (e0, e1, e2, e3) -> do
@@ -1480,9 +1480,9 @@
   lift $ unless (vkCmdBindDescriptorSetsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdBindDescriptorSets is null" Nothing Nothing
   let vkCmdBindDescriptorSets' = mkVkCmdBindDescriptorSets vkCmdBindDescriptorSetsPtr
-  pPDescriptorSets <- ContT $ allocaBytesAligned @DescriptorSet ((Data.Vector.length (descriptorSets)) * 8) 8
+  pPDescriptorSets <- ContT $ allocaBytes @DescriptorSet ((Data.Vector.length (descriptorSets)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorSets `plusPtr` (8 * (i)) :: Ptr DescriptorSet) (e)) (descriptorSets)
-  pPDynamicOffsets <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (dynamicOffsets)) * 4) 4
+  pPDynamicOffsets <- ContT $ allocaBytes @Word32 ((Data.Vector.length (dynamicOffsets)) * 4)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPDynamicOffsets `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (dynamicOffsets)
   lift $ traceAroundEvent "vkCmdBindDescriptorSets" (vkCmdBindDescriptorSets' (commandBufferHandle (commandBuffer)) (pipelineBindPoint) (layout) (firstSet) ((fromIntegral (Data.Vector.length $ (descriptorSets)) :: Word32)) (pPDescriptorSets) ((fromIntegral (Data.Vector.length $ (dynamicOffsets)) :: Word32)) (pPDynamicOffsets))
   pure $ ()
@@ -1726,9 +1726,9 @@
   let pBuffersLength = Data.Vector.length $ (buffers)
   lift $ unless ((Data.Vector.length $ (offsets)) == pBuffersLength) $
     throwIO $ IOError Nothing InvalidArgument "" "pOffsets and pBuffers must have the same length" Nothing Nothing
-  pPBuffers <- ContT $ allocaBytesAligned @Buffer ((Data.Vector.length (buffers)) * 8) 8
+  pPBuffers <- ContT $ allocaBytes @Buffer ((Data.Vector.length (buffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPBuffers `plusPtr` (8 * (i)) :: Ptr Buffer) (e)) (buffers)
-  pPOffsets <- ContT $ allocaBytesAligned @DeviceSize ((Data.Vector.length (offsets)) * 8) 8
+  pPOffsets <- ContT $ allocaBytes @DeviceSize ((Data.Vector.length (offsets)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPOffsets `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) (offsets)
   lift $ traceAroundEvent "vkCmdBindVertexBuffers" (vkCmdBindVertexBuffers' (commandBufferHandle (commandBuffer)) (firstBinding) ((fromIntegral pBuffersLength :: Word32)) (pPBuffers) (pPOffsets))
   pure $ ()
@@ -5035,7 +5035,7 @@
   lift $ unless (vkCmdCopyBufferPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdCopyBuffer is null" Nothing Nothing
   let vkCmdCopyBuffer' = mkVkCmdCopyBuffer vkCmdCopyBufferPtr
-  pPRegions <- ContT $ allocaBytesAligned @BufferCopy ((Data.Vector.length (regions)) * 24) 8
+  pPRegions <- ContT $ allocaBytes @BufferCopy ((Data.Vector.length (regions)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (24 * (i)) :: Ptr BufferCopy) (e)) (regions)
   lift $ traceAroundEvent "vkCmdCopyBuffer" (vkCmdCopyBuffer' (commandBufferHandle (commandBuffer)) (srcBuffer) (dstBuffer) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions))
   pure $ ()
@@ -5580,7 +5580,7 @@
   lift $ unless (vkCmdCopyImagePtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdCopyImage is null" Nothing Nothing
   let vkCmdCopyImage' = mkVkCmdCopyImage vkCmdCopyImagePtr
-  pPRegions <- ContT $ allocaBytesAligned @ImageCopy ((Data.Vector.length (regions)) * 68) 4
+  pPRegions <- ContT $ allocaBytes @ImageCopy ((Data.Vector.length (regions)) * 68)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (68 * (i)) :: Ptr ImageCopy) (e)) (regions)
   lift $ traceAroundEvent "vkCmdCopyImage" (vkCmdCopyImage' (commandBufferHandle (commandBuffer)) (srcImage) (srcImageLayout) (dstImage) (dstImageLayout) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions))
   pure $ ()
@@ -6026,7 +6026,7 @@
   lift $ unless (vkCmdBlitImagePtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdBlitImage is null" Nothing Nothing
   let vkCmdBlitImage' = mkVkCmdBlitImage vkCmdBlitImagePtr
-  pPRegions <- ContT $ allocaBytesAligned @ImageBlit ((Data.Vector.length (regions)) * 80) 4
+  pPRegions <- ContT $ allocaBytes @ImageBlit ((Data.Vector.length (regions)) * 80)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (80 * (i)) :: Ptr ImageBlit) (e)) (regions)
   lift $ traceAroundEvent "vkCmdBlitImage" (vkCmdBlitImage' (commandBufferHandle (commandBuffer)) (srcImage) (srcImageLayout) (dstImage) (dstImageLayout) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions) (filter'))
   pure $ ()
@@ -6382,7 +6382,7 @@
   lift $ unless (vkCmdCopyBufferToImagePtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdCopyBufferToImage is null" Nothing Nothing
   let vkCmdCopyBufferToImage' = mkVkCmdCopyBufferToImage vkCmdCopyBufferToImagePtr
-  pPRegions <- ContT $ allocaBytesAligned @BufferImageCopy ((Data.Vector.length (regions)) * 56) 8
+  pPRegions <- ContT $ allocaBytes @BufferImageCopy ((Data.Vector.length (regions)) * 56)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (56 * (i)) :: Ptr BufferImageCopy) (e)) (regions)
   lift $ traceAroundEvent "vkCmdCopyBufferToImage" (vkCmdCopyBufferToImage' (commandBufferHandle (commandBuffer)) (srcBuffer) (dstImage) (dstImageLayout) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions))
   pure $ ()
@@ -6729,7 +6729,7 @@
   lift $ unless (vkCmdCopyImageToBufferPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdCopyImageToBuffer is null" Nothing Nothing
   let vkCmdCopyImageToBuffer' = mkVkCmdCopyImageToBuffer vkCmdCopyImageToBufferPtr
-  pPRegions <- ContT $ allocaBytesAligned @BufferImageCopy ((Data.Vector.length (regions)) * 56) 8
+  pPRegions <- ContT $ allocaBytes @BufferImageCopy ((Data.Vector.length (regions)) * 56)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (56 * (i)) :: Ptr BufferImageCopy) (e)) (regions)
   lift $ traceAroundEvent "vkCmdCopyImageToBuffer" (vkCmdCopyImageToBuffer' (commandBufferHandle (commandBuffer)) (srcImage) (srcImageLayout) (dstBuffer) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions))
   pure $ ()
@@ -7203,7 +7203,7 @@
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdClearColorImage is null" Nothing Nothing
   let vkCmdClearColorImage' = mkVkCmdClearColorImage vkCmdClearColorImagePtr
   pColor <- ContT $ withCStruct (color)
-  pPRanges <- ContT $ allocaBytesAligned @ImageSubresourceRange ((Data.Vector.length (ranges)) * 20) 4
+  pPRanges <- ContT $ allocaBytes @ImageSubresourceRange ((Data.Vector.length (ranges)) * 20)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRanges `plusPtr` (20 * (i)) :: Ptr ImageSubresourceRange) (e)) (ranges)
   lift $ traceAroundEvent "vkCmdClearColorImage" (vkCmdClearColorImage' (commandBufferHandle (commandBuffer)) (image) (imageLayout) pColor ((fromIntegral (Data.Vector.length $ (ranges)) :: Word32)) (pPRanges))
   pure $ ()
@@ -7421,7 +7421,7 @@
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdClearDepthStencilImage is null" Nothing Nothing
   let vkCmdClearDepthStencilImage' = mkVkCmdClearDepthStencilImage vkCmdClearDepthStencilImagePtr
   pDepthStencil <- ContT $ withCStruct (depthStencil)
-  pPRanges <- ContT $ allocaBytesAligned @ImageSubresourceRange ((Data.Vector.length (ranges)) * 20) 4
+  pPRanges <- ContT $ allocaBytes @ImageSubresourceRange ((Data.Vector.length (ranges)) * 20)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRanges `plusPtr` (20 * (i)) :: Ptr ImageSubresourceRange) (e)) (ranges)
   lift $ traceAroundEvent "vkCmdClearDepthStencilImage" (vkCmdClearDepthStencilImage' (commandBufferHandle (commandBuffer)) (image) (imageLayout) pDepthStencil ((fromIntegral (Data.Vector.length $ (ranges)) :: Word32)) (pPRanges))
   pure $ ()
@@ -7595,9 +7595,9 @@
   lift $ unless (vkCmdClearAttachmentsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdClearAttachments is null" Nothing Nothing
   let vkCmdClearAttachments' = mkVkCmdClearAttachments vkCmdClearAttachmentsPtr
-  pPAttachments <- ContT $ allocaBytesAligned @ClearAttachment ((Data.Vector.length (attachments)) * 24) 4
+  pPAttachments <- ContT $ allocaBytes @ClearAttachment ((Data.Vector.length (attachments)) * 24)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPAttachments `plusPtr` (24 * (i)) :: Ptr ClearAttachment) (e) . ($ ())) (attachments)
-  pPRects <- ContT $ allocaBytesAligned @ClearRect ((Data.Vector.length (rects)) * 24) 4
+  pPRects <- ContT $ allocaBytes @ClearRect ((Data.Vector.length (rects)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRects `plusPtr` (24 * (i)) :: Ptr ClearRect) (e)) (rects)
   lift $ traceAroundEvent "vkCmdClearAttachments" (vkCmdClearAttachments' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32)) (pPAttachments) ((fromIntegral (Data.Vector.length $ (rects)) :: Word32)) (pPRects))
   pure $ ()
@@ -7872,7 +7872,7 @@
   lift $ unless (vkCmdResolveImagePtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdResolveImage is null" Nothing Nothing
   let vkCmdResolveImage' = mkVkCmdResolveImage vkCmdResolveImagePtr
-  pPRegions <- ContT $ allocaBytesAligned @ImageResolve ((Data.Vector.length (regions)) * 68) 4
+  pPRegions <- ContT $ allocaBytes @ImageResolve ((Data.Vector.length (regions)) * 68)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions `plusPtr` (68 * (i)) :: Ptr ImageResolve) (e)) (regions)
   lift $ traceAroundEvent "vkCmdResolveImage" (vkCmdResolveImage' (commandBufferHandle (commandBuffer)) (srcImage) (srcImageLayout) (dstImage) (dstImageLayout) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32)) (pPRegions))
   pure $ ()
@@ -8239,13 +8239,13 @@
   lift $ unless (vkCmdWaitEventsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdWaitEvents is null" Nothing Nothing
   let vkCmdWaitEvents' = mkVkCmdWaitEvents vkCmdWaitEventsPtr
-  pPEvents <- ContT $ allocaBytesAligned @Event ((Data.Vector.length (events)) * 8) 8
+  pPEvents <- ContT $ allocaBytes @Event ((Data.Vector.length (events)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPEvents `plusPtr` (8 * (i)) :: Ptr Event) (e)) (events)
-  pPMemoryBarriers <- ContT $ allocaBytesAligned @MemoryBarrier ((Data.Vector.length (memoryBarriers)) * 24) 8
+  pPMemoryBarriers <- ContT $ allocaBytes @MemoryBarrier ((Data.Vector.length (memoryBarriers)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPMemoryBarriers `plusPtr` (24 * (i)) :: Ptr MemoryBarrier) (e)) (memoryBarriers)
-  pPBufferMemoryBarriers <- ContT $ allocaBytesAligned @BufferMemoryBarrier ((Data.Vector.length (bufferMemoryBarriers)) * 56) 8
+  pPBufferMemoryBarriers <- ContT $ allocaBytes @BufferMemoryBarrier ((Data.Vector.length (bufferMemoryBarriers)) * 56)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPBufferMemoryBarriers `plusPtr` (56 * (i)) :: Ptr BufferMemoryBarrier) (e)) (bufferMemoryBarriers)
-  pPImageMemoryBarriers <- ContT $ allocaBytesAligned @(ImageMemoryBarrier _) ((Data.Vector.length (imageMemoryBarriers)) * 72) 8
+  pPImageMemoryBarriers <- ContT $ allocaBytes @(ImageMemoryBarrier _) ((Data.Vector.length (imageMemoryBarriers)) * 72)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPImageMemoryBarriers `plusPtr` (72 * (i)) :: Ptr (ImageMemoryBarrier _))) (e) . ($ ())) (imageMemoryBarriers)
   lift $ traceAroundEvent "vkCmdWaitEvents" (vkCmdWaitEvents' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (events)) :: Word32)) (pPEvents) (srcStageMask) (dstStageMask) ((fromIntegral (Data.Vector.length $ (memoryBarriers)) :: Word32)) (pPMemoryBarriers) ((fromIntegral (Data.Vector.length $ (bufferMemoryBarriers)) :: Word32)) (pPBufferMemoryBarriers) ((fromIntegral (Data.Vector.length $ (imageMemoryBarriers)) :: Word32)) (forgetExtensions (pPImageMemoryBarriers)))
   pure $ ()
@@ -9035,11 +9035,11 @@
   lift $ unless (vkCmdPipelineBarrierPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdPipelineBarrier is null" Nothing Nothing
   let vkCmdPipelineBarrier' = mkVkCmdPipelineBarrier vkCmdPipelineBarrierPtr
-  pPMemoryBarriers <- ContT $ allocaBytesAligned @MemoryBarrier ((Data.Vector.length (memoryBarriers)) * 24) 8
+  pPMemoryBarriers <- ContT $ allocaBytes @MemoryBarrier ((Data.Vector.length (memoryBarriers)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPMemoryBarriers `plusPtr` (24 * (i)) :: Ptr MemoryBarrier) (e)) (memoryBarriers)
-  pPBufferMemoryBarriers <- ContT $ allocaBytesAligned @BufferMemoryBarrier ((Data.Vector.length (bufferMemoryBarriers)) * 56) 8
+  pPBufferMemoryBarriers <- ContT $ allocaBytes @BufferMemoryBarrier ((Data.Vector.length (bufferMemoryBarriers)) * 56)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPBufferMemoryBarriers `plusPtr` (56 * (i)) :: Ptr BufferMemoryBarrier) (e)) (bufferMemoryBarriers)
-  pPImageMemoryBarriers <- ContT $ allocaBytesAligned @(ImageMemoryBarrier _) ((Data.Vector.length (imageMemoryBarriers)) * 72) 8
+  pPImageMemoryBarriers <- ContT $ allocaBytes @(ImageMemoryBarrier _) ((Data.Vector.length (imageMemoryBarriers)) * 72)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPImageMemoryBarriers `plusPtr` (72 * (i)) :: Ptr (ImageMemoryBarrier _))) (e) . ($ ())) (imageMemoryBarriers)
   lift $ traceAroundEvent "vkCmdPipelineBarrier" (vkCmdPipelineBarrier' (commandBufferHandle (commandBuffer)) (srcStageMask) (dstStageMask) (dependencyFlags) ((fromIntegral (Data.Vector.length $ (memoryBarriers)) :: Word32)) (pPMemoryBarriers) ((fromIntegral (Data.Vector.length $ (bufferMemoryBarriers)) :: Word32)) (pPBufferMemoryBarriers) ((fromIntegral (Data.Vector.length $ (imageMemoryBarriers)) :: Word32)) (forgetExtensions (pPImageMemoryBarriers)))
   pure $ ()
@@ -10717,7 +10717,7 @@
   lift $ unless (vkCmdExecuteCommandsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdExecuteCommands is null" Nothing Nothing
   let vkCmdExecuteCommands' = mkVkCmdExecuteCommands vkCmdExecuteCommandsPtr
-  pPCommandBuffers <- ContT $ allocaBytesAligned @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8) 8
+  pPCommandBuffers <- ContT $ allocaBytes @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPCommandBuffers `plusPtr` (8 * (i)) :: Ptr (Ptr CommandBuffer_T)) (commandBufferHandle (e))) (commandBuffers)
   lift $ traceAroundEvent "vkCmdExecuteCommands" (vkCmdExecuteCommands' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (commandBuffers)) :: Word32)) (pPCommandBuffers))
   pure $ ()
@@ -10748,7 +10748,7 @@
 deriving instance Show ClearRect
 
 instance ToCStruct ClearRect where
-  withCStruct x f = allocaBytesAligned 24 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ClearRect{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Rect2D)) (rect)
     poke ((p `plusPtr` 16 :: Ptr Word32)) (baseArrayLayer)
@@ -10843,7 +10843,7 @@
 deriving instance Show ImageSubresourceLayers
 
 instance ToCStruct ImageSubresourceLayers where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageSubresourceLayers{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageAspectFlags)) (aspectMask)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (mipLevel)
@@ -10908,7 +10908,7 @@
 deriving instance Show BufferCopy
 
 instance ToCStruct BufferCopy where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferCopy{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (srcOffset)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (dstOffset)
@@ -11010,7 +11010,7 @@
 deriving instance Show ImageCopy
 
 instance ToCStruct ImageCopy where
-  withCStruct x f = allocaBytesAligned 68 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 68 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageCopy{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageSubresourceLayers)) (srcSubresource)
     poke ((p `plusPtr` 16 :: Ptr Offset3D)) (srcOffset)
@@ -11101,7 +11101,7 @@
 deriving instance Show ImageBlit
 
 instance ToCStruct ImageBlit where
-  withCStruct x f = allocaBytesAligned 80 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageBlit{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageSubresourceLayers)) (srcSubresource)
     let pSrcOffsets' = lowerArrayPtr ((p `plusPtr` 16 :: Ptr (FixedArray 2 Offset3D)))
@@ -11273,7 +11273,7 @@
 deriving instance Show BufferImageCopy
 
 instance ToCStruct BufferImageCopy where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferImageCopy{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (bufferOffset)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (bufferRowLength)
@@ -11367,7 +11367,7 @@
 deriving instance Show ImageResolve
 
 instance ToCStruct ImageResolve where
-  withCStruct x f = allocaBytesAligned 68 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 68 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageResolve{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageSubresourceLayers)) (srcSubresource)
     poke ((p `plusPtr` 16 :: Ptr Offset3D)) (srcOffset)
@@ -11749,7 +11749,7 @@
     | otherwise = Nothing
 
 instance (Extendss RenderPassBeginInfo es, PokeChain es) => ToCStruct (RenderPassBeginInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassBeginInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -11758,7 +11758,7 @@
     lift $ poke ((p `plusPtr` 24 :: Ptr Framebuffer)) (framebuffer)
     lift $ poke ((p `plusPtr` 32 :: Ptr Rect2D)) (renderArea)
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (clearValues)) :: Word32))
-    pPClearValues' <- ContT $ allocaBytesAligned @ClearValue ((Data.Vector.length (clearValues)) * 16) 4
+    pPClearValues' <- ContT $ allocaBytes @ClearValue ((Data.Vector.length (clearValues)) * 16)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPClearValues' `plusPtr` (16 * (i)) :: Ptr ClearValue) (e) . ($ ())) (clearValues)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr ClearValue))) (pPClearValues')
     lift $ f
@@ -11812,7 +11812,7 @@
 deriving instance Show ClearDepthStencilValue
 
 instance ToCStruct ClearDepthStencilValue where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ClearDepthStencilValue{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (depth))
     poke ((p `plusPtr` 4 :: Ptr Word32)) (stencil)
@@ -11915,7 +11915,7 @@
 deriving instance Show ClearAttachment
 
 instance ToCStruct ClearAttachment where
-  withCStruct x f = allocaBytesAligned 24 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ClearAttachment{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr ImageAspectFlags)) (aspectMask)
     lift $ poke ((p `plusPtr` 4 :: Ptr Word32)) (colorAttachment)
@@ -11943,7 +11943,7 @@
   deriving (Show)
 
 instance ToCStruct ClearColorValue where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr ClearColorValue -> ClearColorValue -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     Float32 v0 v1 v2 v3 -> lift $ do
@@ -11985,7 +11985,7 @@
   deriving (Show)
 
 instance ToCStruct ClearValue where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr ClearValue -> ClearValue -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     Color v -> ContT $ pokeCStruct (castPtr @_ @ClearColorValue p) (v) . ($ ())
diff --git a/src/Vulkan/Core10/CommandPool.hs b/src/Vulkan/Core10/CommandPool.hs
--- a/src/Vulkan/Core10/CommandPool.hs
+++ b/src/Vulkan/Core10/CommandPool.hs
@@ -16,7 +16,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -376,7 +376,7 @@
 deriving instance Show CommandPoolCreateInfo
 
 instance ToCStruct CommandPoolCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandPoolCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core10/DescriptorSet.hs b/src/Vulkan/Core10/DescriptorSet.hs
--- a/src/Vulkan/Core10/DescriptorSet.hs
+++ b/src/Vulkan/Core10/DescriptorSet.hs
@@ -36,7 +36,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -768,7 +768,7 @@
   lift $ unless (vkFreeDescriptorSetsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkFreeDescriptorSets is null" Nothing Nothing
   let vkFreeDescriptorSets' = mkVkFreeDescriptorSets vkFreeDescriptorSetsPtr
-  pPDescriptorSets <- ContT $ allocaBytesAligned @DescriptorSet ((Data.Vector.length (descriptorSets)) * 8) 8
+  pPDescriptorSets <- ContT $ allocaBytes @DescriptorSet ((Data.Vector.length (descriptorSets)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorSets `plusPtr` (8 * (i)) :: Ptr DescriptorSet) (e)) (descriptorSets)
   _ <- lift $ traceAroundEvent "vkFreeDescriptorSets" (vkFreeDescriptorSets' (deviceHandle (device)) (descriptorPool) ((fromIntegral (Data.Vector.length $ (descriptorSets)) :: Word32)) (pPDescriptorSets))
   pure $ ()
@@ -863,9 +863,9 @@
   lift $ unless (vkUpdateDescriptorSetsPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkUpdateDescriptorSets is null" Nothing Nothing
   let vkUpdateDescriptorSets' = mkVkUpdateDescriptorSets vkUpdateDescriptorSetsPtr
-  pPDescriptorWrites <- ContT $ allocaBytesAligned @(WriteDescriptorSet _) ((Data.Vector.length (descriptorWrites)) * 64) 8
+  pPDescriptorWrites <- ContT $ allocaBytes @(WriteDescriptorSet _) ((Data.Vector.length (descriptorWrites)) * 64)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPDescriptorWrites `plusPtr` (64 * (i)) :: Ptr (WriteDescriptorSet _))) (e) . ($ ())) (descriptorWrites)
-  pPDescriptorCopies <- ContT $ allocaBytesAligned @CopyDescriptorSet ((Data.Vector.length (descriptorCopies)) * 56) 8
+  pPDescriptorCopies <- ContT $ allocaBytes @CopyDescriptorSet ((Data.Vector.length (descriptorCopies)) * 56)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorCopies `plusPtr` (56 * (i)) :: Ptr CopyDescriptorSet) (e)) (descriptorCopies)
   lift $ traceAroundEvent "vkUpdateDescriptorSets" (vkUpdateDescriptorSets' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (descriptorWrites)) :: Word32)) (forgetExtensions (pPDescriptorWrites)) ((fromIntegral (Data.Vector.length $ (descriptorCopies)) :: Word32)) (pPDescriptorCopies))
   pure $ ()
@@ -949,7 +949,7 @@
 deriving instance Show DescriptorBufferInfo
 
 instance ToCStruct DescriptorBufferInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorBufferInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Buffer)) (buffer)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (offset)
@@ -1071,7 +1071,7 @@
 deriving instance Show DescriptorImageInfo
 
 instance ToCStruct DescriptorImageInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorImageInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Sampler)) (sampler)
     poke ((p `plusPtr` 8 :: Ptr ImageView)) (imageView)
@@ -1608,7 +1608,7 @@
     | otherwise = Nothing
 
 instance (Extendss WriteDescriptorSet es, PokeChain es) => ToCStruct (WriteDescriptorSet es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p WriteDescriptorSet{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1630,21 +1630,21 @@
     pImageInfo'' <- if Data.Vector.null (imageInfo)
       then pure nullPtr
       else do
-        pPImageInfo <- ContT $ allocaBytesAligned @DescriptorImageInfo (((Data.Vector.length (imageInfo))) * 24) 8
+        pPImageInfo <- ContT $ allocaBytes @DescriptorImageInfo (((Data.Vector.length (imageInfo))) * 24)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPImageInfo `plusPtr` (24 * (i)) :: Ptr DescriptorImageInfo) (e)) ((imageInfo))
         pure $ pPImageInfo
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr DescriptorImageInfo))) pImageInfo''
     pBufferInfo'' <- if Data.Vector.null (bufferInfo)
       then pure nullPtr
       else do
-        pPBufferInfo <- ContT $ allocaBytesAligned @DescriptorBufferInfo (((Data.Vector.length (bufferInfo))) * 24) 8
+        pPBufferInfo <- ContT $ allocaBytes @DescriptorBufferInfo (((Data.Vector.length (bufferInfo))) * 24)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPBufferInfo `plusPtr` (24 * (i)) :: Ptr DescriptorBufferInfo) (e)) ((bufferInfo))
         pure $ pPBufferInfo
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr DescriptorBufferInfo))) pBufferInfo''
     pTexelBufferView'' <- if Data.Vector.null (texelBufferView)
       then pure nullPtr
       else do
-        pPTexelBufferView <- ContT $ allocaBytesAligned @BufferView (((Data.Vector.length (texelBufferView))) * 8) 8
+        pPTexelBufferView <- ContT $ allocaBytes @BufferView (((Data.Vector.length (texelBufferView))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPTexelBufferView `plusPtr` (8 * (i)) :: Ptr BufferView) (e)) ((texelBufferView))
         pure $ pPTexelBufferView
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr BufferView))) pTexelBufferView''
@@ -1898,7 +1898,7 @@
 deriving instance Show CopyDescriptorSet
 
 instance ToCStruct CopyDescriptorSet where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyDescriptorSet{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_DESCRIPTOR_SET)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2097,7 +2097,7 @@
 deriving instance Show DescriptorSetLayoutBinding
 
 instance ToCStruct DescriptorSetLayoutBinding where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetLayoutBinding{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) (binding)
     lift $ poke ((p `plusPtr` 4 :: Ptr DescriptorType)) (descriptorType)
@@ -2113,7 +2113,7 @@
     pImmutableSamplers'' <- if Data.Vector.null (immutableSamplers)
       then pure nullPtr
       else do
-        pPImmutableSamplers <- ContT $ allocaBytesAligned @Sampler (((Data.Vector.length (immutableSamplers))) * 8) 8
+        pPImmutableSamplers <- ContT $ allocaBytes @Sampler (((Data.Vector.length (immutableSamplers))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPImmutableSamplers `plusPtr` (8 * (i)) :: Ptr Sampler) (e)) ((immutableSamplers))
         pure $ pPImmutableSamplers
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr Sampler))) pImmutableSamplers''
@@ -2296,14 +2296,14 @@
     | otherwise = Nothing
 
 instance (Extendss DescriptorSetLayoutCreateInfo es, PokeChain es) => ToCStruct (DescriptorSetLayoutCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetLayoutCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr DescriptorSetLayoutCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (bindings)) :: Word32))
-    pPBindings' <- ContT $ allocaBytesAligned @DescriptorSetLayoutBinding ((Data.Vector.length (bindings)) * 24) 8
+    pPBindings' <- ContT $ allocaBytes @DescriptorSetLayoutBinding ((Data.Vector.length (bindings)) * 24)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPBindings' `plusPtr` (24 * (i)) :: Ptr DescriptorSetLayoutBinding) (e) . ($ ())) (bindings)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DescriptorSetLayoutBinding))) (pPBindings')
     lift $ f
@@ -2380,7 +2380,7 @@
 deriving instance Show DescriptorPoolSize
 
 instance ToCStruct DescriptorPoolSize where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorPoolSize{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DescriptorType)) (type')
     poke ((p `plusPtr` 4 :: Ptr Word32)) (descriptorCount)
@@ -2590,7 +2590,7 @@
     | otherwise = Nothing
 
 instance (Extendss DescriptorPoolCreateInfo es, PokeChain es) => ToCStruct (DescriptorPoolCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorPoolCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2598,7 +2598,7 @@
     lift $ poke ((p `plusPtr` 16 :: Ptr DescriptorPoolCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) (maxSets)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (poolSizes)) :: Word32))
-    pPPoolSizes' <- ContT $ allocaBytesAligned @DescriptorPoolSize ((Data.Vector.length (poolSizes)) * 8) 4
+    pPPoolSizes' <- ContT $ allocaBytes @DescriptorPoolSize ((Data.Vector.length (poolSizes)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPoolSizes' `plusPtr` (8 * (i)) :: Ptr DescriptorPoolSize) (e)) (poolSizes)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr DescriptorPoolSize))) (pPPoolSizes')
     lift $ f
@@ -2716,14 +2716,14 @@
     | otherwise = Nothing
 
 instance (Extendss DescriptorSetAllocateInfo es, PokeChain es) => ToCStruct (DescriptorSetAllocateInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetAllocateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr DescriptorPool)) (descriptorPool)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (setLayouts)) :: Word32))
-    pPSetLayouts' <- ContT $ allocaBytesAligned @DescriptorSetLayout ((Data.Vector.length (setLayouts)) * 8) 8
+    pPSetLayouts' <- ContT $ allocaBytes @DescriptorSetLayout ((Data.Vector.length (setLayouts)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSetLayouts' `plusPtr` (8 * (i)) :: Ptr DescriptorSetLayout) (e)) (setLayouts)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr DescriptorSetLayout))) (pPSetLayouts')
     lift $ f
diff --git a/src/Vulkan/Core10/Device.hs b/src/Vulkan/Core10/Device.hs
--- a/src/Vulkan/Core10/Device.hs
+++ b/src/Vulkan/Core10/Device.hs
@@ -16,7 +16,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -490,7 +490,7 @@
     | otherwise = Nothing
 
 instance (Extendss DeviceQueueCreateInfo es, PokeChain es) => ToCStruct (DeviceQueueCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceQueueCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -498,7 +498,7 @@
     lift $ poke ((p `plusPtr` 16 :: Ptr DeviceQueueCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) (queueFamilyIndex)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queuePriorities)) :: Word32))
-    pPQueuePriorities' <- ContT $ allocaBytesAligned @CFloat ((Data.Vector.length (queuePriorities)) * 4) 4
+    pPQueuePriorities' <- ContT $ allocaBytes @CFloat ((Data.Vector.length (queuePriorities)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPQueuePriorities' `plusPtr` (4 * (i)) :: Ptr CFloat) (CFloat (e))) (queuePriorities)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr CFloat))) (pPQueuePriorities')
     lift $ f
@@ -982,24 +982,24 @@
     | otherwise = Nothing
 
 instance (Extendss DeviceCreateInfo es, PokeChain es) => ToCStruct (DeviceCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr DeviceCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueCreateInfos)) :: Word32))
-    pPQueueCreateInfos' <- ContT $ allocaBytesAligned @(DeviceQueueCreateInfo _) ((Data.Vector.length (queueCreateInfos)) * 40) 8
+    pPQueueCreateInfos' <- ContT $ allocaBytes @(DeviceQueueCreateInfo _) ((Data.Vector.length (queueCreateInfos)) * 40)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPQueueCreateInfos' `plusPtr` (40 * (i)) :: Ptr (DeviceQueueCreateInfo _))) (e) . ($ ())) (queueCreateInfos)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (DeviceQueueCreateInfo _)))) (pPQueueCreateInfos')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (enabledLayerNames)) :: Word32))
-    pPpEnabledLayerNames' <- ContT $ allocaBytesAligned @(Ptr CChar) ((Data.Vector.length (enabledLayerNames)) * 8) 8
+    pPpEnabledLayerNames' <- ContT $ allocaBytes @(Ptr CChar) ((Data.Vector.length (enabledLayerNames)) * 8)
     Data.Vector.imapM_ (\i e -> do
       ppEnabledLayerNames'' <- ContT $ useAsCString (e)
       lift $ poke (pPpEnabledLayerNames' `plusPtr` (8 * (i)) :: Ptr (Ptr CChar)) ppEnabledLayerNames'') (enabledLayerNames)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr (Ptr CChar)))) (pPpEnabledLayerNames')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (enabledExtensionNames)) :: Word32))
-    pPpEnabledExtensionNames' <- ContT $ allocaBytesAligned @(Ptr CChar) ((Data.Vector.length (enabledExtensionNames)) * 8) 8
+    pPpEnabledExtensionNames' <- ContT $ allocaBytes @(Ptr CChar) ((Data.Vector.length (enabledExtensionNames)) * 8)
     Data.Vector.imapM_ (\i e -> do
       ppEnabledExtensionNames'' <- ContT $ useAsCString (e)
       lift $ poke (pPpEnabledExtensionNames' `plusPtr` (8 * (i)) :: Ptr (Ptr CChar)) ppEnabledExtensionNames'') (enabledExtensionNames)
diff --git a/src/Vulkan/Core10/DeviceInitialization.hs b/src/Vulkan/Core10/DeviceInitialization.hs
--- a/src/Vulkan/Core10/DeviceInitialization.hs
+++ b/src/Vulkan/Core10/DeviceInitialization.hs
@@ -68,7 +68,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -1154,7 +1154,7 @@
 deriving instance Show PhysicalDeviceProperties
 
 instance ToCStruct PhysicalDeviceProperties where
-  withCStruct x f = allocaBytesAligned 824 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 824 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (apiVersion)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (driverVersion)
@@ -1329,7 +1329,7 @@
 deriving instance Show ApplicationInfo
 
 instance ToCStruct ApplicationInfo where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ApplicationInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_APPLICATION_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1489,7 +1489,7 @@
     | otherwise = Nothing
 
 instance (Extendss InstanceCreateInfo es, PokeChain es) => ToCStruct (InstanceCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p InstanceCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1500,13 +1500,13 @@
       Just j -> ContT $ withCStruct (j)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ApplicationInfo))) pApplicationInfo''
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (enabledLayerNames)) :: Word32))
-    pPpEnabledLayerNames' <- ContT $ allocaBytesAligned @(Ptr CChar) ((Data.Vector.length (enabledLayerNames)) * 8) 8
+    pPpEnabledLayerNames' <- ContT $ allocaBytes @(Ptr CChar) ((Data.Vector.length (enabledLayerNames)) * 8)
     Data.Vector.imapM_ (\i e -> do
       ppEnabledLayerNames'' <- ContT $ useAsCString (e)
       lift $ poke (pPpEnabledLayerNames' `plusPtr` (8 * (i)) :: Ptr (Ptr CChar)) ppEnabledLayerNames'') (enabledLayerNames)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr (Ptr CChar)))) (pPpEnabledLayerNames')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (enabledExtensionNames)) :: Word32))
-    pPpEnabledExtensionNames' <- ContT $ allocaBytesAligned @(Ptr CChar) ((Data.Vector.length (enabledExtensionNames)) * 8) 8
+    pPpEnabledExtensionNames' <- ContT $ allocaBytes @(Ptr CChar) ((Data.Vector.length (enabledExtensionNames)) * 8)
     Data.Vector.imapM_ (\i e -> do
       ppEnabledExtensionNames'' <- ContT $ useAsCString (e)
       lift $ poke (pPpEnabledExtensionNames' `plusPtr` (8 * (i)) :: Ptr (Ptr CChar)) ppEnabledExtensionNames'') (enabledExtensionNames)
@@ -1646,7 +1646,7 @@
 deriving instance Show QueueFamilyProperties
 
 instance ToCStruct QueueFamilyProperties where
-  withCStruct x f = allocaBytesAligned 24 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueueFamilyProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr QueueFlags)) (queueFlags)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (queueCount)
@@ -1971,7 +1971,7 @@
 deriving instance Show PhysicalDeviceMemoryProperties
 
 instance ToCStruct PhysicalDeviceMemoryProperties where
-  withCStruct x f = allocaBytesAligned 520 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 520 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMemoryProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (memoryTypeCount)
     unless ((Data.Vector.length $ (memoryTypes)) <= MAX_MEMORY_TYPES) $
@@ -2035,7 +2035,7 @@
 deriving instance Show MemoryType
 
 instance ToCStruct MemoryType where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryType{..} f = do
     poke ((p `plusPtr` 0 :: Ptr MemoryPropertyFlags)) (propertyFlags)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (heapIndex)
@@ -2087,7 +2087,7 @@
 deriving instance Show MemoryHeap
 
 instance ToCStruct MemoryHeap where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryHeap{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (size)
     poke ((p `plusPtr` 8 :: Ptr MemoryHeapFlags)) (flags)
@@ -2161,7 +2161,7 @@
 deriving instance Show FormatProperties
 
 instance ToCStruct FormatProperties where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FormatProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr FormatFeatureFlags)) (linearTilingFeatures)
     poke ((p `plusPtr` 4 :: Ptr FormatFeatureFlags)) (optimalTilingFeatures)
@@ -2311,7 +2311,7 @@
 deriving instance Show ImageFormatProperties
 
 instance ToCStruct ImageFormatProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageFormatProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Extent3D)) (maxExtent)
     poke ((p `plusPtr` 12 :: Ptr Word32)) (maxMipLevels)
@@ -3262,7 +3262,7 @@
 deriving instance Show PhysicalDeviceFeatures
 
 instance ToCStruct PhysicalDeviceFeatures where
-  withCStruct x f = allocaBytesAligned 220 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 220 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Bool32)) (boolToBool32 (robustBufferAccess))
     poke ((p `plusPtr` 4 :: Ptr Bool32)) (boolToBool32 (fullDrawIndexUint32))
@@ -3574,7 +3574,7 @@
 deriving instance Show PhysicalDeviceSparseProperties
 
 instance ToCStruct PhysicalDeviceSparseProperties where
-  withCStruct x f = allocaBytesAligned 20 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 20 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSparseProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Bool32)) (boolToBool32 (residencyStandard2DBlockShape))
     poke ((p `plusPtr` 4 :: Ptr Bool32)) (boolToBool32 (residencyStandard2DMultisampleBlockShape))
@@ -4497,7 +4497,7 @@
 deriving instance Show PhysicalDeviceLimits
 
 instance ToCStruct PhysicalDeviceLimits where
-  withCStruct x f = allocaBytesAligned 504 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 504 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceLimits{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (maxImageDimension1D)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (maxImageDimension2D)
diff --git a/src/Vulkan/Core10/Event.hs b/src/Vulkan/Core10/Event.hs
--- a/src/Vulkan/Core10/Event.hs
+++ b/src/Vulkan/Core10/Event.hs
@@ -16,7 +16,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -494,7 +494,7 @@
 deriving instance Show EventCreateInfo
 
 instance ToCStruct EventCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p EventCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EVENT_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core10/ExtensionDiscovery.hs b/src/Vulkan/Core10/ExtensionDiscovery.hs
--- a/src/Vulkan/Core10/ExtensionDiscovery.hs
+++ b/src/Vulkan/Core10/ExtensionDiscovery.hs
@@ -10,7 +10,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -277,7 +277,7 @@
 deriving instance Show ExtensionProperties
 
 instance ToCStruct ExtensionProperties where
-  withCStruct x f = allocaBytesAligned 260 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 260 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExtensionProperties{..} f = do
     pokeFixedLengthNullTerminatedByteString ((p `plusPtr` 0 :: Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar))) (extensionName)
     poke ((p `plusPtr` 256 :: Ptr Word32)) (specVersion)
diff --git a/src/Vulkan/Core10/Fence.hs b/src/Vulkan/Core10/Fence.hs
--- a/src/Vulkan/Core10/Fence.hs
+++ b/src/Vulkan/Core10/Fence.hs
@@ -18,7 +18,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -317,7 +317,7 @@
   lift $ unless (vkResetFencesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkResetFences is null" Nothing Nothing
   let vkResetFences' = mkVkResetFences vkResetFencesPtr
-  pPFences <- ContT $ allocaBytesAligned @Fence ((Data.Vector.length (fences)) * 8) 8
+  pPFences <- ContT $ allocaBytes @Fence ((Data.Vector.length (fences)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPFences `plusPtr` (8 * (i)) :: Ptr Fence) (e)) (fences)
   r <- lift $ traceAroundEvent "vkResetFences" (vkResetFences' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (fences)) :: Word32)) (pPFences))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -443,7 +443,7 @@
   lift $ unless (vkWaitForFencesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkWaitForFences is null" Nothing Nothing
   let vkWaitForFences' = mkVkWaitForFences vkWaitForFencesPtr
-  pPFences <- ContT $ allocaBytesAligned @Fence ((Data.Vector.length (fences)) * 8) 8
+  pPFences <- ContT $ allocaBytes @Fence ((Data.Vector.length (fences)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPFences `plusPtr` (8 * (i)) :: Ptr Fence) (e)) (fences)
   r <- lift $ traceAroundEvent "vkWaitForFences" (vkWaitForFences' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (fences)) :: Word32)) (pPFences) (boolToBool32 (waitAll)) (timeout))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -612,7 +612,7 @@
     | otherwise = Nothing
 
 instance (Extendss FenceCreateInfo es, PokeChain es) => ToCStruct (FenceCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FenceCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FENCE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/FundamentalTypes.hs b/src/Vulkan/Core10/FundamentalTypes.hs
--- a/src/Vulkan/Core10/FundamentalTypes.hs
+++ b/src/Vulkan/Core10/FundamentalTypes.hs
@@ -23,7 +23,7 @@
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
 import Data.Bool (bool)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
 import Vulkan.CStruct (FromCStruct)
@@ -78,7 +78,7 @@
 deriving instance Show Offset2D
 
 instance ToCStruct Offset2D where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Offset2D{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Int32)) (x)
     poke ((p `plusPtr` 4 :: Ptr Int32)) (y)
@@ -137,7 +137,7 @@
 deriving instance Show Offset3D
 
 instance ToCStruct Offset3D where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Offset3D{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Int32)) (x)
     poke ((p `plusPtr` 4 :: Ptr Int32)) (y)
@@ -216,7 +216,7 @@
 deriving instance Show Extent2D
 
 instance ToCStruct Extent2D where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Extent2D{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (width)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (height)
@@ -277,7 +277,7 @@
 deriving instance Show Extent3D
 
 instance ToCStruct Extent3D where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Extent3D{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (width)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (height)
@@ -344,7 +344,7 @@
 deriving instance Show Rect2D
 
 instance ToCStruct Rect2D where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Rect2D{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Offset2D)) (offset)
     poke ((p `plusPtr` 8 :: Ptr Extent2D)) (extent)
diff --git a/src/Vulkan/Core10/Image.hs b/src/Vulkan/Core10/Image.hs
--- a/src/Vulkan/Core10/Image.hs
+++ b/src/Vulkan/Core10/Image.hs
@@ -15,7 +15,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1467,7 +1467,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageCreateInfo es, PokeChain es) => ToCStruct (ImageCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1483,7 +1483,7 @@
     lift $ poke ((p `plusPtr` 56 :: Ptr ImageUsageFlags)) (usage)
     lift $ poke ((p `plusPtr` 60 :: Ptr SharingMode)) (sharingMode)
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueFamilyIndices)) :: Word32))
-    pPQueueFamilyIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4) 4
+    pPQueueFamilyIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPQueueFamilyIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (queueFamilyIndices)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr Word32))) (pPQueueFamilyIndices')
     lift $ poke ((p `plusPtr` 80 :: Ptr ImageLayout)) (initialLayout)
@@ -1656,7 +1656,7 @@
 deriving instance Show SubresourceLayout
 
 instance ToCStruct SubresourceLayout where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubresourceLayout{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (offset)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (size)
diff --git a/src/Vulkan/Core10/ImageView.hs b/src/Vulkan/Core10/ImageView.hs
--- a/src/Vulkan/Core10/ImageView.hs
+++ b/src/Vulkan/Core10/ImageView.hs
@@ -18,7 +18,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -288,7 +288,7 @@
 deriving instance Show ComponentMapping
 
 instance ToCStruct ComponentMapping where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ComponentMapping{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ComponentSwizzle)) (r)
     poke ((p `plusPtr` 4 :: Ptr ComponentSwizzle)) (g)
@@ -465,7 +465,7 @@
 deriving instance Show ImageSubresourceRange
 
 instance ToCStruct ImageSubresourceRange where
-  withCStruct x f = allocaBytesAligned 20 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 20 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageSubresourceRange{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageAspectFlags)) (aspectMask)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (baseMipLevel)
@@ -1231,7 +1231,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageViewCreateInfo es, PokeChain es) => ToCStruct (ImageViewCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageViewCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/LayerDiscovery.hs b/src/Vulkan/Core10/LayerDiscovery.hs
--- a/src/Vulkan/Core10/LayerDiscovery.hs
+++ b/src/Vulkan/Core10/LayerDiscovery.hs
@@ -10,7 +10,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -258,7 +258,7 @@
 deriving instance Show LayerProperties
 
 instance ToCStruct LayerProperties where
-  withCStruct x f = allocaBytesAligned 520 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 520 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p LayerProperties{..} f = do
     pokeFixedLengthNullTerminatedByteString ((p `plusPtr` 0 :: Ptr (FixedArray MAX_EXTENSION_NAME_SIZE CChar))) (layerName)
     poke ((p `plusPtr` 256 :: Ptr Word32)) (specVersion)
diff --git a/src/Vulkan/Core10/Memory.hs b/src/Vulkan/Core10/Memory.hs
--- a/src/Vulkan/Core10/Memory.hs
+++ b/src/Vulkan/Core10/Memory.hs
@@ -19,7 +19,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -648,7 +648,7 @@
   lift $ unless (vkFlushMappedMemoryRangesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkFlushMappedMemoryRanges is null" Nothing Nothing
   let vkFlushMappedMemoryRanges' = mkVkFlushMappedMemoryRanges vkFlushMappedMemoryRangesPtr
-  pPMemoryRanges <- ContT $ allocaBytesAligned @MappedMemoryRange ((Data.Vector.length (memoryRanges)) * 40) 8
+  pPMemoryRanges <- ContT $ allocaBytes @MappedMemoryRange ((Data.Vector.length (memoryRanges)) * 40)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPMemoryRanges `plusPtr` (40 * (i)) :: Ptr MappedMemoryRange) (e)) (memoryRanges)
   r <- lift $ traceAroundEvent "vkFlushMappedMemoryRanges" (vkFlushMappedMemoryRanges' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (memoryRanges)) :: Word32)) (pPMemoryRanges))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -720,7 +720,7 @@
   lift $ unless (vkInvalidateMappedMemoryRangesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkInvalidateMappedMemoryRanges is null" Nothing Nothing
   let vkInvalidateMappedMemoryRanges' = mkVkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRangesPtr
-  pPMemoryRanges <- ContT $ allocaBytesAligned @MappedMemoryRange ((Data.Vector.length (memoryRanges)) * 40) 8
+  pPMemoryRanges <- ContT $ allocaBytes @MappedMemoryRange ((Data.Vector.length (memoryRanges)) * 40)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPMemoryRanges `plusPtr` (40 * (i)) :: Ptr MappedMemoryRange) (e)) (memoryRanges)
   r <- lift $ traceAroundEvent "vkInvalidateMappedMemoryRanges" (vkInvalidateMappedMemoryRanges' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (memoryRanges)) :: Word32)) (pPMemoryRanges))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -1204,7 +1204,7 @@
     | otherwise = Nothing
 
 instance (Extendss MemoryAllocateInfo es, PokeChain es) => ToCStruct (MemoryAllocateInfo es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryAllocateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1305,7 +1305,7 @@
 deriving instance Show MappedMemoryRange
 
 instance ToCStruct MappedMemoryRange where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MappedMemoryRange{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MAPPED_MEMORY_RANGE)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core10/MemoryManagement.hs b/src/Vulkan/Core10/MemoryManagement.hs
--- a/src/Vulkan/Core10/MemoryManagement.hs
+++ b/src/Vulkan/Core10/MemoryManagement.hs
@@ -11,7 +11,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -560,7 +560,7 @@
 deriving instance Show MemoryRequirements
 
 instance ToCStruct MemoryRequirements where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryRequirements{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (size)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (alignment)
diff --git a/src/Vulkan/Core10/OtherTypes.hs b/src/Vulkan/Core10/OtherTypes.hs
--- a/src/Vulkan/Core10/OtherTypes.hs
+++ b/src/Vulkan/Core10/OtherTypes.hs
@@ -13,7 +13,7 @@
                                  ) where
 
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Ptr (castPtr)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -108,7 +108,7 @@
 deriving instance Show MemoryBarrier
 
 instance ToCStruct MemoryBarrier where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryBarrier{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_BARRIER)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -280,7 +280,7 @@
 deriving instance Show BufferMemoryBarrier
 
 instance ToCStruct BufferMemoryBarrier where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferMemoryBarrier{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -757,7 +757,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageMemoryBarrier es, PokeChain es) => ToCStruct (ImageMemoryBarrier es) where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageMemoryBarrier{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -854,7 +854,7 @@
 deriving instance Show DrawIndirectCommand
 
 instance ToCStruct DrawIndirectCommand where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DrawIndirectCommand{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (vertexCount)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (instanceCount)
@@ -944,7 +944,7 @@
 deriving instance Show DrawIndexedIndirectCommand
 
 instance ToCStruct DrawIndexedIndirectCommand where
-  withCStruct x f = allocaBytesAligned 20 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 20 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DrawIndexedIndirectCommand{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (indexCount)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (instanceCount)
@@ -1028,7 +1028,7 @@
 deriving instance Show DispatchIndirectCommand
 
 instance ToCStruct DispatchIndirectCommand where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DispatchIndirectCommand{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (x)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (y)
diff --git a/src/Vulkan/Core10/Pass.hs b/src/Vulkan/Core10/Pass.hs
--- a/src/Vulkan/Core10/Pass.hs
+++ b/src/Vulkan/Core10/Pass.hs
@@ -37,7 +37,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -868,7 +868,7 @@
 deriving instance Show AttachmentDescription
 
 instance ToCStruct AttachmentDescription where
-  withCStruct x f = allocaBytesAligned 36 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 36 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentDescription{..} f = do
     poke ((p `plusPtr` 0 :: Ptr AttachmentDescriptionFlags)) (flags)
     poke ((p `plusPtr` 4 :: Ptr Format)) (format)
@@ -968,7 +968,7 @@
 deriving instance Show AttachmentReference
 
 instance ToCStruct AttachmentReference where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentReference{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (attachment)
     poke ((p `plusPtr` 4 :: Ptr ImageLayout)) (layout)
@@ -1331,12 +1331,12 @@
 deriving instance Show SubpassDescription
 
 instance ToCStruct SubpassDescription where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassDescription{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr SubpassDescriptionFlags)) (flags)
     lift $ poke ((p `plusPtr` 4 :: Ptr PipelineBindPoint)) (pipelineBindPoint)
     lift $ poke ((p `plusPtr` 8 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (inputAttachments)) :: Word32))
-    pPInputAttachments' <- ContT $ allocaBytesAligned @AttachmentReference ((Data.Vector.length (inputAttachments)) * 8) 4
+    pPInputAttachments' <- ContT $ allocaBytes @AttachmentReference ((Data.Vector.length (inputAttachments)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPInputAttachments' `plusPtr` (8 * (i)) :: Ptr AttachmentReference) (e)) (inputAttachments)
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr AttachmentReference))) (pPInputAttachments')
     let pColorAttachmentsLength = Data.Vector.length $ (colorAttachments)
@@ -1344,13 +1344,13 @@
     lift $ unless (fromIntegral pResolveAttachmentsLength == pColorAttachmentsLength || pResolveAttachmentsLength == 0) $
       throwIO $ IOError Nothing InvalidArgument "" "pResolveAttachments and pColorAttachments must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral pColorAttachmentsLength :: Word32))
-    pPColorAttachments' <- ContT $ allocaBytesAligned @AttachmentReference ((Data.Vector.length (colorAttachments)) * 8) 4
+    pPColorAttachments' <- ContT $ allocaBytes @AttachmentReference ((Data.Vector.length (colorAttachments)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPColorAttachments' `plusPtr` (8 * (i)) :: Ptr AttachmentReference) (e)) (colorAttachments)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr AttachmentReference))) (pPColorAttachments')
     pResolveAttachments'' <- if Data.Vector.null (resolveAttachments)
       then pure nullPtr
       else do
-        pPResolveAttachments <- ContT $ allocaBytesAligned @AttachmentReference (((Data.Vector.length (resolveAttachments))) * 8) 4
+        pPResolveAttachments <- ContT $ allocaBytes @AttachmentReference (((Data.Vector.length (resolveAttachments))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPResolveAttachments `plusPtr` (8 * (i)) :: Ptr AttachmentReference) (e)) ((resolveAttachments))
         pure $ pPResolveAttachments
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr AttachmentReference))) pResolveAttachments''
@@ -1359,7 +1359,7 @@
       Just j -> ContT $ withCStruct (j)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr AttachmentReference))) pDepthStencilAttachment''
     lift $ poke ((p `plusPtr` 56 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (preserveAttachments)) :: Word32))
-    pPPreserveAttachments' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (preserveAttachments)) * 4) 4
+    pPPreserveAttachments' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (preserveAttachments)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPreserveAttachments' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (preserveAttachments)
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr Word32))) (pPPreserveAttachments')
     lift $ f
@@ -1655,7 +1655,7 @@
 deriving instance Show SubpassDependency
 
 instance ToCStruct SubpassDependency where
-  withCStruct x f = allocaBytesAligned 28 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 28 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassDependency{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (srcSubpass)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (dstSubpass)
@@ -1928,22 +1928,22 @@
     | otherwise = Nothing
 
 instance (Extendss RenderPassCreateInfo es, PokeChain es) => ToCStruct (RenderPassCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr RenderPassCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32))
-    pPAttachments' <- ContT $ allocaBytesAligned @AttachmentDescription ((Data.Vector.length (attachments)) * 36) 4
+    pPAttachments' <- ContT $ allocaBytes @AttachmentDescription ((Data.Vector.length (attachments)) * 36)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAttachments' `plusPtr` (36 * (i)) :: Ptr AttachmentDescription) (e)) (attachments)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr AttachmentDescription))) (pPAttachments')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (subpasses)) :: Word32))
-    pPSubpasses' <- ContT $ allocaBytesAligned @SubpassDescription ((Data.Vector.length (subpasses)) * 72) 8
+    pPSubpasses' <- ContT $ allocaBytes @SubpassDescription ((Data.Vector.length (subpasses)) * 72)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPSubpasses' `plusPtr` (72 * (i)) :: Ptr SubpassDescription) (e) . ($ ())) (subpasses)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr SubpassDescription))) (pPSubpasses')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (dependencies)) :: Word32))
-    pPDependencies' <- ContT $ allocaBytesAligned @SubpassDependency ((Data.Vector.length (dependencies)) * 28) 4
+    pPDependencies' <- ContT $ allocaBytes @SubpassDependency ((Data.Vector.length (dependencies)) * 28)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDependencies' `plusPtr` (28 * (i)) :: Ptr SubpassDependency) (e)) (dependencies)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr SubpassDependency))) (pPDependencies')
     lift $ f
@@ -2517,7 +2517,7 @@
     | otherwise = Nothing
 
 instance (Extendss FramebufferCreateInfo es, PokeChain es) => ToCStruct (FramebufferCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FramebufferCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2525,7 +2525,7 @@
     lift $ poke ((p `plusPtr` 16 :: Ptr FramebufferCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 24 :: Ptr RenderPass)) (renderPass)
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32))
-    pPAttachments' <- ContT $ allocaBytesAligned @ImageView ((Data.Vector.length (attachments)) * 8) 8
+    pPAttachments' <- ContT $ allocaBytes @ImageView ((Data.Vector.length (attachments)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAttachments' `plusPtr` (8 * (i)) :: Ptr ImageView) (e)) (attachments)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr ImageView))) (pPAttachments')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) (width)
diff --git a/src/Vulkan/Core10/Pipeline.hs b/src/Vulkan/Core10/Pipeline.hs
--- a/src/Vulkan/Core10/Pipeline.hs
+++ b/src/Vulkan/Core10/Pipeline.hs
@@ -65,7 +65,7 @@
 import Control.Monad.IO.Class (liftIO)
 import Data.Foldable (traverse_)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -375,7 +375,7 @@
   lift $ unless (vkCreateGraphicsPipelinesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCreateGraphicsPipelines is null" Nothing Nothing
   let vkCreateGraphicsPipelines' = mkVkCreateGraphicsPipelines vkCreateGraphicsPipelinesPtr
-  pPCreateInfos <- ContT $ allocaBytesAligned @(GraphicsPipelineCreateInfo _) ((Data.Vector.length (createInfos)) * 144) 8
+  pPCreateInfos <- ContT $ allocaBytes @(GraphicsPipelineCreateInfo _) ((Data.Vector.length (createInfos)) * 144)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPCreateInfos `plusPtr` (144 * (i)) :: Ptr (GraphicsPipelineCreateInfo _))) (e) . ($ ())) (createInfos)
   pAllocator <- case (allocator) of
     Nothing -> pure nullPtr
@@ -504,7 +504,7 @@
   lift $ unless (vkCreateComputePipelinesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCreateComputePipelines is null" Nothing Nothing
   let vkCreateComputePipelines' = mkVkCreateComputePipelines vkCreateComputePipelinesPtr
-  pPCreateInfos <- ContT $ allocaBytesAligned @(ComputePipelineCreateInfo _) ((Data.Vector.length (createInfos)) * 96) 8
+  pPCreateInfos <- ContT $ allocaBytes @(ComputePipelineCreateInfo _) ((Data.Vector.length (createInfos)) * 96)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPCreateInfos `plusPtr` (96 * (i)) :: Ptr (ComputePipelineCreateInfo _))) (e) . ($ ())) (createInfos)
   pAllocator <- case (allocator) of
     Nothing -> pure nullPtr
@@ -719,7 +719,7 @@
 deriving instance Show Viewport
 
 instance ToCStruct Viewport where
-  withCStruct x f = allocaBytesAligned 24 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Viewport{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (x))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (y))
@@ -802,7 +802,7 @@
 deriving instance Show SpecializationMapEntry
 
 instance ToCStruct SpecializationMapEntry where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SpecializationMapEntry{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (constantID)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (offset)
@@ -881,10 +881,10 @@
 deriving instance Show SpecializationInfo
 
 instance ToCStruct SpecializationInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SpecializationInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (mapEntries)) :: Word32))
-    pPMapEntries' <- ContT $ allocaBytesAligned @SpecializationMapEntry ((Data.Vector.length (mapEntries)) * 16) 8
+    pPMapEntries' <- ContT $ allocaBytes @SpecializationMapEntry ((Data.Vector.length (mapEntries)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPMapEntries' `plusPtr` (16 * (i)) :: Ptr SpecializationMapEntry) (e)) (mapEntries)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr SpecializationMapEntry))) (pPMapEntries')
     lift $ poke ((p `plusPtr` 16 :: Ptr CSize)) (CSize (dataSize))
@@ -1199,7 +1199,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineShaderStageCreateInfo es, PokeChain es) => ToCStruct (PipelineShaderStageCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineShaderStageCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1429,7 +1429,7 @@
     | otherwise = Nothing
 
 instance (Extendss ComputePipelineCreateInfo es, PokeChain es) => ToCStruct (ComputePipelineCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ComputePipelineCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1519,7 +1519,7 @@
 deriving instance Show VertexInputBindingDescription
 
 instance ToCStruct VertexInputBindingDescription where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p VertexInputBindingDescription{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (binding)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (stride)
@@ -1615,7 +1615,7 @@
 deriving instance Show VertexInputAttributeDescription
 
 instance ToCStruct VertexInputAttributeDescription where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p VertexInputAttributeDescription{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (location)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (binding)
@@ -1744,18 +1744,18 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineVertexInputStateCreateInfo es, PokeChain es) => ToCStruct (PipelineVertexInputStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineVertexInputStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineVertexInputStateCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (vertexBindingDescriptions)) :: Word32))
-    pPVertexBindingDescriptions' <- ContT $ allocaBytesAligned @VertexInputBindingDescription ((Data.Vector.length (vertexBindingDescriptions)) * 12) 4
+    pPVertexBindingDescriptions' <- ContT $ allocaBytes @VertexInputBindingDescription ((Data.Vector.length (vertexBindingDescriptions)) * 12)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexBindingDescriptions' `plusPtr` (12 * (i)) :: Ptr VertexInputBindingDescription) (e)) (vertexBindingDescriptions)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr VertexInputBindingDescription))) (pPVertexBindingDescriptions')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (vertexAttributeDescriptions)) :: Word32))
-    pPVertexAttributeDescriptions' <- ContT $ allocaBytesAligned @VertexInputAttributeDescription ((Data.Vector.length (vertexAttributeDescriptions)) * 16) 4
+    pPVertexAttributeDescriptions' <- ContT $ allocaBytes @VertexInputAttributeDescription ((Data.Vector.length (vertexAttributeDescriptions)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexAttributeDescriptions' `plusPtr` (16 * (i)) :: Ptr VertexInputAttributeDescription) (e)) (vertexAttributeDescriptions)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr VertexInputAttributeDescription))) (pPVertexAttributeDescriptions')
     lift $ f
@@ -1886,7 +1886,7 @@
 deriving instance Show PipelineInputAssemblyStateCreateInfo
 
 instance ToCStruct PipelineInputAssemblyStateCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineInputAssemblyStateCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1980,7 +1980,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineTessellationStateCreateInfo es, PokeChain es) => ToCStruct (PipelineTessellationStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineTessellationStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2146,7 +2146,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineViewportStateCreateInfo es, PokeChain es) => ToCStruct (PipelineViewportStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2163,7 +2163,7 @@
     pViewports'' <- if Data.Vector.null (viewports)
       then pure nullPtr
       else do
-        pPViewports <- ContT $ allocaBytesAligned @Viewport (((Data.Vector.length (viewports))) * 24) 4
+        pPViewports <- ContT $ allocaBytes @Viewport (((Data.Vector.length (viewports))) * 24)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPViewports `plusPtr` (24 * (i)) :: Ptr Viewport) (e)) ((viewports))
         pure $ pPViewports
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Viewport))) pViewports''
@@ -2178,7 +2178,7 @@
     pScissors'' <- if Data.Vector.null (scissors)
       then pure nullPtr
       else do
-        pPScissors <- ContT $ allocaBytesAligned @Rect2D (((Data.Vector.length (scissors))) * 16) 4
+        pPScissors <- ContT $ allocaBytes @Rect2D (((Data.Vector.length (scissors))) * 16)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPScissors `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) ((scissors))
         pure $ pPScissors
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Rect2D))) pScissors''
@@ -2363,7 +2363,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineRasterizationStateCreateInfo es, PokeChain es) => ToCStruct (PipelineRasterizationStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2558,7 +2558,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineMultisampleStateCreateInfo es, PokeChain es) => ToCStruct (PipelineMultisampleStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineMultisampleStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2575,7 +2575,7 @@
         lift $ unless (requiredLen == fromIntegral vecLen) $
           throwIO $ IOError Nothing InvalidArgument "" "sampleMask must be either empty or contain enough bits to cover all the sample specified by 'rasterizationSamples'" Nothing Nothing
         do
-          pPSampleMask' <- ContT $ allocaBytesAligned @SampleMask ((Data.Vector.length ((sampleMask))) * 4) 4
+          pPSampleMask' <- ContT $ allocaBytes @SampleMask ((Data.Vector.length ((sampleMask))) * 4)
           lift $ Data.Vector.imapM_ (\i e -> poke (pPSampleMask' `plusPtr` (4 * (i)) :: Ptr SampleMask) (e)) ((sampleMask))
           pure $ pPSampleMask'
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr SampleMask))) pSampleMask''
@@ -2819,7 +2819,7 @@
 deriving instance Show PipelineColorBlendAttachmentState
 
 instance ToCStruct PipelineColorBlendAttachmentState where
-  withCStruct x f = allocaBytesAligned 32 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineColorBlendAttachmentState{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Bool32)) (boolToBool32 (blendEnable))
     poke ((p `plusPtr` 4 :: Ptr BlendFactor)) (srcColorBlendFactor)
@@ -2976,7 +2976,7 @@
     | otherwise = Nothing
 
 instance (Extendss PipelineColorBlendStateCreateInfo es, PokeChain es) => ToCStruct (PipelineColorBlendStateCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineColorBlendStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2985,7 +2985,7 @@
     lift $ poke ((p `plusPtr` 20 :: Ptr Bool32)) (boolToBool32 (logicOpEnable))
     lift $ poke ((p `plusPtr` 24 :: Ptr LogicOp)) (logicOp)
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32))
-    pPAttachments' <- ContT $ allocaBytesAligned @PipelineColorBlendAttachmentState ((Data.Vector.length (attachments)) * 32) 4
+    pPAttachments' <- ContT $ allocaBytes @PipelineColorBlendAttachmentState ((Data.Vector.length (attachments)) * 32)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAttachments' `plusPtr` (32 * (i)) :: Ptr PipelineColorBlendAttachmentState) (e)) (attachments)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr PipelineColorBlendAttachmentState))) (pPAttachments')
     let pBlendConstants' = lowerArrayPtr ((p `plusPtr` 40 :: Ptr (FixedArray 4 CFloat)))
@@ -3089,13 +3089,13 @@
 deriving instance Show PipelineDynamicStateCreateInfo
 
 instance ToCStruct PipelineDynamicStateCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineDynamicStateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineDynamicStateCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (dynamicStates)) :: Word32))
-    pPDynamicStates' <- ContT $ allocaBytesAligned @DynamicState ((Data.Vector.length (dynamicStates)) * 4) 4
+    pPDynamicStates' <- ContT $ allocaBytes @DynamicState ((Data.Vector.length (dynamicStates)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDynamicStates' `plusPtr` (4 * (i)) :: Ptr DynamicState) (e)) (dynamicStates)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DynamicState))) (pPDynamicStates')
     lift $ f
@@ -3174,7 +3174,7 @@
 deriving instance Show StencilOpState
 
 instance ToCStruct StencilOpState where
-  withCStruct x f = allocaBytesAligned 28 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 28 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p StencilOpState{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StencilOp)) (failOp)
     poke ((p `plusPtr` 4 :: Ptr StencilOp)) (passOp)
@@ -3318,7 +3318,7 @@
 deriving instance Show PipelineDepthStencilStateCreateInfo
 
 instance ToCStruct PipelineDepthStencilStateCreateInfo where
-  withCStruct x f = allocaBytesAligned 104 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 104 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineDepthStencilStateCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -4683,14 +4683,14 @@
     | otherwise = Nothing
 
 instance (Extendss GraphicsPipelineCreateInfo es, PokeChain es) => ToCStruct (GraphicsPipelineCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 144 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 144 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GraphicsPipelineCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (stages)) :: Word32))
-    pPStages' <- ContT $ allocaBytesAligned @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48) 8
+    pPStages' <- ContT $ allocaBytes @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPStages' `plusPtr` (48 * (i)) :: Ptr (PipelineShaderStageCreateInfo _))) (e) . ($ ())) (stages)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (PipelineShaderStageCreateInfo _)))) (pPStages')
     pVertexInputState'' <- case (vertexInputState) of
diff --git a/src/Vulkan/Core10/PipelineCache.hs b/src/Vulkan/Core10/PipelineCache.hs
--- a/src/Vulkan/Core10/PipelineCache.hs
+++ b/src/Vulkan/Core10/PipelineCache.hs
@@ -15,7 +15,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -446,7 +446,7 @@
   lift $ unless (vkMergePipelineCachesPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkMergePipelineCaches is null" Nothing Nothing
   let vkMergePipelineCaches' = mkVkMergePipelineCaches vkMergePipelineCachesPtr
-  pPSrcCaches <- ContT $ allocaBytesAligned @PipelineCache ((Data.Vector.length (srcCaches)) * 8) 8
+  pPSrcCaches <- ContT $ allocaBytes @PipelineCache ((Data.Vector.length (srcCaches)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPSrcCaches `plusPtr` (8 * (i)) :: Ptr PipelineCache) (e)) (srcCaches)
   r <- lift $ traceAroundEvent "vkMergePipelineCaches" (vkMergePipelineCaches' (deviceHandle (device)) (dstCache) ((fromIntegral (Data.Vector.length $ (srcCaches)) :: Word32)) (pPSrcCaches))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -514,7 +514,7 @@
 deriving instance Show PipelineCacheCreateInfo
 
 instance ToCStruct PipelineCacheCreateInfo where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCacheCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core10/PipelineLayout.hs b/src/Vulkan/Core10/PipelineLayout.hs
--- a/src/Vulkan/Core10/PipelineLayout.hs
+++ b/src/Vulkan/Core10/PipelineLayout.hs
@@ -12,7 +12,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -275,7 +275,7 @@
 deriving instance Show PushConstantRange
 
 instance ToCStruct PushConstantRange where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PushConstantRange{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ShaderStageFlags)) (stageFlags)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (offset)
@@ -722,17 +722,17 @@
 deriving instance Show PipelineLayoutCreateInfo
 
 instance ToCStruct PipelineLayoutCreateInfo where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineLayoutCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineLayoutCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (setLayouts)) :: Word32))
-    pPSetLayouts' <- ContT $ allocaBytesAligned @DescriptorSetLayout ((Data.Vector.length (setLayouts)) * 8) 8
+    pPSetLayouts' <- ContT $ allocaBytes @DescriptorSetLayout ((Data.Vector.length (setLayouts)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSetLayouts' `plusPtr` (8 * (i)) :: Ptr DescriptorSetLayout) (e)) (setLayouts)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DescriptorSetLayout))) (pPSetLayouts')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (pushConstantRanges)) :: Word32))
-    pPPushConstantRanges' <- ContT $ allocaBytesAligned @PushConstantRange ((Data.Vector.length (pushConstantRanges)) * 12) 4
+    pPPushConstantRanges' <- ContT $ allocaBytes @PushConstantRange ((Data.Vector.length (pushConstantRanges)) * 12)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPushConstantRanges' `plusPtr` (12 * (i)) :: Ptr PushConstantRange) (e)) (pushConstantRanges)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr PushConstantRange))) (pPPushConstantRanges')
     lift $ f
diff --git a/src/Vulkan/Core10/Query.hs b/src/Vulkan/Core10/Query.hs
--- a/src/Vulkan/Core10/Query.hs
+++ b/src/Vulkan/Core10/Query.hs
@@ -19,7 +19,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -583,7 +583,7 @@
     | otherwise = Nothing
 
 instance (Extendss QueryPoolCreateInfo es, PokeChain es) => ToCStruct (QueryPoolCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueryPoolCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/Queue.hs b/src/Vulkan/Core10/Queue.hs
--- a/src/Vulkan/Core10/Queue.hs
+++ b/src/Vulkan/Core10/Queue.hs
@@ -17,7 +17,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -409,7 +409,7 @@
   lift $ unless (vkQueueSubmitPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkQueueSubmit is null" Nothing Nothing
   let vkQueueSubmit' = mkVkQueueSubmit vkQueueSubmitPtr
-  pPSubmits <- ContT $ allocaBytesAligned @(SubmitInfo _) ((Data.Vector.length (submits)) * 72) 8
+  pPSubmits <- ContT $ allocaBytes @(SubmitInfo _) ((Data.Vector.length (submits)) * 72)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPSubmits `plusPtr` (72 * (i)) :: Ptr (SubmitInfo _))) (e) . ($ ())) (submits)
   r <- lift $ traceAroundEvent "vkQueueSubmit" (vkQueueSubmit' (queueHandle (queue)) ((fromIntegral (Data.Vector.length $ (submits)) :: Word32)) (forgetExtensions (pPSubmits)) (fence))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -798,7 +798,7 @@
     | otherwise = Nothing
 
 instance (Extendss SubmitInfo es, PokeChain es) => ToCStruct (SubmitInfo es) where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubmitInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBMIT_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -807,18 +807,18 @@
     lift $ unless ((Data.Vector.length $ (waitDstStageMask)) == pWaitSemaphoresLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pWaitDstStageMask and pWaitSemaphores must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral pWaitSemaphoresLength :: Word32))
-    pPWaitSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (waitSemaphores)) * 8) 8
+    pPWaitSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (waitSemaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (waitSemaphores)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Semaphore))) (pPWaitSemaphores')
-    pPWaitDstStageMask' <- ContT $ allocaBytesAligned @PipelineStageFlags ((Data.Vector.length (waitDstStageMask)) * 4) 4
+    pPWaitDstStageMask' <- ContT $ allocaBytes @PipelineStageFlags ((Data.Vector.length (waitDstStageMask)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitDstStageMask' `plusPtr` (4 * (i)) :: Ptr PipelineStageFlags) (e)) (waitDstStageMask)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr PipelineStageFlags))) (pPWaitDstStageMask')
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (commandBuffers)) :: Word32))
-    pPCommandBuffers' <- ContT $ allocaBytesAligned @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8) 8
+    pPCommandBuffers' <- ContT $ allocaBytes @(Ptr CommandBuffer_T) ((Data.Vector.length (commandBuffers)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCommandBuffers' `plusPtr` (8 * (i)) :: Ptr (Ptr CommandBuffer_T)) (e)) (commandBuffers)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr (Ptr CommandBuffer_T)))) (pPCommandBuffers')
     lift $ poke ((p `plusPtr` 56 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (signalSemaphores)) :: Word32))
-    pPSignalSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (signalSemaphores)) * 8) 8
+    pPSignalSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (signalSemaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (signalSemaphores)
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr Semaphore))) (pPSignalSemaphores')
     lift $ f
diff --git a/src/Vulkan/Core10/QueueSemaphore.hs b/src/Vulkan/Core10/QueueSemaphore.hs
--- a/src/Vulkan/Core10/QueueSemaphore.hs
+++ b/src/Vulkan/Core10/QueueSemaphore.hs
@@ -13,7 +13,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -274,7 +274,7 @@
     | otherwise = Nothing
 
 instance (Extendss SemaphoreCreateInfo es, PokeChain es) => ToCStruct (SemaphoreCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/Sampler.hs b/src/Vulkan/Core10/Sampler.hs
--- a/src/Vulkan/Core10/Sampler.hs
+++ b/src/Vulkan/Core10/Sampler.hs
@@ -18,7 +18,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -652,7 +652,7 @@
     | otherwise = Nothing
 
 instance (Extendss SamplerCreateInfo es, PokeChain es) => ToCStruct (SamplerCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core10/Shader.hs b/src/Vulkan/Core10/Shader.hs
--- a/src/Vulkan/Core10/Shader.hs
+++ b/src/Vulkan/Core10/Shader.hs
@@ -15,7 +15,7 @@
 import Control.Monad.IO.Class (liftIO)
 import Data.Bits ((.&.))
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (copyBytes)
@@ -360,7 +360,7 @@
     | otherwise = Nothing
 
 instance (Extendss ShaderModuleCreateInfo es, PokeChain es) => ToCStruct (ShaderModuleCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ShaderModuleCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -376,7 +376,7 @@
       -- Otherwise allocate and copy the bytes
       else do
         let len = Data.ByteString.length (code)
-        mem <- ContT $ allocaBytesAligned @Word32 len 4
+        mem <- ContT $ allocaBytes @Word32 len
         lift $ copyBytes mem (castPtr @CChar @Word32 unalignedCode) len
         pure mem
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Word32))) pCode''
diff --git a/src/Vulkan/Core10/SparseResourceMemoryManagement.hs b/src/Vulkan/Core10/SparseResourceMemoryManagement.hs
--- a/src/Vulkan/Core10/SparseResourceMemoryManagement.hs
+++ b/src/Vulkan/Core10/SparseResourceMemoryManagement.hs
@@ -25,7 +25,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -490,7 +490,7 @@
   lift $ unless (vkQueueBindSparsePtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkQueueBindSparse is null" Nothing Nothing
   let vkQueueBindSparse' = mkVkQueueBindSparse vkQueueBindSparsePtr
-  pPBindInfo <- ContT $ allocaBytesAligned @(BindSparseInfo _) ((Data.Vector.length (bindInfo)) * 96) 8
+  pPBindInfo <- ContT $ allocaBytes @(BindSparseInfo _) ((Data.Vector.length (bindInfo)) * 96)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPBindInfo `plusPtr` (96 * (i)) :: Ptr (BindSparseInfo _))) (e) . ($ ())) (bindInfo)
   r <- lift $ traceAroundEvent "vkQueueBindSparse" (vkQueueBindSparse' (queueHandle (queue)) ((fromIntegral (Data.Vector.length $ (bindInfo)) :: Word32)) (forgetExtensions (pPBindInfo)) (fence))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -527,7 +527,7 @@
 deriving instance Show SparseImageFormatProperties
 
 instance ToCStruct SparseImageFormatProperties where
-  withCStruct x f = allocaBytesAligned 20 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 20 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageFormatProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageAspectFlags)) (aspectMask)
     poke ((p `plusPtr` 4 :: Ptr Extent3D)) (imageGranularity)
@@ -598,7 +598,7 @@
 deriving instance Show SparseImageMemoryRequirements
 
 instance ToCStruct SparseImageMemoryRequirements where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageMemoryRequirements{..} f = do
     poke ((p `plusPtr` 0 :: Ptr SparseImageFormatProperties)) (formatProperties)
     poke ((p `plusPtr` 20 :: Ptr Word32)) (imageMipTailFirstLod)
@@ -673,7 +673,7 @@
 deriving instance Show ImageSubresource
 
 instance ToCStruct ImageSubresource where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageSubresource{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageAspectFlags)) (aspectMask)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (mipLevel)
@@ -825,7 +825,7 @@
 deriving instance Show SparseMemoryBind
 
 instance ToCStruct SparseMemoryBind where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseMemoryBind{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceSize)) (resourceOffset)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (size)
@@ -982,7 +982,7 @@
 deriving instance Show SparseImageMemoryBind
 
 instance ToCStruct SparseImageMemoryBind where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageMemoryBind{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageSubresource)) (subresource)
     poke ((p `plusPtr` 12 :: Ptr Offset3D)) (offset)
@@ -1055,11 +1055,11 @@
 deriving instance Show SparseBufferMemoryBindInfo
 
 instance ToCStruct SparseBufferMemoryBindInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseBufferMemoryBindInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Buffer)) (buffer)
     lift $ poke ((p `plusPtr` 8 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (binds)) :: Word32))
-    pPBinds' <- ContT $ allocaBytesAligned @SparseMemoryBind ((Data.Vector.length (binds)) * 40) 8
+    pPBinds' <- ContT $ allocaBytes @SparseMemoryBind ((Data.Vector.length (binds)) * 40)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPBinds' `plusPtr` (40 * (i)) :: Ptr SparseMemoryBind) (e)) (binds)
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr SparseMemoryBind))) (pPBinds')
     lift $ f
@@ -1123,11 +1123,11 @@
 deriving instance Show SparseImageOpaqueMemoryBindInfo
 
 instance ToCStruct SparseImageOpaqueMemoryBindInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageOpaqueMemoryBindInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Image)) (image)
     lift $ poke ((p `plusPtr` 8 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (binds)) :: Word32))
-    pPBinds' <- ContT $ allocaBytesAligned @SparseMemoryBind ((Data.Vector.length (binds)) * 40) 8
+    pPBinds' <- ContT $ allocaBytes @SparseMemoryBind ((Data.Vector.length (binds)) * 40)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPBinds' `plusPtr` (40 * (i)) :: Ptr SparseMemoryBind) (e)) (binds)
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr SparseMemoryBind))) (pPBinds')
     lift $ f
@@ -1200,11 +1200,11 @@
 deriving instance Show SparseImageMemoryBindInfo
 
 instance ToCStruct SparseImageMemoryBindInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageMemoryBindInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Image)) (image)
     lift $ poke ((p `plusPtr` 8 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (binds)) :: Word32))
-    pPBinds' <- ContT $ allocaBytesAligned @SparseImageMemoryBind ((Data.Vector.length (binds)) * 64) 8
+    pPBinds' <- ContT $ allocaBytes @SparseImageMemoryBind ((Data.Vector.length (binds)) * 64)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPBinds' `plusPtr` (64 * (i)) :: Ptr SparseImageMemoryBind) (e)) (binds)
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr SparseImageMemoryBind))) (pPBinds')
     lift $ f
@@ -1381,29 +1381,29 @@
     | otherwise = Nothing
 
 instance (Extendss BindSparseInfo es, PokeChain es) => ToCStruct (BindSparseInfo es) where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindSparseInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_SPARSE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (waitSemaphores)) :: Word32))
-    pPWaitSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (waitSemaphores)) * 8) 8
+    pPWaitSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (waitSemaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (waitSemaphores)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Semaphore))) (pPWaitSemaphores')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (bufferBinds)) :: Word32))
-    pPBufferBinds' <- ContT $ allocaBytesAligned @SparseBufferMemoryBindInfo ((Data.Vector.length (bufferBinds)) * 24) 8
+    pPBufferBinds' <- ContT $ allocaBytes @SparseBufferMemoryBindInfo ((Data.Vector.length (bufferBinds)) * 24)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPBufferBinds' `plusPtr` (24 * (i)) :: Ptr SparseBufferMemoryBindInfo) (e) . ($ ())) (bufferBinds)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr SparseBufferMemoryBindInfo))) (pPBufferBinds')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (imageOpaqueBinds)) :: Word32))
-    pPImageOpaqueBinds' <- ContT $ allocaBytesAligned @SparseImageOpaqueMemoryBindInfo ((Data.Vector.length (imageOpaqueBinds)) * 24) 8
+    pPImageOpaqueBinds' <- ContT $ allocaBytes @SparseImageOpaqueMemoryBindInfo ((Data.Vector.length (imageOpaqueBinds)) * 24)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPImageOpaqueBinds' `plusPtr` (24 * (i)) :: Ptr SparseImageOpaqueMemoryBindInfo) (e) . ($ ())) (imageOpaqueBinds)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr SparseImageOpaqueMemoryBindInfo))) (pPImageOpaqueBinds')
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (imageBinds)) :: Word32))
-    pPImageBinds' <- ContT $ allocaBytesAligned @SparseImageMemoryBindInfo ((Data.Vector.length (imageBinds)) * 24) 8
+    pPImageBinds' <- ContT $ allocaBytes @SparseImageMemoryBindInfo ((Data.Vector.length (imageBinds)) * 24)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPImageBinds' `plusPtr` (24 * (i)) :: Ptr SparseImageMemoryBindInfo) (e) . ($ ())) (imageBinds)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr SparseImageMemoryBindInfo))) (pPImageBinds')
     lift $ poke ((p `plusPtr` 80 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (signalSemaphores)) :: Word32))
-    pPSignalSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (signalSemaphores)) * 8) 8
+    pPSignalSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (signalSemaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (signalSemaphores)
     lift $ poke ((p `plusPtr` 88 :: Ptr (Ptr Semaphore))) (pPSignalSemaphores')
     lift $ f
diff --git a/src/Vulkan/Core11/Originally_Based_On_VK_KHR_protected_memory.hs b/src/Vulkan/Core11/Originally_Based_On_VK_KHR_protected_memory.hs
--- a/src/Vulkan/Core11/Originally_Based_On_VK_KHR_protected_memory.hs
+++ b/src/Vulkan/Core11/Originally_Based_On_VK_KHR_protected_memory.hs
@@ -24,7 +24,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.IO (throwIO)
@@ -156,7 +156,7 @@
 deriving instance Show ProtectedSubmitInfo
 
 instance ToCStruct ProtectedSubmitInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ProtectedSubmitInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -223,7 +223,7 @@
 deriving instance Show PhysicalDeviceProtectedMemoryFeatures
 
 instance ToCStruct PhysicalDeviceProtectedMemoryFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProtectedMemoryFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -287,7 +287,7 @@
 deriving instance Show PhysicalDeviceProtectedMemoryProperties
 
 instance ToCStruct PhysicalDeviceProtectedMemoryProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProtectedMemoryProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -371,7 +371,7 @@
 deriving instance Show DeviceQueueInfo2
 
 instance ToCStruct DeviceQueueInfo2 where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceQueueInfo2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Originally_Based_On_VK_KHR_subgroup.hs b/src/Vulkan/Core11/Originally_Based_On_VK_KHR_subgroup.hs
--- a/src/Vulkan/Core11/Originally_Based_On_VK_KHR_subgroup.hs
+++ b/src/Vulkan/Core11/Originally_Based_On_VK_KHR_subgroup.hs
@@ -6,7 +6,7 @@
                                                           , SubgroupFeatureFlags
                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -105,7 +105,7 @@
 deriving instance Show PhysicalDeviceSubgroupProperties
 
 instance ToCStruct PhysicalDeviceSubgroupProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSubgroupProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_16bit_storage.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_16bit_storage.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_16bit_storage.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_16bit_storage.hs
@@ -4,7 +4,7 @@
                                                          , StructureType(..)
                                                          ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -91,7 +91,7 @@
 deriving instance Show PhysicalDevice16BitStorageFeatures
 
 instance ToCStruct PhysicalDevice16BitStorageFeatures where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevice16BitStorageFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_bind_memory2.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_bind_memory2.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_bind_memory2.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_bind_memory2.hs
@@ -13,7 +13,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (castPtr)
@@ -128,7 +128,7 @@
   lift $ unless (vkBindBufferMemory2Ptr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkBindBufferMemory2 is null" Nothing Nothing
   let vkBindBufferMemory2' = mkVkBindBufferMemory2 vkBindBufferMemory2Ptr
-  pPBindInfos <- ContT $ allocaBytesAligned @(BindBufferMemoryInfo _) ((Data.Vector.length (bindInfos)) * 40) 8
+  pPBindInfos <- ContT $ allocaBytes @(BindBufferMemoryInfo _) ((Data.Vector.length (bindInfos)) * 40)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPBindInfos `plusPtr` (40 * (i)) :: Ptr (BindBufferMemoryInfo _))) (e) . ($ ())) (bindInfos)
   r <- lift $ traceAroundEvent "vkBindBufferMemory2" (vkBindBufferMemory2' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (bindInfos)) :: Word32)) (forgetExtensions (pPBindInfos)))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -199,7 +199,7 @@
   lift $ unless (vkBindImageMemory2Ptr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkBindImageMemory2 is null" Nothing Nothing
   let vkBindImageMemory2' = mkVkBindImageMemory2 vkBindImageMemory2Ptr
-  pPBindInfos <- ContT $ allocaBytesAligned @(BindImageMemoryInfo _) ((Data.Vector.length (bindInfos)) * 40) 8
+  pPBindInfos <- ContT $ allocaBytes @(BindImageMemoryInfo _) ((Data.Vector.length (bindInfos)) * 40)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPBindInfos `plusPtr` (40 * (i)) :: Ptr (BindImageMemoryInfo _))) (e) . ($ ())) (bindInfos)
   r <- lift $ traceAroundEvent "vkBindImageMemory2" (vkBindImageMemory2' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (bindInfos)) :: Word32)) (forgetExtensions (pPBindInfos)))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -382,7 +382,7 @@
     | otherwise = Nothing
 
 instance (Extendss BindBufferMemoryInfo es, PokeChain es) => ToCStruct (BindBufferMemoryInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindBufferMemoryInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -722,7 +722,7 @@
     | otherwise = Nothing
 
 instance (Extendss BindImageMemoryInfo es, PokeChain es) => ToCStruct (BindImageMemoryInfo es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindImageMemoryInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_dedicated_allocation.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_dedicated_allocation.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_dedicated_allocation.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_dedicated_allocation.hs
@@ -5,7 +5,7 @@
                                                                 , StructureType(..)
                                                                 ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -124,7 +124,7 @@
 deriving instance Show MemoryDedicatedRequirements
 
 instance ToCStruct MemoryDedicatedRequirements where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryDedicatedRequirements{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -307,7 +307,7 @@
 deriving instance Show MemoryDedicatedAllocateInfo
 
 instance ToCStruct MemoryDedicatedAllocateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryDedicatedAllocateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_descriptor_update_template.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_descriptor_update_template.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_descriptor_update_template.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_descriptor_update_template.hs
@@ -17,7 +17,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -489,7 +489,7 @@
 deriving instance Show DescriptorUpdateTemplateEntry
 
 instance ToCStruct DescriptorUpdateTemplateEntry where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorUpdateTemplateEntry{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (dstBinding)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (dstArrayElement)
@@ -660,13 +660,13 @@
 deriving instance Show DescriptorUpdateTemplateCreateInfo
 
 instance ToCStruct DescriptorUpdateTemplateCreateInfo where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorUpdateTemplateCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr DescriptorUpdateTemplateCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (descriptorUpdateEntries)) :: Word32))
-    pPDescriptorUpdateEntries' <- ContT $ allocaBytesAligned @DescriptorUpdateTemplateEntry ((Data.Vector.length (descriptorUpdateEntries)) * 32) 8
+    pPDescriptorUpdateEntries' <- ContT $ allocaBytes @DescriptorUpdateTemplateEntry ((Data.Vector.length (descriptorUpdateEntries)) * 32)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorUpdateEntries' `plusPtr` (32 * (i)) :: Ptr DescriptorUpdateTemplateEntry) (e)) (descriptorUpdateEntries)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DescriptorUpdateTemplateEntry))) (pPDescriptorUpdateEntries')
     lift $ poke ((p `plusPtr` 32 :: Ptr DescriptorUpdateTemplateType)) (templateType)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group.hs
@@ -24,7 +24,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.IO (throwIO)
@@ -669,7 +669,7 @@
 deriving instance Show MemoryAllocateFlagsInfo
 
 instance ToCStruct MemoryAllocateFlagsInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryAllocateFlagsInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -780,13 +780,13 @@
 deriving instance Show DeviceGroupRenderPassBeginInfo
 
 instance ToCStruct DeviceGroupRenderPassBeginInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupRenderPassBeginInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) (deviceMask)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (deviceRenderAreas)) :: Word32))
-    pPDeviceRenderAreas' <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (deviceRenderAreas)) * 16) 4
+    pPDeviceRenderAreas' <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (deviceRenderAreas)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDeviceRenderAreas' `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (deviceRenderAreas)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Rect2D))) (pPDeviceRenderAreas')
     lift $ f
@@ -846,7 +846,7 @@
 deriving instance Show DeviceGroupCommandBufferBeginInfo
 
 instance ToCStruct DeviceGroupCommandBufferBeginInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupCommandBufferBeginInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -954,20 +954,20 @@
 deriving instance Show DeviceGroupSubmitInfo
 
 instance ToCStruct DeviceGroupSubmitInfo where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupSubmitInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (waitSemaphoreDeviceIndices)) :: Word32))
-    pPWaitSemaphoreDeviceIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (waitSemaphoreDeviceIndices)) * 4) 4
+    pPWaitSemaphoreDeviceIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (waitSemaphoreDeviceIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphoreDeviceIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (waitSemaphoreDeviceIndices)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPWaitSemaphoreDeviceIndices')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (commandBufferDeviceMasks)) :: Word32))
-    pPCommandBufferDeviceMasks' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (commandBufferDeviceMasks)) * 4) 4
+    pPCommandBufferDeviceMasks' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (commandBufferDeviceMasks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCommandBufferDeviceMasks' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (commandBufferDeviceMasks)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Word32))) (pPCommandBufferDeviceMasks')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (signalSemaphoreDeviceIndices)) :: Word32))
-    pPSignalSemaphoreDeviceIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (signalSemaphoreDeviceIndices)) * 4) 4
+    pPSignalSemaphoreDeviceIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (signalSemaphoreDeviceIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphoreDeviceIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (signalSemaphoreDeviceIndices)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr Word32))) (pPSignalSemaphoreDeviceIndices')
     lift $ f
@@ -1045,7 +1045,7 @@
 deriving instance Show DeviceGroupBindSparseInfo
 
 instance ToCStruct DeviceGroupBindSparseInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupBindSparseInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_groupAndVK_KHR_bind_memory2.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_groupAndVK_KHR_bind_memory2.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_groupAndVK_KHR_bind_memory2.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_groupAndVK_KHR_bind_memory2.hs
@@ -7,7 +7,7 @@
                                                                               , ImageCreateFlags
                                                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -99,12 +99,12 @@
 deriving instance Show BindBufferMemoryDeviceGroupInfo
 
 instance ToCStruct BindBufferMemoryDeviceGroupInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindBufferMemoryDeviceGroupInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (deviceIndices)) :: Word32))
-    pPDeviceIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (deviceIndices)) * 4) 4
+    pPDeviceIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (deviceIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDeviceIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (deviceIndices)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPDeviceIndices')
     lift $ f
@@ -251,16 +251,16 @@
 deriving instance Show BindImageMemoryDeviceGroupInfo
 
 instance ToCStruct BindImageMemoryDeviceGroupInfo where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindImageMemoryDeviceGroupInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (deviceIndices)) :: Word32))
-    pPDeviceIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (deviceIndices)) * 4) 4
+    pPDeviceIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (deviceIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDeviceIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (deviceIndices)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPDeviceIndices')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (splitInstanceBindRegions)) :: Word32))
-    pPSplitInstanceBindRegions' <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (splitInstanceBindRegions)) * 16) 4
+    pPSplitInstanceBindRegions' <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (splitInstanceBindRegions)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSplitInstanceBindRegions' `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (splitInstanceBindRegions)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Rect2D))) (pPSplitInstanceBindRegions')
     lift $ f
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group_creation.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group_creation.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group_creation.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_device_group_creation.hs
@@ -15,7 +15,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -197,7 +197,7 @@
 deriving instance Show PhysicalDeviceGroupProperties
 
 instance ToCStruct PhysicalDeviceGroupProperties where
-  withCStruct x f = allocaBytesAligned 288 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 288 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceGroupProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -296,12 +296,12 @@
 deriving instance Show DeviceGroupDeviceCreateInfo
 
 instance ToCStruct DeviceGroupDeviceCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupDeviceCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (physicalDevices)) :: Word32))
-    pPPhysicalDevices' <- ContT $ allocaBytesAligned @(Ptr PhysicalDevice_T) ((Data.Vector.length (physicalDevices)) * 8) 8
+    pPPhysicalDevices' <- ContT $ allocaBytes @(Ptr PhysicalDevice_T) ((Data.Vector.length (physicalDevices)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPhysicalDevices' `plusPtr` (8 * (i)) :: Ptr (Ptr PhysicalDevice_T)) (e)) (physicalDevices)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (Ptr PhysicalDevice_T)))) (pPPhysicalDevices')
     lift $ f
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence.hs
@@ -6,7 +6,7 @@
                                                           , FenceImportFlags
                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -65,7 +65,7 @@
 deriving instance Show ExportFenceCreateInfo
 
 instance ToCStruct ExportFenceCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportFenceCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence_capabilities.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence_capabilities.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence_capabilities.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_fence_capabilities.hs
@@ -13,7 +13,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -141,7 +141,7 @@
 deriving instance Show PhysicalDeviceExternalFenceInfo
 
 instance ToCStruct PhysicalDeviceExternalFenceInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExternalFenceInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -212,7 +212,7 @@
 deriving instance Show ExternalFenceProperties
 
 instance ToCStruct ExternalFenceProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalFenceProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory.hs
@@ -9,7 +9,7 @@
                                                            , pattern QUEUE_FAMILY_EXTERNAL
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -68,7 +68,7 @@
 deriving instance Show ExternalMemoryImageCreateInfo
 
 instance ToCStruct ExternalMemoryImageCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalMemoryImageCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -132,7 +132,7 @@
 deriving instance Show ExternalMemoryBufferCreateInfo
 
 instance ToCStruct ExternalMemoryBufferCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalMemoryBufferCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -201,7 +201,7 @@
 deriving instance Show ExportMemoryAllocateInfo
 
 instance ToCStruct ExportMemoryAllocateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportMemoryAllocateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory_capabilities.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory_capabilities.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory_capabilities.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_memory_capabilities.hs
@@ -20,7 +20,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -166,7 +166,7 @@
 deriving instance Show ExternalMemoryProperties
 
 instance ToCStruct ExternalMemoryProperties where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalMemoryProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ExternalMemoryFeatureFlags)) (externalMemoryFeatures)
     poke ((p `plusPtr` 4 :: Ptr ExternalMemoryHandleTypeFlags)) (exportFromImportedHandleTypes)
@@ -245,7 +245,7 @@
 deriving instance Show PhysicalDeviceExternalImageFormatInfo
 
 instance ToCStruct PhysicalDeviceExternalImageFormatInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExternalImageFormatInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -296,7 +296,7 @@
 deriving instance Show ExternalImageFormatProperties
 
 instance ToCStruct ExternalImageFormatProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalImageFormatProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -380,7 +380,7 @@
 deriving instance Show PhysicalDeviceExternalBufferInfo
 
 instance ToCStruct PhysicalDeviceExternalBufferInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExternalBufferInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -441,7 +441,7 @@
 deriving instance Show ExternalBufferProperties
 
 instance ToCStruct ExternalBufferProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalBufferProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -615,7 +615,7 @@
 deriving instance Show PhysicalDeviceIDProperties
 
 instance ToCStruct PhysicalDeviceIDProperties where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceIDProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore.hs
@@ -6,7 +6,7 @@
                                                               , SemaphoreImportFlags
                                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -65,7 +65,7 @@
 deriving instance Show ExportSemaphoreCreateInfo
 
 instance ToCStruct ExportSemaphoreCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportSemaphoreCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore_capabilities.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore_capabilities.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore_capabilities.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_external_semaphore_capabilities.hs
@@ -14,7 +14,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (castPtr)
 import GHC.Ptr (nullFunPtr)
@@ -166,7 +166,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceExternalSemaphoreInfo es, PokeChain es) => ToCStruct (PhysicalDeviceExternalSemaphoreInfo es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExternalSemaphoreInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -237,7 +237,7 @@
 deriving instance Show ExternalSemaphoreProperties
 
 instance ToCStruct ExternalSemaphoreProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalSemaphoreProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_get_memory_requirements2.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_get_memory_requirements2.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_get_memory_requirements2.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_get_memory_requirements2.hs
@@ -16,7 +16,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.IO (throwIO)
@@ -246,7 +246,7 @@
 deriving instance Show BufferMemoryRequirementsInfo2
 
 instance ToCStruct BufferMemoryRequirementsInfo2 where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferMemoryRequirementsInfo2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -363,7 +363,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageMemoryRequirementsInfo2 es, PokeChain es) => ToCStruct (ImageMemoryRequirementsInfo2 es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageMemoryRequirementsInfo2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -416,7 +416,7 @@
 deriving instance Show ImageSparseMemoryRequirementsInfo2
 
 instance ToCStruct ImageSparseMemoryRequirementsInfo2 where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageSparseMemoryRequirementsInfo2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -495,7 +495,7 @@
     | otherwise = Nothing
 
 instance (Extendss MemoryRequirements2 es, PokeChain es) => ToCStruct (MemoryRequirements2 es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryRequirements2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -547,7 +547,7 @@
 deriving instance Show SparseImageMemoryRequirements2
 
 instance ToCStruct SparseImageMemoryRequirements2 where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageMemoryRequirements2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_get_physical_device_properties2.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_get_physical_device_properties2.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_get_physical_device_properties2.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_get_physical_device_properties2.hs
@@ -24,7 +24,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -778,7 +778,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceFeatures2 es, PokeChain es) => ToCStruct (PhysicalDeviceFeatures2 es) where
-  withCStruct x f = allocaBytesAligned 240 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 240 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFeatures2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -960,7 +960,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceProperties2 es, PokeChain es) => ToCStruct (PhysicalDeviceProperties2 es) where
-  withCStruct x f = allocaBytesAligned 840 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 840 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProperties2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1038,7 +1038,7 @@
     | otherwise = Nothing
 
 instance (Extendss FormatProperties2 es, PokeChain es) => ToCStruct (FormatProperties2 es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FormatProperties2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FORMAT_PROPERTIES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1142,7 +1142,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageFormatProperties2 es, PokeChain es) => ToCStruct (ImageFormatProperties2 es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageFormatProperties2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1297,7 +1297,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceImageFormatInfo2 es, PokeChain es) => ToCStruct (PhysicalDeviceImageFormatInfo2 es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceImageFormatInfo2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1395,7 +1395,7 @@
     | otherwise = Nothing
 
 instance (Extendss QueueFamilyProperties2 es, PokeChain es) => ToCStruct (QueueFamilyProperties2 es) where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueueFamilyProperties2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1472,7 +1472,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceMemoryProperties2 es, PokeChain es) => ToCStruct (PhysicalDeviceMemoryProperties2 es) where
-  withCStruct x f = allocaBytesAligned 536 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 536 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMemoryProperties2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1526,7 +1526,7 @@
 deriving instance Show SparseImageFormatProperties2
 
 instance ToCStruct SparseImageFormatProperties2 where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SparseImageFormatProperties2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1622,7 +1622,7 @@
 deriving instance Show PhysicalDeviceSparseImageFormatInfo2
 
 instance ToCStruct PhysicalDeviceSparseImageFormatInfo2 where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSparseImageFormatInfo2{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance2.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance2.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance2.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance2.hs
@@ -13,7 +13,7 @@
                                                         , TessellationDomainOrigin(..)
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -104,7 +104,7 @@
 deriving instance Show InputAttachmentAspectReference
 
 instance ToCStruct InputAttachmentAspectReference where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p InputAttachmentAspectReference{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (subpass)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (inputAttachmentIndex)
@@ -176,12 +176,12 @@
 deriving instance Show RenderPassInputAttachmentAspectCreateInfo
 
 instance ToCStruct RenderPassInputAttachmentAspectCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassInputAttachmentAspectCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (aspectReferences)) :: Word32))
-    pPAspectReferences' <- ContT $ allocaBytesAligned @InputAttachmentAspectReference ((Data.Vector.length (aspectReferences)) * 12) 4
+    pPAspectReferences' <- ContT $ allocaBytes @InputAttachmentAspectReference ((Data.Vector.length (aspectReferences)) * 12)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAspectReferences' `plusPtr` (12 * (i)) :: Ptr InputAttachmentAspectReference) (e)) (aspectReferences)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr InputAttachmentAspectReference))) (pPAspectReferences')
     lift $ f
@@ -236,7 +236,7 @@
 deriving instance Show PhysicalDevicePointClippingProperties
 
 instance ToCStruct PhysicalDevicePointClippingProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePointClippingProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -302,7 +302,7 @@
 deriving instance Show ImageViewUsageCreateInfo
 
 instance ToCStruct ImageViewUsageCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageViewUsageCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -368,7 +368,7 @@
 deriving instance Show PipelineTessellationDomainOriginStateCreateInfo
 
 instance ToCStruct PipelineTessellationDomainOriginStateCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineTessellationDomainOriginStateCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance3.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance3.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance3.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_maintenance3.hs
@@ -10,7 +10,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (castPtr)
 import GHC.Ptr (nullFunPtr)
@@ -176,7 +176,7 @@
 deriving instance Show PhysicalDeviceMaintenance3Properties
 
 instance ToCStruct PhysicalDeviceMaintenance3Properties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMaintenance3Properties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -261,7 +261,7 @@
     | otherwise = Nothing
 
 instance (Extendss DescriptorSetLayoutSupport es, PokeChain es) => ToCStruct (DescriptorSetLayoutSupport es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetLayoutSupport{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_multiview.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_multiview.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_multiview.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_multiview.hs
@@ -8,7 +8,7 @@
                                                      , DependencyFlags
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -124,7 +124,7 @@
 deriving instance Show PhysicalDeviceMultiviewFeatures
 
 instance ToCStruct PhysicalDeviceMultiviewFeatures where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMultiviewFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -198,7 +198,7 @@
 deriving instance Show PhysicalDeviceMultiviewProperties
 
 instance ToCStruct PhysicalDeviceMultiviewProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMultiviewProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -373,20 +373,20 @@
 deriving instance Show RenderPassMultiviewCreateInfo
 
 instance ToCStruct RenderPassMultiviewCreateInfo where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassMultiviewCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (viewMasks)) :: Word32))
-    pPViewMasks' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (viewMasks)) * 4) 4
+    pPViewMasks' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (viewMasks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPViewMasks' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (viewMasks)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPViewMasks')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (viewOffsets)) :: Word32))
-    pPViewOffsets' <- ContT $ allocaBytesAligned @Int32 ((Data.Vector.length (viewOffsets)) * 4) 4
+    pPViewOffsets' <- ContT $ allocaBytes @Int32 ((Data.Vector.length (viewOffsets)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPViewOffsets' `plusPtr` (4 * (i)) :: Ptr Int32) (e)) (viewOffsets)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Int32))) (pPViewOffsets')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (correlationMasks)) :: Word32))
-    pPCorrelationMasks' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (correlationMasks)) * 4) 4
+    pPCorrelationMasks' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (correlationMasks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCorrelationMasks' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (correlationMasks)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr Word32))) (pPCorrelationMasks')
     lift $ f
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_sampler_ycbcr_conversion.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_sampler_ycbcr_conversion.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_sampler_ycbcr_conversion.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_sampler_ycbcr_conversion.hs
@@ -29,7 +29,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -299,7 +299,7 @@
 deriving instance Show SamplerYcbcrConversionInfo
 
 instance ToCStruct SamplerYcbcrConversionInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerYcbcrConversionInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -569,7 +569,7 @@
     | otherwise = Nothing
 
 instance (Extendss SamplerYcbcrConversionCreateInfo es, PokeChain es) => ToCStruct (SamplerYcbcrConversionCreateInfo es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerYcbcrConversionCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -681,7 +681,7 @@
 deriving instance Show BindImagePlaneMemoryInfo
 
 instance ToCStruct BindImagePlaneMemoryInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindImagePlaneMemoryInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -768,7 +768,7 @@
 deriving instance Show ImagePlaneMemoryRequirementsInfo
 
 instance ToCStruct ImagePlaneMemoryRequirementsInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImagePlaneMemoryRequirementsInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -839,7 +839,7 @@
 deriving instance Show PhysicalDeviceSamplerYcbcrConversionFeatures
 
 instance ToCStruct PhysicalDeviceSamplerYcbcrConversionFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSamplerYcbcrConversionFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -889,7 +889,7 @@
 deriving instance Show SamplerYcbcrConversionImageFormatProperties
 
 instance ToCStruct SamplerYcbcrConversionImageFormatProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerYcbcrConversionImageFormatProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_shader_draw_parameters.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_shader_draw_parameters.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_shader_draw_parameters.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_shader_draw_parameters.hs
@@ -6,7 +6,7 @@
                                                                   , StructureType(..)
                                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -69,7 +69,7 @@
 deriving instance Show PhysicalDeviceShaderDrawParametersFeatures
 
 instance ToCStruct PhysicalDeviceShaderDrawParametersFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderDrawParametersFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core11/Promoted_From_VK_KHR_variable_pointers.hs b/src/Vulkan/Core11/Promoted_From_VK_KHR_variable_pointers.hs
--- a/src/Vulkan/Core11/Promoted_From_VK_KHR_variable_pointers.hs
+++ b/src/Vulkan/Core11/Promoted_From_VK_KHR_variable_pointers.hs
@@ -6,7 +6,7 @@
                                                              , StructureType(..)
                                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -97,7 +97,7 @@
 deriving instance Show PhysicalDeviceVariablePointersFeatures
 
 instance ToCStruct PhysicalDeviceVariablePointersFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVariablePointersFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12.hs b/src/Vulkan/Core12.hs
--- a/src/Vulkan/Core12.hs
+++ b/src/Vulkan/Core12.hs
@@ -52,7 +52,7 @@
 import Vulkan.Core12.Promoted_From_VK_KHR_uniform_buffer_standard_layout
 import Vulkan.Core12.Promoted_From_VK_KHR_vulkan_memory_model
 import Vulkan.CStruct.Utils (FixedArray)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Data.ByteString (packCString)
@@ -212,7 +212,7 @@
 deriving instance Show PhysicalDeviceVulkan11Features
 
 instance ToCStruct PhysicalDeviceVulkan11Features where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVulkan11Features{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -417,7 +417,7 @@
 deriving instance Show PhysicalDeviceVulkan11Properties
 
 instance ToCStruct PhysicalDeviceVulkan11Properties where
-  withCStruct x f = allocaBytesAligned 112 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 112 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVulkan11Properties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1033,7 +1033,7 @@
 deriving instance Show PhysicalDeviceVulkan12Features
 
 instance ToCStruct PhysicalDeviceVulkan12Features where
-  withCStruct x f = allocaBytesAligned 208 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 208 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVulkan12Features{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1652,7 +1652,7 @@
 deriving instance Show PhysicalDeviceVulkan12Properties
 
 instance ToCStruct PhysicalDeviceVulkan12Properties where
-  withCStruct x f = allocaBytesAligned 736 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 736 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVulkan12Properties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_EXT_descriptor_indexing.hs b/src/Vulkan/Core12/Promoted_From_VK_EXT_descriptor_indexing.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_EXT_descriptor_indexing.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_EXT_descriptor_indexing.hs
@@ -15,7 +15,7 @@
                                                                , DescriptorBindingFlags
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -274,7 +274,7 @@
 deriving instance Show PhysicalDeviceDescriptorIndexingFeatures
 
 instance ToCStruct PhysicalDeviceDescriptorIndexingFeatures where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDescriptorIndexingFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -594,7 +594,7 @@
 deriving instance Show PhysicalDeviceDescriptorIndexingProperties
 
 instance ToCStruct PhysicalDeviceDescriptorIndexingProperties where
-  withCStruct x f = allocaBytesAligned 112 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 112 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDescriptorIndexingProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -881,12 +881,12 @@
 deriving instance Show DescriptorSetLayoutBindingFlagsCreateInfo
 
 instance ToCStruct DescriptorSetLayoutBindingFlagsCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetLayoutBindingFlagsCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (bindingFlags)) :: Word32))
-    pPBindingFlags' <- ContT $ allocaBytesAligned @DescriptorBindingFlags ((Data.Vector.length (bindingFlags)) * 4) 4
+    pPBindingFlags' <- ContT $ allocaBytes @DescriptorBindingFlags ((Data.Vector.length (bindingFlags)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPBindingFlags' `plusPtr` (4 * (i)) :: Ptr DescriptorBindingFlags) (e)) (bindingFlags)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DescriptorBindingFlags))) (pPBindingFlags')
     lift $ f
@@ -968,12 +968,12 @@
 deriving instance Show DescriptorSetVariableDescriptorCountAllocateInfo
 
 instance ToCStruct DescriptorSetVariableDescriptorCountAllocateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetVariableDescriptorCountAllocateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (descriptorCounts)) :: Word32))
-    pPDescriptorCounts' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (descriptorCounts)) * 4) 4
+    pPDescriptorCounts' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (descriptorCounts)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorCounts' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (descriptorCounts)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPDescriptorCounts')
     lift $ f
@@ -1043,7 +1043,7 @@
 deriving instance Show DescriptorSetVariableDescriptorCountLayoutSupport
 
 instance ToCStruct DescriptorSetVariableDescriptorCountLayoutSupport where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorSetVariableDescriptorCountLayoutSupport{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_EXT_host_query_reset.hs b/src/Vulkan/Core12/Promoted_From_VK_EXT_host_query_reset.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_EXT_host_query_reset.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_EXT_host_query_reset.hs
@@ -8,7 +8,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -157,7 +157,7 @@
 deriving instance Show PhysicalDeviceHostQueryResetFeatures
 
 instance ToCStruct PhysicalDeviceHostQueryResetFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceHostQueryResetFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_EXT_sampler_filter_minmax.hs b/src/Vulkan/Core12/Promoted_From_VK_EXT_sampler_filter_minmax.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_EXT_sampler_filter_minmax.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_EXT_sampler_filter_minmax.hs
@@ -8,7 +8,7 @@
                                                                  , SamplerReductionMode(..)
                                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -96,7 +96,7 @@
 deriving instance Show PhysicalDeviceSamplerFilterMinmaxProperties
 
 instance ToCStruct PhysicalDeviceSamplerFilterMinmaxProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSamplerFilterMinmaxProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -166,7 +166,7 @@
 deriving instance Show SamplerReductionModeCreateInfo
 
 instance ToCStruct SamplerReductionModeCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerReductionModeCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_EXT_scalar_block_layout.hs b/src/Vulkan/Core12/Promoted_From_VK_EXT_scalar_block_layout.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_EXT_scalar_block_layout.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_EXT_scalar_block_layout.hs
@@ -4,7 +4,7 @@
                                                                , StructureType(..)
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -64,7 +64,7 @@
 deriving instance Show PhysicalDeviceScalarBlockLayoutFeatures
 
 instance ToCStruct PhysicalDeviceScalarBlockLayoutFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceScalarBlockLayoutFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_EXT_separate_stencil_usage.hs b/src/Vulkan/Core12/Promoted_From_VK_EXT_separate_stencil_usage.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_EXT_separate_stencil_usage.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_EXT_separate_stencil_usage.hs
@@ -4,7 +4,7 @@
                                                                   , StructureType(..)
                                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -93,7 +93,7 @@
 deriving instance Show ImageStencilUsageCreateInfo
 
 instance ToCStruct ImageStencilUsageCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageStencilUsageCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_8bit_storage.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_8bit_storage.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_8bit_storage.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_8bit_storage.hs
@@ -4,7 +4,7 @@
                                                         , StructureType(..)
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -82,7 +82,7 @@
 deriving instance Show PhysicalDevice8BitStorageFeatures
 
 instance ToCStruct PhysicalDevice8BitStorageFeatures where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevice8BitStorageFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_buffer_device_address.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_buffer_device_address.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_buffer_device_address.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_buffer_device_address.hs
@@ -21,7 +21,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -332,7 +332,7 @@
 deriving instance Show PhysicalDeviceBufferDeviceAddressFeatures
 
 instance ToCStruct PhysicalDeviceBufferDeviceAddressFeatures where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceBufferDeviceAddressFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -416,7 +416,7 @@
 deriving instance Show BufferDeviceAddressInfo
 
 instance ToCStruct BufferDeviceAddressInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferDeviceAddressInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -502,7 +502,7 @@
 deriving instance Show BufferOpaqueCaptureAddressCreateInfo
 
 instance ToCStruct BufferOpaqueCaptureAddressCreateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferOpaqueCaptureAddressCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -576,7 +576,7 @@
 deriving instance Show MemoryOpaqueCaptureAddressAllocateInfo
 
 instance ToCStruct MemoryOpaqueCaptureAddressAllocateInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryOpaqueCaptureAddressAllocateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -635,7 +635,7 @@
 deriving instance Show DeviceMemoryOpaqueCaptureAddressInfo
 
 instance ToCStruct DeviceMemoryOpaqueCaptureAddressInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceMemoryOpaqueCaptureAddressInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_create_renderpass2.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_create_renderpass2.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_create_renderpass2.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_create_renderpass2.hs
@@ -20,7 +20,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -868,7 +868,7 @@
     | otherwise = Nothing
 
 instance (Extendss AttachmentDescription2 es, PokeChain es) => ToCStruct (AttachmentDescription2 es) where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentDescription2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1064,7 +1064,7 @@
     | otherwise = Nothing
 
 instance (Extendss AttachmentReference2 es, PokeChain es) => ToCStruct (AttachmentReference2 es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentReference2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1375,7 +1375,7 @@
     | otherwise = Nothing
 
 instance (Extendss SubpassDescription2 es, PokeChain es) => ToCStruct (SubpassDescription2 es) where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassDescription2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1384,7 +1384,7 @@
     lift $ poke ((p `plusPtr` 20 :: Ptr PipelineBindPoint)) (pipelineBindPoint)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) (viewMask)
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (inputAttachments)) :: Word32))
-    pPInputAttachments' <- ContT $ allocaBytesAligned @(AttachmentReference2 _) ((Data.Vector.length (inputAttachments)) * 32) 8
+    pPInputAttachments' <- ContT $ allocaBytes @(AttachmentReference2 _) ((Data.Vector.length (inputAttachments)) * 32)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPInputAttachments' `plusPtr` (32 * (i)) :: Ptr (AttachmentReference2 _))) (e) . ($ ())) (inputAttachments)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr (AttachmentReference2 _)))) (pPInputAttachments')
     let pColorAttachmentsLength = Data.Vector.length $ (colorAttachments)
@@ -1392,13 +1392,13 @@
     lift $ unless (fromIntegral pResolveAttachmentsLength == pColorAttachmentsLength || pResolveAttachmentsLength == 0) $
       throwIO $ IOError Nothing InvalidArgument "" "pResolveAttachments and pColorAttachments must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral pColorAttachmentsLength :: Word32))
-    pPColorAttachments' <- ContT $ allocaBytesAligned @(AttachmentReference2 _) ((Data.Vector.length (colorAttachments)) * 32) 8
+    pPColorAttachments' <- ContT $ allocaBytes @(AttachmentReference2 _) ((Data.Vector.length (colorAttachments)) * 32)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPColorAttachments' `plusPtr` (32 * (i)) :: Ptr (AttachmentReference2 _))) (e) . ($ ())) (colorAttachments)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr (AttachmentReference2 _)))) (pPColorAttachments')
     pResolveAttachments'' <- if Data.Vector.null (resolveAttachments)
       then pure nullPtr
       else do
-        pPResolveAttachments <- ContT $ allocaBytesAligned @(AttachmentReference2 _) (((Data.Vector.length (resolveAttachments))) * 32) 8
+        pPResolveAttachments <- ContT $ allocaBytes @(AttachmentReference2 _) (((Data.Vector.length (resolveAttachments))) * 32)
         Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPResolveAttachments `plusPtr` (32 * (i)) :: Ptr (AttachmentReference2 _))) (e) . ($ ())) ((resolveAttachments))
         pure $ pPResolveAttachments
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr (AttachmentReference2 _)))) pResolveAttachments''
@@ -1407,7 +1407,7 @@
       Just j -> ContT @_ @_ @(Ptr (AttachmentReference2 '[])) $ \cont -> withSomeCStruct @AttachmentReference2 (j) (cont . castPtr)
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr (AttachmentReference2 _)))) pDepthStencilAttachment''
     lift $ poke ((p `plusPtr` 72 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (preserveAttachments)) :: Word32))
-    pPPreserveAttachments' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (preserveAttachments)) * 4) 4
+    pPPreserveAttachments' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (preserveAttachments)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPreserveAttachments' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (preserveAttachments)
     lift $ poke ((p `plusPtr` 80 :: Ptr (Ptr Word32))) (pPPreserveAttachments')
     lift $ f
@@ -1671,7 +1671,7 @@
     | otherwise = Nothing
 
 instance (Extendss SubpassDependency2 es, PokeChain es) => ToCStruct (SubpassDependency2 es) where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassDependency2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1985,26 +1985,26 @@
     | otherwise = Nothing
 
 instance (Extendss RenderPassCreateInfo2 es, PokeChain es) => ToCStruct (RenderPassCreateInfo2 es) where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassCreateInfo2{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr RenderPassCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32))
-    pPAttachments' <- ContT $ allocaBytesAligned @(AttachmentDescription2 _) ((Data.Vector.length (attachments)) * 56) 8
+    pPAttachments' <- ContT $ allocaBytes @(AttachmentDescription2 _) ((Data.Vector.length (attachments)) * 56)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPAttachments' `plusPtr` (56 * (i)) :: Ptr (AttachmentDescription2 _))) (e) . ($ ())) (attachments)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (AttachmentDescription2 _)))) (pPAttachments')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (subpasses)) :: Word32))
-    pPSubpasses' <- ContT $ allocaBytesAligned @(SubpassDescription2 _) ((Data.Vector.length (subpasses)) * 88) 8
+    pPSubpasses' <- ContT $ allocaBytes @(SubpassDescription2 _) ((Data.Vector.length (subpasses)) * 88)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPSubpasses' `plusPtr` (88 * (i)) :: Ptr (SubpassDescription2 _))) (e) . ($ ())) (subpasses)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr (SubpassDescription2 _)))) (pPSubpasses')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (dependencies)) :: Word32))
-    pPDependencies' <- ContT $ allocaBytesAligned @(SubpassDependency2 _) ((Data.Vector.length (dependencies)) * 48) 8
+    pPDependencies' <- ContT $ allocaBytes @(SubpassDependency2 _) ((Data.Vector.length (dependencies)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPDependencies' `plusPtr` (48 * (i)) :: Ptr (SubpassDependency2 _))) (e) . ($ ())) (dependencies)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr (SubpassDependency2 _)))) (pPDependencies')
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (correlatedViewMasks)) :: Word32))
-    pPCorrelatedViewMasks' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (correlatedViewMasks)) * 4) 4
+    pPCorrelatedViewMasks' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (correlatedViewMasks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCorrelatedViewMasks' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (correlatedViewMasks)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr Word32))) (pPCorrelatedViewMasks')
     lift $ f
@@ -2072,7 +2072,7 @@
 deriving instance Show SubpassBeginInfo
 
 instance ToCStruct SubpassBeginInfo where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassBeginInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBPASS_BEGIN_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2122,7 +2122,7 @@
 deriving instance Show SubpassEndInfo
 
 instance ToCStruct SubpassEndInfo where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassEndInfo f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBPASS_END_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_depth_stencil_resolve.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_depth_stencil_resolve.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_depth_stencil_resolve.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_depth_stencil_resolve.hs
@@ -7,7 +7,7 @@
                                                                  , ResolveModeFlags
                                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Utils (maybePeek)
 import GHC.Ptr (castPtr)
 import Foreign.Ptr (nullPtr)
@@ -106,7 +106,7 @@
 deriving instance Show PhysicalDeviceDepthStencilResolveProperties
 
 instance ToCStruct PhysicalDeviceDepthStencilResolveProperties where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDepthStencilResolveProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -282,7 +282,7 @@
 deriving instance Show SubpassDescriptionDepthStencilResolve
 
 instance ToCStruct SubpassDescriptionDepthStencilResolve where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassDescriptionDepthStencilResolve{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_driver_properties.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_driver_properties.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_driver_properties.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_driver_properties.hs
@@ -11,7 +11,7 @@
                                                              ) where
 
 import Vulkan.CStruct.Utils (FixedArray)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Data.ByteString (packCString)
@@ -68,7 +68,7 @@
 deriving instance Show ConformanceVersion
 
 instance ToCStruct ConformanceVersion where
-  withCStruct x f = allocaBytesAligned 4 1 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 4 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ConformanceVersion{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word8)) (major)
     poke ((p `plusPtr` 1 :: Ptr Word8)) (minor)
@@ -154,7 +154,7 @@
 deriving instance Show PhysicalDeviceDriverProperties
 
 instance ToCStruct PhysicalDeviceDriverProperties where
-  withCStruct x f = allocaBytesAligned 536 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 536 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDriverProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_image_format_list.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_image_format_list.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_image_format_list.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_image_format_list.hs
@@ -4,7 +4,7 @@
                                                              , StructureType(..)
                                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -66,12 +66,12 @@
 deriving instance Show ImageFormatListCreateInfo
 
 instance ToCStruct ImageFormatListCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageFormatListCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (viewFormats)) :: Word32))
-    pPViewFormats' <- ContT $ allocaBytesAligned @Format ((Data.Vector.length (viewFormats)) * 4) 4
+    pPViewFormats' <- ContT $ allocaBytes @Format ((Data.Vector.length (viewFormats)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPViewFormats' `plusPtr` (4 * (i)) :: Ptr Format) (e)) (viewFormats)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Format))) (pPViewFormats')
     lift $ f
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_imageless_framebuffer.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_imageless_framebuffer.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_imageless_framebuffer.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_imageless_framebuffer.hs
@@ -9,7 +9,7 @@
                                                                  , FramebufferCreateFlags
                                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -87,7 +87,7 @@
 deriving instance Show PhysicalDeviceImagelessFramebufferFeatures
 
 instance ToCStruct PhysicalDeviceImagelessFramebufferFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceImagelessFramebufferFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -149,12 +149,12 @@
 deriving instance Show FramebufferAttachmentsCreateInfo
 
 instance ToCStruct FramebufferAttachmentsCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FramebufferAttachmentsCreateInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachmentImageInfos)) :: Word32))
-    pPAttachmentImageInfos' <- ContT $ allocaBytesAligned @FramebufferAttachmentImageInfo ((Data.Vector.length (attachmentImageInfos)) * 48) 8
+    pPAttachmentImageInfos' <- ContT $ allocaBytes @FramebufferAttachmentImageInfo ((Data.Vector.length (attachmentImageInfos)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPAttachmentImageInfos' `plusPtr` (48 * (i)) :: Ptr FramebufferAttachmentImageInfo) (e) . ($ ())) (attachmentImageInfos)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr FramebufferAttachmentImageInfo))) (pPAttachmentImageInfos')
     lift $ f
@@ -250,7 +250,7 @@
 deriving instance Show FramebufferAttachmentImageInfo
 
 instance ToCStruct FramebufferAttachmentImageInfo where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FramebufferAttachmentImageInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -260,7 +260,7 @@
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) (height)
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) (layerCount)
     lift $ poke ((p `plusPtr` 36 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (viewFormats)) :: Word32))
-    pPViewFormats' <- ContT $ allocaBytesAligned @Format ((Data.Vector.length (viewFormats)) * 4) 4
+    pPViewFormats' <- ContT $ allocaBytes @Format ((Data.Vector.length (viewFormats)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPViewFormats' `plusPtr` (4 * (i)) :: Ptr Format) (e)) (viewFormats)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Format))) (pPViewFormats')
     lift $ f
@@ -341,12 +341,12 @@
 deriving instance Show RenderPassAttachmentBeginInfo
 
 instance ToCStruct RenderPassAttachmentBeginInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassAttachmentBeginInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachments)) :: Word32))
-    pPAttachments' <- ContT $ allocaBytesAligned @ImageView ((Data.Vector.length (attachments)) * 8) 8
+    pPAttachments' <- ContT $ allocaBytes @ImageView ((Data.Vector.length (attachments)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAttachments' `plusPtr` (8 * (i)) :: Ptr ImageView) (e)) (attachments)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ImageView))) (pPAttachments')
     lift $ f
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_separate_depth_stencil_layouts.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_separate_depth_stencil_layouts.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_separate_depth_stencil_layouts.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_separate_depth_stencil_layouts.hs
@@ -7,7 +7,7 @@
                                                                           , StructureType(..)
                                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -82,7 +82,7 @@
 deriving instance Show PhysicalDeviceSeparateDepthStencilLayoutsFeatures
 
 instance ToCStruct PhysicalDeviceSeparateDepthStencilLayoutsFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSeparateDepthStencilLayoutsFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -151,7 +151,7 @@
 deriving instance Show AttachmentReferenceStencilLayout
 
 instance ToCStruct AttachmentReferenceStencilLayout where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentReferenceStencilLayout{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -243,7 +243,7 @@
 deriving instance Show AttachmentDescriptionStencilLayout
 
 instance ToCStruct AttachmentDescriptionStencilLayout where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentDescriptionStencilLayout{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_atomic_int64.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_atomic_int64.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_atomic_int64.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_atomic_int64.hs
@@ -4,7 +4,7 @@
                                                                , StructureType(..)
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -68,7 +68,7 @@
 deriving instance Show PhysicalDeviceShaderAtomicInt64Features
 
 instance ToCStruct PhysicalDeviceShaderAtomicInt64Features where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderAtomicInt64Features{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float16_int8.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float16_int8.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float16_int8.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float16_int8.hs
@@ -4,7 +4,7 @@
                                                                , StructureType(..)
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -80,7 +80,7 @@
 deriving instance Show PhysicalDeviceShaderFloat16Int8Features
 
 instance ToCStruct PhysicalDeviceShaderFloat16Int8Features where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderFloat16Int8Features{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float_controls.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float_controls.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float_controls.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_float_controls.hs
@@ -5,7 +5,7 @@
                                                                  , ShaderFloatControlsIndependence(..)
                                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -169,7 +169,7 @@
 deriving instance Show PhysicalDeviceFloatControlsProperties
 
 instance ToCStruct PhysicalDeviceFloatControlsProperties where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFloatControlsProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_subgroup_extended_types.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_subgroup_extended_types.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_subgroup_extended_types.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_shader_subgroup_extended_types.hs
@@ -4,7 +4,7 @@
                                                                           , StructureType(..)
                                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -70,7 +70,7 @@
 deriving instance Show PhysicalDeviceShaderSubgroupExtendedTypesFeatures
 
 instance ToCStruct PhysicalDeviceShaderSubgroupExtendedTypesFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderSubgroupExtendedTypesFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_timeline_semaphore.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_timeline_semaphore.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_timeline_semaphore.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_timeline_semaphore.hs
@@ -20,7 +20,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -386,7 +386,7 @@
 deriving instance Show PhysicalDeviceTimelineSemaphoreFeatures
 
 instance ToCStruct PhysicalDeviceTimelineSemaphoreFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTimelineSemaphoreFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -448,7 +448,7 @@
 deriving instance Show PhysicalDeviceTimelineSemaphoreProperties
 
 instance ToCStruct PhysicalDeviceTimelineSemaphoreProperties where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTimelineSemaphoreProperties{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -534,7 +534,7 @@
 deriving instance Show SemaphoreTypeCreateInfo
 
 instance ToCStruct SemaphoreTypeCreateInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreTypeCreateInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -626,7 +626,7 @@
 deriving instance Show TimelineSemaphoreSubmitInfo
 
 instance ToCStruct TimelineSemaphoreSubmitInfo where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p TimelineSemaphoreSubmitInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -641,7 +641,7 @@
     pWaitSemaphoreValues'' <- if Data.Vector.null (waitSemaphoreValues)
       then pure nullPtr
       else do
-        pPWaitSemaphoreValues <- ContT $ allocaBytesAligned @Word64 (((Data.Vector.length (waitSemaphoreValues))) * 8) 8
+        pPWaitSemaphoreValues <- ContT $ allocaBytes @Word64 (((Data.Vector.length (waitSemaphoreValues))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphoreValues `plusPtr` (8 * (i)) :: Ptr Word64) (e)) ((waitSemaphoreValues))
         pure $ pPWaitSemaphoreValues
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word64))) pWaitSemaphoreValues''
@@ -656,7 +656,7 @@
     pSignalSemaphoreValues'' <- if Data.Vector.null (signalSemaphoreValues)
       then pure nullPtr
       else do
-        pPSignalSemaphoreValues <- ContT $ allocaBytesAligned @Word64 (((Data.Vector.length (signalSemaphoreValues))) * 8) 8
+        pPSignalSemaphoreValues <- ContT $ allocaBytes @Word64 (((Data.Vector.length (signalSemaphoreValues))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphoreValues `plusPtr` (8 * (i)) :: Ptr Word64) (e)) ((signalSemaphoreValues))
         pure $ pPSignalSemaphoreValues
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Word64))) pSignalSemaphoreValues''
@@ -746,7 +746,7 @@
 deriving instance Show SemaphoreWaitInfo
 
 instance ToCStruct SemaphoreWaitInfo where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreWaitInfo{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -755,10 +755,10 @@
     lift $ unless ((Data.Vector.length $ (values)) == pSemaphoresLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pValues and pSemaphores must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral pSemaphoresLength :: Word32))
-    pPSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (semaphores)) * 8) 8
+    pPSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (semaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (semaphores)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Semaphore))) (pPSemaphores')
-    pPValues' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (values)) * 8) 8
+    pPValues' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (values)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPValues' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (values)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Word64))) (pPValues')
     lift $ f
@@ -829,7 +829,7 @@
 deriving instance Show SemaphoreSignalInfo
 
 instance ToCStruct SemaphoreSignalInfo where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreSignalInfo{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_uniform_buffer_standard_layout.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_uniform_buffer_standard_layout.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_uniform_buffer_standard_layout.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_uniform_buffer_standard_layout.hs
@@ -4,7 +4,7 @@
                                                                           , StructureType(..)
                                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -66,7 +66,7 @@
 deriving instance Show PhysicalDeviceUniformBufferStandardLayoutFeatures
 
 instance ToCStruct PhysicalDeviceUniformBufferStandardLayoutFeatures where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceUniformBufferStandardLayoutFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Core12/Promoted_From_VK_KHR_vulkan_memory_model.hs b/src/Vulkan/Core12/Promoted_From_VK_KHR_vulkan_memory_model.hs
--- a/src/Vulkan/Core12/Promoted_From_VK_KHR_vulkan_memory_model.hs
+++ b/src/Vulkan/Core12/Promoted_From_VK_KHR_vulkan_memory_model.hs
@@ -4,7 +4,7 @@
                                                                , StructureType(..)
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -81,7 +81,7 @@
 deriving instance Show PhysicalDeviceVulkanMemoryModelFeatures
 
 instance ToCStruct PhysicalDeviceVulkanMemoryModelFeatures where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVulkanMemoryModelFeatures{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_device_coherent_memory.hs b/src/Vulkan/Extensions/VK_AMD_device_coherent_memory.hs
--- a/src/Vulkan/Extensions/VK_AMD_device_coherent_memory.hs
+++ b/src/Vulkan/Extensions/VK_AMD_device_coherent_memory.hs
@@ -100,7 +100,7 @@
                                                         , pattern AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -159,7 +159,7 @@
 deriving instance Show PhysicalDeviceCoherentMemoryFeaturesAMD
 
 instance ToCStruct PhysicalDeviceCoherentMemoryFeaturesAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCoherentMemoryFeaturesAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_display_native_hdr.hs b/src/Vulkan/Extensions/VK_AMD_display_native_hdr.hs
--- a/src/Vulkan/Extensions/VK_AMD_display_native_hdr.hs
+++ b/src/Vulkan/Extensions/VK_AMD_display_native_hdr.hs
@@ -138,7 +138,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -251,7 +251,7 @@
 deriving instance Show DisplayNativeHdrSurfaceCapabilitiesAMD
 
 instance ToCStruct DisplayNativeHdrSurfaceCapabilitiesAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayNativeHdrSurfaceCapabilitiesAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -322,7 +322,7 @@
 deriving instance Show SwapchainDisplayNativeHdrCreateInfoAMD
 
 instance ToCStruct SwapchainDisplayNativeHdrCreateInfoAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SwapchainDisplayNativeHdrCreateInfoAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_memory_overallocation_behavior.hs b/src/Vulkan/Extensions/VK_AMD_memory_overallocation_behavior.hs
--- a/src/Vulkan/Extensions/VK_AMD_memory_overallocation_behavior.hs
+++ b/src/Vulkan/Extensions/VK_AMD_memory_overallocation_behavior.hs
@@ -104,7 +104,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -151,7 +151,7 @@
 deriving instance Show DeviceMemoryOverallocationCreateInfoAMD
 
 instance ToCStruct DeviceMemoryOverallocationCreateInfoAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceMemoryOverallocationCreateInfoAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_pipeline_compiler_control.hs b/src/Vulkan/Extensions/VK_AMD_pipeline_compiler_control.hs
--- a/src/Vulkan/Extensions/VK_AMD_pipeline_compiler_control.hs
+++ b/src/Vulkan/Extensions/VK_AMD_pipeline_compiler_control.hs
@@ -112,7 +112,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -163,7 +163,7 @@
 deriving instance Show PipelineCompilerControlCreateInfoAMD
 
 instance ToCStruct PipelineCompilerControlCreateInfoAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCompilerControlCreateInfoAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_rasterization_order.hs b/src/Vulkan/Extensions/VK_AMD_rasterization_order.hs
--- a/src/Vulkan/Extensions/VK_AMD_rasterization_order.hs
+++ b/src/Vulkan/Extensions/VK_AMD_rasterization_order.hs
@@ -177,7 +177,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -230,7 +230,7 @@
 deriving instance Show PipelineRasterizationStateRasterizationOrderAMD
 
 instance ToCStruct PipelineRasterizationStateRasterizationOrderAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationStateRasterizationOrderAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_shader_core_properties.hs b/src/Vulkan/Extensions/VK_AMD_shader_core_properties.hs
--- a/src/Vulkan/Extensions/VK_AMD_shader_core_properties.hs
+++ b/src/Vulkan/Extensions/VK_AMD_shader_core_properties.hs
@@ -158,7 +158,7 @@
                                                         , pattern AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -260,7 +260,7 @@
 deriving instance Show PhysicalDeviceShaderCorePropertiesAMD
 
 instance ToCStruct PhysicalDeviceShaderCorePropertiesAMD where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderCorePropertiesAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_shader_core_properties2.hs b/src/Vulkan/Extensions/VK_AMD_shader_core_properties2.hs
--- a/src/Vulkan/Extensions/VK_AMD_shader_core_properties2.hs
+++ b/src/Vulkan/Extensions/VK_AMD_shader_core_properties2.hs
@@ -106,7 +106,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -170,7 +170,7 @@
 deriving instance Show PhysicalDeviceShaderCoreProperties2AMD
 
 instance ToCStruct PhysicalDeviceShaderCoreProperties2AMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderCoreProperties2AMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_AMD_shader_info.hs b/src/Vulkan/Extensions/VK_AMD_shader_info.hs
--- a/src/Vulkan/Extensions/VK_AMD_shader_info.hs
+++ b/src/Vulkan/Extensions/VK_AMD_shader_info.hs
@@ -173,7 +173,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -386,7 +386,7 @@
 deriving instance Show ShaderResourceUsageAMD
 
 instance ToCStruct ShaderResourceUsageAMD where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ShaderResourceUsageAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (numUsedVgprs)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (numUsedSgprs)
@@ -481,7 +481,7 @@
 deriving instance Show ShaderStatisticsInfoAMD
 
 instance ToCStruct ShaderStatisticsInfoAMD where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ShaderStatisticsInfoAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ShaderStageFlags)) (shaderStageMask)
     poke ((p `plusPtr` 8 :: Ptr ShaderResourceUsageAMD)) (resourceUsage)
diff --git a/src/Vulkan/Extensions/VK_AMD_texture_gather_bias_lod.hs b/src/Vulkan/Extensions/VK_AMD_texture_gather_bias_lod.hs
--- a/src/Vulkan/Extensions/VK_AMD_texture_gather_bias_lod.hs
+++ b/src/Vulkan/Extensions/VK_AMD_texture_gather_bias_lod.hs
@@ -156,7 +156,7 @@
                                                          , pattern AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME
                                                          ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -201,7 +201,7 @@
 deriving instance Show TextureLODGatherFormatPropertiesAMD
 
 instance ToCStruct TextureLODGatherFormatPropertiesAMD where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p TextureLODGatherFormatPropertiesAMD{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_ANDROID_external_memory_android_hardware_buffer.hs b/src/Vulkan/Extensions/VK_ANDROID_external_memory_android_hardware_buffer.hs
--- a/src/Vulkan/Extensions/VK_ANDROID_external_memory_android_hardware_buffer.hs
+++ b/src/Vulkan/Extensions/VK_ANDROID_external_memory_android_hardware_buffer.hs
@@ -275,7 +275,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -513,7 +513,7 @@
 deriving instance Show ImportAndroidHardwareBufferInfoANDROID
 
 instance ToCStruct ImportAndroidHardwareBufferInfoANDROID where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportAndroidHardwareBufferInfoANDROID{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -587,7 +587,7 @@
 deriving instance Show AndroidHardwareBufferUsageANDROID
 
 instance ToCStruct AndroidHardwareBufferUsageANDROID where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AndroidHardwareBufferUsageANDROID{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -664,7 +664,7 @@
     | otherwise = Nothing
 
 instance (Extendss AndroidHardwareBufferPropertiesANDROID es, PokeChain es) => ToCStruct (AndroidHardwareBufferPropertiesANDROID es) where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AndroidHardwareBufferPropertiesANDROID{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -745,7 +745,7 @@
 deriving instance Show MemoryGetAndroidHardwareBufferInfoANDROID
 
 instance ToCStruct MemoryGetAndroidHardwareBufferInfoANDROID where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryGetAndroidHardwareBufferInfoANDROID{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -909,7 +909,7 @@
 deriving instance Show AndroidHardwareBufferFormatPropertiesANDROID
 
 instance ToCStruct AndroidHardwareBufferFormatPropertiesANDROID where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AndroidHardwareBufferFormatPropertiesANDROID{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -998,7 +998,7 @@
 deriving instance Show ExternalFormatANDROID
 
 instance ToCStruct ExternalFormatANDROID where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalFormatANDROID{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_4444_formats.hs b/src/Vulkan/Extensions/VK_EXT_4444_formats.hs
--- a/src/Vulkan/Extensions/VK_EXT_4444_formats.hs
+++ b/src/Vulkan/Extensions/VK_EXT_4444_formats.hs
@@ -105,7 +105,7 @@
                                               , pattern EXT_4444_FORMATS_EXTENSION_NAME
                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -187,7 +187,7 @@
 deriving instance Show PhysicalDevice4444FormatsFeaturesEXT
 
 instance ToCStruct PhysicalDevice4444FormatsFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevice4444FormatsFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_astc_decode_mode.hs b/src/Vulkan/Extensions/VK_EXT_astc_decode_mode.hs
--- a/src/Vulkan/Extensions/VK_EXT_astc_decode_mode.hs
+++ b/src/Vulkan/Extensions/VK_EXT_astc_decode_mode.hs
@@ -163,7 +163,7 @@
                                                   , pattern EXT_ASTC_DECODE_MODE_EXTENSION_NAME
                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -237,7 +237,7 @@
 deriving instance Show ImageViewASTCDecodeModeEXT
 
 instance ToCStruct ImageViewASTCDecodeModeEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageViewASTCDecodeModeEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -306,7 +306,7 @@
 deriving instance Show PhysicalDeviceASTCDecodeFeaturesEXT
 
 instance ToCStruct PhysicalDeviceASTCDecodeFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceASTCDecodeFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_blend_operation_advanced.hs b/src/Vulkan/Extensions/VK_EXT_blend_operation_advanced.hs
--- a/src/Vulkan/Extensions/VK_EXT_blend_operation_advanced.hs
+++ b/src/Vulkan/Extensions/VK_EXT_blend_operation_advanced.hs
@@ -296,7 +296,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -373,7 +373,7 @@
 deriving instance Show PhysicalDeviceBlendOperationAdvancedFeaturesEXT
 
 instance ToCStruct PhysicalDeviceBlendOperationAdvancedFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceBlendOperationAdvancedFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -467,7 +467,7 @@
 deriving instance Show PhysicalDeviceBlendOperationAdvancedPropertiesEXT
 
 instance ToCStruct PhysicalDeviceBlendOperationAdvancedPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceBlendOperationAdvancedPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -579,7 +579,7 @@
 deriving instance Show PipelineColorBlendAdvancedStateCreateInfoEXT
 
 instance ToCStruct PipelineColorBlendAdvancedStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineColorBlendAdvancedStateCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_buffer_device_address.hs b/src/Vulkan/Extensions/VK_EXT_buffer_device_address.hs
--- a/src/Vulkan/Extensions/VK_EXT_buffer_device_address.hs
+++ b/src/Vulkan/Extensions/VK_EXT_buffer_device_address.hs
@@ -175,7 +175,7 @@
                                                        , pattern EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME
                                                        ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -293,7 +293,7 @@
 deriving instance Show PhysicalDeviceBufferDeviceAddressFeaturesEXT
 
 instance ToCStruct PhysicalDeviceBufferDeviceAddressFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceBufferDeviceAddressFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -366,7 +366,7 @@
 deriving instance Show BufferDeviceAddressCreateInfoEXT
 
 instance ToCStruct BufferDeviceAddressCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferDeviceAddressCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_calibrated_timestamps.hs b/src/Vulkan/Extensions/VK_EXT_calibrated_timestamps.hs
--- a/src/Vulkan/Extensions/VK_EXT_calibrated_timestamps.hs
+++ b/src/Vulkan/Extensions/VK_EXT_calibrated_timestamps.hs
@@ -195,7 +195,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -394,7 +394,7 @@
   lift $ unless (vkGetCalibratedTimestampsEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkGetCalibratedTimestampsEXT is null" Nothing Nothing
   let vkGetCalibratedTimestampsEXT' = mkVkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXTPtr
-  pPTimestampInfos <- ContT $ allocaBytesAligned @CalibratedTimestampInfoEXT ((Data.Vector.length (timestampInfos)) * 24) 8
+  pPTimestampInfos <- ContT $ allocaBytes @CalibratedTimestampInfoEXT ((Data.Vector.length (timestampInfos)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPTimestampInfos `plusPtr` (24 * (i)) :: Ptr CalibratedTimestampInfoEXT) (e)) (timestampInfos)
   pPTimestamps <- ContT $ bracket (callocBytes @Word64 ((fromIntegral ((fromIntegral (Data.Vector.length $ (timestampInfos)) :: Word32))) * 8)) free
   pPMaxDeviation <- ContT $ bracket (callocBytes @Word64 8) free
@@ -432,7 +432,7 @@
 deriving instance Show CalibratedTimestampInfoEXT
 
 instance ToCStruct CalibratedTimestampInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CalibratedTimestampInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_color_write_enable.hs b/src/Vulkan/Extensions/VK_EXT_color_write_enable.hs
--- a/src/Vulkan/Extensions/VK_EXT_color_write_enable.hs
+++ b/src/Vulkan/Extensions/VK_EXT_color_write_enable.hs
@@ -123,7 +123,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -254,7 +254,7 @@
   lift $ unless (vkCmdSetColorWriteEnableEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetColorWriteEnableEXT is null" Nothing Nothing
   let vkCmdSetColorWriteEnableEXT' = mkVkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXTPtr
-  pPColorWriteEnables <- ContT $ allocaBytesAligned @Bool32 ((Data.Vector.length (colorWriteEnables)) * 4) 4
+  pPColorWriteEnables <- ContT $ allocaBytes @Bool32 ((Data.Vector.length (colorWriteEnables)) * 4)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPColorWriteEnables `plusPtr` (4 * (i)) :: Ptr Bool32) (boolToBool32 (e))) (colorWriteEnables)
   lift $ traceAroundEvent "vkCmdSetColorWriteEnableEXT" (vkCmdSetColorWriteEnableEXT' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (colorWriteEnables)) :: Word32)) (pPColorWriteEnables))
   pure $ ()
@@ -298,7 +298,7 @@
 deriving instance Show PhysicalDeviceColorWriteEnableFeaturesEXT
 
 instance ToCStruct PhysicalDeviceColorWriteEnableFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceColorWriteEnableFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -398,12 +398,12 @@
 deriving instance Show PipelineColorWriteCreateInfoEXT
 
 instance ToCStruct PipelineColorWriteCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineColorWriteCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (colorWriteEnables)) :: Word32))
-    pPColorWriteEnables' <- ContT $ allocaBytesAligned @Bool32 ((Data.Vector.length (colorWriteEnables)) * 4) 4
+    pPColorWriteEnables' <- ContT $ allocaBytes @Bool32 ((Data.Vector.length (colorWriteEnables)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPColorWriteEnables' `plusPtr` (4 * (i)) :: Ptr Bool32) (boolToBool32 (e))) (colorWriteEnables)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Bool32))) (pPColorWriteEnables')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_EXT_conditional_rendering.hs b/src/Vulkan/Extensions/VK_EXT_conditional_rendering.hs
--- a/src/Vulkan/Extensions/VK_EXT_conditional_rendering.hs
+++ b/src/Vulkan/Extensions/VK_EXT_conditional_rendering.hs
@@ -181,7 +181,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -464,7 +464,7 @@
 deriving instance Show ConditionalRenderingBeginInfoEXT
 
 instance ToCStruct ConditionalRenderingBeginInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ConditionalRenderingBeginInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -544,7 +544,7 @@
 deriving instance Show CommandBufferInheritanceConditionalRenderingInfoEXT
 
 instance ToCStruct CommandBufferInheritanceConditionalRenderingInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferInheritanceConditionalRenderingInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -617,7 +617,7 @@
 deriving instance Show PhysicalDeviceConditionalRenderingFeaturesEXT
 
 instance ToCStruct PhysicalDeviceConditionalRenderingFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceConditionalRenderingFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_conservative_rasterization.hs b/src/Vulkan/Extensions/VK_EXT_conservative_rasterization.hs
--- a/src/Vulkan/Extensions/VK_EXT_conservative_rasterization.hs
+++ b/src/Vulkan/Extensions/VK_EXT_conservative_rasterization.hs
@@ -167,7 +167,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -312,7 +312,7 @@
 deriving instance Show PhysicalDeviceConservativeRasterizationPropertiesEXT
 
 instance ToCStruct PhysicalDeviceConservativeRasterizationPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceConservativeRasterizationPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -417,7 +417,7 @@
 deriving instance Show PipelineRasterizationConservativeStateCreateInfoEXT
 
 instance ToCStruct PipelineRasterizationConservativeStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationConservativeStateCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_custom_border_color.hs b/src/Vulkan/Extensions/VK_EXT_custom_border_color.hs
--- a/src/Vulkan/Extensions/VK_EXT_custom_border_color.hs
+++ b/src/Vulkan/Extensions/VK_EXT_custom_border_color.hs
@@ -259,7 +259,7 @@
                                                      , pattern EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -349,7 +349,7 @@
 deriving instance Show SamplerCustomBorderColorCreateInfoEXT
 
 instance ToCStruct SamplerCustomBorderColorCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SamplerCustomBorderColorCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -401,7 +401,7 @@
 deriving instance Show PhysicalDeviceCustomBorderColorPropertiesEXT
 
 instance ToCStruct PhysicalDeviceCustomBorderColorPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCustomBorderColorPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -484,7 +484,7 @@
 deriving instance Show PhysicalDeviceCustomBorderColorFeaturesEXT
 
 instance ToCStruct PhysicalDeviceCustomBorderColorFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCustomBorderColorFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_debug_marker.hs b/src/Vulkan/Extensions/VK_EXT_debug_marker.hs
--- a/src/Vulkan/Extensions/VK_EXT_debug_marker.hs
+++ b/src/Vulkan/Extensions/VK_EXT_debug_marker.hs
@@ -291,7 +291,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -729,7 +729,7 @@
 deriving instance Show DebugMarkerObjectNameInfoEXT
 
 instance ToCStruct DebugMarkerObjectNameInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugMarkerObjectNameInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -823,7 +823,7 @@
 deriving instance Show DebugMarkerObjectTagInfoEXT
 
 instance ToCStruct DebugMarkerObjectTagInfoEXT where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugMarkerObjectTagInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -899,7 +899,7 @@
 deriving instance Show DebugMarkerMarkerInfoEXT
 
 instance ToCStruct DebugMarkerMarkerInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugMarkerMarkerInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_debug_report.hs b/src/Vulkan/Extensions/VK_EXT_debug_report.hs
--- a/src/Vulkan/Extensions/VK_EXT_debug_report.hs
+++ b/src/Vulkan/Extensions/VK_EXT_debug_report.hs
@@ -395,7 +395,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -772,7 +772,7 @@
 deriving instance Show DebugReportCallbackCreateInfoEXT
 
 instance ToCStruct DebugReportCallbackCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugReportCallbackCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_debug_utils.hs b/src/Vulkan/Extensions/VK_EXT_debug_utils.hs
--- a/src/Vulkan/Extensions/VK_EXT_debug_utils.hs
+++ b/src/Vulkan/Extensions/VK_EXT_debug_utils.hs
@@ -532,7 +532,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -1421,7 +1421,7 @@
 deriving instance Show DebugUtilsObjectNameInfoEXT
 
 instance ToCStruct DebugUtilsObjectNameInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugUtilsObjectNameInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1512,7 +1512,7 @@
 deriving instance Show DebugUtilsObjectTagInfoEXT
 
 instance ToCStruct DebugUtilsObjectTagInfoEXT where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugUtilsObjectTagInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1589,7 +1589,7 @@
 deriving instance Show DebugUtilsLabelEXT
 
 instance ToCStruct DebugUtilsLabelEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugUtilsLabelEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1732,7 +1732,7 @@
 deriving instance Show DebugUtilsMessengerCreateInfoEXT
 
 instance ToCStruct DebugUtilsMessengerCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugUtilsMessengerCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1894,7 +1894,7 @@
 deriving instance Show DebugUtilsMessengerCallbackDataEXT
 
 instance ToCStruct DebugUtilsMessengerCallbackDataEXT where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DebugUtilsMessengerCallbackDataEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1907,15 +1907,15 @@
     pMessage'' <- ContT $ useAsCString (message)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr CChar))) pMessage''
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueLabels)) :: Word32))
-    pPQueueLabels' <- ContT $ allocaBytesAligned @DebugUtilsLabelEXT ((Data.Vector.length (queueLabels)) * 40) 8
+    pPQueueLabels' <- ContT $ allocaBytes @DebugUtilsLabelEXT ((Data.Vector.length (queueLabels)) * 40)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPQueueLabels' `plusPtr` (40 * (i)) :: Ptr DebugUtilsLabelEXT) (e) . ($ ())) (queueLabels)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr DebugUtilsLabelEXT))) (pPQueueLabels')
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (cmdBufLabels)) :: Word32))
-    pPCmdBufLabels' <- ContT $ allocaBytesAligned @DebugUtilsLabelEXT ((Data.Vector.length (cmdBufLabels)) * 40) 8
+    pPCmdBufLabels' <- ContT $ allocaBytes @DebugUtilsLabelEXT ((Data.Vector.length (cmdBufLabels)) * 40)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPCmdBufLabels' `plusPtr` (40 * (i)) :: Ptr DebugUtilsLabelEXT) (e) . ($ ())) (cmdBufLabels)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr DebugUtilsLabelEXT))) (pPCmdBufLabels')
     lift $ poke ((p `plusPtr` 80 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (objects)) :: Word32))
-    pPObjects' <- ContT $ allocaBytesAligned @DebugUtilsObjectNameInfoEXT ((Data.Vector.length (objects)) * 40) 8
+    pPObjects' <- ContT $ allocaBytes @DebugUtilsObjectNameInfoEXT ((Data.Vector.length (objects)) * 40)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPObjects' `plusPtr` (40 * (i)) :: Ptr DebugUtilsObjectNameInfoEXT) (e) . ($ ())) (objects)
     lift $ poke ((p `plusPtr` 88 :: Ptr (Ptr DebugUtilsObjectNameInfoEXT))) (pPObjects')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_EXT_depth_clip_enable.hs b/src/Vulkan/Extensions/VK_EXT_depth_clip_enable.hs
--- a/src/Vulkan/Extensions/VK_EXT_depth_clip_enable.hs
+++ b/src/Vulkan/Extensions/VK_EXT_depth_clip_enable.hs
@@ -118,7 +118,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -189,7 +189,7 @@
 deriving instance Show PhysicalDeviceDepthClipEnableFeaturesEXT
 
 instance ToCStruct PhysicalDeviceDepthClipEnableFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDepthClipEnableFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -248,7 +248,7 @@
 deriving instance Show PipelineRasterizationDepthClipStateCreateInfoEXT
 
 instance ToCStruct PipelineRasterizationDepthClipStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationDepthClipStateCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_device_memory_report.hs b/src/Vulkan/Extensions/VK_EXT_device_memory_report.hs
--- a/src/Vulkan/Extensions/VK_EXT_device_memory_report.hs
+++ b/src/Vulkan/Extensions/VK_EXT_device_memory_report.hs
@@ -259,7 +259,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -337,7 +337,7 @@
 deriving instance Show PhysicalDeviceDeviceMemoryReportFeaturesEXT
 
 instance ToCStruct PhysicalDeviceDeviceMemoryReportFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDeviceMemoryReportFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -414,7 +414,7 @@
 deriving instance Show DeviceDeviceMemoryReportCreateInfoEXT
 
 instance ToCStruct DeviceDeviceMemoryReportCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceDeviceMemoryReportCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -546,7 +546,7 @@
 deriving instance Show DeviceMemoryReportCallbackDataEXT
 
 instance ToCStruct DeviceMemoryReportCallbackDataEXT where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceMemoryReportCallbackDataEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_directfb_surface.hs b/src/Vulkan/Extensions/VK_EXT_directfb_surface.hs
--- a/src/Vulkan/Extensions/VK_EXT_directfb_surface.hs
+++ b/src/Vulkan/Extensions/VK_EXT_directfb_surface.hs
@@ -110,7 +110,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -328,7 +328,7 @@
 deriving instance Show DirectFBSurfaceCreateInfoEXT
 
 instance ToCStruct DirectFBSurfaceCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DirectFBSurfaceCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_discard_rectangles.hs b/src/Vulkan/Extensions/VK_EXT_discard_rectangles.hs
--- a/src/Vulkan/Extensions/VK_EXT_discard_rectangles.hs
+++ b/src/Vulkan/Extensions/VK_EXT_discard_rectangles.hs
@@ -143,7 +143,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -305,7 +305,7 @@
   lift $ unless (vkCmdSetDiscardRectangleEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetDiscardRectangleEXT is null" Nothing Nothing
   let vkCmdSetDiscardRectangleEXT' = mkVkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXTPtr
-  pPDiscardRectangles <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (discardRectangles)) * 16) 4
+  pPDiscardRectangles <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (discardRectangles)) * 16)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPDiscardRectangles `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (discardRectangles)
   lift $ traceAroundEvent "vkCmdSetDiscardRectangleEXT" (vkCmdSetDiscardRectangleEXT' (commandBufferHandle (commandBuffer)) (firstDiscardRectangle) ((fromIntegral (Data.Vector.length $ (discardRectangles)) :: Word32)) (pPDiscardRectangles))
   pure $ ()
@@ -340,7 +340,7 @@
 deriving instance Show PhysicalDeviceDiscardRectanglePropertiesEXT
 
 instance ToCStruct PhysicalDeviceDiscardRectanglePropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDiscardRectanglePropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -419,14 +419,14 @@
 deriving instance Show PipelineDiscardRectangleStateCreateInfoEXT
 
 instance ToCStruct PipelineDiscardRectangleStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineDiscardRectangleStateCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineDiscardRectangleStateCreateFlagsEXT)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr DiscardRectangleModeEXT)) (discardRectangleMode)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (discardRectangles)) :: Word32))
-    pPDiscardRectangles' <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (discardRectangles)) * 16) 4
+    pPDiscardRectangles' <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (discardRectangles)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDiscardRectangles' `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (discardRectangles)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Rect2D))) (pPDiscardRectangles')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_EXT_display_control.hs b/src/Vulkan/Extensions/VK_EXT_display_control.hs
--- a/src/Vulkan/Extensions/VK_EXT_display_control.hs
+++ b/src/Vulkan/Extensions/VK_EXT_display_control.hs
@@ -185,7 +185,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -563,7 +563,7 @@
 deriving instance Show DisplayPowerInfoEXT
 
 instance ToCStruct DisplayPowerInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPowerInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -613,7 +613,7 @@
 deriving instance Show DeviceEventInfoEXT
 
 instance ToCStruct DeviceEventInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceEventInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -667,7 +667,7 @@
 deriving instance Show DisplayEventInfoEXT
 
 instance ToCStruct DisplayEventInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayEventInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -734,7 +734,7 @@
 deriving instance Show SwapchainCounterCreateInfoEXT
 
 instance ToCStruct SwapchainCounterCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SwapchainCounterCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_display_surface_counter.hs b/src/Vulkan/Extensions/VK_EXT_display_surface_counter.hs
--- a/src/Vulkan/Extensions/VK_EXT_display_surface_counter.hs
+++ b/src/Vulkan/Extensions/VK_EXT_display_surface_counter.hs
@@ -122,7 +122,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -358,7 +358,7 @@
 deriving instance Show SurfaceCapabilities2EXT
 
 instance ToCStruct SurfaceCapabilities2EXT where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceCapabilities2EXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state.hs b/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state.hs
--- a/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state.hs
+++ b/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state.hs
@@ -179,7 +179,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -546,7 +546,7 @@
   lift $ unless (vkCmdSetViewportWithCountEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetViewportWithCountEXT is null" Nothing Nothing
   let vkCmdSetViewportWithCountEXT' = mkVkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXTPtr
-  pPViewports <- ContT $ allocaBytesAligned @Viewport ((Data.Vector.length (viewports)) * 24) 4
+  pPViewports <- ContT $ allocaBytes @Viewport ((Data.Vector.length (viewports)) * 24)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPViewports `plusPtr` (24 * (i)) :: Ptr Viewport) (e)) (viewports)
   lift $ traceAroundEvent "vkCmdSetViewportWithCountEXT" (vkCmdSetViewportWithCountEXT' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (viewports)) :: Word32)) (pPViewports))
   pure $ ()
@@ -649,7 +649,7 @@
   lift $ unless (vkCmdSetScissorWithCountEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetScissorWithCountEXT is null" Nothing Nothing
   let vkCmdSetScissorWithCountEXT' = mkVkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXTPtr
-  pPScissors <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (scissors)) * 16) 4
+  pPScissors <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (scissors)) * 16)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPScissors `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (scissors)
   lift $ traceAroundEvent "vkCmdSetScissorWithCountEXT" (vkCmdSetScissorWithCountEXT' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (scissors)) :: Word32)) (pPScissors))
   pure $ ()
@@ -842,20 +842,20 @@
   let pStridesLength = Data.Vector.length $ (strides)
   lift $ unless (fromIntegral pStridesLength == pBuffersLength || pStridesLength == 0) $
     throwIO $ IOError Nothing InvalidArgument "" "pStrides and pBuffers must have the same length" Nothing Nothing
-  pPBuffers <- ContT $ allocaBytesAligned @Buffer ((Data.Vector.length (buffers)) * 8) 8
+  pPBuffers <- ContT $ allocaBytes @Buffer ((Data.Vector.length (buffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPBuffers `plusPtr` (8 * (i)) :: Ptr Buffer) (e)) (buffers)
-  pPOffsets <- ContT $ allocaBytesAligned @DeviceSize ((Data.Vector.length (offsets)) * 8) 8
+  pPOffsets <- ContT $ allocaBytes @DeviceSize ((Data.Vector.length (offsets)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPOffsets `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) (offsets)
   pSizes <- if Data.Vector.null (sizes)
     then pure nullPtr
     else do
-      pPSizes <- ContT $ allocaBytesAligned @DeviceSize (((Data.Vector.length (sizes))) * 8) 8
+      pPSizes <- ContT $ allocaBytes @DeviceSize (((Data.Vector.length (sizes))) * 8)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPSizes `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) ((sizes))
       pure $ pPSizes
   pStrides <- if Data.Vector.null (strides)
     then pure nullPtr
     else do
-      pPStrides <- ContT $ allocaBytesAligned @DeviceSize (((Data.Vector.length (strides))) * 8) 8
+      pPStrides <- ContT $ allocaBytes @DeviceSize (((Data.Vector.length (strides))) * 8)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPStrides `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) ((strides))
       pure $ pPStrides
   lift $ traceAroundEvent "vkCmdBindVertexBuffers2EXT" (vkCmdBindVertexBuffers2EXT' (commandBufferHandle (commandBuffer)) (firstBinding) ((fromIntegral pBuffersLength :: Word32)) (pPBuffers) (pPOffsets) pSizes pStrides)
@@ -1422,7 +1422,7 @@
 deriving instance Show PhysicalDeviceExtendedDynamicStateFeaturesEXT
 
 instance ToCStruct PhysicalDeviceExtendedDynamicStateFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExtendedDynamicStateFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state2.hs b/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state2.hs
--- a/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state2.hs
+++ b/src/Vulkan/Extensions/VK_EXT_extended_dynamic_state2.hs
@@ -127,7 +127,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -616,7 +616,7 @@
 deriving instance Show PhysicalDeviceExtendedDynamicState2FeaturesEXT
 
 instance ToCStruct PhysicalDeviceExtendedDynamicState2FeaturesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExtendedDynamicState2FeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_external_memory_host.hs b/src/Vulkan/Extensions/VK_EXT_external_memory_host.hs
--- a/src/Vulkan/Extensions/VK_EXT_external_memory_host.hs
+++ b/src/Vulkan/Extensions/VK_EXT_external_memory_host.hs
@@ -182,7 +182,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -402,7 +402,7 @@
 deriving instance Show ImportMemoryHostPointerInfoEXT
 
 instance ToCStruct ImportMemoryHostPointerInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportMemoryHostPointerInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -462,7 +462,7 @@
 deriving instance Show MemoryHostPointerPropertiesEXT
 
 instance ToCStruct MemoryHostPointerPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryHostPointerPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -526,7 +526,7 @@
 deriving instance Show PhysicalDeviceExternalMemoryHostPropertiesEXT
 
 instance ToCStruct PhysicalDeviceExternalMemoryHostPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExternalMemoryHostPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_filter_cubic.hs b/src/Vulkan/Extensions/VK_EXT_filter_cubic.hs
--- a/src/Vulkan/Extensions/VK_EXT_filter_cubic.hs
+++ b/src/Vulkan/Extensions/VK_EXT_filter_cubic.hs
@@ -136,7 +136,7 @@
                                               , pattern EXT_FILTER_CUBIC_EXTENSION_NAME
                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -195,7 +195,7 @@
 deriving instance Show PhysicalDeviceImageViewImageFormatInfoEXT
 
 instance ToCStruct PhysicalDeviceImageViewImageFormatInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceImageViewImageFormatInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -268,7 +268,7 @@
 deriving instance Show FilterCubicImageViewImageFormatPropertiesEXT
 
 instance ToCStruct FilterCubicImageViewImageFormatPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FilterCubicImageViewImageFormatPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_fragment_density_map.hs b/src/Vulkan/Extensions/VK_EXT_fragment_density_map.hs
--- a/src/Vulkan/Extensions/VK_EXT_fragment_density_map.hs
+++ b/src/Vulkan/Extensions/VK_EXT_fragment_density_map.hs
@@ -183,7 +183,7 @@
                                                       , pattern EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME
                                                       ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -268,7 +268,7 @@
 deriving instance Show PhysicalDeviceFragmentDensityMapFeaturesEXT
 
 instance ToCStruct PhysicalDeviceFragmentDensityMapFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentDensityMapFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -348,7 +348,7 @@
 deriving instance Show PhysicalDeviceFragmentDensityMapPropertiesEXT
 
 instance ToCStruct PhysicalDeviceFragmentDensityMapPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentDensityMapPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -483,7 +483,7 @@
 deriving instance Show RenderPassFragmentDensityMapCreateInfoEXT
 
 instance ToCStruct RenderPassFragmentDensityMapCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassFragmentDensityMapCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_fragment_density_map2.hs b/src/Vulkan/Extensions/VK_EXT_fragment_density_map2.hs
--- a/src/Vulkan/Extensions/VK_EXT_fragment_density_map2.hs
+++ b/src/Vulkan/Extensions/VK_EXT_fragment_density_map2.hs
@@ -152,7 +152,7 @@
                                                        , pattern EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME
                                                        ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -217,7 +217,7 @@
 deriving instance Show PhysicalDeviceFragmentDensityMap2FeaturesEXT
 
 instance ToCStruct PhysicalDeviceFragmentDensityMap2FeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentDensityMap2FeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -297,7 +297,7 @@
 deriving instance Show PhysicalDeviceFragmentDensityMap2PropertiesEXT
 
 instance ToCStruct PhysicalDeviceFragmentDensityMap2PropertiesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentDensityMap2PropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_fragment_shader_interlock.hs b/src/Vulkan/Extensions/VK_EXT_fragment_shader_interlock.hs
--- a/src/Vulkan/Extensions/VK_EXT_fragment_shader_interlock.hs
+++ b/src/Vulkan/Extensions/VK_EXT_fragment_shader_interlock.hs
@@ -131,7 +131,7 @@
                                                            , pattern EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -200,7 +200,7 @@
 deriving instance Show PhysicalDeviceFragmentShaderInterlockFeaturesEXT
 
 instance ToCStruct PhysicalDeviceFragmentShaderInterlockFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShaderInterlockFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_full_screen_exclusive.hs b/src/Vulkan/Extensions/VK_EXT_full_screen_exclusive.hs
--- a/src/Vulkan/Extensions/VK_EXT_full_screen_exclusive.hs
+++ b/src/Vulkan/Extensions/VK_EXT_full_screen_exclusive.hs
@@ -287,7 +287,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -688,7 +688,7 @@
 deriving instance Show SurfaceFullScreenExclusiveInfoEXT
 
 instance ToCStruct SurfaceFullScreenExclusiveInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceFullScreenExclusiveInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -758,7 +758,7 @@
 deriving instance Show SurfaceFullScreenExclusiveWin32InfoEXT
 
 instance ToCStruct SurfaceFullScreenExclusiveWin32InfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceFullScreenExclusiveWin32InfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -822,7 +822,7 @@
 deriving instance Show SurfaceCapabilitiesFullScreenExclusiveEXT
 
 instance ToCStruct SurfaceCapabilitiesFullScreenExclusiveEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceCapabilitiesFullScreenExclusiveEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_global_priority.hs b/src/Vulkan/Extensions/VK_EXT_global_priority.hs
--- a/src/Vulkan/Extensions/VK_EXT_global_priority.hs
+++ b/src/Vulkan/Extensions/VK_EXT_global_priority.hs
@@ -134,7 +134,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -187,7 +187,7 @@
 deriving instance Show DeviceQueueGlobalPriorityCreateInfoEXT
 
 instance ToCStruct DeviceQueueGlobalPriorityCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceQueueGlobalPriorityCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_global_priority_query.hs b/src/Vulkan/Extensions/VK_EXT_global_priority_query.hs
--- a/src/Vulkan/Extensions/VK_EXT_global_priority_query.hs
+++ b/src/Vulkan/Extensions/VK_EXT_global_priority_query.hs
@@ -128,7 +128,7 @@
 
 import Vulkan.CStruct.Utils (FixedArray)
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -205,7 +205,7 @@
 deriving instance Show PhysicalDeviceGlobalPriorityQueryFeaturesEXT
 
 instance ToCStruct PhysicalDeviceGlobalPriorityQueryFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceGlobalPriorityQueryFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -291,7 +291,7 @@
 deriving instance Show QueueFamilyGlobalPriorityPropertiesEXT
 
 instance ToCStruct QueueFamilyGlobalPriorityPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueueFamilyGlobalPriorityPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_hdr_metadata.hs b/src/Vulkan/Extensions/VK_EXT_hdr_metadata.hs
--- a/src/Vulkan/Extensions/VK_EXT_hdr_metadata.hs
+++ b/src/Vulkan/Extensions/VK_EXT_hdr_metadata.hs
@@ -130,7 +130,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -226,9 +226,9 @@
   let pSwapchainsLength = Data.Vector.length $ (swapchains)
   lift $ unless ((Data.Vector.length $ (metadata)) == pSwapchainsLength) $
     throwIO $ IOError Nothing InvalidArgument "" "pMetadata and pSwapchains must have the same length" Nothing Nothing
-  pPSwapchains <- ContT $ allocaBytesAligned @SwapchainKHR ((Data.Vector.length (swapchains)) * 8) 8
+  pPSwapchains <- ContT $ allocaBytes @SwapchainKHR ((Data.Vector.length (swapchains)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPSwapchains `plusPtr` (8 * (i)) :: Ptr SwapchainKHR) (e)) (swapchains)
-  pPMetadata <- ContT $ allocaBytesAligned @HdrMetadataEXT ((Data.Vector.length (metadata)) * 64) 8
+  pPMetadata <- ContT $ allocaBytes @HdrMetadataEXT ((Data.Vector.length (metadata)) * 64)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPMetadata `plusPtr` (64 * (i)) :: Ptr HdrMetadataEXT) (e)) (metadata)
   lift $ traceAroundEvent "vkSetHdrMetadataEXT" (vkSetHdrMetadataEXT' (deviceHandle (device)) ((fromIntegral pSwapchainsLength :: Word32)) (pPSwapchains) (pPMetadata))
   pure $ ()
@@ -252,7 +252,7 @@
 deriving instance Show XYColorEXT
 
 instance ToCStruct XYColorEXT where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p XYColorEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (x))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (y))
@@ -325,7 +325,7 @@
 deriving instance Show HdrMetadataEXT
 
 instance ToCStruct HdrMetadataEXT where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p HdrMetadataEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_HDR_METADATA_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_headless_surface.hs b/src/Vulkan/Extensions/VK_EXT_headless_surface.hs
--- a/src/Vulkan/Extensions/VK_EXT_headless_surface.hs
+++ b/src/Vulkan/Extensions/VK_EXT_headless_surface.hs
@@ -118,7 +118,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -266,7 +266,7 @@
 deriving instance Show HeadlessSurfaceCreateInfoEXT
 
 instance ToCStruct HeadlessSurfaceCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p HeadlessSurfaceCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_image_drm_format_modifier.hs b/src/Vulkan/Extensions/VK_EXT_image_drm_format_modifier.hs
--- a/src/Vulkan/Extensions/VK_EXT_image_drm_format_modifier.hs
+++ b/src/Vulkan/Extensions/VK_EXT_image_drm_format_modifier.hs
@@ -542,7 +542,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -688,7 +688,7 @@
 deriving instance Show DrmFormatModifierPropertiesListEXT
 
 instance ToCStruct DrmFormatModifierPropertiesListEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DrmFormatModifierPropertiesListEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -828,7 +828,7 @@
 deriving instance Show DrmFormatModifierPropertiesEXT
 
 instance ToCStruct DrmFormatModifierPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DrmFormatModifierPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word64)) (drmFormatModifier)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (drmFormatModifierPlaneCount)
@@ -933,14 +933,14 @@
 deriving instance Show PhysicalDeviceImageDrmFormatModifierInfoEXT
 
 instance ToCStruct PhysicalDeviceImageDrmFormatModifierInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceImageDrmFormatModifierInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word64)) (drmFormatModifier)
     lift $ poke ((p `plusPtr` 24 :: Ptr SharingMode)) (sharingMode)
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueFamilyIndices)) :: Word32))
-    pPQueueFamilyIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4) 4
+    pPQueueFamilyIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPQueueFamilyIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (queueFamilyIndices)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Word32))) (pPQueueFamilyIndices')
     lift $ f
@@ -1009,12 +1009,12 @@
 deriving instance Show ImageDrmFormatModifierListCreateInfoEXT
 
 instance ToCStruct ImageDrmFormatModifierListCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageDrmFormatModifierListCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (drmFormatModifiers)) :: Word32))
-    pPDrmFormatModifiers' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (drmFormatModifiers)) * 8) 8
+    pPDrmFormatModifiers' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (drmFormatModifiers)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDrmFormatModifiers' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (drmFormatModifiers)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word64))) (pPDrmFormatModifiers')
     lift $ f
@@ -1120,13 +1120,13 @@
 deriving instance Show ImageDrmFormatModifierExplicitCreateInfoEXT
 
 instance ToCStruct ImageDrmFormatModifierExplicitCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageDrmFormatModifierExplicitCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word64)) (drmFormatModifier)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (planeLayouts)) :: Word32))
-    pPPlaneLayouts' <- ContT $ allocaBytesAligned @SubresourceLayout ((Data.Vector.length (planeLayouts)) * 40) 8
+    pPPlaneLayouts' <- ContT $ allocaBytes @SubresourceLayout ((Data.Vector.length (planeLayouts)) * 40)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPlaneLayouts' `plusPtr` (40 * (i)) :: Ptr SubresourceLayout) (e)) (planeLayouts)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr SubresourceLayout))) (pPPlaneLayouts')
     lift $ f
@@ -1185,7 +1185,7 @@
 deriving instance Show ImageDrmFormatModifierPropertiesEXT
 
 instance ToCStruct ImageDrmFormatModifierPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageDrmFormatModifierPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_image_robustness.hs b/src/Vulkan/Extensions/VK_EXT_image_robustness.hs
--- a/src/Vulkan/Extensions/VK_EXT_image_robustness.hs
+++ b/src/Vulkan/Extensions/VK_EXT_image_robustness.hs
@@ -116,7 +116,7 @@
                                                   , pattern EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME
                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -181,7 +181,7 @@
 deriving instance Show PhysicalDeviceImageRobustnessFeaturesEXT
 
 instance ToCStruct PhysicalDeviceImageRobustnessFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceImageRobustnessFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_index_type_uint8.hs b/src/Vulkan/Extensions/VK_EXT_index_type_uint8.hs
--- a/src/Vulkan/Extensions/VK_EXT_index_type_uint8.hs
+++ b/src/Vulkan/Extensions/VK_EXT_index_type_uint8.hs
@@ -89,7 +89,7 @@
                                                   , pattern EXT_INDEX_TYPE_UINT8_EXTENSION_NAME
                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -148,7 +148,7 @@
 deriving instance Show PhysicalDeviceIndexTypeUint8FeaturesEXT
 
 instance ToCStruct PhysicalDeviceIndexTypeUint8FeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceIndexTypeUint8FeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_inline_uniform_block.hs b/src/Vulkan/Extensions/VK_EXT_inline_uniform_block.hs
--- a/src/Vulkan/Extensions/VK_EXT_inline_uniform_block.hs
+++ b/src/Vulkan/Extensions/VK_EXT_inline_uniform_block.hs
@@ -184,7 +184,7 @@
                                                       , pattern EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME
                                                       ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -258,7 +258,7 @@
 deriving instance Show PhysicalDeviceInlineUniformBlockFeaturesEXT
 
 instance ToCStruct PhysicalDeviceInlineUniformBlockFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceInlineUniformBlockFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -353,7 +353,7 @@
 deriving instance Show PhysicalDeviceInlineUniformBlockPropertiesEXT
 
 instance ToCStruct PhysicalDeviceInlineUniformBlockPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceInlineUniformBlockPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -432,7 +432,7 @@
 deriving instance Show WriteDescriptorSetInlineUniformBlockEXT
 
 instance ToCStruct WriteDescriptorSetInlineUniformBlockEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p WriteDescriptorSetInlineUniformBlockEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -487,7 +487,7 @@
 deriving instance Show DescriptorPoolInlineUniformBlockCreateInfoEXT
 
 instance ToCStruct DescriptorPoolInlineUniformBlockCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DescriptorPoolInlineUniformBlockCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_line_rasterization.hs b/src/Vulkan/Extensions/VK_EXT_line_rasterization.hs
--- a/src/Vulkan/Extensions/VK_EXT_line_rasterization.hs
+++ b/src/Vulkan/Extensions/VK_EXT_line_rasterization.hs
@@ -152,7 +152,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -328,7 +328,7 @@
 deriving instance Show PhysicalDeviceLineRasterizationFeaturesEXT
 
 instance ToCStruct PhysicalDeviceLineRasterizationFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceLineRasterizationFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -410,7 +410,7 @@
 deriving instance Show PhysicalDeviceLineRasterizationPropertiesEXT
 
 instance ToCStruct PhysicalDeviceLineRasterizationPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceLineRasterizationPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -529,7 +529,7 @@
 deriving instance Show PipelineRasterizationLineStateCreateInfoEXT
 
 instance ToCStruct PipelineRasterizationLineStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationLineStateCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_memory_budget.hs b/src/Vulkan/Extensions/VK_EXT_memory_budget.hs
--- a/src/Vulkan/Extensions/VK_EXT_memory_budget.hs
+++ b/src/Vulkan/Extensions/VK_EXT_memory_budget.hs
@@ -110,7 +110,7 @@
 
 import Vulkan.CStruct.Utils (FixedArray)
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -184,7 +184,7 @@
 deriving instance Show PhysicalDeviceMemoryBudgetPropertiesEXT
 
 instance ToCStruct PhysicalDeviceMemoryBudgetPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 272 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 272 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMemoryBudgetPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_memory_priority.hs b/src/Vulkan/Extensions/VK_EXT_memory_priority.hs
--- a/src/Vulkan/Extensions/VK_EXT_memory_priority.hs
+++ b/src/Vulkan/Extensions/VK_EXT_memory_priority.hs
@@ -99,7 +99,7 @@
                                                  , pattern EXT_MEMORY_PRIORITY_EXTENSION_NAME
                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Data.Coerce (coerce)
@@ -163,7 +163,7 @@
 deriving instance Show PhysicalDeviceMemoryPriorityFeaturesEXT
 
 instance ToCStruct PhysicalDeviceMemoryPriorityFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMemoryPriorityFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -225,7 +225,7 @@
 deriving instance Show MemoryPriorityAllocateInfoEXT
 
 instance ToCStruct MemoryPriorityAllocateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryPriorityAllocateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_metal_surface.hs b/src/Vulkan/Extensions/VK_EXT_metal_surface.hs
--- a/src/Vulkan/Extensions/VK_EXT_metal_surface.hs
+++ b/src/Vulkan/Extensions/VK_EXT_metal_surface.hs
@@ -108,7 +108,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -260,7 +260,7 @@
 deriving instance Show MetalSurfaceCreateInfoEXT
 
 instance ToCStruct MetalSurfaceCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MetalSurfaceCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_multi_draw.hs b/src/Vulkan/Extensions/VK_EXT_multi_draw.hs
--- a/src/Vulkan/Extensions/VK_EXT_multi_draw.hs
+++ b/src/Vulkan/Extensions/VK_EXT_multi_draw.hs
@@ -136,7 +136,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Utils (with)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -798,7 +798,7 @@
   lift $ unless (vkCmdDrawMultiEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdDrawMultiEXT is null" Nothing Nothing
   let vkCmdDrawMultiEXT' = mkVkCmdDrawMultiEXT vkCmdDrawMultiEXTPtr
-  pPVertexInfo <- ContT $ allocaBytesAligned @MultiDrawInfoEXT ((Data.Vector.length (vertexInfo)) * 8) 4
+  pPVertexInfo <- ContT $ allocaBytes @MultiDrawInfoEXT ((Data.Vector.length (vertexInfo)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexInfo `plusPtr` (8 * (i)) :: Ptr MultiDrawInfoEXT) (e)) (vertexInfo)
   lift $ traceAroundEvent "vkCmdDrawMultiEXT" (vkCmdDrawMultiEXT' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (vertexInfo)) :: Word32)) (pPVertexInfo) (instanceCount) (firstInstance) (stride))
   pure $ ()
@@ -1444,7 +1444,7 @@
   lift $ unless (vkCmdDrawMultiIndexedEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdDrawMultiIndexedEXT is null" Nothing Nothing
   let vkCmdDrawMultiIndexedEXT' = mkVkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXTPtr
-  pPIndexInfo <- ContT $ allocaBytesAligned @MultiDrawIndexedInfoEXT ((Data.Vector.length (indexInfo)) * 12) 4
+  pPIndexInfo <- ContT $ allocaBytes @MultiDrawIndexedInfoEXT ((Data.Vector.length (indexInfo)) * 12)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPIndexInfo `plusPtr` (12 * (i)) :: Ptr MultiDrawIndexedInfoEXT) (e)) (indexInfo)
   pVertexOffset <- case (vertexOffset) of
     Nothing -> pure nullPtr
@@ -1477,7 +1477,7 @@
 deriving instance Show MultiDrawInfoEXT
 
 instance ToCStruct MultiDrawInfoEXT where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MultiDrawInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (firstVertex)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (vertexCount)
@@ -1536,7 +1536,7 @@
 deriving instance Show MultiDrawIndexedInfoEXT
 
 instance ToCStruct MultiDrawIndexedInfoEXT where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MultiDrawIndexedInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (firstIndex)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (indexCount)
@@ -1605,7 +1605,7 @@
 deriving instance Show PhysicalDeviceMultiDrawPropertiesEXT
 
 instance ToCStruct PhysicalDeviceMultiDrawPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMultiDrawPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1673,7 +1673,7 @@
 deriving instance Show PhysicalDeviceMultiDrawFeaturesEXT
 
 instance ToCStruct PhysicalDeviceMultiDrawFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMultiDrawFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_pci_bus_info.hs b/src/Vulkan/Extensions/VK_EXT_pci_bus_info.hs
--- a/src/Vulkan/Extensions/VK_EXT_pci_bus_info.hs
+++ b/src/Vulkan/Extensions/VK_EXT_pci_bus_info.hs
@@ -104,7 +104,7 @@
                                               , pattern EXT_PCI_BUS_INFO_EXTENSION_NAME
                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -161,7 +161,7 @@
 deriving instance Show PhysicalDevicePCIBusInfoPropertiesEXT
 
 instance ToCStruct PhysicalDevicePCIBusInfoPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePCIBusInfoPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_physical_device_drm.hs b/src/Vulkan/Extensions/VK_EXT_physical_device_drm.hs
--- a/src/Vulkan/Extensions/VK_EXT_physical_device_drm.hs
+++ b/src/Vulkan/Extensions/VK_EXT_physical_device_drm.hs
@@ -108,7 +108,7 @@
                                                      , pattern EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -175,7 +175,7 @@
 deriving instance Show PhysicalDeviceDrmPropertiesEXT
 
 instance ToCStruct PhysicalDeviceDrmPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDrmPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_pipeline_creation_cache_control.hs b/src/Vulkan/Extensions/VK_EXT_pipeline_creation_cache_control.hs
--- a/src/Vulkan/Extensions/VK_EXT_pipeline_creation_cache_control.hs
+++ b/src/Vulkan/Extensions/VK_EXT_pipeline_creation_cache_control.hs
@@ -208,7 +208,7 @@
                                                                  , pattern EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME
                                                                  ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -284,7 +284,7 @@
 deriving instance Show PhysicalDevicePipelineCreationCacheControlFeaturesEXT
 
 instance ToCStruct PhysicalDevicePipelineCreationCacheControlFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePipelineCreationCacheControlFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_pipeline_creation_feedback.hs b/src/Vulkan/Extensions/VK_EXT_pipeline_creation_feedback.hs
--- a/src/Vulkan/Extensions/VK_EXT_pipeline_creation_feedback.hs
+++ b/src/Vulkan/Extensions/VK_EXT_pipeline_creation_feedback.hs
@@ -131,7 +131,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -190,7 +190,7 @@
 deriving instance Show PipelineCreationFeedbackEXT
 
 instance ToCStruct PipelineCreationFeedbackEXT where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCreationFeedbackEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr PipelineCreationFeedbackFlagsEXT)) (flags)
     poke ((p `plusPtr` 8 :: Ptr Word64)) (duration)
@@ -323,7 +323,7 @@
 deriving instance Show PipelineCreationFeedbackCreateInfoEXT
 
 instance ToCStruct PipelineCreationFeedbackCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCreationFeedbackCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_private_data.hs b/src/Vulkan/Extensions/VK_EXT_private_data.hs
--- a/src/Vulkan/Extensions/VK_EXT_private_data.hs
+++ b/src/Vulkan/Extensions/VK_EXT_private_data.hs
@@ -159,7 +159,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -538,7 +538,7 @@
 deriving instance Show DevicePrivateDataCreateInfoEXT
 
 instance ToCStruct DevicePrivateDataCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DevicePrivateDataCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -593,7 +593,7 @@
 deriving instance Show PrivateDataSlotCreateInfoEXT
 
 instance ToCStruct PrivateDataSlotCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PrivateDataSlotCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -661,7 +661,7 @@
 deriving instance Show PhysicalDevicePrivateDataFeaturesEXT
 
 instance ToCStruct PhysicalDevicePrivateDataFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePrivateDataFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_provoking_vertex.hs b/src/Vulkan/Extensions/VK_EXT_provoking_vertex.hs
--- a/src/Vulkan/Extensions/VK_EXT_provoking_vertex.hs
+++ b/src/Vulkan/Extensions/VK_EXT_provoking_vertex.hs
@@ -195,7 +195,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -279,7 +279,7 @@
 deriving instance Show PhysicalDeviceProvokingVertexFeaturesEXT
 
 instance ToCStruct PhysicalDeviceProvokingVertexFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProvokingVertexFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -351,7 +351,7 @@
 deriving instance Show PhysicalDeviceProvokingVertexPropertiesEXT
 
 instance ToCStruct PhysicalDeviceProvokingVertexPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceProvokingVertexPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -433,7 +433,7 @@
 deriving instance Show PipelineRasterizationProvokingVertexStateCreateInfoEXT
 
 instance ToCStruct PipelineRasterizationProvokingVertexStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationProvokingVertexStateCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_robustness2.hs b/src/Vulkan/Extensions/VK_EXT_robustness2.hs
--- a/src/Vulkan/Extensions/VK_EXT_robustness2.hs
+++ b/src/Vulkan/Extensions/VK_EXT_robustness2.hs
@@ -132,7 +132,7 @@
                                              , pattern EXT_ROBUSTNESS_2_EXTENSION_NAME
                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -238,7 +238,7 @@
 deriving instance Show PhysicalDeviceRobustness2FeaturesEXT
 
 instance ToCStruct PhysicalDeviceRobustness2FeaturesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRobustness2FeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -319,7 +319,7 @@
 deriving instance Show PhysicalDeviceRobustness2PropertiesEXT
 
 instance ToCStruct PhysicalDeviceRobustness2PropertiesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRobustness2PropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_sample_locations.hs b/src/Vulkan/Extensions/VK_EXT_sample_locations.hs
--- a/src/Vulkan/Extensions/VK_EXT_sample_locations.hs
+++ b/src/Vulkan/Extensions/VK_EXT_sample_locations.hs
@@ -187,7 +187,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -405,7 +405,7 @@
 deriving instance Show SampleLocationEXT
 
 instance ToCStruct SampleLocationEXT where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SampleLocationEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (x))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (y))
@@ -505,14 +505,14 @@
 deriving instance Show SampleLocationsInfoEXT
 
 instance ToCStruct SampleLocationsInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SampleLocationsInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr SampleCountFlagBits)) (sampleLocationsPerPixel)
     lift $ poke ((p `plusPtr` 20 :: Ptr Extent2D)) (sampleLocationGridSize)
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (sampleLocations)) :: Word32))
-    pPSampleLocations' <- ContT $ allocaBytesAligned @SampleLocationEXT ((Data.Vector.length (sampleLocations)) * 8) 4
+    pPSampleLocations' <- ContT $ allocaBytes @SampleLocationEXT ((Data.Vector.length (sampleLocations)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSampleLocations' `plusPtr` (8 * (i)) :: Ptr SampleLocationEXT) (e)) (sampleLocations)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr SampleLocationEXT))) (pPSampleLocations')
     lift $ f
@@ -584,7 +584,7 @@
 deriving instance Show AttachmentSampleLocationsEXT
 
 instance ToCStruct AttachmentSampleLocationsEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AttachmentSampleLocationsEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) (attachmentIndex)
     ContT $ pokeCStruct ((p `plusPtr` 8 :: Ptr SampleLocationsInfoEXT)) (sampleLocationsInfo) . ($ ())
@@ -655,7 +655,7 @@
 deriving instance Show SubpassSampleLocationsEXT
 
 instance ToCStruct SubpassSampleLocationsEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubpassSampleLocationsEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) (subpassIndex)
     ContT $ pokeCStruct ((p `plusPtr` 8 :: Ptr SampleLocationsInfoEXT)) (sampleLocationsInfo) . ($ ())
@@ -744,16 +744,16 @@
 deriving instance Show RenderPassSampleLocationsBeginInfoEXT
 
 instance ToCStruct RenderPassSampleLocationsBeginInfoEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassSampleLocationsBeginInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (attachmentInitialSampleLocations)) :: Word32))
-    pPAttachmentInitialSampleLocations' <- ContT $ allocaBytesAligned @AttachmentSampleLocationsEXT ((Data.Vector.length (attachmentInitialSampleLocations)) * 48) 8
+    pPAttachmentInitialSampleLocations' <- ContT $ allocaBytes @AttachmentSampleLocationsEXT ((Data.Vector.length (attachmentInitialSampleLocations)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPAttachmentInitialSampleLocations' `plusPtr` (48 * (i)) :: Ptr AttachmentSampleLocationsEXT) (e) . ($ ())) (attachmentInitialSampleLocations)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr AttachmentSampleLocationsEXT))) (pPAttachmentInitialSampleLocations')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (postSubpassSampleLocations)) :: Word32))
-    pPPostSubpassSampleLocations' <- ContT $ allocaBytesAligned @SubpassSampleLocationsEXT ((Data.Vector.length (postSubpassSampleLocations)) * 48) 8
+    pPPostSubpassSampleLocations' <- ContT $ allocaBytes @SubpassSampleLocationsEXT ((Data.Vector.length (postSubpassSampleLocations)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPPostSubpassSampleLocations' `plusPtr` (48 * (i)) :: Ptr SubpassSampleLocationsEXT) (e) . ($ ())) (postSubpassSampleLocations)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr SubpassSampleLocationsEXT))) (pPPostSubpassSampleLocations')
     lift $ f
@@ -814,7 +814,7 @@
 deriving instance Show PipelineSampleLocationsStateCreateInfoEXT
 
 instance ToCStruct PipelineSampleLocationsStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineSampleLocationsStateCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -896,7 +896,7 @@
 deriving instance Show PhysicalDeviceSampleLocationsPropertiesEXT
 
 instance ToCStruct PhysicalDeviceSampleLocationsPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSampleLocationsPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -974,7 +974,7 @@
 deriving instance Show MultisamplePropertiesEXT
 
 instance ToCStruct MultisamplePropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MultisamplePropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_shader_atomic_float.hs b/src/Vulkan/Extensions/VK_EXT_shader_atomic_float.hs
--- a/src/Vulkan/Extensions/VK_EXT_shader_atomic_float.hs
+++ b/src/Vulkan/Extensions/VK_EXT_shader_atomic_float.hs
@@ -107,7 +107,7 @@
                                                      , pattern EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -211,7 +211,7 @@
 deriving instance Show PhysicalDeviceShaderAtomicFloatFeaturesEXT
 
 instance ToCStruct PhysicalDeviceShaderAtomicFloatFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderAtomicFloatFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_shader_demote_to_helper_invocation.hs b/src/Vulkan/Extensions/VK_EXT_shader_demote_to_helper_invocation.hs
--- a/src/Vulkan/Extensions/VK_EXT_shader_demote_to_helper_invocation.hs
+++ b/src/Vulkan/Extensions/VK_EXT_shader_demote_to_helper_invocation.hs
@@ -104,7 +104,7 @@
                                                                     , pattern EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME
                                                                     ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -165,7 +165,7 @@
 deriving instance Show PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
 
 instance ToCStruct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_shader_image_atomic_int64.hs b/src/Vulkan/Extensions/VK_EXT_shader_image_atomic_int64.hs
--- a/src/Vulkan/Extensions/VK_EXT_shader_image_atomic_int64.hs
+++ b/src/Vulkan/Extensions/VK_EXT_shader_image_atomic_int64.hs
@@ -115,7 +115,7 @@
                                                            , pattern EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -178,7 +178,7 @@
 deriving instance Show PhysicalDeviceShaderImageAtomicInt64FeaturesEXT
 
 instance ToCStruct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderImageAtomicInt64FeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_subgroup_size_control.hs b/src/Vulkan/Extensions/VK_EXT_subgroup_size_control.hs
--- a/src/Vulkan/Extensions/VK_EXT_subgroup_size_control.hs
+++ b/src/Vulkan/Extensions/VK_EXT_subgroup_size_control.hs
@@ -170,7 +170,7 @@
                                                        , pattern EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME
                                                        ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -260,7 +260,7 @@
 deriving instance Show PhysicalDeviceSubgroupSizeControlFeaturesEXT
 
 instance ToCStruct PhysicalDeviceSubgroupSizeControlFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSubgroupSizeControlFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -355,7 +355,7 @@
 deriving instance Show PhysicalDeviceSubgroupSizeControlPropertiesEXT
 
 instance ToCStruct PhysicalDeviceSubgroupSizeControlPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSubgroupSizeControlPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -436,7 +436,7 @@
 deriving instance Show PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
 
 instance ToCStruct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_texel_buffer_alignment.hs b/src/Vulkan/Extensions/VK_EXT_texel_buffer_alignment.hs
--- a/src/Vulkan/Extensions/VK_EXT_texel_buffer_alignment.hs
+++ b/src/Vulkan/Extensions/VK_EXT_texel_buffer_alignment.hs
@@ -98,7 +98,7 @@
                                                         , pattern EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -161,7 +161,7 @@
 deriving instance Show PhysicalDeviceTexelBufferAlignmentFeaturesEXT
 
 instance ToCStruct PhysicalDeviceTexelBufferAlignmentFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTexelBufferAlignmentFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -254,7 +254,7 @@
 deriving instance Show PhysicalDeviceTexelBufferAlignmentPropertiesEXT
 
 instance ToCStruct PhysicalDeviceTexelBufferAlignmentPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTexelBufferAlignmentPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_texture_compression_astc_hdr.hs b/src/Vulkan/Extensions/VK_EXT_texture_compression_astc_hdr.hs
--- a/src/Vulkan/Extensions/VK_EXT_texture_compression_astc_hdr.hs
+++ b/src/Vulkan/Extensions/VK_EXT_texture_compression_astc_hdr.hs
@@ -147,7 +147,7 @@
                                                               , pattern EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME
                                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -248,7 +248,7 @@
 deriving instance Show PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
 
 instance ToCStruct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_tooling_info.hs b/src/Vulkan/Extensions/VK_EXT_tooling_info.hs
--- a/src/Vulkan/Extensions/VK_EXT_tooling_info.hs
+++ b/src/Vulkan/Extensions/VK_EXT_tooling_info.hs
@@ -192,7 +192,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -365,7 +365,7 @@
 deriving instance Show PhysicalDeviceToolPropertiesEXT
 
 instance ToCStruct PhysicalDeviceToolPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 1048 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 1048 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceToolPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_transform_feedback.hs b/src/Vulkan/Extensions/VK_EXT_transform_feedback.hs
--- a/src/Vulkan/Extensions/VK_EXT_transform_feedback.hs
+++ b/src/Vulkan/Extensions/VK_EXT_transform_feedback.hs
@@ -255,7 +255,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -472,14 +472,14 @@
   let pSizesLength = Data.Vector.length $ (sizes)
   lift $ unless (fromIntegral pSizesLength == pBuffersLength || pSizesLength == 0) $
     throwIO $ IOError Nothing InvalidArgument "" "pSizes and pBuffers must have the same length" Nothing Nothing
-  pPBuffers <- ContT $ allocaBytesAligned @Buffer ((Data.Vector.length (buffers)) * 8) 8
+  pPBuffers <- ContT $ allocaBytes @Buffer ((Data.Vector.length (buffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPBuffers `plusPtr` (8 * (i)) :: Ptr Buffer) (e)) (buffers)
-  pPOffsets <- ContT $ allocaBytesAligned @DeviceSize ((Data.Vector.length (offsets)) * 8) 8
+  pPOffsets <- ContT $ allocaBytes @DeviceSize ((Data.Vector.length (offsets)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPOffsets `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) (offsets)
   pSizes <- if Data.Vector.null (sizes)
     then pure nullPtr
     else do
-      pPSizes <- ContT $ allocaBytesAligned @DeviceSize (((Data.Vector.length (sizes))) * 8) 8
+      pPSizes <- ContT $ allocaBytes @DeviceSize (((Data.Vector.length (sizes))) * 8)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPSizes `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) ((sizes))
       pure $ pPSizes
   lift $ traceAroundEvent "vkCmdBindTransformFeedbackBuffersEXT" (vkCmdBindTransformFeedbackBuffersEXT' (commandBufferHandle (commandBuffer)) (firstBinding) ((fromIntegral pBuffersLength :: Word32)) (pPBuffers) (pPOffsets) pSizes)
@@ -642,12 +642,12 @@
   let pCounterBufferOffsetsLength = Data.Vector.length $ (counterBufferOffsets)
   lift $ unless (fromIntegral pCounterBufferOffsetsLength == pCounterBuffersLength || pCounterBufferOffsetsLength == 0) $
     throwIO $ IOError Nothing InvalidArgument "" "pCounterBufferOffsets and pCounterBuffers must have the same length" Nothing Nothing
-  pPCounterBuffers <- ContT $ allocaBytesAligned @Buffer ((Data.Vector.length (counterBuffers)) * 8) 8
+  pPCounterBuffers <- ContT $ allocaBytes @Buffer ((Data.Vector.length (counterBuffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPCounterBuffers `plusPtr` (8 * (i)) :: Ptr Buffer) (e)) (counterBuffers)
   pCounterBufferOffsets <- if Data.Vector.null (counterBufferOffsets)
     then pure nullPtr
     else do
-      pPCounterBufferOffsets <- ContT $ allocaBytesAligned @DeviceSize (((Data.Vector.length (counterBufferOffsets))) * 8) 8
+      pPCounterBufferOffsets <- ContT $ allocaBytes @DeviceSize (((Data.Vector.length (counterBufferOffsets))) * 8)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPCounterBufferOffsets `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) ((counterBufferOffsets))
       pure $ pPCounterBufferOffsets
   lift $ traceAroundEvent "vkCmdBeginTransformFeedbackEXT" (vkCmdBeginTransformFeedbackEXT' (commandBufferHandle (commandBuffer)) (firstCounterBuffer) ((fromIntegral pCounterBuffersLength :: Word32)) (pPCounterBuffers) pCounterBufferOffsets)
@@ -800,12 +800,12 @@
   let pCounterBufferOffsetsLength = Data.Vector.length $ (counterBufferOffsets)
   lift $ unless (fromIntegral pCounterBufferOffsetsLength == pCounterBuffersLength || pCounterBufferOffsetsLength == 0) $
     throwIO $ IOError Nothing InvalidArgument "" "pCounterBufferOffsets and pCounterBuffers must have the same length" Nothing Nothing
-  pPCounterBuffers <- ContT $ allocaBytesAligned @Buffer ((Data.Vector.length (counterBuffers)) * 8) 8
+  pPCounterBuffers <- ContT $ allocaBytes @Buffer ((Data.Vector.length (counterBuffers)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPCounterBuffers `plusPtr` (8 * (i)) :: Ptr Buffer) (e)) (counterBuffers)
   pCounterBufferOffsets <- if Data.Vector.null (counterBufferOffsets)
     then pure nullPtr
     else do
-      pPCounterBufferOffsets <- ContT $ allocaBytesAligned @DeviceSize (((Data.Vector.length (counterBufferOffsets))) * 8) 8
+      pPCounterBufferOffsets <- ContT $ allocaBytes @DeviceSize (((Data.Vector.length (counterBufferOffsets))) * 8)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPCounterBufferOffsets `plusPtr` (8 * (i)) :: Ptr DeviceSize) (e)) ((counterBufferOffsets))
       pure $ pPCounterBufferOffsets
   lift $ traceAroundEvent "vkCmdEndTransformFeedbackEXT" (vkCmdEndTransformFeedbackEXT' (commandBufferHandle (commandBuffer)) (firstCounterBuffer) ((fromIntegral pCounterBuffersLength :: Word32)) (pPCounterBuffers) pCounterBufferOffsets)
@@ -1849,7 +1849,7 @@
 deriving instance Show PhysicalDeviceTransformFeedbackFeaturesEXT
 
 instance ToCStruct PhysicalDeviceTransformFeedbackFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTransformFeedbackFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1971,7 +1971,7 @@
 deriving instance Show PhysicalDeviceTransformFeedbackPropertiesEXT
 
 instance ToCStruct PhysicalDeviceTransformFeedbackPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceTransformFeedbackPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2077,7 +2077,7 @@
 deriving instance Show PipelineRasterizationStateStreamCreateInfoEXT
 
 instance ToCStruct PipelineRasterizationStateStreamCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRasterizationStateStreamCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_validation_cache.hs b/src/Vulkan/Extensions/VK_EXT_validation_cache.hs
--- a/src/Vulkan/Extensions/VK_EXT_validation_cache.hs
+++ b/src/Vulkan/Extensions/VK_EXT_validation_cache.hs
@@ -146,7 +146,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -623,7 +623,7 @@
   lift $ unless (vkMergeValidationCachesEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkMergeValidationCachesEXT is null" Nothing Nothing
   let vkMergeValidationCachesEXT' = mkVkMergeValidationCachesEXT vkMergeValidationCachesEXTPtr
-  pPSrcCaches <- ContT $ allocaBytesAligned @ValidationCacheEXT ((Data.Vector.length (srcCaches)) * 8) 8
+  pPSrcCaches <- ContT $ allocaBytes @ValidationCacheEXT ((Data.Vector.length (srcCaches)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPSrcCaches `plusPtr` (8 * (i)) :: Ptr ValidationCacheEXT) (e)) (srcCaches)
   r <- lift $ traceAroundEvent "vkMergeValidationCachesEXT" (vkMergeValidationCachesEXT' (deviceHandle (device)) (dstCache) ((fromIntegral (Data.Vector.length $ (srcCaches)) :: Word32)) (pPSrcCaches))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -681,7 +681,7 @@
 deriving instance Show ValidationCacheCreateInfoEXT
 
 instance ToCStruct ValidationCacheCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ValidationCacheCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -744,7 +744,7 @@
 deriving instance Show ShaderModuleValidationCacheCreateInfoEXT
 
 instance ToCStruct ShaderModuleValidationCacheCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ShaderModuleValidationCacheCreateInfoEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_validation_features.hs b/src/Vulkan/Extensions/VK_EXT_validation_features.hs
--- a/src/Vulkan/Extensions/VK_EXT_validation_features.hs
+++ b/src/Vulkan/Extensions/VK_EXT_validation_features.hs
@@ -152,7 +152,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -238,16 +238,16 @@
 deriving instance Show ValidationFeaturesEXT
 
 instance ToCStruct ValidationFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ValidationFeaturesEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VALIDATION_FEATURES_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (enabledValidationFeatures)) :: Word32))
-    pPEnabledValidationFeatures' <- ContT $ allocaBytesAligned @ValidationFeatureEnableEXT ((Data.Vector.length (enabledValidationFeatures)) * 4) 4
+    pPEnabledValidationFeatures' <- ContT $ allocaBytes @ValidationFeatureEnableEXT ((Data.Vector.length (enabledValidationFeatures)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPEnabledValidationFeatures' `plusPtr` (4 * (i)) :: Ptr ValidationFeatureEnableEXT) (e)) (enabledValidationFeatures)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ValidationFeatureEnableEXT))) (pPEnabledValidationFeatures')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (disabledValidationFeatures)) :: Word32))
-    pPDisabledValidationFeatures' <- ContT $ allocaBytesAligned @ValidationFeatureDisableEXT ((Data.Vector.length (disabledValidationFeatures)) * 4) 4
+    pPDisabledValidationFeatures' <- ContT $ allocaBytes @ValidationFeatureDisableEXT ((Data.Vector.length (disabledValidationFeatures)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDisabledValidationFeatures' `plusPtr` (4 * (i)) :: Ptr ValidationFeatureDisableEXT) (e)) (disabledValidationFeatures)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr ValidationFeatureDisableEXT))) (pPDisabledValidationFeatures')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_EXT_validation_flags.hs b/src/Vulkan/Extensions/VK_EXT_validation_flags.hs
--- a/src/Vulkan/Extensions/VK_EXT_validation_flags.hs
+++ b/src/Vulkan/Extensions/VK_EXT_validation_flags.hs
@@ -117,7 +117,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showsPrec)
@@ -173,12 +173,12 @@
 deriving instance Show ValidationFlagsEXT
 
 instance ToCStruct ValidationFlagsEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ValidationFlagsEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VALIDATION_FLAGS_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (disabledValidationChecks)) :: Word32))
-    pPDisabledValidationChecks' <- ContT $ allocaBytesAligned @ValidationCheckEXT ((Data.Vector.length (disabledValidationChecks)) * 4) 4
+    pPDisabledValidationChecks' <- ContT $ allocaBytes @ValidationCheckEXT ((Data.Vector.length (disabledValidationChecks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDisabledValidationChecks' `plusPtr` (4 * (i)) :: Ptr ValidationCheckEXT) (e)) (disabledValidationChecks)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ValidationCheckEXT))) (pPDisabledValidationChecks')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_EXT_vertex_attribute_divisor.hs b/src/Vulkan/Extensions/VK_EXT_vertex_attribute_divisor.hs
--- a/src/Vulkan/Extensions/VK_EXT_vertex_attribute_divisor.hs
+++ b/src/Vulkan/Extensions/VK_EXT_vertex_attribute_divisor.hs
@@ -174,7 +174,7 @@
                                                           , pattern EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME
                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -266,7 +266,7 @@
 deriving instance Show VertexInputBindingDivisorDescriptionEXT
 
 instance ToCStruct VertexInputBindingDivisorDescriptionEXT where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p VertexInputBindingDivisorDescriptionEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (binding)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (divisor)
@@ -323,12 +323,12 @@
 deriving instance Show PipelineVertexInputDivisorStateCreateInfoEXT
 
 instance ToCStruct PipelineVertexInputDivisorStateCreateInfoEXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineVertexInputDivisorStateCreateInfoEXT{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (vertexBindingDivisors)) :: Word32))
-    pPVertexBindingDivisors' <- ContT $ allocaBytesAligned @VertexInputBindingDivisorDescriptionEXT ((Data.Vector.length (vertexBindingDivisors)) * 8) 4
+    pPVertexBindingDivisors' <- ContT $ allocaBytes @VertexInputBindingDivisorDescriptionEXT ((Data.Vector.length (vertexBindingDivisors)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexBindingDivisors' `plusPtr` (8 * (i)) :: Ptr VertexInputBindingDivisorDescriptionEXT) (e)) (vertexBindingDivisors)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr VertexInputBindingDivisorDescriptionEXT))) (pPVertexBindingDivisors')
     lift $ f
@@ -383,7 +383,7 @@
 deriving instance Show PhysicalDeviceVertexAttributeDivisorPropertiesEXT
 
 instance ToCStruct PhysicalDeviceVertexAttributeDivisorPropertiesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVertexAttributeDivisorPropertiesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -456,7 +456,7 @@
 deriving instance Show PhysicalDeviceVertexAttributeDivisorFeaturesEXT
 
 instance ToCStruct PhysicalDeviceVertexAttributeDivisorFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVertexAttributeDivisorFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_vertex_input_dynamic_state.hs b/src/Vulkan/Extensions/VK_EXT_vertex_input_dynamic_state.hs
--- a/src/Vulkan/Extensions/VK_EXT_vertex_input_dynamic_state.hs
+++ b/src/Vulkan/Extensions/VK_EXT_vertex_input_dynamic_state.hs
@@ -129,7 +129,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -280,9 +280,9 @@
   lift $ unless (vkCmdSetVertexInputEXTPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetVertexInputEXT is null" Nothing Nothing
   let vkCmdSetVertexInputEXT' = mkVkCmdSetVertexInputEXT vkCmdSetVertexInputEXTPtr
-  pPVertexBindingDescriptions <- ContT $ allocaBytesAligned @VertexInputBindingDescription2EXT ((Data.Vector.length (vertexBindingDescriptions)) * 32) 8
+  pPVertexBindingDescriptions <- ContT $ allocaBytes @VertexInputBindingDescription2EXT ((Data.Vector.length (vertexBindingDescriptions)) * 32)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexBindingDescriptions `plusPtr` (32 * (i)) :: Ptr VertexInputBindingDescription2EXT) (e)) (vertexBindingDescriptions)
-  pPVertexAttributeDescriptions <- ContT $ allocaBytesAligned @VertexInputAttributeDescription2EXT ((Data.Vector.length (vertexAttributeDescriptions)) * 32) 8
+  pPVertexAttributeDescriptions <- ContT $ allocaBytes @VertexInputAttributeDescription2EXT ((Data.Vector.length (vertexAttributeDescriptions)) * 32)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPVertexAttributeDescriptions `plusPtr` (32 * (i)) :: Ptr VertexInputAttributeDescription2EXT) (e)) (vertexAttributeDescriptions)
   lift $ traceAroundEvent "vkCmdSetVertexInputEXT" (vkCmdSetVertexInputEXT' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (vertexBindingDescriptions)) :: Word32)) (pPVertexBindingDescriptions) ((fromIntegral (Data.Vector.length $ (vertexAttributeDescriptions)) :: Word32)) (pPVertexAttributeDescriptions))
   pure $ ()
@@ -326,7 +326,7 @@
 deriving instance Show PhysicalDeviceVertexInputDynamicStateFeaturesEXT
 
 instance ToCStruct PhysicalDeviceVertexInputDynamicStateFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceVertexInputDynamicStateFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -434,7 +434,7 @@
 deriving instance Show VertexInputBindingDescription2EXT
 
 instance ToCStruct VertexInputBindingDescription2EXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p VertexInputBindingDescription2EXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -543,7 +543,7 @@
 deriving instance Show VertexInputAttributeDescription2EXT
 
 instance ToCStruct VertexInputAttributeDescription2EXT where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p VertexInputAttributeDescription2EXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_ycbcr_2plane_444_formats.hs b/src/Vulkan/Extensions/VK_EXT_ycbcr_2plane_444_formats.hs
--- a/src/Vulkan/Extensions/VK_EXT_ycbcr_2plane_444_formats.hs
+++ b/src/Vulkan/Extensions/VK_EXT_ycbcr_2plane_444_formats.hs
@@ -101,7 +101,7 @@
                                                           , pattern EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME
                                                           ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -168,7 +168,7 @@
 deriving instance Show PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
 
 instance ToCStruct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_EXT_ycbcr_image_arrays.hs b/src/Vulkan/Extensions/VK_EXT_ycbcr_image_arrays.hs
--- a/src/Vulkan/Extensions/VK_EXT_ycbcr_image_arrays.hs
+++ b/src/Vulkan/Extensions/VK_EXT_ycbcr_image_arrays.hs
@@ -85,7 +85,7 @@
                                                     , pattern EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME
                                                     ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -146,7 +146,7 @@
 deriving instance Show PhysicalDeviceYcbcrImageArraysFeaturesEXT
 
 instance ToCStruct PhysicalDeviceYcbcrImageArraysFeaturesEXT where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceYcbcrImageArraysFeaturesEXT{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_FUCHSIA_external_memory.hs b/src/Vulkan/Extensions/VK_FUCHSIA_external_memory.hs
--- a/src/Vulkan/Extensions/VK_FUCHSIA_external_memory.hs
+++ b/src/Vulkan/Extensions/VK_FUCHSIA_external_memory.hs
@@ -131,7 +131,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -339,7 +339,7 @@
 deriving instance Show ImportMemoryZirconHandleInfoFUCHSIA
 
 instance ToCStruct ImportMemoryZirconHandleInfoFUCHSIA where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportMemoryZirconHandleInfoFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -392,7 +392,7 @@
 deriving instance Show MemoryZirconHandlePropertiesFUCHSIA
 
 instance ToCStruct MemoryZirconHandlePropertiesFUCHSIA where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryZirconHandlePropertiesFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -467,7 +467,7 @@
 deriving instance Show MemoryGetZirconHandleInfoFUCHSIA
 
 instance ToCStruct MemoryGetZirconHandleInfoFUCHSIA where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryGetZirconHandleInfoFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_FUCHSIA_external_semaphore.hs b/src/Vulkan/Extensions/VK_FUCHSIA_external_semaphore.hs
--- a/src/Vulkan/Extensions/VK_FUCHSIA_external_semaphore.hs
+++ b/src/Vulkan/Extensions/VK_FUCHSIA_external_semaphore.hs
@@ -128,7 +128,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -405,7 +405,7 @@
 deriving instance Show ImportSemaphoreZirconHandleInfoFUCHSIA
 
 instance ToCStruct ImportSemaphoreZirconHandleInfoFUCHSIA where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportSemaphoreZirconHandleInfoFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -532,7 +532,7 @@
 deriving instance Show SemaphoreGetZirconHandleInfoFUCHSIA
 
 instance ToCStruct SemaphoreGetZirconHandleInfoFUCHSIA where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreGetZirconHandleInfoFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_FUCHSIA_imagepipe_surface.hs b/src/Vulkan/Extensions/VK_FUCHSIA_imagepipe_surface.hs
--- a/src/Vulkan/Extensions/VK_FUCHSIA_imagepipe_surface.hs
+++ b/src/Vulkan/Extensions/VK_FUCHSIA_imagepipe_surface.hs
@@ -108,7 +108,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -265,7 +265,7 @@
 deriving instance Show ImagePipeSurfaceCreateInfoFUCHSIA
 
 instance ToCStruct ImagePipeSurfaceCreateInfoFUCHSIA where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImagePipeSurfaceCreateInfoFUCHSIA{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_GGP_frame_token.hs b/src/Vulkan/Extensions/VK_GGP_frame_token.hs
--- a/src/Vulkan/Extensions/VK_GGP_frame_token.hs
+++ b/src/Vulkan/Extensions/VK_GGP_frame_token.hs
@@ -92,7 +92,7 @@
                                              , GgpFrameToken
                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -132,7 +132,7 @@
 deriving instance Show PresentFrameTokenGGP
 
 instance ToCStruct PresentFrameTokenGGP where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentFrameTokenGGP{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_GGP_stream_descriptor_surface.hs b/src/Vulkan/Extensions/VK_GGP_stream_descriptor_surface.hs
--- a/src/Vulkan/Extensions/VK_GGP_stream_descriptor_surface.hs
+++ b/src/Vulkan/Extensions/VK_GGP_stream_descriptor_surface.hs
@@ -134,7 +134,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -295,7 +295,7 @@
 deriving instance Show StreamDescriptorSurfaceCreateInfoGGP
 
 instance ToCStruct StreamDescriptorSurfaceCreateInfoGGP where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p StreamDescriptorSurfaceCreateInfoGGP{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_GOOGLE_display_timing.hs b/src/Vulkan/Extensions/VK_GOOGLE_display_timing.hs
--- a/src/Vulkan/Extensions/VK_GOOGLE_display_timing.hs
+++ b/src/Vulkan/Extensions/VK_GOOGLE_display_timing.hs
@@ -139,7 +139,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -377,7 +377,7 @@
 deriving instance Show RefreshCycleDurationGOOGLE
 
 instance ToCStruct RefreshCycleDurationGOOGLE where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RefreshCycleDurationGOOGLE{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word64)) (refreshDuration)
     f
@@ -467,7 +467,7 @@
 deriving instance Show PastPresentationTimingGOOGLE
 
 instance ToCStruct PastPresentationTimingGOOGLE where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PastPresentationTimingGOOGLE{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (presentID)
     poke ((p `plusPtr` 8 :: Ptr Word64)) (desiredPresentTime)
@@ -556,7 +556,7 @@
 deriving instance Show PresentTimesInfoGOOGLE
 
 instance ToCStruct PresentTimesInfoGOOGLE where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentTimesInfoGOOGLE{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -571,7 +571,7 @@
     pTimes'' <- if Data.Vector.null (times)
       then pure nullPtr
       else do
-        pPTimes <- ContT $ allocaBytesAligned @PresentTimeGOOGLE (((Data.Vector.length (times))) * 16) 8
+        pPTimes <- ContT $ allocaBytes @PresentTimeGOOGLE (((Data.Vector.length (times))) * 16)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPTimes `plusPtr` (16 * (i)) :: Ptr PresentTimeGOOGLE) (e)) ((times))
         pure $ pPTimes
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr PresentTimeGOOGLE))) pTimes''
@@ -630,7 +630,7 @@
 deriving instance Show PresentTimeGOOGLE
 
 instance ToCStruct PresentTimeGOOGLE where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentTimeGOOGLE{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (presentID)
     poke ((p `plusPtr` 8 :: Ptr Word64)) (desiredPresentTime)
diff --git a/src/Vulkan/Extensions/VK_INTEL_performance_query.hs b/src/Vulkan/Extensions/VK_INTEL_performance_query.hs
--- a/src/Vulkan/Extensions/VK_INTEL_performance_query.hs
+++ b/src/Vulkan/Extensions/VK_INTEL_performance_query.hs
@@ -367,7 +367,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1057,7 +1057,7 @@
 deriving instance Show PerformanceValueINTEL
 
 instance ToCStruct PerformanceValueINTEL where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceValueINTEL{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr PerformanceValueTypeINTEL)) (type')
     ContT $ pokeCStruct ((p `plusPtr` 8 :: Ptr PerformanceValueDataINTEL)) (data') . ($ ())
@@ -1101,7 +1101,7 @@
 deriving instance Show InitializePerformanceApiInfoINTEL
 
 instance ToCStruct InitializePerformanceApiInfoINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p InitializePerformanceApiInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1164,7 +1164,7 @@
 deriving instance Show QueryPoolPerformanceQueryCreateInfoINTEL
 
 instance ToCStruct QueryPoolPerformanceQueryCreateInfoINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueryPoolPerformanceQueryCreateInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1214,7 +1214,7 @@
 deriving instance Show PerformanceMarkerInfoINTEL
 
 instance ToCStruct PerformanceMarkerInfoINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceMarkerInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1279,7 +1279,7 @@
 deriving instance Show PerformanceStreamMarkerInfoINTEL
 
 instance ToCStruct PerformanceStreamMarkerInfoINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceStreamMarkerInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1337,7 +1337,7 @@
 deriving instance Show PerformanceOverrideInfoINTEL
 
 instance ToCStruct PerformanceOverrideInfoINTEL where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceOverrideInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1400,7 +1400,7 @@
 deriving instance Show PerformanceConfigurationAcquireInfoINTEL
 
 instance ToCStruct PerformanceConfigurationAcquireInfoINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceConfigurationAcquireInfoINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1440,7 +1440,7 @@
   deriving (Show)
 
 instance ToCStruct PerformanceValueDataINTEL where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr PerformanceValueDataINTEL -> PerformanceValueDataINTEL -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     Value32 v -> lift $ poke (castPtr @_ @Word32 p) (v)
diff --git a/src/Vulkan/Extensions/VK_INTEL_shader_integer_functions2.hs b/src/Vulkan/Extensions/VK_INTEL_shader_integer_functions2.hs
--- a/src/Vulkan/Extensions/VK_INTEL_shader_integer_functions2.hs
+++ b/src/Vulkan/Extensions/VK_INTEL_shader_integer_functions2.hs
@@ -99,7 +99,7 @@
                                                              , pattern INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME
                                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -161,7 +161,7 @@
 deriving instance Show PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
 
 instance ToCStruct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_acceleration_structure.hs b/src/Vulkan/Extensions/VK_KHR_acceleration_structure.hs
--- a/src/Vulkan/Extensions/VK_KHR_acceleration_structure.hs
+++ b/src/Vulkan/Extensions/VK_KHR_acceleration_structure.hs
@@ -1247,7 +1247,7 @@
 import Data.Bits (shiftL)
 import Data.Bits (shiftR)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -2302,7 +2302,7 @@
   lift $ unless (vkCmdWriteAccelerationStructuresPropertiesKHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdWriteAccelerationStructuresPropertiesKHR is null" Nothing Nothing
   let vkCmdWriteAccelerationStructuresPropertiesKHR' = mkVkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHRPtr
-  pPAccelerationStructures <- ContT $ allocaBytesAligned @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8) 8
+  pPAccelerationStructures <- ContT $ allocaBytes @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPAccelerationStructures `plusPtr` (8 * (i)) :: Ptr AccelerationStructureKHR) (e)) (accelerationStructures)
   lift $ traceAroundEvent "vkCmdWriteAccelerationStructuresPropertiesKHR" (vkCmdWriteAccelerationStructuresPropertiesKHR' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (accelerationStructures)) :: Word32)) (pPAccelerationStructures) (queryType) (queryPool) (firstQuery))
   pure $ ()
@@ -2451,7 +2451,7 @@
   lift $ unless (vkWriteAccelerationStructuresPropertiesKHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkWriteAccelerationStructuresPropertiesKHR is null" Nothing Nothing
   let vkWriteAccelerationStructuresPropertiesKHR' = mkVkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHRPtr
-  pPAccelerationStructures <- ContT $ allocaBytesAligned @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8) 8
+  pPAccelerationStructures <- ContT $ allocaBytes @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPAccelerationStructures `plusPtr` (8 * (i)) :: Ptr AccelerationStructureKHR) (e)) (accelerationStructures)
   r <- lift $ traceAroundEvent "vkWriteAccelerationStructuresPropertiesKHR" (vkWriteAccelerationStructuresPropertiesKHR' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (accelerationStructures)) :: Word32)) (pPAccelerationStructures) (queryType) (CSize (dataSize)) (data') (CSize (stride)))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -3227,11 +3227,11 @@
   let pInfosLength = Data.Vector.length $ (infos)
   lift $ unless ((Data.Vector.length $ (buildRangeInfos)) == pInfosLength) $
     throwIO $ IOError Nothing InvalidArgument "" "ppBuildRangeInfos and pInfos must have the same length" Nothing Nothing
-  pPInfos <- ContT $ allocaBytesAligned @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80) 8
+  pPInfos <- ContT $ allocaBytes @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPInfos `plusPtr` (80 * (i)) :: Ptr AccelerationStructureBuildGeometryInfoKHR) (e) . ($ ())) (infos)
-  pPpBuildRangeInfos <- ContT $ allocaBytesAligned @(Ptr AccelerationStructureBuildRangeInfoKHR) ((Data.Vector.length (buildRangeInfos)) * 8) 8
+  pPpBuildRangeInfos <- ContT $ allocaBytes @(Ptr AccelerationStructureBuildRangeInfoKHR) ((Data.Vector.length (buildRangeInfos)) * 8)
   Data.Vector.imapM_ (\i e -> do
-    pPpBuildRangeInfos' <- ContT $ allocaBytesAligned @AccelerationStructureBuildRangeInfoKHR ((Data.Vector.length (e)) * 16) 4
+    pPpBuildRangeInfos' <- ContT $ allocaBytes @AccelerationStructureBuildRangeInfoKHR ((Data.Vector.length (e)) * 16)
     lift $ Data.Vector.imapM_ (\i' e' -> poke (pPpBuildRangeInfos' `plusPtr` (16 * (i')) :: Ptr AccelerationStructureBuildRangeInfoKHR) (e')) (e)
     lift $ poke (pPpBuildRangeInfos `plusPtr` (8 * (i)) :: Ptr (Ptr AccelerationStructureBuildRangeInfoKHR)) (pPpBuildRangeInfos')) (buildRangeInfos)
   lift $ traceAroundEvent "vkCmdBuildAccelerationStructuresKHR" (vkCmdBuildAccelerationStructuresKHR' (commandBufferHandle (commandBuffer)) ((fromIntegral pInfosLength :: Word32)) (pPInfos) (pPpBuildRangeInfos))
@@ -3865,15 +3865,15 @@
     throwIO $ IOError Nothing InvalidArgument "" "pIndirectStrides and pInfos must have the same length" Nothing Nothing
   lift $ unless ((Data.Vector.length $ (maxPrimitiveCounts)) == pInfosLength) $
     throwIO $ IOError Nothing InvalidArgument "" "ppMaxPrimitiveCounts and pInfos must have the same length" Nothing Nothing
-  pPInfos <- ContT $ allocaBytesAligned @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80) 8
+  pPInfos <- ContT $ allocaBytes @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPInfos `plusPtr` (80 * (i)) :: Ptr AccelerationStructureBuildGeometryInfoKHR) (e) . ($ ())) (infos)
-  pPIndirectDeviceAddresses <- ContT $ allocaBytesAligned @DeviceAddress ((Data.Vector.length (indirectDeviceAddresses)) * 8) 8
+  pPIndirectDeviceAddresses <- ContT $ allocaBytes @DeviceAddress ((Data.Vector.length (indirectDeviceAddresses)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPIndirectDeviceAddresses `plusPtr` (8 * (i)) :: Ptr DeviceAddress) (e)) (indirectDeviceAddresses)
-  pPIndirectStrides <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (indirectStrides)) * 4) 4
+  pPIndirectStrides <- ContT $ allocaBytes @Word32 ((Data.Vector.length (indirectStrides)) * 4)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPIndirectStrides `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (indirectStrides)
-  pPpMaxPrimitiveCounts <- ContT $ allocaBytesAligned @(Ptr Word32) ((Data.Vector.length (maxPrimitiveCounts)) * 8) 8
+  pPpMaxPrimitiveCounts <- ContT $ allocaBytes @(Ptr Word32) ((Data.Vector.length (maxPrimitiveCounts)) * 8)
   Data.Vector.imapM_ (\i e -> do
-    pPpMaxPrimitiveCounts' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (e)) * 4) 4
+    pPpMaxPrimitiveCounts' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (e)) * 4)
     lift $ Data.Vector.imapM_ (\i' e' -> poke (pPpMaxPrimitiveCounts' `plusPtr` (4 * (i')) :: Ptr Word32) (e')) (e)
     lift $ poke (pPpMaxPrimitiveCounts `plusPtr` (8 * (i)) :: Ptr (Ptr Word32)) (pPpMaxPrimitiveCounts')) (maxPrimitiveCounts)
   lift $ traceAroundEvent "vkCmdBuildAccelerationStructuresIndirectKHR" (vkCmdBuildAccelerationStructuresIndirectKHR' (commandBufferHandle (commandBuffer)) ((fromIntegral pInfosLength :: Word32)) (pPInfos) (pPIndirectDeviceAddresses) (pPIndirectStrides) (pPpMaxPrimitiveCounts))
@@ -4354,11 +4354,11 @@
   let pInfosLength = Data.Vector.length $ (infos)
   lift $ unless ((Data.Vector.length $ (buildRangeInfos)) == pInfosLength) $
     throwIO $ IOError Nothing InvalidArgument "" "ppBuildRangeInfos and pInfos must have the same length" Nothing Nothing
-  pPInfos <- ContT $ allocaBytesAligned @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80) 8
+  pPInfos <- ContT $ allocaBytes @AccelerationStructureBuildGeometryInfoKHR ((Data.Vector.length (infos)) * 80)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPInfos `plusPtr` (80 * (i)) :: Ptr AccelerationStructureBuildGeometryInfoKHR) (e) . ($ ())) (infos)
-  pPpBuildRangeInfos <- ContT $ allocaBytesAligned @(Ptr AccelerationStructureBuildRangeInfoKHR) ((Data.Vector.length (buildRangeInfos)) * 8) 8
+  pPpBuildRangeInfos <- ContT $ allocaBytes @(Ptr AccelerationStructureBuildRangeInfoKHR) ((Data.Vector.length (buildRangeInfos)) * 8)
   Data.Vector.imapM_ (\i e -> do
-    pPpBuildRangeInfos' <- ContT $ allocaBytesAligned @AccelerationStructureBuildRangeInfoKHR ((Data.Vector.length (e)) * 16) 4
+    pPpBuildRangeInfos' <- ContT $ allocaBytes @AccelerationStructureBuildRangeInfoKHR ((Data.Vector.length (e)) * 16)
     lift $ Data.Vector.imapM_ (\i' e' -> poke (pPpBuildRangeInfos' `plusPtr` (16 * (i')) :: Ptr AccelerationStructureBuildRangeInfoKHR) (e')) (e)
     lift $ poke (pPpBuildRangeInfos `plusPtr` (8 * (i)) :: Ptr (Ptr AccelerationStructureBuildRangeInfoKHR)) (pPpBuildRangeInfos')) (buildRangeInfos)
   r <- lift $ traceAroundEvent "vkBuildAccelerationStructuresKHR" (vkBuildAccelerationStructuresKHR' (deviceHandle (device)) (deferredOperation) ((fromIntegral pInfosLength :: Word32)) (pPInfos) (pPpBuildRangeInfos))
@@ -4597,7 +4597,7 @@
   pMaxPrimitiveCounts <- if Data.Vector.null (maxPrimitiveCounts)
     then pure nullPtr
     else do
-      pPMaxPrimitiveCounts <- ContT $ allocaBytesAligned @Word32 (((Data.Vector.length (maxPrimitiveCounts))) * 4) 4
+      pPMaxPrimitiveCounts <- ContT $ allocaBytes @Word32 (((Data.Vector.length (maxPrimitiveCounts))) * 4)
       lift $ Data.Vector.imapM_ (\i e -> poke (pPMaxPrimitiveCounts `plusPtr` (4 * (i)) :: Ptr Word32) (e)) ((maxPrimitiveCounts))
       pure $ pPMaxPrimitiveCounts
   pPSizeInfo <- ContT (withZeroCStruct @AccelerationStructureBuildSizesInfoKHR)
@@ -4658,12 +4658,12 @@
 deriving instance Show WriteDescriptorSetAccelerationStructureKHR
 
 instance ToCStruct WriteDescriptorSetAccelerationStructureKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p WriteDescriptorSetAccelerationStructureKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (accelerationStructures)) :: Word32))
-    pPAccelerationStructures' <- ContT $ allocaBytesAligned @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8) 8
+    pPAccelerationStructures' <- ContT $ allocaBytes @AccelerationStructureKHR ((Data.Vector.length (accelerationStructures)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAccelerationStructures' `plusPtr` (8 * (i)) :: Ptr AccelerationStructureKHR) (e)) (accelerationStructures)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr AccelerationStructureKHR))) (pPAccelerationStructures')
     lift $ f
@@ -4753,7 +4753,7 @@
 deriving instance Show PhysicalDeviceAccelerationStructureFeaturesKHR
 
 instance ToCStruct PhysicalDeviceAccelerationStructureFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceAccelerationStructureFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -4881,7 +4881,7 @@
 deriving instance Show PhysicalDeviceAccelerationStructurePropertiesKHR
 
 instance ToCStruct PhysicalDeviceAccelerationStructurePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceAccelerationStructurePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5046,7 +5046,7 @@
     | otherwise = Nothing
 
 instance (Extendss AccelerationStructureGeometryTrianglesDataKHR es, PokeChain es) => ToCStruct (AccelerationStructureGeometryTrianglesDataKHR es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureGeometryTrianglesDataKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -5119,7 +5119,7 @@
 deriving instance Show AccelerationStructureGeometryAabbsDataKHR
 
 instance ToCStruct AccelerationStructureGeometryAabbsDataKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureGeometryAabbsDataKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5175,7 +5175,7 @@
 deriving instance Show AccelerationStructureGeometryInstancesDataKHR
 
 instance ToCStruct AccelerationStructureGeometryInstancesDataKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureGeometryInstancesDataKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5253,7 +5253,7 @@
 deriving instance Show AccelerationStructureGeometryKHR
 
 instance ToCStruct AccelerationStructureGeometryKHR where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureGeometryKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5465,7 +5465,7 @@
 deriving instance Show AccelerationStructureBuildGeometryInfoKHR
 
 instance ToCStruct AccelerationStructureBuildGeometryInfoKHR where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureBuildGeometryInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5475,7 +5475,7 @@
     lift $ poke ((p `plusPtr` 32 :: Ptr AccelerationStructureKHR)) (srcAccelerationStructure)
     lift $ poke ((p `plusPtr` 40 :: Ptr AccelerationStructureKHR)) (dstAccelerationStructure)
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (geometries)) :: Word32))
-    pPGeometries' <- ContT $ allocaBytesAligned @AccelerationStructureGeometryKHR ((Data.Vector.length (geometries)) * 96) 8
+    pPGeometries' <- ContT $ allocaBytes @AccelerationStructureGeometryKHR ((Data.Vector.length (geometries)) * 96)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPGeometries' `plusPtr` (96 * (i)) :: Ptr AccelerationStructureGeometryKHR) (e) . ($ ())) (geometries)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr AccelerationStructureGeometryKHR))) (pPGeometries')
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr (Ptr AccelerationStructureGeometryKHR)))) (nullPtr)
@@ -5606,7 +5606,7 @@
 deriving instance Show AccelerationStructureBuildRangeInfoKHR
 
 instance ToCStruct AccelerationStructureBuildRangeInfoKHR where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureBuildRangeInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (primitiveCount)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (primitiveOffset)
@@ -5813,7 +5813,7 @@
     | otherwise = Nothing
 
 instance (Extendss AccelerationStructureCreateInfoKHR es, PokeChain es) => ToCStruct (AccelerationStructureCreateInfoKHR es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureCreateInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -5899,7 +5899,7 @@
 deriving instance Show AabbPositionsKHR
 
 instance ToCStruct AabbPositionsKHR where
-  withCStruct x f = allocaBytesAligned 24 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AabbPositionsKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (minX))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (minY))
@@ -5973,7 +5973,7 @@
 deriving instance Show TransformMatrixKHR
 
 instance ToCStruct TransformMatrixKHR where
-  withCStruct x f = allocaBytesAligned 48 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p TransformMatrixKHR{..} f = do
     let pMatrixRow0' = lowerArrayPtr ((p `plusPtr` 0 :: Ptr (FixedArray 4 CFloat)))
     case (matrixRow0) of
@@ -6112,7 +6112,7 @@
 deriving instance Show AccelerationStructureInstanceKHR
 
 instance ToCStruct AccelerationStructureInstanceKHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureInstanceKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr TransformMatrixKHR)) (transform)
     poke ((p `plusPtr` 48 :: Ptr Word32)) (((coerce @_ @Word32 (mask)) `shiftL` 24) .|. (instanceCustomIndex))
@@ -6182,7 +6182,7 @@
 deriving instance Show AccelerationStructureDeviceAddressInfoKHR
 
 instance ToCStruct AccelerationStructureDeviceAddressInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureDeviceAddressInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6250,7 +6250,7 @@
 deriving instance Show AccelerationStructureVersionInfoKHR
 
 instance ToCStruct AccelerationStructureVersionInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureVersionInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6344,7 +6344,7 @@
 deriving instance Show CopyAccelerationStructureInfoKHR
 
 instance ToCStruct CopyAccelerationStructureInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyAccelerationStructureInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6438,7 +6438,7 @@
 deriving instance Show CopyAccelerationStructureToMemoryInfoKHR
 
 instance ToCStruct CopyAccelerationStructureToMemoryInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyAccelerationStructureToMemoryInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6520,7 +6520,7 @@
 deriving instance Show CopyMemoryToAccelerationStructureInfoKHR
 
 instance ToCStruct CopyMemoryToAccelerationStructureInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyMemoryToAccelerationStructureInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6574,7 +6574,7 @@
 deriving instance Show AccelerationStructureBuildSizesInfoKHR
 
 instance ToCStruct AccelerationStructureBuildSizesInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureBuildSizesInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -6619,7 +6619,7 @@
   deriving (Show)
 
 instance ToCStruct DeviceOrHostAddressKHR where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr DeviceOrHostAddressKHR -> DeviceOrHostAddressKHR -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     DeviceAddress v -> lift $ poke (castPtr @_ @DeviceAddress p) (v)
@@ -6639,7 +6639,7 @@
   deriving (Show)
 
 instance ToCStruct DeviceOrHostAddressConstKHR where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr DeviceOrHostAddressConstKHR -> DeviceOrHostAddressConstKHR -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     DeviceAddressConst v -> lift $ poke (castPtr @_ @DeviceAddress p) (v)
@@ -6660,7 +6660,7 @@
   deriving (Show)
 
 instance ToCStruct AccelerationStructureGeometryDataKHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr AccelerationStructureGeometryDataKHR -> AccelerationStructureGeometryDataKHR -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     Triangles v -> ContT $ pokeSomeCStruct (forgetExtensions (castPtr @_ @(AccelerationStructureGeometryTrianglesDataKHR _) p)) (v) . ($ ())
diff --git a/src/Vulkan/Extensions/VK_KHR_android_surface.hs b/src/Vulkan/Extensions/VK_KHR_android_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_android_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_android_surface.hs
@@ -176,7 +176,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -359,7 +359,7 @@
 deriving instance Show AndroidSurfaceCreateInfoKHR
 
 instance ToCStruct AndroidSurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AndroidSurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_copy_commands2.hs b/src/Vulkan/Extensions/VK_KHR_copy_commands2.hs
--- a/src/Vulkan/Extensions/VK_KHR_copy_commands2.hs
+++ b/src/Vulkan/Extensions/VK_KHR_copy_commands2.hs
@@ -179,7 +179,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (castPtr)
 import GHC.Ptr (nullFunPtr)
@@ -840,7 +840,7 @@
 deriving instance Show BufferCopy2KHR
 
 instance ToCStruct BufferCopy2KHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferCopy2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_COPY_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -935,7 +935,7 @@
 deriving instance Show ImageCopy2KHR
 
 instance ToCStruct ImageCopy2KHR where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageCopy2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_COPY_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1057,7 +1057,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageBlit2KHR es, PokeChain es) => ToCStruct (ImageBlit2KHR es) where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageBlit2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_BLIT_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1208,7 +1208,7 @@
     | otherwise = Nothing
 
 instance (Extendss BufferImageCopy2KHR es, PokeChain es) => ToCStruct (BufferImageCopy2KHR es) where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferImageCopy2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -1317,7 +1317,7 @@
 deriving instance Show ImageResolve2KHR
 
 instance ToCStruct ImageResolve2KHR where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageResolve2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1459,14 +1459,14 @@
 deriving instance Show CopyBufferInfo2KHR
 
 instance ToCStruct CopyBufferInfo2KHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyBufferInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Buffer)) (srcBuffer)
     lift $ poke ((p `plusPtr` 24 :: Ptr Buffer)) (dstBuffer)
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @BufferCopy2KHR ((Data.Vector.length (regions)) * 40) 8
+    pPRegions' <- ContT $ allocaBytes @BufferCopy2KHR ((Data.Vector.length (regions)) * 40)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions' `plusPtr` (40 * (i)) :: Ptr BufferCopy2KHR) (e)) (regions)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr BufferCopy2KHR))) (pPRegions')
     lift $ f
@@ -1875,7 +1875,7 @@
 deriving instance Show CopyImageInfo2KHR
 
 instance ToCStruct CopyImageInfo2KHR where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyImageInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1884,7 +1884,7 @@
     lift $ poke ((p `plusPtr` 32 :: Ptr Image)) (dstImage)
     lift $ poke ((p `plusPtr` 40 :: Ptr ImageLayout)) (dstImageLayout)
     lift $ poke ((p `plusPtr` 44 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @ImageCopy2KHR ((Data.Vector.length (regions)) * 88) 8
+    pPRegions' <- ContT $ allocaBytes @ImageCopy2KHR ((Data.Vector.length (regions)) * 88)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions' `plusPtr` (88 * (i)) :: Ptr ImageCopy2KHR) (e)) (regions)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr ImageCopy2KHR))) (pPRegions')
     lift $ f
@@ -2209,7 +2209,7 @@
 deriving instance Show BlitImageInfo2KHR
 
 instance ToCStruct BlitImageInfo2KHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BlitImageInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2218,7 +2218,7 @@
     lift $ poke ((p `plusPtr` 32 :: Ptr Image)) (dstImage)
     lift $ poke ((p `plusPtr` 40 :: Ptr ImageLayout)) (dstImageLayout)
     lift $ poke ((p `plusPtr` 44 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @(ImageBlit2KHR _) ((Data.Vector.length (regions)) * 96) 8
+    pPRegions' <- ContT $ allocaBytes @(ImageBlit2KHR _) ((Data.Vector.length (regions)) * 96)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPRegions' `plusPtr` (96 * (i)) :: Ptr (ImageBlit2KHR _))) (e) . ($ ())) (regions)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr (ImageBlit2KHR _)))) (pPRegions')
     lift $ poke ((p `plusPtr` 56 :: Ptr Filter)) (filter')
@@ -2574,7 +2574,7 @@
 deriving instance Show CopyBufferToImageInfo2KHR
 
 instance ToCStruct CopyBufferToImageInfo2KHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyBufferToImageInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2582,7 +2582,7 @@
     lift $ poke ((p `plusPtr` 24 :: Ptr Image)) (dstImage)
     lift $ poke ((p `plusPtr` 32 :: Ptr ImageLayout)) (dstImageLayout)
     lift $ poke ((p `plusPtr` 36 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @(BufferImageCopy2KHR _) ((Data.Vector.length (regions)) * 72) 8
+    pPRegions' <- ContT $ allocaBytes @(BufferImageCopy2KHR _) ((Data.Vector.length (regions)) * 72)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPRegions' `plusPtr` (72 * (i)) :: Ptr (BufferImageCopy2KHR _))) (e) . ($ ())) (regions)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr (BufferImageCopy2KHR _)))) (pPRegions')
     lift $ f
@@ -2925,7 +2925,7 @@
 deriving instance Show CopyImageToBufferInfo2KHR
 
 instance ToCStruct CopyImageToBufferInfo2KHR where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyImageToBufferInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2933,7 +2933,7 @@
     lift $ poke ((p `plusPtr` 24 :: Ptr ImageLayout)) (srcImageLayout)
     lift $ poke ((p `plusPtr` 32 :: Ptr Buffer)) (dstBuffer)
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @(BufferImageCopy2KHR _) ((Data.Vector.length (regions)) * 72) 8
+    pPRegions' <- ContT $ allocaBytes @(BufferImageCopy2KHR _) ((Data.Vector.length (regions)) * 72)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPRegions' `plusPtr` (72 * (i)) :: Ptr (BufferImageCopy2KHR _))) (e) . ($ ())) (regions)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr (BufferImageCopy2KHR _)))) (pPRegions')
     lift $ f
@@ -3170,7 +3170,7 @@
 deriving instance Show ResolveImageInfo2KHR
 
 instance ToCStruct ResolveImageInfo2KHR where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ResolveImageInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3179,7 +3179,7 @@
     lift $ poke ((p `plusPtr` 32 :: Ptr Image)) (dstImage)
     lift $ poke ((p `plusPtr` 40 :: Ptr ImageLayout)) (dstImageLayout)
     lift $ poke ((p `plusPtr` 44 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (regions)) :: Word32))
-    pPRegions' <- ContT $ allocaBytesAligned @ImageResolve2KHR ((Data.Vector.length (regions)) * 88) 8
+    pPRegions' <- ContT $ allocaBytes @ImageResolve2KHR ((Data.Vector.length (regions)) * 88)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPRegions' `plusPtr` (88 * (i)) :: Ptr ImageResolve2KHR) (e)) (regions)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr ImageResolve2KHR))) (pPRegions')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_KHR_display.hs b/src/Vulkan/Extensions/VK_KHR_display.hs
--- a/src/Vulkan/Extensions/VK_KHR_display.hs
+++ b/src/Vulkan/Extensions/VK_KHR_display.hs
@@ -551,7 +551,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1266,7 +1266,7 @@
 deriving instance Show DisplayPropertiesKHR
 
 instance ToCStruct DisplayPropertiesKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPropertiesKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr DisplayKHR)) (display)
     displayName'' <- ContT $ useAsCString (displayName)
@@ -1337,7 +1337,7 @@
 deriving instance Show DisplayPlanePropertiesKHR
 
 instance ToCStruct DisplayPlanePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPlanePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DisplayKHR)) (currentDisplay)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (currentStackIndex)
@@ -1406,7 +1406,7 @@
 deriving instance Show DisplayModeParametersKHR
 
 instance ToCStruct DisplayModeParametersKHR where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayModeParametersKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Extent2D)) (visibleRegion)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (refreshRate)
@@ -1461,7 +1461,7 @@
 deriving instance Show DisplayModePropertiesKHR
 
 instance ToCStruct DisplayModePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayModePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DisplayModeKHR)) (displayMode)
     poke ((p `plusPtr` 8 :: Ptr DisplayModeParametersKHR)) (parameters)
@@ -1524,7 +1524,7 @@
 deriving instance Show DisplayModeCreateInfoKHR
 
 instance ToCStruct DisplayModeCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayModeCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1641,7 +1641,7 @@
 deriving instance Show DisplayPlaneCapabilitiesKHR
 
 instance ToCStruct DisplayPlaneCapabilitiesKHR where
-  withCStruct x f = allocaBytesAligned 68 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 68 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPlaneCapabilitiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DisplayPlaneAlphaFlagsKHR)) (supportedAlpha)
     poke ((p `plusPtr` 4 :: Ptr Offset2D)) (minSrcPosition)
@@ -1806,7 +1806,7 @@
 deriving instance Show DisplaySurfaceCreateInfoKHR
 
 instance ToCStruct DisplaySurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplaySurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_display_swapchain.hs b/src/Vulkan/Extensions/VK_KHR_display_swapchain.hs
--- a/src/Vulkan/Extensions/VK_KHR_display_swapchain.hs
+++ b/src/Vulkan/Extensions/VK_KHR_display_swapchain.hs
@@ -226,7 +226,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -399,7 +399,7 @@
   lift $ unless (vkCreateSharedSwapchainsKHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCreateSharedSwapchainsKHR is null" Nothing Nothing
   let vkCreateSharedSwapchainsKHR' = mkVkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHRPtr
-  pPCreateInfos <- ContT $ allocaBytesAligned @(SwapchainCreateInfoKHR _) ((Data.Vector.length (createInfos)) * 104) 8
+  pPCreateInfos <- ContT $ allocaBytes @(SwapchainCreateInfoKHR _) ((Data.Vector.length (createInfos)) * 104)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPCreateInfos `plusPtr` (104 * (i)) :: Ptr (SwapchainCreateInfoKHR _))) (e) . ($ ())) (createInfos)
   pAllocator <- case (allocator) of
     Nothing -> pure nullPtr
@@ -481,7 +481,7 @@
 deriving instance Show DisplayPresentInfoKHR
 
 instance ToCStruct DisplayPresentInfoKHR where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPresentInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_fence_fd.hs b/src/Vulkan/Extensions/VK_KHR_external_fence_fd.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_fence_fd.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_fence_fd.hs
@@ -117,7 +117,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -403,7 +403,7 @@
 deriving instance Show ImportFenceFdInfoKHR
 
 instance ToCStruct ImportFenceFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportFenceFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -515,7 +515,7 @@
 deriving instance Show FenceGetFdInfoKHR
 
 instance ToCStruct FenceGetFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FenceGetFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_fence_win32.hs b/src/Vulkan/Extensions/VK_KHR_external_fence_win32.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_fence_win32.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_fence_win32.hs
@@ -141,7 +141,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -418,7 +418,7 @@
 deriving instance Show ImportFenceWin32HandleInfoKHR
 
 instance ToCStruct ImportFenceWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportFenceWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -534,7 +534,7 @@
 deriving instance Show ExportFenceWin32HandleInfoKHR
 
 instance ToCStruct ExportFenceWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportFenceWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -649,7 +649,7 @@
 deriving instance Show FenceGetWin32HandleInfoKHR
 
 instance ToCStruct FenceGetWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FenceGetWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_memory_fd.hs b/src/Vulkan/Extensions/VK_KHR_external_memory_fd.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_memory_fd.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_memory_fd.hs
@@ -139,7 +139,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -396,7 +396,7 @@
 deriving instance Show ImportMemoryFdInfoKHR
 
 instance ToCStruct ImportMemoryFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportMemoryFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -449,7 +449,7 @@
 deriving instance Show MemoryFdPropertiesKHR
 
 instance ToCStruct MemoryFdPropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryFdPropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -540,7 +540,7 @@
 deriving instance Show MemoryGetFdInfoKHR
 
 instance ToCStruct MemoryGetFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryGetFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_memory_win32.hs b/src/Vulkan/Extensions/VK_KHR_external_memory_win32.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_memory_win32.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_memory_win32.hs
@@ -155,7 +155,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -443,7 +443,7 @@
 deriving instance Show ImportMemoryWin32HandleInfoKHR
 
 instance ToCStruct ImportMemoryWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportMemoryWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -569,7 +569,7 @@
 deriving instance Show ExportMemoryWin32HandleInfoKHR
 
 instance ToCStruct ExportMemoryWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportMemoryWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -627,7 +627,7 @@
 deriving instance Show MemoryWin32HandlePropertiesKHR
 
 instance ToCStruct MemoryWin32HandlePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryWin32HandlePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -721,7 +721,7 @@
 deriving instance Show MemoryGetWin32HandleInfoKHR
 
 instance ToCStruct MemoryGetWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryGetWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_semaphore_fd.hs b/src/Vulkan/Extensions/VK_KHR_external_semaphore_fd.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_semaphore_fd.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_semaphore_fd.hs
@@ -121,7 +121,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -430,7 +430,7 @@
 deriving instance Show ImportSemaphoreFdInfoKHR
 
 instance ToCStruct ImportSemaphoreFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportSemaphoreFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -561,7 +561,7 @@
 deriving instance Show SemaphoreGetFdInfoKHR
 
 instance ToCStruct SemaphoreGetFdInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreGetFdInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_external_semaphore_win32.hs b/src/Vulkan/Extensions/VK_KHR_external_semaphore_win32.hs
--- a/src/Vulkan/Extensions/VK_KHR_external_semaphore_win32.hs
+++ b/src/Vulkan/Extensions/VK_KHR_external_semaphore_win32.hs
@@ -166,7 +166,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -492,7 +492,7 @@
 deriving instance Show ImportSemaphoreWin32HandleInfoKHR
 
 instance ToCStruct ImportSemaphoreWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportSemaphoreWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -621,7 +621,7 @@
 deriving instance Show ExportSemaphoreWin32HandleInfoKHR
 
 instance ToCStruct ExportSemaphoreWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportSemaphoreWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -746,7 +746,7 @@
 deriving instance Show D3D12FenceSubmitInfoKHR
 
 instance ToCStruct D3D12FenceSubmitInfoKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p D3D12FenceSubmitInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -761,7 +761,7 @@
     pWaitSemaphoreValues'' <- if Data.Vector.null (waitSemaphoreValues)
       then pure nullPtr
       else do
-        pPWaitSemaphoreValues <- ContT $ allocaBytesAligned @Word64 (((Data.Vector.length (waitSemaphoreValues))) * 8) 8
+        pPWaitSemaphoreValues <- ContT $ allocaBytes @Word64 (((Data.Vector.length (waitSemaphoreValues))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphoreValues `plusPtr` (8 * (i)) :: Ptr Word64) (e)) ((waitSemaphoreValues))
         pure $ pPWaitSemaphoreValues
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word64))) pWaitSemaphoreValues''
@@ -776,7 +776,7 @@
     pSignalSemaphoreValues'' <- if Data.Vector.null (signalSemaphoreValues)
       then pure nullPtr
       else do
-        pPSignalSemaphoreValues <- ContT $ allocaBytesAligned @Word64 (((Data.Vector.length (signalSemaphoreValues))) * 8) 8
+        pPSignalSemaphoreValues <- ContT $ allocaBytes @Word64 (((Data.Vector.length (signalSemaphoreValues))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphoreValues `plusPtr` (8 * (i)) :: Ptr Word64) (e)) ((signalSemaphoreValues))
         pure $ pPSignalSemaphoreValues
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Word64))) pSignalSemaphoreValues''
@@ -895,7 +895,7 @@
 deriving instance Show SemaphoreGetWin32HandleInfoKHR
 
 instance ToCStruct SemaphoreGetWin32HandleInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreGetWin32HandleInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_fragment_shading_rate.hs b/src/Vulkan/Extensions/VK_KHR_fragment_shading_rate.hs
--- a/src/Vulkan/Extensions/VK_KHR_fragment_shading_rate.hs
+++ b/src/Vulkan/Extensions/VK_KHR_fragment_shading_rate.hs
@@ -226,7 +226,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -434,7 +434,7 @@
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetFragmentShadingRateKHR is null" Nothing Nothing
   let vkCmdSetFragmentShadingRateKHR' = mkVkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHRPtr
   pFragmentSize <- ContT $ withCStruct (fragmentSize)
-  pCombinerOps <- ContT $ allocaBytesAligned @(FixedArray 2 FragmentShadingRateCombinerOpKHR) 8 4
+  pCombinerOps <- ContT $ allocaBytes @(FixedArray 2 FragmentShadingRateCombinerOpKHR) 8
   let pCombinerOps' = lowerArrayPtr pCombinerOps
   lift $ case (combinerOps) of
     (e0, e1) -> do
@@ -725,7 +725,7 @@
 deriving instance Show FragmentShadingRateAttachmentInfoKHR
 
 instance ToCStruct FragmentShadingRateAttachmentInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FragmentShadingRateAttachmentInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -810,7 +810,7 @@
 deriving instance Show PipelineFragmentShadingRateStateCreateInfoKHR
 
 instance ToCStruct PipelineFragmentShadingRateStateCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineFragmentShadingRateStateCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -901,7 +901,7 @@
 deriving instance Show PhysicalDeviceFragmentShadingRateFeaturesKHR
 
 instance ToCStruct PhysicalDeviceFragmentShadingRateFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShadingRateFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1166,7 +1166,7 @@
 deriving instance Show PhysicalDeviceFragmentShadingRatePropertiesKHR
 
 instance ToCStruct PhysicalDeviceFragmentShadingRatePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShadingRatePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1287,7 +1287,7 @@
 deriving instance Show PhysicalDeviceFragmentShadingRateKHR
 
 instance ToCStruct PhysicalDeviceFragmentShadingRateKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShadingRateKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_get_display_properties2.hs b/src/Vulkan/Extensions/VK_KHR_get_display_properties2.hs
--- a/src/Vulkan/Extensions/VK_KHR_get_display_properties2.hs
+++ b/src/Vulkan/Extensions/VK_KHR_get_display_properties2.hs
@@ -177,7 +177,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -556,7 +556,7 @@
 deriving instance Show DisplayProperties2KHR
 
 instance ToCStruct DisplayProperties2KHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayProperties2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -602,7 +602,7 @@
 deriving instance Show DisplayPlaneProperties2KHR
 
 instance ToCStruct DisplayPlaneProperties2KHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPlaneProperties2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -654,7 +654,7 @@
 deriving instance Show DisplayModeProperties2KHR
 
 instance ToCStruct DisplayModeProperties2KHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayModeProperties2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -734,7 +734,7 @@
 deriving instance Show DisplayPlaneInfo2KHR
 
 instance ToCStruct DisplayPlaneInfo2KHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPlaneInfo2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -791,7 +791,7 @@
 deriving instance Show DisplayPlaneCapabilities2KHR
 
 instance ToCStruct DisplayPlaneCapabilities2KHR where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DisplayPlaneCapabilities2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_get_surface_capabilities2.hs b/src/Vulkan/Extensions/VK_KHR_get_surface_capabilities2.hs
--- a/src/Vulkan/Extensions/VK_KHR_get_surface_capabilities2.hs
+++ b/src/Vulkan/Extensions/VK_KHR_get_surface_capabilities2.hs
@@ -165,7 +165,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -517,7 +517,7 @@
     | otherwise = Nothing
 
 instance (Extendss PhysicalDeviceSurfaceInfo2KHR es, PokeChain es) => ToCStruct (PhysicalDeviceSurfaceInfo2KHR es) where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSurfaceInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -599,7 +599,7 @@
     | otherwise = Nothing
 
 instance (Extendss SurfaceCapabilities2KHR es, PokeChain es) => ToCStruct (SurfaceCapabilities2KHR es) where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceCapabilities2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -651,7 +651,7 @@
 deriving instance Show SurfaceFormat2KHR
 
 instance ToCStruct SurfaceFormat2KHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceFormat2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_incremental_present.hs b/src/Vulkan/Extensions/VK_KHR_incremental_present.hs
--- a/src/Vulkan/Extensions/VK_KHR_incremental_present.hs
+++ b/src/Vulkan/Extensions/VK_KHR_incremental_present.hs
@@ -172,7 +172,7 @@
                                                      ) where
 
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -251,7 +251,7 @@
 deriving instance Show PresentRegionsKHR
 
 instance ToCStruct PresentRegionsKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentRegionsKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PRESENT_REGIONS_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -266,7 +266,7 @@
     pRegions'' <- if Data.Vector.null (regions)
       then pure nullPtr
       else do
-        pPRegions <- ContT $ allocaBytesAligned @PresentRegionKHR (((Data.Vector.length (regions))) * 16) 8
+        pPRegions <- ContT $ allocaBytes @PresentRegionKHR (((Data.Vector.length (regions))) * 16)
         Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPRegions `plusPtr` (16 * (i)) :: Ptr PresentRegionKHR) (e) . ($ ())) ((regions))
         pure $ pPRegions
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr PresentRegionKHR))) pRegions''
@@ -330,7 +330,7 @@
 deriving instance Show PresentRegionKHR
 
 instance ToCStruct PresentRegionKHR where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentRegionKHR{..} f = evalContT $ do
     let pRectanglesLength = Data.Vector.length $ (rectangles)
     rectangleCount'' <- lift $ if (rectangleCount) == 0
@@ -343,7 +343,7 @@
     pRectangles'' <- if Data.Vector.null (rectangles)
       then pure nullPtr
       else do
-        pPRectangles <- ContT $ allocaBytesAligned @RectLayerKHR (((Data.Vector.length (rectangles))) * 20) 4
+        pPRectangles <- ContT $ allocaBytes @RectLayerKHR (((Data.Vector.length (rectangles))) * 20)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPRectangles `plusPtr` (20 * (i)) :: Ptr RectLayerKHR) (e)) ((rectangles))
         pure $ pPRectangles
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr RectLayerKHR))) pRectangles''
@@ -413,7 +413,7 @@
 deriving instance Show RectLayerKHR
 
 instance ToCStruct RectLayerKHR where
-  withCStruct x f = allocaBytesAligned 20 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 20 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RectLayerKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Offset2D)) (offset)
     poke ((p `plusPtr` 8 :: Ptr Extent2D)) (extent)
diff --git a/src/Vulkan/Extensions/VK_KHR_performance_query.hs b/src/Vulkan/Extensions/VK_KHR_performance_query.hs
--- a/src/Vulkan/Extensions/VK_KHR_performance_query.hs
+++ b/src/Vulkan/Extensions/VK_KHR_performance_query.hs
@@ -540,7 +540,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -933,7 +933,7 @@
 deriving instance Show PhysicalDevicePerformanceQueryFeaturesKHR
 
 instance ToCStruct PhysicalDevicePerformanceQueryFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePerformanceQueryFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -999,7 +999,7 @@
 deriving instance Show PhysicalDevicePerformanceQueryPropertiesKHR
 
 instance ToCStruct PhysicalDevicePerformanceQueryPropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePerformanceQueryPropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1063,7 +1063,7 @@
 deriving instance Show PerformanceCounterKHR
 
 instance ToCStruct PerformanceCounterKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceCounterKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1140,7 +1140,7 @@
 deriving instance Show PerformanceCounterDescriptionKHR
 
 instance ToCStruct PerformanceCounterDescriptionKHR where
-  withCStruct x f = allocaBytesAligned 792 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 792 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceCounterDescriptionKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1235,13 +1235,13 @@
 deriving instance Show QueryPoolPerformanceCreateInfoKHR
 
 instance ToCStruct QueryPoolPerformanceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueryPoolPerformanceCreateInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) (queueFamilyIndex)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (counterIndices)) :: Word32))
-    pPCounterIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (counterIndices)) * 4) 4
+    pPCounterIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (counterIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCounterIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (counterIndices)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPCounterIndices')
     lift $ f
@@ -1299,7 +1299,7 @@
 deriving instance Show AcquireProfilingLockInfoKHR
 
 instance ToCStruct AcquireProfilingLockInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AcquireProfilingLockInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1362,7 +1362,7 @@
 deriving instance Show PerformanceQuerySubmitInfoKHR
 
 instance ToCStruct PerformanceQuerySubmitInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PerformanceQuerySubmitInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1403,7 +1403,7 @@
   deriving (Show)
 
 instance ToCStruct PerformanceCounterResultKHR where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr PerformanceCounterResultKHR -> PerformanceCounterResultKHR -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     Int32Counter v -> lift $ poke (castPtr @_ @Int32 p) (v)
diff --git a/src/Vulkan/Extensions/VK_KHR_pipeline_executable_properties.hs b/src/Vulkan/Extensions/VK_KHR_pipeline_executable_properties.hs
--- a/src/Vulkan/Extensions/VK_KHR_pipeline_executable_properties.hs
+++ b/src/Vulkan/Extensions/VK_KHR_pipeline_executable_properties.hs
@@ -206,7 +206,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -630,7 +630,7 @@
 deriving instance Show PhysicalDevicePipelineExecutablePropertiesFeaturesKHR
 
 instance ToCStruct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -683,7 +683,7 @@
 deriving instance Show PipelineInfoKHR
 
 instance ToCStruct PipelineInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -762,7 +762,7 @@
 deriving instance Show PipelineExecutablePropertiesKHR
 
 instance ToCStruct PipelineExecutablePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 536 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 536 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineExecutablePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -839,7 +839,7 @@
 deriving instance Show PipelineExecutableInfoKHR
 
 instance ToCStruct PipelineExecutableInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineExecutableInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -908,7 +908,7 @@
 deriving instance Show PipelineExecutableStatisticKHR
 
 instance ToCStruct PipelineExecutableStatisticKHR where
-  withCStruct x f = allocaBytesAligned 544 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 544 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineExecutableStatisticKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1001,7 +1001,7 @@
 deriving instance Show PipelineExecutableInternalRepresentationKHR
 
 instance ToCStruct PipelineExecutableInternalRepresentationKHR where
-  withCStruct x f = allocaBytesAligned 552 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 552 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineExecutableInternalRepresentationKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1055,7 +1055,7 @@
   deriving (Show)
 
 instance ToCStruct PipelineExecutableStatisticValueKHR where
-  withCStruct x f = allocaBytesAligned 8 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr PipelineExecutableStatisticValueKHR -> PipelineExecutableStatisticValueKHR -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     B32 v -> lift $ poke (castPtr @_ @Bool32 p) (boolToBool32 (v))
diff --git a/src/Vulkan/Extensions/VK_KHR_pipeline_library.hs b/src/Vulkan/Extensions/VK_KHR_pipeline_library.hs
--- a/src/Vulkan/Extensions/VK_KHR_pipeline_library.hs
+++ b/src/Vulkan/Extensions/VK_KHR_pipeline_library.hs
@@ -89,7 +89,7 @@
                                                   , pattern KHR_PIPELINE_LIBRARY_EXTENSION_NAME
                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -155,12 +155,12 @@
 deriving instance Show PipelineLibraryCreateInfoKHR
 
 instance ToCStruct PipelineLibraryCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineLibraryCreateInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (libraries)) :: Word32))
-    pPLibraries' <- ContT $ allocaBytesAligned @Pipeline ((Data.Vector.length (libraries)) * 8) 8
+    pPLibraries' <- ContT $ allocaBytes @Pipeline ((Data.Vector.length (libraries)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPLibraries' `plusPtr` (8 * (i)) :: Ptr Pipeline) (e)) (libraries)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Pipeline))) (pPLibraries')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_KHR_portability_subset.hs b/src/Vulkan/Extensions/VK_KHR_portability_subset.hs
--- a/src/Vulkan/Extensions/VK_KHR_portability_subset.hs
+++ b/src/Vulkan/Extensions/VK_KHR_portability_subset.hs
@@ -144,7 +144,7 @@
                                                     , pattern KHR_PORTABILITY_SUBSET_EXTENSION_NAME
                                                     ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -296,7 +296,7 @@
 deriving instance Show PhysicalDevicePortabilitySubsetFeaturesKHR
 
 instance ToCStruct PhysicalDevicePortabilitySubsetFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePortabilitySubsetFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -415,7 +415,7 @@
 deriving instance Show PhysicalDevicePortabilitySubsetPropertiesKHR
 
 instance ToCStruct PhysicalDevicePortabilitySubsetPropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePortabilitySubsetPropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_push_descriptor.hs b/src/Vulkan/Extensions/VK_KHR_push_descriptor.hs
--- a/src/Vulkan/Extensions/VK_KHR_push_descriptor.hs
+++ b/src/Vulkan/Extensions/VK_KHR_push_descriptor.hs
@@ -138,7 +138,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -344,7 +344,7 @@
   lift $ unless (vkCmdPushDescriptorSetKHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdPushDescriptorSetKHR is null" Nothing Nothing
   let vkCmdPushDescriptorSetKHR' = mkVkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHRPtr
-  pPDescriptorWrites <- ContT $ allocaBytesAligned @(WriteDescriptorSet _) ((Data.Vector.length (descriptorWrites)) * 64) 8
+  pPDescriptorWrites <- ContT $ allocaBytes @(WriteDescriptorSet _) ((Data.Vector.length (descriptorWrites)) * 64)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPDescriptorWrites `plusPtr` (64 * (i)) :: Ptr (WriteDescriptorSet _))) (e) . ($ ())) (descriptorWrites)
   lift $ traceAroundEvent "vkCmdPushDescriptorSetKHR" (vkCmdPushDescriptorSetKHR' (commandBufferHandle (commandBuffer)) (pipelineBindPoint) (layout) (set) ((fromIntegral (Data.Vector.length $ (descriptorWrites)) :: Word32)) (forgetExtensions (pPDescriptorWrites)))
   pure $ ()
@@ -532,7 +532,7 @@
 deriving instance Show PhysicalDevicePushDescriptorPropertiesKHR
 
 instance ToCStruct PhysicalDevicePushDescriptorPropertiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDevicePushDescriptorPropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_ray_query.hs b/src/Vulkan/Extensions/VK_KHR_ray_query.hs
--- a/src/Vulkan/Extensions/VK_KHR_ray_query.hs
+++ b/src/Vulkan/Extensions/VK_KHR_ray_query.hs
@@ -252,7 +252,7 @@
                                            , pattern KHR_RAY_QUERY_EXTENSION_NAME
                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -310,7 +310,7 @@
 deriving instance Show PhysicalDeviceRayQueryFeaturesKHR
 
 instance ToCStruct PhysicalDeviceRayQueryFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRayQueryFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_ray_tracing_pipeline.hs b/src/Vulkan/Extensions/VK_KHR_ray_tracing_pipeline.hs
--- a/src/Vulkan/Extensions/VK_KHR_ray_tracing_pipeline.hs
+++ b/src/Vulkan/Extensions/VK_KHR_ray_tracing_pipeline.hs
@@ -764,7 +764,7 @@
 import Control.Monad.IO.Class (liftIO)
 import Data.Foldable (traverse_)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -1716,7 +1716,7 @@
   lift $ unless (vkCreateRayTracingPipelinesKHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCreateRayTracingPipelinesKHR is null" Nothing Nothing
   let vkCreateRayTracingPipelinesKHR' = mkVkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHRPtr
-  pPCreateInfos <- ContT $ allocaBytesAligned @(RayTracingPipelineCreateInfoKHR _) ((Data.Vector.length (createInfos)) * 104) 8
+  pPCreateInfos <- ContT $ allocaBytes @(RayTracingPipelineCreateInfoKHR _) ((Data.Vector.length (createInfos)) * 104)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPCreateInfos `plusPtr` (104 * (i)) :: Ptr (RayTracingPipelineCreateInfoKHR _))) (e) . ($ ())) (createInfos)
   pAllocator <- case (allocator) of
     Nothing -> pure nullPtr
@@ -2525,7 +2525,7 @@
 deriving instance Show RayTracingShaderGroupCreateInfoKHR
 
 instance ToCStruct RayTracingShaderGroupCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RayTracingShaderGroupCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2946,18 +2946,18 @@
     | otherwise = Nothing
 
 instance (Extendss RayTracingPipelineCreateInfoKHR es, PokeChain es) => ToCStruct (RayTracingPipelineCreateInfoKHR es) where
-  withCStruct x f = allocaBytesAligned 104 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 104 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RayTracingPipelineCreateInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (stages)) :: Word32))
-    pPStages' <- ContT $ allocaBytesAligned @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48) 8
+    pPStages' <- ContT $ allocaBytes @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPStages' `plusPtr` (48 * (i)) :: Ptr (PipelineShaderStageCreateInfo _))) (e) . ($ ())) (stages)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (PipelineShaderStageCreateInfo _)))) (pPStages')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (groups)) :: Word32))
-    pPGroups' <- ContT $ allocaBytesAligned @RayTracingShaderGroupCreateInfoKHR ((Data.Vector.length (groups)) * 48) 8
+    pPGroups' <- ContT $ allocaBytes @RayTracingShaderGroupCreateInfoKHR ((Data.Vector.length (groups)) * 48)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPGroups' `plusPtr` (48 * (i)) :: Ptr RayTracingShaderGroupCreateInfoKHR) (e)) (groups)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr RayTracingShaderGroupCreateInfoKHR))) (pPGroups')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) (maxPipelineRayRecursionDepth)
@@ -3116,7 +3116,7 @@
 deriving instance Show PhysicalDeviceRayTracingPipelineFeaturesKHR
 
 instance ToCStruct PhysicalDeviceRayTracingPipelineFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRayTracingPipelineFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3218,7 +3218,7 @@
 deriving instance Show PhysicalDeviceRayTracingPipelinePropertiesKHR
 
 instance ToCStruct PhysicalDeviceRayTracingPipelinePropertiesKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRayTracingPipelinePropertiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3313,7 +3313,7 @@
 deriving instance Show StridedDeviceAddressRegionKHR
 
 instance ToCStruct StridedDeviceAddressRegionKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p StridedDeviceAddressRegionKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceAddress)) (deviceAddress)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (stride)
@@ -3397,7 +3397,7 @@
 deriving instance Show TraceRaysIndirectCommandKHR
 
 instance ToCStruct TraceRaysIndirectCommandKHR where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p TraceRaysIndirectCommandKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (width)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (height)
@@ -3480,7 +3480,7 @@
 deriving instance Show RayTracingPipelineInterfaceCreateInfoKHR
 
 instance ToCStruct RayTracingPipelineInterfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RayTracingPipelineInterfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_shader_clock.hs b/src/Vulkan/Extensions/VK_KHR_shader_clock.hs
--- a/src/Vulkan/Extensions/VK_KHR_shader_clock.hs
+++ b/src/Vulkan/Extensions/VK_KHR_shader_clock.hs
@@ -112,7 +112,7 @@
                                               , pattern KHR_SHADER_CLOCK_EXTENSION_NAME
                                               ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -174,7 +174,7 @@
 deriving instance Show PhysicalDeviceShaderClockFeaturesKHR
 
 instance ToCStruct PhysicalDeviceShaderClockFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderClockFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_shader_subgroup_uniform_control_flow.hs b/src/Vulkan/Extensions/VK_KHR_shader_subgroup_uniform_control_flow.hs
--- a/src/Vulkan/Extensions/VK_KHR_shader_subgroup_uniform_control_flow.hs
+++ b/src/Vulkan/Extensions/VK_KHR_shader_subgroup_uniform_control_flow.hs
@@ -102,7 +102,7 @@
                                                                       , pattern KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME
                                                                       ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -165,7 +165,7 @@
 deriving instance Show PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
 
 instance ToCStruct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_shader_terminate_invocation.hs b/src/Vulkan/Extensions/VK_KHR_shader_terminate_invocation.hs
--- a/src/Vulkan/Extensions/VK_KHR_shader_terminate_invocation.hs
+++ b/src/Vulkan/Extensions/VK_KHR_shader_terminate_invocation.hs
@@ -109,7 +109,7 @@
                                                              , pattern KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME
                                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -170,7 +170,7 @@
 deriving instance Show PhysicalDeviceShaderTerminateInvocationFeaturesKHR
 
 instance ToCStruct PhysicalDeviceShaderTerminateInvocationFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderTerminateInvocationFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_shared_presentable_image.hs b/src/Vulkan/Extensions/VK_KHR_shared_presentable_image.hs
--- a/src/Vulkan/Extensions/VK_KHR_shared_presentable_image.hs
+++ b/src/Vulkan/Extensions/VK_KHR_shared_presentable_image.hs
@@ -229,7 +229,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -365,7 +365,7 @@
 deriving instance Show SharedPresentSurfaceCapabilitiesKHR
 
 instance ToCStruct SharedPresentSurfaceCapabilitiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SharedPresentSurfaceCapabilitiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_surface.hs b/src/Vulkan/Extensions/VK_KHR_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_surface.hs
@@ -437,7 +437,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1033,7 +1033,7 @@
 deriving instance Show SurfaceCapabilitiesKHR
 
 instance ToCStruct SurfaceCapabilitiesKHR where
-  withCStruct x f = allocaBytesAligned 52 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 52 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceCapabilitiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (minImageCount)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (maxImageCount)
@@ -1119,7 +1119,7 @@
 deriving instance Show SurfaceFormatKHR
 
 instance ToCStruct SurfaceFormatKHR where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceFormatKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Format)) (format)
     poke ((p `plusPtr` 4 :: Ptr ColorSpaceKHR)) (colorSpace)
diff --git a/src/Vulkan/Extensions/VK_KHR_surface_protected_capabilities.hs b/src/Vulkan/Extensions/VK_KHR_surface_protected_capabilities.hs
--- a/src/Vulkan/Extensions/VK_KHR_surface_protected_capabilities.hs
+++ b/src/Vulkan/Extensions/VK_KHR_surface_protected_capabilities.hs
@@ -114,7 +114,7 @@
                                                                 , pattern KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME
                                                                 ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -161,7 +161,7 @@
 deriving instance Show SurfaceProtectedCapabilitiesKHR
 
 instance ToCStruct SurfaceProtectedCapabilitiesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SurfaceProtectedCapabilitiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_swapchain.hs b/src/Vulkan/Extensions/VK_KHR_swapchain.hs
--- a/src/Vulkan/Extensions/VK_KHR_swapchain.hs
+++ b/src/Vulkan/Extensions/VK_KHR_swapchain.hs
@@ -1128,7 +1128,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -2705,7 +2705,7 @@
     | otherwise = Nothing
 
 instance (Extendss SwapchainCreateInfoKHR es, PokeChain es) => ToCStruct (SwapchainCreateInfoKHR es) where
-  withCStruct x f = allocaBytesAligned 104 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 104 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SwapchainCreateInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -2720,7 +2720,7 @@
     lift $ poke ((p `plusPtr` 56 :: Ptr ImageUsageFlags)) (imageUsage)
     lift $ poke ((p `plusPtr` 60 :: Ptr SharingMode)) (imageSharingMode)
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (queueFamilyIndices)) :: Word32))
-    pPQueueFamilyIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4) 4
+    pPQueueFamilyIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (queueFamilyIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPQueueFamilyIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (queueFamilyIndices)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr Word32))) (pPQueueFamilyIndices')
     lift $ poke ((p `plusPtr` 80 :: Ptr SurfaceTransformFlagBitsKHR)) (preTransform)
@@ -2923,23 +2923,23 @@
     | otherwise = Nothing
 
 instance (Extendss PresentInfoKHR es, PokeChain es) => ToCStruct (PresentInfoKHR es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PresentInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PRESENT_INFO_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (waitSemaphores)) :: Word32))
-    pPWaitSemaphores' <- ContT $ allocaBytesAligned @Semaphore ((Data.Vector.length (waitSemaphores)) * 8) 8
+    pPWaitSemaphores' <- ContT $ allocaBytes @Semaphore ((Data.Vector.length (waitSemaphores)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphores' `plusPtr` (8 * (i)) :: Ptr Semaphore) (e)) (waitSemaphores)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Semaphore))) (pPWaitSemaphores')
     let pSwapchainsLength = Data.Vector.length $ (swapchains)
     lift $ unless ((Data.Vector.length $ (imageIndices)) == pSwapchainsLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pImageIndices and pSwapchains must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral pSwapchainsLength :: Word32))
-    pPSwapchains' <- ContT $ allocaBytesAligned @SwapchainKHR ((Data.Vector.length (swapchains)) * 8) 8
+    pPSwapchains' <- ContT $ allocaBytes @SwapchainKHR ((Data.Vector.length (swapchains)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSwapchains' `plusPtr` (8 * (i)) :: Ptr SwapchainKHR) (e)) (swapchains)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr SwapchainKHR))) (pPSwapchains')
-    pPImageIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (imageIndices)) * 4) 4
+    pPImageIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (imageIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPImageIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (imageIndices)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr Word32))) (pPImageIndices')
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr Result))) (results)
@@ -3016,7 +3016,7 @@
 deriving instance Show DeviceGroupPresentCapabilitiesKHR
 
 instance ToCStruct DeviceGroupPresentCapabilitiesKHR where
-  withCStruct x f = allocaBytesAligned 152 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 152 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupPresentCapabilitiesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3088,7 +3088,7 @@
 deriving instance Show ImageSwapchainCreateInfoKHR
 
 instance ToCStruct ImageSwapchainCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageSwapchainCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3168,7 +3168,7 @@
 deriving instance Show BindImageMemorySwapchainInfoKHR
 
 instance ToCStruct BindImageMemorySwapchainInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindImageMemorySwapchainInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3314,7 +3314,7 @@
 deriving instance Show AcquireNextImageInfoKHR
 
 instance ToCStruct AcquireNextImageInfoKHR where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AcquireNextImageInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3466,12 +3466,12 @@
 deriving instance Show DeviceGroupPresentInfoKHR
 
 instance ToCStruct DeviceGroupPresentInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupPresentInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (deviceMasks)) :: Word32))
-    pPDeviceMasks' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (deviceMasks)) * 4) 4
+    pPDeviceMasks' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (deviceMasks)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDeviceMasks' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (deviceMasks)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Word32))) (pPDeviceMasks')
     lift $ poke ((p `plusPtr` 32 :: Ptr DeviceGroupPresentModeFlagBitsKHR)) (mode)
@@ -3530,7 +3530,7 @@
 deriving instance Show DeviceGroupSwapchainCreateInfoKHR
 
 instance ToCStruct DeviceGroupSwapchainCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceGroupSwapchainCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_synchronization2.hs b/src/Vulkan/Extensions/VK_KHR_synchronization2.hs
--- a/src/Vulkan/Extensions/VK_KHR_synchronization2.hs
+++ b/src/Vulkan/Extensions/VK_KHR_synchronization2.hs
@@ -536,7 +536,7 @@
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1009,9 +1009,9 @@
   let pEventsLength = Data.Vector.length $ (events)
   lift $ unless ((Data.Vector.length $ (dependencyInfos)) == pEventsLength) $
     throwIO $ IOError Nothing InvalidArgument "" "pDependencyInfos and pEvents must have the same length" Nothing Nothing
-  pPEvents <- ContT $ allocaBytesAligned @Event ((Data.Vector.length (events)) * 8) 8
+  pPEvents <- ContT $ allocaBytes @Event ((Data.Vector.length (events)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPEvents `plusPtr` (8 * (i)) :: Ptr Event) (e)) (events)
-  pPDependencyInfos <- ContT $ allocaBytesAligned @DependencyInfoKHR ((Data.Vector.length (dependencyInfos)) * 64) 8
+  pPDependencyInfos <- ContT $ allocaBytes @DependencyInfoKHR ((Data.Vector.length (dependencyInfos)) * 64)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPDependencyInfos `plusPtr` (64 * (i)) :: Ptr DependencyInfoKHR) (e) . ($ ())) (dependencyInfos)
   lift $ traceAroundEvent "vkCmdWaitEvents2KHR" (vkCmdWaitEvents2KHR' (commandBufferHandle (commandBuffer)) ((fromIntegral pEventsLength :: Word32)) (pPEvents) (pPDependencyInfos))
   pure $ ()
@@ -1610,7 +1610,7 @@
   lift $ unless (vkQueueSubmit2KHRPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkQueueSubmit2KHR is null" Nothing Nothing
   let vkQueueSubmit2KHR' = mkVkQueueSubmit2KHR vkQueueSubmit2KHRPtr
-  pPSubmits <- ContT $ allocaBytesAligned @(SubmitInfo2KHR _) ((Data.Vector.length (submits)) * 64) 8
+  pPSubmits <- ContT $ allocaBytes @(SubmitInfo2KHR _) ((Data.Vector.length (submits)) * 64)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPSubmits `plusPtr` (64 * (i)) :: Ptr (SubmitInfo2KHR _))) (e) . ($ ())) (submits)
   r <- lift $ traceAroundEvent "vkQueueSubmit2KHR" (vkQueueSubmit2KHR' (queueHandle (queue)) ((fromIntegral (Data.Vector.length $ (submits)) :: Word32)) (forgetExtensions (pPSubmits)) (fence))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -2637,7 +2637,7 @@
 deriving instance Show MemoryBarrier2KHR
 
 instance ToCStruct MemoryBarrier2KHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MemoryBarrier2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3641,7 +3641,7 @@
     | otherwise = Nothing
 
 instance (Extendss ImageMemoryBarrier2KHR es, PokeChain es) => ToCStruct (ImageMemoryBarrier2KHR es) where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageMemoryBarrier2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
@@ -4372,7 +4372,7 @@
 deriving instance Show BufferMemoryBarrier2KHR
 
 instance ToCStruct BufferMemoryBarrier2KHR where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BufferMemoryBarrier2KHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -4504,21 +4504,21 @@
 deriving instance Show DependencyInfoKHR
 
 instance ToCStruct DependencyInfoKHR where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DependencyInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEPENDENCY_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr DependencyFlags)) (dependencyFlags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (memoryBarriers)) :: Word32))
-    pPMemoryBarriers' <- ContT $ allocaBytesAligned @MemoryBarrier2KHR ((Data.Vector.length (memoryBarriers)) * 48) 8
+    pPMemoryBarriers' <- ContT $ allocaBytes @MemoryBarrier2KHR ((Data.Vector.length (memoryBarriers)) * 48)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPMemoryBarriers' `plusPtr` (48 * (i)) :: Ptr MemoryBarrier2KHR) (e)) (memoryBarriers)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr MemoryBarrier2KHR))) (pPMemoryBarriers')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (bufferMemoryBarriers)) :: Word32))
-    pPBufferMemoryBarriers' <- ContT $ allocaBytesAligned @BufferMemoryBarrier2KHR ((Data.Vector.length (bufferMemoryBarriers)) * 80) 8
+    pPBufferMemoryBarriers' <- ContT $ allocaBytes @BufferMemoryBarrier2KHR ((Data.Vector.length (bufferMemoryBarriers)) * 80)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPBufferMemoryBarriers' `plusPtr` (80 * (i)) :: Ptr BufferMemoryBarrier2KHR) (e)) (bufferMemoryBarriers)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr BufferMemoryBarrier2KHR))) (pPBufferMemoryBarriers')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (imageMemoryBarriers)) :: Word32))
-    pPImageMemoryBarriers' <- ContT $ allocaBytesAligned @(ImageMemoryBarrier2KHR _) ((Data.Vector.length (imageMemoryBarriers)) * 96) 8
+    pPImageMemoryBarriers' <- ContT $ allocaBytes @(ImageMemoryBarrier2KHR _) ((Data.Vector.length (imageMemoryBarriers)) * 96)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPImageMemoryBarriers' `plusPtr` (96 * (i)) :: Ptr (ImageMemoryBarrier2KHR _))) (e) . ($ ())) (imageMemoryBarriers)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr (ImageMemoryBarrier2KHR _)))) (pPImageMemoryBarriers')
     lift $ f
@@ -4657,7 +4657,7 @@
 deriving instance Show SemaphoreSubmitInfoKHR
 
 instance ToCStruct SemaphoreSubmitInfoKHR where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SemaphoreSubmitInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -4743,7 +4743,7 @@
 deriving instance Show CommandBufferSubmitInfoKHR
 
 instance ToCStruct CommandBufferSubmitInfoKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferSubmitInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -4899,22 +4899,22 @@
     | otherwise = Nothing
 
 instance (Extendss SubmitInfo2KHR es, PokeChain es) => ToCStruct (SubmitInfo2KHR es) where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SubmitInfo2KHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SUBMIT_INFO_2_KHR)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr SubmitFlagsKHR)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (waitSemaphoreInfos)) :: Word32))
-    pPWaitSemaphoreInfos' <- ContT $ allocaBytesAligned @SemaphoreSubmitInfoKHR ((Data.Vector.length (waitSemaphoreInfos)) * 48) 8
+    pPWaitSemaphoreInfos' <- ContT $ allocaBytes @SemaphoreSubmitInfoKHR ((Data.Vector.length (waitSemaphoreInfos)) * 48)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPWaitSemaphoreInfos' `plusPtr` (48 * (i)) :: Ptr SemaphoreSubmitInfoKHR) (e)) (waitSemaphoreInfos)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr SemaphoreSubmitInfoKHR))) (pPWaitSemaphoreInfos')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (commandBufferInfos)) :: Word32))
-    pPCommandBufferInfos' <- ContT $ allocaBytesAligned @CommandBufferSubmitInfoKHR ((Data.Vector.length (commandBufferInfos)) * 32) 8
+    pPCommandBufferInfos' <- ContT $ allocaBytes @CommandBufferSubmitInfoKHR ((Data.Vector.length (commandBufferInfos)) * 32)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPCommandBufferInfos' `plusPtr` (32 * (i)) :: Ptr CommandBufferSubmitInfoKHR) (e)) (commandBufferInfos)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr CommandBufferSubmitInfoKHR))) (pPCommandBufferInfos')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (signalSemaphoreInfos)) :: Word32))
-    pPSignalSemaphoreInfos' <- ContT $ allocaBytesAligned @SemaphoreSubmitInfoKHR ((Data.Vector.length (signalSemaphoreInfos)) * 48) 8
+    pPSignalSemaphoreInfos' <- ContT $ allocaBytes @SemaphoreSubmitInfoKHR ((Data.Vector.length (signalSemaphoreInfos)) * 48)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSignalSemaphoreInfos' `plusPtr` (48 * (i)) :: Ptr SemaphoreSubmitInfoKHR) (e)) (signalSemaphoreInfos)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr SemaphoreSubmitInfoKHR))) (pPSignalSemaphoreInfos')
     lift $ f
@@ -4978,7 +4978,7 @@
 deriving instance Show QueueFamilyCheckpointProperties2NV
 
 instance ToCStruct QueueFamilyCheckpointProperties2NV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueueFamilyCheckpointProperties2NV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5038,7 +5038,7 @@
 deriving instance Show CheckpointData2NV
 
 instance ToCStruct CheckpointData2NV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CheckpointData2NV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -5110,7 +5110,7 @@
 deriving instance Show PhysicalDeviceSynchronization2FeaturesKHR
 
 instance ToCStruct PhysicalDeviceSynchronization2FeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceSynchronization2FeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_wayland_surface.hs b/src/Vulkan/Extensions/VK_KHR_wayland_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_wayland_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_wayland_surface.hs
@@ -205,7 +205,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -422,7 +422,7 @@
 deriving instance Show WaylandSurfaceCreateInfoKHR
 
 instance ToCStruct WaylandSurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p WaylandSurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_win32_keyed_mutex.hs b/src/Vulkan/Extensions/VK_KHR_win32_keyed_mutex.hs
--- a/src/Vulkan/Extensions/VK_KHR_win32_keyed_mutex.hs
+++ b/src/Vulkan/Extensions/VK_KHR_win32_keyed_mutex.hs
@@ -95,7 +95,7 @@
                                                    ) where
 
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -206,7 +206,7 @@
 deriving instance Show Win32KeyedMutexAcquireReleaseInfoKHR
 
 instance ToCStruct Win32KeyedMutexAcquireReleaseInfoKHR where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Win32KeyedMutexAcquireReleaseInfoKHR{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -216,23 +216,23 @@
     lift $ unless ((Data.Vector.length $ (acquireTimeouts)) == pAcquireSyncsLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pAcquireTimeouts and pAcquireSyncs must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral pAcquireSyncsLength :: Word32))
-    pPAcquireSyncs' <- ContT $ allocaBytesAligned @DeviceMemory ((Data.Vector.length (acquireSyncs)) * 8) 8
+    pPAcquireSyncs' <- ContT $ allocaBytes @DeviceMemory ((Data.Vector.length (acquireSyncs)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireSyncs' `plusPtr` (8 * (i)) :: Ptr DeviceMemory) (e)) (acquireSyncs)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DeviceMemory))) (pPAcquireSyncs')
-    pPAcquireKeys' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (acquireKeys)) * 8) 8
+    pPAcquireKeys' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (acquireKeys)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireKeys' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (acquireKeys)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Word64))) (pPAcquireKeys')
-    pPAcquireTimeouts' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (acquireTimeouts)) * 4) 4
+    pPAcquireTimeouts' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (acquireTimeouts)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireTimeouts' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (acquireTimeouts)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Word32))) (pPAcquireTimeouts')
     let pReleaseSyncsLength = Data.Vector.length $ (releaseSyncs)
     lift $ unless ((Data.Vector.length $ (releaseKeys)) == pReleaseSyncsLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pReleaseKeys and pReleaseSyncs must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral pReleaseSyncsLength :: Word32))
-    pPReleaseSyncs' <- ContT $ allocaBytesAligned @DeviceMemory ((Data.Vector.length (releaseSyncs)) * 8) 8
+    pPReleaseSyncs' <- ContT $ allocaBytes @DeviceMemory ((Data.Vector.length (releaseSyncs)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPReleaseSyncs' `plusPtr` (8 * (i)) :: Ptr DeviceMemory) (e)) (releaseSyncs)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr DeviceMemory))) (pPReleaseSyncs')
-    pPReleaseKeys' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (releaseKeys)) * 8) 8
+    pPReleaseKeys' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (releaseKeys)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPReleaseKeys' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (releaseKeys)
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr Word64))) (pPReleaseKeys')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_KHR_win32_surface.hs b/src/Vulkan/Extensions/VK_KHR_win32_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_win32_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_win32_surface.hs
@@ -231,7 +231,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -443,7 +443,7 @@
 deriving instance Show Win32SurfaceCreateInfoKHR
 
 instance ToCStruct Win32SurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Win32SurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_workgroup_memory_explicit_layout.hs b/src/Vulkan/Extensions/VK_KHR_workgroup_memory_explicit_layout.hs
--- a/src/Vulkan/Extensions/VK_KHR_workgroup_memory_explicit_layout.hs
+++ b/src/Vulkan/Extensions/VK_KHR_workgroup_memory_explicit_layout.hs
@@ -121,7 +121,7 @@
                                                                   , pattern KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME
                                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -204,7 +204,7 @@
 deriving instance Show PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
 
 instance ToCStruct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_xcb_surface.hs b/src/Vulkan/Extensions/VK_KHR_xcb_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_xcb_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_xcb_surface.hs
@@ -188,7 +188,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -405,7 +405,7 @@
 deriving instance Show XcbSurfaceCreateInfoKHR
 
 instance ToCStruct XcbSurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p XcbSurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_xlib_surface.hs b/src/Vulkan/Extensions/VK_KHR_xlib_surface.hs
--- a/src/Vulkan/Extensions/VK_KHR_xlib_surface.hs
+++ b/src/Vulkan/Extensions/VK_KHR_xlib_surface.hs
@@ -188,7 +188,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -407,7 +407,7 @@
 deriving instance Show XlibSurfaceCreateInfoKHR
 
 instance ToCStruct XlibSurfaceCreateInfoKHR where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p XlibSurfaceCreateInfoKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_KHR_zero_initialize_workgroup_memory.hs b/src/Vulkan/Extensions/VK_KHR_zero_initialize_workgroup_memory.hs
--- a/src/Vulkan/Extensions/VK_KHR_zero_initialize_workgroup_memory.hs
+++ b/src/Vulkan/Extensions/VK_KHR_zero_initialize_workgroup_memory.hs
@@ -97,7 +97,7 @@
                                                                   , pattern KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME
                                                                   ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -159,7 +159,7 @@
 deriving instance Show PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
 
 instance ToCStruct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_MVK_ios_surface.hs b/src/Vulkan/Extensions/VK_MVK_ios_surface.hs
--- a/src/Vulkan/Extensions/VK_MVK_ios_surface.hs
+++ b/src/Vulkan/Extensions/VK_MVK_ios_surface.hs
@@ -126,7 +126,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -317,7 +317,7 @@
 deriving instance Show IOSSurfaceCreateInfoMVK
 
 instance ToCStruct IOSSurfaceCreateInfoMVK where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p IOSSurfaceCreateInfoMVK{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_MVK_macos_surface.hs b/src/Vulkan/Extensions/VK_MVK_macos_surface.hs
--- a/src/Vulkan/Extensions/VK_MVK_macos_surface.hs
+++ b/src/Vulkan/Extensions/VK_MVK_macos_surface.hs
@@ -126,7 +126,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -321,7 +321,7 @@
 deriving instance Show MacOSSurfaceCreateInfoMVK
 
 instance ToCStruct MacOSSurfaceCreateInfoMVK where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MacOSSurfaceCreateInfoMVK{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NN_vi_surface.hs b/src/Vulkan/Extensions/VK_NN_vi_surface.hs
--- a/src/Vulkan/Extensions/VK_NN_vi_surface.hs
+++ b/src/Vulkan/Extensions/VK_NN_vi_surface.hs
@@ -125,7 +125,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -294,7 +294,7 @@
 deriving instance Show ViSurfaceCreateInfoNN
 
 instance ToCStruct ViSurfaceCreateInfoNN where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ViSurfaceCreateInfoNN{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NVX_binary_import.hs b/src/Vulkan/Extensions/VK_NVX_binary_import.hs
--- a/src/Vulkan/Extensions/VK_NVX_binary_import.hs
+++ b/src/Vulkan/Extensions/VK_NVX_binary_import.hs
@@ -142,7 +142,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -398,7 +398,7 @@
 deriving instance Show CuModuleCreateInfoNVX
 
 instance ToCStruct CuModuleCreateInfoNVX where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CuModuleCreateInfoNVX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -447,7 +447,7 @@
 deriving instance Show CuFunctionCreateInfoNVX
 
 instance ToCStruct CuFunctionCreateInfoNVX where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CuFunctionCreateInfoNVX{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -512,7 +512,7 @@
 deriving instance Show CuLaunchInfoNVX
 
 instance ToCStruct CuLaunchInfoNVX where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CuLaunchInfoNVX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NVX_image_view_handle.hs b/src/Vulkan/Extensions/VK_NVX_image_view_handle.hs
--- a/src/Vulkan/Extensions/VK_NVX_image_view_handle.hs
+++ b/src/Vulkan/Extensions/VK_NVX_image_view_handle.hs
@@ -104,7 +104,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -318,7 +318,7 @@
 deriving instance Show ImageViewHandleInfoNVX
 
 instance ToCStruct ImageViewHandleInfoNVX where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageViewHandleInfoNVX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -380,7 +380,7 @@
 deriving instance Show ImageViewAddressPropertiesNVX
 
 instance ToCStruct ImageViewAddressPropertiesNVX where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImageViewAddressPropertiesNVX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NVX_multiview_per_view_attributes.hs b/src/Vulkan/Extensions/VK_NVX_multiview_per_view_attributes.hs
--- a/src/Vulkan/Extensions/VK_NVX_multiview_per_view_attributes.hs
+++ b/src/Vulkan/Extensions/VK_NVX_multiview_per_view_attributes.hs
@@ -161,7 +161,7 @@
                                                                , pattern NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME
                                                                ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -215,7 +215,7 @@
 deriving instance Show PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
 
 instance ToCStruct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_clip_space_w_scaling.hs b/src/Vulkan/Extensions/VK_NV_clip_space_w_scaling.hs
--- a/src/Vulkan/Extensions/VK_NV_clip_space_w_scaling.hs
+++ b/src/Vulkan/Extensions/VK_NV_clip_space_w_scaling.hs
@@ -215,7 +215,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -344,7 +344,7 @@
   lift $ unless (vkCmdSetViewportWScalingNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetViewportWScalingNV is null" Nothing Nothing
   let vkCmdSetViewportWScalingNV' = mkVkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNVPtr
-  pPViewportWScalings <- ContT $ allocaBytesAligned @ViewportWScalingNV ((Data.Vector.length (viewportWScalings)) * 8) 4
+  pPViewportWScalings <- ContT $ allocaBytes @ViewportWScalingNV ((Data.Vector.length (viewportWScalings)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPViewportWScalings `plusPtr` (8 * (i)) :: Ptr ViewportWScalingNV) (e)) (viewportWScalings)
   lift $ traceAroundEvent "vkCmdSetViewportWScalingNV" (vkCmdSetViewportWScalingNV' (commandBufferHandle (commandBuffer)) (firstViewport) ((fromIntegral (Data.Vector.length $ (viewportWScalings)) :: Word32)) (pPViewportWScalings))
   pure $ ()
@@ -369,7 +369,7 @@
 deriving instance Show ViewportWScalingNV
 
 instance ToCStruct ViewportWScalingNV where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ViewportWScalingNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (xcoeff))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (ycoeff))
@@ -433,7 +433,7 @@
 deriving instance Show PipelineViewportWScalingStateCreateInfoNV
 
 instance ToCStruct PipelineViewportWScalingStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportWScalingStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -449,7 +449,7 @@
     pViewportWScalings'' <- if Data.Vector.null (viewportWScalings)
       then pure nullPtr
       else do
-        pPViewportWScalings <- ContT $ allocaBytesAligned @ViewportWScalingNV (((Data.Vector.length (viewportWScalings))) * 8) 4
+        pPViewportWScalings <- ContT $ allocaBytes @ViewportWScalingNV (((Data.Vector.length (viewportWScalings))) * 8)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPViewportWScalings `plusPtr` (8 * (i)) :: Ptr ViewportWScalingNV) (e)) ((viewportWScalings))
         pure $ pPViewportWScalings
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ViewportWScalingNV))) pViewportWScalings''
diff --git a/src/Vulkan/Extensions/VK_NV_compute_shader_derivatives.hs b/src/Vulkan/Extensions/VK_NV_compute_shader_derivatives.hs
--- a/src/Vulkan/Extensions/VK_NV_compute_shader_derivatives.hs
+++ b/src/Vulkan/Extensions/VK_NV_compute_shader_derivatives.hs
@@ -124,7 +124,7 @@
                                                            , pattern NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -194,7 +194,7 @@
 deriving instance Show PhysicalDeviceComputeShaderDerivativesFeaturesNV
 
 instance ToCStruct PhysicalDeviceComputeShaderDerivativesFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceComputeShaderDerivativesFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_cooperative_matrix.hs b/src/Vulkan/Extensions/VK_NV_cooperative_matrix.hs
--- a/src/Vulkan/Extensions/VK_NV_cooperative_matrix.hs
+++ b/src/Vulkan/Extensions/VK_NV_cooperative_matrix.hs
@@ -182,7 +182,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -359,7 +359,7 @@
 deriving instance Show PhysicalDeviceCooperativeMatrixFeaturesNV
 
 instance ToCStruct PhysicalDeviceCooperativeMatrixFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCooperativeMatrixFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -430,7 +430,7 @@
 deriving instance Show PhysicalDeviceCooperativeMatrixPropertiesNV
 
 instance ToCStruct PhysicalDeviceCooperativeMatrixPropertiesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCooperativeMatrixPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -520,7 +520,7 @@
 deriving instance Show CooperativeMatrixPropertiesNV
 
 instance ToCStruct CooperativeMatrixPropertiesNV where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CooperativeMatrixPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_corner_sampled_image.hs b/src/Vulkan/Extensions/VK_NV_corner_sampled_image.hs
--- a/src/Vulkan/Extensions/VK_NV_corner_sampled_image.hs
+++ b/src/Vulkan/Extensions/VK_NV_corner_sampled_image.hs
@@ -159,7 +159,7 @@
                                                      , pattern NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -221,7 +221,7 @@
 deriving instance Show PhysicalDeviceCornerSampledImageFeaturesNV
 
 instance ToCStruct PhysicalDeviceCornerSampledImageFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCornerSampledImageFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_coverage_reduction_mode.hs b/src/Vulkan/Extensions/VK_NV_coverage_reduction_mode.hs
--- a/src/Vulkan/Extensions/VK_NV_coverage_reduction_mode.hs
+++ b/src/Vulkan/Extensions/VK_NV_coverage_reduction_mode.hs
@@ -151,7 +151,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -332,7 +332,7 @@
 deriving instance Show PhysicalDeviceCoverageReductionModeFeaturesNV
 
 instance ToCStruct PhysicalDeviceCoverageReductionModeFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceCoverageReductionModeFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -415,7 +415,7 @@
 deriving instance Show PipelineCoverageReductionStateCreateInfoNV
 
 instance ToCStruct PipelineCoverageReductionStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCoverageReductionStateCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -485,7 +485,7 @@
 deriving instance Show FramebufferMixedSamplesCombinationNV
 
 instance ToCStruct FramebufferMixedSamplesCombinationNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p FramebufferMixedSamplesCombinationNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_dedicated_allocation.hs b/src/Vulkan/Extensions/VK_NV_dedicated_allocation.hs
--- a/src/Vulkan/Extensions/VK_NV_dedicated_allocation.hs
+++ b/src/Vulkan/Extensions/VK_NV_dedicated_allocation.hs
@@ -184,7 +184,7 @@
                                                      , pattern NV_DEDICATED_ALLOCATION_EXTENSION_NAME
                                                      ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -251,7 +251,7 @@
 deriving instance Show DedicatedAllocationImageCreateInfoNV
 
 instance ToCStruct DedicatedAllocationImageCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DedicatedAllocationImageCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -302,7 +302,7 @@
 deriving instance Show DedicatedAllocationBufferCreateInfoNV
 
 instance ToCStruct DedicatedAllocationBufferCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DedicatedAllocationBufferCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -420,7 +420,7 @@
 deriving instance Show DedicatedAllocationMemoryAllocateInfoNV
 
 instance ToCStruct DedicatedAllocationMemoryAllocateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DedicatedAllocationMemoryAllocateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_dedicated_allocation_image_aliasing.hs b/src/Vulkan/Extensions/VK_NV_dedicated_allocation_image_aliasing.hs
--- a/src/Vulkan/Extensions/VK_NV_dedicated_allocation_image_aliasing.hs
+++ b/src/Vulkan/Extensions/VK_NV_dedicated_allocation_image_aliasing.hs
@@ -93,7 +93,7 @@
                                                                     , pattern NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME
                                                                     ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -154,7 +154,7 @@
 deriving instance Show PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
 
 instance ToCStruct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_device_diagnostic_checkpoints.hs b/src/Vulkan/Extensions/VK_NV_device_diagnostic_checkpoints.hs
--- a/src/Vulkan/Extensions/VK_NV_device_diagnostic_checkpoints.hs
+++ b/src/Vulkan/Extensions/VK_NV_device_diagnostic_checkpoints.hs
@@ -118,7 +118,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.IO (throwIO)
@@ -320,7 +320,7 @@
 deriving instance Show QueueFamilyCheckpointPropertiesNV
 
 instance ToCStruct QueueFamilyCheckpointPropertiesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p QueueFamilyCheckpointPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -382,7 +382,7 @@
 deriving instance Show CheckpointDataNV
 
 instance ToCStruct CheckpointDataNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CheckpointDataNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_CHECKPOINT_DATA_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_device_diagnostics_config.hs b/src/Vulkan/Extensions/VK_NV_device_diagnostics_config.hs
--- a/src/Vulkan/Extensions/VK_NV_device_diagnostics_config.hs
+++ b/src/Vulkan/Extensions/VK_NV_device_diagnostics_config.hs
@@ -112,7 +112,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -181,7 +181,7 @@
 deriving instance Show PhysicalDeviceDiagnosticsConfigFeaturesNV
 
 instance ToCStruct PhysicalDeviceDiagnosticsConfigFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDiagnosticsConfigFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -236,7 +236,7 @@
 deriving instance Show DeviceDiagnosticsConfigCreateInfoNV
 
 instance ToCStruct DeviceDiagnosticsConfigCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DeviceDiagnosticsConfigCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_device_generated_commands.hs b/src/Vulkan/Extensions/VK_NV_device_generated_commands.hs
--- a/src/Vulkan/Extensions/VK_NV_device_generated_commands.hs
+++ b/src/Vulkan/Extensions/VK_NV_device_generated_commands.hs
@@ -595,7 +595,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import Foreign.Marshal.Utils (maybePeek)
@@ -1777,7 +1777,7 @@
 deriving instance Show PhysicalDeviceDeviceGeneratedCommandsFeaturesNV
 
 instance ToCStruct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDeviceGeneratedCommandsFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1862,7 +1862,7 @@
 deriving instance Show PhysicalDeviceDeviceGeneratedCommandsPropertiesNV
 
 instance ToCStruct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceDeviceGeneratedCommandsPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1994,12 +1994,12 @@
 deriving instance Show GraphicsShaderGroupCreateInfoNV
 
 instance ToCStruct GraphicsShaderGroupCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GraphicsShaderGroupCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (stages)) :: Word32))
-    pPStages' <- ContT $ allocaBytesAligned @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48) 8
+    pPStages' <- ContT $ allocaBytes @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPStages' `plusPtr` (48 * (i)) :: Ptr (PipelineShaderStageCreateInfo _))) (e) . ($ ())) (stages)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (PipelineShaderStageCreateInfo _)))) (pPStages')
     pVertexInputState'' <- case (vertexInputState) of
@@ -2130,16 +2130,16 @@
 deriving instance Show GraphicsPipelineShaderGroupsCreateInfoNV
 
 instance ToCStruct GraphicsPipelineShaderGroupsCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GraphicsPipelineShaderGroupsCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (groups)) :: Word32))
-    pPGroups' <- ContT $ allocaBytesAligned @GraphicsShaderGroupCreateInfoNV ((Data.Vector.length (groups)) * 48) 8
+    pPGroups' <- ContT $ allocaBytes @GraphicsShaderGroupCreateInfoNV ((Data.Vector.length (groups)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPGroups' `plusPtr` (48 * (i)) :: Ptr GraphicsShaderGroupCreateInfoNV) (e) . ($ ())) (groups)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr GraphicsShaderGroupCreateInfoNV))) (pPGroups')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (pipelines)) :: Word32))
-    pPPipelines' <- ContT $ allocaBytesAligned @Pipeline ((Data.Vector.length (pipelines)) * 8) 8
+    pPPipelines' <- ContT $ allocaBytes @Pipeline ((Data.Vector.length (pipelines)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPPipelines' `plusPtr` (8 * (i)) :: Ptr Pipeline) (e)) (pipelines)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Pipeline))) (pPPipelines')
     lift $ f
@@ -2195,7 +2195,7 @@
 deriving instance Show BindShaderGroupIndirectCommandNV
 
 instance ToCStruct BindShaderGroupIndirectCommandNV where
-  withCStruct x f = allocaBytesAligned 4 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 4 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindShaderGroupIndirectCommandNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (groupIndex)
     f
@@ -2272,7 +2272,7 @@
 deriving instance Show BindIndexBufferIndirectCommandNV
 
 instance ToCStruct BindIndexBufferIndirectCommandNV where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindIndexBufferIndirectCommandNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceAddress)) (bufferAddress)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (size)
@@ -2346,7 +2346,7 @@
 deriving instance Show BindVertexBufferIndirectCommandNV
 
 instance ToCStruct BindVertexBufferIndirectCommandNV where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindVertexBufferIndirectCommandNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr DeviceAddress)) (bufferAddress)
     poke ((p `plusPtr` 8 :: Ptr Word32)) (size)
@@ -2401,7 +2401,7 @@
 deriving instance Show SetStateFlagsIndirectCommandNV
 
 instance ToCStruct SetStateFlagsIndirectCommandNV where
-  withCStruct x f = allocaBytesAligned 4 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 4 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SetStateFlagsIndirectCommandNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (data')
     f
@@ -2470,7 +2470,7 @@
 deriving instance Show IndirectCommandsStreamNV
 
 instance ToCStruct IndirectCommandsStreamNV where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p IndirectCommandsStreamNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Buffer)) (buffer)
     poke ((p `plusPtr` 8 :: Ptr DeviceSize)) (offset)
@@ -2644,7 +2644,7 @@
 deriving instance Show IndirectCommandsLayoutTokenNV
 
 instance ToCStruct IndirectCommandsLayoutTokenNV where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p IndirectCommandsLayoutTokenNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2662,10 +2662,10 @@
     lift $ unless ((Data.Vector.length $ (indexTypeValues)) == pIndexTypesLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pIndexTypeValues and pIndexTypes must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 64 :: Ptr Word32)) ((fromIntegral pIndexTypesLength :: Word32))
-    pPIndexTypes' <- ContT $ allocaBytesAligned @IndexType ((Data.Vector.length (indexTypes)) * 4) 4
+    pPIndexTypes' <- ContT $ allocaBytes @IndexType ((Data.Vector.length (indexTypes)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPIndexTypes' `plusPtr` (4 * (i)) :: Ptr IndexType) (e)) (indexTypes)
     lift $ poke ((p `plusPtr` 72 :: Ptr (Ptr IndexType))) (pPIndexTypes')
-    pPIndexTypeValues' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (indexTypeValues)) * 4) 4
+    pPIndexTypeValues' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (indexTypeValues)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPIndexTypeValues' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (indexTypeValues)
     lift $ poke ((p `plusPtr` 80 :: Ptr (Ptr Word32))) (pPIndexTypeValues')
     lift $ f
@@ -2845,18 +2845,18 @@
 deriving instance Show IndirectCommandsLayoutCreateInfoNV
 
 instance ToCStruct IndirectCommandsLayoutCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p IndirectCommandsLayoutCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr IndirectCommandsLayoutUsageFlagsNV)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr PipelineBindPoint)) (pipelineBindPoint)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (tokens)) :: Word32))
-    pPTokens' <- ContT $ allocaBytesAligned @IndirectCommandsLayoutTokenNV ((Data.Vector.length (tokens)) * 88) 8
+    pPTokens' <- ContT $ allocaBytes @IndirectCommandsLayoutTokenNV ((Data.Vector.length (tokens)) * 88)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPTokens' `plusPtr` (88 * (i)) :: Ptr IndirectCommandsLayoutTokenNV) (e) . ($ ())) (tokens)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr IndirectCommandsLayoutTokenNV))) (pPTokens')
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (streamStrides)) :: Word32))
-    pPStreamStrides' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (streamStrides)) * 4) 4
+    pPStreamStrides' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (streamStrides)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPStreamStrides' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (streamStrides)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr Word32))) (pPStreamStrides')
     lift $ f
@@ -3100,7 +3100,7 @@
 deriving instance Show GeneratedCommandsInfoNV
 
 instance ToCStruct GeneratedCommandsInfoNV where
-  withCStruct x f = allocaBytesAligned 120 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 120 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeneratedCommandsInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3108,7 +3108,7 @@
     lift $ poke ((p `plusPtr` 24 :: Ptr Pipeline)) (pipeline)
     lift $ poke ((p `plusPtr` 32 :: Ptr IndirectCommandsLayoutNV)) (indirectCommandsLayout)
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (streams)) :: Word32))
-    pPStreams' <- ContT $ allocaBytesAligned @IndirectCommandsStreamNV ((Data.Vector.length (streams)) * 16) 8
+    pPStreams' <- ContT $ allocaBytes @IndirectCommandsStreamNV ((Data.Vector.length (streams)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPStreams' `plusPtr` (16 * (i)) :: Ptr IndirectCommandsStreamNV) (e)) (streams)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr IndirectCommandsStreamNV))) (pPStreams')
     lift $ poke ((p `plusPtr` 56 :: Ptr Word32)) (sequencesCount)
@@ -3236,7 +3236,7 @@
 deriving instance Show GeneratedCommandsMemoryRequirementsInfoNV
 
 instance ToCStruct GeneratedCommandsMemoryRequirementsInfoNV where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeneratedCommandsMemoryRequirementsInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_external_memory.hs b/src/Vulkan/Extensions/VK_NV_external_memory.hs
--- a/src/Vulkan/Extensions/VK_NV_external_memory.hs
+++ b/src/Vulkan/Extensions/VK_NV_external_memory.hs
@@ -144,7 +144,7 @@
                                                 , ExternalMemoryHandleTypeFlagsNV
                                                 ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -193,7 +193,7 @@
 deriving instance Show ExternalMemoryImageCreateInfoNV
 
 instance ToCStruct ExternalMemoryImageCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalMemoryImageCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -252,7 +252,7 @@
 deriving instance Show ExportMemoryAllocateInfoNV
 
 instance ToCStruct ExportMemoryAllocateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportMemoryAllocateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_external_memory_capabilities.hs b/src/Vulkan/Extensions/VK_NV_external_memory_capabilities.hs
--- a/src/Vulkan/Extensions/VK_NV_external_memory_capabilities.hs
+++ b/src/Vulkan/Extensions/VK_NV_external_memory_capabilities.hs
@@ -162,7 +162,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.Base (when)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
@@ -368,7 +368,7 @@
 deriving instance Show ExternalImageFormatPropertiesNV
 
 instance ToCStruct ExternalImageFormatPropertiesNV where
-  withCStruct x f = allocaBytesAligned 48 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 48 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExternalImageFormatPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ImageFormatProperties)) (imageFormatProperties)
     poke ((p `plusPtr` 32 :: Ptr ExternalMemoryFeatureFlagsNV)) (externalMemoryFeatures)
diff --git a/src/Vulkan/Extensions/VK_NV_external_memory_win32.hs b/src/Vulkan/Extensions/VK_NV_external_memory_win32.hs
--- a/src/Vulkan/Extensions/VK_NV_external_memory_win32.hs
+++ b/src/Vulkan/Extensions/VK_NV_external_memory_win32.hs
@@ -293,7 +293,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -451,7 +451,7 @@
 deriving instance Show ImportMemoryWin32HandleInfoNV
 
 instance ToCStruct ImportMemoryWin32HandleInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ImportMemoryWin32HandleInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -527,7 +527,7 @@
 deriving instance Show ExportMemoryWin32HandleInfoNV
 
 instance ToCStruct ExportMemoryWin32HandleInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ExportMemoryWin32HandleInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_fragment_coverage_to_color.hs b/src/Vulkan/Extensions/VK_NV_fragment_coverage_to_color.hs
--- a/src/Vulkan/Extensions/VK_NV_fragment_coverage_to_color.hs
+++ b/src/Vulkan/Extensions/VK_NV_fragment_coverage_to_color.hs
@@ -100,7 +100,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -204,7 +204,7 @@
 deriving instance Show PipelineCoverageToColorStateCreateInfoNV
 
 instance ToCStruct PipelineCoverageToColorStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCoverageToColorStateCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_fragment_shader_barycentric.hs b/src/Vulkan/Extensions/VK_NV_fragment_shader_barycentric.hs
--- a/src/Vulkan/Extensions/VK_NV_fragment_shader_barycentric.hs
+++ b/src/Vulkan/Extensions/VK_NV_fragment_shader_barycentric.hs
@@ -187,7 +187,7 @@
                                                             , pattern NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME
                                                             ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -253,7 +253,7 @@
 deriving instance Show PhysicalDeviceFragmentShaderBarycentricFeaturesNV
 
 instance ToCStruct PhysicalDeviceFragmentShaderBarycentricFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShaderBarycentricFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_fragment_shading_rate_enums.hs b/src/Vulkan/Extensions/VK_NV_fragment_shading_rate_enums.hs
--- a/src/Vulkan/Extensions/VK_NV_fragment_shading_rate_enums.hs
+++ b/src/Vulkan/Extensions/VK_NV_fragment_shading_rate_enums.hs
@@ -209,7 +209,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -393,7 +393,7 @@
   lift $ unless (vkCmdSetFragmentShadingRateEnumNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetFragmentShadingRateEnumNV is null" Nothing Nothing
   let vkCmdSetFragmentShadingRateEnumNV' = mkVkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNVPtr
-  pCombinerOps <- ContT $ allocaBytesAligned @(FixedArray 2 FragmentShadingRateCombinerOpKHR) 8 4
+  pCombinerOps <- ContT $ allocaBytes @(FixedArray 2 FragmentShadingRateCombinerOpKHR) 8
   let pCombinerOps' = lowerArrayPtr pCombinerOps
   lift $ case (combinerOps) of
     (e0, e1) -> do
@@ -451,7 +451,7 @@
 deriving instance Show PhysicalDeviceFragmentShadingRateEnumsFeaturesNV
 
 instance ToCStruct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShadingRateEnumsFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -532,7 +532,7 @@
 deriving instance Show PhysicalDeviceFragmentShadingRateEnumsPropertiesNV
 
 instance ToCStruct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceFragmentShadingRateEnumsPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -632,7 +632,7 @@
 deriving instance Show PipelineFragmentShadingRateEnumStateCreateInfoNV
 
 instance ToCStruct PipelineFragmentShadingRateEnumStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineFragmentShadingRateEnumStateCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_framebuffer_mixed_samples.hs b/src/Vulkan/Extensions/VK_NV_framebuffer_mixed_samples.hs
--- a/src/Vulkan/Extensions/VK_NV_framebuffer_mixed_samples.hs
+++ b/src/Vulkan/Extensions/VK_NV_framebuffer_mixed_samples.hs
@@ -137,7 +137,7 @@
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -285,7 +285,7 @@
 deriving instance Show PipelineCoverageModulationStateCreateInfoNV
 
 instance ToCStruct PipelineCoverageModulationStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineCoverageModulationStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -303,7 +303,7 @@
     pCoverageModulationTable'' <- if Data.Vector.null (coverageModulationTable)
       then pure nullPtr
       else do
-        pPCoverageModulationTable <- ContT $ allocaBytesAligned @CFloat (((Data.Vector.length (coverageModulationTable))) * 4) 4
+        pPCoverageModulationTable <- ContT $ allocaBytes @CFloat (((Data.Vector.length (coverageModulationTable))) * 4)
         lift $ Data.Vector.imapM_ (\i e -> poke (pPCoverageModulationTable `plusPtr` (4 * (i)) :: Ptr CFloat) (CFloat (e))) ((coverageModulationTable))
         pure $ pPCoverageModulationTable
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr CFloat))) pCoverageModulationTable''
diff --git a/src/Vulkan/Extensions/VK_NV_inherited_viewport_scissor.hs b/src/Vulkan/Extensions/VK_NV_inherited_viewport_scissor.hs
--- a/src/Vulkan/Extensions/VK_NV_inherited_viewport_scissor.hs
+++ b/src/Vulkan/Extensions/VK_NV_inherited_viewport_scissor.hs
@@ -158,7 +158,7 @@
                                                            , pattern NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -230,7 +230,7 @@
 deriving instance Show PhysicalDeviceInheritedViewportScissorFeaturesNV
 
 instance ToCStruct PhysicalDeviceInheritedViewportScissorFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceInheritedViewportScissorFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -407,7 +407,7 @@
 deriving instance Show CommandBufferInheritanceViewportScissorInfoNV
 
 instance ToCStruct CommandBufferInheritanceViewportScissorInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferInheritanceViewportScissorInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_mesh_shader.hs b/src/Vulkan/Extensions/VK_NV_mesh_shader.hs
--- a/src/Vulkan/Extensions/VK_NV_mesh_shader.hs
+++ b/src/Vulkan/Extensions/VK_NV_mesh_shader.hs
@@ -271,7 +271,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -2206,7 +2206,7 @@
 deriving instance Show PhysicalDeviceMeshShaderFeaturesNV
 
 instance ToCStruct PhysicalDeviceMeshShaderFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMeshShaderFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2326,7 +2326,7 @@
 deriving instance Show PhysicalDeviceMeshShaderPropertiesNV
 
 instance ToCStruct PhysicalDeviceMeshShaderPropertiesNV where
-  withCStruct x f = allocaBytesAligned 88 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 88 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMeshShaderPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2462,7 +2462,7 @@
 deriving instance Show DrawMeshTasksIndirectCommandNV
 
 instance ToCStruct DrawMeshTasksIndirectCommandNV where
-  withCStruct x f = allocaBytesAligned 8 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 8 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p DrawMeshTasksIndirectCommandNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (taskCount)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (firstTask)
diff --git a/src/Vulkan/Extensions/VK_NV_ray_tracing.hs b/src/Vulkan/Extensions/VK_NV_ray_tracing.hs
--- a/src/Vulkan/Extensions/VK_NV_ray_tracing.hs
+++ b/src/Vulkan/Extensions/VK_NV_ray_tracing.hs
@@ -576,7 +576,7 @@
 import Control.Monad.IO.Class (liftIO)
 import Data.Foldable (traverse_)
 import Data.Typeable (eqT)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -1114,7 +1114,7 @@
   lift $ unless (vkBindAccelerationStructureMemoryNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkBindAccelerationStructureMemoryNV is null" Nothing Nothing
   let vkBindAccelerationStructureMemoryNV' = mkVkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNVPtr
-  pPBindInfos <- ContT $ allocaBytesAligned @BindAccelerationStructureMemoryInfoNV ((Data.Vector.length (bindInfos)) * 56) 8
+  pPBindInfos <- ContT $ allocaBytes @BindAccelerationStructureMemoryInfoNV ((Data.Vector.length (bindInfos)) * 56)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPBindInfos `plusPtr` (56 * (i)) :: Ptr BindAccelerationStructureMemoryInfoNV) (e) . ($ ())) (bindInfos)
   r <- lift $ traceAroundEvent "vkBindAccelerationStructureMemoryNV" (vkBindAccelerationStructureMemoryNV' (deviceHandle (device)) ((fromIntegral (Data.Vector.length $ (bindInfos)) :: Word32)) (pPBindInfos))
   lift $ when (r < SUCCESS) (throwIO (VulkanException r))
@@ -1375,7 +1375,7 @@
   lift $ unless (vkCmdWriteAccelerationStructuresPropertiesNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdWriteAccelerationStructuresPropertiesNV is null" Nothing Nothing
   let vkCmdWriteAccelerationStructuresPropertiesNV' = mkVkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNVPtr
-  pPAccelerationStructures <- ContT $ allocaBytesAligned @AccelerationStructureNV ((Data.Vector.length (accelerationStructures)) * 8) 8
+  pPAccelerationStructures <- ContT $ allocaBytes @AccelerationStructureNV ((Data.Vector.length (accelerationStructures)) * 8)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPAccelerationStructures `plusPtr` (8 * (i)) :: Ptr AccelerationStructureNV) (e)) (accelerationStructures)
   lift $ traceAroundEvent "vkCmdWriteAccelerationStructuresPropertiesNV" (vkCmdWriteAccelerationStructuresPropertiesNV' (commandBufferHandle (commandBuffer)) ((fromIntegral (Data.Vector.length $ (accelerationStructures)) :: Word32)) (pPAccelerationStructures) (queryType) (queryPool) (firstQuery))
   pure $ ()
@@ -2237,7 +2237,7 @@
   lift $ unless (vkCreateRayTracingPipelinesNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCreateRayTracingPipelinesNV is null" Nothing Nothing
   let vkCreateRayTracingPipelinesNV' = mkVkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNVPtr
-  pPCreateInfos <- ContT $ allocaBytesAligned @(RayTracingPipelineCreateInfoNV _) ((Data.Vector.length (createInfos)) * 80) 8
+  pPCreateInfos <- ContT $ allocaBytes @(RayTracingPipelineCreateInfoNV _) ((Data.Vector.length (createInfos)) * 80)
   Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPCreateInfos `plusPtr` (80 * (i)) :: Ptr (RayTracingPipelineCreateInfoNV _))) (e) . ($ ())) (createInfos)
   pAllocator <- case (allocator) of
     Nothing -> pure nullPtr
@@ -2498,7 +2498,7 @@
 deriving instance Show RayTracingShaderGroupCreateInfoNV
 
 instance ToCStruct RayTracingShaderGroupCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RayTracingShaderGroupCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -2757,18 +2757,18 @@
     | otherwise = Nothing
 
 instance (Extendss RayTracingPipelineCreateInfoNV es, PokeChain es) => ToCStruct (RayTracingPipelineCreateInfoNV es) where
-  withCStruct x f = allocaBytesAligned 80 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 80 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RayTracingPipelineCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV)
     pNext'' <- fmap castPtr . ContT $ withChain (next)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) pNext''
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineCreateFlags)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (stages)) :: Word32))
-    pPStages' <- ContT $ allocaBytesAligned @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48) 8
+    pPStages' <- ContT $ allocaBytes @(PipelineShaderStageCreateInfo _) ((Data.Vector.length (stages)) * 48)
     Data.Vector.imapM_ (\i e -> ContT $ pokeSomeCStruct (forgetExtensions (pPStages' `plusPtr` (48 * (i)) :: Ptr (PipelineShaderStageCreateInfo _))) (e) . ($ ())) (stages)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr (PipelineShaderStageCreateInfo _)))) (pPStages')
     lift $ poke ((p `plusPtr` 32 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (groups)) :: Word32))
-    pPGroups' <- ContT $ allocaBytesAligned @RayTracingShaderGroupCreateInfoNV ((Data.Vector.length (groups)) * 40) 8
+    pPGroups' <- ContT $ allocaBytes @RayTracingShaderGroupCreateInfoNV ((Data.Vector.length (groups)) * 40)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPGroups' `plusPtr` (40 * (i)) :: Ptr RayTracingShaderGroupCreateInfoNV) (e)) (groups)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr RayTracingShaderGroupCreateInfoNV))) (pPGroups')
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) (maxRecursionDepth)
@@ -2949,7 +2949,7 @@
 deriving instance Show GeometryTrianglesNV
 
 instance ToCStruct GeometryTrianglesNV where
-  withCStruct x f = allocaBytesAligned 96 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 96 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeometryTrianglesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3069,7 +3069,7 @@
 deriving instance Show GeometryAABBNV
 
 instance ToCStruct GeometryAABBNV where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeometryAABBNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GEOMETRY_AABB_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3140,7 +3140,7 @@
 deriving instance Show GeometryDataNV
 
 instance ToCStruct GeometryDataNV where
-  withCStruct x f = allocaBytesAligned 136 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 136 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeometryDataNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr GeometryTrianglesNV)) (triangles)
     poke ((p `plusPtr` 96 :: Ptr GeometryAABBNV)) (aabbs)
@@ -3216,7 +3216,7 @@
 deriving instance Show GeometryNV
 
 instance ToCStruct GeometryNV where
-  withCStruct x f = allocaBytesAligned 168 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 168 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p GeometryNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_GEOMETRY_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3354,7 +3354,7 @@
 deriving instance Show AccelerationStructureInfoNV
 
 instance ToCStruct AccelerationStructureInfoNV where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3362,7 +3362,7 @@
     lift $ poke ((p `plusPtr` 20 :: Ptr BuildAccelerationStructureFlagsNV)) (flags)
     lift $ poke ((p `plusPtr` 24 :: Ptr Word32)) (instanceCount)
     lift $ poke ((p `plusPtr` 28 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (geometries)) :: Word32))
-    pPGeometries' <- ContT $ allocaBytesAligned @GeometryNV ((Data.Vector.length (geometries)) * 168) 8
+    pPGeometries' <- ContT $ allocaBytes @GeometryNV ((Data.Vector.length (geometries)) * 168)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPGeometries' `plusPtr` (168 * (i)) :: Ptr GeometryNV) (e)) (geometries)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr GeometryNV))) (pPGeometries')
     lift $ f
@@ -3436,7 +3436,7 @@
 deriving instance Show AccelerationStructureCreateInfoNV
 
 instance ToCStruct AccelerationStructureCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3557,7 +3557,7 @@
 deriving instance Show BindAccelerationStructureMemoryInfoNV
 
 instance ToCStruct BindAccelerationStructureMemoryInfoNV where
-  withCStruct x f = allocaBytesAligned 56 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 56 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p BindAccelerationStructureMemoryInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3565,7 +3565,7 @@
     lift $ poke ((p `plusPtr` 24 :: Ptr DeviceMemory)) (memory)
     lift $ poke ((p `plusPtr` 32 :: Ptr DeviceSize)) (memoryOffset)
     lift $ poke ((p `plusPtr` 40 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (deviceIndices)) :: Word32))
-    pPDeviceIndices' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (deviceIndices)) * 4) 4
+    pPDeviceIndices' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (deviceIndices)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDeviceIndices' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (deviceIndices)
     lift $ poke ((p `plusPtr` 48 :: Ptr (Ptr Word32))) (pPDeviceIndices')
     lift $ f
@@ -3649,12 +3649,12 @@
 deriving instance Show WriteDescriptorSetAccelerationStructureNV
 
 instance ToCStruct WriteDescriptorSetAccelerationStructureNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p WriteDescriptorSetAccelerationStructureNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (accelerationStructures)) :: Word32))
-    pPAccelerationStructures' <- ContT $ allocaBytesAligned @AccelerationStructureNV ((Data.Vector.length (accelerationStructures)) * 8) 8
+    pPAccelerationStructures' <- ContT $ allocaBytes @AccelerationStructureNV ((Data.Vector.length (accelerationStructures)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAccelerationStructures' `plusPtr` (8 * (i)) :: Ptr AccelerationStructureNV) (e)) (accelerationStructures)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr AccelerationStructureNV))) (pPAccelerationStructures')
     lift $ f
@@ -3719,7 +3719,7 @@
 deriving instance Show AccelerationStructureMemoryRequirementsInfoNV
 
 instance ToCStruct AccelerationStructureMemoryRequirementsInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureMemoryRequirementsInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -3810,7 +3810,7 @@
 deriving instance Show PhysicalDeviceRayTracingPropertiesNV
 
 instance ToCStruct PhysicalDeviceRayTracingPropertiesNV where
-  withCStruct x f = allocaBytesAligned 64 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRayTracingPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_ray_tracing_motion_blur.hs b/src/Vulkan/Extensions/VK_NV_ray_tracing_motion_blur.hs
--- a/src/Vulkan/Extensions/VK_NV_ray_tracing_motion_blur.hs
+++ b/src/Vulkan/Extensions/VK_NV_ray_tracing_motion_blur.hs
@@ -215,7 +215,7 @@
 import Data.Bits ((.|.))
 import Data.Bits (shiftL)
 import Data.Bits (shiftR)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Ptr (castPtr)
@@ -322,7 +322,7 @@
 deriving instance Show PhysicalDeviceRayTracingMotionBlurFeaturesNV
 
 instance ToCStruct PhysicalDeviceRayTracingMotionBlurFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRayTracingMotionBlurFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -388,7 +388,7 @@
 deriving instance Show AccelerationStructureGeometryMotionTrianglesDataNV
 
 instance ToCStruct AccelerationStructureGeometryMotionTrianglesDataNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureGeometryMotionTrianglesDataNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -433,7 +433,7 @@
 deriving instance Show AccelerationStructureMotionInfoNV
 
 instance ToCStruct AccelerationStructureMotionInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureMotionInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -558,7 +558,7 @@
 deriving instance Show SRTDataNV
 
 instance ToCStruct SRTDataNV where
-  withCStruct x f = allocaBytesAligned 64 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 64 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p SRTDataNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr CFloat)) (CFloat (sx))
     poke ((p `plusPtr` 4 :: Ptr CFloat)) (CFloat (a))
@@ -733,7 +733,7 @@
 deriving instance Show AccelerationStructureSRTMotionInstanceNV
 
 instance ToCStruct AccelerationStructureSRTMotionInstanceNV where
-  withCStruct x f = allocaBytesAligned 144 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 144 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureSRTMotionInstanceNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr SRTDataNV)) (transformT0)
     poke ((p `plusPtr` 64 :: Ptr SRTDataNV)) (transformT1)
@@ -874,7 +874,7 @@
 deriving instance Show AccelerationStructureMatrixMotionInstanceNV
 
 instance ToCStruct AccelerationStructureMatrixMotionInstanceNV where
-  withCStruct x f = allocaBytesAligned 112 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 112 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureMatrixMotionInstanceNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr TransformMatrixKHR)) (transformT0)
     poke ((p `plusPtr` 48 :: Ptr TransformMatrixKHR)) (transformT1)
@@ -985,7 +985,7 @@
 deriving instance Show AccelerationStructureMotionInstanceNV
 
 instance ToCStruct AccelerationStructureMotionInstanceNV where
-  withCStruct x f = allocaBytesAligned 152 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 152 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p AccelerationStructureMotionInstanceNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr AccelerationStructureMotionInstanceTypeNV)) (type')
     lift $ poke ((p `plusPtr` 4 :: Ptr AccelerationStructureMotionInstanceFlagsNV)) (flags)
@@ -1012,7 +1012,7 @@
   deriving (Show)
 
 instance ToCStruct AccelerationStructureMotionInstanceDataNV where
-  withCStruct x f = allocaBytesAligned 144 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 144 $ \p -> pokeCStruct p x (f p)
   pokeCStruct :: Ptr AccelerationStructureMotionInstanceDataNV -> AccelerationStructureMotionInstanceDataNV -> IO a -> IO a
   pokeCStruct p = (. const) . runContT .  \case
     StaticInstance v -> lift $ poke (castPtr @_ @AccelerationStructureInstanceKHR p) (v)
diff --git a/src/Vulkan/Extensions/VK_NV_representative_fragment_test.hs b/src/Vulkan/Extensions/VK_NV_representative_fragment_test.hs
--- a/src/Vulkan/Extensions/VK_NV_representative_fragment_test.hs
+++ b/src/Vulkan/Extensions/VK_NV_representative_fragment_test.hs
@@ -168,7 +168,7 @@
                                                              , pattern NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME
                                                              ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -231,7 +231,7 @@
 deriving instance Show PhysicalDeviceRepresentativeFragmentTestFeaturesNV
 
 instance ToCStruct PhysicalDeviceRepresentativeFragmentTestFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceRepresentativeFragmentTestFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -293,7 +293,7 @@
 deriving instance Show PipelineRepresentativeFragmentTestStateCreateInfoNV
 
 instance ToCStruct PipelineRepresentativeFragmentTestStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineRepresentativeFragmentTestStateCreateInfoNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_scissor_exclusive.hs b/src/Vulkan/Extensions/VK_NV_scissor_exclusive.hs
--- a/src/Vulkan/Extensions/VK_NV_scissor_exclusive.hs
+++ b/src/Vulkan/Extensions/VK_NV_scissor_exclusive.hs
@@ -133,7 +133,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -295,7 +295,7 @@
   lift $ unless (vkCmdSetExclusiveScissorNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetExclusiveScissorNV is null" Nothing Nothing
   let vkCmdSetExclusiveScissorNV' = mkVkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNVPtr
-  pPExclusiveScissors <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (exclusiveScissors)) * 16) 4
+  pPExclusiveScissors <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (exclusiveScissors)) * 16)
   lift $ Data.Vector.imapM_ (\i e -> poke (pPExclusiveScissors `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (exclusiveScissors)
   lift $ traceAroundEvent "vkCmdSetExclusiveScissorNV" (vkCmdSetExclusiveScissorNV' (commandBufferHandle (commandBuffer)) (firstExclusiveScissor) ((fromIntegral (Data.Vector.length $ (exclusiveScissors)) :: Word32)) (pPExclusiveScissors))
   pure $ ()
@@ -341,7 +341,7 @@
 deriving instance Show PhysicalDeviceExclusiveScissorFeaturesNV
 
 instance ToCStruct PhysicalDeviceExclusiveScissorFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceExclusiveScissorFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -426,12 +426,12 @@
 deriving instance Show PipelineViewportExclusiveScissorStateCreateInfoNV
 
 instance ToCStruct PipelineViewportExclusiveScissorStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportExclusiveScissorStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (exclusiveScissors)) :: Word32))
-    pPExclusiveScissors' <- ContT $ allocaBytesAligned @Rect2D ((Data.Vector.length (exclusiveScissors)) * 16) 4
+    pPExclusiveScissors' <- ContT $ allocaBytes @Rect2D ((Data.Vector.length (exclusiveScissors)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPExclusiveScissors' `plusPtr` (16 * (i)) :: Ptr Rect2D) (e)) (exclusiveScissors)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr Rect2D))) (pPExclusiveScissors')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_NV_shader_image_footprint.hs b/src/Vulkan/Extensions/VK_NV_shader_image_footprint.hs
--- a/src/Vulkan/Extensions/VK_NV_shader_image_footprint.hs
+++ b/src/Vulkan/Extensions/VK_NV_shader_image_footprint.hs
@@ -273,7 +273,7 @@
                                                        , pattern NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME
                                                        ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -336,7 +336,7 @@
 deriving instance Show PhysicalDeviceShaderImageFootprintFeaturesNV
 
 instance ToCStruct PhysicalDeviceShaderImageFootprintFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderImageFootprintFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_shader_sm_builtins.hs b/src/Vulkan/Extensions/VK_NV_shader_sm_builtins.hs
--- a/src/Vulkan/Extensions/VK_NV_shader_sm_builtins.hs
+++ b/src/Vulkan/Extensions/VK_NV_shader_sm_builtins.hs
@@ -138,7 +138,7 @@
                                                    , pattern NV_SHADER_SM_BUILTINS_EXTENSION_NAME
                                                    ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -195,7 +195,7 @@
 deriving instance Show PhysicalDeviceShaderSMBuiltinsPropertiesNV
 
 instance ToCStruct PhysicalDeviceShaderSMBuiltinsPropertiesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderSMBuiltinsPropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -266,7 +266,7 @@
 deriving instance Show PhysicalDeviceShaderSMBuiltinsFeaturesNV
 
 instance ToCStruct PhysicalDeviceShaderSMBuiltinsFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShaderSMBuiltinsFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_NV_shading_rate_image.hs b/src/Vulkan/Extensions/VK_NV_shading_rate_image.hs
--- a/src/Vulkan/Extensions/VK_NV_shading_rate_image.hs
+++ b/src/Vulkan/Extensions/VK_NV_shading_rate_image.hs
@@ -318,7 +318,7 @@
 import Vulkan.Internal.Utils (traceAroundEvent)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import GHC.Ptr (nullFunPtr)
 import Foreign.Ptr (nullPtr)
@@ -589,7 +589,7 @@
   lift $ unless (vkCmdSetViewportShadingRatePaletteNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetViewportShadingRatePaletteNV is null" Nothing Nothing
   let vkCmdSetViewportShadingRatePaletteNV' = mkVkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNVPtr
-  pPShadingRatePalettes <- ContT $ allocaBytesAligned @ShadingRatePaletteNV ((Data.Vector.length (shadingRatePalettes)) * 16) 8
+  pPShadingRatePalettes <- ContT $ allocaBytes @ShadingRatePaletteNV ((Data.Vector.length (shadingRatePalettes)) * 16)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPShadingRatePalettes `plusPtr` (16 * (i)) :: Ptr ShadingRatePaletteNV) (e) . ($ ())) (shadingRatePalettes)
   lift $ traceAroundEvent "vkCmdSetViewportShadingRatePaletteNV" (vkCmdSetViewportShadingRatePaletteNV' (commandBufferHandle (commandBuffer)) (firstViewport) ((fromIntegral (Data.Vector.length $ (shadingRatePalettes)) :: Word32)) (pPShadingRatePalettes))
   pure $ ()
@@ -685,7 +685,7 @@
   lift $ unless (vkCmdSetCoarseSampleOrderNVPtr /= nullFunPtr) $
     throwIO $ IOError Nothing InvalidArgument "" "The function pointer for vkCmdSetCoarseSampleOrderNV is null" Nothing Nothing
   let vkCmdSetCoarseSampleOrderNV' = mkVkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNVPtr
-  pPCustomSampleOrders <- ContT $ allocaBytesAligned @CoarseSampleOrderCustomNV ((Data.Vector.length (customSampleOrders)) * 24) 8
+  pPCustomSampleOrders <- ContT $ allocaBytes @CoarseSampleOrderCustomNV ((Data.Vector.length (customSampleOrders)) * 24)
   Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPCustomSampleOrders `plusPtr` (24 * (i)) :: Ptr CoarseSampleOrderCustomNV) (e) . ($ ())) (customSampleOrders)
   lift $ traceAroundEvent "vkCmdSetCoarseSampleOrderNV" (vkCmdSetCoarseSampleOrderNV' (commandBufferHandle (commandBuffer)) (sampleOrderType) ((fromIntegral (Data.Vector.length $ (customSampleOrders)) :: Word32)) (pPCustomSampleOrders))
   pure $ ()
@@ -732,10 +732,10 @@
 deriving instance Show ShadingRatePaletteNV
 
 instance ToCStruct ShadingRatePaletteNV where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ShadingRatePaletteNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (shadingRatePaletteEntries)) :: Word32))
-    pPShadingRatePaletteEntries' <- ContT $ allocaBytesAligned @ShadingRatePaletteEntryNV ((Data.Vector.length (shadingRatePaletteEntries)) * 4) 4
+    pPShadingRatePaletteEntries' <- ContT $ allocaBytes @ShadingRatePaletteEntryNV ((Data.Vector.length (shadingRatePaletteEntries)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPShadingRatePaletteEntries' `plusPtr` (4 * (i)) :: Ptr ShadingRatePaletteEntryNV) (e)) (shadingRatePaletteEntries)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ShadingRatePaletteEntryNV))) (pPShadingRatePaletteEntries')
     lift $ f
@@ -809,13 +809,13 @@
 deriving instance Show PipelineViewportShadingRateImageStateCreateInfoNV
 
 instance ToCStruct PipelineViewportShadingRateImageStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportShadingRateImageStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Bool32)) (boolToBool32 (shadingRateImageEnable))
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (shadingRatePalettes)) :: Word32))
-    pPShadingRatePalettes' <- ContT $ allocaBytesAligned @ShadingRatePaletteNV ((Data.Vector.length (shadingRatePalettes)) * 16) 8
+    pPShadingRatePalettes' <- ContT $ allocaBytes @ShadingRatePaletteNV ((Data.Vector.length (shadingRatePalettes)) * 16)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPShadingRatePalettes' `plusPtr` (16 * (i)) :: Ptr ShadingRatePaletteNV) (e) . ($ ())) (shadingRatePalettes)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ShadingRatePaletteNV))) (pPShadingRatePalettes')
     lift $ f
@@ -889,7 +889,7 @@
 deriving instance Show PhysicalDeviceShadingRateImageFeaturesNV
 
 instance ToCStruct PhysicalDeviceShadingRateImageFeaturesNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShadingRateImageFeaturesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -971,7 +971,7 @@
 deriving instance Show PhysicalDeviceShadingRateImagePropertiesNV
 
 instance ToCStruct PhysicalDeviceShadingRateImagePropertiesNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceShadingRateImagePropertiesNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -1046,7 +1046,7 @@
 deriving instance Show CoarseSampleLocationNV
 
 instance ToCStruct CoarseSampleLocationNV where
-  withCStruct x f = allocaBytesAligned 12 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 12 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CoarseSampleLocationNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr Word32)) (pixelX)
     poke ((p `plusPtr` 4 :: Ptr Word32)) (pixelY)
@@ -1156,12 +1156,12 @@
 deriving instance Show CoarseSampleOrderCustomNV
 
 instance ToCStruct CoarseSampleOrderCustomNV where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CoarseSampleOrderCustomNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr ShadingRatePaletteEntryNV)) (shadingRate)
     lift $ poke ((p `plusPtr` 4 :: Ptr Word32)) (sampleCount)
     lift $ poke ((p `plusPtr` 8 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (sampleLocations)) :: Word32))
-    pPSampleLocations' <- ContT $ allocaBytesAligned @CoarseSampleLocationNV ((Data.Vector.length (sampleLocations)) * 12) 4
+    pPSampleLocations' <- ContT $ allocaBytes @CoarseSampleLocationNV ((Data.Vector.length (sampleLocations)) * 12)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPSampleLocations' `plusPtr` (12 * (i)) :: Ptr CoarseSampleLocationNV) (e)) (sampleLocations)
     lift $ poke ((p `plusPtr` 16 :: Ptr (Ptr CoarseSampleLocationNV))) (pPSampleLocations')
     lift $ f
@@ -1254,13 +1254,13 @@
 deriving instance Show PipelineViewportCoarseSampleOrderStateCreateInfoNV
 
 instance ToCStruct PipelineViewportCoarseSampleOrderStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportCoarseSampleOrderStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr CoarseSampleOrderTypeNV)) (sampleOrderType)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (customSampleOrders)) :: Word32))
-    pPCustomSampleOrders' <- ContT $ allocaBytesAligned @CoarseSampleOrderCustomNV ((Data.Vector.length (customSampleOrders)) * 24) 8
+    pPCustomSampleOrders' <- ContT $ allocaBytes @CoarseSampleOrderCustomNV ((Data.Vector.length (customSampleOrders)) * 24)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPCustomSampleOrders' `plusPtr` (24 * (i)) :: Ptr CoarseSampleOrderCustomNV) (e) . ($ ())) (customSampleOrders)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr CoarseSampleOrderCustomNV))) (pPCustomSampleOrders')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_NV_viewport_swizzle.hs b/src/Vulkan/Extensions/VK_NV_viewport_swizzle.hs
--- a/src/Vulkan/Extensions/VK_NV_viewport_swizzle.hs
+++ b/src/Vulkan/Extensions/VK_NV_viewport_swizzle.hs
@@ -284,7 +284,7 @@
 
 import Vulkan.Internal.Utils (enumReadPrec)
 import Vulkan.Internal.Utils (enumShowsPrec)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import GHC.Show (showString)
@@ -363,7 +363,7 @@
 deriving instance Show ViewportSwizzleNV
 
 instance ToCStruct ViewportSwizzleNV where
-  withCStruct x f = allocaBytesAligned 16 4 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ViewportSwizzleNV{..} f = do
     poke ((p `plusPtr` 0 :: Ptr ViewportCoordinateSwizzleNV)) (x)
     poke ((p `plusPtr` 4 :: Ptr ViewportCoordinateSwizzleNV)) (y)
@@ -432,13 +432,13 @@
 deriving instance Show PipelineViewportSwizzleStateCreateInfoNV
 
 instance ToCStruct PipelineViewportSwizzleStateCreateInfoNV where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PipelineViewportSwizzleStateCreateInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr PipelineViewportSwizzleStateCreateFlagsNV)) (flags)
     lift $ poke ((p `plusPtr` 20 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (viewportSwizzles)) :: Word32))
-    pPViewportSwizzles' <- ContT $ allocaBytesAligned @ViewportSwizzleNV ((Data.Vector.length (viewportSwizzles)) * 16) 4
+    pPViewportSwizzles' <- ContT $ allocaBytes @ViewportSwizzleNV ((Data.Vector.length (viewportSwizzles)) * 16)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPViewportSwizzles' `plusPtr` (16 * (i)) :: Ptr ViewportSwizzleNV) (e)) (viewportSwizzles)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr ViewportSwizzleNV))) (pPViewportSwizzles')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_NV_win32_keyed_mutex.hs b/src/Vulkan/Extensions/VK_NV_win32_keyed_mutex.hs
--- a/src/Vulkan/Extensions/VK_NV_win32_keyed_mutex.hs
+++ b/src/Vulkan/Extensions/VK_NV_win32_keyed_mutex.hs
@@ -238,7 +238,7 @@
                                                   ) where
 
 import Control.Monad (unless)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import GHC.IO (throwIO)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
@@ -339,7 +339,7 @@
 deriving instance Show Win32KeyedMutexAcquireReleaseInfoNV
 
 instance ToCStruct Win32KeyedMutexAcquireReleaseInfoNV where
-  withCStruct x f = allocaBytesAligned 72 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 72 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p Win32KeyedMutexAcquireReleaseInfoNV{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -349,23 +349,23 @@
     lift $ unless ((Data.Vector.length $ (acquireTimeoutMilliseconds)) == pAcquireSyncsLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pAcquireTimeoutMilliseconds and pAcquireSyncs must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral pAcquireSyncsLength :: Word32))
-    pPAcquireSyncs' <- ContT $ allocaBytesAligned @DeviceMemory ((Data.Vector.length (acquireSyncs)) * 8) 8
+    pPAcquireSyncs' <- ContT $ allocaBytes @DeviceMemory ((Data.Vector.length (acquireSyncs)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireSyncs' `plusPtr` (8 * (i)) :: Ptr DeviceMemory) (e)) (acquireSyncs)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr DeviceMemory))) (pPAcquireSyncs')
-    pPAcquireKeys' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (acquireKeys)) * 8) 8
+    pPAcquireKeys' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (acquireKeys)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireKeys' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (acquireKeys)
     lift $ poke ((p `plusPtr` 32 :: Ptr (Ptr Word64))) (pPAcquireKeys')
-    pPAcquireTimeoutMilliseconds' <- ContT $ allocaBytesAligned @Word32 ((Data.Vector.length (acquireTimeoutMilliseconds)) * 4) 4
+    pPAcquireTimeoutMilliseconds' <- ContT $ allocaBytes @Word32 ((Data.Vector.length (acquireTimeoutMilliseconds)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPAcquireTimeoutMilliseconds' `plusPtr` (4 * (i)) :: Ptr Word32) (e)) (acquireTimeoutMilliseconds)
     lift $ poke ((p `plusPtr` 40 :: Ptr (Ptr Word32))) (pPAcquireTimeoutMilliseconds')
     let pReleaseSyncsLength = Data.Vector.length $ (releaseSyncs)
     lift $ unless ((Data.Vector.length $ (releaseKeys)) == pReleaseSyncsLength) $
       throwIO $ IOError Nothing InvalidArgument "" "pReleaseKeys and pReleaseSyncs must have the same length" Nothing Nothing
     lift $ poke ((p `plusPtr` 48 :: Ptr Word32)) ((fromIntegral pReleaseSyncsLength :: Word32))
-    pPReleaseSyncs' <- ContT $ allocaBytesAligned @DeviceMemory ((Data.Vector.length (releaseSyncs)) * 8) 8
+    pPReleaseSyncs' <- ContT $ allocaBytes @DeviceMemory ((Data.Vector.length (releaseSyncs)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPReleaseSyncs' `plusPtr` (8 * (i)) :: Ptr DeviceMemory) (e)) (releaseSyncs)
     lift $ poke ((p `plusPtr` 56 :: Ptr (Ptr DeviceMemory))) (pPReleaseSyncs')
-    pPReleaseKeys' <- ContT $ allocaBytesAligned @Word64 ((Data.Vector.length (releaseKeys)) * 8) 8
+    pPReleaseKeys' <- ContT $ allocaBytes @Word64 ((Data.Vector.length (releaseKeys)) * 8)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPReleaseKeys' `plusPtr` (8 * (i)) :: Ptr Word64) (e)) (releaseKeys)
     lift $ poke ((p `plusPtr` 64 :: Ptr (Ptr Word64))) (pPReleaseKeys')
     lift $ f
diff --git a/src/Vulkan/Extensions/VK_QCOM_render_pass_transform.hs b/src/Vulkan/Extensions/VK_QCOM_render_pass_transform.hs
--- a/src/Vulkan/Extensions/VK_QCOM_render_pass_transform.hs
+++ b/src/Vulkan/Extensions/VK_QCOM_render_pass_transform.hs
@@ -262,7 +262,7 @@
                                                         , SurfaceTransformFlagsKHR
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -326,7 +326,7 @@
 deriving instance Show RenderPassTransformBeginInfoQCOM
 
 instance ToCStruct RenderPassTransformBeginInfoQCOM where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p RenderPassTransformBeginInfoQCOM{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -400,7 +400,7 @@
 deriving instance Show CommandBufferInheritanceRenderPassTransformInfoQCOM
 
 instance ToCStruct CommandBufferInheritanceRenderPassTransformInfoQCOM where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CommandBufferInheritanceRenderPassTransformInfoQCOM{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_QCOM_rotated_copy_commands.hs b/src/Vulkan/Extensions/VK_QCOM_rotated_copy_commands.hs
--- a/src/Vulkan/Extensions/VK_QCOM_rotated_copy_commands.hs
+++ b/src/Vulkan/Extensions/VK_QCOM_rotated_copy_commands.hs
@@ -128,7 +128,7 @@
                                                         , SurfaceTransformFlagsKHR
                                                         ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Vulkan.CStruct (FromCStruct)
@@ -179,7 +179,7 @@
 deriving instance Show CopyCommandTransformInfoQCOM
 
 instance ToCStruct CopyCommandTransformInfoQCOM where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p CopyCommandTransformInfoQCOM{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_QNX_screen_surface.hs b/src/Vulkan/Extensions/VK_QNX_screen_surface.hs
--- a/src/Vulkan/Extensions/VK_QNX_screen_surface.hs
+++ b/src/Vulkan/Extensions/VK_QNX_screen_surface.hs
@@ -110,7 +110,7 @@
 import Control.Exception.Base (bracket)
 import Control.Monad (unless)
 import Control.Monad.IO.Class (liftIO)
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Marshal.Alloc (callocBytes)
 import Foreign.Marshal.Alloc (free)
 import GHC.Base (when)
@@ -326,7 +326,7 @@
 deriving instance Show ScreenSurfaceCreateInfoQNX
 
 instance ToCStruct ScreenSurfaceCreateInfoQNX where
-  withCStruct x f = allocaBytesAligned 40 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 40 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p ScreenSurfaceCreateInfoQNX{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
diff --git a/src/Vulkan/Extensions/VK_VALVE_mutable_descriptor_type.hs b/src/Vulkan/Extensions/VK_VALVE_mutable_descriptor_type.hs
--- a/src/Vulkan/Extensions/VK_VALVE_mutable_descriptor_type.hs
+++ b/src/Vulkan/Extensions/VK_VALVE_mutable_descriptor_type.hs
@@ -143,7 +143,7 @@
                                                            , pattern VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME
                                                            ) where
 
-import Foreign.Marshal.Alloc (allocaBytesAligned)
+import Foreign.Marshal.Alloc (allocaBytes)
 import Foreign.Ptr (nullPtr)
 import Foreign.Ptr (plusPtr)
 import Control.Monad.Trans.Class (lift)
@@ -266,7 +266,7 @@
 deriving instance Show PhysicalDeviceMutableDescriptorTypeFeaturesVALVE
 
 instance ToCStruct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE where
-  withCStruct x f = allocaBytesAligned 24 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 24 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p PhysicalDeviceMutableDescriptorTypeFeaturesVALVE{..} f = do
     poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE)
     poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
@@ -360,10 +360,10 @@
 deriving instance Show MutableDescriptorTypeListVALVE
 
 instance ToCStruct MutableDescriptorTypeListVALVE where
-  withCStruct x f = allocaBytesAligned 16 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 16 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MutableDescriptorTypeListVALVE{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (descriptorTypes)) :: Word32))
-    pPDescriptorTypes' <- ContT $ allocaBytesAligned @DescriptorType ((Data.Vector.length (descriptorTypes)) * 4) 4
+    pPDescriptorTypes' <- ContT $ allocaBytes @DescriptorType ((Data.Vector.length (descriptorTypes)) * 4)
     lift $ Data.Vector.imapM_ (\i e -> poke (pPDescriptorTypes' `plusPtr` (4 * (i)) :: Ptr DescriptorType) (e)) (descriptorTypes)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr DescriptorType))) (pPDescriptorTypes')
     lift $ f
@@ -424,12 +424,12 @@
 deriving instance Show MutableDescriptorTypeCreateInfoVALVE
 
 instance ToCStruct MutableDescriptorTypeCreateInfoVALVE where
-  withCStruct x f = allocaBytesAligned 32 8 $ \p -> pokeCStruct p x (f p)
+  withCStruct x f = allocaBytes 32 $ \p -> pokeCStruct p x (f p)
   pokeCStruct p MutableDescriptorTypeCreateInfoVALVE{..} f = evalContT $ do
     lift $ poke ((p `plusPtr` 0 :: Ptr StructureType)) (STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE)
     lift $ poke ((p `plusPtr` 8 :: Ptr (Ptr ()))) (nullPtr)
     lift $ poke ((p `plusPtr` 16 :: Ptr Word32)) ((fromIntegral (Data.Vector.length $ (mutableDescriptorTypeLists)) :: Word32))
-    pPMutableDescriptorTypeLists' <- ContT $ allocaBytesAligned @MutableDescriptorTypeListVALVE ((Data.Vector.length (mutableDescriptorTypeLists)) * 16) 8
+    pPMutableDescriptorTypeLists' <- ContT $ allocaBytes @MutableDescriptorTypeListVALVE ((Data.Vector.length (mutableDescriptorTypeLists)) * 16)
     Data.Vector.imapM_ (\i e -> ContT $ pokeCStruct (pPMutableDescriptorTypeLists' `plusPtr` (16 * (i)) :: Ptr MutableDescriptorTypeListVALVE) (e) . ($ ())) (mutableDescriptorTypeLists)
     lift $ poke ((p `plusPtr` 24 :: Ptr (Ptr MutableDescriptorTypeListVALVE))) (pPMutableDescriptorTypeLists')
     lift $ f
diff --git a/test/Driver.hs b/test/Driver.hs
new file mode 100644
--- /dev/null
+++ b/test/Driver.hs
@@ -0,0 +1,1 @@
+{-# OPTIONS_GHC -F -pgmF tasty-discover #-}
diff --git a/test/Structs.hs b/test/Structs.hs
new file mode 100644
--- /dev/null
+++ b/test/Structs.hs
@@ -0,0 +1,104 @@
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE OverloadedLists #-}
+
+module Structs where
+
+import           Data.Bits
+import qualified Language.C.Inline             as C
+import           Test.Tasty.HUnit
+import           VkCtx
+import qualified Vulkan                        as Vk
+import           Vulkan.Zero
+
+C.context (C.baseCtx <> vkCtx)
+C.include "<vulkan/vulkan.h>"
+C.include "<string.h>"
+
+unit_simple :: IO ()
+unit_simple = do
+  let e = Vk.Extent3D 2 3 5
+  Vk.withCStruct e $ \p -> do
+    [C.block| void {
+      VkExtent3D *p = $(VkExtent3D *p);
+      p->width *= 2;
+      p->height *= 2;
+      p->depth *= 2;
+    } |]
+    e' <- Vk.peekCStruct p
+    e' @?= Vk.Extent3D 4 6 10
+
+unit_bitfield :: IO ()
+unit_bitfield = do
+  let e = Vk.AccelerationStructureInstanceKHR
+        { transform                      = zero
+        , instanceCustomIndex            = 2
+        , mask                           = 3
+        , instanceShaderBindingTableRecordOffset = 5
+        , flags = Vk.GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR
+        , accelerationStructureReference = 11
+        }
+  Vk.withCStruct e $ \p -> do
+    [C.block| void {
+      VkAccelerationStructureInstanceKHR *p = $(VkAccelerationStructureInstanceKHR *p);
+      p->instanceCustomIndex *= 2;
+      p->mask *= 2;
+      p->instanceShaderBindingTableRecordOffset *= 2;
+      p->flags *= 2;
+      p->accelerationStructureReference *= 2;
+    } |]
+    e' <- Vk.peekCStruct p
+    show e' @?= show
+      (Vk.AccelerationStructureInstanceKHR
+        zero
+        4
+        6
+        10
+        (Vk.GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR `shiftL` 1)
+        22
+      )
+
+unit_strings :: IO ()
+unit_strings = do
+  let e = Vk.ApplicationInfo { applicationName    = Just "Hello"
+                             , applicationVersion = 2
+                             , engineName         = Just "World"
+                             , engineVersion      = 3
+                             , apiVersion         = Vk.MAKE_API_VERSION 5 7 11
+                             }
+  Vk.withCStruct e $ \p -> do
+    b <- [C.block| int {
+      VkApplicationInfo *p = $(VkApplicationInfo *p);
+      if(strcmp(p->pApplicationName, "Hello") || strcmp(p->pEngineName, "World")){
+        return 0;
+      }
+      p->pApplicationName = "Foo";
+      p->applicationVersion *= 2;
+      p->pEngineName = "Bar";
+      p->engineVersion *= 2;
+      p->apiVersion = VK_MAKE_VERSION(13,17,19);
+      return 1;
+    } |]
+    assertBool "Read strings on C side" (b /= 0)
+    e' <- Vk.peekCStruct p
+    show e' @?= show
+      (Vk.ApplicationInfo (Just "Foo")
+                          4
+                          (Just "Bar")
+                          6
+                          (Vk.MAKE_API_VERSION 13 17 19)
+      )
+
+unit_lists :: IO ()
+unit_lists = do
+  let e = Vk.BindBufferMemoryDeviceGroupInfo [2, 3, 5]
+  Vk.withCStruct e $ \p -> do
+    [C.block| void {
+      VkBindBufferMemoryDeviceGroupInfo *p = $(VkBindBufferMemoryDeviceGroupInfo *p);
+      for(int i = 0; i < p->deviceIndexCount; ++i){
+        ((uint32_t*)p->pDeviceIndices)[i] *= 2;
+      }
+    } |]
+    e' <- Vk.peekCStruct p
+    show e' @?= show (Vk.BindBufferMemoryDeviceGroupInfo [4, 6, 10])
diff --git a/test/VkCtx.hs b/test/VkCtx.hs
new file mode 100644
--- /dev/null
+++ b/test/VkCtx.hs
@@ -0,0 +1,25 @@
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE TemplateHaskell #-}
+
+module VkCtx (vkCtx) where
+
+import qualified Data.Map                      as Map
+import qualified Language.C.Inline             as C
+import qualified Language.C.Inline.Context     as C
+import qualified Language.C.Types              as C
+import qualified Vulkan                        as Vk
+import           Language.Haskell.TH
+
+vkCtx :: C.Context
+vkCtx = mempty { C.ctxTypesTable = Map.fromList ts }
+ where
+  ts =
+    [ (C.TypeName "VkExtent3D", [t| Vk.Extent3D |])
+    , ( C.TypeName "VkAccelerationStructureInstanceKHR"
+      , [t| Vk.AccelerationStructureInstanceKHR |]
+      )
+    , (C.TypeName "VkApplicationInfo", [t| Vk.ApplicationInfo |])
+    , ( C.TypeName "VkBindBufferMemoryDeviceGroupInfo"
+      , [t| Vk.BindBufferMemoryDeviceGroupInfo |]
+      )
+    ]
diff --git a/vulkan.cabal b/vulkan.cabal
--- a/vulkan.cabal
+++ b/vulkan.cabal
@@ -5,8 +5,9 @@
 -- see: https://github.com/sol/hpack
 
 name:           vulkan
-version:        3.11
+version:        3.11.0.2
 synopsis:       Bindings to the Vulkan graphics API.
+description:    Please see [the readme](https://github.com/expipiplus1/vulkan/#readme)
 category:       Graphics
 homepage:       https://github.com/expipiplus1/vulkan#readme
 bug-reports:    https://github.com/expipiplus1/vulkan/issues
@@ -560,4 +561,58 @@
     cpp-options: -DGENERIC_INSTANCES
   if flag(trace-calls)
     cpp-options: -DTRACE_CALLS
+  default-language: Haskell2010
+
+test-suite test
+  type: exitcode-stdio-1.0
+  main-is: Driver.hs
+  other-modules:
+      Structs
+      VkCtx
+  hs-source-dirs:
+      test
+  default-extensions:
+      AllowAmbiguousTypes
+      CPP
+      DataKinds
+      DefaultSignatures
+      DeriveAnyClass
+      DeriveGeneric
+      DerivingStrategies
+      DuplicateRecordFields
+      FlexibleContexts
+      FlexibleInstances
+      GADTs
+      GeneralizedNewtypeDeriving
+      InstanceSigs
+      LambdaCase
+      MagicHash
+      NoMonomorphismRestriction
+      OverloadedStrings
+      PartialTypeSignatures
+      PatternSynonyms
+      PolyKinds
+      QuantifiedConstraints
+      RankNTypes
+      RecordWildCards
+      RoleAnnotations
+      ScopedTypeVariables
+      StandaloneDeriving
+      Strict
+      TypeApplications
+      TypeFamilyDependencies
+      TypeOperators
+      TypeSynonymInstances
+      UndecidableInstances
+      ViewPatterns
+  build-tool-depends:
+      tasty-discover:tasty-discover
+  build-depends:
+      base
+    , containers
+    , inline-c
+    , tasty
+    , tasty-hunit
+    , template-haskell
+    , vulkan
   default-language: Haskell2010
