diff --git a/benchmarks/babelstream/src/AlpakaStream.h b/benchmarks/babelstream/src/AlpakaStream.h
index ba556b028dba..0524fb37a0ce 100644
--- a/benchmarks/babelstream/src/AlpakaStream.h
+++ b/benchmarks/babelstream/src/AlpakaStream.h
@@ -42,8 +42,8 @@ struct AlpakaStream : Stream<T>
     using DevHost = alpaka::Dev<PlatformHost>;
     using PlatformAcc = alpaka::Platform<Acc>;
     using DevAcc = alpaka::Dev<Acc>;
-    using BufHost = alpaka::Buf<alpaka::DevCpu, T, Dim, Idx>;
-    using BufAcc = alpaka::Buf<Acc, T, Dim, Idx>;
+    using BufHost = alpaka::Buf<alpaka::DevCpu, T, Dim, Idx, alpaka::MemVisibilityTypeList<alpaka::DevCpu>>;
+    using BufAcc = alpaka::Buf<Acc, T, Dim, Idx, alpaka::MemVisibilityTypeList<Acc>>;
     using Queue = alpaka::Queue<Acc, alpaka::Blocking>;
 
     using WorkDiv = alpaka::WorkDivMembers<Dim, Idx>;
diff --git a/example/bufferCopy/src/bufferCopy.cpp b/example/bufferCopy/src/bufferCopy.cpp
index 12bd4a1a2acb..ad9d7cc08143 100644
--- a/example/bufferCopy/src/bufferCopy.cpp
+++ b/example/bufferCopy/src/bufferCopy.cpp
@@ -148,8 +148,7 @@ auto main() -> int
     //
     // The `alloc` method returns a reference counted buffer handle.
     // When the last such handle is destroyed, the memory is freed automatically.
-    using BufHost = alpaka::Buf<Host, Data, Dim, Idx>;
-    BufHost hostBuffer(alpaka::allocBuf<Data, Idx>(devHost, extents));
+    auto hostBuffer(alpaka::allocBuf<Data, Idx>(devHost, extents));
     // You can also use already allocated memory and wrap it within a view (irrespective of the device type).
     // The view does not own the underlying memory. So you have to make sure that
     // the view does not outlive its underlying memory.
@@ -159,7 +158,7 @@ auto main() -> int
     // Allocate accelerator memory buffers
     //
     // The interface to allocate a buffer is the same on the host and on the device.
-    using BufAcc = alpaka::Buf<Acc, Data, Dim, Idx>;
+    using BufAcc = alpaka::Buf<Acc, Data, Dim, Idx, alpaka::MemVisibilityTypeList<Acc>>;
     BufAcc deviceBuffer1(alpaka::allocBuf<Data, Idx>(devAcc, extents));
     BufAcc deviceBuffer2(alpaka::allocBuf<Data, Idx>(devAcc, extents));
 
diff --git a/example/convolution1D/src/convolution1D.cpp b/example/convolution1D/src/convolution1D.cpp
index 047f462ef0a7..ed3885bfff27 100644
--- a/example/convolution1D/src/convolution1D.cpp
+++ b/example/convolution1D/src/convolution1D.cpp
@@ -83,7 +83,7 @@ auto main() -> int
     using DevAcc = alpaka::ExampleDefaultAcc<Dim, Idx>;
     using QueueProperty = alpaka::Blocking;
     using QueueAcc = alpaka::Queue<DevAcc, QueueProperty>;
-    using BufAcc = alpaka::Buf<DevAcc, DataType, Dim, Idx>;
+    using BufAcc = alpaka::Buf<DevAcc, DataType, Dim, Idx, alpaka::MemVisibilityTypeList<DevAcc>>;
 
     std::cout << "Using alpaka accelerator: " << alpaka::getAccName<DevAcc>() << '\n';
 
diff --git a/example/counterBasedRng/src/counterBasedRng.cpp b/example/counterBasedRng/src/counterBasedRng.cpp
index 86da223f1d0a..0f2489639323 100644
--- a/example/counterBasedRng/src/counterBasedRng.cpp
+++ b/example/counterBasedRng/src/counterBasedRng.cpp
@@ -162,8 +162,7 @@ auto main() -> int
     CounterBasedRngKernel::Key key = {rd(), rd()};
 
     // Allocate buffer on the accelerator
-    using BufAcc = alpaka::Buf<Acc, Data, Dim, Idx>;
-    BufAcc bufAcc(alpaka::allocBuf<Data, Idx>(devAcc, extent));
+    auto bufAcc(alpaka::allocBuf<Data, Idx>(devAcc, extent));
 
     // Create the kernel execution task.
     auto const taskKernelAcc = alpaka::createTaskKernel<Acc>(
diff --git a/example/heatEquation/src/heatEquation.cpp b/example/heatEquation/src/heatEquation.cpp
index ff7ee6c7dafe..4e97e15f6974 100644
--- a/example/heatEquation/src/heatEquation.cpp
+++ b/example/heatEquation/src/heatEquation.cpp
@@ -121,9 +121,8 @@ auto main() -> int
     double* const pNextHost = std::data(uNextBufHost);
 
     // Accelerator buffer
-    using BufAcc = alpaka::Buf<Acc, double, Dim, Idx>;
-    auto uNextBufAcc = BufAcc{alpaka::allocBuf<double, Idx>(devAcc, extent)};
-    auto uCurrBufAcc = BufAcc{alpaka::allocBuf<double, Idx>(devAcc, extent)};
+    auto uNextBufAcc{alpaka::allocBuf<double, Idx>(devAcc, extent)};
+    auto uCurrBufAcc{alpaka::allocBuf<double, Idx>(devAcc, extent)};
 
     double* pCurrAcc = std::data(uCurrBufAcc);
     double* pNextAcc = std::data(uNextBufAcc);
diff --git a/example/monteCarloIntegration/src/monteCarloIntegration.cpp b/example/monteCarloIntegration/src/monteCarloIntegration.cpp
index 52e050785c88..1059c75b8a7b 100644
--- a/example/monteCarloIntegration/src/monteCarloIntegration.cpp
+++ b/example/monteCarloIntegration/src/monteCarloIntegration.cpp
@@ -88,8 +88,6 @@ auto main() -> int
     using QueueAcc = alpaka::Queue<Acc, QueueProperty>;
     QueueAcc queue{devAcc};
 
-    using BufHost = alpaka::Buf<Host, uint32_t, Dim, Idx>;
-    using BufAcc = alpaka::Buf<Acc, uint32_t, Dim, Idx>;
     using WorkDiv = alpaka::WorkDivMembers<Dim, Idx>;
     // Problem parameter.
     constexpr size_t numPoints = 1'000'000u;
@@ -104,8 +102,8 @@ auto main() -> int
         alpaka::GridBlockExtentSubDivRestrictions::Unrestricted)};
 
     // Setup buffer.
-    BufHost bufHost{alpaka::allocBuf<uint32_t, Idx>(devHost, extent)};
-    BufAcc bufAcc{alpaka::allocBuf<uint32_t, Idx>(devAcc, extent)};
+    auto bufHost{alpaka::allocBuf<uint32_t, Idx>(devHost, extent)};
+    auto bufAcc{alpaka::allocBuf<uint32_t, Idx>(devAcc, extent)};
     uint32_t* const ptrBufAcc{std::data(bufAcc)};
 
     // Initialize the global count to 0.
diff --git a/example/randomCells2D/src/randomCells2D.cpp b/example/randomCells2D/src/randomCells2D.cpp
index a0a21370cecc..1f614f7ce516 100644
--- a/example/randomCells2D/src/randomCells2D.cpp
+++ b/example/randomCells2D/src/randomCells2D.cpp
@@ -156,12 +156,12 @@ auto main() -> int
     using QueueAcc = alpaka::Queue<Acc, QueueProperty>;
     QueueAcc queue{devAcc};
 
-    using BufHost = alpaka::Buf<Host, float, Dim, Idx>;
-    using BufAcc = alpaka::Buf<Acc, float, Dim, Idx>;
-    using BufHostRand = alpaka::Buf<Host, RandomEngineSingle, Dim, Idx>;
-    using BufAccRand = alpaka::Buf<Acc, RandomEngineSingle, Dim, Idx>;
-    using BufHostRandVec = alpaka::Buf<Host, RandomEngineVector, Dim, Idx>;
-    using BufAccRandVec = alpaka::Buf<Acc, RandomEngineVector, Dim, Idx>;
+    using BufHost = alpaka::Buf<Host, float, Dim, Idx, alpaka::MemVisibilityTypeList<Host>>;
+    using BufAcc = alpaka::Buf<Acc, float, Dim, Idx, alpaka::MemVisibilityTypeList<Acc>>;
+    using BufHostRand = alpaka::Buf<Host, RandomEngineSingle, Dim, Idx, alpaka::MemVisibilityTypeList<Host>>;
+    using BufAccRand = alpaka::Buf<Acc, RandomEngineSingle, Dim, Idx, alpaka::MemVisibilityTypeList<Acc>>;
+    using BufHostRandVec = alpaka::Buf<Host, RandomEngineVector, Dim, Idx, alpaka::MemVisibilityTypeList<Host>>;
+    using BufAccRandVec = alpaka::Buf<Acc, RandomEngineVector, Dim, Idx, alpaka::MemVisibilityTypeList<Acc>>;
     using WorkDiv = alpaka::WorkDivMembers<Dim, Idx>;
 
     constexpr Idx numX = NUM_X;
diff --git a/example/randomStrategies/src/randomStrategies.cpp b/example/randomStrategies/src/randomStrategies.cpp
index 3dd0c9efde5e..43f01d0fe00f 100644
--- a/example/randomStrategies/src/randomStrategies.cpp
+++ b/example/randomStrategies/src/randomStrategies.cpp
@@ -44,8 +44,8 @@ struct Box
     QueueAcc queue; ///< default accelerator queue
 
     // buffers holding the PRNG states
-    using BufHostRand = alpaka::Buf<Host, RandomEngine, Dim, Idx>;
-    using BufAccRand = alpaka::Buf<Acc, RandomEngine, Dim, Idx>;
+    using BufHostRand = alpaka::Buf<Host, RandomEngine, Dim, Idx, alpaka::MemVisibilityTypeList<PlatformHost>>;
+    using BufAccRand = alpaka::Buf<Acc, RandomEngine, Dim, Idx, alpaka::MemVisibilityTypeList<PlatformAcc>>;
 
     Vec const extentRand; ///< size of the buffer of PRNG states
     WorkDiv workdivRand; ///< work division for PRNG buffer initialization
@@ -53,8 +53,8 @@ struct Box
     BufAccRand bufAccRand; ///< device side PRNG states buffer
 
     // buffers holding the "simulation" results
-    using BufHost = alpaka::Buf<Host, float, Dim, Idx>;
-    using BufAcc = alpaka::Buf<Acc, float, Dim, Idx>;
+    using BufHost = alpaka::Buf<Host, float, Dim, Idx, alpaka::MemVisibilityTypeList<PlatformHost>>;
+    using BufAcc = alpaka::Buf<Acc, float, Dim, Idx, alpaka::MemVisibilityTypeList<PlatformAcc>>;
 
     Vec const extentResult; ///< size of the results buffer
     WorkDiv workdivResult; ///< work division of the result calculation
diff --git a/example/reduce/src/reduce.cpp b/example/reduce/src/reduce.cpp
index 2d5fe2c1dc21..d132995ef9d7 100644
--- a/example/reduce/src/reduce.cpp
+++ b/example/reduce/src/reduce.cpp
@@ -49,7 +49,7 @@ auto reduce(
     DevAcc devAcc,
     QueueAcc queue,
     uint64_t n,
-    alpaka::Buf<DevHost, T, Dim, Idx> hostMemory,
+    alpaka::Buf<DevHost, T, Dim, Idx, alpaka::MemVisibilityTypeList<DevHost>> hostMemory,
     TFunc func) -> T
 {
     static constexpr uint64_t blockSize = getMaxBlockSize<Accelerator, 256>();
@@ -62,10 +62,11 @@ auto reduce(
     if(blockCount > maxBlockCount)
         blockCount = maxBlockCount;
 
-    alpaka::Buf<DevAcc, T, Dim, Extent> sourceDeviceMemory = alpaka::allocBuf<T, Idx>(devAcc, n);
+    using DevBuf = alpaka::Buf<DevAcc, T, Dim, Extent, alpaka::MemVisibilityTypeList<DevAcc>>;
 
-    alpaka::Buf<DevAcc, T, Dim, Extent> destinationDeviceMemory
-        = alpaka::allocBuf<T, Idx>(devAcc, static_cast<Extent>(blockCount));
+    DevBuf sourceDeviceMemory = alpaka::allocBuf<T, Idx>(devAcc, n);
+
+    DevBuf destinationDeviceMemory = alpaka::allocBuf<T, Idx>(devAcc, static_cast<Extent>(blockCount));
 
     // copy the data to the GPU
     alpaka::memcpy(queue, sourceDeviceMemory, hostMemory, n);
diff --git a/example/vectorAdd/src/vectorAdd.cpp b/example/vectorAdd/src/vectorAdd.cpp
index 5eca205279c8..1639a7602616 100644
--- a/example/vectorAdd/src/vectorAdd.cpp
+++ b/example/vectorAdd/src/vectorAdd.cpp
@@ -111,8 +111,8 @@ auto main() -> int
     auto const devHost = alpaka::getDevByIdx(platformHost, 0);
 
     // Allocate 3 host memory buffers
-    using BufHost = alpaka::Buf<DevHost, Data, Dim, Idx>;
-    BufHost bufHostA(alpaka::allocBuf<Data, Idx>(devHost, extent));
+    auto bufHostA(alpaka::allocBuf<Data, Idx>(devHost, extent));
+    using BufHost = decltype(bufHostA);
     BufHost bufHostB(alpaka::allocBuf<Data, Idx>(devHost, extent));
     BufHost bufHostC(alpaka::allocBuf<Data, Idx>(devHost, extent));
 
@@ -129,8 +129,8 @@ auto main() -> int
     }
 
     // Allocate 3 buffers on the accelerator
-    using BufAcc = alpaka::Buf<DevAcc, Data, Dim, Idx>;
-    BufAcc bufAccA(alpaka::allocBuf<Data, Idx>(devAcc, extent));
+    auto bufAccA(alpaka::allocBuf<Data, Idx>(devAcc, extent));
+    using BufAcc = decltype(bufAccA);
     BufAcc bufAccB(alpaka::allocBuf<Data, Idx>(devAcc, extent));
     BufAcc bufAccC(alpaka::allocBuf<Data, Idx>(devAcc, extent));
 
diff --git a/include/alpaka/acc/AccGenericSycl.hpp b/include/alpaka/acc/AccGenericSycl.hpp
index fc8ba1da760f..9e533f892701 100644
--- a/include/alpaka/acc/AccGenericSycl.hpp
+++ b/include/alpaka/acc/AccGenericSycl.hpp
@@ -118,6 +118,11 @@ namespace alpaka::trait
     {
     };
 
+    struct MemVisibility<alpaka::AccCpuSerial<TDim, TIdx>>
+    {
+        using type = alpaka::MemVisibleGenericSycl;
+    };
+
     //! The SYCL accelerator device properties get trait specialization.
     template<template<typename, typename> typename TAcc, typename TDim, typename TIdx>
     struct GetAccDevProps<
diff --git a/include/alpaka/acc/Tag.hpp b/include/alpaka/acc/Tag.hpp
index f7880afd6f15..73575daa0a4d 100644
--- a/include/alpaka/acc/Tag.hpp
+++ b/include/alpaka/acc/Tag.hpp
@@ -31,6 +31,7 @@ namespace alpaka
     CREATE_ACC_TAG(TagGpuCudaRt);
     CREATE_ACC_TAG(TagGpuHipRt);
     CREATE_ACC_TAG(TagGpuSyclIntel);
+#undef CREATE_ACC_TAG
 
     namespace trait
     {
diff --git a/include/alpaka/alpaka.hpp b/include/alpaka/alpaka.hpp
index e06dede53d48..b0458c00249e 100644
--- a/include/alpaka/alpaka.hpp
+++ b/include/alpaka/alpaka.hpp
@@ -130,6 +130,7 @@
 #include "alpaka/math/MathStdLib.hpp"
 #include "alpaka/math/MathUniformCudaHipBuiltIn.hpp"
 // mem
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/alloc/AllocCpuAligned.hpp"
 #include "alpaka/mem/alloc/AllocCpuNew.hpp"
 #include "alpaka/mem/alloc/Traits.hpp"
diff --git a/include/alpaka/dev/DevCpu.hpp b/include/alpaka/dev/DevCpu.hpp
index e36c263072fa..b1cda711541b 100644
--- a/include/alpaka/dev/DevCpu.hpp
+++ b/include/alpaka/dev/DevCpu.hpp
@@ -167,16 +167,16 @@ namespace alpaka
         };
     } // namespace trait
 
-    template<typename TElem, typename TDim, typename TIdx>
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
     class BufCpu;
 
     namespace trait
     {
         //! The CPU device memory buffer type trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct BufType<DevCpu, TElem, TDim, TIdx>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct BufType<DevCpu, TElem, TDim, TIdx, TMemVisibility>
         {
-            using type = BufCpu<TElem, TDim, TIdx>;
+            using type = BufCpu<TElem, TDim, TIdx, TMemVisibility>;
         };
 
         //! The CPU device platform type trait specialization.
diff --git a/include/alpaka/dev/DevGenericSycl.hpp b/include/alpaka/dev/DevGenericSycl.hpp
index 729090f8f2d3..55902d840f15 100644
--- a/include/alpaka/dev/DevGenericSycl.hpp
+++ b/include/alpaka/dev/DevGenericSycl.hpp
@@ -32,7 +32,7 @@
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx, typename TDev>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
     class BufGenericSycl;
 
     namespace detail
@@ -219,10 +219,10 @@ namespace alpaka::trait
     };
 
     //! The SYCL device memory buffer type trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct BufType<DevGenericSycl<TPlatform>, TElem, TDim, TIdx>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct BufType<DevGenericSycl<TPlatform>, TElem, TDim, TIdx, TMemVisibility>
     {
-        using type = BufGenericSycl<TElem, TDim, TIdx, TPlatform>;
+        using type = BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>;
     };
 
     //! The SYCL device platform type trait specialization.
diff --git a/include/alpaka/dev/DevUniformCudaHipRt.hpp b/include/alpaka/dev/DevUniformCudaHipRt.hpp
index 876d8ca5a434..dfbc1dc62d77 100644
--- a/include/alpaka/dev/DevUniformCudaHipRt.hpp
+++ b/include/alpaka/dev/DevUniformCudaHipRt.hpp
@@ -48,7 +48,7 @@ namespace alpaka
     template<typename TApi>
     struct PlatformUniformCudaHipRt;
 
-    template<typename TApi, typename TElem, typename TDim, typename TIdx>
+    template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
     struct BufUniformCudaHipRt;
 
     //! The CUDA/HIP RT device handle.
@@ -222,10 +222,10 @@ namespace alpaka
         };
 
         //! The CUDA/HIP RT device memory buffer type trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct BufType<DevUniformCudaHipRt<TApi>, TElem, TDim, TIdx>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct BufType<DevUniformCudaHipRt<TApi>, TElem, TDim, TIdx, TMemVisibility>
         {
-            using type = BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>;
+            using type = BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>;
         };
 
         //! The CUDA/HIP RT device platform type trait specialization.
diff --git a/include/alpaka/mem/Visibility.hpp b/include/alpaka/mem/Visibility.hpp
new file mode 100644
index 000000000000..349beb719e20
--- /dev/null
+++ b/include/alpaka/mem/Visibility.hpp
@@ -0,0 +1,153 @@
+/* Copyright 2023 Simeon Ehrig
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+#pragma once
+
+#include "alpaka/acc/Traits.hpp"
+#include "alpaka/dev/Traits.hpp"
+#include "alpaka/mem/view/ViewAccessOps.hpp"
+#include "alpaka/meta/ForEachType.hpp"
+#include "alpaka/meta/TypeListOps.hpp"
+#include "alpaka/platform/Traits.hpp"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#define CREATE_MEM_VISIBILITY(mem_name)                                                                               \
+    struct mem_name                                                                                                   \
+    {                                                                                                                 \
+        static std::string get_name()                                                                                 \
+        {                                                                                                             \
+            return #mem_name;                                                                                         \
+        }                                                                                                             \
+    }
+
+namespace alpaka
+{
+    CREATE_MEM_VISIBILITY(MemVisibleCPU);
+    CREATE_MEM_VISIBILITY(MemVisibleFpgaSyclIntel);
+    CREATE_MEM_VISIBILITY(MemVisibleGenericSycl);
+    CREATE_MEM_VISIBILITY(MemVisibleCpuSycl);
+    CREATE_MEM_VISIBILITY(MemVisibleGpuCudaRt);
+    CREATE_MEM_VISIBILITY(MemVisibleGpuHipRt);
+    CREATE_MEM_VISIBILITY(MemVisibleGpuSyclIntel);
+#undef CREATE_MEM_VISIBILITY
+
+    namespace trait
+    {
+        //! Get memory visibility from a type.
+        //! Normally it is acc or buffer type.
+        //!
+        //! \tparam TType which implements the trait
+        template<typename TType>
+        struct MemVisibility;
+    } // namespace trait
+
+    namespace detail
+    {
+        struct AppendMemTypeName
+        {
+            template<typename TTYPE>
+            void operator()(std::vector<std::string>& vs)
+            {
+                vs.push_back(TTYPE::get_name());
+            }
+        };
+    } // namespace detail
+
+    template<
+        typename T,
+        typename = std::enable_if_t<
+            alpaka::isPlatform<std::decay_t<T>> || alpaka::isDevice<std::decay_t<T>>
+            || alpaka::isAccelerator<std::decay_t<T>> || alpaka::internal::isView<std::decay_t<T>>>>
+    inline std::string getMemVisiblityName()
+    {
+        using MemVisibilityType = typename alpaka::trait::MemVisibility<std::decay_t<T>>::type;
+        if constexpr(alpaka::meta::isList<MemVisibilityType>)
+        {
+            std::vector<std::string> vs;
+            alpaka::meta::forEachType<MemVisibilityType>(detail::AppendMemTypeName{}, vs);
+
+            std::stringstream ss;
+            ss << "<";
+            for(std::size_t i = 0; i < vs.size(); ++i)
+            {
+                if(i == (vs.size() - 1))
+                {
+                    ss << vs[i] << ">";
+                }
+                else
+                {
+                    ss << vs[i] << ", ";
+                }
+            }
+            return ss.str();
+        }
+        else
+        {
+            return MemVisibilityType::get_name();
+        }
+    }
+
+    template<typename TType>
+    [[maybe_unused]] static std::string getMemVisiblityName(TType)
+    {
+        return getMemVisiblityName<TType>();
+    }
+
+    template<
+        typename T,
+        typename TBuf,
+        typename = std::enable_if_t<
+            (alpaka::isPlatform<std::decay_t<T>> || alpaka::isDevice<std::decay_t<T>>
+             || alpaka::isAccelerator<std::decay_t<T>>) &&alpaka::internal::isView<std::decay_t<TBuf>>>>
+    inline constexpr bool hasSameMemView()
+    {
+        if constexpr(alpaka::isDevice<std::decay_t<T>> || alpaka::isAccelerator<std::decay_t<T>>)
+        {
+            using Platform = alpaka::Platform<T>;
+            return alpaka::meta::Contains<
+                typename alpaka::trait::MemVisibility<TBuf>::type,
+                typename alpaka::trait::MemVisibility<Platform>::type>::value;
+        }
+        else
+        {
+            return alpaka::meta::Contains<
+                typename alpaka::trait::MemVisibility<TBuf>::type,
+                typename alpaka::trait::MemVisibility<T>::type>::value;
+        }
+        ALPAKA_UNREACHABLE({});
+    }
+
+    template<typename TDev, typename TBuf>
+    inline constexpr bool hasSameMemView(TDev&, TBuf&)
+    {
+        return hasSameMemView<std::decay_t<TDev>, std::decay_t<TBuf>>();
+    }
+
+    namespace detail
+    {
+        template<typename T, typename = void>
+        struct MemVisibilityHelper
+        {
+            using type = typename alpaka::trait::MemVisibility<T>::type;
+        };
+
+        template<typename T>
+        struct MemVisibilityHelper<
+            T,
+            std::enable_if_t<alpaka::isDevice<std::decay_t<T>> || alpaka::isAccelerator<std::decay_t<T>>>>
+        {
+            using type = typename alpaka::trait::MemVisibility<alpaka::Platform<std::decay_t<T>>>::type;
+        };
+    } // namespace detail
+
+    template<typename T>
+    using MemVisibility = typename alpaka::detail::MemVisibilityHelper<std::decay_t<T>>::type;
+
+    template<typename T>
+    using MemVisibilityTypeList = alpaka::meta::toTuple<alpaka::MemVisibility<std::decay_t<T>>>;
+} // namespace alpaka
diff --git a/include/alpaka/mem/buf/BufCpu.hpp b/include/alpaka/mem/buf/BufCpu.hpp
index 4bfc91c73332..1045933965b4 100644
--- a/include/alpaka/mem/buf/BufCpu.hpp
+++ b/include/alpaka/mem/buf/BufCpu.hpp
@@ -11,10 +11,12 @@
 #include "alpaka/core/Vectorize.hpp"
 #include "alpaka/dev/DevCpu.hpp"
 #include "alpaka/dev/Traits.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/alloc/AllocCpuAligned.hpp"
 #include "alpaka/mem/buf/Traits.hpp"
 #include "alpaka/mem/view/ViewAccessOps.hpp"
 #include "alpaka/meta/DependentFalseType.hpp"
+#include "alpaka/meta/Unique.hpp"
 #include "alpaka/platform/PlatformCpu.hpp"
 #include "alpaka/vec/Vec.hpp"
 
@@ -85,8 +87,8 @@ namespace alpaka
     } // namespace detail
 
     //! The CPU memory buffer.
-    template<typename TElem, typename TDim, typename TIdx>
-    class BufCpu : public internal::ViewAccessOps<BufCpu<TElem, TDim, TIdx>>
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    class BufCpu : public internal::ViewAccessOps<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
     {
     public:
         template<typename TExtent, typename Deleter>
@@ -103,67 +105,69 @@ namespace alpaka
     namespace trait
     {
         //! The BufCpu device type trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct DevType<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DevType<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = DevCpu;
         };
 
         //! The BufCpu device get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct GetDev<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetDev<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST static auto getDev(BufCpu<TElem, TDim, TIdx> const& buf) -> DevCpu
+            ALPAKA_FN_HOST static auto getDev(BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf) -> DevCpu
             {
                 return buf.m_spBufCpuImpl->m_dev;
             }
         };
 
         //! The BufCpu dimension getter trait.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct DimType<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DimType<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TDim;
         };
 
         //! The BufCpu memory element type get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct ElemType<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct ElemType<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TElem;
         };
 
         //! The BufCpu width get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct GetExtents<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetExtents<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(BufCpu<TElem, TDim, TIdx> const& buf)
+            ALPAKA_FN_HOST auto operator()(BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf)
             {
                 return buf.m_spBufCpuImpl->m_extentElements;
             }
         };
 
         //! The BufCpu native pointer get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct GetPtrNative<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrNative<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST static auto getPtrNative(BufCpu<TElem, TDim, TIdx> const& buf) -> TElem const*
+            ALPAKA_FN_HOST static auto getPtrNative(BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf)
+                -> TElem const*
             {
                 return buf.m_spBufCpuImpl->m_pMem;
             }
 
-            ALPAKA_FN_HOST static auto getPtrNative(BufCpu<TElem, TDim, TIdx>& buf) -> TElem*
+            ALPAKA_FN_HOST static auto getPtrNative(BufCpu<TElem, TDim, TIdx, TMemVisibility>& buf) -> TElem*
             {
                 return buf.m_spBufCpuImpl->m_pMem;
             }
         };
 
         //! The BufCpu pointer on device get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct GetPtrDev<BufCpu<TElem, TDim, TIdx>, DevCpu>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrDev<BufCpu<TElem, TDim, TIdx, TMemVisibility>, DevCpu, TMemVisibility>
         {
-            ALPAKA_FN_HOST static auto getPtrDev(BufCpu<TElem, TDim, TIdx> const& buf, DevCpu const& dev)
-                -> TElem const*
+            ALPAKA_FN_HOST static auto getPtrDev(
+                BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf,
+                DevCpu const& dev) -> TElem const*
             {
                 if(dev == getDev(buf))
                 {
@@ -175,7 +179,8 @@ namespace alpaka
                 }
             }
 
-            ALPAKA_FN_HOST static auto getPtrDev(BufCpu<TElem, TDim, TIdx>& buf, DevCpu const& dev) -> TElem*
+            ALPAKA_FN_HOST static auto getPtrDev(BufCpu<TElem, TDim, TIdx, TMemVisibility>& buf, DevCpu const& dev)
+                -> TElem*
             {
                 if(dev == getDev(buf))
                 {
@@ -193,7 +198,8 @@ namespace alpaka
         struct BufAlloc<TElem, TDim, TIdx, DevCpu>
         {
             template<typename TExtent>
-            ALPAKA_FN_HOST static auto allocBuf(DevCpu const& dev, TExtent const& extent) -> BufCpu<TElem, TDim, TIdx>
+            ALPAKA_FN_HOST static auto allocBuf(DevCpu const& dev, TExtent const& extent)
+                -> BufCpu<TElem, TDim, TIdx, std::tuple<alpaka::MemVisibility<DevCpu>>>
             {
                 ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -215,7 +221,11 @@ namespace alpaka
                 auto* memPtr = alpaka::malloc<TElem>(Allocator{}, static_cast<std::size_t>(getExtentProduct(extent)));
                 auto deleter = [](TElem* ptr) { alpaka::free(Allocator{}, ptr); };
 
-                return BufCpu<TElem, TDim, TIdx>(dev, memPtr, std::move(deleter), extent);
+                return BufCpu<TElem, TDim, TIdx, std::tuple<alpaka::MemVisibility<DevCpu>>>(
+                    dev,
+                    memPtr,
+                    std::move(deleter),
+                    extent);
             }
         };
 
@@ -224,7 +234,8 @@ namespace alpaka
         struct AsyncBufAlloc<TElem, TDim, TIdx, DevCpu>
         {
             template<typename TQueue, typename TExtent>
-            ALPAKA_FN_HOST static auto allocAsyncBuf(TQueue queue, TExtent const& extent) -> BufCpu<TElem, TDim, TIdx>
+            ALPAKA_FN_HOST static auto allocAsyncBuf(TQueue queue, TExtent const& extent)
+                -> BufCpu<TElem, TDim, TIdx, std::tuple<alpaka::MemVisibility<DevCpu>>>
             {
                 ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -260,7 +271,11 @@ namespace alpaka
                         });
                 };
 
-                return BufCpu<TElem, TDim, TIdx>(dev, memPtr, std::move(deleter), extent);
+                return BufCpu<TElem, TDim, TIdx, std::tuple<alpaka::MemVisibility<DevCpu>>>(
+                    dev,
+                    memPtr,
+                    std::move(deleter),
+                    extent);
             }
         };
 
@@ -278,7 +293,13 @@ namespace alpaka
             ALPAKA_FN_HOST static auto allocMappedBuf(
                 DevCpu const& host,
                 PlatformCpu const& /*platform*/,
-                TExtent const& extent) -> BufCpu<TElem, TDim, TIdx>
+                TExtent const& extent)
+                -> BufCpu<
+                    TElem,
+                    TDim,
+                    TIdx,
+                    alpaka::meta::Unique<
+                        std::tuple<alpaka::MemVisibility<DevCpu>, alpaka::MemVisibility<PlatformCpu>>>>
             {
                 // Allocate standard host memory.
                 return allocBuf<TElem, TIdx>(host, extent);
@@ -292,21 +313,28 @@ namespace alpaka
         };
 
         //! The BufCpu offset get trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct GetOffsets<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetOffsets<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(BufCpu<TElem, TDim, TIdx> const&) const -> Vec<TDim, TIdx>
+            ALPAKA_FN_HOST auto operator()(BufCpu<TElem, TDim, TIdx, TMemVisibility> const&) const -> Vec<TDim, TIdx>
             {
                 return Vec<TDim, TIdx>::zeros();
             }
         };
 
         //! The BufCpu idx type trait specialization.
-        template<typename TElem, typename TDim, typename TIdx>
-        struct IdxType<BufCpu<TElem, TDim, TIdx>>
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct IdxType<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TIdx;
         };
+
+        template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct MemVisibility<BufCpu<TElem, TDim, TIdx, TMemVisibility>>
+        {
+            using type = TMemVisibility;
+        };
+
     } // namespace trait
 } // namespace alpaka
 
diff --git a/include/alpaka/mem/buf/BufCpuSycl.hpp b/include/alpaka/mem/buf/BufCpuSycl.hpp
index d63eebf540ca..d6d05f487cb4 100644
--- a/include/alpaka/mem/buf/BufCpuSycl.hpp
+++ b/include/alpaka/mem/buf/BufCpuSycl.hpp
@@ -11,8 +11,8 @@
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx>
-    using BufCpuSycl = BufGenericSycl<TElem, TDim, TIdx, PlatformCpuSycl>;
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using BufCpuSycl = BufGenericSycl<TElem, TDim, TIdx, PlatformCpuSycl, TMemVisibility>;
 } // namespace alpaka
 
 #endif
diff --git a/include/alpaka/mem/buf/BufCudaRt.hpp b/include/alpaka/mem/buf/BufCudaRt.hpp
index a5e0020bdb62..f974b2490f3f 100644
--- a/include/alpaka/mem/buf/BufCudaRt.hpp
+++ b/include/alpaka/mem/buf/BufCudaRt.hpp
@@ -5,14 +5,16 @@
 #pragma once
 
 #include "alpaka/core/ApiCudaRt.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/buf/BufUniformCudaHipRt.hpp"
 
+
 #ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx>
-    using BufCudaRt = BufUniformCudaHipRt<ApiCudaRt, TElem, TDim, TIdx>;
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using BufCudaRt = BufUniformCudaHipRt<ApiCudaRt, TElem, TDim, TIdx, TMemVisibility>;
 } // namespace alpaka
 
 #endif // ALPAKA_ACC_GPU_CUDA_ENABLED
diff --git a/include/alpaka/mem/buf/BufFpgaSyclIntel.hpp b/include/alpaka/mem/buf/BufFpgaSyclIntel.hpp
index 2dca26f1984f..30238b69cc62 100644
--- a/include/alpaka/mem/buf/BufFpgaSyclIntel.hpp
+++ b/include/alpaka/mem/buf/BufFpgaSyclIntel.hpp
@@ -11,8 +11,8 @@
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx>
-    using BufFpgaSyclIntel = BufGenericSycl<TElem, TDim, TIdx, DevFpgaSyclIntel>;
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using BufFpgaSyclIntel = BufGenericSycl<TElem, TDim, TIdx, DevFpgaSyclIntel, TMemVisibility>;
 } // namespace alpaka
 
 #endif
diff --git a/include/alpaka/mem/buf/BufGenericSycl.hpp b/include/alpaka/mem/buf/BufGenericSycl.hpp
index b4a5fd94ed54..7f9d63c05cb7 100644
--- a/include/alpaka/mem/buf/BufGenericSycl.hpp
+++ b/include/alpaka/mem/buf/BufGenericSycl.hpp
@@ -9,9 +9,11 @@
 #include "alpaka/dev/Traits.hpp"
 #include "alpaka/dim/DimIntegralConst.hpp"
 #include "alpaka/dim/Traits.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/buf/BufCpu.hpp"
 #include "alpaka/mem/buf/Traits.hpp"
 #include "alpaka/mem/view/ViewAccessOps.hpp"
+#include "alpaka/meta/Unique.hpp"
 #include "alpaka/vec/Vec.hpp"
 
 #include <memory>
@@ -24,8 +26,8 @@
 namespace alpaka
 {
     //! The SYCL memory buffer.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    class BufGenericSycl : public internal::ViewAccessOps<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    class BufGenericSycl : public internal::ViewAccessOps<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
     public:
         static_assert(
@@ -62,67 +64,68 @@ namespace alpaka
 namespace alpaka::trait
 {
     //! The BufGenericSycl device type trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct DevType<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct DevType<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
         using type = DevGenericSycl<TPlatform>;
     };
 
     //! The BufGenericSycl device get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetDev<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetDev<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
-        static auto getDev(BufGenericSycl<TElem, TDim, TIdx, TPlatform> const& buf)
+        static auto getDev(BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility> const& buf)
         {
             return buf.m_dev;
         }
     };
 
     //! The BufGenericSycl dimension getter trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct DimType<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct DimType<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
         using type = TDim;
     };
 
     //! The BufGenericSycl memory element type get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct ElemType<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct ElemType<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
         using type = TElem;
     };
 
     //! The BufGenericSycl extent get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetExtents<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetExtents<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
-        auto operator()(BufGenericSycl<TElem, TDim, TIdx, TPlatform> const& buf) const
+        auto operator()(BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility> const& buf) const
         {
             return buf.m_extentElements;
         }
     };
 
     //! The BufGenericSycl native pointer get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetPtrNative<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetPtrNative<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
-        static auto getPtrNative(BufGenericSycl<TElem, TDim, TIdx, TPlatform> const& buf) -> TElem const*
+        static auto getPtrNative(BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility> const& buf)
+            -> TElem const*
         {
             return buf.m_spMem.get();
         }
 
-        static auto getPtrNative(BufGenericSycl<TElem, TDim, TIdx, TPlatform>& buf) -> TElem*
+        static auto getPtrNative(BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>& buf) -> TElem*
         {
             return buf.m_spMem.get();
         }
     };
 
     //! The BufGenericSycl pointer on device get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetPtrDev<BufGenericSycl<TElem, TDim, TIdx, TPlatform>, DevGenericSycl<TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetPtrDev<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>, DevGenericSycl<TPlatform>>
     {
         static auto getPtrDev(
-            BufGenericSycl<TElem, TDim, TIdx, TPlatform> const& buf,
+            BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility> const& buf,
             DevGenericSycl<TPlatform> const& dev) -> TElem const*
         {
             if(dev == getDev(buf))
@@ -135,8 +138,9 @@ namespace alpaka::trait
             }
         }
 
-        static auto getPtrDev(BufGenericSycl<TElem, TDim, TIdx, TPlatform>& buf, DevGenericSycl<TPlatform> const& dev)
-            -> TElem*
+        static auto getPtrDev(
+            BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>& buf,
+            DevGenericSycl<TPlatform> const& dev) -> TElem*
         {
             if(dev == getDev(buf))
             {
@@ -155,7 +159,7 @@ namespace alpaka::trait
     {
         template<typename TExtent>
         static auto allocBuf(DevGenericSycl<TPlatform> const& dev, TExtent const& extent)
-            -> BufGenericSycl<TElem, TDim, TIdx, TPlatform>
+            -> BufGenericSycl<TElem, TDim, TIdx, TPlatform, alpaka::MemVisibilityTypeList<TPlatform>>
         {
             ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -197,7 +201,11 @@ namespace alpaka::trait
                 nativeContext);
             auto deleter = [ctx = nativeContext](TElem* ptr) { sycl::free(ptr, ctx); };
 
-            return BufGenericSycl<TElem, TDim, TIdx, TPlatform>(dev, memPtr, std::move(deleter), extent);
+            return BufGenericSycl<TElem, TDim, TIdx, TPlatform, alpaka::MemVisibilityTypeList<TPlatform>>(
+                dev,
+                memPtr,
+                std::move(deleter),
+                extent);
         }
     };
 
@@ -208,10 +216,10 @@ namespace alpaka::trait
     };
 
     //! The BufGenericSycl offset get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetOffsets<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetOffsets<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
-        auto operator()(BufGenericSycl<TElem, TDim, TIdx, TPlatform> const&) const -> Vec<TDim, TIdx>
+        auto operator()(BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility> const&) const -> Vec<TDim, TIdx>
         {
             return Vec<TDim, TIdx>::zeros();
         }
@@ -222,8 +230,11 @@ namespace alpaka::trait
     struct BufAllocMapped
     {
         template<typename TExtent>
-        static auto allocMappedBuf(DevCpu const& host, TPlatform const& platform, TExtent const& extent)
-            -> BufCpu<TElem, TDim, TIdx>
+        static auto allocMappedBuf(DevCpu const& host, TPlatform const& platform, TExtent const& extent) -> BufCpu<
+            TElem,
+            TDim,
+            TIdx,
+            alpaka::meta::Unique<std::tuple<alpaka::MemVisibleCPU, alpaka::MemVisibility<TPlatform>>>>
         {
             ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -233,31 +244,47 @@ namespace alpaka::trait
             TElem* memPtr = sycl::malloc_host<TElem>(static_cast<std::size_t>(getExtentProduct(extent)), ctx);
             auto deleter = [ctx](TElem* ptr) { sycl::free(ptr, ctx); };
 
-            return BufCpu<TElem, TDim, TIdx>(host, memPtr, std::move(deleter), extent);
+            return BufCpu<
+                TElem,
+                TDim,
+                TIdx,
+                alpaka::meta::Unique<std::tuple<alpaka::MemVisibleCPU, alpaka::MemVisibility<TPlatform>>>>(
+                host,
+                memPtr,
+                std::move(deleter),
+                extent);
         }
     };
 
     //! The BufGenericSycl idx type trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct IdxType<BufGenericSycl<TElem, TDim, TIdx, TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct IdxType<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
     {
         using type = TIdx;
     };
 
     //! The BufCpu pointer on SYCL device get trait specialization.
-    template<typename TElem, typename TDim, typename TIdx, typename TPlatform>
-    struct GetPtrDev<BufCpu<TElem, TDim, TIdx>, DevGenericSycl<TPlatform>>
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct GetPtrDev<BufCpu<TElem, TDim, TIdx, TMemVisibility>, DevGenericSycl<TPlatform>>
     {
-        static auto getPtrDev(BufCpu<TElem, TDim, TIdx> const& buf, DevGenericSycl<TPlatform> const&) -> TElem const*
+        static auto getPtrDev(BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf, DevGenericSycl<TPlatform> const&)
+            -> TElem const*
         {
             return getPtrNative(buf);
         }
 
-        static auto getPtrDev(BufCpu<TElem, TDim, TIdx>& buf, DevGenericSycl<TPlatform> const&) -> TElem*
+        static auto getPtrDev(BufCpu<TElem, TDim, TIdx, TMemVisibility>& buf, DevGenericSycl<TPlatform> const&)
+            -> TElem*
         {
             return getPtrNative(buf);
         }
     };
+
+    template<typename TElem, typename TDim, typename TIdx, typename TPlatform, typename TMemVisibility>
+    struct MemVisibility<BufGenericSycl<TElem, TDim, TIdx, TPlatform, TMemVisibility>>
+    {
+        using type = TMemVisibility;
+    };
 } // namespace alpaka::trait
 
 #    include "alpaka/mem/buf/sycl/Copy.hpp"
diff --git a/include/alpaka/mem/buf/BufGpuSyclIntel.hpp b/include/alpaka/mem/buf/BufGpuSyclIntel.hpp
index dd20f8a39648..f46d90971387 100644
--- a/include/alpaka/mem/buf/BufGpuSyclIntel.hpp
+++ b/include/alpaka/mem/buf/BufGpuSyclIntel.hpp
@@ -11,8 +11,8 @@
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx>
-    using BufGpuSyclIntel = BufGenericSycl<TElem, TDim, TIdx, PlatformGpuSyclIntel>;
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using BufGpuSyclIntel = BufGenericSycl<TElem, TDim, TIdx, PlatformGpuSyclIntel, TMemVisibility>;
 } // namespace alpaka
 
 #endif
diff --git a/include/alpaka/mem/buf/BufHipRt.hpp b/include/alpaka/mem/buf/BufHipRt.hpp
index 4a59bc46e5d5..cf392d6c94a9 100644
--- a/include/alpaka/mem/buf/BufHipRt.hpp
+++ b/include/alpaka/mem/buf/BufHipRt.hpp
@@ -11,8 +11,8 @@
 
 namespace alpaka
 {
-    template<typename TElem, typename TDim, typename TIdx>
-    using BufHipRt = BufUniformCudaHipRt<ApiHipRt, TElem, TDim, TIdx>;
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using BufHipRt = BufUniformCudaHipRt<ApiHipRt, TElem, TDim, TIdx, TMemVisibility>;
 } // namespace alpaka
 
 #endif // ALPAKA_ACC_GPU_HIP_ENABLED
diff --git a/include/alpaka/mem/buf/BufUniformCudaHipRt.hpp b/include/alpaka/mem/buf/BufUniformCudaHipRt.hpp
index 826edaba7b1e..d15e80763f47 100644
--- a/include/alpaka/mem/buf/BufUniformCudaHipRt.hpp
+++ b/include/alpaka/mem/buf/BufUniformCudaHipRt.hpp
@@ -11,9 +11,11 @@
 #include "alpaka/dev/DevUniformCudaHipRt.hpp"
 #include "alpaka/dev/Traits.hpp"
 #include "alpaka/dim/DimIntegralConst.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/buf/Traits.hpp"
 #include "alpaka/mem/view/ViewAccessOps.hpp"
 #include "alpaka/meta/DependentFalseType.hpp"
+#include "alpaka/meta/Unique.hpp"
 #include "alpaka/vec/Vec.hpp"
 
 #include <cstddef>
@@ -29,7 +31,7 @@ namespace alpaka
     struct ApiCudaRt;
     struct ApiHipRt;
 
-    template<typename TElem, typename TDim, typename TIdx>
+    template<typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
     class BufCpu;
 
     namespace detail
@@ -50,10 +52,10 @@ namespace alpaka
     } // namespace detail
 
     //! The CUDA/HIP memory buffer.
-    template<typename TApi, typename TElem, typename TDim, typename TIdx>
+    template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
     struct BufUniformCudaHipRt
         : detail::PitchHolder<TDim>
-        , internal::ViewAccessOps<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        , internal::ViewAccessOps<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
     {
         static_assert(!std::is_const_v<TElem>, "The elem type of the buffer must not be const");
         static_assert(!std::is_const_v<TIdx>, "The idx type of the buffer must not be const!");
@@ -90,17 +92,17 @@ namespace alpaka
     namespace trait
     {
         //! The BufUniformCudaHipRt device type trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct DevType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DevType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = DevUniformCudaHipRt<TApi>;
         };
 
         //! The BufUniformCudaHipRt device get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetDev<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetDev<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST static auto getDev(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const& buf)
+            ALPAKA_FN_HOST static auto getDev(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const& buf)
                 -> DevUniformCudaHipRt<TApi>
             {
                 return buf.m_dev;
@@ -108,51 +110,53 @@ namespace alpaka
         };
 
         //! The BufUniformCudaHipRt dimension getter trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct DimType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DimType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TDim;
         };
 
         //! The BufUniformCudaHipRt memory element type get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct ElemType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct ElemType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TElem;
         };
 
         //! The BufUniformCudaHipRt extent get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetExtents<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetExtents<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const& buffer) const
+            ALPAKA_FN_HOST auto operator()(
+                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const& buffer) const
             {
                 return buffer.m_extentElements;
             }
         };
 
         //! The BufUniformCudaHipRt native pointer get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetPtrNative<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrNative<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST static auto getPtrNative(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const& buf)
-                -> TElem const*
+            ALPAKA_FN_HOST static auto getPtrNative(
+                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const& buf) -> TElem const*
             {
                 return buf.m_spMem.get();
             }
 
-            ALPAKA_FN_HOST static auto getPtrNative(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>& buf) -> TElem*
+            ALPAKA_FN_HOST static auto getPtrNative(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>& buf)
+                -> TElem*
             {
                 return buf.m_spMem.get();
             }
         };
 
         //! The BufUniformCudaHipRt pointer on device get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetPtrDev<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>, DevUniformCudaHipRt<TApi>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrDev<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>, DevUniformCudaHipRt<TApi>>
         {
             ALPAKA_FN_HOST static auto getPtrDev(
-                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const& buf,
+                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const& buf,
                 DevUniformCudaHipRt<TApi> const& dev) -> TElem const*
             {
                 if(dev == getDev(buf))
@@ -166,7 +170,7 @@ namespace alpaka
             }
 
             ALPAKA_FN_HOST static auto getPtrDev(
-                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>& buf,
+                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>& buf,
                 DevUniformCudaHipRt<TApi> const& dev) -> TElem*
             {
                 if(dev == getDev(buf))
@@ -180,11 +184,11 @@ namespace alpaka
             }
         };
 
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetPitchesInBytes<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPitchesInBytes<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const& buf) const
-                -> Vec<TDim, TIdx>
+            ALPAKA_FN_HOST auto operator()(
+                BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const& buf) const -> Vec<TDim, TIdx>
             {
                 Vec<TDim, TIdx> v{};
                 if constexpr(TDim::value > 0)
@@ -207,7 +211,12 @@ namespace alpaka
         {
             template<typename TExtent>
             ALPAKA_FN_HOST static auto allocBuf(DevUniformCudaHipRt<TApi> const& dev, TExtent const& extent)
-                -> BufUniformCudaHipRt<TApi, TElem, Dim, TIdx>
+                -> BufUniformCudaHipRt<
+                    TApi,
+                    TElem,
+                    Dim,
+                    TIdx,
+                    alpaka::MemVisibilityTypeList<DevUniformCudaHipRt<TApi>>>
             {
                 ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -289,7 +298,12 @@ namespace alpaka
 
             template<typename TQueue, typename TExtent>
             ALPAKA_FN_HOST static auto allocAsyncBuf(TQueue queue, [[maybe_unused]] TExtent const& extent)
-                -> BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>
+                -> BufUniformCudaHipRt<
+                    TApi,
+                    TElem,
+                    TDim,
+                    TIdx,
+                    alpaka::MemVisibilityTypeList<DevUniformCudaHipRt<TApi>>>
             {
                 ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -342,7 +356,13 @@ namespace alpaka
             ALPAKA_FN_HOST static auto allocMappedBuf(
                 DevCpu const& host,
                 PlatformUniformCudaHipRt<TApi> const& /*platform*/,
-                TExtent const& extent) -> BufCpu<TElem, TDim, TIdx>
+                TExtent const& extent)
+                -> BufCpu<
+                    TElem,
+                    TDim,
+                    TIdx,
+                    alpaka::meta::Unique<
+                        std::tuple<alpaka::MemVisibleCPU, alpaka::MemVisibility<PlatformUniformCudaHipRt<TApi>>>>>
             {
                 ALPAKA_DEBUG_MINIMAL_LOG_SCOPE;
 
@@ -355,7 +375,16 @@ namespace alpaka
                     TApi::hostMallocMapped | TApi::hostMallocPortable));
                 auto deleter = [](TElem* ptr) { ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK_NOEXCEPT(TApi::hostFree(ptr)); };
 
-                return BufCpu<TElem, TDim, TIdx>(host, memPtr, std::move(deleter), extent);
+                return BufCpu<
+                    TElem,
+                    TDim,
+                    TIdx,
+                    alpaka::meta::Unique<
+                        std::tuple<alpaka::MemVisibleCPU, alpaka::MemVisibility<PlatformUniformCudaHipRt<TApi>>>>>(
+                    host,
+                    memPtr,
+                    std::move(deleter),
+                    extent);
             }
         };
 
@@ -366,10 +395,10 @@ namespace alpaka
         };
 
         //! The BufUniformCudaHipRt offset get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetOffsets<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetOffsets<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx> const&) const
+            ALPAKA_FN_HOST auto operator()(BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility> const&) const
                 -> Vec<TDim, TIdx>
             {
                 return Vec<TDim, TIdx>::zeros();
@@ -377,18 +406,24 @@ namespace alpaka
         };
 
         //! The BufUniformCudaHipRt idx type trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct IdxType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct IdxType<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TIdx;
         };
 
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct MemVisibility<BufUniformCudaHipRt<TApi, TElem, TDim, TIdx, TMemVisibility>>
+        {
+            using type = alpaka::meta::toTuple<TMemVisibility>;
+        };
+
         //! The BufCpu pointer on CUDA/HIP device get trait specialization.
-        template<typename TApi, typename TElem, typename TDim, typename TIdx>
-        struct GetPtrDev<BufCpu<TElem, TDim, TIdx>, DevUniformCudaHipRt<TApi>>
+        template<typename TApi, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrDev<BufCpu<TElem, TDim, TIdx, TMemVisibility>, DevUniformCudaHipRt<TApi>>
         {
             ALPAKA_FN_HOST static auto getPtrDev(
-                BufCpu<TElem, TDim, TIdx> const& buf,
+                BufCpu<TElem, TDim, TIdx, TMemVisibility> const& buf,
                 DevUniformCudaHipRt<TApi> const&) -> TElem const*
             {
                 // TODO: Check if the memory is mapped at all!
@@ -402,8 +437,9 @@ namespace alpaka
                 return pDev;
             }
 
-            ALPAKA_FN_HOST static auto getPtrDev(BufCpu<TElem, TDim, TIdx>& buf, DevUniformCudaHipRt<TApi> const&)
-                -> TElem*
+            ALPAKA_FN_HOST static auto getPtrDev(
+                BufCpu<TElem, TDim, TIdx, TMemVisibility>& buf,
+                DevUniformCudaHipRt<TApi> const&) -> TElem*
             {
                 // TODO: Check if the memory is mapped at all!
                 TElem* pDev(nullptr);
diff --git a/include/alpaka/mem/buf/Traits.hpp b/include/alpaka/mem/buf/Traits.hpp
index 33e7c9bda7f1..fca1a07417ad 100644
--- a/include/alpaka/mem/buf/Traits.hpp
+++ b/include/alpaka/mem/buf/Traits.hpp
@@ -19,7 +19,13 @@ namespace alpaka
     namespace trait
     {
         //! The memory buffer type trait.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TSfinae = void>
+        template<
+            typename TDev,
+            typename TElem,
+            typename TDim,
+            typename TIdx,
+            typename TMemVisibility,
+            typename TSfinae = void>
         struct BufType;
 
         //! The memory allocator trait.
@@ -48,8 +54,8 @@ namespace alpaka
     } // namespace trait
 
     //! The memory buffer type trait alias template to remove the ::type.
-    template<typename TDev, typename TElem, typename TDim, typename TIdx>
-    using Buf = typename trait::BufType<alpaka::Dev<TDev>, TElem, TDim, TIdx>::type;
+    template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+    using Buf = typename trait::BufType<alpaka::Dev<TDev>, TElem, TDim, TIdx, TMemVisibility>::type;
 
     //! Allocates memory on the given device.
     //!
diff --git a/include/alpaka/mem/view/ViewAccessOps.hpp b/include/alpaka/mem/view/ViewAccessOps.hpp
index 27056678dd17..36723d8902d6 100644
--- a/include/alpaka/mem/view/ViewAccessOps.hpp
+++ b/include/alpaka/mem/view/ViewAccessOps.hpp
@@ -20,6 +20,7 @@ namespace alpaka::internal
     inline constexpr bool isView = false;
 
     // TODO(bgruber): replace this by a concept in C++20
+    // TODO(simeonehrig): extend the trait by memory Visiblity type
     template<typename TView>
     inline constexpr bool isView<
         TView,
diff --git a/include/alpaka/mem/view/ViewPlainPtr.hpp b/include/alpaka/mem/view/ViewPlainPtr.hpp
index ceb4d95aed32..adeff7558bfc 100644
--- a/include/alpaka/mem/view/ViewPlainPtr.hpp
+++ b/include/alpaka/mem/view/ViewPlainPtr.hpp
@@ -8,9 +8,18 @@
 #include "alpaka/dev/DevCpu.hpp"
 #include "alpaka/dev/DevGenericSycl.hpp"
 #include "alpaka/dev/DevUniformCudaHipRt.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/mem/view/Traits.hpp"
 #include "alpaka/mem/view/ViewAccessOps.hpp"
 #include "alpaka/meta/DependentFalseType.hpp"
+#include "alpaka/meta/TypeListOps.hpp"
+#include "alpaka/platform/PlatformCpu.hpp"
+#include "alpaka/platform/PlatformCpuSycl.hpp"
+#include "alpaka/platform/PlatformCudaRt.hpp"
+#include "alpaka/platform/PlatformFpgaSyclIntel.hpp"
+#include "alpaka/platform/PlatformGenericSycl.hpp"
+#include "alpaka/platform/PlatformGpuSyclIntel.hpp"
+#include "alpaka/platform/PlatformHipRt.hpp"
 #include "alpaka/vec/Vec.hpp"
 
 #include <type_traits>
@@ -19,8 +28,13 @@
 namespace alpaka
 {
     //! The memory view to wrap plain pointers.
-    template<typename TDev, typename TElem, typename TDim, typename TIdx>
-    struct ViewPlainPtr final : internal::ViewAccessOps<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+    template<
+        typename TDev,
+        typename TElem,
+        typename TDim,
+        typename TIdx,
+        typename TMemVisibility = alpaka::meta::toTuple<alpaka::MemVisibility<TDev>>>
+    struct ViewPlainPtr final : internal::ViewAccessOps<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
     {
         static_assert(!std::is_const_v<TIdx>, "The idx type of the view can not be const!");
 
@@ -49,15 +63,21 @@ namespace alpaka
     namespace trait
     {
         //! The ViewPlainPtr device type trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct DevType<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DevType<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = alpaka::Dev<TDev>;
         };
 
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct MemVisibility<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
+        {
+            using type = TMemVisibility;
+        };
+
         //! The ViewPlainPtr device get trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct GetDev<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetDev<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             static auto getDev(ViewPlainPtr<TDev, TElem, TDim, TIdx> const& view) -> alpaka::Dev<TDev>
             {
@@ -66,15 +86,15 @@ namespace alpaka
         };
 
         //! The ViewPlainPtr dimension getter trait.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct DimType<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct DimType<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TDim;
         };
 
         //! The ViewPlainPtr memory element type get trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct ElemType<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct ElemType<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TElem;
         };
@@ -82,32 +102,32 @@ namespace alpaka
 
     namespace trait
     {
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct GetExtents<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetExtents<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(ViewPlainPtr<TDev, TElem, TDim, TIdx> const& view) const
+            ALPAKA_FN_HOST auto operator()(ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility> const& view) const
             {
                 return view.m_extentElements;
             }
         };
 
         //! The ViewPlainPtr native pointer get trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct GetPtrNative<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPtrNative<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
-            static auto getPtrNative(ViewPlainPtr<TDev, TElem, TDim, TIdx> const& view) -> TElem const*
+            static auto getPtrNative(ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility> const& view) -> TElem const*
             {
                 return view.m_pMem;
             }
 
-            static auto getPtrNative(ViewPlainPtr<TDev, TElem, TDim, TIdx>& view) -> TElem*
+            static auto getPtrNative(ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>& view) -> TElem*
             {
                 return view.m_pMem;
             }
         };
 
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct GetPitchesInBytes<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetPitchesInBytes<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             ALPAKA_FN_HOST auto operator()(ViewPlainPtr<TDev, TElem, TDim, TIdx> const& view) const
             {
@@ -174,18 +194,19 @@ namespace alpaka
         };
 #endif
         //! The ViewPlainPtr offset get trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct GetOffsets<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct GetOffsets<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
-            ALPAKA_FN_HOST auto operator()(ViewPlainPtr<TDev, TElem, TDim, TIdx> const&) const -> Vec<TDim, TIdx>
+            ALPAKA_FN_HOST auto operator()(ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility> const&) const
+                -> Vec<TDim, TIdx>
             {
                 return Vec<TDim, TIdx>::zeros();
             }
         };
 
         //! The ViewPlainPtr idx type trait specialization.
-        template<typename TDev, typename TElem, typename TDim, typename TIdx>
-        struct IdxType<ViewPlainPtr<TDev, TElem, TDim, TIdx>>
+        template<typename TDev, typename TElem, typename TDim, typename TIdx, typename TMemVisibility>
+        struct IdxType<ViewPlainPtr<TDev, TElem, TDim, TIdx, TMemVisibility>>
         {
             using type = TIdx;
         };
diff --git a/include/alpaka/meta/TypeListOps.hpp b/include/alpaka/meta/TypeListOps.hpp
index 2d6bcfe7f45f..e77ccb5cade8 100644
--- a/include/alpaka/meta/TypeListOps.hpp
+++ b/include/alpaka/meta/TypeListOps.hpp
@@ -1,9 +1,10 @@
-/* Copyright 2022 Bernhard Manfred Gruber
+/* Copyright 2024 Bernhard Manfred Gruber, Simeon Ehrig
  * SPDX-License-Identifier: MPL-2.0
  */
 
 #pragma once
 
+#include <tuple>
 #include <type_traits>
 
 namespace alpaka::meta
@@ -35,4 +36,59 @@ namespace alpaka::meta
     {
         static constexpr bool value = std::is_same_v<Head, Value> || Contains<List<Tail...>, Value>::value;
     };
+
+    // copied from https://stackoverflow.com/a/51073558/22035743
+    template<typename T>
+    struct IsList : std::false_type
+    {
+    };
+
+    template<template<typename...> class TList, typename... TTypes>
+    struct IsList<TList<TTypes...>> : std::true_type
+    {
+    };
+
+    //! \brief Checks whether the specified type is a list. List is a type with a variadic number of template types.
+    template<typename T>
+    constexpr bool isList = IsList<std::decay_t<T>>::value;
+
+    namespace detail
+    {
+        template<template<typename...> class TListType, typename TType, typename = void>
+        struct ToListImpl
+        {
+            using type = TListType<TType>;
+        };
+
+        template<template<typename...> class TListType, typename TList>
+        struct ToListImpl<TListType, TList, std::enable_if_t<alpaka::meta::isList<TList>>>
+        {
+            using type = TList;
+        };
+    } // namespace detail
+
+    //! \brief Takes an arbitrary number of types (T) and creates a type list of type TListType with the types (T). If
+    //! T is a single template parameter and it satisfies alpaka::meta::isList, the type of the structure is T (no type
+    //! change).
+    //! \tparam TListType type of the created list
+    //! \tparam T possible list types or type list
+    template<template<typename...> class TListType, typename... T>
+    struct ToList;
+
+    template<template<typename...> class TListType, typename T>
+    struct ToList<TListType, T> : detail::ToListImpl<TListType, T>
+    {
+    };
+
+    template<template<typename...> class TListType, typename T, typename... Ts>
+    struct ToList<TListType, T, Ts...>
+    {
+        using type = TListType<T, Ts...>;
+    };
+
+    //! \brief If T is a single argument and a type list (fullfil alpaka::meta::isList), the return type is T.
+    //! Otherwise, std::tuple is returned with T types as template parameters.
+    template<typename... T>
+    using toTuple = typename ToList<std::tuple, T...>::type;
+
 } // namespace alpaka::meta
diff --git a/include/alpaka/platform/PlatformCpu.hpp b/include/alpaka/platform/PlatformCpu.hpp
index c431fd418785..aab9f3a3790f 100644
--- a/include/alpaka/platform/PlatformCpu.hpp
+++ b/include/alpaka/platform/PlatformCpu.hpp
@@ -6,6 +6,7 @@
 
 #include "alpaka/core/Concepts.hpp"
 #include "alpaka/dev/DevCpu.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/Traits.hpp"
 
 #include <sstream>
@@ -65,5 +66,11 @@ namespace alpaka
                 return {};
             }
         };
+
+        template<>
+        struct MemVisibility<PlatformCpu>
+        {
+            using type = alpaka::MemVisibleCPU;
+        };
     } // namespace trait
 } // namespace alpaka
diff --git a/include/alpaka/platform/PlatformCpuSycl.hpp b/include/alpaka/platform/PlatformCpuSycl.hpp
index db055f9689b2..893ce8e39dc1 100644
--- a/include/alpaka/platform/PlatformCpuSycl.hpp
+++ b/include/alpaka/platform/PlatformCpuSycl.hpp
@@ -6,6 +6,7 @@
 
 #include "alpaka/dev/DevGenericSycl.hpp"
 #include "alpaka/dev/Traits.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/PlatformGenericSycl.hpp"
 
 #include <string>
@@ -39,6 +40,12 @@ namespace alpaka::trait
     {
         using type = DevGenericSycl<PlatformCpuSycl>; // = DevCpuSycl
     };
+
+    template<>
+    struct MemVisibility<PlatformCpuSycl>
+    {
+        using type = alpaka::MemVisibleCpuSycl;
+    };
 } // namespace alpaka::trait
 
 #endif
diff --git a/include/alpaka/platform/PlatformCudaRt.hpp b/include/alpaka/platform/PlatformCudaRt.hpp
index 9bf76fa66682..011f782c2d2d 100644
--- a/include/alpaka/platform/PlatformCudaRt.hpp
+++ b/include/alpaka/platform/PlatformCudaRt.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "alpaka/core/ApiCudaRt.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/PlatformUniformCudaHipRt.hpp"
 
 #ifdef ALPAKA_ACC_GPU_CUDA_ENABLED
@@ -13,6 +14,15 @@ namespace alpaka
 {
     //! The CUDA RT platform.
     using PlatformCudaRt = PlatformUniformCudaHipRt<ApiCudaRt>;
+
+    namespace trait
+    {
+        template<>
+        struct MemVisibility<PlatformCudaRt>
+        {
+            using type = alpaka::MemVisibleGpuCudaRt;
+        };
+    } // namespace trait
 } // namespace alpaka
 
 #endif // ALPAKA_ACC_GPU_CUDA_ENABLED
diff --git a/include/alpaka/platform/PlatformFpgaSyclIntel.hpp b/include/alpaka/platform/PlatformFpgaSyclIntel.hpp
index 21ee2c257c5f..b6190b75312c 100644
--- a/include/alpaka/platform/PlatformFpgaSyclIntel.hpp
+++ b/include/alpaka/platform/PlatformFpgaSyclIntel.hpp
@@ -6,6 +6,7 @@
 
 #include "alpaka/dev/DevGenericSycl.hpp"
 #include "alpaka/dev/Traits.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/PlatformGenericSycl.hpp"
 
 #if defined(ALPAKA_ACC_SYCL_ENABLED) && defined(ALPAKA_SYCL_ONEAPI_FPGA)
@@ -57,6 +58,12 @@ namespace alpaka::trait
     {
         using type = DevGenericSycl<PlatformFpgaSyclIntel>; // = DevFpgaSyclIntel
     };
+
+    template<>
+    struct MemVisibility<PlatformFpgaSyclIntel>
+    {
+        using type = alpaka::MemVisibleFpgaSyclIntel;
+    };
 } // namespace alpaka::trait
 
 #endif
diff --git a/include/alpaka/platform/PlatformGpuSyclIntel.hpp b/include/alpaka/platform/PlatformGpuSyclIntel.hpp
index 216bb5ae26a1..7cfabd09e303 100644
--- a/include/alpaka/platform/PlatformGpuSyclIntel.hpp
+++ b/include/alpaka/platform/PlatformGpuSyclIntel.hpp
@@ -6,6 +6,7 @@
 
 #include "alpaka/dev/DevGenericSycl.hpp"
 #include "alpaka/dev/Traits.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/PlatformGenericSycl.hpp"
 
 #include <string>
@@ -42,6 +43,12 @@ namespace alpaka::trait
     {
         using type = DevGenericSycl<PlatformGpuSyclIntel>; // = DevGpuSyclIntel
     };
+
+    template<>
+    struct MemVisibility<PlatformGpuSyclIntel>
+    {
+        using type = alpaka::MemVisibleGpuSyclIntel;
+    };
 } // namespace alpaka::trait
 
 #endif
diff --git a/include/alpaka/platform/PlatformHipRt.hpp b/include/alpaka/platform/PlatformHipRt.hpp
index 25303aeaf10e..4179bd8f0967 100644
--- a/include/alpaka/platform/PlatformHipRt.hpp
+++ b/include/alpaka/platform/PlatformHipRt.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "alpaka/core/ApiHipRt.hpp"
+#include "alpaka/mem/Visibility.hpp"
 #include "alpaka/platform/PlatformUniformCudaHipRt.hpp"
 
 #ifdef ALPAKA_ACC_GPU_HIP_ENABLED
@@ -13,6 +14,15 @@ namespace alpaka
 {
     //! The HIP RT platform.
     using PlatformHipRt = PlatformUniformCudaHipRt<ApiHipRt>;
+
+    namespace trait
+    {
+        template<>
+        struct MemVisibility<PlatformHipRt>
+        {
+            using type = alpaka::MemVisibleGpuHipRt;
+        };
+    } // namespace trait
 } // namespace alpaka
 
 #endif // ALPAKA_ACC_GPU_HIP_ENABLED
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index bcd108ff8d4c..209a41d9ccbf 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -25,11 +25,7 @@ add_subdirectory("idx/")
 add_subdirectory("intrinsic/")
 add_subdirectory("kernel/")
 add_subdirectory("math/")
-add_subdirectory("mem/buf/")
-add_subdirectory("mem/copy/")
-add_subdirectory("mem/fence/")
-add_subdirectory("mem/p2p/")
-add_subdirectory("mem/view/")
+add_subdirectory("mem/")
 add_subdirectory("meta/")
 add_subdirectory("queue/")
 add_subdirectory("rand/")
diff --git a/test/unit/math/src/Buffer.hpp b/test/unit/math/src/Buffer.hpp
index 7687fcfd3ca1..8adcb189fcaf 100644
--- a/test/unit/math/src/Buffer.hpp
+++ b/test/unit/math/src/Buffer.hpp
@@ -6,12 +6,36 @@
 
 #include "Defines.hpp"
 
+#include <alpaka/meta/TypeListOps.hpp>
+#include <alpaka/meta/Unique.hpp>
 #include <alpaka/test/acc/TestAccs.hpp>
 
 #include <ostream>
 
 namespace mathtest
 {
+    namespace detail
+    {
+        template<typename THost, typename TPlatform, typename = void>
+        struct MemVisibilityMappedBufferImpl
+        {
+            using type = typename alpaka::MemVisibilityTypeList<THost>;
+        };
+
+        template<typename THost, typename TPlatform>
+        struct MemVisibilityMappedBufferImpl<
+            THost,
+            TPlatform,
+            std::enable_if_t<alpaka::hasMappedBufSupport<TPlatform>>>
+        {
+            using type = typename alpaka::meta::Unique<
+                std::tuple<alpaka::MemVisibility<THost>, alpaka::MemVisibility<TPlatform>>>;
+        };
+    } // namespace detail
+
+    template<typename THost, typename TPlatform>
+    using MemVisibilityMappedBuffer = typename detail::MemVisibilityMappedBufferImpl<THost, TPlatform>::type;
+
     //! Provides alpaka-style buffer with arguments' data.
     //! TData can be a plain value or a complex data-structure.
     //! The operator() is overloaded and returns the value from the correct Buffer,
@@ -32,11 +56,12 @@ namespace mathtest
         // Defines using's for alpaka-buffer.
         using DevHost = alpaka::DevCpu;
         using PlatformHost = alpaka::Platform<DevHost>;
-        using BufHost = alpaka::Buf<DevHost, TData, Dim, Idx>;
 
         using DevAcc = alpaka::Dev<TAcc>;
         using PlatformAcc = alpaka::Platform<DevAcc>;
-        using BufAcc = alpaka::Buf<DevAcc, TData, Dim, Idx>;
+
+        using BufHost = alpaka::Buf<DevHost, TData, Dim, Idx, MemVisibilityMappedBuffer<DevHost, PlatformAcc>>;
+        using BufAcc = alpaka::Buf<DevAcc, TData, Dim, Idx, alpaka::MemVisibilityTypeList<PlatformAcc>>;
 
         PlatformHost platformHost;
         DevHost devHost;
diff --git a/test/unit/mem/CMakeLists.txt b/test/unit/mem/CMakeLists.txt
new file mode 100644
index 000000000000..f4e76bcb7262
--- /dev/null
+++ b/test/unit/mem/CMakeLists.txt
@@ -0,0 +1,33 @@
+#
+# Copyright 2024 Simeon Ehrig
+# SPDX-License-Identifier: MPL-2.0
+#
+
+################################################################################
+# Required CMake version.
+################################################################################
+
+cmake_minimum_required(VERSION 3.22)
+
+set(_TARGET_NAME "memVisibilityTest")
+
+append_recursive_files_add_to_src_group("src/" "src/" "cpp" _FILES_SOURCE)
+
+alpaka_add_executable(
+    ${_TARGET_NAME}
+    ${_FILES_SOURCE})
+target_link_libraries(
+    ${_TARGET_NAME}
+    PRIVATE common)
+
+set_target_properties(${_TARGET_NAME} PROPERTIES FOLDER "test/unit")
+target_compile_definitions(${_TARGET_NAME} PRIVATE "-DTEST_UNIT_MEM")
+
+add_test(NAME ${_TARGET_NAME} COMMAND ${_TARGET_NAME} ${_alpaka_TEST_OPTIONS})
+
+
+add_subdirectory("buf/")
+add_subdirectory("copy/")
+add_subdirectory("fence/")
+add_subdirectory("p2p/")
+add_subdirectory("view/")
diff --git a/test/unit/mem/copy/src/BufSlicing.cpp b/test/unit/mem/copy/src/BufSlicing.cpp
index 6169fdaf5ff2..ed2a4dc6f1f9 100644
--- a/test/unit/mem/copy/src/BufSlicing.cpp
+++ b/test/unit/mem/copy/src/BufSlicing.cpp
@@ -28,8 +28,8 @@ struct TestContainer
     using DevHost = alpaka::DevCpu;
     using PlatformHost = alpaka::Platform<DevHost>;
 
-    using BufHost = alpaka::Buf<DevHost, TData, TDim, TIdx>;
-    using BufDevice = alpaka::Buf<DevAcc, TData, TDim, TIdx>;
+    using BufHost = alpaka::Buf<DevHost, TData, TDim, TIdx, alpaka::MemVisibilityTypeList<PlatformHost>>;
+    using BufDevice = alpaka::Buf<DevAcc, TData, TDim, TIdx, alpaka::MemVisibilityTypeList<PlatformAcc>>;
 
     using SubView = alpaka::ViewSubView<DevAcc, TData, TDim, TIdx>;
 
diff --git a/test/unit/mem/src/Visibility.cpp b/test/unit/mem/src/Visibility.cpp
new file mode 100644
index 000000000000..097f7ec60b88
--- /dev/null
+++ b/test/unit/mem/src/Visibility.cpp
@@ -0,0 +1,243 @@
+/* Copyright 2024 Simeon Ehrig
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+#include <alpaka/alpaka.hpp>
+
+#include <catch2/catch_template_test_macros.hpp>
+
+#include <iostream>
+#include <type_traits>
+
+using Dim = alpaka::DimInt<1>;
+using Idx = std::size_t;
+
+// TODO(SimeonEhrig): Replace implementation. Instead using a list, specialize `alpaka::Platform` for
+// tags to get the Memory Visiblity
+
+//! \brief check if the accelerator related to the tag is bounded to the cpu platform
+//! \tparam TTag alpaka tag type
+template<typename TTag, typename = void>
+struct isCpuTag : std::false_type
+{
+};
+
+template<typename TTag>
+struct isCpuTag<
+    TTag,
+    std::enable_if_t<
+        // TAGCpuSycl is not included because it has it's own platform
+        std::is_same_v<TTag, alpaka::TagCpuSerial> || std::is_same_v<TTag, alpaka::TagCpuThreads>
+        || std::is_same_v<TTag, alpaka::TagCpuTbbBlocks> || std::is_same_v<TTag, alpaka::TagCpuOmp2Blocks>
+        || std::is_same_v<TTag, alpaka::TagCpuOmp2Threads>>> : std::true_type
+{
+};
+
+template<typename TTagMemView, typename = void>
+struct AccIsEnabledMemVisibilities : std::false_type
+{
+};
+
+template<typename TTagMemView>
+struct AccIsEnabledMemVisibilities<
+    TTagMemView,
+    std::void_t<alpaka::TagToAcc<std::tuple_element_t<0, TTagMemView>, alpaka::DimInt<1>, int>>> : std::true_type
+{
+};
+
+using ExpectedTagsMemVisibilities = alpaka::meta::Filter<
+    std::tuple<
+        std::tuple<alpaka::TagCpuSerial, alpaka::MemVisibleCPU>,
+        std::tuple<alpaka::TagCpuThreads, alpaka::MemVisibleCPU>,
+        std::tuple<alpaka::TagCpuTbbBlocks, alpaka::MemVisibleCPU>,
+        std::tuple<alpaka::TagCpuOmp2Blocks, alpaka::MemVisibleCPU>,
+        std::tuple<alpaka::TagCpuOmp2Threads, alpaka::MemVisibleCPU>,
+        std::tuple<alpaka::TagGpuCudaRt, alpaka::MemVisibleGpuCudaRt>,
+        std::tuple<alpaka::TagGpuHipRt, alpaka::MemVisibleGpuHipRt>,
+        std::tuple<alpaka::TagCpuSycl, alpaka::MemVisibleCpuSycl>,
+        std::tuple<alpaka::TagFpgaSyclIntel, alpaka::MemVisibleFpgaSyclIntel>,
+        std::tuple<alpaka::TagGpuSyclIntel, alpaka::MemVisibleGpuSyclIntel>>,
+    AccIsEnabledMemVisibilities>;
+
+TEMPLATE_LIST_TEST_CASE("memoryVisibilityType", "[mem][visibility]", ExpectedTagsMemVisibilities)
+{
+    using Tag = std::tuple_element_t<0, TestType>;
+    using ExpectedMemVisibility = std::tuple_element_t<1, TestType>;
+
+    using PltfType = alpaka::Platform<alpaka::TagToAcc<Tag, Dim, Idx>>;
+    STATIC_REQUIRE(std::is_same_v<typename alpaka::trait::MemVisibility<PltfType>::type, ExpectedMemVisibility>);
+}
+
+using EnabledTagTagList = alpaka::meta::CartesianProduct<std::tuple, alpaka::EnabledAccTags, alpaka::EnabledAccTags>;
+
+TEMPLATE_LIST_TEST_CASE("testHasSameMemView", "[mem][visibility]", EnabledTagTagList)
+{
+    using Tag1 = std::tuple_element_t<0, TestType>;
+    using Tag2 = std::tuple_element_t<1, TestType>;
+
+    SUCCEED(Tag1::get_name() << " + " << Tag2::get_name());
+
+    using Acc1 = alpaka::TagToAcc<Tag1, Dim, Idx>;
+    using Acc2 = alpaka::TagToAcc<Tag2, Dim, Idx>;
+
+    auto const plt1 = alpaka::Platform<Acc1>{};
+    auto const plt2 = alpaka::Platform<Acc2>{};
+
+    using Plt1 = decltype(plt1);
+    using Plt2 = decltype(plt2);
+
+    auto const dev1 = alpaka::getDevByIdx(plt1, 0);
+    auto const dev2 = alpaka::getDevByIdx(plt2, 0);
+
+    using BufAcc1 = alpaka::Buf<Acc1, float, Dim, Idx, alpaka::MemVisibilityTypeList<Plt1>>;
+    using BufAcc2 = alpaka::Buf<Acc2, float, Dim, Idx, alpaka::MemVisibilityTypeList<Plt2>>;
+
+    BufAcc1 bufDev1(alpaka::allocBuf<float, Idx>(dev1, Idx(1)));
+    BufAcc2 bufDev2(alpaka::allocBuf<float, Idx>(dev2, Idx(1)));
+
+    STATIC_REQUIRE(alpaka::hasSameMemView(plt1, bufDev1));
+    STATIC_REQUIRE(alpaka::hasSameMemView(dev1, bufDev1));
+    STATIC_REQUIRE(alpaka::hasSameMemView<Acc1, BufAcc1>());
+    STATIC_REQUIRE(alpaka::hasSameMemView(plt2, bufDev2));
+    STATIC_REQUIRE(alpaka::hasSameMemView(dev2, bufDev2));
+    STATIC_REQUIRE(alpaka::hasSameMemView<Acc2, BufAcc2>());
+
+    // at the moment, only the cpu platform has different accelerator types
+    // therefore all cpu accelerators can access the memory of other cpu accelerators
+    // if the accelerator is not a cpu accelerator, both accelerators needs to be the
+    // same to support access to the memory of each other
+    if constexpr((isCpuTag<Tag1>::value && isCpuTag<Tag2>::value) || std::is_same_v<Tag1, Tag2>)
+    {
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt1, bufDev2));
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt2, bufDev1));
+        STATIC_REQUIRE(alpaka::hasSameMemView<Acc2, BufAcc1>());
+    }
+    else
+    {
+        STATIC_REQUIRE_FALSE(alpaka::hasSameMemView(plt1, bufDev2));
+        STATIC_REQUIRE_FALSE(alpaka::hasSameMemView(plt2, bufDev1));
+        STATIC_REQUIRE_FALSE(alpaka::hasSameMemView<Acc2, BufAcc1>());
+    }
+}
+
+using EnabledTagTagMemVisibilityList
+    = alpaka::meta::CartesianProduct<std::tuple, ExpectedTagsMemVisibilities, ExpectedTagsMemVisibilities>;
+
+TEMPLATE_LIST_TEST_CASE("testMemView", "[mem][visibility]", EnabledTagTagMemVisibilityList)
+{
+    using Tag1 = std::tuple_element_t<0, std::tuple_element_t<0, TestType>>;
+    using ExpectedMemVisibilityForTag1 = std::tuple_element_t<1, std::tuple_element_t<0, TestType>>;
+    using Tag2 = std::tuple_element_t<0, std::tuple_element_t<1, TestType>>;
+    using ExpectedMemVisibilityForTag2 = std::tuple_element_t<1, std::tuple_element_t<1, TestType>>;
+
+    SUCCEED(
+        "Tag1: " << Tag1::get_name() << " + " << ExpectedMemVisibilityForTag1::get_name()
+                 << "\nTag2: " << Tag2::get_name() << " + " << ExpectedMemVisibilityForTag1::get_name());
+
+
+    constexpr Idx data_size = 10;
+
+    using Acc1 = alpaka::TagToAcc<Tag1, Dim, Idx>;
+    using Acc2 = alpaka::TagToAcc<Tag2, Dim, Idx>;
+
+    auto const plt1 = alpaka::Platform<Acc1>{};
+    auto const plt2 = alpaka::Platform<Acc2>{};
+
+    auto const dev1 = alpaka::getDevByIdx(plt1, 0);
+    auto const dev2 = alpaka::getDevByIdx(plt2, 0);
+
+    using Vec1D = alpaka::Vec<alpaka::DimInt<1>, Idx>;
+    Vec1D const extents(Vec1D::all(data_size));
+
+    std::array<int, data_size> data;
+
+    auto data_view1 = alpaka::createView(dev1, data.data(), extents);
+    STATIC_REQUIRE(std::is_same_v<
+                   typename alpaka::trait::MemVisibility<decltype(data_view1)>::type,
+                   std::tuple<ExpectedMemVisibilityForTag1>>);
+    STATIC_REQUIRE(alpaka::hasSameMemView(plt1, data_view1));
+
+    auto data_view2 = alpaka::createView(dev2, data.data(), extents);
+    STATIC_REQUIRE(std::is_same_v<
+                   typename alpaka::trait::MemVisibility<decltype(data_view2)>::type,
+                   std::tuple<ExpectedMemVisibilityForTag2>>);
+    STATIC_REQUIRE(alpaka::hasSameMemView(plt2, data_view2));
+
+    if constexpr(std::is_same_v<ExpectedMemVisibilityForTag1, ExpectedMemVisibilityForTag2>)
+    {
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt1, data_view2));
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt2, data_view1));
+    }
+    else
+    {
+        STATIC_REQUIRE_FALSE(alpaka::hasSameMemView(plt1, data_view2));
+        STATIC_REQUIRE_FALSE(alpaka::hasSameMemView(plt2, data_view1));
+    }
+}
+
+TEMPLATE_LIST_TEST_CASE("testMemBuf", "[mem][visibility]", EnabledTagTagMemVisibilityList)
+{
+    using Tag1 = std::tuple_element_t<0, std::tuple_element_t<0, TestType>>;
+    using ExpectedMemVisibilityForTag1 = std::tuple_element_t<1, std::tuple_element_t<0, TestType>>;
+    using Tag2 = std::tuple_element_t<0, std::tuple_element_t<1, TestType>>;
+    using ExpectedMemVisibilityForTag2 = std::tuple_element_t<1, std::tuple_element_t<1, TestType>>;
+
+    SUCCEED(
+        "Tag1: " << Tag1::get_name() << " + " << ExpectedMemVisibilityForTag1::get_name()
+                 << "\nTag2: " << Tag2::get_name() << " + " << ExpectedMemVisibilityForTag1::get_name());
+
+    constexpr Idx data_size = 10;
+
+    using Acc1 = alpaka::TagToAcc<Tag1, Dim, Idx>;
+    using Acc2 = alpaka::TagToAcc<Tag2, Dim, Idx>;
+
+    auto const plt1 = alpaka::Platform<Acc1>{};
+    auto const plt2 = alpaka::Platform<Acc2>{};
+
+    auto const dev1 = alpaka::getDevByIdx(plt1, 0);
+    auto const dev2 = alpaka::getDevByIdx(plt2, 0);
+
+    using Vec1D = alpaka::Vec<alpaka::DimInt<1>, Idx>;
+    Vec1D const extents(Vec1D::all(data_size));
+
+    // we need only to test the first tag, because the second tag contains the same acc's
+    auto buf1 = alpaka::allocBuf<float, Idx>(dev1, extents);
+
+    STATIC_REQUIRE(std::is_same_v<
+                   typename alpaka::trait::MemVisibility<decltype(buf1)>::type,
+                   std::tuple<ExpectedMemVisibilityForTag1>>);
+
+    STATIC_REQUIRE(alpaka::hasSameMemView(plt1, buf1));
+
+    if constexpr(!std::is_same_v<Tag1, alpaka::TagGpuSyclIntel>)
+    {
+        alpaka::Queue<Acc1, alpaka::NonBlocking> queue1(dev1);
+
+        auto buf1Async = alpaka::allocAsyncBuf<float, Idx>(queue1, extents);
+
+        alpaka::wait(queue1);
+
+        STATIC_REQUIRE(std::is_same_v<
+                       typename alpaka::trait::MemVisibility<decltype(buf1Async)>::type,
+                       std::tuple<ExpectedMemVisibilityForTag1>>);
+
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt1, buf1Async));
+    }
+
+    if constexpr(isCpuTag<Tag1>::value && alpaka::hasMappedBufSupport<alpaka::Platform<Acc2>>)
+    {
+        auto mappedBuffer = alpaka::allocMappedBuf<alpaka::Platform<Acc2>, float, Idx>(dev1, plt2, extents);
+
+        using expectedMappedBufferMemView
+            = alpaka::meta::Unique<std::tuple<ExpectedMemVisibilityForTag1, ExpectedMemVisibilityForTag2>>;
+
+        STATIC_REQUIRE(std::is_same_v<
+                       typename alpaka::trait::MemVisibility<decltype(mappedBuffer)>::type,
+                       expectedMappedBufferMemView>);
+
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt1, mappedBuffer));
+        STATIC_REQUIRE(alpaka::hasSameMemView(plt2, mappedBuffer));
+        STATIC_REQUIRE(alpaka::hasSameMemView(dev1, mappedBuffer));
+        STATIC_REQUIRE(alpaka::hasSameMemView(dev2, mappedBuffer));
+    }
+}