diff --git a/src/video_core/compatible_formats.cpp b/src/video_core/compatible_formats.cpp
index acf2668dc0..8317d06369 100644
--- a/src/video_core/compatible_formats.cpp
+++ b/src/video_core/compatible_formats.cpp
@@ -48,6 +48,15 @@ constexpr std::array VIEW_CLASS_32_BITS{
     PixelFormat::A2B10G10R10_UINT,
 };
 
+constexpr std::array VIEW_CLASS_32_BITS_NO_BGR{
+    PixelFormat::R16G16_FLOAT,      PixelFormat::B10G11R11_FLOAT,  PixelFormat::R32_FLOAT,
+    PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,      PixelFormat::R32_UINT,
+    PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,         PixelFormat::A8B8G8R8_UNORM,
+    PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,   PixelFormat::R16G16_SNORM,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,   PixelFormat::A8B8G8R8_UINT,
+    PixelFormat::A8B8G8R8_SINT,     PixelFormat::A2B10G10R10_UINT,
+};
+
 // TODO: How should we handle 24 bits?
 
 constexpr std::array VIEW_CLASS_16_BITS{
@@ -205,7 +214,6 @@ constexpr Table MakeViewTable() {
     EnableRange(view, VIEW_CLASS_128_BITS);
     EnableRange(view, VIEW_CLASS_96_BITS);
     EnableRange(view, VIEW_CLASS_64_BITS);
-    EnableRange(view, VIEW_CLASS_32_BITS);
     EnableRange(view, VIEW_CLASS_16_BITS);
     EnableRange(view, VIEW_CLASS_8_BITS);
     EnableRange(view, VIEW_CLASS_RGTC1_RED);
@@ -231,20 +239,47 @@ constexpr Table MakeCopyTable() {
     EnableRange(copy, COPY_CLASS_64_BITS);
     return copy;
 }
+
+constexpr Table MakeNativeBgrViewTable() {
+    Table copy = MakeViewTable();
+    EnableRange(copy, VIEW_CLASS_32_BITS);
+    return copy;
+}
+
+constexpr Table MakeNonNativeBgrViewTable() {
+    Table copy = MakeViewTable();
+    EnableRange(copy, VIEW_CLASS_32_BITS_NO_BGR);
+    return copy;
+}
+
+constexpr Table MakeNativeBgrCopyTable() {
+    Table copy = MakeCopyTable();
+    EnableRange(copy, VIEW_CLASS_32_BITS);
+    return copy;
+}
+
+constexpr Table MakeNonNativeBgrCopyTable() {
+    Table copy = MakeCopyTable();
+    EnableRange(copy, VIEW_CLASS_32_BITS);
+    return copy;
+}
 } // Anonymous namespace
 
-bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views) {
+bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views,
+                      bool native_bgr) {
     if (broken_views) {
         // If format views are broken, only accept formats that are identical.
         return format_a == format_b;
     }
-    static constexpr Table TABLE = MakeViewTable();
-    return IsSupported(TABLE, format_a, format_b);
+    static constexpr Table BGR_TABLE = MakeNativeBgrViewTable();
+    static constexpr Table NO_BGR_TABLE = MakeNonNativeBgrViewTable();
+    return IsSupported(native_bgr ? BGR_TABLE : NO_BGR_TABLE, format_a, format_b);
 }
 
-bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b) {
-    static constexpr Table TABLE = MakeCopyTable();
-    return IsSupported(TABLE, format_a, format_b);
+bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b, bool native_bgr) {
+    static constexpr Table BGR_TABLE = MakeNativeBgrCopyTable();
+    static constexpr Table NO_BGR_TABLE = MakeNonNativeBgrCopyTable();
+    return IsSupported(native_bgr ? BGR_TABLE : NO_BGR_TABLE, format_a, format_b);
 }
 
 } // namespace VideoCore::Surface
diff --git a/src/video_core/compatible_formats.h b/src/video_core/compatible_formats.h
index 9a05229889..55745e0421 100644
--- a/src/video_core/compatible_formats.h
+++ b/src/video_core/compatible_formats.h
@@ -8,8 +8,9 @@
 
 namespace VideoCore::Surface {
 
-bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views);
+bool IsViewCompatible(PixelFormat format_a, PixelFormat format_b, bool broken_views,
+                      bool native_bgr);
 
-bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b);
+bool IsCopyCompatible(PixelFormat format_a, PixelFormat format_b, bool native_bgr);
 
 } // namespace VideoCore::Surface
diff --git a/src/video_core/renderer_opengl/gl_texture_cache.h b/src/video_core/renderer_opengl/gl_texture_cache.h
index a6172f009e..3fbaa102fc 100644
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -86,6 +86,11 @@ public:
 
     FormatProperties FormatInfo(VideoCommon::ImageType type, GLenum internal_format) const;
 
+    bool HasNativeBgr() const noexcept {
+        // OpenGL does not have native support for the BGR internal format
+        return false;
+    }
+
     bool HasBrokenTextureViewFormats() const noexcept {
         return has_broken_texture_view_formats;
     }
diff --git a/src/video_core/renderer_vulkan/vk_texture_cache.h b/src/video_core/renderer_vulkan/vk_texture_cache.h
index b08c234590..3aee27ce08 100644
--- a/src/video_core/renderer_vulkan/vk_texture_cache.h
+++ b/src/video_core/renderer_vulkan/vk_texture_cache.h
@@ -93,6 +93,11 @@ struct TextureCacheRuntime {
         // No known Vulkan driver has broken image views
         return false;
     }
+
+    bool HasNativeBgr() const noexcept {
+        // All known Vulkan drivers can natively handle BGR textures
+        return true;
+    }
 };
 
 class Image : public VideoCommon::ImageBase {
diff --git a/src/video_core/texture_cache/image_base.cpp b/src/video_core/texture_cache/image_base.cpp
index 959b3f1153..9914926b3c 100644
--- a/src/video_core/texture_cache/image_base.cpp
+++ b/src/video_core/texture_cache/image_base.cpp
@@ -120,9 +120,10 @@ void AddImageAlias(ImageBase& lhs, ImageBase& rhs, ImageId lhs_id, ImageId rhs_i
     if (lhs.info.type == ImageType::Linear) {
         base = SubresourceBase{.level = 0, .layer = 0};
     } else {
-        // We are passing relaxed formats as an option, having broken views or not won't matter
+        // We are passing relaxed formats as an option, having broken views/bgr or not won't matter
         static constexpr bool broken_views = false;
-        base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS, broken_views);
+        static constexpr bool native_bgr = true;
+        base = FindSubresource(rhs.info, lhs, rhs.gpu_addr, OPTIONS, broken_views, native_bgr);
     }
     if (!base) {
         LOG_ERROR(HW_GPU, "Image alias should have been flipped");
diff --git a/src/video_core/texture_cache/image_view_base.cpp b/src/video_core/texture_cache/image_view_base.cpp
index 18f72e5089..f89a40b4c4 100644
--- a/src/video_core/texture_cache/image_view_base.cpp
+++ b/src/video_core/texture_cache/image_view_base.cpp
@@ -24,7 +24,7 @@ ImageViewBase::ImageViewBase(const ImageViewInfo& info, const ImageInfo& image_i
           .height = std::max(image_info.size.height >> range.base.level, 1u),
           .depth = std::max(image_info.size.depth >> range.base.level, 1u),
       } {
-    ASSERT_MSG(VideoCore::Surface::IsViewCompatible(image_info.format, info.format, false),
+    ASSERT_MSG(VideoCore::Surface::IsViewCompatible(image_info.format, info.format, false, true),
                "Image view format {} is incompatible with image format {}", info.format,
                image_info.format);
     const bool is_async = Settings::values.use_asynchronous_gpu_emulation.GetValue();
diff --git a/src/video_core/texture_cache/texture_cache.h b/src/video_core/texture_cache/texture_cache.h
index b1da69971d..98e33c3a08 100644
--- a/src/video_core/texture_cache/texture_cache.h
+++ b/src/video_core/texture_cache/texture_cache.h
@@ -876,6 +876,7 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
         return ImageId{};
     }
     const bool broken_views = runtime.HasBrokenTextureViewFormats();
+    const bool native_bgr = runtime.HasNativeBgr();
     ImageId image_id;
     const auto lambda = [&](ImageId existing_image_id, ImageBase& existing_image) {
         if (info.type == ImageType::Linear || existing_image.info.type == ImageType::Linear) {
@@ -885,11 +886,12 @@ ImageId TextureCache<P>::FindImage(const ImageInfo& info, GPUVAddr gpu_addr,
             if (existing_image.gpu_addr == gpu_addr && existing.type == info.type &&
                 existing.pitch == info.pitch &&
                 IsPitchLinearSameSize(existing, info, strict_size) &&
-                IsViewCompatible(existing.format, info.format, broken_views)) {
+                IsViewCompatible(existing.format, info.format, broken_views, native_bgr)) {
                 image_id = existing_image_id;
                 return true;
             }
-        } else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views)) {
+        } else if (IsSubresource(info, existing_image, gpu_addr, options, broken_views,
+                                 native_bgr)) {
             image_id = existing_image_id;
             return true;
         }
@@ -920,6 +922,7 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
     ImageInfo new_info = info;
     const size_t size_bytes = CalculateGuestSizeInBytes(new_info);
     const bool broken_views = runtime.HasBrokenTextureViewFormats();
+    const bool native_bgr = runtime.HasNativeBgr();
     std::vector<ImageId> overlap_ids;
     std::vector<ImageId> left_aliased_ids;
     std::vector<ImageId> right_aliased_ids;
@@ -935,8 +938,8 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
             return;
         }
         static constexpr bool strict_size = true;
-        const std::optional<OverlapResult> solution =
-            ResolveOverlap(new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views);
+        const std::optional<OverlapResult> solution = ResolveOverlap(
+            new_info, gpu_addr, cpu_addr, overlap, strict_size, broken_views, native_bgr);
         if (solution) {
             gpu_addr = solution->gpu_addr;
             cpu_addr = solution->cpu_addr;
@@ -946,10 +949,10 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, VA
         }
         static constexpr auto options = RelaxedOptions::Size | RelaxedOptions::Format;
         const ImageBase new_image_base(new_info, gpu_addr, cpu_addr);
-        if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views)) {
+        if (IsSubresource(new_info, overlap, gpu_addr, options, broken_views, native_bgr)) {
             left_aliased_ids.push_back(overlap_id);
         } else if (IsSubresource(overlap.info, new_image_base, overlap.gpu_addr, options,
-                                 broken_views)) {
+                                 broken_views, native_bgr)) {
             right_aliased_ids.push_back(overlap_id);
         }
     });
diff --git a/src/video_core/texture_cache/util.cpp b/src/video_core/texture_cache/util.cpp
index a0bc1f7b69..2c42d1449e 100644
--- a/src/video_core/texture_cache/util.cpp
+++ b/src/video_core/texture_cache/util.cpp
@@ -1035,13 +1035,13 @@ bool IsPitchLinearSameSize(const ImageInfo& lhs, const ImageInfo& rhs, bool stri
 
 std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info, GPUVAddr gpu_addr,
                                             VAddr cpu_addr, const ImageBase& overlap,
-                                            bool strict_size, bool broken_views) {
+                                            bool strict_size, bool broken_views, bool native_bgr) {
     ASSERT(new_info.type != ImageType::Linear);
     ASSERT(overlap.info.type != ImageType::Linear);
     if (!IsLayerStrideCompatible(new_info, overlap.info)) {
         return std::nullopt;
     }
-    if (!IsViewCompatible(overlap.info.format, new_info.format, broken_views)) {
+    if (!IsViewCompatible(overlap.info.format, new_info.format, broken_views, native_bgr)) {
         return std::nullopt;
     }
     if (gpu_addr == overlap.gpu_addr) {
@@ -1085,14 +1085,14 @@ bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs) {
 
 std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const ImageBase& image,
                                                GPUVAddr candidate_addr, RelaxedOptions options,
-                                               bool broken_views) {
+                                               bool broken_views, bool native_bgr) {
     const std::optional<SubresourceBase> base = image.TryFindBase(candidate_addr);
     if (!base) {
         return std::nullopt;
     }
     const ImageInfo& existing = image.info;
     if (False(options & RelaxedOptions::Format)) {
-        if (!IsViewCompatible(existing.format, candidate.format, broken_views)) {
+        if (!IsViewCompatible(existing.format, candidate.format, broken_views, native_bgr)) {
             return std::nullopt;
         }
     }
@@ -1129,8 +1129,9 @@ std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const
 }
 
 bool IsSubresource(const ImageInfo& candidate, const ImageBase& image, GPUVAddr candidate_addr,
-                   RelaxedOptions options, bool broken_views) {
-    return FindSubresource(candidate, image, candidate_addr, options, broken_views).has_value();
+                   RelaxedOptions options, bool broken_views, bool native_bgr) {
+    return FindSubresource(candidate, image, candidate_addr, options, broken_views, native_bgr)
+        .has_value();
 }
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
diff --git a/src/video_core/texture_cache/util.h b/src/video_core/texture_cache/util.h
index 52a9207d6e..4d0072867a 100644
--- a/src/video_core/texture_cache/util.h
+++ b/src/video_core/texture_cache/util.h
@@ -87,7 +87,8 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
 [[nodiscard]] std::optional<OverlapResult> ResolveOverlap(const ImageInfo& new_info,
                                                           GPUVAddr gpu_addr, VAddr cpu_addr,
                                                           const ImageBase& overlap,
-                                                          bool strict_size, bool broken_views);
+                                                          bool strict_size, bool broken_views,
+                                                          bool native_bgr);
 
 [[nodiscard]] bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs);
 
@@ -95,11 +96,11 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
                                                              const ImageBase& image,
                                                              GPUVAddr candidate_addr,
                                                              RelaxedOptions options,
-                                                             bool broken_views);
+                                                             bool broken_views, bool native_bgr);
 
 [[nodiscard]] bool IsSubresource(const ImageInfo& candidate, const ImageBase& image,
-                                 GPUVAddr candidate_addr, RelaxedOptions options,
-                                 bool broken_views);
+                                 GPUVAddr candidate_addr, RelaxedOptions options, bool broken_views,
+                                 bool native_bgr);
 
 void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase* dst,
                       const ImageBase* src);