diff --git a/src/tint/cmd/tint/main.cc b/src/tint/cmd/tint/main.cc
index 81a9e5b..4d18bb9 100644
--- a/src/tint/cmd/tint/main.cc
+++ b/src/tint/cmd/tint/main.cc
@@ -178,6 +178,10 @@
 
     tint::Vector<std::string, 4> transforms;
 
+#if TINT_BUILD_SPV_WRITER
+    bool use_storage_input_output_16 = true;
+#endif  // TINT_BULD_SPV_WRITER
+
 #if TINT_BUILD_HLSL_WRITER
     std::string fxc_path;
     std::string dxc_path;
@@ -345,6 +349,13 @@
     });
 #endif
 
+#if TINT_BUILD_SPV_WRITER
+    auto& use_storage_input_output_16 =
+        options.Add<BoolOption>("use-storage-input-output-16",
+                                "Use the StorageInputOutput16 SPIR-V capability", Default{true});
+    TINT_DEFER(opts->use_storage_input_output_16 = *use_storage_input_output_16.value);
+#endif
+
     auto& disable_wg_init = options.Add<BoolOption>(
         "disable-workgroup-init", "Disable workgroup memory zero initialization", Default{false});
     TINT_DEFER(opts->disable_workgroup_init = *disable_wg_init.value);
@@ -687,6 +698,7 @@
     tint::spirv::writer::Options gen_options;
     gen_options.disable_robustness = !options.enable_robustness;
     gen_options.disable_workgroup_init = options.disable_workgroup_init;
+    gen_options.use_storage_input_output_16 = options.use_storage_input_output_16;
     gen_options.bindings = tint::spirv::writer::GenerateBindings(program);
 
     tint::Result<tint::spirv::writer::Output> result;
@@ -1067,9 +1079,13 @@
 
         gen_options.texture_builtins_from_uniform = std::move(textureBuiltinsFromUniform);
 
-        // Place the first_instance push constant member after user-defined push constants (if any).
-        gen_options.first_instance_offset =
-            inspector.GetEntryPoint(entry_point_name).push_constant_size;
+        auto entry_point = inspector.GetEntryPoint(entry_point_name);
+
+        if (entry_point.instance_index_used) {
+            // Place the first_instance push constant member after user-defined push constants (if
+            // any).
+            gen_options.first_instance_offset = entry_point.push_constant_size;
+        }
 
         auto result = tint::glsl::writer::Generate(prg, gen_options, entry_point_name);
         if (result != tint::Success) {
diff --git a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
index a9c8c31..326c1a2 100644
--- a/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/ast_printer.cc
@@ -347,6 +347,7 @@
 
     if (version_.IsES() && requires_default_precision_qualifier_) {
         current_buffer_->Insert("precision highp float;", helpers_insertion_point++, indent);
+        current_buffer_->Insert("precision highp int;", helpers_insertion_point++, indent);
     }
 
     if (!helpers_.lines.empty()) {
diff --git a/src/tint/lang/glsl/writer/ast_printer/function_test.cc b/src/tint/lang/glsl/writer/ast_printer/function_test.cc
index 32a8b0f..a04b329 100644
--- a/src/tint/lang/glsl/writer/ast_printer/function_test.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/function_test.cc
@@ -113,6 +113,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 void func() {
   return;
@@ -160,6 +161,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 layout(location = 0) in float foo_1;
 layout(location = 1) out float value;
@@ -200,6 +202,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 float frag_main(vec4 coord) {
   return coord.x;
@@ -252,6 +255,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 layout(location = 1) out float col1_1;
 layout(location = 2) out float col2_1;
@@ -391,6 +395,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct UBO {
   vec4 coord;
@@ -432,6 +437,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Uniforms {
   vec4 coord;
@@ -473,6 +479,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   int a;
@@ -521,6 +528,7 @@
     EXPECT_EQ(gen.Result(),
               R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   int a;
@@ -566,6 +574,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   int a;
@@ -611,6 +620,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   int a;
@@ -658,6 +668,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct S {
   float x;
@@ -705,6 +716,7 @@
     EXPECT_EQ(gen.Result(),
               R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct S {
   float x;
@@ -741,6 +753,7 @@
     EXPECT_THAT(gen.Diagnostics(), testing::IsEmpty());
     EXPECT_EQ(gen.Result(), R"(#version 310 es
 precision highp float;
+precision highp int;
 
 void tint_symbol() {
 }
diff --git a/src/tint/lang/glsl/writer/ast_printer/member_accessor_test.cc b/src/tint/lang/glsl/writer/ast_printer/member_accessor_test.cc
index ef7e638..302d899 100644
--- a/src/tint/lang/glsl/writer/ast_printer/member_accessor_test.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/member_accessor_test.cc
@@ -298,6 +298,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   int a;
@@ -351,6 +352,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   float z;
@@ -399,6 +401,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   float z;
@@ -447,6 +450,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   float z;
@@ -494,6 +498,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Data {
   float z;
@@ -547,6 +552,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   vec3 a;
@@ -608,6 +614,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   vec3 a;
@@ -670,6 +677,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   vec3 a;
@@ -731,6 +739,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   vec3 a;
@@ -791,6 +800,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   vec3 a;
@@ -852,6 +862,7 @@
     auto* expected =
         R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct Inner {
   ivec3 a;
diff --git a/src/tint/lang/glsl/writer/ast_printer/sanitizer_test.cc b/src/tint/lang/glsl/writer/ast_printer/sanitizer_test.cc
index 83a653c..0cd03ab 100644
--- a/src/tint/lang/glsl/writer/ast_printer/sanitizer_test.cc
+++ b/src/tint/lang/glsl/writer/ast_printer/sanitizer_test.cc
@@ -60,6 +60,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float a[];
@@ -100,6 +101,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float z;
@@ -144,6 +146,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 layout(binding = 1, std430) buffer my_struct_ssbo {
   float a[];
@@ -181,6 +184,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 void tint_symbol() {
   int idx = 3;
@@ -223,6 +227,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 struct S {
   int a;
@@ -269,6 +274,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 void tint_symbol() {
   int v = 0;
@@ -314,6 +320,7 @@
     auto got = gen.Result();
     auto* expect = R"(#version 310 es
 precision highp float;
+precision highp int;
 
 void tint_symbol() {
   mat4 a[4] = mat4[4](mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f), mat4(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
diff --git a/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc b/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
index d9eee77..9c58491 100644
--- a/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/ast_builtin_test.cc
@@ -1722,7 +1722,6 @@
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
 OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16
 %15 = OpExtInstImport "GLSL.std.450"
 OpMemoryModel Logical GLSL450
 OpEntryPoint Fragment %3 "a_func"
@@ -1822,7 +1821,6 @@
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
 OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16
 OpMemoryModel Logical GLSL450
 OpEntryPoint Fragment %3 "a_func"
 OpExecutionMode %3 OriginUpperLeft
@@ -1928,7 +1926,6 @@
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
 OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16
 %17 = OpExtInstImport "GLSL.std.450"
 OpMemoryModel Logical GLSL450
 OpEntryPoint Fragment %3 "a_func"
@@ -2031,7 +2028,6 @@
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
 OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16
 OpMemoryModel Logical GLSL450
 OpEntryPoint Fragment %3 "a_func"
 OpExecutionMode %3 OriginUpperLeft
diff --git a/src/tint/lang/spirv/writer/ast_printer/ast_printer.cc b/src/tint/lang/spirv/writer/ast_printer/ast_printer.cc
index d76a591..4272172 100644
--- a/src/tint/lang/spirv/writer/ast_printer/ast_printer.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/ast_printer.cc
@@ -188,7 +188,7 @@
     data.Add<ast::transform::CanonicalizeEntryPointIO::Config>(
         ast::transform::CanonicalizeEntryPointIO::Config(
             ast::transform::CanonicalizeEntryPointIO::ShaderStyle::kSpirv, 0xFFFFFFFF,
-            options.emit_vertex_point_size));
+            options.emit_vertex_point_size, !options.use_storage_input_output_16));
 
     SanitizedResult result;
     ast::transform::DataMap outputs;
diff --git a/src/tint/lang/spirv/writer/ast_printer/binary_expression_test.cc b/src/tint/lang/spirv/writer/ast_printer/binary_expression_test.cc
index 15e4fb2..570448e 100644
--- a/src/tint/lang/spirv/writer/ast_printer/binary_expression_test.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/binary_expression_test.cc
@@ -1344,8 +1344,7 @@
             return R"(OpCapability Shader
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
-OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16)";
+OpCapability StorageBuffer16BitAccess)";
     }
     return {};
 }
@@ -1639,8 +1638,7 @@
             return R"(OpCapability Shader
 OpCapability Float16
 OpCapability UniformAndStorageBuffer16BitAccess
-OpCapability StorageBuffer16BitAccess
-OpCapability StorageInputOutput16)";
+OpCapability StorageBuffer16BitAccess)";
     }
     return {};
 }
diff --git a/src/tint/lang/spirv/writer/ast_printer/builder.cc b/src/tint/lang/spirv/writer/ast_printer/builder.cc
index eb393ca..67d829d 100644
--- a/src/tint/lang/spirv/writer/ast_printer/builder.cc
+++ b/src/tint/lang/spirv/writer/ast_printer/builder.cc
@@ -350,7 +350,6 @@
             module_.PushCapability(SpvCapabilityFloat16);
             module_.PushCapability(SpvCapabilityUniformAndStorageBuffer16BitAccess);
             module_.PushCapability(SpvCapabilityStorageBuffer16BitAccess);
-            module_.PushCapability(SpvCapabilityStorageInputOutput16);
             break;
         default:
             return false;
@@ -739,6 +738,13 @@
         return false;
     }
 
+    // Emit the StorageInputOutput16 capability if needed.
+    if (sc == core::AddressSpace::kIn || sc == core::AddressSpace::kOut) {
+        if (type->DeepestElement()->Is<core::type::F16>()) {
+            module_.PushCapability(SpvCapabilityStorageInputOutput16);
+        }
+    }
+
     module_.PushDebug(spv::Op::OpName, {Operand(var_id), Operand(v->name->symbol.Name())});
 
     OperandList ops = {Operand(type_id), result, U32Operand(ConvertAddressSpace(sc))};
diff --git a/src/tint/lang/spirv/writer/common/options.h b/src/tint/lang/spirv/writer/common/options.h
index e16b267..f7fdee7 100644
--- a/src/tint/lang/spirv/writer/common/options.h
+++ b/src/tint/lang/spirv/writer/common/options.h
@@ -141,6 +141,9 @@
     /// VK_KHR_zero_initialize_workgroup_memory is enabled.
     bool use_zero_initialize_workgroup_memory_extension = false;
 
+    /// Set to `true` to use the StorageInputOutput16 capability for shader IO that uses f16 types.
+    bool use_storage_input_output_16 = true;
+
     /// Set to `true` to generate a PointSize builtin and have it set to 1.0
     /// from all vertex shaders in the module.
     bool emit_vertex_point_size = true;
@@ -172,6 +175,7 @@
                  disable_runtime_sized_array_index_clamping,
                  disable_workgroup_init,
                  use_zero_initialize_workgroup_memory_extension,
+                 use_storage_input_output_16,
                  emit_vertex_point_size,
                  clamp_frag_depth,
                  pass_matrix_by_pointer,
diff --git a/src/tint/lang/spirv/writer/function_test.cc b/src/tint/lang/spirv/writer/function_test.cc
index 2658f3f..bb68130 100644
--- a/src/tint/lang/spirv/writer/function_test.cc
+++ b/src/tint/lang/spirv/writer/function_test.cc
@@ -346,6 +346,118 @@
 )");
 }
 
+TEST_F(SpirvWriterTest, Function_ShaderIO_F16_Input_WithCapability) {
+    auto* input = b.FunctionParam("input", ty.vec4<f16>());
+    input->SetLocation(1, std::nullopt);
+    auto* func = b.Function("main", ty.vec4<f32>(), core::ir::Function::PipelineStage::kFragment);
+    func->SetReturnLocation(2, std::nullopt);
+    func->SetParams({input});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Convert(ty.vec4<f32>(), input));
+    });
+
+    Options options;
+    options.use_storage_input_output_16 = true;
+    ASSERT_TRUE(Generate(options)) << Error() << output_;
+    EXPECT_INST("OpCapability StorageInputOutput16");
+    EXPECT_INST(R"(OpEntryPoint Fragment %main "main" %main_loc1_Input %main_loc2_Output)");
+    EXPECT_INST("%main_loc1_Input = OpVariable %_ptr_Input_v4half Input");
+    EXPECT_INST("%main_loc2_Output = OpVariable %_ptr_Output_v4float Output");
+    EXPECT_INST(R"(
+       %main = OpFunction %void None %16
+         %17 = OpLabel
+         %18 = OpLoad %v4half %main_loc1_Input
+         %19 = OpFunctionCall %v4float %main_inner %18
+               OpStore %main_loc2_Output %19
+               OpReturn
+               OpFunctionEnd
+)");
+}
+
+TEST_F(SpirvWriterTest, Function_ShaderIO_F16_Input_WithoutCapability) {
+    auto* input = b.FunctionParam("input", ty.vec4<f16>());
+    input->SetLocation(1, std::nullopt);
+    auto* func = b.Function("main", ty.vec4<f32>(), core::ir::Function::PipelineStage::kFragment);
+    func->SetReturnLocation(2, std::nullopt);
+    func->SetParams({input});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Convert(ty.vec4<f32>(), input));
+    });
+
+    Options options;
+    options.use_storage_input_output_16 = false;
+    ASSERT_TRUE(Generate(options)) << Error() << output_;
+    EXPECT_INST(R"(OpEntryPoint Fragment %main "main" %main_loc1_Input %main_loc2_Output)");
+    EXPECT_INST("%main_loc1_Input = OpVariable %_ptr_Input_v4float Input");
+    EXPECT_INST("%main_loc2_Output = OpVariable %_ptr_Output_v4float Output");
+    EXPECT_INST(R"(
+       %main = OpFunction %void None %16
+         %17 = OpLabel
+         %18 = OpLoad %v4float %main_loc1_Input
+         %19 = OpFConvert %v4half %18
+         %20 = OpFunctionCall %v4float %main_inner %19
+               OpStore %main_loc2_Output %20
+               OpReturn
+               OpFunctionEnd
+)");
+}
+
+TEST_F(SpirvWriterTest, Function_ShaderIO_F16_Output_WithCapability) {
+    auto* input = b.FunctionParam("input", ty.vec4<f32>());
+    input->SetLocation(1, std::nullopt);
+    auto* func = b.Function("main", ty.vec4<f16>(), core::ir::Function::PipelineStage::kFragment);
+    func->SetReturnLocation(2, std::nullopt);
+    func->SetParams({input});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Convert(ty.vec4<f16>(), input));
+    });
+
+    Options options;
+    options.use_storage_input_output_16 = true;
+    ASSERT_TRUE(Generate(options)) << Error() << output_;
+    EXPECT_INST("OpCapability StorageInputOutput16");
+    EXPECT_INST(R"(OpEntryPoint Fragment %main "main" %main_loc1_Input %main_loc2_Output)");
+    EXPECT_INST("%main_loc1_Input = OpVariable %_ptr_Input_v4float Input");
+    EXPECT_INST("%main_loc2_Output = OpVariable %_ptr_Output_v4half Output");
+    EXPECT_INST(R"(
+       %main = OpFunction %void None %16
+         %17 = OpLabel
+         %18 = OpLoad %v4float %main_loc1_Input
+         %19 = OpFunctionCall %v4half %main_inner %18
+               OpStore %main_loc2_Output %19
+               OpReturn
+               OpFunctionEnd
+)");
+}
+
+TEST_F(SpirvWriterTest, Function_ShaderIO_F16_Output_WithoutCapability) {
+    auto* input = b.FunctionParam("input", ty.vec4<f32>());
+    input->SetLocation(1, std::nullopt);
+    auto* func = b.Function("main", ty.vec4<f16>(), core::ir::Function::PipelineStage::kFragment);
+    func->SetReturnLocation(2, std::nullopt);
+    func->SetParams({input});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Convert(ty.vec4<f16>(), input));
+    });
+
+    Options options;
+    options.use_storage_input_output_16 = false;
+    ASSERT_TRUE(Generate(options)) << Error() << output_;
+    EXPECT_INST(R"(OpEntryPoint Fragment %main "main" %main_loc1_Input %main_loc2_Output)");
+    EXPECT_INST("%main_loc1_Input = OpVariable %_ptr_Input_v4float Input");
+    EXPECT_INST("%main_loc2_Output = OpVariable %_ptr_Output_v4float Output");
+    EXPECT_INST(R"(
+       %main = OpFunction %void None %16
+         %17 = OpLabel
+         %18 = OpLoad %v4float %main_loc1_Input
+         %19 = OpFunctionCall %v4half %main_inner %18
+         %20 = OpFConvert %v4float %19
+               OpStore %main_loc2_Output %20
+               OpReturn
+               OpFunctionEnd
+)");
+}
+
 TEST_F(SpirvWriterTest, Function_ShaderIO_DualSourceBlend) {
     auto* outputs =
         ty.Struct(mod.symbols.New("Outputs"), {
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index ef41faf..9fc98fd 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -493,7 +493,6 @@
                     module_.PushCapability(SpvCapabilityFloat16);
                     module_.PushCapability(SpvCapabilityUniformAndStorageBuffer16BitAccess);
                     module_.PushCapability(SpvCapabilityStorageBuffer16BitAccess);
-                    module_.PushCapability(SpvCapabilityStorageInputOutput16);
                     module_.PushType(spv::Op::OpTypeFloat, {id, 16u});
                 },
                 [&](const core::type::Vector* vec) {
@@ -2065,6 +2064,9 @@
             }
             case core::AddressSpace::kIn: {
                 TINT_ASSERT(!current_function_);
+                if (store_ty->DeepestElement()->Is<core::type::F16>()) {
+                    module_.PushCapability(SpvCapabilityStorageInputOutput16);
+                }
                 module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassInput)});
                 EmitIOAttributes(id, var->Attributes(), core::AddressSpace::kIn);
                 break;
@@ -2089,6 +2091,9 @@
             }
             case core::AddressSpace::kOut: {
                 TINT_ASSERT(!current_function_);
+                if (store_ty->DeepestElement()->Is<core::type::F16>()) {
+                    module_.PushCapability(SpvCapabilityStorageInputOutput16);
+                }
                 module_.PushType(spv::Op::OpVariable, {ty, id, U32Operand(SpvStorageClassOutput)});
                 EmitIOAttributes(id, var->Attributes(), core::AddressSpace::kOut);
                 break;
diff --git a/src/tint/lang/spirv/writer/raise/raise.cc b/src/tint/lang/spirv/writer/raise/raise.cc
index 70d4669..bbaeb1f 100644
--- a/src/tint/lang/spirv/writer/raise/raise.cc
+++ b/src/tint/lang/spirv/writer/raise/raise.cc
@@ -144,7 +144,8 @@
     RUN_TRANSFORM(raise::HandleMatrixArithmetic, module);
     RUN_TRANSFORM(raise::MergeReturn, module);
     RUN_TRANSFORM(raise::ShaderIO, module,
-                  raise::ShaderIOConfig{options.clamp_frag_depth, options.emit_vertex_point_size});
+                  raise::ShaderIOConfig{options.clamp_frag_depth, options.emit_vertex_point_size,
+                                        !options.use_storage_input_output_16});
     RUN_TRANSFORM(core::ir::transform::Std140, module);
     RUN_TRANSFORM(raise::VarForDynamicIndex, module);
 
diff --git a/src/tint/lang/spirv/writer/raise/shader_io.cc b/src/tint/lang/spirv/writer/raise/shader_io.cc
index 8266f23..ddb311b 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io.cc
+++ b/src/tint/lang/spirv/writer/raise/shader_io.cc
@@ -112,8 +112,19 @@
             }
             name << name_suffix;
 
+            // Replace f16 types with f32 types if necessary.
+            auto* store_type = io.type;
+            if (config.polyfill_f16_io) {
+                if (store_type->DeepestElement()->Is<core::type::F16>()) {
+                    store_type = ty.f32();
+                    if (auto* vec = io.type->As<core::type::Vector>()) {
+                        store_type = ty.vec(store_type, vec->Width());
+                    }
+                }
+            }
+
             // Create an IO variable and add it to the root block.
-            auto* ptr = ty.ptr(addrspace, io.type, access);
+            auto* ptr = ty.ptr(addrspace, store_type, access);
             auto* var = b.Var(name.str(), ptr);
             var->SetAttributes(core::ir::IOAttributes{
                 io.attributes.location,
@@ -150,7 +161,15 @@
                 from = builder.Access(ptr, input_vars[idx], 0_u)->Result(0);
             }
         }
-        return builder.Load(from)->Result(0);
+
+        auto* value = builder.Load(from)->Result(0);
+
+        // Convert f32 values to f16 values if needed.
+        if (config.polyfill_f16_io && inputs[idx].type->DeepestElement()->Is<core::type::F16>()) {
+            value = builder.Convert(inputs[idx].type, value)->Result(0);
+        }
+
+        return value;
     }
 
     /// @copydoc ShaderIO::BackendState::SetOutput
@@ -169,6 +188,12 @@
                 value = ClampFragDepth(builder, value);
             }
         }
+
+        // Convert f16 values to f32 values if needed.
+        if (config.polyfill_f16_io && value->Type()->DeepestElement()->Is<core::type::F16>()) {
+            value = builder.Convert(to->Type()->UnwrapPtr(), value)->Result(0);
+        }
+
         builder.Store(to, value);
     }
 
diff --git a/src/tint/lang/spirv/writer/raise/shader_io.h b/src/tint/lang/spirv/writer/raise/shader_io.h
index 3ec521c..38cd9ad 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io.h
+++ b/src/tint/lang/spirv/writer/raise/shader_io.h
@@ -46,6 +46,8 @@
     bool clamp_frag_depth = false;
     /// true if a vertex point size builtin output should be added
     bool emit_vertex_point_size = false;
+    /// true if f16 IO types should be replaced with f32 types and converted
+    bool polyfill_f16_io = false;
 };
 
 /// ShaderIO is a transform that moves each entry point function's parameters and return value to
diff --git a/src/tint/lang/spirv/writer/raise/shader_io_test.cc b/src/tint/lang/spirv/writer/raise/shader_io_test.cc
index 5738a20..61d3ef7 100644
--- a/src/tint/lang/spirv/writer/raise/shader_io_test.cc
+++ b/src/tint/lang/spirv/writer/raise/shader_io_test.cc
@@ -1491,5 +1491,197 @@
     EXPECT_EQ(expect, str());
 }
 
+TEST_F(SpirvWriter_ShaderIOTest, F16_IO_WithoutPolyfill) {
+    auto* outputs =
+        ty.Struct(mod.symbols.New("Outputs"), {
+                                                  {
+                                                      mod.symbols.New("out1"),
+                                                      ty.f16(),
+                                                      core::type::StructMemberAttributes{
+                                                          /* location */ 1u,
+                                                          /* index */ std::nullopt,
+                                                          /* color */ std::nullopt,
+                                                          /* builtin */ std::nullopt,
+                                                          /* interpolation */ std::nullopt,
+                                                          /* invariant */ false,
+                                                      },
+                                                  },
+                                                  {
+                                                      mod.symbols.New("out2"),
+                                                      ty.vec4<f16>(),
+                                                      core::type::StructMemberAttributes{
+                                                          /* location */ 2u,
+                                                          /* index */ std::nullopt,
+                                                          /* color */ std::nullopt,
+                                                          /* builtin */ std::nullopt,
+                                                          /* interpolation */ std::nullopt,
+                                                          /* invariant */ false,
+                                                      },
+                                                  },
+                                              });
+
+    auto* in1 = b.FunctionParam("in1", ty.f16());
+    auto* in2 = b.FunctionParam("in2", ty.vec4<f16>());
+    in1->SetLocation(1, std::nullopt);
+    in1->SetLocation(2, std::nullopt);
+    auto* func = b.Function("main", outputs, core::ir::Function::PipelineStage::kFragment);
+    func->SetParams({in1, in2});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Construct(outputs, in1, in2));
+    });
+
+    auto* src = R"(
+Outputs = struct @align(8) {
+  out1:f16 @offset(0), @location(1)
+  out2:vec4<f16> @offset(8), @location(2)
+}
+
+%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs -> %b1 {
+  %b1 = block {
+    %4:Outputs = construct %in1, %in2
+    ret %4
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Outputs = struct @align(8) {
+  out1:f16 @offset(0)
+  out2:vec4<f16> @offset(8)
+}
+
+%b1 = block {  # root
+  %main_loc2_Input:ptr<__in, f16, read> = var @location(2)
+  %main_Input:ptr<__in, vec4<f16>, read> = var
+  %main_loc1_Output:ptr<__out, f16, write> = var @location(1)
+  %main_loc2_Output:ptr<__out, vec4<f16>, write> = var @location(2)
+}
+
+%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs -> %b2 {
+  %b2 = block {
+    %8:Outputs = construct %in1, %in2
+    ret %8
+  }
+}
+%main = @fragment func():void -> %b3 {
+  %b3 = block {
+    %10:f16 = load %main_loc2_Input
+    %11:vec4<f16> = load %main_Input
+    %12:Outputs = call %main_inner, %10, %11
+    %13:f16 = access %12, 0u
+    store %main_loc1_Output, %13
+    %14:vec4<f16> = access %12, 1u
+    store %main_loc2_Output, %14
+    ret
+  }
+}
+)";
+
+    ShaderIOConfig config;
+    config.polyfill_f16_io = false;
+    Run(ShaderIO, config);
+
+    EXPECT_EQ(expect, str());
+}
+
+TEST_F(SpirvWriter_ShaderIOTest, F16_IO_WithPolyfill) {
+    auto* outputs =
+        ty.Struct(mod.symbols.New("Outputs"), {
+                                                  {
+                                                      mod.symbols.New("out1"),
+                                                      ty.f16(),
+                                                      core::type::StructMemberAttributes{
+                                                          /* location */ 1u,
+                                                          /* index */ std::nullopt,
+                                                          /* color */ std::nullopt,
+                                                          /* builtin */ std::nullopt,
+                                                          /* interpolation */ std::nullopt,
+                                                          /* invariant */ false,
+                                                      },
+                                                  },
+                                                  {
+                                                      mod.symbols.New("out2"),
+                                                      ty.vec4<f16>(),
+                                                      core::type::StructMemberAttributes{
+                                                          /* location */ 2u,
+                                                          /* index */ std::nullopt,
+                                                          /* color */ std::nullopt,
+                                                          /* builtin */ std::nullopt,
+                                                          /* interpolation */ std::nullopt,
+                                                          /* invariant */ false,
+                                                      },
+                                                  },
+                                              });
+
+    auto* in1 = b.FunctionParam("in1", ty.f16());
+    auto* in2 = b.FunctionParam("in2", ty.vec4<f16>());
+    in1->SetLocation(1, std::nullopt);
+    in1->SetLocation(2, std::nullopt);
+    auto* func = b.Function("main", outputs, core::ir::Function::PipelineStage::kFragment);
+    func->SetParams({in1, in2});
+    b.Append(func->Block(), [&] {  //
+        b.Return(func, b.Construct(outputs, in1, in2));
+    });
+
+    auto* src = R"(
+Outputs = struct @align(8) {
+  out1:f16 @offset(0), @location(1)
+  out2:vec4<f16> @offset(8), @location(2)
+}
+
+%main = @fragment func(%in1:f16 [@location(2)], %in2:vec4<f16>):Outputs -> %b1 {
+  %b1 = block {
+    %4:Outputs = construct %in1, %in2
+    ret %4
+  }
+}
+)";
+    EXPECT_EQ(src, str());
+
+    auto* expect = R"(
+Outputs = struct @align(8) {
+  out1:f16 @offset(0)
+  out2:vec4<f16> @offset(8)
+}
+
+%b1 = block {  # root
+  %main_loc2_Input:ptr<__in, f32, read> = var @location(2)
+  %main_Input:ptr<__in, vec4<f32>, read> = var
+  %main_loc1_Output:ptr<__out, f32, write> = var @location(1)
+  %main_loc2_Output:ptr<__out, vec4<f32>, write> = var @location(2)
+}
+
+%main_inner = func(%in1:f16, %in2:vec4<f16>):Outputs -> %b2 {
+  %b2 = block {
+    %8:Outputs = construct %in1, %in2
+    ret %8
+  }
+}
+%main = @fragment func():void -> %b3 {
+  %b3 = block {
+    %10:f32 = load %main_loc2_Input
+    %11:f16 = convert %10
+    %12:vec4<f32> = load %main_Input
+    %13:vec4<f16> = convert %12
+    %14:Outputs = call %main_inner, %11, %13
+    %15:f16 = access %14, 0u
+    %16:f32 = convert %15
+    store %main_loc1_Output, %16
+    %17:vec4<f16> = access %14, 1u
+    %18:vec4<f32> = convert %17
+    store %main_loc2_Output, %18
+    ret
+  }
+}
+)";
+
+    ShaderIOConfig config;
+    config.polyfill_f16_io = true;
+    Run(ShaderIO, config);
+
+    EXPECT_EQ(expect, str());
+}
+
 }  // namespace
 }  // namespace tint::spirv::writer::raise
diff --git a/src/tint/lang/spirv/writer/type_test.cc b/src/tint/lang/spirv/writer/type_test.cc
index 08fd086..27fdc1b 100644
--- a/src/tint/lang/spirv/writer/type_test.cc
+++ b/src/tint/lang/spirv/writer/type_test.cc
@@ -98,7 +98,6 @@
     EXPECT_INST("OpCapability Float16");
     EXPECT_INST("OpCapability UniformAndStorageBuffer16BitAccess");
     EXPECT_INST("OpCapability StorageBuffer16BitAccess");
-    EXPECT_INST("OpCapability StorageInputOutput16");
     EXPECT_INST("%half = OpTypeFloat 16");
 }
 
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
index 842e41b..db9a682 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.cc
@@ -339,6 +339,17 @@
                     value = b.IndexAccessor(value, 0_i);
                 }
             }
+
+            // Replace f16 types with f32 types if necessary.
+            if (cfg.polyfill_f16_io && type->DeepestElement()->Is<core::type::F16>()) {
+                value = b.Call(ast_type, value);
+
+                ast_type = b.ty.f32();
+                if (auto* vec = type->As<core::type::Vector>()) {
+                    ast_type = b.ty.vec(ast_type, vec->Width());
+                }
+            }
+
             b.GlobalVar(symbol, ast_type, core::AddressSpace::kIn, std::move(attrs));
             return value;
         } else if (cfg.shader_style == ShaderStyle::kMsl &&
@@ -406,9 +417,27 @@
             }
         }
 
+        ast::Type ast_type;
+
+        // Replace f16 types with f32 types if necessary.
+        if (cfg.shader_style == ShaderStyle::kSpirv && cfg.polyfill_f16_io &&
+            type->DeepestElement()->Is<core::type::F16>()) {
+            auto make_ast_type = [&] {
+                auto ty = b.ty.f32();
+                if (auto* vec = type->As<core::type::Vector>()) {
+                    ty = b.ty.vec(ty, vec->Width());
+                }
+                return ty;
+            };
+            ast_type = make_ast_type();
+            value = b.Call(make_ast_type(), value);
+        } else {
+            ast_type = CreateASTTypeFor(ctx, type);
+        }
+
         OutputValue output;
         output.name = name;
-        output.type = CreateASTTypeFor(ctx, type);
+        output.type = ast_type;
         output.attributes = std::move(attrs);
         output.value = value;
         output.location = location;
@@ -984,10 +1013,12 @@
 
 CanonicalizeEntryPointIO::Config::Config(ShaderStyle style,
                                          uint32_t sample_mask,
-                                         bool emit_point_size)
+                                         bool emit_point_size,
+                                         bool polyfill_f16)
     : shader_style(style),
       fixed_sample_mask(sample_mask),
-      emit_vertex_point_size(emit_point_size) {}
+      emit_vertex_point_size(emit_point_size),
+      polyfill_f16_io(polyfill_f16) {}
 
 CanonicalizeEntryPointIO::Config::Config(const Config&) = default;
 CanonicalizeEntryPointIO::Config::~Config() = default;
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
index d63d479..ddf761d 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io.h
@@ -118,9 +118,11 @@
         /// @param style the approach to use for emitting shader IO.
         /// @param sample_mask an optional sample mask to combine with shader masks
         /// @param emit_vertex_point_size `true` to generate a pointsize builtin
+        /// @param polyfill_f16_io `true` to replace f16 types with f32 types
         explicit Config(ShaderStyle style,
                         uint32_t sample_mask = 0xFFFFFFFF,
-                        bool emit_vertex_point_size = false);
+                        bool emit_vertex_point_size = false,
+                        bool polyfill_f16_io = false);
 
         /// Copy constructor
         Config(const Config&);
@@ -137,6 +139,9 @@
         /// Set to `true` to generate a pointsize builtin and have it set to 1.0
         /// from all vertex shaders in the module.
         const bool emit_vertex_point_size;
+
+        /// Set to `true` to replace f16 IO types with f32 types and convert them.
+        const bool polyfill_f16_io = false;
     };
 
     /// HLSLWaveIntrinsic is an InternalAttribute that is used to decorate a stub function so that
diff --git a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_test.cc b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_test.cc
index 7c33b29..ec83e9e 100644
--- a/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/canonicalize_entry_point_io_test.cc
@@ -4420,5 +4420,60 @@
     EXPECT_EQ(expect, str(got));
 }
 
+TEST_F(CanonicalizeEntryPointIOTest, F16_Polyfill_Spirv) {
+    auto* src = R"(
+enable f16;
+
+struct Outputs {
+  @location(1) a : f16,
+  @location(2) b : vec4<f16>,
+}
+
+@fragment
+fn frag_main(@location(1) loc1 : f16,
+             @location(2) loc2 : vec4<f16>) -> Outputs {
+  return Outputs(loc1 * 2, loc2 * 3);
+}
+)";
+
+    auto* expect = R"(
+enable f16;
+
+@location(1) @internal(disable_validation__ignore_address_space) var<__in> loc1_1 : f32;
+
+@location(2) @internal(disable_validation__ignore_address_space) var<__in> loc2_1 : vec4<f32>;
+
+@location(1) @internal(disable_validation__ignore_address_space) var<__out> a_1 : f32;
+
+@location(2) @internal(disable_validation__ignore_address_space) var<__out> b_1 : vec4<f32>;
+
+struct Outputs {
+  a : f16,
+  b : vec4<f16>,
+}
+
+fn frag_main_inner(loc1 : f16, loc2 : vec4<f16>) -> Outputs {
+  return Outputs((loc1 * 2), (loc2 * 3));
+}
+
+@fragment
+fn frag_main() {
+  let inner_result = frag_main_inner(f16(loc1_1), vec4<f16>(loc2_1));
+  a_1 = f32(inner_result.a);
+  b_1 = vec4<f32>(inner_result.b);
+}
+)";
+
+    DataMap data;
+
+    data.Add<CanonicalizeEntryPointIO::Config>(CanonicalizeEntryPointIO::ShaderStyle::kSpirv,
+                                               /* fixed_sample_mask */ 0xFFFFFFFF,
+                                               /* emit_vertex_point_size */ false,
+                                               /* polyfill_f16_io */ true);
+    auto got = Run<Unshadow, CanonicalizeEntryPointIO>(src, data);
+
+    EXPECT_EQ(expect, str(got));
+}
+
 }  // namespace
 }  // namespace tint::ast::transform
diff --git a/src/tint/lang/wgsl/ast/transform/offset_first_index.cc b/src/tint/lang/wgsl/ast/transform/offset_first_index.cc
index 04bdd9a..143b43f 100644
--- a/src/tint/lang/wgsl/ast/transform/offset_first_index.cc
+++ b/src/tint/lang/wgsl/ast/transform/offset_first_index.cc
@@ -53,15 +53,6 @@
 constexpr char kFirstVertexName[] = "first_vertex";
 constexpr char kFirstInstanceName[] = "first_instance";
 
-bool ShouldRun(const Program& program) {
-    for (auto* fn : program.AST().Functions()) {
-        if (fn->PipelineStage() == PipelineStage::kVertex) {
-            return true;
-        }
-    }
-    return false;
-}
-
 }  // namespace
 
 OffsetFirstIndex::OffsetFirstIndex() = default;
@@ -70,14 +61,13 @@
 Transform::ApplyResult OffsetFirstIndex::Apply(const Program& src,
                                                const DataMap& inputs,
                                                DataMap&) const {
-    if (!ShouldRun(src)) {
-        return SkipTransform;
-    }
-
     const Config* cfg = inputs.Get<Config>();
     if (!cfg) {
         return SkipTransform;
     }
+    if (!cfg->first_vertex_offset.has_value() && !cfg->first_instance_offset.has_value()) {
+        return SkipTransform;
+    }
 
     ProgramBuilder b;
     program::CloneContext ctx{&b, &src, /* auto_clone_symbols */ true};
@@ -86,9 +76,6 @@
     std::unordered_map<const sem::Variable*, const char*> builtin_vars;
     std::unordered_map<const core::type::StructMember*, const char*> builtin_members;
 
-    bool has_vertex_index = false;
-    bool has_instance_index = false;
-
     // Traverse the AST scanning for builtin accesses via variables (includes
     // parameters) or structure member accesses.
     for (auto* node : ctx.src->ASTNodes().Objects()) {
@@ -100,13 +87,11 @@
                         cfg->first_vertex_offset.has_value()) {
                         auto* sem_var = ctx.src->Sem().Get(var);
                         builtin_vars.emplace(sem_var, kFirstVertexName);
-                        has_vertex_index = true;
                     }
                     if (builtin == core::BuiltinValue::kInstanceIndex && cfg &&
                         cfg->first_instance_offset.has_value()) {
                         auto* sem_var = ctx.src->Sem().Get(var);
                         builtin_vars.emplace(sem_var, kFirstInstanceName);
-                        has_instance_index = true;
                     }
                 }
             }
@@ -119,23 +104,17 @@
                         cfg->first_vertex_offset.has_value()) {
                         auto* sem_mem = ctx.src->Sem().Get(member);
                         builtin_members.emplace(sem_mem, kFirstVertexName);
-                        has_vertex_index = true;
                     }
                     if (builtin == core::BuiltinValue::kInstanceIndex && cfg &&
                         cfg->first_instance_offset.has_value()) {
                         auto* sem_mem = ctx.src->Sem().Get(member);
                         builtin_members.emplace(sem_mem, kFirstInstanceName);
-                        has_instance_index = true;
                     }
                 }
             }
         }
     }
 
-    if (!has_vertex_index && !has_instance_index) {
-        return SkipTransform;
-    }
-
     Vector<const ast::StructMember*, 8> members;
 
     const ast::Variable* push_constants_var = nullptr;
@@ -159,11 +138,11 @@
     }
 
     // Add push constant members and calculate byte offsets
-    if (has_vertex_index) {
+    if (cfg->first_vertex_offset.has_value()) {
         members.Push(b.Member(kFirstVertexName, b.ty.u32(),
                               Vector{b.MemberOffset(AInt(*cfg->first_vertex_offset))}));
     }
-    if (has_instance_index) {
+    if (cfg->first_instance_offset.has_value()) {
         members.Push(b.Member(kFirstInstanceName, b.ty.u32(),
                               Vector{b.MemberOffset(AInt(*cfg->first_instance_offset))}));
     }
diff --git a/src/tint/lang/wgsl/ast/transform/offset_first_index_test.cc b/src/tint/lang/wgsl/ast/transform/offset_first_index_test.cc
index 7d026ed..09dd505 100644
--- a/src/tint/lang/wgsl/ast/transform/offset_first_index_test.cc
+++ b/src/tint/lang/wgsl/ast/transform/offset_first_index_test.cc
@@ -41,12 +41,49 @@
 TEST_F(OffsetFirstIndexTest, ShouldRunEmptyModule) {
     auto* src = R"()";
 
-    DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
-    EXPECT_FALSE(ShouldRun<OffsetFirstIndex>(src, config));
+    EXPECT_FALSE(ShouldRun<OffsetFirstIndex>(src));
 }
 
-TEST_F(OffsetFirstIndexTest, ShouldRunFragmentStage) {
+TEST_F(OffsetFirstIndexTest, ShouldRunNoVertexIndexNoInstanceIndex) {
+    auto* src = R"(
+@fragment
+fn entry() {
+  return;
+}
+)";
+
+    DataMap config;
+    config.Add<OffsetFirstIndex::Config>(std::nullopt, std::nullopt);
+    EXPECT_FALSE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
+}
+
+TEST_F(OffsetFirstIndexTest, ShouldRunNoVertexIndex) {
+    auto* src = R"(
+@fragment
+fn entry() {
+  return;
+}
+)";
+
+    DataMap config;
+    config.Add<OffsetFirstIndex::Config>(std::nullopt, 0);
+    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
+}
+
+TEST_F(OffsetFirstIndexTest, ShouldRunNoInstanceIndex) {
+    auto* src = R"(
+@fragment
+fn entry() {
+  return;
+}
+)";
+
+    DataMap config;
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
+    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
+}
+
+TEST_F(OffsetFirstIndexTest, ShouldRun) {
     auto* src = R"(
 @fragment
 fn entry() {
@@ -56,20 +93,7 @@
 
     DataMap config;
     config.Add<OffsetFirstIndex::Config>(0, 4);
-    EXPECT_FALSE(ShouldRun<OffsetFirstIndex>(src, config));
-}
-
-TEST_F(OffsetFirstIndexTest, ShouldRunVertexStage) {
-    auto* src = R"(
-@vertex
-fn entry() -> @builtin(position) vec4<f32> {
-  return vec4<f32>();
-}
-)";
-
-    DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
-    EXPECT_FALSE(ShouldRun<OffsetFirstIndex>(src, config));
+    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
 }
 
 TEST_F(OffsetFirstIndexTest, ShouldRunVertexStageWithVertexIndex) {
@@ -82,7 +106,7 @@
 
     DataMap config;
     config.Add<OffsetFirstIndex::Config>(0, 4);
-    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, config));
+    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
 }
 
 TEST_F(OffsetFirstIndexTest, ShouldRunVertexStageWithInstanceIndex) {
@@ -95,16 +119,14 @@
 
     DataMap config;
     config.Add<OffsetFirstIndex::Config>(0, 4);
-    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, config));
+    EXPECT_TRUE(ShouldRun<OffsetFirstIndex>(src, std::move(config)));
 }
 
 TEST_F(OffsetFirstIndexTest, EmptyModule) {
     auto* src = "";
     auto* expect = "";
 
-    DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
-    auto got = Run<OffsetFirstIndex>(src, std::move(config));
+    auto got = Run<OffsetFirstIndex>(src);
 
     EXPECT_EQ(expect, str(got));
 }
@@ -118,9 +140,7 @@
 )";
     auto* expect = src;
 
-    DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
-    auto got = Run<OffsetFirstIndex>(src, std::move(config));
+    auto got = Run<OffsetFirstIndex>(src);
 
     EXPECT_EQ(expect, str(got));
 }
@@ -160,7 +180,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -201,7 +221,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -244,7 +264,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(std::nullopt, 4);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -287,7 +307,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(std::nullopt, 4);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -577,7 +597,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -614,7 +634,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -663,7 +683,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
@@ -712,7 +732,7 @@
 )";
 
     DataMap config;
-    config.Add<OffsetFirstIndex::Config>(0, 4);
+    config.Add<OffsetFirstIndex::Config>(0, std::nullopt);
     auto got = Run<OffsetFirstIndex>(src, std::move(config));
 
     EXPECT_EQ(expect, str(got));
diff --git a/src/tint/utils/containers/hashmap_base.h b/src/tint/utils/containers/hashmap_base.h
index 2a86e3a..ba78fd0 100644
--- a/src/tint/utils/containers/hashmap_base.h
+++ b/src/tint/utils/containers/hashmap_base.h
@@ -38,6 +38,7 @@
 #include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/math/hash.h"
 #include "src/tint/utils/math/math.h"
+#include "src/tint/utils/memory/aligned_storage.h"
 #include "src/tint/utils/traits/traits.h"
 
 namespace tint {
@@ -418,21 +419,14 @@
   protected:
     /// Node holds an Entry in a linked list.
     struct Node {
-        /// A structure that has the same size and alignment as Entry.
-        /// Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
-        struct alignas(alignof(ENTRY)) Storage {
-            /// Byte array of length sizeof(ENTRY)
-            uint8_t data[sizeof(ENTRY)];
-        };
-
         /// Destructs the entry.
         void Destroy() { Entry().~ENTRY(); }
 
         /// @returns the storage reinterpreted as an `Entry&`
-        ENTRY& Entry() { return *Bitcast<ENTRY*>(&storage.data[0]); }
+        ENTRY& Entry() { return storage.Get(); }
 
         /// @returns the storage reinterpreted as a `const Entry&`
-        const ENTRY& Entry() const { return *Bitcast<const ENTRY*>(&storage.data[0]); }
+        const ENTRY& Entry() const { return storage.Get(); }
 
         /// @returns a reference to the Entry's HashmapKey
         const HashmapBase::Key& Key() const { return HashmapBase::Entry::KeyOf(Entry()); }
@@ -450,7 +444,7 @@
         /// storage is a buffer that has the same size and alignment as Entry.
         /// The storage holds a constructed Entry when linked in the slots, and is destructed when
         /// removed from slots.
-        Storage storage;
+        AlignedStorage<ENTRY> storage;
 
         /// next is the next Node in the slot, or in the free list.
         Node* next;
diff --git a/src/tint/utils/containers/vector.h b/src/tint/utils/containers/vector.h
index c7edd0e..cd806c1 100644
--- a/src/tint/utils/containers/vector.h
+++ b/src/tint/utils/containers/vector.h
@@ -41,6 +41,7 @@
 #include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/compiler.h"
 #include "src/tint/utils/math/hash.h"
+#include "src/tint/utils/memory/aligned_storage.h"
 #include "src/tint/utils/memory/bitcast.h"
 
 #ifndef TINT_VECTOR_MUTATION_CHECKS_ENABLED
@@ -912,26 +913,18 @@
     constexpr static bool HasSmallArray = N > 0;
 
     /// A structure that has the same size and alignment as T.
-    /// Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
-    struct alignas(alignof(T)) TStorage {
-        /// @returns the storage reinterpreted as a T*
-        T* Get() { return Bitcast<T*>(&data[0]); }
-        /// @returns the storage reinterpreted as a T*
-        const T* Get() const { return Bitcast<const T*>(&data[0]); }
-        /// Byte array of length sizeof(T)
-        uint8_t data[sizeof(T)];
-    };
+    using TStorage = AlignedStorage<T>;
 
     /// The internal structure for the vector with a small array.
     struct ImplWithSmallArray {
         TStorage small_arr[N];
-        tint::Slice<T> slice = {small_arr[0].Get(), 0, N};
+        tint::Slice<T> slice = {&small_arr[0].Get(), 0, N};
 
         /// Allocates a new vector of `T` either from #small_arr, or from the heap, then assigns the
         /// pointer it to #slice.data, and updates #slice.cap.
         void Allocate(size_t new_cap) {
             if (new_cap < N) {
-                slice.data = small_arr[0].Get();
+                slice.data = &small_arr[0].Get();
                 slice.cap = N;
             } else {
                 slice.data = Bitcast<T*>(new TStorage[new_cap]);
@@ -941,14 +934,14 @@
 
         /// Frees `data`, if isn't a pointer to #small_arr
         void Free(T* data) const {
-            if (data != small_arr[0].Get()) {
+            if (data != &small_arr[0].Get()) {
                 delete[] Bitcast<TStorage*>(data);
             }
         }
 
         /// Indicates whether the slice structure can be std::move()d.
         /// @returns true if #slice.data does not point to #small_arr
-        bool CanMove() const { return slice.data != small_arr[0].Get(); }
+        bool CanMove() const { return slice.data != &small_arr[0].Get(); }
     };
 
     /// The internal structure for the vector without a small array.
diff --git a/src/tint/utils/diagnostic/diagnostic.h b/src/tint/utils/diagnostic/diagnostic.h
index fc4438d..ac5c42a 100644
--- a/src/tint/utils/diagnostic/diagnostic.h
+++ b/src/tint/utils/diagnostic/diagnostic.h
@@ -252,8 +252,6 @@
     /// @returns true iff the diagnostic list contains errors diagnostics (or of
     /// higher severity).
     bool ContainsErrors() const { return error_count_ > 0; }
-    /// deprecated, use `ContainsErrors`
-    bool contains_errors() const { return ContainsErrors(); }
     /// @returns the number of error diagnostics (or of higher severity).
     size_t NumErrors() const { return error_count_; }
     /// @returns the number of entries in the list.
diff --git a/src/tint/utils/diagnostic/formatter.h b/src/tint/utils/diagnostic/formatter.h
index 1841fe0..63da5e2 100644
--- a/src/tint/utils/diagnostic/formatter.h
+++ b/src/tint/utils/diagnostic/formatter.h
@@ -69,8 +69,6 @@
     /// @return the list of diagnostics `list` formatted to a string.
     /// @param list the list of diagnostic messages to format
     std::string Format(const List& list) const;
-    /// deprecated, use `Format`
-    std::string format(const List& list) const { return Format(list); }
 
   private:
     struct State;
diff --git a/src/tint/utils/memory/BUILD.bazel b/src/tint/utils/memory/BUILD.bazel
index 0bd13c9..6cb1b67 100644
--- a/src/tint/utils/memory/BUILD.bazel
+++ b/src/tint/utils/memory/BUILD.bazel
@@ -42,6 +42,7 @@
     "memory.cc",
   ],
   hdrs = [
+    "aligned_storage.h",
     "bitcast.h",
     "block_allocator.h",
     "bump_allocator.h",
diff --git a/src/tint/utils/memory/BUILD.cmake b/src/tint/utils/memory/BUILD.cmake
index 3151d3f..1d69077 100644
--- a/src/tint/utils/memory/BUILD.cmake
+++ b/src/tint/utils/memory/BUILD.cmake
@@ -39,6 +39,7 @@
 # Kind:      lib
 ################################################################################
 tint_add_target(tint_utils_memory lib
+  utils/memory/aligned_storage.h
   utils/memory/bitcast.h
   utils/memory/block_allocator.h
   utils/memory/bump_allocator.h
diff --git a/src/tint/utils/memory/BUILD.gn b/src/tint/utils/memory/BUILD.gn
index e5b44f2..0ab12e1 100644
--- a/src/tint/utils/memory/BUILD.gn
+++ b/src/tint/utils/memory/BUILD.gn
@@ -44,6 +44,7 @@
 
 libtint_source_set("memory") {
   sources = [
+    "aligned_storage.h",
     "bitcast.h",
     "block_allocator.h",
     "bump_allocator.h",
diff --git a/src/tint/utils/memory/aligned_storage.h b/src/tint/utils/memory/aligned_storage.h
new file mode 100644
index 0000000..c532c4f
--- /dev/null
+++ b/src/tint/utils/memory/aligned_storage.h
@@ -0,0 +1,53 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_
+#define SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_
+
+#include <cstddef>
+
+#include "src/tint/utils/memory/bitcast.h"
+
+namespace tint {
+
+/// A structure that has the same size and alignment as Entry.
+/// Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
+template <typename T>
+struct alignas(alignof(T)) AlignedStorage {
+    /// Byte array of length sizeof(T)
+    std::byte data[sizeof(T)];
+
+    /// @returns a pointer to aligned storage, reinterpreted as T&
+    T& Get() { return *Bitcast<T*>(&data[0]); }
+
+    /// @returns a pointer to aligned storage, reinterpreted as T&
+    const T& Get() const { return *Bitcast<const T*>(&data[0]); }
+};
+
+}  // namespace tint
+
+#endif  // SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_
diff --git a/src/tint/utils/rtti/switch.h b/src/tint/utils/rtti/switch.h
index 24173d0..2436f5f 100644
--- a/src/tint/utils/rtti/switch.h
+++ b/src/tint/utils/rtti/switch.h
@@ -33,7 +33,7 @@
 
 #include "src/tint/utils/ice/ice.h"
 #include "src/tint/utils/macros/defer.h"
-#include "src/tint/utils/memory/bitcast.h"
+#include "src/tint/utils/memory/aligned_storage.h"
 #include "src/tint/utils/rtti/castable.h"
 #include "src/tint/utils/rtti/ignore.h"
 
@@ -300,13 +300,8 @@
         }
     }
 
-    // Replacement for std::aligned_storage as this is broken on earlier versions of MSVC.
-    using ReturnTypeOrU8 = std::conditional_t<kHasReturnType, ReturnType, uint8_t>;
-    struct alignas(alignof(ReturnTypeOrU8)) ReturnStorage {
-        uint8_t data[sizeof(ReturnTypeOrU8)];
-    };
-    ReturnStorage return_storage;
-    auto* result = tint::Bitcast<ReturnTypeOrU8*>(&return_storage);
+    AlignedStorage<std::conditional_t<kHasReturnType, ReturnType, uint8_t>> return_storage;
+    auto* result = &return_storage.Get();
 
     const tint::TypeInfo& type_info = object->TypeInfo();