diff --git a/dawn.json b/dawn.json
index bff7679..3d41fa9 100644
--- a/dawn.json
+++ b/dawn.json
@@ -1919,6 +1919,7 @@
             {"value": 1022, "name": "host mapped pointer", "tags": ["dawn"]},
             {"value": 1023, "name": "multi planar render targets", "tags": ["dawn"]},
             {"value": 1024, "name": "multi planar format nv12a", "tags": ["dawn"]},
+            {"value": 1025, "name": "framebuffer fetch", "tags": ["dawn"]},
 
             {"value": 1100, "name": "shared texture memory vk dedicated allocation", "tags": ["dawn", "native"]},
             {"value": 1101, "name": "shared texture memory a hardware buffer", "tags": ["dawn", "native"]},
diff --git a/docs/dawn/features/framebuffer_fetch.md b/docs/dawn/features/framebuffer_fetch.md
new file mode 100644
index 0000000..b47e701
--- /dev/null
+++ b/docs/dawn/features/framebuffer_fetch.md
@@ -0,0 +1,14 @@
+# Framebuffer Fetch (experimental)
+
+This extension enables support for the [`chromium_experimental_framebuffer_fetch`](../../tint/extensions/chromium_experimental_framebuffer_fetch.md) WGSL extension.
+
+The extension is experimental and might change for example to gain new validation rules (with extension struct) in the future.
+
+It is available on tiler Metal GPUs.
+
+## Validation
+
+In `Device::CreateRenderPipeline` or `Device::CreateRenderPipelineAsync`:
+ - For each `@color(N) in : T` fragment in:
+   - color target N must exist
+   - color target N's format must match T in both component count and base type
diff --git a/src/dawn/native/Device.cpp b/src/dawn/native/Device.cpp
index 927eac3..adf2915 100644
--- a/src/dawn/native/Device.cpp
+++ b/src/dawn/native/Device.cpp
@@ -1482,6 +1482,10 @@
         mWGSLAllowedFeatures.extensions.insert(
             tint::wgsl::Extension::kChromiumExperimentalPixelLocal);
     }
+    if (mEnabledFeatures.IsEnabled(Feature::FramebufferFetch)) {
+        mWGSLAllowedFeatures.extensions.insert(
+            tint::wgsl::Extension::kChromiumExperimentalFramebufferFetch);
+    }
 }
 
 const tint::wgsl::AllowedFeatures& DeviceBase::GetWGSLAllowedFeatures() const {
diff --git a/src/dawn/native/Features.cpp b/src/dawn/native/Features.cpp
index b7a9cf3..4c55707 100644
--- a/src/dawn/native/Features.cpp
+++ b/src/dawn/native/Features.cpp
@@ -258,6 +258,11 @@
       "https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/dawn/features/"
       "host_mapped_pointer.md",
       FeatureInfo::FeatureState::Experimental}},
+    {Feature::FramebufferFetch,
+     {"Support loading the current framebuffer value in fragment shaders.",
+      "https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/dawn/features/"
+      "framebuffer_fetch.md",
+      FeatureInfo::FeatureState::Experimental}},
 };
 
 }  // anonymous namespace
diff --git a/src/dawn/native/RenderPipeline.cpp b/src/dawn/native/RenderPipeline.cpp
index cd47356..1d03bf9 100644
--- a/src/dawn/native/RenderPipeline.cpp
+++ b/src/dawn/native/RenderPipeline.cpp
@@ -31,6 +31,7 @@
 #include <cmath>
 
 #include "dawn/common/BitSetIterator.h"
+#include "dawn/common/ityp_span.h"
 #include "dawn/native/ChainUtils.h"
 #include "dawn/native/CommandValidation.h"
 #include "dawn/native/Commands.h"
@@ -420,69 +421,78 @@
 
 MaybeError ValidateColorTargetState(
     DeviceBase* device,
-    const ColorTargetState* descriptor,
+    const ColorTargetState& descriptor,
+    const Format* format,
     bool fragmentWritten,
-    const EntryPointMetadata::FragmentOutputVariableInfo& fragmentOutputVariable) {
-    DAWN_INVALID_IF(descriptor->nextInChain != nullptr, "nextInChain must be nullptr.");
+    const EntryPointMetadata::FragmentRenderAttachmentInfo& fragmentOutputVariable) {
+    DAWN_INVALID_IF(descriptor.nextInChain != nullptr, "nextInChain must be nullptr.");
 
-    if (descriptor->blend) {
-        DAWN_TRY_CONTEXT(ValidateBlendState(device, descriptor->blend), "validating blend state.");
+    if (descriptor.blend) {
+        DAWN_TRY_CONTEXT(ValidateBlendState(device, descriptor.blend), "validating blend state.");
     }
 
-    DAWN_TRY(ValidateColorWriteMask(descriptor->writeMask));
-
-    const Format* format;
-    DAWN_TRY_ASSIGN(format, device->GetInternalFormat(descriptor->format));
+    DAWN_TRY(ValidateColorWriteMask(descriptor.writeMask));
     DAWN_INVALID_IF(!format->IsColor() || !format->isRenderable,
-                    "Color format (%s) is not color renderable.", descriptor->format);
+                    "Color format (%s) is not color renderable.", format->format);
 
     DAWN_INVALID_IF(
-        descriptor->blend &&
+        descriptor.blend &&
             !(format->GetAspectInfo(Aspect::Color).supportedSampleTypes & SampleTypeBit::Float),
-        "Blending is enabled but color format (%s) is not blendable.", descriptor->format);
+        "Blending is enabled but color format (%s) is not blendable.", format->format);
 
-    if (fragmentWritten) {
+    if (!fragmentWritten) {
         DAWN_INVALID_IF(
-            fragmentOutputVariable.baseType != format->GetAspectInfo(Aspect::Color).baseType,
-            "Color format (%s) base type (%s) doesn't match the fragment "
-            "module output type (%s).",
-            descriptor->format, format->GetAspectInfo(Aspect::Color).baseType,
-            fragmentOutputVariable.baseType);
-
-        DAWN_INVALID_IF(fragmentOutputVariable.componentCount < format->componentCount,
-                        "The fragment stage has fewer output components (%u) than the color format "
-                        "(%s) component count (%u).",
-                        fragmentOutputVariable.componentCount, descriptor->format,
-                        format->componentCount);
-
-        if (descriptor->blend) {
-            if (fragmentOutputVariable.componentCount < 4u) {
-                // No alpha channel output
-                // Make sure there's no alpha involved in the blending operation
-                DAWN_INVALID_IF(BlendFactorContainsSrcAlpha(descriptor->blend->color.srcFactor) ||
-                                    BlendFactorContainsSrcAlpha(descriptor->blend->color.dstFactor),
-                                "Color blending srcfactor (%s) or dstFactor (%s) is reading alpha "
-                                "but it is missing from fragment output.",
-                                descriptor->blend->color.srcFactor,
-                                descriptor->blend->color.dstFactor);
-            }
-        }
-    } else {
-        DAWN_INVALID_IF(
-            descriptor->writeMask != wgpu::ColorWriteMask::None,
+            descriptor.writeMask != wgpu::ColorWriteMask::None,
             "Color target has no corresponding fragment stage output but writeMask (%s) is "
             "not zero.",
-            descriptor->writeMask);
+            descriptor.writeMask);
+        return {};
+    }
+
+    DAWN_INVALID_IF(
+        fragmentOutputVariable.baseType != format->GetAspectInfo(Aspect::Color).baseType,
+        "Color format (%s) base type (%s) doesn't match the fragment "
+        "module output type (%s).",
+        format->format, format->GetAspectInfo(Aspect::Color).baseType,
+        fragmentOutputVariable.baseType);
+
+    DAWN_INVALID_IF(fragmentOutputVariable.componentCount < format->componentCount,
+                    "The fragment stage has fewer output components (%u) than the color format "
+                    "(%s) component count (%u).",
+                    fragmentOutputVariable.componentCount, format->format, format->componentCount);
+
+    if (descriptor.blend && fragmentOutputVariable.componentCount < 4u) {
+        // No alpha channel output, make sure there's no alpha involved in the blending operation.
+        DAWN_INVALID_IF(BlendFactorContainsSrcAlpha(descriptor.blend->color.srcFactor) ||
+                            BlendFactorContainsSrcAlpha(descriptor.blend->color.dstFactor),
+                        "Color blending srcFactor (%s) or dstFactor (%s) is reading alpha "
+                        "but it is missing from fragment output.",
+                        descriptor.blend->color.srcFactor, descriptor.blend->color.dstFactor);
     }
 
     return {};
 }
 
-MaybeError ValidateCompatibilityColorTargetState(
-    const uint8_t firstColorTargetIndex,
-    const ColorTargetState* const firstColorTargetState,
-    const uint8_t targetIndex,
-    const ColorTargetState* target) {
+MaybeError ValidateFramebufferInput(
+    DeviceBase* device,
+    const Format* format,
+    const EntryPointMetadata::FragmentRenderAttachmentInfo& inputVar) {
+    DAWN_INVALID_IF(inputVar.baseType != format->GetAspectInfo(Aspect::Color).baseType,
+                    "Color format (%s) base type (%s) doesn't match the fragment "
+                    "module input type (%s).",
+                    format->format, format->GetAspectInfo(Aspect::Color).baseType,
+                    inputVar.baseType);
+    DAWN_INVALID_IF(inputVar.componentCount != format->componentCount,
+                    "The fragment stage number of input components (%u) doesn't match the color "
+                    "format (%s) component count (%u).",
+                    inputVar.componentCount, format->format, format->componentCount);
+    return {};
+}
+
+MaybeError ValidateColorTargetStatesMatch(const uint8_t firstColorTargetIndex,
+                                          const ColorTargetState* const firstColorTargetState,
+                                          const uint8_t targetIndex,
+                                          const ColorTargetState* target) {
     DAWN_INVALID_IF(firstColorTargetState->writeMask != target->writeMask,
                     "targets[%u].writeMask (%s) does not match targets[%u].writeMask (%s).",
                     targetIndex, target->writeMask, firstColorTargetIndex,
@@ -537,7 +547,7 @@
                                  const FragmentState* descriptor,
                                  const PipelineLayoutBase* layout,
                                  const DepthStencilState* depthStencil,
-                                 bool alphaToCoverageEnabled) {
+                                 const MultisampleState& multisample) {
     DAWN_INVALID_IF(descriptor->nextInChain != nullptr, "nextInChain must be nullptr.");
 
     DAWN_TRY_CONTEXT(ValidateProgrammableStage(device, descriptor->module, descriptor->entryPoint,
@@ -546,11 +556,6 @@
                      "validating fragment stage (%s, entryPoint: %s).", descriptor->module,
                      descriptor->entryPoint);
 
-    uint32_t maxColorAttachments = device->GetLimits().v1.maxColorAttachments;
-    DAWN_INVALID_IF(descriptor->targetCount > maxColorAttachments,
-                    "Number of targets (%u) exceeds the maximum (%u).", descriptor->targetCount,
-                    maxColorAttachments);
-
     const EntryPointMetadata& fragmentMetadata =
         descriptor->module->GetEntryPoint(descriptor->entryPoint);
 
@@ -569,41 +574,53 @@
                         depthStencil->format, descriptor->module, descriptor->entryPoint);
     }
 
-    uint8_t firstColorTargetIndex = 0;
-    const ColorTargetState* firstColorTargetState = nullptr;
-    ColorAttachmentFormats colorAttachmentFormats;
+    uint32_t maxColorAttachments = device->GetLimits().v1.maxColorAttachments;
+    DAWN_INVALID_IF(descriptor->targetCount > maxColorAttachments,
+                    "Number of targets (%u) exceeds the maximum (%u).", descriptor->targetCount,
+                    maxColorAttachments);
+    ityp::span<ColorAttachmentIndex, const ColorTargetState> targets(
+        descriptor->targets, ColorAttachmentIndex(uint8_t(descriptor->targetCount)));
 
-    for (ColorAttachmentIndex attachmentIndex(uint8_t(0));
-         attachmentIndex < ColorAttachmentIndex(static_cast<uint8_t>(descriptor->targetCount));
-         ++attachmentIndex) {
-        const uint8_t i = static_cast<uint8_t>(attachmentIndex);
-        const ColorTargetState* target = &descriptor->targets[i];
-
-        if (target->format != wgpu::TextureFormat::Undefined) {
-            DAWN_TRY_CONTEXT(
-                ValidateColorTargetState(device, target,
-                                         fragmentMetadata.fragmentOutputsWritten[attachmentIndex],
-                                         fragmentMetadata.fragmentOutputVariables[attachmentIndex]),
-                "validating targets[%u].", i);
-            colorAttachmentFormats->push_back(&device->GetValidInternalFormat(target->format));
-            if (device->IsCompatibilityMode()) {
-                if (!firstColorTargetState) {
-                    firstColorTargetState = target;
-                    firstColorTargetIndex = i;
-                } else {
-                    DAWN_TRY_CONTEXT(ValidateCompatibilityColorTargetState(
-                                         firstColorTargetIndex, firstColorTargetState, i, target),
-                                     "validating targets[%u] in compatibility mode.", i);
-                }
-            }
+    ityp::bitset<ColorAttachmentIndex, kMaxColorAttachments> targetMask;
+    for (ColorAttachmentIndex i{}; i < targets.size(); ++i) {
+        if (targets[i].format == wgpu::TextureFormat::Undefined) {
+            DAWN_INVALID_IF(targets[i].blend,
+                            "Color target[%u] blend state is set when the format is undefined.",
+                            static_cast<uint8_t>(i));
         } else {
-            DAWN_INVALID_IF(target->blend,
-                            "Color target[%u] blend state is set when the format is undefined.", i);
+            targetMask.set(i);
         }
     }
+
+    ColorAttachmentFormats colorAttachmentFormats;
+    for (ColorAttachmentIndex i : IterateBitSet(targetMask)) {
+        const Format* format;
+        DAWN_TRY_ASSIGN(format, device->GetInternalFormat(targets[i].format));
+
+        DAWN_TRY_CONTEXT(ValidateColorTargetState(device, targets[i], format,
+                                                  fragmentMetadata.fragmentOutputMask[i],
+                                                  fragmentMetadata.fragmentOutputVariables[i]),
+                         "validating targets[%u] framebuffer output.", static_cast<uint8_t>(i));
+        colorAttachmentFormats->push_back(&device->GetValidInternalFormat(targets[i].format));
+
+        if (fragmentMetadata.fragmentInputMask[i]) {
+            DAWN_TRY_CONTEXT(ValidateFramebufferInput(device, format,
+                                                      fragmentMetadata.fragmentInputVariables[i]),
+                             "validating targets[%u]'s framebuffer input.",
+                             static_cast<uint8_t>(i));
+        }
+    }
+
+    auto extraFramebufferInputs = fragmentMetadata.fragmentInputMask & ~targetMask;
+    DAWN_INVALID_IF(
+        extraFramebufferInputs.any(),
+        "Framebuffer input at index %u is used without a corresponding color target state.",
+        uint8_t(ityp::Sub(GetHighestBitIndexPlusOne(extraFramebufferInputs),
+                          ColorAttachmentIndex(uint8_t(1)))));
+
     DAWN_TRY(ValidateColorAttachmentBytesPerSample(device, colorAttachmentFormats));
 
-    if (alphaToCoverageEnabled) {
+    if (multisample.alphaToCoverageEnabled) {
         DAWN_INVALID_IF(fragmentMetadata.usesSampleMaskOutput,
                         "alphaToCoverageEnabled is true when the sample_mask builtin is a "
                         "pipeline output of fragment stage of %s.",
@@ -621,12 +638,34 @@
             format->format);
     }
 
+    if (multisample.count != 1) {
+        DAWN_INVALID_IF(fragmentMetadata.fragmentInputMask.any(),
+                        "Framebuffer inputs are used when the sample count (%u) is not 1.",
+                        multisample.count);
+    }
+
     if (device->IsCompatibilityMode()) {
         DAWN_INVALID_IF(
             fragmentMetadata.usesSampleMaskOutput,
             "sample_mask is not supported in compatibility mode in the fragment stage (%s, "
             "entryPoint: %s)",
             descriptor->module, descriptor->entryPoint);
+
+        // Check that all the color target states match.
+        ColorAttachmentIndex firstColorTargetIndex{};
+        const ColorTargetState* firstColorTargetState = nullptr;
+        for (ColorAttachmentIndex i : IterateBitSet(targetMask)) {
+            if (!firstColorTargetState) {
+                firstColorTargetState = &targets[i];
+                firstColorTargetIndex = i;
+                continue;
+            }
+
+            DAWN_TRY_CONTEXT(ValidateColorTargetStatesMatch(
+                                 static_cast<uint8_t>(firstColorTargetIndex), firstColorTargetState,
+                                 static_cast<uint8_t>(i), &targets[i]),
+                             "validating targets in compatibility mode.");
+        }
     }
 
     return {};
@@ -735,8 +774,7 @@
 
     if (descriptor->fragment != nullptr) {
         DAWN_TRY_CONTEXT(ValidateFragmentState(device, descriptor->fragment, descriptor->layout,
-                                               descriptor->depthStencil,
-                                               descriptor->multisample.alphaToCoverageEnabled),
+                                               descriptor->depthStencil, descriptor->multisample),
                          "validating fragment state.");
 
         bool hasStorageAttachments =
diff --git a/src/dawn/native/ShaderModule.cpp b/src/dawn/native/ShaderModule.cpp
index 9af60c5..0a99e7b 100644
--- a/src/dawn/native/ShaderModule.cpp
+++ b/src/dawn/native/ShaderModule.cpp
@@ -625,7 +625,9 @@
     metadata->usedInterStageVariables.resize(maxInterStageShaderVariables);
     metadata->interStageVariables.resize(maxInterStageShaderVariables);
 
+    // Vertex shader specific reflection.
     if (metadata->stage == SingleShaderStage::Vertex) {
+        // Vertex input reflection.
         for (const auto& inputVar : entryPoint.input_variables) {
             uint32_t unsanitizedLocation = inputVar.attributes.location.value();
             if (DelayedInvalidIf(unsanitizedLocation >= maxVertexAttributes,
@@ -641,6 +643,7 @@
             metadata->usedVertexInputs.set(location);
         }
 
+        // Vertex ouput (inter-stage variables) reflection.
         uint32_t totalInterStageShaderComponents = 0;
         for (const auto& outputVar : entryPoint.output_variables) {
             EntryPointMetadata::InterStageVariableInfo variable;
@@ -668,6 +671,7 @@
             metadata->interStageVariables[location] = variable;
         }
 
+        // Other vertex metadata.
         metadata->totalInterStageShaderComponents = totalInterStageShaderComponents;
         DelayedInvalidIf(totalInterStageShaderComponents > maxInterStageShaderComponents,
                          "Total vertex output components count (%u) exceeds the maximum (%u).",
@@ -677,38 +681,44 @@
         metadata->usesInstanceIndex = entryPoint.instance_index_used;
     }
 
+    // Fragment shader specific reflection.
     if (metadata->stage == SingleShaderStage::Fragment) {
         uint32_t totalInterStageShaderComponents = 0;
+
+        // Fragment input (inter-stage variables) reflection.
         for (const auto& inputVar : entryPoint.input_variables) {
-            if (inputVar.attributes.location.has_value()) {
-                uint32_t location = inputVar.attributes.location.value();
-                EntryPointMetadata::InterStageVariableInfo variable;
-                variable.name = inputVar.variable_name;
-                DAWN_TRY_ASSIGN(variable.baseType, TintComponentTypeToInterStageComponentType(
-                                                       inputVar.component_type));
-                DAWN_TRY_ASSIGN(
-                    variable.componentCount,
-                    TintCompositionTypeToInterStageComponentCount(inputVar.composition_type));
-                DAWN_TRY_ASSIGN(
-                    variable.interpolationType,
-                    TintInterpolationTypeToInterpolationType(inputVar.interpolation_type));
-                DAWN_TRY_ASSIGN(variable.interpolationSampling,
-                                TintInterpolationSamplingToInterpolationSamplingType(
-                                    inputVar.interpolation_sampling));
-                totalInterStageShaderComponents += variable.componentCount;
-
-                if (DelayedInvalidIf(location >= maxInterStageShaderVariables,
-                                     "Fragment input variable \"%s\" has a location (%u) that "
-                                     "is greater than or equal to (%u).",
-                                     inputVar.name, location, maxInterStageShaderVariables)) {
-                    continue;
-                }
-
-                metadata->usedInterStageVariables[location] = true;
-                metadata->interStageVariables[location] = variable;
+            // Skip over @color framebuffer fetch, it is handled below.
+            if (!inputVar.attributes.location.has_value()) {
+                DAWN_ASSERT(inputVar.attributes.color.has_value());
+                continue;
             }
+
+            uint32_t location = inputVar.attributes.location.value();
+            EntryPointMetadata::InterStageVariableInfo variable;
+            variable.name = inputVar.variable_name;
+            DAWN_TRY_ASSIGN(variable.baseType,
+                            TintComponentTypeToInterStageComponentType(inputVar.component_type));
+            DAWN_TRY_ASSIGN(variable.componentCount, TintCompositionTypeToInterStageComponentCount(
+                                                         inputVar.composition_type));
+            DAWN_TRY_ASSIGN(variable.interpolationType,
+                            TintInterpolationTypeToInterpolationType(inputVar.interpolation_type));
+            DAWN_TRY_ASSIGN(variable.interpolationSampling,
+                            TintInterpolationSamplingToInterpolationSamplingType(
+                                inputVar.interpolation_sampling));
+            totalInterStageShaderComponents += variable.componentCount;
+
+            if (DelayedInvalidIf(location >= maxInterStageShaderVariables,
+                                 "Fragment input variable \"%s\" has a location (%u) that "
+                                 "is greater than or equal to (%u).",
+                                 inputVar.name, location, maxInterStageShaderVariables)) {
+                continue;
+            }
+
+            metadata->usedInterStageVariables[location] = true;
+            metadata->interStageVariables[location] = variable;
         }
 
+        // Other fragment metadata
         if (entryPoint.front_facing_used) {
             totalInterStageShaderComponents += 1;
         }
@@ -726,9 +736,10 @@
                          "Total fragment input components count (%u) exceeds the maximum (%u).",
                          totalInterStageShaderComponents, maxInterStageShaderComponents);
 
+        // Fragment output reflection.
         uint32_t maxColorAttachments = limits.v1.maxColorAttachments;
         for (const auto& outputVar : entryPoint.output_variables) {
-            EntryPointMetadata::FragmentOutputVariableInfo variable;
+            EntryPointMetadata::FragmentRenderAttachmentInfo variable;
             DAWN_TRY_ASSIGN(variable.baseType,
                             TintComponentTypeToTextureComponentType(outputVar.component_type));
             DAWN_TRY_ASSIGN(variable.componentCount, TintCompositionTypeToInterStageComponentCount(
@@ -745,9 +756,40 @@
 
             ColorAttachmentIndex attachment(static_cast<uint8_t>(unsanitizedAttachment));
             metadata->fragmentOutputVariables[attachment] = variable;
-            metadata->fragmentOutputsWritten.set(attachment);
+            metadata->fragmentOutputMask.set(attachment);
         }
 
+        // Fragment input reflection.
+        for (const auto& inputVar : entryPoint.input_variables) {
+            if (!inputVar.attributes.color.has_value()) {
+                continue;
+            }
+
+            // Tint should disallow using @color(N) without the respective enable, which is gated
+            // on the extension.
+            DAWN_ASSERT(device->HasFeature(Feature::FramebufferFetch));
+
+            EntryPointMetadata::FragmentRenderAttachmentInfo variable;
+            DAWN_TRY_ASSIGN(variable.baseType,
+                            TintComponentTypeToTextureComponentType(inputVar.component_type));
+            DAWN_TRY_ASSIGN(variable.componentCount, TintCompositionTypeToInterStageComponentCount(
+                                                         inputVar.composition_type));
+            DAWN_ASSERT(variable.componentCount <= 4);
+
+            uint32_t unsanitizedAttachment = inputVar.attributes.color.value();
+            if (DelayedInvalidIf(unsanitizedAttachment >= maxColorAttachments,
+                                 "Fragment input variable \"%s\" has a location (%u) that "
+                                 "exceeds the maximum (%u).",
+                                 inputVar.name, unsanitizedAttachment, maxColorAttachments)) {
+                continue;
+            }
+
+            ColorAttachmentIndex attachment(static_cast<uint8_t>(unsanitizedAttachment));
+            metadata->fragmentInputVariables[attachment] = variable;
+            metadata->fragmentInputMask.set(attachment);
+        }
+
+        // Fragment PLS reflection.
         if (!entryPoint.pixel_local_members.empty()) {
             metadata->usesPixelLocal = true;
             metadata->pixelLocalBlockSize =
@@ -762,6 +804,7 @@
         }
     }
 
+    // Generic resource binding reflection.
     for (const tint::inspector::ResourceBinding& resource :
          inspector->GetResourceBindings(entryPoint.name)) {
         ShaderBindingInfo info;
@@ -843,6 +886,7 @@
                         resource.binding, resource.bind_group);
     }
 
+    // Reflection of combined sampler and texture uses.
     auto samplerTextureUses = inspector->GetSamplerTextureUses(entryPoint.name);
     metadata->samplerTexturePairs.reserve(samplerTextureUses.Length());
     std::transform(samplerTextureUses.begin(), samplerTextureUses.end(),
diff --git a/src/dawn/native/ShaderModule.h b/src/dawn/native/ShaderModule.h
index f813085..1df1170 100644
--- a/src/dawn/native/ShaderModule.h
+++ b/src/dawn/native/ShaderModule.h
@@ -211,14 +211,19 @@
         vertexInputBaseTypes;
     ityp::bitset<VertexAttributeLocation, kMaxVertexAttributes> usedVertexInputs;
 
-    // An array to record the basic types (float, int and uint) of the fragment shader outputs.
-    struct FragmentOutputVariableInfo {
+    // An array to record the basic types (float, int and uint) of the fragment shader framebuffer
+    // input/outputs (inputs being "framebuffer fetch").
+    struct FragmentRenderAttachmentInfo {
         TextureComponentType baseType;
         uint8_t componentCount;
     };
-    ityp::array<ColorAttachmentIndex, FragmentOutputVariableInfo, kMaxColorAttachments>
+    ityp::array<ColorAttachmentIndex, FragmentRenderAttachmentInfo, kMaxColorAttachments>
         fragmentOutputVariables;
-    ityp::bitset<ColorAttachmentIndex, kMaxColorAttachments> fragmentOutputsWritten;
+    ityp::bitset<ColorAttachmentIndex, kMaxColorAttachments> fragmentOutputMask;
+
+    ityp::array<ColorAttachmentIndex, FragmentRenderAttachmentInfo, kMaxColorAttachments>
+        fragmentInputVariables;
+    ityp::bitset<ColorAttachmentIndex, kMaxColorAttachments> fragmentInputMask;
 
     struct InterStageVariableInfo {
         std::string name;
diff --git a/src/dawn/native/metal/RenderPipelineMTL.mm b/src/dawn/native/metal/RenderPipelineMTL.mm
index 124ad5d..d4a2a76 100644
--- a/src/dawn/native/metal/RenderPipelineMTL.mm
+++ b/src/dawn/native/metal/RenderPipelineMTL.mm
@@ -401,13 +401,13 @@
             mStagesRequiringStorageBufferLength |= wgpu::ShaderStage::Fragment;
         }
 
-        const auto& fragmentOutputsWritten = fragmentStage.metadata->fragmentOutputsWritten;
+        const auto& fragmentOutputMask = fragmentStage.metadata->fragmentOutputMask;
         for (ColorAttachmentIndex i : IterateBitSet(GetColorAttachmentsMask())) {
             descriptorMTL.colorAttachments[static_cast<uint8_t>(i)].pixelFormat =
                 MetalPixelFormat(GetDevice(), GetColorAttachmentFormat(i));
             const ColorTargetState* descriptor = GetColorTargetState(i);
             ComputeBlendDesc(descriptorMTL.colorAttachments[static_cast<uint8_t>(i)], descriptor,
-                             fragmentOutputsWritten[i]);
+                             fragmentOutputMask[i]);
         }
 
         if (GetAttachmentState()->HasPixelLocalStorage()) {
diff --git a/src/dawn/native/vulkan/RenderPipelineVk.cpp b/src/dawn/native/vulkan/RenderPipelineVk.cpp
index d05cfb6..c7ad09f 100644
--- a/src/dawn/native/vulkan/RenderPipelineVk.cpp
+++ b/src/dawn/native/vulkan/RenderPipelineVk.cpp
@@ -488,13 +488,13 @@
             blend.colorWriteMask = 0;
         }
 
-        const auto& fragmentOutputsWritten =
-            GetStage(SingleShaderStage::Fragment).metadata->fragmentOutputsWritten;
+        const auto& fragmentOutputMask =
+            GetStage(SingleShaderStage::Fragment).metadata->fragmentOutputMask;
         ColorAttachmentIndex highestColorAttachmentIndexPlusOne =
             GetHighestBitIndexPlusOne(GetColorAttachmentsMask());
         for (ColorAttachmentIndex i : IterateBitSet(GetColorAttachmentsMask())) {
             const ColorTargetState* target = GetColorTargetState(i);
-            colorBlendAttachments[i] = ComputeColorDesc(target, fragmentOutputsWritten[i]);
+            colorBlendAttachments[i] = ComputeColorDesc(target, fragmentOutputMask[i]);
         }
 
         colorBlend.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
diff --git a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
index de01a26..03ac33b 100644
--- a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp
@@ -2511,5 +2511,120 @@
     }
 }
 
+class FramebufferFetchFeatureTest : public RenderPipelineValidationTest {
+  protected:
+    WGPUDevice CreateTestDevice(native::Adapter dawnAdapter,
+                                wgpu::DeviceDescriptor descriptor) override {
+        wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::FramebufferFetch};
+        descriptor.requiredFeatures = requiredFeatures;
+        descriptor.requiredFeatureCount = 1;
+        return dawnAdapter.CreateDevice(&descriptor);
+    }
+};
+
+// Test that the framebuffer input must have a corresponding color target.
+TEST_F(FramebufferFetchFeatureTest, FramebufferInputMustHaveColorTarget) {
+    uint32_t colorIndices[] = {0, 1, 2, kMaxColorAttachments - 1, kMaxColorAttachments};
+    for (uint32_t colorIndex : colorIndices) {
+        std::ostringstream fsStream;
+        fsStream << R"(
+            enable chromium_experimental_framebuffer_fetch;
+            @fragment fn main(@color()"
+                 << colorIndex << R"() in : vec4f) -> @location(1) vec4f {
+                return in;
+            }
+        )";
+
+        utils::ComboRenderPipelineDescriptor desc;
+        desc.vertex.module = vsModule;
+        desc.vertex.entryPoint = "main";
+        desc.cFragment.module = utils::CreateShaderModule(device, fsStream.str().c_str());
+        desc.cFragment.entryPoint = "main";
+        desc.cFragment.targetCount = 2;
+        desc.cTargets[0].format = wgpu::TextureFormat::Undefined;
+        desc.cTargets[1].format = wgpu::TextureFormat::RGBA8Unorm;
+
+        // Only colorIndex 1 should work because it is the only index with a color target.
+        if (colorIndex == 1) {
+            device.CreateRenderPipeline(&desc);
+        } else {
+            ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&desc));
+        }
+    }
+}
+
+// Test that the framebuffer fetch requires multisampling to be off.
+TEST_F(FramebufferFetchFeatureTest, MultisampleDisallowed) {
+    utils::ComboRenderPipelineDescriptor desc;
+    desc.vertex.entryPoint = "main";
+    desc.vertex.module = vsModule;
+    desc.cFragment.entryPoint = "main";
+    desc.cFragment.module = utils::CreateShaderModule(device, R"(
+        enable chromium_experimental_framebuffer_fetch;
+        @fragment fn main(@color(0) in : vec4f) -> @location(0) vec4f {
+            return in;
+        }
+    )");
+
+    desc.multisample.count = 1;
+    device.CreateRenderPipeline(&desc);
+
+    desc.multisample.count = 4;
+    ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&desc));
+}
+
+// Test that the framebuffer fetch type matches the texture format exactly.
+TEST_F(FramebufferFetchFeatureTest, InputMatchesFormat) {
+    struct ValidPair {
+        const char* type;
+        wgpu::TextureFormat format;
+    };
+
+    std::array<ValidPair, 9> validPairs = {{
+        {"f32", wgpu::TextureFormat::R32Float},
+        {"vec2f", wgpu::TextureFormat::RG16Float},
+        {"vec4f", wgpu::TextureFormat::RGBA8Unorm},
+        {"u32", wgpu::TextureFormat::R32Uint},
+        {"vec2u", wgpu::TextureFormat::RG16Uint},
+        {"vec4u", wgpu::TextureFormat::RGBA8Uint},
+        {"i32", wgpu::TextureFormat::R32Sint},
+        {"vec2i", wgpu::TextureFormat::RG16Sint},
+        {"vec4i", wgpu::TextureFormat::RGBA8Sint},
+    }};
+
+    for (size_t i = 0; i < validPairs.size(); i++) {
+        wgpu::TextureFormat format = validPairs[i].format;
+        const char* outputType = validPairs[i].type;
+
+        for (size_t j = 0; j < validPairs.size(); j++) {
+            const char* inputType = validPairs[j].type;
+
+            std::ostringstream fsStream;
+            fsStream << R"(
+                enable chromium_experimental_framebuffer_fetch;
+                @fragment fn main(@color(0) in : )"
+                     << inputType << R"() -> @location(0) )" << outputType << R"( {
+                    var res : )"
+                     << outputType << R"(;
+                    return res;
+                }
+            )";
+
+            utils::ComboRenderPipelineDescriptor desc;
+            desc.vertex.module = vsModule;
+            desc.vertex.entryPoint = "main";
+            desc.cFragment.module = utils::CreateShaderModule(device, fsStream.str().c_str());
+            desc.cFragment.entryPoint = "main";
+            desc.cTargets[0].format = format;
+
+            if (i == j) {
+                device.CreateRenderPipeline(&desc);
+            } else {
+                ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&desc));
+            }
+        }
+    }
+}
+
 }  // anonymous namespace
 }  // namespace dawn
diff --git a/src/dawn/tests/unittests/validation/ShaderModuleValidationTests.cpp b/src/dawn/tests/unittests/validation/ShaderModuleValidationTests.cpp
index 67fe96d..d713d92 100644
--- a/src/dawn/tests/unittests/validation/ShaderModuleValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/ShaderModuleValidationTests.cpp
@@ -784,20 +784,22 @@
 };
 
 struct WGSLExtensionInfo {
-    const char* WGSLName;
+    const char* wgslName;
     // Is this WGSL extension experimental, i.e. guarded by AllowUnsafeAPIs toggle
     bool isExperimental;
     // The WebGPU feature that required to enable this extension, set to nullptr if no feature
     // required.
-    const char* RequiredFeatureName;
+    const char* requiredFeatureName;
 };
 
 constexpr struct WGSLExtensionInfo kExtensions[] = {
     {"f16", false, "shader-f16"},
     {"chromium_experimental_dp4a", true, "chromium-experimental-dp4a"},
     {"chromium_experimental_subgroups", true, "chromium-experimental-subgroups"},
+    {"chromium_experimental_pixel_local", true, "pixel-local-storage-coherent"},
     {"chromium_disable_uniformity_analysis", true, nullptr},
     {"chromium_internal_dual_source_blending", true, "dual-source-blending"},
+    {"chromium_experimental_framebuffer_fetch", true, "framebuffer-fetch"},
 
     // Currently the following WGSL extensions are not enabled under any situation.
     /*
@@ -825,13 +827,13 @@
 TEST_F(ShaderModuleExtensionValidationTestSafeNoFeature,
        OnlyStableExtensionsRequiringNoFeatureAllowed) {
     for (auto& extension : kExtensions) {
-        std::string wgsl = std::string("enable ") + extension.WGSLName + R"(;
+        std::string wgsl = std::string("enable ") + extension.wgslName + R"(;
 
 @compute @workgroup_size(1) fn main() {})";
 
         // On a safe device with no feature required, only stable extensions requiring no features
         // are allowed.
-        if (!extension.isExperimental && !extension.RequiredFeatureName) {
+        if (!extension.isExperimental && !extension.requiredFeatureName) {
             utils::CreateShaderModule(device, wgsl.c_str());
         } else {
             ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, wgsl.c_str()));
@@ -857,13 +859,13 @@
 TEST_F(ShaderModuleExtensionValidationTestUnsafeNoFeature,
        OnlyExtensionsRequiringNoFeatureAllowed) {
     for (auto& extension : kExtensions) {
-        std::string wgsl = std::string("enable ") + extension.WGSLName + R"(;
+        std::string wgsl = std::string("enable ") + extension.wgslName + R"(;
 
 @compute @workgroup_size(1) fn main() {})";
 
         // On an unsafe device with no feature required, only extensions requiring no features are
         // allowed.
-        if (!extension.RequiredFeatureName) {
+        if (!extension.requiredFeatureName) {
             utils::CreateShaderModule(device, wgsl.c_str());
         } else {
             ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, wgsl.c_str()));
@@ -888,7 +890,7 @@
 
 TEST_F(ShaderModuleExtensionValidationTestSafeAllFeatures, OnlyStableExtensionsAllowed) {
     for (auto& extension : kExtensions) {
-        std::string wgsl = std::string("enable ") + extension.WGSLName + R"(;
+        std::string wgsl = std::string("enable ") + extension.wgslName + R"(;
 
 @compute @workgroup_size(1) fn main() {})";
 
@@ -918,7 +920,7 @@
 
 TEST_F(ShaderModuleExtensionValidationTestUnsafeAllFeatures, AllExtensionsAllowed) {
     for (auto& extension : kExtensions) {
-        std::string wgsl = std::string("enable ") + extension.WGSLName + R"(;
+        std::string wgsl = std::string("enable ") + extension.wgslName + R"(;
 
 @compute @workgroup_size(1) fn main() {})";
 
diff --git a/src/dawn/wire/SupportedFeatures.cpp b/src/dawn/wire/SupportedFeatures.cpp
index 5a3f191..1097dca 100644
--- a/src/dawn/wire/SupportedFeatures.cpp
+++ b/src/dawn/wire/SupportedFeatures.cpp
@@ -84,6 +84,7 @@
         case WGPUFeatureName_PixelLocalStorageCoherent:
         case WGPUFeatureName_PixelLocalStorageNonCoherent:
         case WGPUFeatureName_Norm16TextureFormats:
+        case WGPUFeatureName_FramebufferFetch:
             return true;
     }