diff --git a/src/Magnum/Vk/Device.cpp b/src/Magnum/Vk/Device.cpp
index 4591799b7..db0ef3d6e 100644
--- a/src/Magnum/Vk/Device.cpp
+++ b/src/Magnum/Vk/Device.cpp
@@ -31,6 +31,7 @@
 #include <Corrade/Containers/GrowableArray.h>
 #include <Corrade/Containers/StaticArray.h>
 #include <Corrade/Containers/String.h>
+#include <Corrade/Containers/StringIterable.h>
 #include <Corrade/Containers/StringView.h>
 #include <Corrade/Utility/Algorithms.h>
 #include <Corrade/Utility/Arguments.h>
@@ -669,12 +670,11 @@ void Device::wrap(Instance& instance, const VkPhysicalDevice physicalDevice, con
     _handle = handle;
     _flags = flags;
     _properties.emplace(DeviceProperties::wrap(instance, physicalDevice));
-    initializeExtensions(enabledExtensions);
 
     /* Because we have no control over extensions / features, no workarounds
        are used here -- better to just do nothing than just a partial attempt */
     Containers::Array<std::pair<Containers::StringView, bool>> encounteredWorkarounds = Implementation::disableAllWorkarounds();
-    initialize(instance, version, encounteredWorkarounds, enabledFeatures);
+    initialize(instance, version, enabledExtensions, encounteredWorkarounds, enabledFeatures);
 }
 
 void Device::wrap(Instance& instance, const VkPhysicalDevice physicalDevice, const VkDevice handle, const Version version, const std::initializer_list<Containers::StringView> enabledExtensions, const DeviceFeatures& enabledFeatures, const HandleFlags flags) {
@@ -782,8 +782,7 @@ Result Device::tryCreateInternal(Instance& instance, const DeviceCreateInfo& inf
 
     /* Initialize the enabled extension list and feature-, extension-,
        workaround-dependent function pointers */
-    initializeExtensions<const char*>({info->ppEnabledExtensionNames, info->enabledExtensionCount});
-    initialize(instance, version, encounteredWorkarounds, info._state->enabledFeatures | info._state->implicitFeatures);
+    initialize(instance, version, Containers::arrayView(info->ppEnabledExtensionNames, info->enabledExtensionCount), encounteredWorkarounds, info._state->enabledFeatures | info._state->implicitFeatures);
 
     /* Print a list of used workarounds */
     if(!info._state->quietLog) {
@@ -852,22 +851,20 @@ Result Device::tryCreateInternal(Instance& instance, const DeviceCreateInfo& inf
     return Result::Success;
 }
 
-template<class T> void Device::initializeExtensions(const Containers::ArrayView<const T> enabledExtensions) {
+void Device::initialize(Instance& instance, const Version version, const Containers::StringIterable& enabledExtensions, Containers::Array<std::pair<Containers::StringView, bool>>& encounteredWorkarounds, const DeviceFeatures& enabledFeatures) {
     /* Mark all known extensions as enabled */
-    for(const T extension: enabledExtensions) {
+    for(const Containers::StringView extension: enabledExtensions) {
         for(const Version version: KnownVersionsForExtensions) {
             const Containers::ArrayView<const Extension> knownExtensions =
                 Extension::extensions(version);
-            const auto found = std::lower_bound(knownExtensions.begin(), knownExtensions.end(), extension, [](const Extension& a, const T& b) {
-                return a.string() < static_cast<const Containers::StringView&>(b);
+            const auto found = std::lower_bound(knownExtensions.begin(), knownExtensions.end(), extension, [](const Extension& a, Containers::StringView b) {
+                return a.string() < b;
             });
             if(found == knownExtensions.end() || found->string() != extension) continue;
             _enabledExtensions.set(found->index(), true);
         }
     }
-}
 
-void Device::initialize(Instance& instance, const Version version, Containers::Array<std::pair<Containers::StringView, bool>>& encounteredWorkarounds, const DeviceFeatures& enabledFeatures) {
     /* Init version, features, function pointers */
     _version = version;
     _enabledFeatures = enabledFeatures;
diff --git a/src/Magnum/Vk/Device.h b/src/Magnum/Vk/Device.h
index 0e071e676..93e5019da 100644
--- a/src/Magnum/Vk/Device.h
+++ b/src/Magnum/Vk/Device.h
@@ -502,8 +502,7 @@ class MAGNUM_VK_EXPORT Device {
            tryCreate(Instance&, DeviceCreateInfo&&) */
         Result tryCreateInternal(Instance& isntance, const DeviceCreateInfo&, DeviceProperties&&);
 
-        template<class T> MAGNUM_VK_LOCAL void initializeExtensions(Containers::ArrayView<const T> enabledExtensions);
-        MAGNUM_VK_LOCAL void initialize(Instance& instance, Version version, Containers::Array<std::pair<Containers::StringView, bool>>& encounteredWorkarounds, const DeviceFeatures& enabledFeatures);
+        MAGNUM_VK_LOCAL void initialize(Instance& instance, Version version, const Containers::StringIterable& enabledExtensions, Containers::Array<std::pair<Containers::StringView, bool>>& encounteredWorkarounds, const DeviceFeatures& enabledFeatures);
 
         MAGNUM_VK_LOCAL static void getQueueImplementationDefault(Device& self, const VkDeviceQueueInfo2& info, VkQueue& queue);
         MAGNUM_VK_LOCAL static void getQueueImplementation11(Device& self, const VkDeviceQueueInfo2& info, VkQueue& queue);
diff --git a/src/Magnum/Vk/Instance.cpp b/src/Magnum/Vk/Instance.cpp
index f34e69c84..d8b628526 100644
--- a/src/Magnum/Vk/Instance.cpp
+++ b/src/Magnum/Vk/Instance.cpp
@@ -30,6 +30,7 @@
 #include <Corrade/Containers/Optional.h>
 #include <Corrade/Containers/GrowableArray.h>
 #include <Corrade/Containers/String.h>
+#include <Corrade/Containers/StringIterable.h>
 #include <Corrade/Containers/StringView.h>
 #include <Corrade/Utility/Arguments.h>
 
@@ -272,8 +273,7 @@ void Instance::wrap(const VkInstance handle, const Version version, const Contai
        repeating what was passed to the constructor */
     _handle = handle;
     _flags = flags;
-    initializeExtensions(enabledExtensions);
-    initialize(version, 0, nullptr);
+    initialize(version, enabledExtensions, 0, nullptr);
 }
 
 void Instance::wrap(const VkInstance handle, const Version version, const std::initializer_list<Containers::StringView> enabledExtensions, const HandleFlags flags) {
@@ -333,11 +333,10 @@ Result Instance::tryCreate(const InstanceCreateInfo& info) {
         return Result(result);
     }
 
-    initializeExtensions<const char*>({info->ppEnabledExtensionNames, info->enabledExtensionCount});
     if(info._state)
-        initialize(version, info._state->argc, info._state->argv);
+        initialize(version, Containers::arrayView(info->ppEnabledExtensionNames, info->enabledExtensionCount), info._state->argc, info._state->argv);
     else
-        initialize(version, 0, nullptr);
+        initialize(version, Containers::arrayView(info->ppEnabledExtensionNames, info->enabledExtensionCount), 0, nullptr);
 
     return Result::Success;
 }
@@ -346,25 +345,23 @@ Result Instance::tryCreate() {
     return tryCreate(InstanceCreateInfo{});
 }
 
-template<class T> void Instance::initializeExtensions(const Containers::ArrayView<const T> enabledExtensions) {
+void Instance::initialize(const Version version, const Containers::StringIterable& enabledExtensions, const Int argc, const char* const* const argv) {
     /* Mark all known extensions as enabled */
-    for(const T extension: enabledExtensions) {
+    for(const Containers::StringView extension: enabledExtensions) {
         for(Containers::ArrayView<const InstanceExtension> knownExtensions: {
             InstanceExtension::extensions(Version::None),
           /*InstanceExtension::extensions(Version::Vk10), is empty */
             InstanceExtension::extensions(Version::Vk11),
           /*InstanceExtension::extensions(Version::Vk12) is empty */
         }) {
-            const auto found = std::lower_bound(knownExtensions.begin(), knownExtensions.end(), extension, [](const InstanceExtension& a, const T& b) {
-                return a.string() < static_cast<const Containers::StringView&>(b);
+            const auto found = std::lower_bound(knownExtensions.begin(), knownExtensions.end(), extension, [](const InstanceExtension& a, Containers::StringView b) {
+                return a.string() < b;
             });
             if(found == knownExtensions.end() || found->string() != extension) continue;
             _extensionStatus.set(found->index(), true);
         }
     }
-}
 
-void Instance::initialize(const Version version, const Int argc, const char* const* const argv) {
     /* Init version, function pointers */
     _version = version;
     flextVkInitInstance(_handle, &_functionPointers);
diff --git a/src/Magnum/Vk/Instance.h b/src/Magnum/Vk/Instance.h
index 987f7c3f0..af9ae28d8 100644
--- a/src/Magnum/Vk/Instance.h
+++ b/src/Magnum/Vk/Instance.h
@@ -435,8 +435,7 @@ class MAGNUM_VK_EXPORT Instance {
         Implementation::InstanceState& state() { return *_state; }
 
     private:
-        template<class T> MAGNUM_VK_LOCAL void initializeExtensions(Containers::ArrayView<const T> enabledExtensions);
-        MAGNUM_VK_LOCAL void initialize(Version version, Int argc, const char* const* argv);
+        MAGNUM_VK_LOCAL void initialize(Version version, const Containers::StringIterable& enabledExtensions, Int argc, const char* const* argv);
 
         VkInstance _handle;
         HandleFlags _flags;