diff --git a/examples/async-update/main.rs b/examples/async-update/main.rs
index 265888bd7f..6a9fb044f7 100644
--- a/examples/async-update/main.rs
+++ b/examples/async-update/main.rs
@@ -51,7 +51,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, Queue,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -123,9 +123,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
@@ -151,12 +152,13 @@ fn main() -> Result<(), impl Error> {
     // For this, we need to find the queue family with the fewest queue flags set, since if the
     // queue fmaily has more flags than `TRANSFER | SPARSE_BINDING`, that means it is not dedicated
     // to transfer operations.
-    let transfer_family_index = physical_device
-        .queue_family_properties()
-        .iter()
-        .enumerate()
-        .filter(|(_, q)| {
-            q.queue_flags.intersects(QueueFlags::TRANSFER)
+    let transfer_family_index = QueueFamilyIndex(
+        physical_device
+            .queue_family_properties()
+            .iter()
+            .enumerate()
+            .filter(|(_, q)| {
+                q.queue_flags.intersects(QueueFlags::TRANSFER)
                 // Queue familes dedicated to transfers are not required to support partial 
                 // transfers of images, reported by a mininum granularity of [0, 0, 0]. If you need 
                 // to do partial transfers of images like we do in this example, you therefore have 
@@ -171,10 +173,11 @@ fn main() -> Result<(), impl Error> {
                 && q.min_image_transfer_granularity[0..2]
                     .iter()
                     .all(|&g| TRANSFER_GRANULARITY % g == 0)
-        })
-        .min_by_key(|(_, q)| q.queue_flags.count())
-        .unwrap()
-        .0 as u32;
+            })
+            .min_by_key(|(_, q)| q.queue_flags.count())
+            .unwrap()
+            .0 as u32,
+    );
 
     let (device, mut queues) = {
         let mut queue_create_infos = vec![QueueCreateInfo {
diff --git a/examples/basic-compute-shader/main.rs b/examples/basic-compute-shader/main.rs
index 3662fb0522..74acce269d 100644
--- a/examples/basic-compute-shader/main.rs
+++ b/examples/basic-compute-shader/main.rs
@@ -16,7 +16,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -56,7 +56,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/buffer-allocator/main.rs b/examples/buffer-allocator/main.rs
index d60f8d44f6..01f70e5f84 100644
--- a/examples/buffer-allocator/main.rs
+++ b/examples/buffer-allocator/main.rs
@@ -16,7 +16,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -79,9 +79,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/clear-attachments/main.rs b/examples/clear-attachments/main.rs
index 626665b0d2..111db768b1 100644
--- a/examples/clear-attachments/main.rs
+++ b/examples/clear-attachments/main.rs
@@ -7,7 +7,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -59,9 +59,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/debug/main.rs b/examples/debug/main.rs
index 402a63fe48..c5f453ae2c 100644
--- a/examples/debug/main.rs
+++ b/examples/debug/main.rs
@@ -1,6 +1,7 @@
 use vulkano::{
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
+        QueueFamilyIndex,
     },
     instance::{
         debug::{
@@ -126,7 +127,7 @@ fn main() {
         .filter(|p| p.supported_extensions().contains(&device_extensions))
         .map(|p| {
             (!p.queue_family_properties().is_empty())
-                .then_some((p, 0))
+                .then_some((p, QueueFamilyIndex(0)))
                 .expect("couldn't find a queue family")
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
diff --git a/examples/deferred/main.rs b/examples/deferred/main.rs
index f759a5def4..0a80f9798d 100644
--- a/examples/deferred/main.rs
+++ b/examples/deferred/main.rs
@@ -28,7 +28,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -82,9 +82,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/dynamic-buffers/main.rs b/examples/dynamic-buffers/main.rs
index 8424171ac2..d6fe044f9d 100644
--- a/examples/dynamic-buffers/main.rs
+++ b/examples/dynamic-buffers/main.rs
@@ -17,7 +17,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -53,7 +53,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/dynamic-local-size/main.rs b/examples/dynamic-local-size/main.rs
index a87c46a312..5171ea35e6 100644
--- a/examples/dynamic-local-size/main.rs
+++ b/examples/dynamic-local-size/main.rs
@@ -16,7 +16,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage},
@@ -59,7 +59,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/gl-interop/main.rs b/examples/gl-interop/main.rs
index 0a8f11b8da..65f7f45d27 100644
--- a/examples/gl-interop/main.rs
+++ b/examples/gl-interop/main.rs
@@ -29,7 +29,7 @@ mod linux {
         },
         device::{
             physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, Queue,
-            QueueCreateInfo, QueueFlags,
+            QueueCreateInfo, QueueFamilyIndex, QueueFlags,
         },
         format::Format,
         image::{
@@ -555,9 +555,10 @@ mod linux {
                     .enumerate()
                     .position(|(i, q)| {
                         q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                            && p.surface_support(i as u32, &surface).unwrap_or(false)
+                            && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                                .unwrap_or(false)
                     })
-                    .map(|i| (p, i as u32))
+                    .map(|i| (p, QueueFamilyIndex(i as u32)))
             })
             .filter(|(p, _)| p.properties().driver_uuid.unwrap() == display.driver_uuid().unwrap())
             .filter(|(p, _)| {
diff --git a/examples/image-self-copy-blit/main.rs b/examples/image-self-copy-blit/main.rs
index 35cb9992a4..3487afd4a8 100644
--- a/examples/image-self-copy-blit/main.rs
+++ b/examples/image-self-copy-blit/main.rs
@@ -12,7 +12,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -84,9 +84,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/image/main.rs b/examples/image/main.rs
index f5150de1fd..208df7d02b 100644
--- a/examples/image/main.rs
+++ b/examples/image/main.rs
@@ -10,7 +10,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -82,9 +82,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/immutable-sampler/main.rs b/examples/immutable-sampler/main.rs
index 0efed2009d..200f9e2c87 100644
--- a/examples/immutable-sampler/main.rs
+++ b/examples/immutable-sampler/main.rs
@@ -19,7 +19,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -88,9 +88,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/indirect/main.rs b/examples/indirect/main.rs
index 4aacb2b205..7e9a163c65 100644
--- a/examples/indirect/main.rs
+++ b/examples/indirect/main.rs
@@ -29,7 +29,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -96,9 +96,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/instancing/main.rs b/examples/instancing/main.rs
index 0c07620397..9a2278ae21 100644
--- a/examples/instancing/main.rs
+++ b/examples/instancing/main.rs
@@ -12,7 +12,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -94,9 +94,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/mesh-shader/main.rs b/examples/mesh-shader/main.rs
index d6709c086b..9d5b71f965 100644
--- a/examples/mesh-shader/main.rs
+++ b/examples/mesh-shader/main.rs
@@ -25,7 +25,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -115,9 +115,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/msaa-renderpass/main.rs b/examples/msaa-renderpass/main.rs
index cb46608451..9c77b6042c 100644
--- a/examples/msaa-renderpass/main.rs
+++ b/examples/msaa-renderpass/main.rs
@@ -62,7 +62,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage, SampleCount},
@@ -109,7 +109,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::GRAPHICS))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/multi-window/main.rs b/examples/multi-window/main.rs
index ae726a40aa..a0d9124571 100644
--- a/examples/multi-window/main.rs
+++ b/examples/multi-window/main.rs
@@ -16,7 +16,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -99,9 +99,10 @@ fn main() -> Result<(), impl Error> {
                     .enumerate()
                     .position(|(i, q)| {
                         q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                            && p.surface_support(i as u32, &surface).unwrap_or(false)
+                            && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                                .unwrap_or(false)
                     })
-                    .map(|i| (p, i as u32))
+                    .map(|i| (p, QueueFamilyIndex(i as u32)))
             })
             .min_by_key(|(p, _)| match p.properties().device_type {
                 PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/multiview/main.rs b/examples/multiview/main.rs
index 63fcdf7f66..88bae6db98 100644
--- a/examples/multiview/main.rs
+++ b/examples/multiview/main.rs
@@ -13,7 +13,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -87,7 +87,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::GRAPHICS))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/occlusion-query/main.rs b/examples/occlusion-query/main.rs
index c850a602b0..aff567f3e0 100644
--- a/examples/occlusion-query/main.rs
+++ b/examples/occlusion-query/main.rs
@@ -11,7 +11,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage},
@@ -77,9 +77,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/offscreen/main.rs b/examples/offscreen/main.rs
index cbb062204b..2412b01065 100644
--- a/examples/offscreen/main.rs
+++ b/examples/offscreen/main.rs
@@ -9,7 +9,10 @@ use vulkano::{
         CommandBufferUsage, CopyImageToBufferInfo, RecordingCommandBuffer, RenderPassBeginInfo,
         SubpassBeginInfo, SubpassContents,
     },
-    device::{physical::PhysicalDeviceType, Device, DeviceCreateInfo, QueueCreateInfo, QueueFlags},
+    device::{
+        physical::PhysicalDeviceType, Device, DeviceCreateInfo, QueueCreateInfo, QueueFamilyIndex,
+        QueueFlags,
+    },
     format::Format,
     image::{view::ImageView, Image, ImageCreateInfo, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -55,7 +58,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::GRAPHICS))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/pipeline-caching/main.rs b/examples/pipeline-caching/main.rs
index fdbb66cba5..f150019838 100644
--- a/examples/pipeline-caching/main.rs
+++ b/examples/pipeline-caching/main.rs
@@ -23,7 +23,7 @@ use std::{
 use vulkano::{
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     pipeline::{
@@ -60,7 +60,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/push-constants/main.rs b/examples/push-constants/main.rs
index 343747fc18..cb792278db 100644
--- a/examples/push-constants/main.rs
+++ b/examples/push-constants/main.rs
@@ -15,7 +15,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -51,7 +51,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/push-descriptors/main.rs b/examples/push-descriptors/main.rs
index d6958b167e..e2faa37b58 100644
--- a/examples/push-descriptors/main.rs
+++ b/examples/push-descriptors/main.rs
@@ -8,7 +8,7 @@ use vulkano::{
     descriptor_set::{layout::DescriptorSetLayoutCreateFlags, WriteDescriptorSet},
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -78,9 +78,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/runtime-array/main.rs b/examples/runtime-array/main.rs
index 9161202aa0..a2e8f06bcb 100644
--- a/examples/runtime-array/main.rs
+++ b/examples/runtime-array/main.rs
@@ -11,7 +11,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -83,9 +83,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/runtime-shader/main.rs b/examples/runtime-shader/main.rs
index a0d5cd8f49..4dd535b827 100644
--- a/examples/runtime-shader/main.rs
+++ b/examples/runtime-shader/main.rs
@@ -21,7 +21,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -85,9 +85,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/self-copy-buffer/main.rs b/examples/self-copy-buffer/main.rs
index 0779f1145d..8123d22a80 100644
--- a/examples/self-copy-buffer/main.rs
+++ b/examples/self-copy-buffer/main.rs
@@ -14,7 +14,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -50,7 +50,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/shader-include/main.rs b/examples/shader-include/main.rs
index 6fc5f5c13c..8d675d1781 100644
--- a/examples/shader-include/main.rs
+++ b/examples/shader-include/main.rs
@@ -14,7 +14,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -50,7 +50,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/shader-types-sharing/main.rs b/examples/shader-types-sharing/main.rs
index 047469643d..c965631531 100644
--- a/examples/shader-types-sharing/main.rs
+++ b/examples/shader-types-sharing/main.rs
@@ -28,7 +28,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, Queue,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -64,7 +64,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/simple-particles/main.rs b/examples/simple-particles/main.rs
index 04bfccbadc..7edee3ff84 100644
--- a/examples/simple-particles/main.rs
+++ b/examples/simple-particles/main.rs
@@ -15,7 +15,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -96,9 +96,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/specialization-constants/main.rs b/examples/specialization-constants/main.rs
index 59b20b8c22..8622ee403f 100644
--- a/examples/specialization-constants/main.rs
+++ b/examples/specialization-constants/main.rs
@@ -12,7 +12,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
     memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
@@ -48,7 +48,7 @@ fn main() {
             p.queue_family_properties()
                 .iter()
                 .position(|q| q.queue_flags.intersects(QueueFlags::COMPUTE))
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/teapot/main.rs b/examples/teapot/main.rs
index 4a9eb5477d..482be80b06 100644
--- a/examples/teapot/main.rs
+++ b/examples/teapot/main.rs
@@ -18,7 +18,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceOwned,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{view::ImageView, Image, ImageCreateInfo, ImageType, ImageUsage},
@@ -90,9 +90,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/tessellation/main.rs b/examples/tessellation/main.rs
index d5aa14bcc4..519b1e2cb1 100644
--- a/examples/tessellation/main.rs
+++ b/examples/tessellation/main.rs
@@ -21,7 +21,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -188,9 +188,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/texture-array/main.rs b/examples/texture-array/main.rs
index 4c0b40fe79..962235edec 100644
--- a/examples/texture-array/main.rs
+++ b/examples/texture-array/main.rs
@@ -10,7 +10,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     format::Format,
     image::{
@@ -84,9 +84,10 @@ fn main() -> Result<(), impl Error> {
                 .enumerate()
                 .position(|(i, q)| {
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         .min_by_key(|(p, _)| match p.properties().device_type {
             PhysicalDeviceType::DiscreteGpu => 0,
diff --git a/examples/triangle-v1_3/main.rs b/examples/triangle-v1_3/main.rs
index 1edb5cc3ae..214f26761b 100644
--- a/examples/triangle-v1_3/main.rs
+++ b/examples/triangle-v1_3/main.rs
@@ -21,7 +21,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-        QueueCreateInfo, QueueFlags,
+        QueueCreateInfo, QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -133,12 +133,13 @@ fn main() -> Result<(), impl Error> {
                     // a window surface, as we do in this example, we also need to check that
                     // queues in this queue family are capable of presenting images to the surface.
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
                 // The code here searches for the first queue family that is suitable. If none is
                 // found, `None` is returned to `filter_map`, which disqualifies this physical
                 // device.
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         // All the physical devices that pass the filters above are suitable for the application.
         // However, not every device is equal, some are preferred over others. Now, we assign each
diff --git a/examples/triangle/main.rs b/examples/triangle/main.rs
index 54e7025592..8dca127623 100644
--- a/examples/triangle/main.rs
+++ b/examples/triangle/main.rs
@@ -17,7 +17,7 @@ use vulkano::{
     },
     device::{
         physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     image::{view::ImageView, Image, ImageUsage},
     instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
@@ -123,12 +123,13 @@ fn main() -> Result<(), impl Error> {
                     // a window surface, as we do in this example, we also need to check that
                     // queues in this queue family are capable of presenting images to the surface.
                     q.queue_flags.intersects(QueueFlags::GRAPHICS)
-                        && p.surface_support(i as u32, &surface).unwrap_or(false)
+                        && p.surface_support(QueueFamilyIndex(i as u32), &surface)
+                            .unwrap_or(false)
                 })
                 // The code here searches for the first queue family that is suitable. If none is
                 // found, `None` is returned to `filter_map`, which disqualifies this physical
                 // device.
-                .map(|i| (p, i as u32))
+                .map(|i| (p, QueueFamilyIndex(i as u32)))
         })
         // All the physical devices that pass the filters above are suitable for the application.
         // However, not every device is equal, some are preferred over others. Now, we assign each
diff --git a/vulkano-util/src/context.rs b/vulkano-util/src/context.rs
index 41be85bb39..7c1c51dc45 100644
--- a/vulkano-util/src/context.rs
+++ b/vulkano-util/src/context.rs
@@ -5,7 +5,7 @@ use vulkano::{
     device::{
         physical::{PhysicalDevice, PhysicalDeviceType},
         Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures, Queue, QueueCreateInfo,
-        QueueFlags,
+        QueueFamilyIndex, QueueFlags,
     },
     instance::{
         debug::{DebugUtilsMessenger, DebugUtilsMessengerCreateInfo},
@@ -202,7 +202,7 @@ impl VulkanoContext {
             .queue_family_properties()
             .iter()
             .enumerate()
-            .map(|(i, q)| (i as u32, q))
+            .map(|(i, q)| (QueueFamilyIndex(i as u32), q))
             .find(|(_i, q)| q.queue_flags.intersects(QueueFlags::GRAPHICS))
             .map(|(i, _)| i)
             .expect("could not find a queue that supports graphics");
@@ -211,7 +211,7 @@ impl VulkanoContext {
             .queue_family_properties()
             .iter()
             .enumerate()
-            .map(|(i, q)| (i as u32, q))
+            .map(|(i, q)| (QueueFamilyIndex(i as u32), q))
             .find(|(i, q)| {
                 q.queue_flags.intersects(QueueFlags::COMPUTE) && *i != queue_family_graphics
             })
diff --git a/vulkano/src/command_buffer/allocator.rs b/vulkano/src/command_buffer/allocator.rs
index a662cfb61d..1d89823f94 100644
--- a/vulkano/src/command_buffer/allocator.rs
+++ b/vulkano/src/command_buffer/allocator.rs
@@ -12,7 +12,7 @@ use super::{
     CommandBufferLevel,
 };
 use crate::{
-    device::{Device, DeviceOwned},
+    device::{Device, DeviceOwned, QueueFamilyIndex},
     instance::InstanceOwnedDebugWrapper,
     Validated, ValidationError, VulkanError,
 };
@@ -59,7 +59,7 @@ pub unsafe trait CommandBufferAllocator: DeviceOwned + Send + Sync + 'static {
     /// Allocates a command buffer.
     fn allocate(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
     ) -> Result<CommandBufferAlloc, Validated<VulkanError>>;
 
@@ -213,7 +213,7 @@ impl StandardCommandBufferAllocator {
     #[inline]
     pub fn try_reset_pool(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         flags: CommandPoolResetFlags,
     ) -> Result<(), Validated<ResetCommandPoolError>> {
         if let Some(entry) = unsafe { &mut *self.entry(queue_family_index) }.as_mut() {
@@ -233,11 +233,11 @@ impl StandardCommandBufferAllocator {
     ///
     /// - Panics if `queue_family_index` is not less than the number of queue families.
     #[inline]
-    pub fn clear(&self, queue_family_index: u32) {
+    pub fn clear(&self, queue_family_index: QueueFamilyIndex) {
         unsafe { *self.entry(queue_family_index) = None };
     }
 
-    fn entry(&self, queue_family_index: u32) -> *mut Option<Entry> {
+    fn entry(&self, queue_family_index: QueueFamilyIndex) -> *mut Option<Entry> {
         let pools = self.pools.get_or(|| {
             self.device
                 .physical_device()
@@ -247,7 +247,7 @@ impl StandardCommandBufferAllocator {
                 .collect()
         });
 
-        pools[queue_family_index as usize].get()
+        pools[queue_family_index.0 as usize].get()
     }
 }
 
@@ -255,7 +255,7 @@ unsafe impl CommandBufferAllocator for StandardCommandBufferAllocator {
     #[inline]
     fn allocate(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
     ) -> Result<CommandBufferAlloc, Validated<VulkanError>> {
         if !self
@@ -331,7 +331,7 @@ unsafe impl<T: CommandBufferAllocator> CommandBufferAllocator for Arc<T> {
     #[inline]
     fn allocate(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
     ) -> Result<CommandBufferAlloc, Validated<VulkanError>> {
         (**self).allocate(queue_family_index, level)
@@ -368,7 +368,7 @@ unsafe impl Send for Entry {}
 impl Entry {
     fn new(
         device: Arc<Device>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         buffer_count: &[usize; 2],
         pool_reserve: Arc<ArrayQueue<Arc<Pool>>>,
     ) -> Result<Self, VulkanError> {
@@ -381,7 +381,7 @@ impl Entry {
 
     fn allocate(
         &mut self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         buffer_count: &[usize; 2],
     ) -> Result<CommandBufferAlloc, VulkanError> {
@@ -477,7 +477,7 @@ struct Pool {
 impl Pool {
     fn new(
         device: Arc<Device>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         buffer_counts: &[usize; 2],
         pool_reserve: &Arc<ArrayQueue<Arc<Self>>>,
     ) -> Result<Arc<Self>, VulkanError> {
diff --git a/vulkano/src/command_buffer/auto/builder.rs b/vulkano/src/command_buffer/auto/builder.rs
index 43d80e896a..fe85fd562b 100644
--- a/vulkano/src/command_buffer/auto/builder.rs
+++ b/vulkano/src/command_buffer/auto/builder.rs
@@ -48,6 +48,7 @@ use std::{
     ops::{Range, RangeInclusive},
     sync::{atomic::AtomicBool, Arc},
 };
+use vulkano::device::QueueFamilyIndex;
 
 /// A command buffer in the recording state.
 ///
@@ -70,7 +71,7 @@ impl RecordingCommandBuffer {
     #[inline]
     pub fn new(
         allocator: Arc<dyn CommandBufferAllocator>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: CommandBufferBeginInfo,
     ) -> Result<RecordingCommandBuffer, Validated<VulkanError>> {
@@ -81,7 +82,7 @@ impl RecordingCommandBuffer {
 
     fn validate_new(
         device: &Device,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: &CommandBufferBeginInfo,
     ) -> Result<(), Box<ValidationError>> {
@@ -93,7 +94,7 @@ impl RecordingCommandBuffer {
     #[cfg_attr(not(feature = "document_unchecked"), doc(hidden))]
     pub unsafe fn new_unchecked(
         allocator: Arc<dyn CommandBufferAllocator>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: CommandBufferBeginInfo,
     ) -> Result<Self, Validated<VulkanError>> {
diff --git a/vulkano/src/command_buffer/auto/mod.rs b/vulkano/src/command_buffer/auto/mod.rs
index c89b376f95..b1b77eac17 100644
--- a/vulkano/src/command_buffer/auto/mod.rs
+++ b/vulkano/src/command_buffer/auto/mod.rs
@@ -70,7 +70,7 @@ use super::{
 };
 use crate::{
     buffer::Subbuffer,
-    device::{Device, DeviceOwned},
+    device::{Device, DeviceOwned, QueueFamilyIndex},
     image::{Image, ImageLayout, ImageSubresourceRange},
     sync::PipelineStageAccessFlags,
     DeviceSize, ValidationError, VulkanObject,
@@ -130,7 +130,7 @@ impl CommandBuffer {
 
     /// Returns the queue family index of this command buffer.
     #[inline]
-    pub fn queue_family_index(&self) -> u32 {
+    pub fn queue_family_index(&self) -> QueueFamilyIndex {
         self.inner.queue_family_index()
     }
 
@@ -323,7 +323,7 @@ mod tests {
             },
             DescriptorSet, WriteDescriptorSet,
         },
-        device::{Device, DeviceCreateInfo, QueueCreateInfo},
+        device::{Device, DeviceCreateInfo, QueueCreateInfo, QueueFamilyIndex},
         image::sampler::{Sampler, SamplerCreateInfo},
         memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
         pipeline::{layout::PipelineLayoutCreateInfo, PipelineBindPoint, PipelineLayout},
@@ -366,7 +366,7 @@ mod tests {
             physical_device,
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index: 0,
+                    queue_family_index: QueueFamilyIndex(0),
                     ..Default::default()
                 }],
                 ..Default::default()
diff --git a/vulkano/src/command_buffer/pool.rs b/vulkano/src/command_buffer/pool.rs
index 778bd97c01..68531705bb 100644
--- a/vulkano/src/command_buffer/pool.rs
+++ b/vulkano/src/command_buffer/pool.rs
@@ -8,7 +8,7 @@
 
 use crate::{
     command_buffer::CommandBufferLevel,
-    device::{Device, DeviceOwned},
+    device::{Device, DeviceOwned, QueueFamilyIndex},
     instance::InstanceOwnedDebugWrapper,
     macros::{impl_id_counter, vulkan_bitflags},
     Requires, RequiresAllOf, RequiresOneOf, Validated, ValidationError, Version, VulkanError,
@@ -31,7 +31,7 @@ pub struct CommandPool {
     id: NonZeroU64,
 
     flags: CommandPoolCreateFlags,
-    queue_family_index: u32,
+    queue_family_index: QueueFamilyIndex,
 
     // Unimplement `Sync`, as Vulkan command pools are not thread-safe.
     _marker: PhantomData<Cell<ash::vk::CommandPool>>,
@@ -72,7 +72,7 @@ impl CommandPool {
 
         let create_info_vk = ash::vk::CommandPoolCreateInfo {
             flags: flags.into(),
-            queue_family_index,
+            queue_family_index: queue_family_index.0,
             ..Default::default()
         };
 
@@ -131,7 +131,7 @@ impl CommandPool {
 
     /// Returns the queue family on which command buffers of this pool can be executed.
     #[inline]
-    pub fn queue_family_index(&self) -> u32 {
+    pub fn queue_family_index(&self) -> QueueFamilyIndex {
         self.queue_family_index
     }
 
@@ -353,7 +353,7 @@ pub struct CommandPoolCreateInfo {
     /// from this pool must be submitted on a queue belonging to that family.
     ///
     /// The default value is `u32::MAX`, which must be overridden.
-    pub queue_family_index: u32,
+    pub queue_family_index: QueueFamilyIndex,
 
     pub _ne: crate::NonExhaustive,
 }
@@ -363,7 +363,7 @@ impl Default for CommandPoolCreateInfo {
     fn default() -> Self {
         Self {
             flags: CommandPoolCreateFlags::empty(),
-            queue_family_index: u32::MAX,
+            queue_family_index: QueueFamilyIndex(u32::MAX),
             _ne: crate::NonExhaustive(()),
         }
     }
@@ -382,7 +382,7 @@ impl CommandPoolCreateInfo {
                 .set_vuids(&["VUID-VkCommandPoolCreateInfo-flags-parameter"])
         })?;
 
-        if queue_family_index >= device.physical_device().queue_family_properties().len() as u32 {
+        if queue_family_index.0 >= device.physical_device().queue_family_properties().len() as u32 {
             return Err(Box::new(ValidationError {
                 context: "queue_family_index".into(),
                 problem: "is not less than the number of queue families in the physical device"
diff --git a/vulkano/src/command_buffer/sys.rs b/vulkano/src/command_buffer/sys.rs
index 9b302cb004..b17c2adde6 100644
--- a/vulkano/src/command_buffer/sys.rs
+++ b/vulkano/src/command_buffer/sys.rs
@@ -13,6 +13,7 @@ use crate::{
 };
 use smallvec::SmallVec;
 use std::{fmt::Debug, mem::ManuallyDrop, ptr, sync::Arc};
+use vulkano::device::QueueFamilyIndex;
 
 /// A raw command buffer in the recording state.
 ///
@@ -27,7 +28,7 @@ use std::{fmt::Debug, mem::ManuallyDrop, ptr, sync::Arc};
 pub struct RawRecordingCommandBuffer {
     allocation: ManuallyDrop<CommandBufferAlloc>,
     allocator: Arc<dyn CommandBufferAllocator>,
-    queue_family_index: u32,
+    queue_family_index: QueueFamilyIndex,
     // Must be `None` in a primary command buffer and `Some` in a secondary command buffer.
     inheritance_info: Option<CommandBufferInheritanceInfo>,
     pub(super) usage: CommandBufferUsage,
@@ -38,7 +39,7 @@ impl RawRecordingCommandBuffer {
     #[inline]
     pub fn new(
         allocator: Arc<dyn CommandBufferAllocator>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: CommandBufferBeginInfo,
     ) -> Result<Self, Validated<VulkanError>> {
@@ -49,7 +50,7 @@ impl RawRecordingCommandBuffer {
 
     pub(super) fn validate_new(
         device: &Device,
-        _queue_family_index: u32,
+        _queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: &CommandBufferBeginInfo,
     ) -> Result<(), Box<ValidationError>> {
@@ -76,7 +77,7 @@ impl RawRecordingCommandBuffer {
     #[cfg_attr(not(feature = "document_unchecked"), doc(hidden))]
     pub unsafe fn new_unchecked(
         allocator: Arc<dyn CommandBufferAllocator>,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         level: CommandBufferLevel,
         begin_info: CommandBufferBeginInfo,
     ) -> Result<Self, Validated<VulkanError>> {
@@ -214,7 +215,7 @@ impl RawRecordingCommandBuffer {
 
     /// Returns the queue family index that this command buffer was created for.
     #[inline]
-    pub fn queue_family_index(&self) -> u32 {
+    pub fn queue_family_index(&self) -> QueueFamilyIndex {
         self.queue_family_index
     }
 
@@ -237,7 +238,8 @@ impl RawRecordingCommandBuffer {
     }
 
     pub(in crate::command_buffer) fn queue_family_properties(&self) -> &QueueFamilyProperties {
-        &self.device().physical_device().queue_family_properties()[self.queue_family_index as usize]
+        &self.device().physical_device().queue_family_properties()
+            [self.queue_family_index.0 as usize]
     }
 }
 
@@ -343,7 +345,7 @@ unsafe impl Sync for RawCommandBuffer {}
 impl RawCommandBuffer {
     /// Returns the queue family index that this command buffer was created for.
     #[inline]
-    pub fn queue_family_index(&self) -> u32 {
+    pub fn queue_family_index(&self) -> QueueFamilyIndex {
         self.inner.queue_family_index
     }
 
diff --git a/vulkano/src/device/mod.rs b/vulkano/src/device/mod.rs
index 1b853da08e..80cb23d78d 100644
--- a/vulkano/src/device/mod.rs
+++ b/vulkano/src/device/mod.rs
@@ -9,7 +9,7 @@
 //! use vulkano::{
 //!     device::{
 //!         physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
-//!         QueueCreateInfo,
+//!         QueueCreateInfo, QueueFamilyIndex,
 //!     },
 //!     instance::{Instance, InstanceExtensions},
 //!     Version, VulkanLibrary,
@@ -38,7 +38,7 @@
 //!         physical_device,
 //!         DeviceCreateInfo {
 //!             queue_create_infos: vec![QueueCreateInfo {
-//!                 queue_family_index: 0,
+//!                 queue_family_index: QueueFamilyIndex(0),
 //!                 ..Default::default()
 //!             }],
 //!             enabled_extensions: extensions,
@@ -100,7 +100,7 @@ pub(crate) use self::properties::DevicePropertiesFfi;
 use self::{physical::PhysicalDevice, queue::DeviceQueueInfo};
 pub use self::{
     properties::DeviceProperties,
-    queue::{Queue, QueueFamilyProperties, QueueFlags, QueueGuard},
+    queue::{Queue, QueueFamilyIndex, QueueFamilyProperties, QueueFlags, QueueGuard},
 };
 pub use crate::fns::DeviceFunctions;
 use crate::{
@@ -161,7 +161,7 @@ pub struct Device {
     // This is the minimum of Instance::max_api_version and PhysicalDevice::api_version.
     api_version: Version,
     fns: DeviceFunctions,
-    active_queue_family_indices: SmallVec<[u32; 2]>,
+    active_queue_family_indices: SmallVec<[QueueFamilyIndex; 2]>,
 
     // This is required for validation in `memory::device_memory`, the count must only be modified
     // in that module.
@@ -355,7 +355,7 @@ impl Device {
 
                 ash::vk::DeviceQueueCreateInfo {
                     flags: flags.into(),
-                    queue_family_index,
+                    queue_family_index: queue_family_index.0,
                     queue_count: queues.len() as u32,
                     p_queue_priorities: queues.as_ptr(),
                     ..Default::default()
@@ -592,7 +592,7 @@ impl Device {
 
     /// Returns the queue family indices that this device uses.
     #[inline]
-    pub fn active_queue_family_indices(&self) -> &[u32] {
+    pub fn active_queue_family_indices(&self) -> &[QueueFamilyIndex] {
         &self.active_queue_family_indices
     }
 
@@ -2104,7 +2104,7 @@ pub struct QueueCreateInfo {
     /// The index of the queue family to create queues for.
     ///
     /// The default value is `0`.
-    pub queue_family_index: u32,
+    pub queue_family_index: QueueFamilyIndex,
 
     /// The queues to create for the given queue family, each with a relative priority.
     ///
@@ -2124,7 +2124,7 @@ impl Default for QueueCreateInfo {
     fn default() -> Self {
         Self {
             flags: QueueCreateFlags::empty(),
-            queue_family_index: 0,
+            queue_family_index: QueueFamilyIndex(0),
             queues: vec![0.5],
             _ne: crate::NonExhaustive(()),
         }
@@ -2159,7 +2159,7 @@ impl QueueCreateInfo {
 
         let queue_family_properties = physical_device
             .queue_family_properties()
-            .get(queue_family_index as usize)
+            .get(queue_family_index.0 as usize)
             .ok_or_else(|| {
                 Box::new(ValidationError {
                     context: "queue_family_index".into(),
@@ -2301,6 +2301,7 @@ pub struct MemoryFdProperties {
 mod tests {
     use crate::device::{
         Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures, QueueCreateInfo,
+        QueueFamilyIndex,
     };
     use std::{ffi::CString, sync::Arc};
 
@@ -2365,7 +2366,7 @@ mod tests {
             physical_device,
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index,
+                    queue_family_index: QueueFamilyIndex(queue_family_index),
                     queues,
                     ..Default::default()
                 }],
@@ -2396,7 +2397,7 @@ mod tests {
             physical_device,
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index: 0,
+                    queue_family_index: QueueFamilyIndex(0),
                     ..Default::default()
                 }],
                 enabled_features: features,
@@ -2421,7 +2422,7 @@ mod tests {
             physical_device.clone(),
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index: 0,
+                    queue_family_index: QueueFamilyIndex(0),
                     queues: vec![1.4],
                     ..Default::default()
                 }],
@@ -2437,7 +2438,7 @@ mod tests {
             physical_device,
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index: 0,
+                    queue_family_index: QueueFamilyIndex(0),
                     queues: vec![-0.2],
                     ..Default::default()
                 }],
diff --git a/vulkano/src/device/physical.rs b/vulkano/src/device/physical.rs
index 1586abef72..f87e39f46f 100644
--- a/vulkano/src/device/physical.rs
+++ b/vulkano/src/device/physical.rs
@@ -3,8 +3,8 @@ use crate::{
     buffer::{ExternalBufferInfo, ExternalBufferProperties},
     cache::{OnceCache, WeakArcOnceCache},
     device::{
-        properties::DeviceProperties, DeviceExtensions, DeviceFeatures, DeviceFeaturesFfi,
-        DevicePropertiesFfi,
+        properties::DeviceProperties, queue::QueueFamilyIndex, DeviceExtensions, DeviceFeatures,
+        DeviceFeaturesFfi, DevicePropertiesFfi,
     },
     display::{Display, DisplayPlaneProperties, DisplayPlanePropertiesRaw, DisplayProperties},
     format::{DrmFormatModifierProperties, Format, FormatProperties},
@@ -1958,7 +1958,7 @@ impl PhysicalDevice {
         assert_eq!(self.instance(), surface.instance());
 
         if !(0..self.queue_family_properties.len() as u32).any(|index| unsafe {
-            self.surface_support_unchecked(index, surface)
+            self.surface_support_unchecked(QueueFamilyIndex(index), surface)
                 .unwrap_or_default()
         }) {
             return Err(Box::new(ValidationError {
@@ -2332,7 +2332,7 @@ impl PhysicalDevice {
         assert_eq!(self.instance(), surface.instance());
 
         if !(0..self.queue_family_properties.len() as u32).any(|index| unsafe {
-            self.surface_support_unchecked(index, surface)
+            self.surface_support_unchecked(QueueFamilyIndex(index), surface)
                 .unwrap_or_default()
         }) {
             return Err(Box::new(ValidationError {
@@ -2632,7 +2632,7 @@ impl PhysicalDevice {
         assert_eq!(self.instance(), surface.instance());
 
         if !(0..self.queue_family_properties.len() as u32).any(|index| unsafe {
-            self.surface_support_unchecked(index, surface)
+            self.surface_support_unchecked(QueueFamilyIndex(index), surface)
                 .unwrap_or_default()
         }) {
             return Err(Box::new(ValidationError {
@@ -2855,7 +2855,7 @@ impl PhysicalDevice {
     #[inline]
     pub fn surface_support(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         surface: &Surface,
     ) -> Result<bool, Validated<VulkanError>> {
         self.validate_surface_support(queue_family_index, surface)?;
@@ -2865,7 +2865,7 @@ impl PhysicalDevice {
 
     fn validate_surface_support(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         _surface: &Surface,
     ) -> Result<(), Box<ValidationError>> {
         if !self.instance.enabled_extensions().khr_surface {
@@ -2877,7 +2877,7 @@ impl PhysicalDevice {
             }));
         }
 
-        if queue_family_index >= self.queue_family_properties.len() as u32 {
+        if queue_family_index.0 >= self.queue_family_properties.len() as u32 {
             return Err(Box::new(ValidationError {
                 context: "queue_family_index".into(),
                 problem: "is not less than the number of queue families in the physical device"
@@ -2893,18 +2893,18 @@ impl PhysicalDevice {
     #[cfg_attr(not(feature = "document_unchecked"), doc(hidden))]
     pub unsafe fn surface_support_unchecked(
         &self,
-        queue_family_index: u32,
+        queue_family_index: QueueFamilyIndex,
         surface: &Surface,
     ) -> Result<bool, VulkanError> {
         surface
             .surface_support
-            .get_or_try_insert((self.handle, queue_family_index), |_| {
+            .get_or_try_insert((self.handle, queue_family_index.0), |_| {
                 let fns = self.instance.fns();
 
                 let mut output = MaybeUninit::uninit();
                 (fns.khr_surface.get_physical_device_surface_support_khr)(
                     self.handle,
-                    queue_family_index,
+                    queue_family_index.0,
                     surface.handle(),
                     output.as_mut_ptr(),
                 )
diff --git a/vulkano/src/device/queue.rs b/vulkano/src/device/queue.rs
index 87679074f5..6b76a05b96 100644
--- a/vulkano/src/device/queue.rs
+++ b/vulkano/src/device/queue.rs
@@ -15,12 +15,43 @@ use parking_lot::{Mutex, MutexGuard};
 use smallvec::SmallVec;
 use std::{
     ffi::CString,
+    fmt::{Display, Formatter},
     hash::{Hash, Hasher},
     mem::MaybeUninit,
+    ops::Deref,
     ptr,
     sync::Arc,
 };
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub struct QueueFamilyIndex(pub u32);
+
+impl Deref for QueueFamilyIndex {
+    type Target = u32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Display for QueueFamilyIndex {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "QueueFamilyIndex {}", self.0)
+    }
+}
+
+impl From<QueueFamilyIndex> for u32 {
+    fn from(value: QueueFamilyIndex) -> Self {
+        value.0
+    }
+}
+
+impl From<QueueFamilyIndex> for usize {
+    fn from(value: QueueFamilyIndex) -> Self {
+        value.0 as usize
+    }
+}
+
 /// Represents a queue where commands can be submitted.
 // TODO: should use internal synchronization?
 #[derive(Debug)]
@@ -29,7 +60,7 @@ pub struct Queue {
     device: InstanceOwnedDebugWrapper<Arc<Device>>,
 
     flags: QueueCreateFlags,
-    queue_family_index: u32,
+    queue_family_index: QueueFamilyIndex,
     queue_index: u32, // index within family
 
     state: Mutex<QueueState>,
@@ -46,7 +77,7 @@ impl Queue {
 
         let queue_info_vk = ash::vk::DeviceQueueInfo2 {
             flags: flags.into(),
-            queue_family_index,
+            queue_family_index: queue_family_index.0,
             queue_index,
             ..Default::default()
         };
@@ -109,7 +140,7 @@ impl Queue {
 
     /// Returns the index of the queue family that this queue belongs to.
     #[inline]
-    pub fn queue_family_index(&self) -> u32 {
+    pub fn queue_family_index(&self) -> QueueFamilyIndex {
         self.queue_family_index
     }
 
@@ -179,7 +210,7 @@ impl Hash for Queue {
 #[derive(Clone, Debug)]
 pub(super) struct DeviceQueueInfo {
     pub(super) flags: QueueCreateFlags,
-    pub(super) queue_family_index: u32,
+    pub(super) queue_family_index: QueueFamilyIndex,
     pub(super) queue_index: u32,
     pub(super) _ne: crate::NonExhaustive,
 }
@@ -189,7 +220,7 @@ impl Default for DeviceQueueInfo {
     fn default() -> Self {
         Self {
             flags: QueueCreateFlags::empty(),
-            queue_family_index: 0,
+            queue_family_index: QueueFamilyIndex(0),
             queue_index: 0,
             _ne: crate::NonExhaustive(()),
         }
@@ -776,7 +807,7 @@ impl<'a> QueueGuard<'a> {
     ) -> Result<(), Box<ValidationError>> {
         let device = self.queue.device();
         let queue_family_properties = &device.physical_device().queue_family_properties()
-            [self.queue.queue_family_index as usize];
+            [self.queue.queue_family_index.0 as usize];
 
         if let Some(fence) = fence {
             // VUID-vkQueueSubmit2-commonparent
diff --git a/vulkano/src/sync/future/fence_signal.rs b/vulkano/src/sync/future/fence_signal.rs
index f2f69c1d9c..47e386c05e 100644
--- a/vulkano/src/sync/future/fence_signal.rs
+++ b/vulkano/src/sync/future/fence_signal.rs
@@ -282,7 +282,7 @@ where
                     // Same remark as `CommandBuffer`.
                     assert!(fence.is_none());
                     debug_assert!(queue.device().physical_device().queue_family_properties()
-                        [queue.queue_family_index() as usize]
+                        [queue.queue_family_index().0 as usize]
                         .queue_flags
                         .intersects(QueueFlags::SPARSE_BINDING));
 
diff --git a/vulkano/src/sync/mod.rs b/vulkano/src/sync/mod.rs
index 8cb495ebae..0223398c55 100644
--- a/vulkano/src/sync/mod.rs
+++ b/vulkano/src/sync/mod.rs
@@ -16,7 +16,10 @@ pub use self::{
         MemoryBarrier, PipelineStage, PipelineStages, QueueFamilyOwnershipTransfer,
     },
 };
-use crate::{device::Queue, VulkanError};
+use crate::{
+    device::{Queue, QueueFamilyIndex},
+    VulkanError,
+};
 use std::{
     error::Error,
     fmt::{Display, Formatter},
@@ -40,7 +43,7 @@ pub enum SharingMode {
     /// The resource is used is only one queue family.
     Exclusive,
     /// The resource is used in multiple queue families. Can be slower than `Exclusive`.
-    Concurrent(Vec<u32>), // TODO: Vec is too expensive here
+    Concurrent(Vec<QueueFamilyIndex>), // TODO: Vec is too expensive here
 }
 
 impl<'a> From<&'a Arc<Queue>> for SharingMode {
diff --git a/vulkano/src/sync/semaphore.rs b/vulkano/src/sync/semaphore.rs
index 37e1f56e8b..082da2124a 100644
--- a/vulkano/src/sync/semaphore.rs
+++ b/vulkano/src/sync/semaphore.rs
@@ -1956,7 +1956,7 @@ pub struct ExternalSemaphoreProperties {
 #[cfg(test)]
 mod tests {
     use crate::{
-        device::{Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo},
+        device::{Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo, QueueFamilyIndex},
         instance::{Instance, InstanceCreateInfo, InstanceExtensions},
         sync::semaphore::{
             ExternalSemaphoreHandleType, ExternalSemaphoreHandleTypes, Semaphore,
@@ -2019,7 +2019,7 @@ mod tests {
             physical_device,
             DeviceCreateInfo {
                 queue_create_infos: vec![QueueCreateInfo {
-                    queue_family_index: 0,
+                    queue_family_index: QueueFamilyIndex(0),
                     ..Default::default()
                 }],
                 enabled_extensions: DeviceExtensions {
diff --git a/vulkano/src/tests.rs b/vulkano/src/tests.rs
index abf1067c70..057aeb079e 100644
--- a/vulkano/src/tests.rs
+++ b/vulkano/src/tests.rs
@@ -27,7 +27,7 @@ macro_rules! gfx_dev_and_queue {
     });
     ($($feature:ident),*; $($extension:ident),*) => ({
         use crate::device::physical::PhysicalDeviceType;
-        use crate::device::{Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo};
+        use crate::device::{Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo, QueueFamilyIndex};
         use crate::device::DeviceFeatures;
 
         let instance = instance!();
@@ -55,7 +55,7 @@ macro_rules! gfx_dev_and_queue {
             .filter_map(|p| {
                 p.queue_family_properties().iter()
                     .position(|q| q.queue_flags.intersects(crate::device::QueueFlags::GRAPHICS))
-                    .map(|i| (p, i as u32))
+                    .map(|i| (p, QueueFamilyIndex(i as u32)))
             })
             .min_by_key(|(p, _)| {
                 match p.properties().device_type {