diff --git a/CMakeLists.txt b/CMakeLists.txt
index f038a12bb0f..3813b53d91c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -198,6 +198,42 @@ macro(opm-simulators_prereqs_hook)
   # NVCC as for the rest. In the case that NVCC does not support
   # that compiler it will error out.
   if(NOT CMAKE_DISABLE_FIND_PACKAGE_CUDA AND NOT CONVERT_CUDA_TO_HIP)
+    # do I need this?
+    if(CMAKE_BUILD_TYPE)
+      set(_flags_suffix "_${CMAKE_BUILD_TYPE}")
+    endif()
+    if(NOT DEFINED ENV{CUDAHOSTCXX} AND NOT DEFINED CMAKE_CUDA_HOST_COMPILER AND
+        (NOT CMAKE_CUDA_FLAGS${_flags_suffix} OR NOT CMAKE_CUDA_FLAGS${_flags_suffix} MATCHES ".*-ccbin .*"))
+      message(STATUS "Setting CUDA host compiler CMAKE_CUDA_HOST_COMPILER to ${CMAKE_CXX_COMPILER} to "
+        "prevent incompatibilities. Note that this might report that there "
+        "is not CUDA compiler if your system's CUDA compiler does not support "
+        "${CMAKE_CXX_COMPILER}.")
+      # check_language does not seem to care about ${CMAKE_CUDA_FLAGS} or $(CUDA_NVCC_FLAGS}.
+      # Hence we set CMAKE_CUDA_HOST_COMPILER to our C++ compiler.
+      # In check_language(CUDA) we will get an error if we in addition put
+      # "-ccbin ${CMAKE_CXX_COMPILER}" into CMAKE_CUDA_FLAGS. It results
+      # in "${NVCC} -ccbin=${CMAKE_CXX_COMPILER}   -ccbin ${CMAKE_CXX_COMPILER}"
+      # which causes nvcc to abort
+      set(CMAKE_CUDA_HOST_COMPILER ${CMAKE_CXX_COMPILER})
+      set(ENV{CUDAHOSTCXX} ${CMAKE_CUDA_HOST_COMPILER}) # The only thing honored by check_language(CUDA)!
+    endif()
+    include(CheckLanguage)
+    check_language(CUDA)
+    if(CMAKE_CUDA_COMPILER)
+      # OPTIONAL is ignored. Hence the magic above to check whether enabling CUDA works
+      enable_language(CUDA)
+      set(CUDA_FOUND ON)
+    else()
+      message(FATAL_ERROR "CUDA support requested but no suitable CUDA compiler found. "
+        "Use -DCMAKE_DISABLE_FIND_PACKAGE_CUDA=ON to disable CUDA support.")
+    endif()
+    if(CUDA_FOUND AND CMAKE_CUDA_COMPILER_VERSION VERSION_LESS "9.0")
+      set(CUDA_FOUND OFF)
+      message(WARNING
+        "Deactivating CUDA as we require version 9.0 or newer."
+        " Found only CUDA version ${CUDA_VERSION}."
+      )
+    endif()
     if(CUDA_FOUND)
       find_package(CUDAToolkit REQUIRED)
       target_link_libraries(opmsimulators
@@ -364,8 +400,10 @@ macro(opm-simulators_sources_hook)
     # cuda warns when constxpr functions are used in kernels.
     # since the entire stl is constexpr ..., we enable relaxed flag
     set_source_files_properties(
+      opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.cu
       tests/gpuistl/test_blackoilfluidstategpu.cu
       tests/gpuistl/test_gpu_ad.cu
+      tests/gpuistl/test_gpu_ecl_thermal_law_manager.cu
       tests/gpuistl/test_gpu_linear_two_phase_material.cu
       tests/gpuistl/test_gpuPvt.cu
       tests/gpuistl/test_gpuBlackOilFluidSystem.cu
@@ -490,6 +528,7 @@ macro(opm-simulators_tests_hook)
                  cuVector_operations
                  deviceBlockOperations
                  gpu_ad
+                 gpu_ecl_thermal_law_manager
                  gpu_linear_two_phase_material
                  gpu_resources
                  gpu_safe_call
@@ -515,6 +554,7 @@ macro(opm-simulators_tests_hook)
                  primary_variables_gpu
                  solver_adapter
                  throw_macros_on_gpu
+                 blackoilintensivequantities_gpu
            )
       if(TEST ${test})
         set_tests_properties(${test}
@@ -681,6 +721,9 @@ macro(opm-simulators_targets_hook)
   target_sources(test_RestartSerialization PRIVATE $<TARGET_OBJECTS:moduleVersion>)
   target_sources(test_glift1 PRIVATE $<TARGET_OBJECTS:moduleVersion>)
   target_sources(test_tpsa_localresidual PRIVATE $<TARGET_OBJECTS:moduleVersion>)
+  if (TARGET test_blackoilintensivequantities_gpu)
+    target_sources(test_blackoilintensivequantities_gpu PRIVATE $<TARGET_OBJECTS:moduleVersion>)
+  endif()
   if(MPI_FOUND)
     target_sources(test_chopstep PRIVATE $<TARGET_OBJECTS:moduleVersion>)
   endif()
@@ -711,6 +754,7 @@ macro(opm-simulators_targets_hook)
     gaswater_saltprec_energy
     gaswater_saltprec_vapwat
     gaswater_solvent
+    gpu
     micp
     oilwater
     oilwater_brine
@@ -725,14 +769,25 @@ macro(opm-simulators_targets_hook)
   )
 
   foreach(OBJ ${COMMON_MODELS} ${FLOW_MODELS} ${FLOW_VARIANT_MODELS})
+    set(SOURCE_FILE "flow/flow_${OBJ}.cpp")
+
+    if(OBJ STREQUAL "gpu")
+      if (CONVERT_CUDA_TO_HIP)
+        set(SOURCE_FILE "flow/flow_${OBJ}.hip")
+      else()
+        set(SOURCE_FILE "flow/flow_${OBJ}.cu")
+      endif()
+    endif()
+
     opm_add_library(
       TARGET
         flow_lib${OBJ}
       TYPE
         OBJECT
       SOURCES
-        flow/flow_${OBJ}.cpp
+        ${SOURCE_FILE}
     )
+
     simulators_add_target_options(TARGET flow_lib${OBJ})
     list(APPEND FLOW_TGTS $<TARGET_OBJECTS:flow_lib${OBJ}>)
     list(APPEND FLOWMODELS_PREFIXED flow_${OBJ})
diff --git a/CMakeLists_files.cmake b/CMakeLists_files.cmake
index 6075ba58577..fbc8a8608e1 100644
--- a/CMakeLists_files.cmake
+++ b/CMakeLists_files.cmake
@@ -337,9 +337,12 @@ if(CUDA_FOUND OR hip_FOUND)
   ADD_CUDA_OR_HIP_FILE(MAIN_SOURCE_FILES opm/simulators/linalg detail/FlexibleSolverWrapper.cpp)
   ADD_CUDA_OR_HIP_FILE(MAIN_SOURCE_FILES opm/simulators/linalg FlexibleSolver_gpu_instantiate.cpp)
   ADD_CUDA_OR_HIP_FILE(MAIN_SOURCE_FILES opm/simulators/linalg PreconditionerFactory_gpu_instantiate.cpp)
+  ADD_CUDA_OR_HIP_FILE(MAIN_SOURCE_FILES opm/simulators/linalg GpuBlackoilIntensiveQuantitiesDispatcher.cu)
 
 
   # HEADERS
+  ADD_CUDA_OR_HIP_FILE(PUBLIC_HEADER_FILES opm/simulators/linalg GpuBlackoilIntensiveQuantitiesDispatcher.hpp)
+  ADD_CUDA_OR_HIP_FILE(PUBLIC_HEADER_FILES opm/simulators/linalg GpuFlowGasWaterEnergyTypeTags.hpp)
   ADD_CUDA_OR_HIP_FILE(PUBLIC_HEADER_FILES opm/simulators/linalg detail/autotuner.hpp)
   ADD_CUDA_OR_HIP_FILE(PUBLIC_HEADER_FILES opm/simulators/linalg detail/coloringAndReorderingUtils.hpp)
   ADD_CUDA_OR_HIP_FILE(PUBLIC_HEADER_FILES opm/simulators/linalg detail/gpu_safe_call.hpp)
@@ -570,6 +573,7 @@ if(CUDA_FOUND OR hip_FOUND)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_safe_conversion.cpp)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_solver_adapter.cpp)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_gpu_ad.cu)
+  ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_gpu_ecl_thermal_law_manager.cu)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_gpu_linear_two_phase_material.cu)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_gpuPvt.cu)
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_gpu_smart_pointers.cu)
@@ -587,6 +591,8 @@ if(CUDA_FOUND OR hip_FOUND)
     ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_primary_variables_gpu.cu)
   endif()
   ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_MiniMatrix.cu)
+  ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_blackoilintensivequantities_gpu.cu)
+
   # Boost < 1.75 + nvcc = trouble in this test
   if(Boost_VERSION VERSION_GREATER 1.74)
     ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_MiniVector.cu)
@@ -595,6 +601,34 @@ if(CUDA_FOUND OR hip_FOUND)
   if(MPI_FOUND)
     ADD_CUDA_OR_HIP_FILE(TEST_SOURCE_FILES tests test_GpuOwnerOverlapCopy.cpp)
   endif()
+
+  # for loop providing the flag --expt-relaxed-constexpr to fix some cuda issues with constexpr
+  if(NOT CONVERT_CUDA_TO_HIP)
+    set(CU_FILES_NEEDING_RELAXED_CONSTEXPR
+      tests/gpuistl/test_gpu_ad.cu
+      tests/gpuistl/test_gpu_linear_two_phase_material.cu
+      tests/gpuistl/test_gpuPvt.cu
+      tests/gpuistl/test_gpuBlackOilFluidSystem.cu
+      tests/gpuistl/test_GpuSparseMatrix.cu
+      tests/gpuistl/test_GpuSparseTable.cu
+      tests/gpuistl/test_blackoilfluidstategpu.cu
+      flow/flow_gpu.cu
+    )
+
+    foreach(file ${CU_FILES_NEEDING_RELAXED_CONSTEXPR})
+        set_source_files_properties(${file} PROPERTIES COMPILE_FLAGS "--expt-relaxed-constexpr")
+    endforeach()
+
+    set(CU_FILES_NEEDING_FPERMISSIVE
+      tests/gpuistl/test_primary_variables_gpu.cu
+    )
+
+    foreach(file ${CU_FILES_NEEDING_FPERMISSIVE})
+      # Certain structures in OPM requires the -fpermissive flag to compile with nvcc,
+      # this enables this for the specific files
+      set_source_files_properties(${file} PROPERTIES COMPILE_FLAGS "-fpermissive --expt-relaxed-constexpr -Xcompiler=-fpermissive")
+    endforeach()
+  endif()
 endif()
 
 if(USE_GPU_BRIDGE)
@@ -707,6 +741,7 @@ list (APPEND TEST_DATA_FILES
   tests/data/test_stokes2c.dgf
   tests/data/test_stokes2cni.dgf
   tests/data/waterair.dgf
+  tests/very_simple_deck.DATA
   )
 
 
@@ -966,6 +1001,7 @@ list (APPEND PUBLIC_HEADER_FILES
   opm/simulators/flow/FacePropertiesTPSA_impl.hpp
   opm/simulators/flow/FemCpGridCompat.hpp
   opm/simulators/flow/FIBlackoilModel.hpp
+  opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp
   opm/simulators/flow/FIPContainer.hpp
   opm/simulators/flow/FlowBaseProblemProperties.hpp
   opm/simulators/flow/FlowBaseVanguard.hpp
@@ -1014,6 +1050,7 @@ list (APPEND PUBLIC_HEADER_FILES
   opm/simulators/flow/RFTContainer.hpp
   opm/simulators/flow/RSTConv.hpp
   opm/simulators/flow/RegionPhasePVAverage.hpp
+  opm/simulators/flow/SimplifiedFlowProblemGPU.hpp
   opm/simulators/flow/SimulatorConvergenceOutput.hpp
   opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp
   opm/simulators/flow/SimulatorFullyImplicitBlackoil_impl.hpp
diff --git a/flow/flow_gaswater_energy.cpp b/flow/flow_gaswater_energy.cpp
index f41a022e6ba..12d11c1ff2b 100644
--- a/flow/flow_gaswater_energy.cpp
+++ b/flow/flow_gaswater_energy.cpp
@@ -22,74 +22,12 @@
 #include <flow/flow_gaswater_energy.hpp>
 
 #include <opm/material/common/ResetLocale.hpp>
-#include <opm/models/blackoil/blackoiltwophaseindices.hh>
 
 #include <opm/grid/CpGrid.hpp>
 #include <opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp>
 #include <opm/simulators/flow/Main.hpp>
 
-#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
-#include <opm/models/discretization/common/tpfalinearizer.hh>
-#include <opm/material/thermal/EnergyModuleType.hpp>
-
-namespace Opm {
-namespace Properties {
-namespace TTag {
-struct FlowGasWaterEnergyProblem {
-    using InheritsFrom = std::tuple<FlowProblem>;
-};
-}
-
-template<class TypeTag>
-struct Linearizer<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
-
-template<class TypeTag>
-struct LocalResidual<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
-
-template<class TypeTag>
-struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
-
-template<class TypeTag>
-struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
-
-template<class TypeTag>
-struct EnergyModuleType<TypeTag, TTag::FlowGasWaterEnergyProblem>
-{ static constexpr EnergyModules value = EnergyModules::FullyImplicitThermal; };
-
-template<class TypeTag>
-struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterEnergyProblem> {
-    static constexpr bool value = true;
-};
-
-template<class TypeTag>
-struct EnableVapwat<TypeTag, TTag::FlowGasWaterEnergyProblem> {
-    static constexpr bool value = true;
-};
-
-//! The indices required by the model
-template<class TypeTag>
-struct Indices<TypeTag, TTag::FlowGasWaterEnergyProblem>
-{
-private:
-    // it is unfortunately not possible to simply use 'TypeTag' here because this leads
-    // to cyclic definitions of some properties. if this happens the compiler error
-    // messages unfortunately are *really* confusing and not really helpful.
-    using BaseTypeTag = TTag::FlowProblem;
-    using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
-    static constexpr EnergyModules energyModuleType = getPropValue<TypeTag, Properties::EnergyModuleType>();
-    static constexpr int numEnergyVars = energyModuleType == EnergyModules::FullyImplicitThermal;
-public:
-    using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
-                                         getPropValue<TypeTag, Properties::EnableExtbo>(),
-                                         getPropValue<TypeTag, Properties::EnablePolymer>(),
-                                         numEnergyVars,
-                                         getPropValue<TypeTag, Properties::EnableFoam>(),
-                                         getPropValue<TypeTag, Properties::EnableBrine>(),
-                                         /*PVOffset=*/0,
-                                         /*disabledCompIdx=*/FluidSystem::oilCompIdx,
-                                         getPropValue<TypeTag, Properties::EnableBioeffects>()>;
-};
-}}
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
 
 namespace Opm {
 
diff --git a/flow/flow_gpu.cu b/flow/flow_gpu.cu
new file mode 100644
index 00000000000..73bdad29732
--- /dev/null
+++ b/flow/flow_gpu.cu
@@ -0,0 +1,67 @@
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "config.h"
+
+// For now flow_gpu is developed to support SPE11 simulations, that is 2-phase gas-water flow with
+// thermal effects The goal is to support both property-evaluation and matrix assembly on the GPU,
+// in addition to the linear solver which already works on the GPU. The CPU would still have to
+// manage well contributions, although there are no wells in SPE11, only source-terms.
+
+#include <flow/flow_gpu.hpp>
+
+#include <opm/common/utility/gpuDecorators.hpp>
+
+#include <opm/material/common/ResetLocale.hpp>
+#include <opm/material/thermal/EnergyModuleType.hpp>
+#include <opm/models/blackoil/blackoiltwophaseindices.hh>
+
+#include <opm/grid/CpGrid.hpp>
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+#include <opm/simulators/flow/Main.hpp>
+#include <opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp>
+#include <opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp>
+
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
+#include <opm/models/discretization/common/tpfalinearizer.hh>
+
+namespace Opm
+{
+
+int
+flowGasWaterEnergyMainGPU(int argc, char** argv, bool outputCout, bool outputFiles)
+{
+    // we always want to use the default locale, and thus spare us the trouble
+    // with incorrect locale settings.
+    resetLocale();
+
+    FlowMain<Properties::TTag::FlowGasWaterEnergyProblemGPU> mainfunc {
+        argc, argv, outputCout, outputFiles};
+    return mainfunc.execute();
+}
+
+int
+flowGasWaterEnergyMainGPUStandalone(int argc, char** argv)
+{
+    using TypeTag = Properties::TTag::FlowGasWaterEnergyProblemGPU;
+    auto mainObject = std::make_unique<::Opm::Main>(argc, argv);
+    auto ret = mainObject->runStatic<TypeTag>();
+    // Destruct mainObject as the destructor calls MPI_Finalize!
+    mainObject.reset();
+    return ret;
+}
+
+} // namespace Opm
diff --git a/flow/flow_gpu.hip b/flow/flow_gpu.hip
new file mode 100644
index 00000000000..2d931fc3077
--- /dev/null
+++ b/flow/flow_gpu.hip
@@ -0,0 +1,67 @@
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "config.h"
+
+// For now flow_gpu is developed to support SPE11 simulations, that is 2-phase gas-water flow with
+// thermal effects The goal is to support both property-evaluation and matrix assembly on the GPU,
+// in addition to the linear solver which already works on the GPU. The CPU would still have to
+// manage well contributions, although there are no wells in SPE11, only source-terms.
+
+#include <flow/flow_gpu.hpp>
+
+#include <opm/common/utility/gpuDecorators.hpp>
+
+#include <opm/material/common/ResetLocale.hpp>
+#include <opm/material/thermal/EnergyModuleType.hpp>
+
+#include <opm/grid/CpGrid.hpp>
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+#include <opm/simulators/flow/Main.hpp>
+#include <opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp>
+#include <opm/simulators/flow/SimulatorFullyImplicitBlackoil.hpp>
+
+#include <opm/models/blackoil/blackoiltwophaseindices.hh>
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
+#include <opm/models/discretization/common/tpfalinearizer.hh>
+
+namespace Opm
+{
+
+int
+flowGasWaterEnergyMainGPU(int argc, char** argv, bool outputCout, bool outputFiles)
+{
+    // we always want to use the default locale, and thus spare us the trouble
+    // with incorrect locale settings.
+    resetLocale();
+
+    FlowMain<Properties::TTag::FlowGasWaterEnergyProblemGPU> mainfunc {
+        argc, argv, outputCout, outputFiles};
+    return mainfunc.execute();
+}
+
+int
+flowGasWaterEnergyMainGPUStandalone(int argc, char** argv)
+{
+    using TypeTag = Properties::TTag::FlowGasWaterEnergyProblemGPU;
+    auto mainObject = std::make_unique<::Opm::Main>(argc, argv);
+    auto ret = mainObject->runStatic<TypeTag>();
+    // Destruct mainObject as the destructor calls MPI_Finalize!
+    mainObject.reset();
+    return ret;
+}
+
+} // namespace Opm
diff --git a/flow/flow_gpu.hpp b/flow/flow_gpu.hpp
new file mode 100644
index 00000000000..9d2706e0882
--- /dev/null
+++ b/flow/flow_gpu.hpp
@@ -0,0 +1,74 @@
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef FLOW_GPU_HIP_HPP
+#define FLOW_GPU_HIP_HPP
+
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+
+namespace Opm
+{
+
+namespace Properties
+{
+    namespace TTag
+    {
+        // FlowGasWaterEnergyProblemGPU is declared in FlowGasWaterEnergyTypeTag.hpp
+        // (InheritsFrom = FlowGasWaterEnergyProblem).  The template below maps it
+        // to FlowGasWaterEnergyProblemGPUTrue<Storage> for GPU-storage variants.
+
+        template <template <class> class Storage>
+        struct FlowGasWaterEnergyProblemGPUTrue {
+            using InheritsFrom = std::tuple<FlowGasWaterEnergyProblemGPU>;
+        };
+
+        template <template <class> class Storage>
+        struct to_gpu_type<FlowGasWaterEnergyProblemGPU, Storage> {
+            using type = FlowGasWaterEnergyProblemGPUTrue<Storage>;
+        };
+    } // namespace TTag
+
+    template <class TypeTag>
+    struct RunAssemblyOnGpu<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+        static constexpr bool value = true;
+    };
+
+    template <class TypeTag>
+    struct Scalar<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+        using type = double;
+    };
+
+    template <class TypeTag>
+    struct GpuFIBlackOilModel<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+        using type = SimplifiedGpuFIBlackOilModel<TypeTag>;
+    };
+
+    template <class TypeTag, template <class> class Storage>
+    struct FluidSystem<TypeTag, TTag::FlowGasWaterEnergyProblemGPUTrue<Storage>> {
+        using type = Opm::
+            BlackOilFluidSystemNonStatic<double, Opm::BlackOilDefaultFluidSystemIndices, Storage>;
+    };
+} // namespace Properties
+
+//! \brief Main function used in flow binary.
+int flowGasWaterEnergyMainGPU(int argc, char** argv, bool outputCout, bool outputFiles);
+
+//! \brief Main function used in flow_gaswater binary.
+int flowGasWaterEnergyMainGPUStandalone(int argc, char** argv);
+
+} // namespace Opm
+
+#endif // FLOW_GPU_HIP_HPP
diff --git a/flow/flow_gpu_main.cpp b/flow/flow_gpu_main.cpp
new file mode 100644
index 00000000000..4664876220e
--- /dev/null
+++ b/flow/flow_gpu_main.cpp
@@ -0,0 +1,25 @@
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include "config.h"
+#include <flow/flow_gpu.hpp>
+
+
+int
+main(int argc, char** argv)
+{
+    return Opm::flowGasWaterEnergyMainGPUStandalone(argc, argv);
+}
diff --git a/opm/models/blackoil/blackoilconvectivemixingmodule.hh b/opm/models/blackoil/blackoilconvectivemixingmodule.hh
index 7a8b87ff29c..80967390cdc 100644
--- a/opm/models/blackoil/blackoilconvectivemixingmodule.hh
+++ b/opm/models/blackoil/blackoilconvectivemixingmodule.hh
@@ -35,6 +35,7 @@
 
 #include <opm/material/common/MathToolbox.hpp>
 #include <opm/material/common/Valgrind.hpp>
+#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
 
 #include <opm/models/common/multiphasebaseproperties.hh>
 #include <opm/models/blackoil/blackoilenergymodules.hh>
@@ -214,9 +215,9 @@ public:
         }
 
         const auto& liquidPhaseIdx =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
-               ? fsys.waterPhaseIdx
-               : fsys.oilPhaseIdx;
+            fsys.phaseIsActive(waterPhaseIdx)
+               ? waterPhaseIdx
+               : oilPhaseIdx;
 
         // Compute avg density based on pure water
         const auto& t_in = intQuantsIn.fluidState().temperature(liquidPhaseIdx);
@@ -320,9 +321,9 @@ public:
         }
 
         const auto& liquidPhaseIdx =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
-                ? fsys.waterPhaseIdx
-                : fsys.oilPhaseIdx;
+            fsys.phaseIsActive(waterPhaseIdx)
+                ? waterPhaseIdx
+                : oilPhaseIdx;
 
         // interiour
         const auto& t_in = intQuantsIn.fluidState().temperature(liquidPhaseIdx);
@@ -331,14 +332,14 @@ public:
         const auto& salt_in = intQuantsIn.fluidState().saltSaturation();
 
         const auto bLiquidSatIn =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
+            fsys.phaseIsActive(waterPhaseIdx)
                 ? fsys.waterPvt().inverseFormationVolumeFactor(intQuantsIn.pvtRegionIndex(),
                                                                        t_in, p_in, rssat_in, salt_in)
                 : fsys.oilPvt().inverseFormationVolumeFactor(intQuantsIn.pvtRegionIndex(),
                                                                      t_in, p_in, rssat_in);
 
         const auto& densityLiquidIn =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
+            fsys.phaseIsActive(waterPhaseIdx)
                 ? fsys.waterPvt().waterReferenceDensity(intQuantsIn.pvtRegionIndex())
                 : fsys.oilPvt().oilReferenceDensity(intQuantsIn.pvtRegionIndex());
 
@@ -354,14 +355,14 @@ public:
         const auto rssat_ex = Opm::getValue(intQuantsEx.saturatedDissolutionFactor());
         const auto salt_ex = Opm::getValue(intQuantsEx.fluidState().saltSaturation());
         const auto bLiquidSatEx =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
+            fsys.phaseIsActive(waterPhaseIdx)
                 ? fsys.waterPvt().inverseFormationVolumeFactor(intQuantsEx.pvtRegionIndex(),
                                                                        t_ex, p_ex, rssat_ex, salt_ex)
                 : fsys.oilPvt().inverseFormationVolumeFactor(intQuantsEx.pvtRegionIndex(),
                                                                      t_ex, p_ex, rssat_ex);
 
         const auto& densityLiquidEx =
-            fsys.phaseIsActive(fsys.waterPhaseIdx)
+            fsys.phaseIsActive(waterPhaseIdx)
                 ? fsys.waterPvt().waterReferenceDensity(intQuantsEx.pvtRegionIndex())
                 : fsys.oilPvt().oilReferenceDensity(intQuantsEx.pvtRegionIndex());
 
@@ -389,7 +390,7 @@ public:
             const auto& rssat_up = (upIdx == interiorDofIdx) ? rssat_in : rssat_ex;
             unsigned globalUpIndex = (upIdx == interiorDofIdx) ? globalIndexIn : globalIndexEx;
             const auto& Rsup =
-                fsys.phaseIsActive(fsys.waterPhaseIdx)
+                fsys.phaseIsActive(waterPhaseIdx)
                     ? up.fluidState().Rsw()
                     : up.fluidState().Rs();
 
diff --git a/opm/models/blackoil/blackoildiffusionmodule.hh b/opm/models/blackoil/blackoildiffusionmodule.hh
index 51db5942f01..721ffc29619 100644
--- a/opm/models/blackoil/blackoildiffusionmodule.hh
+++ b/opm/models/blackoil/blackoildiffusionmodule.hh
@@ -448,7 +448,10 @@ public:
             return *this;
         }
 
-        if (FluidSystem::enableDiffusion()) {
+        // TODO: Cannot really access the non-static enableDiffusion bool here
+        // Doing it this way seems wrong as well because it should be runtime-dependent,
+        // not sure yet what is the best solution.
+        if constexpr (getPropValue<TypeTag, Properties::EnableDiffusion>()) {
             tortuosity_ = rhs.tortuosity_;
             diffusionCoefficient_ = rhs.diffusionCoefficient_;
         }
@@ -462,6 +465,12 @@ public:
     OPM_HOST_DEVICE Evaluation diffusionCoefficient(unsigned phaseIdx, unsigned compIdx) const
     { return diffusionCoefficient_[phaseIdx][compIdx]; }
 
+    /*!
+     * \brief Returns all the diffusion coefficients
+     */
+    OPM_HOST_DEVICE const std::array<std::array<Evaluation, numComponents>, numPhases>& diffusionCoefficients() const
+    { return diffusionCoefficient_; }
+
     /*!
      * \brief Returns the tortuousity of the sub-domain of a fluid
      *        phase in the porous medium.
@@ -469,6 +478,12 @@ public:
     OPM_HOST_DEVICE Evaluation tortuosity(unsigned phaseIdx) const
     { return tortuosity_[phaseIdx]; }
 
+    /*!
+     * \brief Returns all the tortuosities
+     */
+    OPM_HOST_DEVICE const std::array<Evaluation, numPhases>& tortuosities() const
+    { return tortuosity_; }
+
     /*!
      * \brief Returns the effective molecular diffusion coefficient of
      *        the porous medium for a component in a phase.
@@ -695,9 +710,9 @@ protected:
     }
 
 public:
-    static void update(EvaluationArray& effectiveDiffusionCoefficient,
-                       const IntensiveQuantities& intQuantsInside,
-                       const IntensiveQuantities& intQuantsOutside)
+    OPM_HOST_DEVICE static void update(EvaluationArray& effectiveDiffusionCoefficient,
+                                       const IntensiveQuantities& intQuantsInside,
+                                       const IntensiveQuantities& intQuantsOutside)
     {
         const FluidSystem& fsys = intQuantsInside.getFluidSystem();
 
diff --git a/opm/models/blackoil/blackoilextbomodules.hh b/opm/models/blackoil/blackoilextbomodules.hh
index 0a0cce88532..804ab00cadb 100644
--- a/opm/models/blackoil/blackoilextbomodules.hh
+++ b/opm/models/blackoil/blackoilextbomodules.hh
@@ -187,7 +187,7 @@ public:
                 storage[contiZfracEqIdx - 1] += regWghtFactor*Toolbox::template decay<LhsEval>(intQuants.zFraction());
             }
             else {
-                throw std::runtime_error("Only component conservation in terms of surface volumes is implemented. ");
+                OPM_THROW(std::runtime_error, "Only component conservation in terms of surface volumes is implemented. ");
             }
         }
     }
diff --git a/opm/models/blackoil/blackoilintensivequantities.hh b/opm/models/blackoil/blackoilintensivequantities.hh
index c249bdd3b9f..0e8574905d4 100644
--- a/opm/models/blackoil/blackoilintensivequantities.hh
+++ b/opm/models/blackoil/blackoilintensivequantities.hh
@@ -175,20 +175,64 @@ public:
             fluidState_.setRsw(0.0);
         }
     }
-    BlackOilIntensiveQuantities(const BlackOilIntensiveQuantities& other) = default;
 
-    BlackOilIntensiveQuantities& operator=(const BlackOilIntensiveQuantities& other) = default;
+    OPM_HOST_DEVICE BlackOilIntensiveQuantities& operator=(const BlackOilIntensiveQuantities& other) = default;
 
     template<class OtherTypeTag>
     friend class BlackOilIntensiveQuantities;
 
     // This ctor is used when switching to the GPU typetag which currently supports thermal effects and diffusion.
     template<class OtherTypeTag>
+    requires (energyModuleType == EnergyModules::FullyImplicitThermal && (enableDiffusion != 0))
+    explicit BlackOilIntensiveQuantities(
+        const BlackOilIntensiveQuantities<OtherTypeTag>& other, const FluidSystem& fsystem)
+        : fluidState_(other.fluidState_.template withOtherFluidSystem<FluidSystem, Indices::numPhases>(fsystem))
+        , BlackOilEnergyIntensiveQuantities<TypeTag, energyModuleType>(
+            other.rockInternalEnergy_, other.totalThermalConductivity_, other.rockFraction_)
+        , BlackOilDiffusionIntensiveQuantities<TypeTag, enableDiffusion>(
+            other.tortuosities(), other.diffusionCoefficients())
+        , referencePorosity_(other.referencePorosity_)
+        , porosity_(other.porosity_)
+        , rockCompTransMultiplier_(other.rockCompTransMultiplier_)
+        , mobility_(other.mobility_)
+        , dirMob_(/*NOT YET SUPPORTED ON GPU*/)
+    {
+        static_assert(!enableSolvent);
+        static_assert(!enableExtbo);
+        static_assert(!enablePolymer);
+        static_assert(!enableFoam);
+        static_assert(!enableMICP);
+        static_assert(!enableBrine);
+        static_assert(!enableDispersion);
+    }
+
+    template<class OtherTypeTag>
+    requires (energyModuleType == EnergyModules::FullyImplicitThermal && (enableDiffusion == 0))
     explicit BlackOilIntensiveQuantities(
         const BlackOilIntensiveQuantities<OtherTypeTag>& other, const FluidSystem& fsystem)
-        : fluidState_(other.fluidState_.withOtherFluidSystem(fsystem))
+        : fluidState_(other.fluidState_.template withOtherFluidSystem<FluidSystem, Indices::numPhases>(fsystem))
         , BlackOilEnergyIntensiveQuantities<TypeTag, energyModuleType>(
             other.rockInternalEnergy_, other.totalThermalConductivity_, other.rockFraction_)
+        , referencePorosity_(other.referencePorosity_)
+        , porosity_(other.porosity_)
+        , rockCompTransMultiplier_(other.rockCompTransMultiplier_)
+        , mobility_(other.mobility_)
+        , dirMob_(/*NOT YET SUPPORTED ON GPU*/)
+    {
+        static_assert(!enableSolvent);
+        static_assert(!enableExtbo);
+        static_assert(!enablePolymer);
+        static_assert(!enableFoam);
+        static_assert(!enableMICP);
+        static_assert(!enableBrine);
+        static_assert(!enableDispersion);
+    }
+
+    template<class OtherTypeTag>
+    requires (energyModuleType != EnergyModules::FullyImplicitThermal && (enableDiffusion != 0))
+    explicit BlackOilIntensiveQuantities(
+        const BlackOilIntensiveQuantities<OtherTypeTag>& other, const FluidSystem& fsystem)
+        : fluidState_(other.fluidState_.template withOtherFluidSystem<FluidSystem, Indices::numPhases>(fsystem))
         , BlackOilDiffusionIntensiveQuantities<TypeTag, enableDiffusion>(
             other.tortuosities(), other.diffusionCoefficients())
         , referencePorosity_(other.referencePorosity_)
@@ -206,6 +250,28 @@ public:
         static_assert(!enableDispersion);
     }
 
+    template<class OtherTypeTag>
+    requires (energyModuleType != EnergyModules::FullyImplicitThermal && (enableDiffusion == 0))
+    explicit BlackOilIntensiveQuantities(
+        const BlackOilIntensiveQuantities<OtherTypeTag>& other, const FluidSystem& fsystem)
+        : fluidState_(other.fluidState_.template withOtherFluidSystem<FluidSystem, Indices::numPhases>(fsystem))
+        , referencePorosity_(other.referencePorosity_)
+        , porosity_(other.porosity_)
+        , rockCompTransMultiplier_(other.rockCompTransMultiplier_)
+        , mobility_(other.mobility_)
+        , dirMob_(/*NOT YET SUPPORTED ON GPU*/)
+    {
+        static_assert(!enableSolvent);
+        static_assert(!enableExtbo);
+        static_assert(!enablePolymer);
+        static_assert(!enableFoam);
+        static_assert(!enableMICP);
+        static_assert(!enableBrine);
+        static_assert(!enableDispersion);
+    }
+
+    BlackOilIntensiveQuantities(const BlackOilIntensiveQuantities& other) = default;
+
     /**
      * \brief Create a copy of this intensive quantities object
      *
@@ -215,12 +281,51 @@ public:
      * \endcode
      */
     template <class OtherTypeTag>
-    auto withOtherFluidSystem(const GetPropType<OtherTypeTag, Properties::FluidSystem>& other) const
+    auto withOtherFluidSystem(GetPropType<OtherTypeTag, Properties::FluidSystem>* other) const
     {
-        BlackOilIntensiveQuantities<OtherTypeTag> newIntQuants(*this, other);
+        BlackOilIntensiveQuantities<OtherTypeTag> newIntQuants(*this, *other);
         return newIntQuants;
     }
 
+    /*!
+     * \brief Field-by-field overlay of the BlackOil intensive-quantity values from
+     *        another \c BlackOilIntensiveQuantities instantiation onto this one.
+     *
+     * Used by the experimental GPU intensive-quantities dispatcher to write the
+     * GPU-computed result onto a CPU-side \c IntensiveQuantities even when the
+     * two TypeTags are not value-compatible (e.g. when the CPU TypeTag enables
+     * dispersion or other modules that the GPU TypeTag does not). Only stored
+     * fields that the dispatcher actually computes are copied; the
+     * \c mobility_ field is left untouched (the GPU relperm path is currently
+     * known to return zero, see \c GpuBlackoilIntensiveQuantitiesDispatcher).
+     */
+    template<class OtherTypeTag>
+    OPM_HOST_DEVICE void overlayBlackOilFieldsFrom(
+        const BlackOilIntensiveQuantities<OtherTypeTag>& other)
+    {
+        // Full fluid-state copy (handles every stored field, including
+        // Rs/Rv/Rsw/Rvw, salt concentration, solvent fields, ...). This
+        // is intentionally chosen over a hand-picked field list so that
+        // the GPU dispatcher can be used as the *only* fill of the IQ
+        // cache (no CPU pre-pass required).
+        fluidState_.assign(other.fluidState_);
+
+        for (unsigned phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
+            if (!FluidSystem::phaseIsActive(phaseIdx)) {
+                continue;
+            }
+            mobility_[phaseIdx] = other.mobility_[phaseIdx];
+        }
+        if constexpr (energyModuleType == EnergyModules::FullyImplicitThermal) {
+            this->rockInternalEnergy_ = other.rockInternalEnergy_;
+            this->totalThermalConductivity_ = other.totalThermalConductivity_;
+            this->rockFraction_ = other.rockFraction_;
+        }
+        porosity_ = other.porosity_;
+        referencePorosity_ = other.referencePorosity_;
+        rockCompTransMultiplier_ = other.rockCompTransMultiplier_;
+    }
+
     OPM_HOST_DEVICE void updateTempSalt(const Problem& problem,
                                         const PrimaryVariables& priVars,
                                         const unsigned globalSpaceIdx,
@@ -430,11 +535,15 @@ public:
             }
             else {
                 if (getFluidSystem().enableDissolvedGas()) { // Add So > 0? i.e. if only water set rs = 0)
-                    const Evaluation& RsSat = enableExtbo ? asImp_().rs() :
-                        getFluidSystem().saturatedDissolutionFactor(fluidState_,
+                    Evaluation RsSat;
+                    if constexpr (enableExtbo) {
+                        RsSat = asImp_().rs();
+                    } else {
+                        RsSat = getFluidSystem().saturatedDissolutionFactor(fluidState_,
                                                                 oilPhaseIdx,
                                                                 pvtRegionIdx,
                                                                 SoMax);
+                    }
                     fluidState_.setRs(min(RsMax, RsSat));
                 }
                 else {
@@ -448,11 +557,15 @@ public:
             }
             else {
                 if (getFluidSystem().enableVaporizedOil() ) { // Add Sg > 0? i.e. if only water set rv = 0)
-                    const Evaluation& RvSat = enableExtbo ? asImp_().rv() :
-                        getFluidSystem().saturatedDissolutionFactor(fluidState_,
+                    Evaluation RvSat;
+                    if constexpr (enableExtbo) {
+                        RvSat = asImp_().rv();
+                    } else {
+                        RvSat = getFluidSystem().saturatedDissolutionFactor(fluidState_,
                                                                 gasPhaseIdx,
                                                                 pvtRegionIdx,
                                                                 SoMax);
+                    }
                     fluidState_.setRv(min(RvMax, RvSat));
                 }
                 else {
@@ -514,11 +627,16 @@ public:
             const auto [b, mu] = getFluidSystem().inverseFormationVolumeFactorAndViscosity(fluidState_, phaseIdx, pvtRegionIdx);
             fluidState_.setInvB(phaseIdx, b);
             for (int i = 0; i < nmobilities; ++i) {
-                if (enableExtbo && phaseIdx == oilPhaseIdx) {
-                    (*mobilities[i])[phaseIdx] /= asImp_().oilViscosity();
-                }
-                else if (enableExtbo && phaseIdx == gasPhaseIdx) {
-                    (*mobilities[i])[phaseIdx] /= asImp_().gasViscosity();
+                if constexpr (enableExtbo) {
+                    if (phaseIdx == oilPhaseIdx) {
+                        (*mobilities[i])[phaseIdx] /= asImp_().oilViscosity();
+                    }
+                    else if (phaseIdx == gasPhaseIdx) {
+                        (*mobilities[i])[phaseIdx] /= asImp_().gasViscosity();
+                    }
+                    else {
+                        (*mobilities[i])[phaseIdx] /= mu;
+                    }
                 }
                 else {
                     (*mobilities[i])[phaseIdx] /= mu;
@@ -845,7 +963,7 @@ public:
                     case Dir::ZPlus:
                         return dirMob_->getArray(2)[phaseIdx];
                     default:
-                        throw std::runtime_error("Unexpected face direction");
+                        OPM_THROW(std::runtime_error, "Unexpected face direction");
                 }
             }
             else{
@@ -906,7 +1024,7 @@ public:
             return BrineIntQua::permFactor();
         }
         else {
-            throw std::logic_error("permFactor() called but salt precipitation or bioeffects are disabled");
+            OPM_THROW(std::logic_error, "permFactor() called but salt precipitation and bioeffects are disabled");
         }
     }
 
diff --git a/opm/models/blackoil/blackoillocalresidualtpfa.hh b/opm/models/blackoil/blackoillocalresidualtpfa.hh
index df0cad47a1b..a40a34088f5 100644
--- a/opm/models/blackoil/blackoillocalresidualtpfa.hh
+++ b/opm/models/blackoil/blackoillocalresidualtpfa.hh
@@ -47,9 +47,11 @@
 #include <opm/models/blackoil/blackoilpolymermodules.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 #include <opm/models/blackoil/blackoilsolventmodules.hh>
+#include <opm/models/blackoil/blackoilmoduleparams.hh>
 
 #include <opm/common/ErrorMacros.hpp>
 #include <opm/common/utility/gpuDecorators.hpp>
+#include <opm/common/utility/gpuistl_if_available.hpp>
 
 #include <array>
 #include <cassert>
@@ -568,49 +570,6 @@ public:
         }
     }
 
-    template <class BoundaryConditionData, class RateVectorLocal, class LocalProblem>
-    OPM_HOST_DEVICE static void computeBoundaryFlux(RateVectorLocal& bdyFlux,
-                                                    const LocalProblem& problem,
-                                                    const BoundaryConditionData& bdyInfo,
-                                                    const IntensiveQuantities& insideIntQuants,
-                                                    unsigned globalSpaceIdx)
-    {
-#if OPM_IS_INSIDE_HOST_FUNCTION
-        switch (bdyInfo.type) {
-        case BCType::NONE:
-            bdyFlux = 0.0;
-            break;
-        case BCType::RATE:
-            computeBoundaryFluxRate(bdyFlux, bdyInfo);
-            break;
-        case BCType::FREE:
-        case BCType::DIRICHLET:
-            computeBoundaryFluxFree(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
-            break;
-        case BCType::THERMAL:
-            computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
-            break;
-        default:
-            throw std::logic_error("Unknown boundary condition type "
-                                   + std::to_string(static_cast<int>(bdyInfo.type))
-                                   + " in computeBoundaryFlux().");
-        }
-#else // TODO: support all boundary conditions on GPU as well to unify this code
-        switch (bdyInfo.type) {
-        case BCType::NONE:
-            bdyFlux = 0.0;
-            break;
-        case BCType::THERMAL:
-            computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
-            break;
-        default:
-            OPM_THROW(std::logic_error,
-                      "Boundary condition type " + std::to_string(static_cast<int>(bdyInfo.type))
-                          + " is not supported for GPU fluid systems in computeBoundaryFlux().");
-        }
-#endif
-    }
-
     template <class BoundaryConditionData>
     static void computeBoundaryFluxRate(RateVector& bdyFlux, const BoundaryConditionData& bdyInfo)
     {
@@ -745,17 +704,20 @@ public:
         if constexpr (enableFullyImplicitThermal) {
             Evaluation heatFlux;
             // avoid overload of functions with same numeber of elements in eclproblem
-
             Scalar alpha;
-            if constexpr (runAssemblyOnGpu) {
-                // This path is currently only intended for the SimplifiedBlackoilModel for GPUs
-                // which currently does not aim to reproduce the full problem object on the GPU.
+// #if OPM_IS_INSIDE_DEVICE_FUNCTION
+//                 // This path is currently only intended for the SimplifiedBlackoilModel for GPUs
+//                 // which currently does not aim to reproduce the full problem object on the GPU.
+//                 alpha = problem.getAlpha(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
+// #else
+//                 alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(
+//                     globalSpaceIdx, bdyInfo.boundaryFaceIndex);
+// #endif
+            if constexpr (!std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
                 alpha = problem.getAlpha(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
             } else {
-                alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(
-                    globalSpaceIdx, bdyInfo.boundaryFaceIndex);
+                alpha = problem.eclTransmissibilities().thermalHalfTransBoundary(globalSpaceIdx, bdyInfo.boundaryFaceIndex);
             }
-
             unsigned inIdx = 0; // dummy
             // always calculated with derivatives of this cell
             EnergyModule::ExtensiveQuantities::updateEnergyBoundary(heatFlux,
@@ -775,6 +737,49 @@ public:
 #endif
     }
 
+    template <class BoundaryConditionData, class RateVectorLocal, class LocalProblem>
+    OPM_HOST_DEVICE static void computeBoundaryFlux(RateVectorLocal& bdyFlux,
+                                    const LocalProblem& problem,
+                                    const BoundaryConditionData& bdyInfo,
+                                    const IntensiveQuantities& insideIntQuants,
+                                    unsigned globalSpaceIdx)
+    {
+        if constexpr (std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
+            switch (bdyInfo.type) {
+            case BCType::NONE:
+                bdyFlux = 0.0;
+                break;
+            case BCType::RATE:
+                computeBoundaryFluxRate(bdyFlux, bdyInfo);
+                break;
+            case BCType::FREE:
+            case BCType::DIRICHLET:
+                computeBoundaryFluxFree(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
+                break;
+            case BCType::THERMAL:
+                computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
+                break;
+            default:
+                OPM_THROW(std::logic_error, "Unknown boundary condition type "
+                                    + std::to_string(static_cast<int>(bdyInfo.type))
+                                    + " in computeBoundaryFlux().");
+            }
+        } else { // Non-static fluid system used in GPU assembly
+            switch (bdyInfo.type) {
+            case BCType::NONE:
+                bdyFlux = 0.0;
+                break;
+            case BCType::THERMAL:
+                computeBoundaryThermal(problem, bdyFlux, bdyInfo, insideIntQuants, globalSpaceIdx);
+                break;
+            default:
+                OPM_THROW(std::logic_error,
+                        "Boundary condition type " + std::to_string(static_cast<int>(bdyInfo.type))
+                            + " is not supported for GPU fluid systems in computeBoundaryFlux().");
+            }
+        }
+    }
+
     static void computeSource(RateVector& source,
                               const Problem& problem,
                               const IntensiveQuantities& insideIntQuants,
@@ -958,10 +963,19 @@ public:
      * This overload accepts a fluid system instance, enabling use in GPU kernels and
      * other contexts where the static fluid system is not accessible.
      */
+    template <class ScalarVector>
+    OPM_HOST_DEVICE static void adaptMassConservationQuantities_(ScalarVector& container,
+                                                                 unsigned pvtRegionIdx)
+    {
+        // Delegate to the generic overload using a default-constructed static FluidSystem
+        // instance. Valid because the static FluidSystem is stateless (std::is_empty_v).
+        adaptMassConservationQuantities_(container, pvtRegionIdx, FluidSystem{});
+    }
+
     template <class ScalarVector, class FsysType>
     OPM_HOST_DEVICE static void adaptMassConservationQuantities_(ScalarVector& container,
-                                                                 unsigned pvtRegionIdx,
-                                                                 const FsysType& fsys)
+                                                 unsigned pvtRegionIdx,
+                                                 const FsysType& fsys)
     {
         if constexpr (!blackoilConserveSurfaceVolume) {
             // convert "surface volume" to mass. this is complicated a bit by the fact that
diff --git a/opm/models/discretization/common/fvbasediscretization.hh b/opm/models/discretization/common/fvbasediscretization.hh
index c324d4ad6b2..3601aad0ae5 100644
--- a/opm/models/discretization/common/fvbasediscretization.hh
+++ b/opm/models/discretization/common/fvbasediscretization.hh
@@ -660,6 +660,31 @@ public:
         return &intensiveQuantityCache_[timeIdx][globalIdx];
     }
 
+    // TODO: make this more efficient (avoid copy!) and still valid for gpu
+    // TODO: did not want to delve into the special IntQuants vector with special allocators
+    std::vector<IntensiveQuantities> allIntensiveQuantities0()
+    {
+        std::vector<IntensiveQuantities> allIntensiveQuantities;
+        auto& timeZeroIntQuants = intensiveQuantityCache_[0];
+        allIntensiveQuantities.insert(allIntensiveQuantities.end(),
+                                        timeZeroIntQuants.begin(),
+                                        timeZeroIntQuants.end());
+
+
+        return allIntensiveQuantities;
+    }
+
+    std::vector<IntensiveQuantities> allIntensiveQuantities1()
+    {
+        std::vector<IntensiveQuantities> allIntensiveQuantities;
+        auto& timeOneIntQuants = intensiveQuantityCache_[1];
+        assert(!timeOneIntQuants.empty());
+        allIntensiveQuantities.insert(allIntensiveQuantities.end(),
+                timeOneIntQuants.begin(),
+                timeOneIntQuants.end());
+        return allIntensiveQuantities;
+    }
+
     /*!
      * \brief Update the intensive quantity cache for a entity on the grid at given time.
      *
@@ -1204,6 +1229,9 @@ public:
     bool isLocalDof(unsigned globalIdx) const
     { return isLocalDof_[globalIdx]; }
 
+    size_t numDof() const
+    { return asImp_().numGridDof(); }
+
     /*!
      * \brief Returns the volume \f$\mathrm{[m^3]}\f$ of the whole grid which represents
      *        the spatial domain.
diff --git a/opm/models/discretization/common/fvbaseproperties.hh b/opm/models/discretization/common/fvbaseproperties.hh
index 4f3f6dd3ad5..c54afe6e43e 100644
--- a/opm/models/discretization/common/fvbaseproperties.hh
+++ b/opm/models/discretization/common/fvbaseproperties.hh
@@ -46,6 +46,12 @@ namespace TTag {
 struct FvBaseDiscretization
 { using InheritsFrom = std::tuple<FvBaseNewtonMethod, ImplicitModel>; };
 
+template<class TypeTag, template<class> class Storage>
+struct to_gpu_type {};
+
+template<class TypeTag, template <class> class Storage>
+using to_gpu_type_t = typename to_gpu_type<TypeTag, Storage>::type;
+
 } // namespace TTag
 
 
@@ -131,6 +137,11 @@ struct PrimaryVariables { using type = UndefinedProperty; };
 //! The secondary variables within a sub-control volume
 template<class TypeTag, class MyTypeTag>
 struct IntensiveQuantities { using type = UndefinedProperty; };
+
+//! The blackoilmodel that is tailored for GPU compatibility
+template<class TypeTag, class MyTypeTag>
+struct GpuFIBlackOilModel { using type = UndefinedProperty; };
+
 //! The discretization specific part of the intensive quantities
 
 template<class TypeTag, class MyTypeTag>
diff --git a/opm/models/discretization/common/nullfvbaseelementcontext.hh b/opm/models/discretization/common/nullfvbaseelementcontext.hh
new file mode 100644
index 00000000000..5effc3ddcf7
--- /dev/null
+++ b/opm/models/discretization/common/nullfvbaseelementcontext.hh
@@ -0,0 +1,312 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+
+  Copyright 2026 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 2 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+
+  Consult the COPYING file in the top-level source directory of this
+  module for the precise wording of the license and the list of
+  copyright holders.
+*/
+/*!
+ * \file
+ *
+ * \brief GPU-compatible stub of FvBaseElementContext.
+ *
+ * All methods are annotated with OPM_HOST_DEVICE and return dummy/default
+ * values. This class is intended as a placeholder so that GPU kernels that
+ * receive an element context can compile; it does not implement any real
+ * behaviour.
+ *
+ * The heavy Dune/grid infrastructure present in FvBaseElementContext is
+ * intentionally absent here because those types are not usable inside a
+ * CUDA/HIP kernel.
+ */
+#ifndef OPM_FV_BASE_ELEMENT_CONTEXT_GPU_HH
+#define OPM_FV_BASE_ELEMENT_CONTEXT_GPU_HH
+
+#include <opm/common/utility/gpuDecorators.hpp>
+#include <opm/models/discretization/common/fvbaseproperties.hh>
+#include <opm/models/discretization/common/linearizationtype.hh>
+
+#include <cstddef>
+
+namespace Opm
+{
+
+/*!
+ * \ingroup FiniteVolumeDiscretizations
+ *
+ * \brief GPU-compatible stub mirroring the public interface of FvBaseElementContext.
+ *
+ * Uses the same TypeTag-based template parameter as FvBaseElementContext; all
+ * concrete types are extracted via GetPropType at compile time.
+ *
+ * \tparam TypeTag  The type tag from which Scalar, PrimaryVariables, etc. are derived.
+ */
+template <class TypeTag>
+class NullFvBaseElementContext
+{
+public:
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
+    using IntensiveQuantities = GetPropType<TypeTag, Properties::IntensiveQuantities>;
+    using ExtensiveQuantities = GetPropType<TypeTag, Properties::ExtensiveQuantities>;
+    using Problem = GetPropType<TypeTag, Properties::Problem>;
+    using Model = GetPropType<TypeTag, Properties::Model>;
+    using GradientCalculator = GetPropType<TypeTag, Properties::GradientCalculator>;
+
+    // -----------------------------------------------------------------------
+    // Construction / assignment
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE NullFvBaseElementContext() = default;
+    OPM_HOST_DEVICE ~NullFvBaseElementContext() = default;
+    OPM_HOST_DEVICE NullFvBaseElementContext(const NullFvBaseElementContext&) = default;
+    OPM_HOST_DEVICE NullFvBaseElementContext(NullFvBaseElementContext&&) noexcept = default;
+    OPM_HOST_DEVICE NullFvBaseElementContext& operator=(const NullFvBaseElementContext&) = default;
+    OPM_HOST_DEVICE NullFvBaseElementContext& operator=(NullFvBaseElementContext&&) noexcept
+        = default;
+
+    // -----------------------------------------------------------------------
+    // Stencil / element update stubs
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE void updateAll()
+    {
+    }
+    OPM_HOST_DEVICE void updateStencil()
+    {
+    }
+    OPM_HOST_DEVICE void updatePrimaryStencil()
+    {
+    }
+    OPM_HOST_DEVICE void updateStencilTopology()
+    {
+    }
+    OPM_HOST_DEVICE void updateAllIntensiveQuantities()
+    {
+    }
+    OPM_HOST_DEVICE void updateIntensiveQuantities(unsigned /*timeIdx*/)
+    {
+    }
+    OPM_HOST_DEVICE void updatePrimaryIntensiveQuantities(unsigned /*timeIdx*/)
+    {
+    }
+    OPM_HOST_DEVICE void updateIntensiveQuantities(const PrimaryVariables& /*priVars*/,
+                                                   unsigned /*dofIdx*/,
+                                                   unsigned /*timeIdx*/)
+    {
+    }
+    OPM_HOST_DEVICE void updateAllExtensiveQuantities()
+    {
+    }
+    OPM_HOST_DEVICE void updateExtensiveQuantities(unsigned /*timeIdx*/)
+    {
+    }
+
+    // -----------------------------------------------------------------------
+    // Focus DOF
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE void setFocusDofIndex(unsigned dofIdx)
+    {
+        focusDofIdx_ = static_cast<int>(dofIdx);
+    }
+    OPM_HOST_DEVICE unsigned focusDofIndex() const
+    {
+        return focusDofIdx_;
+    }
+
+    // -----------------------------------------------------------------------
+    // Linearization type
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE LinearizationType linearizationType() const
+    {
+        return LinearizationType {};
+    }
+
+    // -----------------------------------------------------------------------
+    // Problem / model accessors — return references to dummy stored objects
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE const Problem& problem() const
+    {
+        return problem_;
+    }
+    OPM_HOST_DEVICE const Model& model() const
+    {
+        return model_;
+    }
+
+    // -----------------------------------------------------------------------
+    // DOF / face counts
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE std::size_t numDof(unsigned /*timeIdx*/) const
+    {
+        return 0;
+    }
+    OPM_HOST_DEVICE std::size_t numPrimaryDof(unsigned /*timeIdx*/) const
+    {
+        return 0;
+    }
+    OPM_HOST_DEVICE std::size_t numInteriorFaces(unsigned /*timeIdx*/) const
+    {
+        return 0;
+    }
+    OPM_HOST_DEVICE std::size_t numBoundaryFaces(unsigned /*timeIdx*/) const
+    {
+        return 0;
+    }
+
+    // -----------------------------------------------------------------------
+    // Global space index / volume
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE unsigned globalSpaceIndex(unsigned /*dofIdx*/, unsigned /*timeIdx*/) const
+    {
+        return 0;
+    }
+
+    OPM_HOST_DEVICE Scalar dofVolume(unsigned /*dofIdx*/, unsigned /*timeIdx*/) const
+    {
+        return Scalar {0};
+    }
+
+    OPM_HOST_DEVICE Scalar dofTotalVolume(unsigned /*dofIdx*/, unsigned /*timeIdx*/) const
+    {
+        return Scalar {0};
+    }
+
+    // -----------------------------------------------------------------------
+    // Boundary
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE bool onBoundary() const
+    {
+        return false;
+    }
+
+    // -----------------------------------------------------------------------
+    // Intensive quantities
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE const IntensiveQuantities& intensiveQuantities(unsigned /*dofIdx*/,
+                                                                   unsigned /*timeIdx*/) const
+    {
+        return intensiveQuantitiesStashed_;
+    }
+
+    OPM_HOST_DEVICE IntensiveQuantities& intensiveQuantities(unsigned /*dofIdx*/,
+                                                             unsigned /*timeIdx*/)
+    {
+        return intensiveQuantitiesStashed_;
+    }
+
+    OPM_HOST_DEVICE const IntensiveQuantities* thermodynamicHint(unsigned /*dofIdx*/,
+                                                                 unsigned /*timeIdx*/) const
+    {
+        return nullptr;
+    }
+
+    // -----------------------------------------------------------------------
+    // Primary variables
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE const PrimaryVariables& primaryVars(unsigned /*dofIdx*/,
+                                                        unsigned /*timeIdx*/) const
+    {
+        return priVarsStashed_;
+    }
+
+    // -----------------------------------------------------------------------
+    // Stash / restore
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE bool haveStashedIntensiveQuantities() const
+    {
+        return stashedDofIdx_ != -1;
+    }
+
+    OPM_HOST_DEVICE int stashedDofIdx() const
+    {
+        return stashedDofIdx_;
+    }
+
+    OPM_HOST_DEVICE void stashIntensiveQuantities(unsigned dofIdx)
+    {
+        stashedDofIdx_ = static_cast<int>(dofIdx);
+    }
+
+    OPM_HOST_DEVICE void restoreIntensiveQuantities(unsigned /*dofIdx*/)
+    {
+        stashedDofIdx_ = -1;
+    }
+
+    // -----------------------------------------------------------------------
+    // Gradient calculator
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE const GradientCalculator& gradientCalculator() const
+    {
+        return gradientCalculator_;
+    }
+
+    // -----------------------------------------------------------------------
+    // Extensive quantities
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE const ExtensiveQuantities& extensiveQuantities(unsigned /*fluxIdx*/,
+                                                                   unsigned /*timeIdx*/) const
+    {
+        return extensiveQuantitiesStashed_;
+    }
+
+    // -----------------------------------------------------------------------
+    // Storage cache flag
+    // -----------------------------------------------------------------------
+
+    OPM_HOST_DEVICE bool enableStorageCache() const
+    {
+        return enableStorageCache_;
+    }
+    OPM_HOST_DEVICE void setEnableStorageCache(bool yesno)
+    {
+        enableStorageCache_ = yesno;
+    }
+
+private:
+    // Dummy stored objects returned by reference accessors.
+    // On device these are default-constructed and carry no meaningful data.
+    Problem problem_ {};
+    Model model_ {};
+    GradientCalculator gradientCalculator_ {};
+    IntensiveQuantities intensiveQuantitiesStashed_ {};
+    ExtensiveQuantities extensiveQuantitiesStashed_ {};
+    PrimaryVariables priVarsStashed_ {};
+
+    int stashedDofIdx_ {-1};
+    int focusDofIdx_ {-1};
+    bool enableStorageCache_ {false};
+};
+
+} // namespace Opm
+
+#endif // OPM_FV_BASE_ELEMENT_CONTEXT_GPU_HH
diff --git a/opm/models/discretization/common/tpfalinearizer.hh b/opm/models/discretization/common/tpfalinearizer.hh
index 40027c74e59..71848bfc8f0 100644
--- a/opm/models/discretization/common/tpfalinearizer.hh
+++ b/opm/models/discretization/common/tpfalinearizer.hh
@@ -42,12 +42,21 @@
 #include <opm/input/eclipse/EclipseState/Grid/FaceDir.hpp>
 #include <opm/input/eclipse/Schedule/BCProp.hpp>
 
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
 #include <opm/models/blackoil/blackoilproperties.hh>
 #include <opm/models/common/multiphasebaseproperties.hh>
 #include <opm/models/discretization/common/baseauxiliarymodule.hh>
 #include <opm/models/discretization/common/fvbaseproperties.hh>
 #include <opm/models/discretization/common/linearizationtype.hh>
+
 #include <opm/simulators/linalg/exportSystem.hpp>
+#include <opm/simulators/flow/SimplifiedFlowProblemGPU.hpp>
+
+// TODO: fetch via typetag of another class instead of accessing directly in this class
+#include <opm/models/blackoil/blackoilconvectivemixingmodule.hh>
+
+#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
+#include <opm/material/fluidsystems/BlackOilFluidSystemNonStatic.hpp>
 
 #include <cassert>
 #include <cstddef>
@@ -56,25 +65,31 @@
 #include <map>
 #include <memory>
 #include <numeric>
+#include <omp.h>
 #include <set>
 #include <stdexcept>
 #include <unordered_map>
 #include <vector>
 
+#include <chrono>
+
 #include <fmt/format.h>
 
 #include <opm/common/utility/gpuDecorators.hpp>
+#include <opm/common/utility/pointerArithmetic.hpp>
+#include <opm/common/utility/gpuistl_if_available.hpp>
 #if HAVE_CUDA
+#include <opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp>
 #if USE_HIP
-#include <opm/simulators/linalg/gpuistl_hip/GpuBuffer.hpp>
-#include <opm/simulators/linalg/gpuistl_hip/GpuView.hpp>
+#include <opm/simulators/linalg/gpuistl_hip/GpuSparseMatrixWrapper.hpp>
 #include <opm/simulators/linalg/gpuistl_hip/MiniMatrix.hpp>
 #include <opm/simulators/linalg/gpuistl_hip/MiniVector.hpp>
+#include <opm/simulators/linalg/gpuistl_hip/detail/gpusparse_matrix_operations.hpp>
 #else
-#include <opm/simulators/linalg/gpuistl/GpuBuffer.hpp>
-#include <opm/simulators/linalg/gpuistl/GpuView.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuSparseMatrixWrapper.hpp>
 #include <opm/simulators/linalg/gpuistl/MiniMatrix.hpp>
 #include <opm/simulators/linalg/gpuistl/MiniVector.hpp>
+#include <opm/simulators/linalg/gpuistl/detail/gpusparse_matrix_operations.hpp>
 #endif
 #endif
 
@@ -117,6 +132,50 @@ struct FullDomain
             gpuistl::make_view(buffer.cells)
         };
     };
+
+template<class TypeTag,
+         class LocalIntensiveQuantities,
+         class LocalModelClass,
+         class LocalResidualKernel,
+         class VectorBlockType,
+         class MatrixBlockType,
+         class ADVectorBlockType,
+         class DiagPtrType,
+         class DomainType,
+         class NeighborSparseTable,
+         class GpuResidualView,
+         class LocalGpuProblemType>
+__global__ void gpu_parallelize_linearization_kernel(
+    const unsigned int numCells,
+    const DomainType GPU_LOCAL_domain,
+    const NeighborSparseTable GPU_LOCAL_neighborInfo,
+    DiagPtrType GPU_LOCAL_diagMatAddress,
+    GpuResidualView GPU_LOCAL_residualView,
+    LocalModelClass localModel,
+    GetPropType<TypeTag, Properties::Scalar> invLocDT,
+    bool dispersionActive,
+    bool enableBioeffects,
+    bool onFullDomain,
+    const gpuistl::GpuView<GetPropType<TypeTag, Properties::Scalar>> GPU_LOCAL_volumes,
+    LocalGpuProblemType localGpuProblem);
+
+template<class TypeTag,
+         class LocalIntensiveQuantities,
+         class LocalModelClass,
+         class LocalResidualKernel,
+         class VectorBlockType,
+         class MatrixBlockType,
+         class ADVectorBlockType,
+         class DiagPtrType,
+         class GpuResidualView,
+         class GpuBoundaryInfoView,
+         class GpuProblem>
+__global__ void linearize_kernel_bc(
+    DiagPtrType GPU_LOCAL_diagMatAddress,
+    GpuResidualView GPU_LOCAL_residualView,
+    const GpuBoundaryInfoView GPU_LOCAL_boundaryInfo,
+    LocalModelClass localModel,
+    GpuProblem gpuProblem);
 #endif
 
 template <class ResidualNBInfoType,class BlockType>
@@ -154,24 +213,111 @@ struct NeighborInfoStruct
     }
 };
 
+template<class VectorBlock, class ScalarFluidState>
+struct BoundaryConditionData
+{
+    BCType type;
+    VectorBlock massRate;
+    unsigned pvtRegionIdx;
+    unsigned boundaryFaceIndex;
+    double faceArea;
+    double faceZCoord;
+    ScalarFluidState exFluidState;
+};
+
+template<class BoundaryConditionData>
+struct BoundaryInfo
+{
+    unsigned int cell;
+    int dir;
+    unsigned int bfIndex;
+    BoundaryConditionData bcdata;
+};
+
 #if HAVE_CUDA && OPM_IS_COMPILING_WITH_GPU_COMPILER
 namespace  gpuistl {
-    template<class MiniMatrixType, class MatrixBlockType, class ResidualNBInfoType>
-    auto copy_to_gpu(const SparseTable<NeighborInfoStruct<ResidualNBInfoType, MatrixBlockType>>& cpuNeighborInfoTable)
+    template< class MiniMatrixType, class GpuMatrixType, class CpuMatrixType, class MatrixBlockType, class ResidualNBInfoType>
+    auto copy_to_gpu(const SparseTable<NeighborInfoStruct<ResidualNBInfoType, MatrixBlockType>>& cpu_neighbor_table, GpuMatrixType& gpuJacobian, CpuMatrixType& cpuJacobian)
     {
-        // Convert the DUNE FieldMatrix/MatrixBlock to MiniMatrix types
+        // Convert the DUNE FieldVectors to MiniMatrix types
         using StructWithMinimatrix = NeighborInfoStruct<ResidualNBInfoType, MiniMatrixType>;
-        std::vector<StructWithMinimatrix> minimatrices(cpuNeighborInfoTable.dataSize());
+        using Scalar = typename GpuMatrixType::field_type;
+        std::vector<StructWithMinimatrix> minimatrices(cpu_neighbor_table.dataSize());
         size_t idx = 0;
-        for (auto e : cpuNeighborInfoTable.dataStorage()) {
-            minimatrices[idx++] = StructWithMinimatrix(e);
+        for (auto e : cpu_neighbor_table.dataStorage()) {
+            minimatrices[idx] = StructWithMinimatrix(e);
+
+            Scalar* gpuBufStart = gpuJacobian.getNonZeroValues().data();
+            Scalar* cpuBufStart = &(cpuJacobian[0][0][0][0]);
+            Scalar* cpuPtr = &((*e.matBlockAddress)[0][0]);
+
+            const size_t gpuNonZeroes = gpuJacobian.nonzeroes();
+            const size_t cpuNonZeroes = cpuJacobian.nonzeroes();
+
+            // To compute the length of the buffer of the cpuJacobian we here assume we have a blocked
+            // BCRS matrix with square blocks and that the blocks are stored as Dune::FieldMatrix
+            using CpuBlockType = typename CpuMatrixType::block_type::BaseType;
+
+            const size_t gpuBlockSize = gpuJacobian.blockSize() * gpuJacobian.blockSize();
+            const size_t cpuBlockSize = CpuBlockType::rows * CpuBlockType::cols;
+
+            size_t gpuBufferSize = gpuNonZeroes * gpuBlockSize;
+            size_t cpuBufferSize = cpuNonZeroes * cpuBlockSize;
+
+            assert (gpuBufferSize == cpuBufferSize);
+
+            // convert the pointer from CPU to GPU pointer based on offset in CPU jacobian
+            Scalar* gpuPtr = ComputePtrBasedOnOffsetInOtherBuffer(
+                gpuBufStart, gpuBufferSize,
+                cpuBufStart, cpuBufferSize,
+                cpuPtr
+            );
+
+            minimatrices[idx].matBlockAddress = reinterpret_cast<MiniMatrixType*>(gpuPtr);
+
+            ++idx;
         }
 
         return SparseTable<StructWithMinimatrix, gpuistl::GpuBuffer>(
             gpuistl::GpuBuffer<StructWithMinimatrix>(minimatrices),
-            gpuistl::GpuBuffer<int>(cpuNeighborInfoTable.rowStarts())
+            gpuistl::GpuBuffer<int>(cpu_neighbor_table.rowStarts())
         );
     }
+
+    // Handle the BoundaryInfo structs
+    template<class GpuVecBlock, class GpuFluidState, class BoundaryInfoTypeGPU, class BoundaryInfoTypeCPU, typename GpuFluidSystemPtr>
+    auto copy_to_gpu(const std::vector<BoundaryInfoTypeCPU>& cpu_boundary_info, GpuFluidSystemPtr* dynamicGpuFluidSystemPtr)
+    {
+        std::vector<BoundaryInfoTypeGPU> gpu_boundary_info;
+        for (const auto& info : cpu_boundary_info) {
+            gpu_boundary_info.push_back(BoundaryInfoTypeGPU{info.cell,
+                                        info.dir,
+                                        info.bfIndex,
+                                        BoundaryConditionData<GpuVecBlock, GpuFluidState>{
+                                            info.bcdata.type,
+                                            GpuVecBlock(info.bcdata.massRate),
+                                            info.bcdata.pvtRegionIdx,
+                                            info.bcdata.boundaryFaceIndex,
+                                            info.bcdata.faceArea,
+                                            info.bcdata.faceZCoord,
+                                            info.bcdata.exFluidState.withOtherFluidSystem(dynamicGpuFluidSystemPtr)}});
+        }
+
+        return gpuistl::GpuBuffer<BoundaryInfoTypeGPU>(gpu_boundary_info);
+    }
+
+    // Implemented for residual_, which is a vector of FiedVectors
+    // We then make a GpuBuffer of MiniVectors
+    template<class CpuVecOfVecType, class GpuInnerVecType>
+    auto copy_to_gpu_residual(CpuVecOfVecType& cpuVecOfVec)
+    {
+        std::vector<GpuInnerVecType> stdVecOfInnerVecs;
+        for (const auto& vec : cpuVecOfVec) {
+            stdVecOfInnerVecs.push_back((GpuInnerVecType)vec);
+        }
+
+        return gpuistl::GpuBuffer<GpuInnerVecType>(stdVecOfInnerVecs);
+    }
 }
 #endif
 
@@ -210,6 +356,8 @@ class TpfaLinearizer
 
     using Vector = GlobalEqVector;
 
+    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
+
     enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
     enum { historySize = getPropValue<TypeTag, Properties::TimeDiscHistorySize>() };
     enum { dimWorld = GridView::dimensionworld };
@@ -219,8 +367,9 @@ class TpfaLinearizer
     using ADVectorBlock = GetPropType<TypeTag, Properties::RateVector>;
 
 #if HAVE_CUDA && OPM_IS_COMPILING_WITH_GPU_COMPILER
-    using MatrixBlockGPU = gpuistl::MiniMatrix<Scalar, numEq * numEq>;
+    using MatrixBlockGPU = gpuistl::MiniMatrix<Scalar, numEq>;
     using VectorBlockGPU = gpuistl::MiniVector<Scalar, numEq>;
+    using ADVectorBlockGPU = gpuistl::MiniVector<Evaluation, numEq>;
 #endif
 
     static constexpr bool linearizeNonLocalElements =
@@ -570,7 +719,7 @@ private:
         std::vector<NeighborSet> sparsityPattern(model.numTotalDof());
         const Scalar gravity = problem_().gravity()[dimWorld - 1];
         unsigned numCells = model.numTotalDof();
-        neighborInfo_.reserve(numCells, 6 * numCells);
+        neighborInfo_.reserve(numCells, 6 * numCells); // Expect ~6 neighbors per cell
         std::vector<NeighborInfoCPU> loc_nbinfo;
         for (const auto& elem : elements(gridView_())) {
             stencil.update(elem);
@@ -626,7 +775,7 @@ private:
                             massrate[ii] = massrateAD[ii].value();
                         }
                         const auto& exFluidState = problem_().boundaryFluidState(myIdx, dir_id);
-                        BoundaryConditionData bcdata{type,
+                        BoundaryConditionDataCPU bcdata{type,
                                                      massrate,
                                                      exFluidState.pvtRegionIndex(),
                                                      bfIndex,
@@ -659,6 +808,11 @@ private:
             }
         }
 
+#if HAVE_CUDA
+        gpuJacobian_.reset(new gpuistl::GpuSparseMatrixWrapper<Scalar>(gpuistl::GpuSparseMatrixWrapper<Scalar>::fromMatrix(jacobian_->istlMatrix())));
+        gpuBufferDiagMatAddress_.reset(new gpuistl::GpuBuffer<Scalar*>(gpuistl::detail::getDiagPtrs(*gpuJacobian_)));
+#endif
+
         // Create dummy full domain.
         fullDomain_.cells.resize(numCells);
         std::iota(fullDomain_.cells.begin(), fullDomain_.cells.end(), 0);
@@ -670,6 +824,10 @@ private:
         residual_ = 0.0;
         // zero all matrix entries
         jacobian_->clear();
+
+#if HAVE_CUDA
+        gpuJacobian_->setToZero();
+#endif
     }
 
     // Initialize the flows, flores, and velocity sparse tables
@@ -798,7 +956,8 @@ private:
     }
 
 public:
-    void setResAndJacobi(VectorBlock& res, MatrixBlock& bMat, const ADVectorBlock& resid) const
+    template<class VectorBlockType, class MatrixBlockType, class ADVectorBlockType>
+    OPM_HOST_DEVICE static void setResAndJacobi(VectorBlockType& res, MatrixBlockType& bMat, const ADVectorBlockType& resid)
     {
         for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
             res[eqIdx] = resid[eqIdx].value();
@@ -899,6 +1058,8 @@ private:
     template <class SubDomainType>
     void linearize_(const SubDomainType& domain)
     {
+        constexpr bool run_assembly_on_gpu = getPropValue<TypeTag, Properties::RunAssemblyOnGpu>();
+
         // This check should be removed once this is addressed by
         // for example storing the previous timesteps' values for
         // rsmax (for DRSDT) and similar.
@@ -908,164 +1069,481 @@ private:
             }
         }
 
+        const double invDt = 1.0 / simulator_().timeStepSize();
+
         OPM_TIMEBLOCK(linearize);
 
         // We do not call resetSystem_() here, since that will set
         // the full system to zero, not just our part.
         // Instead, that must be called before starting the linearization.
         const bool dispersionActive = simulator_().vanguard().eclState().getSimulationConfig().rock_config().dispersion();
-        const auto& blockVelocity = simulator_().problem().eclWriter().outputModule().getFlows().blockVelocity();
         const unsigned int numCells = domain.cells.size();
+        const bool on_full_domain = (numCells == model_().numTotalDof());
+
+        if constexpr (!run_assembly_on_gpu) {
+            linearize_parallelization_wrapper<run_assembly_on_gpu, IntensiveQuantities, Model, LocalResidual, VectorBlock, MatrixBlock, ADVectorBlock>(
+                numCells/*numCells*/,
+                domain,
+                neighborInfo_,
+                diagMatAddress_,
+                residual_,
+                model_(),
+                invDt,
+                dispersionActive,
+                enableBioeffects,
+                on_full_domain,
+                problem_());
+
+            linearize_kernel_CPU_boundary<IntensiveQuantities, Model, LocalResidual, VectorBlock, MatrixBlock, ADVectorBlock>(
+                diagMatAddress_,
+                residual_,
+                boundaryInfo_);
+        } else {
+#if HAVE_CUDA && OPM_IS_COMPILING_WITH_GPU_COMPILER
+            // Make sure we have can have the domain on the GPU.
+            if constexpr (std::is_same_v<SubDomainType, FullDomain<>>) {
+
+                auto domain_buffer = copy_to_gpu(domain);
+                auto domain_view = make_view(domain_buffer);
+
+                auto neighborInfo_buffer = gpuistl::copy_to_gpu<MatrixBlockGPU>(neighborInfo_, *gpuJacobian_, jacobian_->istlMatrix());
+                auto neighborInfo_view = gpuistl::make_view(neighborInfo_buffer);
+
+                using NeighborInfoGPU = NeighborInfoStruct<ResidualNBInfo, MatrixBlockGPU>;
+
+                auto diagMatAddressView = gpuistl::make_view(*gpuBufferDiagMatAddress_);
+
+                // Take the residual_ and move it to the GPU
+                // This requires going from doubles, to a blocked vector
+                // This is done using a GpuBuffer which contains MiniVectors
+
+                auto gpuResidualBuffer = gpuistl::copy_to_gpu_residual<GlobalEqVector, VectorBlockGPU>(residual_);
+                auto gpuResidualView = gpuistl::make_view(gpuResidualBuffer);
 
-        // Fetch timestepsize used later in accumulation term.
-        const double dt = simulator_().timeStepSize();
+                using CorrectTypeTagView = typename ::Opm::Properties::TTag::to_gpu_type_t<TypeTag, gpuistl::GpuView>;
+                using GPUBOIQ = BlackOilIntensiveQuantities<CorrectTypeTagView>;
 
+                using LocalResidualGPU = BlackOilLocalResidualTPFA<CorrectTypeTagView>;
+
+                // test creating a FluidSystem that is suitable for GPU use
+                auto& dynamicFluidSystem = FluidSystem::getNonStaticInstance();
+                auto dynamicGpuFluidSystemBuffer = ::Opm::gpuistl::copy_to_gpu(dynamicFluidSystem);
+                auto dynamicGpuFluidSystemView = ::Opm::gpuistl::make_view(dynamicGpuFluidSystemBuffer);
+
+                std::vector<Scalar> volumes(numCells);
+                for (unsigned i = 0; i < numCells; ++i) {
+                    volumes[domain.cells[i]] = model_().dofTotalVolume(domain.cells[i]);
+                }
+                auto gpuVolumesBuffer = gpuistl::GpuBuffer<Scalar>(volumes);
+                auto gpuVolumesView = gpuistl::make_view(gpuVolumesBuffer);
+
+                // We need to have a pointer to the fluidysystem that can be used inside a GPU kernel
+                // Having a pointer to the view is not good enough as the view exists on the host, so
+                // allocat a view on the GPU with a pointer to it via the make_gpu_shared_ptr function
+                auto dynamicGpuFluidSystemPtr = gpuistl::make_gpu_shared_ptr(dynamicGpuFluidSystemView);
+
+                using GpuScalarFluidState = typename GPUBOIQ::ScalarFluidState;
+                using BoundaryConditionDataGPU = BoundaryConditionData<VectorBlockGPU, GpuScalarFluidState>;
+                using BoundaryInfoGPU = BoundaryInfo<BoundaryConditionDataGPU>;
+
+                // Copy boundary info to GPU
+                gpuistl::GpuBuffer<BoundaryInfoGPU> boundaryInfo_buffer = gpuistl::copy_to_gpu<VectorBlockGPU, GpuScalarFluidState, BoundaryInfoGPU>(boundaryInfo_, dynamicGpuFluidSystemPtr.get());
+
+                auto boundaryInfo_view = gpuistl::make_view(boundaryInfo_buffer);
+
+                using GpuModel = GetPropType<TypeTag, Properties::GpuFIBlackOilModel>;
+                GpuModel gpuModel(model_().allIntensiveQuantities0(), model_().allIntensiveQuantities1());
+
+                auto gpuModelBuffer = gpuistl::copy_to_gpu(gpuModel, dynamicGpuFluidSystemPtr.get());
+                auto gpuModelView = gpuistl::make_view(gpuModelBuffer);
+
+                // Handle the thermal half transmissibilities that on CPU are accessible in the kernel via the problem instance
+                // that instead must be prefetched for the GPU.
+                std::vector<Scalar> alpha0(numCells);
+                std::vector<Scalar> alpha1(numCells);
+                std::vector<Scalar> alpha2(numCells);
+
+                const std::map<std::pair<unsigned, unsigned>, Scalar>& thermalHalfTransBoundary = problem_().eclTransmissibilities().getThermalHalfTransBoundary();
+
+                for (auto e : thermalHalfTransBoundary) {
+                    const auto& key = e.first;
+                    const auto& value = e.second;
+                    const unsigned cell = key.first;
+                    const unsigned dir = key.second;
+                    if (dir == 0) {
+                        alpha0[cell] = value;
+                    } else if (dir == 1) {
+                        alpha1[cell] = value;
+                    } else if (dir == 2) {
+                        alpha2[cell] = value;
+                    }
+                    else {
+                        OPM_THROW(std::logic_error, "Invalid direction for thermal half transmissibility: " + std::to_string(dir));
+                    }
+                }
+
+                SimplifiedFlowProblemGPU<Scalar> gpuFlowProblem(alpha0, alpha1, alpha2, problem_().moduleParams());
+                auto gpuFlowProblemBuffer = gpuistl::copy_to_gpu(gpuFlowProblem);
+                auto gpuFlowProblemView = gpuistl::make_view(gpuFlowProblemBuffer);
+                using GpuProblem = decltype(gpuFlowProblemView);
+
+                int constexpr blockSize = 256;
+#if USE_HIP
+                hipDeviceSynchronize();
+#else
+                cudaDeviceSynchronize();
+#endif
+                auto linearizeStartTime = std::chrono::high_resolution_clock::now();
+
+                linearize_parallelization_wrapper<run_assembly_on_gpu, GPUBOIQ, decltype(gpuModelView), LocalResidualGPU, VectorBlockGPU, MatrixBlockGPU, ADVectorBlockGPU>(
+                    numCells,
+                    domain_view,
+                    neighborInfo_view,
+                    diagMatAddressView,
+                    gpuResidualView,
+                    gpuModelView,
+                    invDt,
+                    dispersionActive,
+                    enableBioeffects,
+                    on_full_domain,
+                    gpuFlowProblemView,
+                    gpuVolumesView);
+                if (boundaryInfo_buffer.size() > 0) {
+                    linearize_kernel_bc<CorrectTypeTagView, GPUBOIQ, decltype(gpuModelView), LocalResidualGPU, VectorBlockGPU, MatrixBlockGPU, ADVectorBlockGPU><<<((boundaryInfo_buffer.size()+blockSize - 1)/blockSize), blockSize>>>(
+                        diagMatAddressView,
+                        gpuResidualView,
+                        boundaryInfo_view,
+                        gpuModelView,
+                        gpuFlowProblemView);
+                }
+
+#if USE_HIP
+                hipDeviceSynchronize();
+#else
+                cudaDeviceSynchronize();
+#endif
+                auto linearizeEndTime = std::chrono::high_resolution_clock::now();
+                auto linearizeDuration = std::chrono::duration_cast<std::chrono::microseconds>(linearizeEndTime - linearizeStartTime).count();
+                std::cout << fmt::format("GPU linearization took {:.3f} ms\n", static_cast<double>(linearizeDuration) / 1000.0);
+
+                // Now move the gpu residual into the cpu residual
+                auto cpuResidualFromGpu = gpuResidualBuffer.asStdVector();
+                std::memcpy(residual_.data(), cpuResidualFromGpu.data(), numCells * numEq * sizeof(Scalar));
+
+                // move computed jacobian from GPU to CPU
+                auto gpuJacobianNonZeroes = gpuJacobian_->getNonZeroValues().asStdVector();
+                auto& cpuJacobian = jacobian_->istlMatrix();
+                const size_t totalMatrixSize = cpuJacobian.nonzeroes() * numEq * numEq;
+
+                std::memcpy(&(cpuJacobian[0][0][0][0]), gpuJacobianNonZeroes.data(),
+                        totalMatrixSize * sizeof(Scalar));
+            } else {
+                assert(false && "Only FullDomain is supported on GPU");
+            }
+#else
+            OPM_THROW(std::logic_error, "Trying to run GPU assembly without compiling with GPU support");
+#endif
+        }
+
+        // Handle source terms separately as we want the functionality for CPU and GPU cases
+        // but for now we cannot handle this inside the kernel due to the use of problem_()
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
         for (unsigned ii = 0; ii < numCells; ++ii) {
             OPM_TIMEBLOCK_LOCAL(linearizationForEachCell, Subsystem::Assembly);
             const unsigned globI = domain.cells[ii];
-            const auto& nbInfos = neighborInfo_[globI];
             VectorBlock res(0.0);
             MatrixBlock bMat(0.0);
             ADVectorBlock adres(0.0);
-            ADVectorBlock darcyFlux(0.0);
             const IntensiveQuantities& intQuantsIn = model_().intensiveQuantities(globI, /*timeIdx*/ 0);
+            const double volume = model_().dofTotalVolume(globI);
 
-            // Flux term.
-            {
-                OPM_TIMEBLOCK_LOCAL(fluxCalculationForEachCell, Subsystem::Assembly);
-                short loc = 0;
-                for (const auto& nbInfo : nbInfos) {
-                    OPM_TIMEBLOCK_LOCAL(fluxCalculationForEachFace, Subsystem::Assembly);
-                    const unsigned globJ = nbInfo.neighbor;
-                    assert(globJ != globI);
-                    res = 0.0;
-                    bMat = 0.0;
-                    adres = 0.0;
-                    darcyFlux = 0.0;
-                    const IntensiveQuantities& intQuantsEx = model_().intensiveQuantities(globJ, /*timeIdx*/ 0);
-                    LocalResidual::computeFlux(adres, darcyFlux, globI, globJ, intQuantsIn, intQuantsEx,
-                                               nbInfo.res_nbinfo, problem_().moduleParams());
-                    adres *= nbInfo.res_nbinfo.faceArea;
+            // Cell-wise source terms.
+            // This will include well sources if SeparateSparseSourceTerms is false.
+            res = 0.0;
+            bMat = 0.0;
+            adres = 0.0;
+            if (separateSparseSourceTerms_) {
+                LocalResidual::computeSourceDense(adres, problem_(), intQuantsIn, globI, 0);
+            }
+            else {
+                LocalResidual::computeSource(adres, problem_(), intQuantsIn, globI, 0);
+            }
+            adres *= -volume;
+            setResAndJacobi(res, bMat, adres);
+            residual_[globI] += res;
+            //SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
+            *diagMatAddress_[globI] += bMat;
+        } // end of loop for cell globI.
+
+        // Add sparse source terms. For now only wells.
+        if (separateSparseSourceTerms_) {
+            problem_().wellModel().addReservoirSourceTerms(residual_, diagMatAddress_);
+        }
+    }
+
+    template<bool useGPU,
+             class LocalIntensiveQuantities,
+             class LocalModelClass,
+             class LocalResidualKernel,
+             class VectorBlockType,
+             class MatrixBlockType,
+             class ADVectorBlockType,
+             class DiagPtrType,
+             class DomainType,
+             class NeighborSparseTable,
+             class ResidualType,
+             class LocalGpuProblemType>
+    void linearize_parallelization_wrapper(
+        const unsigned int numCells,
+        const DomainType& localDomain,
+        const NeighborSparseTable& localNeighborInfo,
+        DiagPtrType& localDiagMatAddress,
+        ResidualType& localResidual,
+        LocalModelClass& localModel,
+        Scalar invLocDT,
+        bool dispersionActive,
+        bool enableBioeffectsArg,
+        bool onFullDomain,
+        LocalGpuProblemType& localGpuProblem,
+        const gpuistl::GpuView<Scalar>& localVolumes = gpuistl::GpuView<Scalar>()
+        )
+    {
+        if constexpr (useGPU) {
+            assert(!enableBioeffectsArg && "Bioeffects not yet supported on GPU");
+            assert(!dispersionActive && "Dispersion not yet supported on GPU");
+            int constexpr blockSize = 256;
+#if HAVE_CUDA && OPM_IS_COMPILING_WITH_GPU_COMPILER
+            gpu_parallelize_linearization_kernel<TypeTag, LocalIntensiveQuantities, LocalModelClass, LocalResidualKernel, VectorBlockType, MatrixBlockType, ADVectorBlockType, DiagPtrType, DomainType, NeighborSparseTable, ResidualType, LocalGpuProblemType><<<((numCells + blockSize - 1) / blockSize), blockSize>>>(
+                numCells,
+                localDomain,
+                localNeighborInfo,
+                localDiagMatAddress,
+                localResidual,
+                localModel,
+                invLocDT,
+                dispersionActive,
+                enableBioeffectsArg,
+                onFullDomain,
+                localVolumes,
+                localGpuProblem);
+#else
+            assert(false && "Trying to run GPU code without GPU support");
+#endif
+        }
+        else {
+#pragma omp parallel for
+            for (unsigned ii = 0; ii < numCells; ++ii) {
+            linearize_kernel<false, LocalGpuProblemType, decltype(velocityInfo_), LocalIntensiveQuantities , LocalModelClass, LocalResidual, VectorBlockType, MatrixBlockType, ADVectorBlockType, DiagPtrType, DomainType, NeighborSparseTable, ResidualType>(
+                ii,
+                localDomain,
+                localNeighborInfo,
+                localDiagMatAddress,
+                localResidual,
+                localModel,
+                velocityInfo_,
+                invLocDT,
+                localGpuProblem,
+                dispersionActive,
+                enableBioeffects,
+                onFullDomain,
+                0 /* not used on CPU */);
+            }
+        }
+    }
+
+    // Some helper structs so we can wrap arguments and use references or const values in the same signature
+    // based on whether or not we are instantiating the function for GPU or CPU.
+public:
+    template<typename T, bool useGPU>
+    using ArgType = std::conditional_t<useGPU, T, T&>;
+
+    template<typename T, bool useGPU>
+    using ConstArgType = std::conditional_t<useGPU, T, const T&>;
+
+    template<bool useGPU,
+             class ProblemType,
+             class VelocityInfoType,
+             class LocalIntensiveQuantities,
+             class LocalModelClass,
+             class LocalResidualKernel,
+             class VectorBlockType,
+             class MatrixBlockType,
+             class ADVectorBlockType,
+             class DiagPtrType,
+             class DomainType,
+             class NeighborSparseTable,
+             class GpuResidualView,
+             class GpuScalarViewType>
+    OPM_HOST_DEVICE static void linearize_kernel(
+        const unsigned int ii,
+        const ConstArgType<DomainType, useGPU> GPU_LOCAL_domain,
+        const ConstArgType<NeighborSparseTable, useGPU> GPU_LOCAL_neighborInfo,
+        const ConstArgType<DiagPtrType, useGPU> GPU_LOCAL_diagMatAddress,
+        ArgType<GpuResidualView, useGPU> GPU_LOCAL_residualView,
+        ArgType<LocalModelClass, useGPU> localModel,
+        ArgType<VelocityInfoType, useGPU> localVelocityInfo,
+        Scalar invLocDT,
+        const ConstArgType<ProblemType, useGPU> localProblem,
+        bool dispersionActive,
+        bool enableBioeffects,
+        bool on_full_domain,
+        const GpuScalarViewType GPU_LOCAL_volumes // NO DEFAULT CTOR EXISTS
+        )
+    {
+        const unsigned globI = GPU_LOCAL_domain.cells[ii];
+        const auto& nbInfos = GPU_LOCAL_neighborInfo[globI];
+        VectorBlockType res(0.0);
+        MatrixBlockType bMat(0.0);
+        ADVectorBlockType adres(0.0);
+        ADVectorBlockType darcyFlux(0.0);
+        const LocalIntensiveQuantities& intQuantsIn = localModel.intensiveQuantities(globI, /*timeIdx*/ 0);
+
+        // Flux term.
+        {
+            short loc = 0;
+            for (const auto& nbInfo : nbInfos) {
+                const unsigned globJ = nbInfo.neighbor;
+                res = 0.0;
+                bMat = 0.0;
+                adres = 0.0;
+                darcyFlux = 0.0;
+
+                const LocalIntensiveQuantities& intQuantsEx = localModel.intensiveQuantities(globJ, /*timeIdx*/ 0);
+
+                LocalResidualKernel::computeFlux(adres, darcyFlux, globI, globJ, intQuantsIn, intQuantsEx,
+                                                nbInfo.res_nbinfo, localProblem.moduleParams());
+
+                // currently not supported on GPU
+                if constexpr (!useGPU) {
                     if (dispersionActive || enableBioeffects) {
                         for (unsigned phaseIdx = 0; phaseIdx < numEq; ++phaseIdx) {
-                            velocityInfo_[globI][loc].velocity[phaseIdx] =
+                            localVelocityInfo[globI][loc].velocity[phaseIdx] =
                                 darcyFlux[phaseIdx].value() / nbInfo.res_nbinfo.faceArea;
                         }
+                        loc++;
                     }
-                    else if (!blockVelocity.empty()) {
-                        if (std::ranges::binary_search(blockVelocity,
-                                                       simulator_().vanguard().cartesianIndex(globI))) {
-                            for (unsigned phaseIdx = 0; phaseIdx < numEq; ++phaseIdx) {
-                                velocityInfo_[globI][loc].velocity[phaseIdx] =
-                                    darcyFlux[phaseIdx].value() / nbInfo.res_nbinfo.faceArea;
-                            }
-                        }
-                    }
-                    setResAndJacobi(res, bMat, adres);
-                    residual_[globI] += res;
-                    //SparseAdapter syntax:  jacobian_->addToBlock(globI, globI, bMat);
-                    *diagMatAddress_[globI] += bMat;
-                    bMat *= -1.0;
-                    //SparseAdapter syntax: jacobian_->addToBlock(globJ, globI, bMat);
-                    *nbInfo.matBlockAddress += bMat;
-                    ++loc;
                 }
-            }
 
-            // Accumulation term.
-            const double volume = model_().dofTotalVolume(globI);
-            const Scalar storefac = volume / dt;
-            adres = 0.0;
-            {
-                OPM_TIMEBLOCK_LOCAL(computeStorage, Subsystem::Assembly);
-                LocalResidual::template computeStorage<Evaluation>(adres, intQuantsIn);
+                adres *= nbInfo.res_nbinfo.faceArea;
+                setResAndJacobi(res, bMat, adres);
+                GPU_LOCAL_residualView[globI] += res;
+
+                //SparseAdapter syntax:  jacobian_->addToBlock(globI, globI, bMat);
+                *reinterpret_cast<MatrixBlockType*>(GPU_LOCAL_diagMatAddress[globI]) += bMat;
+                bMat *= -1.0;
+                //SparseAdapter syntax: jacobian_->addToBlock(globJ, globI, bMat);
+                *nbInfo.matBlockAddress += bMat;
             }
-            setResAndJacobi(res, bMat, adres);
+        }
+
+        // Accumulation term.
+        adres = 0.0;
+        {
+            LocalResidualKernel::template computeStorage<Evaluation>(adres, intQuantsIn);
+        }
+        setResAndJacobi(res, bMat, adres);
+
+        if constexpr (!useGPU) {
             // Either use cached storage term, or compute it on the fly.
-            if (model_().enableStorageCache()) {
+            if (localModel.enableStorageCache()) {
                 // The cached storage for timeIdx 0 (current time) is not
                 // used, but after storage cache is shifted at the end of the
                 // timestep, it will become cached storage for timeIdx 1.
-                model_().updateCachedStorage(globI, /*timeIdx=*/0, res);
+                localModel.updateCachedStorage(globI, /*timeIdx=*/0, res);
                 // We should not update the storage cache here for NLDD local solves.
                 // This will reset the start-of-step storage to incorrect numbers when
                 // we do local solves, where the iteration number will start from 0,
                 // but the starting state may not be identical to the start-of-step state.
                 // Note that a full assembly must be done before local solves
                 // otherwise this will be left un-updated.
-                if (problem_().iterationContext().isFirstGlobalIteration()) {
+                if (localProblem.iterationContext().isFirstGlobalIteration()) {
                     // Need to update the storage cache.
-                    if (problem_().recycleFirstIterationStorage()) {
+                    if (localProblem.recycleFirstIterationStorage()) {
                         // Assumes nothing have changed in the system which
                         // affects masses calculated from primary variables.
-                        model_().updateCachedStorage(globI, /*timeIdx=*/1, res);
+                        if (on_full_domain) {
+                            // This is to avoid resetting the start-of-step storage
+                            // to incorrect numbers when we do local solves, where the iteration
+                            // number will start from 0, but the starting state may not be identical
+                            // to the start-of-step state.
+                            // Note that a full assembly must be done before local solves
+                            // otherwise this will be left un-updated.
+                            localModel.updateCachedStorage(globI, 1, res);
+                        }
                     }
                     else {
-                        Dune::FieldVector<Scalar, numEq> tmp;
-                        const IntensiveQuantities intQuantOld = model_().intensiveQuantities(globI, 1);
-                        LocalResidual::template computeStorage<Scalar>(tmp, intQuantOld);
-                        model_().updateCachedStorage(globI, /*timeIdx=*/1, tmp);
+                        VectorBlockType tmp;
+                        const LocalIntensiveQuantities intQuantOld = localModel.intensiveQuantities(globI, 1);
+                        LocalResidualKernel::template computeStorage<Scalar>(tmp, intQuantOld);
+                        localModel.updateCachedStorage(globI, 1, tmp);
                     }
                 }
-                res -= model_().cachedStorage(globI, 1);
+                res -= localModel.cachedStorage(globI, 1);
             }
             else {
                 OPM_TIMEBLOCK_LOCAL(computeStorage0, Subsystem::Assembly);
-                Dune::FieldVector<Scalar, numEq> tmp;
-                const IntensiveQuantities intQuantOld = model_().intensiveQuantities(globI, 1);
-                LocalResidual::template computeStorage<Scalar>(tmp, intQuantOld);
+                VectorBlockType tmp;
+                const LocalIntensiveQuantities intQuantOld = localModel.intensiveQuantities(globI, 1);
+                LocalResidualKernel::template computeStorage<Scalar>(tmp, intQuantOld);
                 // assume volume do not change
                 res -= tmp;
             }
-            res *= storefac;
-            bMat *= storefac;
-            residual_[globI] += res;
-            //SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
-            *diagMatAddress_[globI] += bMat;
-
-            // Cell-wise source terms.
-            // This will include well sources if SeparateSparseSourceTerms is false.
-            res = 0.0;
-            bMat = 0.0;
-            adres = 0.0;
-            if (separateSparseSourceTerms_) {
-                LocalResidual::computeSourceDense(adres, problem_(), intQuantsIn, globI, 0);
-            }
-            else {
-                LocalResidual::computeSource(adres, problem_(), intQuantsIn, globI, 0);
-            }
-            adres *= -volume;
-            setResAndJacobi(res, bMat, adres);
-            residual_[globI] += res;
-            //SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
-            *diagMatAddress_[globI] += bMat;
-        } // end of loop for cell globI.
+        } else {
+            VectorBlockType tmp;
+            const LocalIntensiveQuantities intQuantOld = localModel.intensiveQuantities(globI, 1);
+            LocalResidualKernel::template computeStorage<Scalar>(tmp, intQuantOld);
+            // assume volume do not change
+            res -= tmp;
+        }
 
-        // Add sparse source terms. For now only wells.
-        if (separateSparseSourceTerms_) {
-            problem_().wellModel().addReservoirSourceTerms(residual_, diagMatAddress_);
+        Scalar volume;
+        if constexpr (useGPU) {
+            volume = GPU_LOCAL_volumes[globI];
+        } else {
+            volume = localModel.dofTotalVolume(globI);
         }
+        const Scalar storefac = volume * invLocDT;//volume / dt;
+        res *= storefac;
+        bMat *= storefac;
+        GPU_LOCAL_residualView[globI] += res;
+        //SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
+        *reinterpret_cast<MatrixBlockType*>(GPU_LOCAL_diagMatAddress[globI]) += bMat;
+    }
 
+private:
+    template<class LocalIntensiveQuantities,
+             class LocalModelClass,
+             class LocalResidualKernel,
+             class VectorBlockType,
+             class MatrixBlockType,
+             class ADVectorBlockType,
+             class DiagPtrType,
+             class GpuResidualView,
+             class GpuBoundaryInfoView>
+    void linearize_kernel_CPU_boundary(
+        DiagPtrType& GPU_LOCAL_diagMatAddress,
+        GpuResidualView& GPU_LOCAL_residualView,
+        const GpuBoundaryInfoView& GPU_LOCAL_boundaryInfo)
+    {
         // Boundary terms. Only looping over cells with nontrivial bcs.
-        for (const auto& bdyInfo : boundaryInfo_) {
-            if (bdyInfo.bcdata.type == BCType::NONE) {
-                continue;
+        for (int ii = 0; ii < GPU_LOCAL_boundaryInfo.size(); ++ii)
+        {
+            if (GPU_LOCAL_boundaryInfo[ii].bcdata.type != BCType::NONE)
+            {
+                VectorBlockType res(.0);
+                MatrixBlockType bMat(0.0);
+                ADVectorBlockType adres(0.0);
+                const unsigned globI = GPU_LOCAL_boundaryInfo[ii].cell;
+                const LocalIntensiveQuantities& insideIntQuants = model_().intensiveQuantities(globI, /*timeIdx*/ 0);
+                LocalResidual::computeBoundaryFlux(adres, problem_(), GPU_LOCAL_boundaryInfo[ii].bcdata, insideIntQuants, globI);
+                adres *= GPU_LOCAL_boundaryInfo[ii].bcdata.faceArea;
+                setResAndJacobi(res, bMat, adres);
+                GPU_LOCAL_residualView[globI] += res;
+                ////SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
+                *reinterpret_cast<MatrixBlockType*>(GPU_LOCAL_diagMatAddress[globI]) += bMat;
             }
-
-            VectorBlock res(0.0);
-            MatrixBlock bMat(0.0);
-            ADVectorBlock adres(0.0);
-            const unsigned globI = bdyInfo.cell;
-            const IntensiveQuantities& insideIntQuants = model_().intensiveQuantities(globI, /*timeIdx*/ 0);
-            LocalResidual::computeBoundaryFlux(adres, problem_(), bdyInfo.bcdata, insideIntQuants, globI);
-            adres *= bdyInfo.bcdata.faceArea;
-            setResAndJacobi(res, bMat, adres);
-            residual_[globI] += res;
-            ////SparseAdapter syntax: jacobian_->addToBlock(globI, globI, bMat);
-            *diagMatAddress_[globI] += bMat;
         }
     }
 
@@ -1095,6 +1573,10 @@ private:
 
     // the jacobian matrix
     std::unique_ptr<SparseMatrixAdapter> jacobian_{};
+#if HAVE_CUDA
+    std::unique_ptr<gpuistl::GpuSparseMatrixWrapper<Scalar>> gpuJacobian_;
+    std::unique_ptr<gpuistl::GpuBuffer<Scalar*>> gpuBufferDiagMatAddress_;
+#endif
 
     // the right-hand side
     GlobalEqVector residual_;
@@ -1124,25 +1606,12 @@ private:
     SparseTable<VelocityInfo> velocityInfo_;
 
     using ScalarFluidState = typename IntensiveQuantities::ScalarFluidState;
-    struct BoundaryConditionData
-    {
-        BCType type;
-        VectorBlock massRate;
-        unsigned pvtRegionIdx;
-        unsigned boundaryFaceIndex;
-        double faceArea;
-        double faceZCoord;
-        ScalarFluidState exFluidState;
-    };
 
-    struct BoundaryInfo
-    {
-        unsigned int cell;
-        int dir;
-        unsigned int bfIndex;
-        BoundaryConditionData bcdata;
-    };
-    std::vector<BoundaryInfo> boundaryInfo_;
+    using BoundaryConditionDataCPU = BoundaryConditionData<VectorBlock, ScalarFluidState>;
+
+    using BoundaryInfoCPU = BoundaryInfo<BoundaryConditionDataCPU>;
+
+    std::vector<BoundaryInfoCPU> boundaryInfo_;
 
     bool separateSparseSourceTerms_ = false;
 
@@ -1151,6 +1620,118 @@ private:
     int exportIndex_;
     int exportCount_;
 };
+
+#if HAVE_CUDA && OPM_IS_COMPILING_WITH_GPU_COMPILER
+template<class TypeTag,
+         class LocalIntensiveQuantities,
+         class LocalModelClass,
+         class LocalResidualKernel,
+         class VectorBlockType,
+         class MatrixBlockType,
+         class ADVectorBlockType,
+         class DiagPtrType,
+         class DomainType,
+         class NeighborSparseTable,
+         class GpuResidualView,
+         class LocalGpuProblemType>
+__global__ __launch_bounds__(256) void gpu_parallelize_linearization_kernel(
+    const unsigned int numCells,
+    const DomainType GPU_LOCAL_domain,
+    const NeighborSparseTable GPU_LOCAL_neighborInfo,
+    DiagPtrType GPU_LOCAL_diagMatAddress,
+    GpuResidualView GPU_LOCAL_residualView,
+    LocalModelClass localModel,
+    GetPropType<TypeTag, Properties::Scalar> invLocDT,
+    bool dispersionActive,
+    bool enableBioeffects,
+    bool onFullDomain,
+    const gpuistl::GpuView<GetPropType<TypeTag, Properties::Scalar>> GPU_LOCAL_volumes,
+    LocalGpuProblemType localGpuProblem)
+{
+    const unsigned int ii = blockIdx.x * blockDim.x + threadIdx.x;
+
+    if (ii < numCells) {
+        TpfaLinearizer<TypeTag>::template linearize_kernel<true,
+        LocalGpuProblemType,
+        std::nullptr_t,
+        LocalIntensiveQuantities,
+        LocalModelClass,
+        LocalResidualKernel,
+        VectorBlockType,
+        MatrixBlockType,
+        ADVectorBlockType,
+        DiagPtrType,
+        DomainType,
+        NeighborSparseTable,
+        GpuResidualView>(
+            ii,
+            GPU_LOCAL_domain,
+            GPU_LOCAL_neighborInfo,
+            GPU_LOCAL_diagMatAddress,
+            GPU_LOCAL_residualView,
+            localModel,
+            nullptr,
+            invLocDT,
+            localGpuProblem,
+            dispersionActive,
+            enableBioeffects,
+            onFullDomain,
+            GPU_LOCAL_volumes
+            );
+    }
+}
+
+template<class TypeTag,
+         class LocalIntensiveQuantities,
+         class LocalModelClass,
+         class LocalResidualKernel,
+         class VectorBlockType,
+         class MatrixBlockType,
+         class ADVectorBlockType,
+         class DiagPtrType,
+         class GpuResidualView,
+         class GpuBoundaryInfoView,
+         class GpuProblem>
+__global__ void linearize_kernel_bc(
+    DiagPtrType GPU_LOCAL_diagMatAddress,
+    GpuResidualView GPU_LOCAL_residualView,
+    const GpuBoundaryInfoView GPU_LOCAL_boundaryInfo,
+    LocalModelClass localModel,
+    GpuProblem gpuProblem)
+{
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    constexpr int numEq = getPropValue<TypeTag, Properties::NumEq>();
+    const unsigned int ii = blockIdx.x * blockDim.x + threadIdx.x;
+    if (ii < GPU_LOCAL_boundaryInfo.size())
+    {
+        if (GPU_LOCAL_boundaryInfo[ii].bcdata.type != BCType::NONE)
+        {
+            VectorBlockType res(.0);
+            MatrixBlockType bMat(0.0);
+            ADVectorBlockType adres(0.0);
+            const unsigned globI = GPU_LOCAL_boundaryInfo[ii].cell;
+            const LocalIntensiveQuantities& insideIntQuants = localModel.intensiveQuantities(globI, /*timeIdx*/ 0);
+            if constexpr (!std::is_empty_v<GetPropType<TypeTag, Properties::FluidSystem>>) {
+                LocalResidualKernel::computeBoundaryFlux(adres, gpuProblem, GPU_LOCAL_boundaryInfo[ii].bcdata, insideIntQuants, globI);
+            }
+            adres *= GPU_LOCAL_boundaryInfo[ii].bcdata.faceArea;
+            TpfaLinearizer<TypeTag>::setResAndJacobi(res, bMat, adres);
+            auto* residualPtr = &(GPU_LOCAL_residualView.data()[globI]);
+            for (int i = 0; i < numEq; ++i) {
+                atomicAdd(&((*residualPtr)[i]), res[i]);
+            }
+            auto* matPtr = reinterpret_cast<MatrixBlockType*>(GPU_LOCAL_diagMatAddress[globI]);
+            for (int row = 0; row < bMat.size(); ++row) {
+                for (int col = 0; col < bMat.size(); ++col) {
+                    Scalar* elemPtr = &((*matPtr)[row][col]);
+                    atomicAdd(elemPtr, bMat[row][col]);
+                }
+            }
+        }
+    }
+}
+#endif
+
 } // namespace Opm
 
 #endif // TPFA_LINEARIZER
diff --git a/opm/simulators/aquifers/BlackoilAquiferModel.hpp b/opm/simulators/aquifers/BlackoilAquiferModel.hpp
index 1138c41af96..d81bd0c5664 100644
--- a/opm/simulators/aquifers/BlackoilAquiferModel.hpp
+++ b/opm/simulators/aquifers/BlackoilAquiferModel.hpp
@@ -32,7 +32,7 @@
 #include <opm/simulators/aquifers/AquiferCarterTracy.hpp>
 #include <opm/simulators/aquifers/AquiferFetkovich.hpp>
 #include <opm/simulators/aquifers/AquiferNumerical.hpp>
-#include <opm/simulators/aquifers/SupportsFaceTag.hpp>
+// #include <opm/simulators/aquifers/SupportsFaceTag.hpp>
 
 #include <opm/simulators/flow/BaseAquiferModel.hpp>
 
diff --git a/opm/simulators/aquifers/BlackoilAquiferModel_impl.hpp b/opm/simulators/aquifers/BlackoilAquiferModel_impl.hpp
index 386576aa1eb..97ebaf0bef2 100644
--- a/opm/simulators/aquifers/BlackoilAquiferModel_impl.hpp
+++ b/opm/simulators/aquifers/BlackoilAquiferModel_impl.hpp
@@ -46,7 +46,7 @@ BlackoilAquiferModel<TypeTag>::BlackoilAquiferModel(Simulator& simulator)
 {
     // Grid needs to support Facetag
     using Grid = std::remove_const_t<std::remove_reference_t<decltype(simulator.vanguard().grid())>>;
-    static_assert(SupportsFaceTag<Grid>::value, "Grid has to support assumptions about face tag.");
+    // static_assert(SupportsFaceTag<Grid>::value, "Grid has to support assumptions about face tag.");
 
     init();
 }
diff --git a/opm/simulators/flow/FIBlackoilModel.hpp b/opm/simulators/flow/FIBlackoilModel.hpp
index 5a56ed016f8..ad1253e292a 100644
--- a/opm/simulators/flow/FIBlackoilModel.hpp
+++ b/opm/simulators/flow/FIBlackoilModel.hpp
@@ -42,9 +42,23 @@
 
 #include <opm/material/fluidmatrixinteractions/EclMultiplexerMaterialParams.hpp>
 
+#include <opm/common/OpmLog/OpmLog.hpp>
+
+#if HAVE_CUDA
+#include <opm/simulators/flow/FlowProblemParameters.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.hpp>
+#include <memory>
+#include <variant>
+#include <vector>
+#endif
+
+#include <chrono>
 #include <cstddef>
+#include <format>
 #include <stdexcept>
 #include <type_traits>
+#include <mutex>
+#include <thread>
 
 namespace Opm {
 
@@ -79,29 +93,67 @@ class FIBlackOilModel : public BlackOilModel<TypeTag>
                           Dune::Partitions::all,
                           ThreadManager::maxThreads())
     {
+#if HAVE_CUDA
+        useGpuIntensiveQuantitiesDispatcher_ =
+            Parameters::Get<Parameters::ExperimentalComputePropertiesOnGpu>();
+#endif
     }
 
     void invalidateAndUpdateIntensiveQuantities(unsigned timeIdx) const
     {
+
         this->invalidateIntensiveQuantitiesCache(timeIdx);
         if constexpr (gridIsUnchanging) {
             if constexpr (avoidElementContext) {
                 updateCachedIntQuants(timeIdx);
                 return;
             }
-            OPM_BEGIN_PARALLEL_TRY_CATCH();
+
+            if (updateHasRun < 4) {
+                const auto timeBegin = std::chrono::steady_clock::now();
+                OPM_BEGIN_PARALLEL_TRY_CATCH();
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
-            for (const auto& chunk : element_chunks_) {
-                ElementContext elemCtx(this->simulator_);
-                for (const auto& elem : chunk) {
-                    elemCtx.updatePrimaryStencil(elem);
-                    elemCtx.updatePrimaryIntensiveQuantities(timeIdx);
+                for (const auto& chunk : element_chunks_) {
+                    ElementContext elemCtx(this->simulator_);
+                    for (const auto& elem : chunk) {
+                        elemCtx.updatePrimaryStencil(elem);
+                        elemCtx.updatePrimaryIntensiveQuantities(timeIdx);
+                    }
+                }
+                OPM_END_PARALLEL_TRY_CATCH("invalidateAndUpdateIntensiveQuantities: state error",
+                                        this->simulator_.vanguard().grid().comm());
+                const auto timeEnd = std::chrono::steady_clock::now();
+                const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd - timeBegin).count();
+                OpmLog::info(std::format("Updated intensive quantities for {} elements in {} ms", this->gridView_.size(0), duration));
+                ++updateHasRun;
+            } else {
+                OpmLog::info("Intensive quantities update skipped since it has already been run once");
+            }
+
+#if HAVE_CUDA
+            // After all cells are CPU-updated and written into the cache,
+            // overlay the GPU-computed BlackOil fields in one batched call.
+            if constexpr (Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcherSupport<TypeTag>::value)
+            {
+                if (useGpuIntensiveQuantitiesDispatcher_) {
+                    runGpuIntensiveQuantitiesDispatcher_(timeIdx);
+
+                    const std::size_t numCells = this->intensiveQuantityCache_[timeIdx].size();
+                    for (std::size_t i = 0; i < numCells; ++i) {
+                        this->setIntensiveQuantitiesCacheEntryValidity(i, timeIdx, true);
+                    }
+                }
+                else {
+                    updateHasRun = 0; // reset so that the CPU update runs on the next call, if GPU dispatcher is not used
                 }
+            } else {
+                updateHasRun = 0; // reset so that the CPU update runs on the next call, if GPU dispatcher is not supported
             }
-            OPM_END_PARALLEL_TRY_CATCH("invalidateAndUpdateIntensiveQuantities: state error",
-                                       this->simulator_.vanguard().grid().comm());
+#else
+            updateHasRun = 0; // reset so that the CPU update runs on the next call, if GPU dispatcher is not supported
+#endif
         } else {
             // Grid is possibly refined or otherwise changed between calls.
             ElementContext elemCtx(this->simulator_);
@@ -254,6 +306,7 @@ class FIBlackOilModel : public BlackOilModel<TypeTag>
     void updateCachedIntQuantsLoop(const unsigned timeIdx) const
     {
         const auto& elementMapper = this->simulator_.model().elementMapper();
+        const auto cpuStartTime = std::chrono::steady_clock::now();
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
@@ -262,6 +315,32 @@ class FIBlackOilModel : public BlackOilModel<TypeTag>
                 this->template updateSingleCachedIntQuantUnchecked<Args...>(elementMapper.index(elem), timeIdx);
             }
         }
+        const auto cpuDuration =
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+                std::chrono::steady_clock::now() - cpuStartTime);
+        Opm::OpmLog::info(std::format("updateCachedIntQuantsLoop CPU loop took {} ms",
+                                      cpuDuration.count()));
+
+#if HAVE_CUDA
+        // After the CPU per-cell update has populated all fields, optionally
+        // overlay the BlackOil intensive-quantities fields with their GPU
+        // counterparts via the experimental dispatcher. The dispatcher only
+        // overwrites the subset of fields covered by
+        // BlackOilIntensiveQuantities::overlayBlackOilFieldsFrom; everything
+        // else (mobility, energy, ...) keeps the CPU-computed value.
+        if constexpr (Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcherSupport<TypeTag>::value)
+        {
+            if (useGpuIntensiveQuantitiesDispatcher_) {
+                const auto gpuStartTime = std::chrono::steady_clock::now();
+                runGpuIntensiveQuantitiesDispatcher_(timeIdx);
+                const auto gpuDuration =
+                    std::chrono::duration_cast<std::chrono::milliseconds>(
+                        std::chrono::steady_clock::now() - gpuStartTime);
+                Opm::OpmLog::info(std::format("updateCachedIntQuantsLoop GPU dispatch took {} ms",
+                                              gpuDuration.count()));
+            }
+        }
+#endif
     }
 
     template <class ...Args>
@@ -276,6 +355,42 @@ class FIBlackOilModel : public BlackOilModel<TypeTag>
     }
 
     ElementChunks<GridView, Dune::Partitions::All> element_chunks_;
+
+#if HAVE_CUDA
+    bool useGpuIntensiveQuantitiesDispatcher_{false};
+    using GpuDispatcherStorage = std::conditional_t<
+        Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcherSupport<TypeTag>::value,
+        std::unique_ptr<Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcher<TypeTag>>,
+        std::monostate>;
+    mutable GpuDispatcherStorage gpuIntensiveQuantitiesDispatcher_{};
+
+    void runGpuIntensiveQuantitiesDispatcher_(const unsigned timeIdx) const
+    {
+        if constexpr (Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcherSupport<TypeTag>::value) {
+            if (!gpuIntensiveQuantitiesDispatcher_) {
+                gpuIntensiveQuantitiesDispatcher_ =
+                    std::make_unique<
+                        Opm::gpuistl::GpuBlackoilIntensiveQuantitiesDispatcher<TypeTag>>();
+            }
+            using PV = GetPropType<TypeTag, Properties::PrimaryVariables>;
+            const auto& sol = this->solution(timeIdx);
+            const std::size_t numCells = this->intensiveQuantityCache_[timeIdx].size();
+            std::vector<const PV*> priVarsPtrs(numCells);
+            std::vector<IntensiveQuantities*> outIqPtrs(numCells);
+            for (std::size_t i = 0; i < numCells; ++i) {
+                priVarsPtrs[i] = &sol[i];
+                outIqPtrs[i] = &this->intensiveQuantityCache_[timeIdx][i];
+            }
+            gpuIntensiveQuantitiesDispatcher_->update(
+                this->simulator_.problem(),
+                priVarsPtrs.data(),
+                outIqPtrs.data(),
+                numCells);
+        }
+    }
+#endif
+
+    mutable int updateHasRun = 0;
 };
 
 } // namespace Opm
diff --git a/opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp b/opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp
new file mode 100644
index 00000000000..c383c3f64c5
--- /dev/null
+++ b/opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp
@@ -0,0 +1,132 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  Copyright 2026 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*!
+ * \file
+ *
+ * Shared TypeTag declaration for the gas+water+energy (CO2STORE-style)
+ * blackoil flow problem. Originally inlined into
+ * \c flow/flow_gaswater_energy.cpp; extracted into a header so that other
+ * translation units (e.g. the GPU intensive-quantities dispatcher) can
+ * obtain matching property bindings via \c GetPropType.
+ */
+#ifndef OPM_FLOW_GASWATER_ENERGY_TYPETAG_HPP
+#define OPM_FLOW_GASWATER_ENERGY_TYPETAG_HPP
+
+#include <opm/material/thermal/EnergyModuleType.hpp>
+
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
+#include <opm/models/blackoil/blackoiltwophaseindices.hh>
+#include <opm/models/discretization/common/tpfalinearizer.hh>
+
+#include <opm/simulators/flow/FlowProblemBlackoilProperties.hpp>
+
+namespace Opm::Properties {
+namespace TTag {
+struct FlowGasWaterEnergyProblem {
+    using InheritsFrom = std::tuple<FlowProblem>;
+};
+
+/// GPU-simulation variant: all physics properties are inherited from
+/// \c FlowGasWaterEnergyProblem; the GPU-specific property overrides
+/// (RunAssemblyOnGpu, GpuFIBlackOilModel, …) are added in \c flow_gpu.cu.
+struct FlowGasWaterEnergyProblemGPU {
+    using InheritsFrom = std::tuple<FlowGasWaterEnergyProblem>;
+};
+
+} // namespace TTag
+
+// -----------------------------------------------------------------------
+// FlowGasWaterEnergyProblemGPU property overrides that affect the layout
+// of \c BlackOilIntensiveQuantities (and therefore must be visible to
+// every translation unit that instantiates that class with this TypeTag,
+// otherwise we get an ODR violation: e.g. the dispatcher TU and
+// \c flow_gpu.cu would compile differently sized / ordered IQ structs).
+//
+// Dispersion is not yet supported on the GPU assembly path; disable it
+// even though the CPU parent TypeTag enables it.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+    static constexpr bool value = false;
+};
+
+template <class TypeTag>
+struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+    static constexpr bool value = false;
+};
+
+template <class TypeTag>
+struct EnableEnergy<TypeTag, TTag::FlowGasWaterEnergyProblemGPU> {
+    static constexpr bool value = true;
+};
+
+template<class TypeTag>
+struct Linearizer<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = TpfaLinearizer<TypeTag>; };
+
+template<class TypeTag>
+struct LocalResidual<TypeTag, TTag::FlowGasWaterEnergyProblem> { using type = BlackOilLocalResidualTPFA<TypeTag>; };
+
+template<class TypeTag>
+struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
+
+template<class TypeTag>
+struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyProblem> { static constexpr bool value = true; };
+
+template<class TypeTag>
+struct EnergyModuleType<TypeTag, TTag::FlowGasWaterEnergyProblem>
+{ static constexpr EnergyModules value = EnergyModules::FullyImplicitThermal; };
+
+template<class TypeTag>
+struct EnableDisgasInWater<TypeTag, TTag::FlowGasWaterEnergyProblem> {
+    static constexpr bool value = true;
+};
+
+template<class TypeTag>
+struct EnableVapwat<TypeTag, TTag::FlowGasWaterEnergyProblem> {
+    static constexpr bool value = true;
+};
+
+//! The indices required by the model
+template<class TypeTag>
+struct Indices<TypeTag, TTag::FlowGasWaterEnergyProblem>
+{
+private:
+    // it is unfortunately not possible to simply use 'TypeTag' here because
+    // this leads to cyclic definitions of some properties.
+    using BaseTypeTag = TTag::FlowProblem;
+    using FluidSystem = GetPropType<BaseTypeTag, Properties::FluidSystem>;
+    static constexpr EnergyModules energyModuleType = getPropValue<TypeTag, Properties::EnergyModuleType>();
+    static constexpr int numEnergyVars = energyModuleType == EnergyModules::FullyImplicitThermal;
+public:
+    using type = BlackOilTwoPhaseIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
+                                         getPropValue<TypeTag, Properties::EnableExtbo>(),
+                                         getPropValue<TypeTag, Properties::EnablePolymer>(),
+                                         numEnergyVars,
+                                         getPropValue<TypeTag, Properties::EnableFoam>(),
+                                         getPropValue<TypeTag, Properties::EnableBrine>(),
+                                         /*PVOffset=*/0,
+                                         /*disabledCompIdx=*/FluidSystem::oilCompIdx,
+                                         getPropValue<TypeTag, Properties::EnableBioeffects>()>;
+};
+
+} // namespace Opm::Properties
+
+#endif // OPM_FLOW_GASWATER_ENERGY_TYPETAG_HPP
diff --git a/opm/simulators/flow/FlowProblem.hpp b/opm/simulators/flow/FlowProblem.hpp
index 73ff334ffd9..d78e7f5cc77 100644
--- a/opm/simulators/flow/FlowProblem.hpp
+++ b/opm/simulators/flow/FlowProblem.hpp
@@ -833,6 +833,9 @@ class FlowProblem : public GetPropType<TypeTag, Properties::BaseProblem>
     std::shared_ptr<const EclMaterialLawManager> materialLawManager() const
     { return materialLawManager_; }
 
+    std::shared_ptr<const EclThermalLawManager> thermalLawManager() const
+    { return thermalLawManager_; }
+
     template <class FluidState, class ...Args>
     void updateRelperms(
         std::array<Evaluation,numPhases> &mobility,
diff --git a/opm/simulators/flow/FlowProblemParameters.cpp b/opm/simulators/flow/FlowProblemParameters.cpp
index 2f5f29668da..61d8375a8d4 100644
--- a/opm/simulators/flow/FlowProblemParameters.cpp
+++ b/opm/simulators/flow/FlowProblemParameters.cpp
@@ -81,6 +81,13 @@ void registerFlowProblemParameters()
         ("Conserve inner energy and not enthalpy "
          "even if THERMAL is used.");
 
+#if HAVE_CUDA
+    Parameters::Register<Parameters::ExperimentalComputePropertiesOnGpu>
+        ("Experimental: compute BlackOilIntensiveQuantities on the GPU "
+         "via the GpuBlackoilIntensiveQuantitiesDispatcher. Only takes "
+         "effect for CO2STORE-compatible TypeTags; ignored otherwise.");
+#endif
+
     // By default, stop it after the universe will probably have stopped
     // to exist. (the ECL problem will finish the simulation explicitly
     // after it simulated the last episode specified in the deck.)
diff --git a/opm/simulators/flow/FlowProblemParameters.hpp b/opm/simulators/flow/FlowProblemParameters.hpp
index 9908026b63e..aad64841cfb 100644
--- a/opm/simulators/flow/FlowProblemParameters.hpp
+++ b/opm/simulators/flow/FlowProblemParameters.hpp
@@ -69,6 +69,14 @@ struct UseHybridNewton { static constexpr bool value = false; };
 // Conserve inner energy instead of enthalpy even if THERMAL is used
 struct ConserveInnerEnergyThermal { static constexpr bool value = false; };
 
+#if HAVE_CUDA
+// Experimental: route the per-element BlackOilIntensiveQuantities update
+// through the GPU dispatcher instead of computing it on the CPU. Only takes
+// effect for CO2STORE-compatible TypeTags (gas+water, no oil); ignored
+// otherwise.
+struct ExperimentalComputePropertiesOnGpu { static constexpr bool value = true; };
+#endif
+
 } // namespace Opm::Parameters
 
 namespace Opm {
diff --git a/opm/simulators/flow/GpuFlowProblem.hpp b/opm/simulators/flow/GpuFlowProblem.hpp
new file mode 100644
index 00000000000..77130dcc783
--- /dev/null
+++ b/opm/simulators/flow/GpuFlowProblem.hpp
@@ -0,0 +1,587 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  Copyright 2026 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*!
+ * \file
+ * \brief GPU-compatible, simplified version of Opm::FlowProblem.
+ *
+ * Only exposes the subset of the FlowProblem / FlowProblemBlackoil interface
+ * that BlackOilIntensiveQuantities needs in order to call ::update(). Anything
+ * that is not used by the intensive quantities (well model, aquifers, source
+ * terms, boundary conditions, ...) is intentionally absent.
+ */
+#ifndef OPM_GPU_FLOW_PROBLEM_HPP
+#define OPM_GPU_FLOW_PROBLEM_HPP
+
+#include <opm/common/utility/VectorWithDefaultAllocator.hpp>
+#include <opm/common/utility/gpuDecorators.hpp>
+
+#include <opm/models/discretization/common/linearizationtype.hh>
+
+#include <opm/material/fluidmatrixinteractions/GpuEclMaterialLawManager.hpp>
+#include <opm/material/thermal/GpuEclThermalLawManager.hpp>
+
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace Opm::gpuistl
+{
+template <typename T>
+class GpuBuffer;
+template <typename T>
+class GpuView;
+} // namespace Opm::gpuistl
+
+namespace Opm {
+
+/*!
+ * \brief No-op thermal-law manager used as the default 4th template arg of
+ *        \c GpuFlowProblem.
+ *
+ * Carries no data and exposes the minimum surface needed by the
+ * \c GpuFlowProblem builder/copy/view machinery: a \c FluidSystem alias
+ * fixed to \c void (so the \c hasThermal compile-time switch evaluates
+ * to false), trivial empty params types, and trivial accessors that
+ * return default-constructed values.
+ *
+ * Intentionally not callable on the device when actually queried: it is
+ * only used by non-thermal \c GpuFlowProblem instantiations whose dispatch
+ * paths never call \c solidEnergyLawParams or \c thermalConductionLawParams.
+ */
+struct NoThermalLawManager
+{
+    using FluidSystem = void;
+    struct SolidEnergyLawParams {};
+    struct ThermalConductionLawParams {};
+
+    OPM_HOST_DEVICE SolidEnergyLawParams solidEnergyLawParams(unsigned /*elemIdx*/) const
+    {
+        return SolidEnergyLawParams{};
+    }
+    OPM_HOST_DEVICE ThermalConductionLawParams
+    thermalConductionLawParams(unsigned /*elemIdx*/) const
+    {
+        return ThermalConductionLawParams{};
+    }
+};
+
+} // namespace Opm
+
+namespace Opm::gpuistl {
+
+/*! \brief copy_to_gpu overload for the no-op thermal manager. */
+inline ::Opm::NoThermalLawManager
+copy_to_gpu(const ::Opm::NoThermalLawManager& /*cpu*/)
+{
+    return ::Opm::NoThermalLawManager{};
+}
+
+/*! \brief make_view overload for the no-op thermal manager. */
+inline ::Opm::NoThermalLawManager
+make_view(::Opm::NoThermalLawManager& /*buf*/)
+{
+    return ::Opm::NoThermalLawManager{};
+}
+
+} // namespace Opm::gpuistl
+
+namespace Opm {
+
+/*!
+ * \brief Minimal, GPU-compatible problem class.
+ *
+ * Provides exactly the interface required by BlackOilIntensiveQuantities to
+ * compute a primary-variable update on the device. All cell-wise rock /
+ * fluid bookkeeping data is kept in templated Storage so the same class can
+ * be used as a CPU object (default \c std::vector) or as a GPU object
+ * (\c GpuBuffer / \c GpuView).
+ *
+ * The material law manager is held by value (so it is trivially copyable
+ * into a CUDA kernel together with the rest of the problem state).
+ *
+ * \tparam ScalarT             Floating point type used for rock data.
+ * \tparam MaterialLawManagerT GPU material law manager type (e.g.
+ *                             \c Opm::EclMaterialLaw::GpuManager).
+ * \tparam Storage             Container template used for per-cell data.
+ * \tparam ThermalLawManagerT  GPU thermal-law manager type (e.g.
+ *                             \c Opm::EclThermalLaw::GpuManager). Defaults
+ *                             to \c NoThermalLawManager, a no-op stub used
+ *                             by non-thermal callers.
+ */
+template <class ScalarT,
+          class MaterialLawManagerT,
+          template <class> class Storage = ::Opm::VectorWithDefaultAllocator,
+          class ThermalLawManagerT = ::Opm::NoThermalLawManager>
+class GpuFlowProblem
+{
+public:
+    using Scalar = ScalarT;
+    using EclMaterialLawManager = MaterialLawManagerT;
+    using MaterialLawParams = typename EclMaterialLawManager::MaterialLawParams;
+    using EclThermalLawManager = ThermalLawManagerT;
+    using SolidEnergyLawParams = typename EclThermalLawManager::SolidEnergyLawParams;
+    using ThermalConductionLawParams = typename EclThermalLawManager::ThermalConductionLawParams;
+
+    /*! \brief True iff the thermal-law manager carries a real fluid-system
+     *         tag (anything other than \c void) and therefore the
+     *         thermal-extraction code paths should be enabled. */
+    static constexpr bool hasThermal
+        = !std::is_same_v<typename EclThermalLawManager::FluidSystem, void>;
+
+    /*! \brief Trivial nested model() helper that satisfies the
+     *         \c problem.model().linearizer().getLinearizationType() chain
+     *         that BlackOilIntensiveQuantities walks. */
+    struct ModelView
+    {
+        struct LinearizerView
+        {
+            OPM_HOST_DEVICE LinearizationType getLinearizationType() const
+            {
+                return LinearizationType{};
+            }
+        };
+
+        OPM_HOST_DEVICE LinearizerView linearizer() const
+        {
+            return LinearizerView{};
+        }
+    };
+
+    OPM_HOST_DEVICE GpuFlowProblem() = default;
+
+    OPM_HOST_DEVICE GpuFlowProblem(EclMaterialLawManager materialLawManager,
+                                   Storage<Scalar> porosity,
+                                   Storage<Scalar> rockCompressibility,
+                                   Storage<Scalar> rockReferencePressure,
+                                   Storage<Scalar> maxOilSaturation,
+                                   Storage<Scalar> maxOilVaporizationFactor,
+                                   Storage<Scalar> maxGasDissolutionFactor,
+                                   EclThermalLawManager thermalLawManager,
+                                   Storage<Scalar> rockFraction,
+                                   Storage<int> pvtRegionIndex)
+        : materialLawManager_(std::move(materialLawManager))
+        , porosity_(std::move(porosity))
+        , rockCompressibility_(std::move(rockCompressibility))
+        , rockReferencePressure_(std::move(rockReferencePressure))
+        , maxOilSaturation_(std::move(maxOilSaturation))
+        , maxOilVaporizationFactor_(std::move(maxOilVaporizationFactor))
+        , maxGasDissolutionFactor_(std::move(maxGasDissolutionFactor))
+        , thermalLawManager_(std::move(thermalLawManager))
+        , rockFraction_(std::move(rockFraction))
+        , pvtRegionIndex_(std::move(pvtRegionIndex))
+    {
+    }
+
+    /*!
+     * \brief Construct from any CPU \c FlowProblem (or \c FlowProblemBlackoil).
+     *
+     * Iterates over all grid degrees of freedom and copies the rock /
+     * mixing-control fields used by \c BlackOilIntensiveQuantities into local
+     * vectors. The inner material-law manager is constructed from
+     * \c *cpu.materialLawManager(), so the GPU manager type held by this
+     * problem must in turn be constructible from
+     * \c Opm::EclMaterialLaw::Manager (i.e. use CPU vector storage and
+     * piecewise-linear vector-storage two-phase laws).
+     *
+     * Only enabled when this problem itself uses CPU vector storage.
+     */
+    template <class CpuProblem,
+              class StS = Storage<Scalar>,
+              std::enable_if_t<
+                  std::is_same_v<StS, ::Opm::VectorWithDefaultAllocator<Scalar>>,
+                  int> = 0>
+    explicit GpuFlowProblem(const CpuProblem& cpu)
+        : materialLawManager_(*cpu.materialLawManager(), cpu.model().numGridDof())
+    {
+        const std::size_t n = cpu.model().numGridDof();
+        porosity_.resize(n);
+        rockCompressibility_.resize(n);
+        rockReferencePressure_.resize(n);
+        maxOilSaturation_.resize(n);
+        maxOilVaporizationFactor_.resize(n);
+        maxGasDissolutionFactor_.resize(n);
+        for (std::size_t i = 0; i < n; ++i) {
+            const unsigned u = static_cast<unsigned>(i);
+            porosity_[i]                = cpu.porosity(u, 0u);
+            rockCompressibility_[i]     = cpu.rockCompressibility(u);
+            rockReferencePressure_[i]   = cpu.rockReferencePressure(u);
+            maxOilSaturation_[i]        = cpu.maxOilSaturation(u);
+            maxOilVaporizationFactor_[i] = cpu.maxOilVaporizationFactor(0u, u);
+            maxGasDissolutionFactor_[i]  = cpu.maxGasDissolutionFactor(0u, u);
+        }
+        if constexpr (hasThermal) {
+            using FluidSystemTag = typename EclThermalLawManager::FluidSystem;
+            thermalLawManager_
+                = ::Opm::EclThermalLaw::buildCpuManagerFromFlowProblem<Scalar, FluidSystemTag>(
+                    cpu, n);
+            rockFraction_.resize(n);
+            pvtRegionIndex_.resize(n);
+            for (std::size_t i = 0; i < n; ++i) {
+                const unsigned u = static_cast<unsigned>(i);
+                rockFraction_[i] = cpu.rockFraction(u, 0u);
+                pvtRegionIndex_[i] = static_cast<int>(cpu.pvtRegionIndex(u));
+            }
+        }
+    }
+
+    /*!
+     * \brief Construct directly into device-resident \c GpuBuffer storage
+     *        from any CPU \c FlowProblem (or \c FlowProblemBlackoil).
+     *
+     * Internally builds the per-cell rock/mixing data on the host as
+     * \c std::vector<Scalar>, then uploads each as a single
+     * \c GpuBuffer<Scalar>. The inner GPU material law manager is constructed
+     * from \c *cpu.materialLawManager() via its own GpuBuffer-storage
+     * constructor, which uploads the per-cell sample arrays.
+     *
+     * Only enabled when this problem itself uses \c GpuBuffer storage.
+     */
+    template <class CpuProblem,
+              class StS = Storage<Scalar>,
+              std::enable_if_t<
+                  std::is_same_v<StS, ::Opm::gpuistl::GpuBuffer<Scalar>>,
+                  int> = 0>
+    explicit GpuFlowProblem(const CpuProblem& cpu)
+        : materialLawManager_(*cpu.materialLawManager(), cpu.model().numGridDof())
+        , porosity_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.porosity(u, 0u));
+          }))
+        , rockCompressibility_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.rockCompressibility(u));
+          }))
+        , rockReferencePressure_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.rockReferencePressure(u));
+          }))
+        , maxOilSaturation_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.maxOilSaturation(u));
+          }))
+        , maxOilVaporizationFactor_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.maxOilVaporizationFactor(0u, u));
+          }))
+        , maxGasDissolutionFactor_(extractRockField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.maxGasDissolutionFactor(0u, u));
+          }))
+        , thermalLawManager_(buildGpuThermalManager(cpu))
+        , rockFraction_(extractThermalScalarField(cpu, [](const CpuProblem& p, unsigned u) {
+              return Scalar(p.rockFraction(u, 0u));
+          }))
+        , pvtRegionIndex_(extractThermalIntField(cpu, [](const CpuProblem& p, unsigned u) {
+              return static_cast<int>(p.pvtRegionIndex(u));
+          }))
+    {
+    }
+
+    OPM_HOST_DEVICE ModelView model() const
+    {
+        return ModelView{};
+    }
+
+    OPM_HOST_DEVICE int satnumRegionIndex(std::size_t elemIdx) const
+    {
+        return materialLawManager_.satnumRegionIdx(static_cast<unsigned>(elemIdx));
+    }
+
+    OPM_HOST_DEVICE MaterialLawParams materialLawParams(std::size_t elemIdx) const
+    {
+        return materialLawManager_.materialLawParams(static_cast<unsigned>(elemIdx));
+    }
+
+    OPM_HOST_DEVICE Scalar rockCompressibility(std::size_t elemIdx) const
+    {
+        return rockCompressibility_.size() == 0 ? Scalar(0) : rockCompressibility_[elemIdx];
+    }
+
+    OPM_HOST_DEVICE Scalar rockReferencePressure(std::size_t elemIdx) const
+    {
+        return rockReferencePressure_.size() == 0 ? Scalar(0) : rockReferencePressure_[elemIdx];
+    }
+
+    OPM_HOST_DEVICE Scalar porosity(std::size_t elemIdx, unsigned /*timeIdx*/) const
+    {
+        return porosity_.size() == 0 ? Scalar(0) : porosity_[elemIdx];
+    }
+
+    OPM_HOST_DEVICE Scalar maxOilVaporizationFactor(unsigned /*timeIdx*/, std::size_t elemIdx) const
+    {
+        return maxOilVaporizationFactor_.size() == 0 ? Scalar(0) : maxOilVaporizationFactor_[elemIdx];
+    }
+
+    OPM_HOST_DEVICE Scalar maxGasDissolutionFactor(unsigned /*timeIdx*/, std::size_t elemIdx) const
+    {
+        return maxGasDissolutionFactor_.size() == 0 ? Scalar(0) : maxGasDissolutionFactor_[elemIdx];
+    }
+
+    OPM_HOST_DEVICE Scalar maxOilSaturation(std::size_t elemIdx) const
+    {
+        return maxOilSaturation_.size() == 0 ? Scalar(0) : maxOilSaturation_[elemIdx];
+    }
+
+    /*! \brief Per-cell PVT region index. Returns 0 when the GpuFlowProblem
+     *         instantiation has no thermal support. */
+    OPM_HOST_DEVICE unsigned pvtRegionIndex(std::size_t elemIdx) const
+    {
+        return pvtRegionIndex_.size() == 0
+                   ? 0u
+                   : static_cast<unsigned>(pvtRegionIndex_[elemIdx]);
+    }
+
+    /*! \brief Per-cell rock fraction (1 - effective porosity). Returns 0
+     *         when the GpuFlowProblem instantiation has no thermal
+     *         support. */
+    OPM_HOST_DEVICE Scalar rockFraction(std::size_t elemIdx, unsigned /*timeIdx*/) const
+    {
+        return rockFraction_.size() == 0 ? Scalar(0) : rockFraction_[elemIdx];
+    }
+
+    /*! \brief Solid-energy law parameters for a single cell. Forwards to
+     *         the embedded thermal-law manager. */
+    OPM_HOST_DEVICE SolidEnergyLawParams
+    solidEnergyLawParams(std::size_t elemIdx, unsigned /*timeIdx*/) const
+    {
+        return thermalLawManager_.solidEnergyLawParams(static_cast<unsigned>(elemIdx));
+    }
+
+    /*! \brief Thermal-conduction law parameters for a single cell.
+     *         Forwards to the embedded thermal-law manager. */
+    OPM_HOST_DEVICE ThermalConductionLawParams
+    thermalConductionLawParams(std::size_t elemIdx, unsigned /*timeIdx*/) const
+    {
+        return thermalLawManager_.thermalConductionLawParams(static_cast<unsigned>(elemIdx));
+    }
+
+    /*! \brief Default rock-pore-volume multiplier (1 if no compressibility). */
+    template <class Evaluation>
+    OPM_HOST_DEVICE Evaluation rockCompPoroMultiplier(const auto& /*intQuants*/, std::size_t /*elemIdx*/) const
+    {
+        return Evaluation(1.0);
+    }
+
+    /*! \brief Default rock-trans multiplier (1 if no compressibility). */
+    template <class Evaluation>
+    OPM_HOST_DEVICE Evaluation rockCompTransMultiplier(const auto& /*intQuants*/, std::size_t /*elemIdx*/) const
+    {
+        return Evaluation(1.0);
+    }
+
+    /*!
+     * \brief Update the relative permeabilities of all phases for a single
+     *        cell, in the same way as the CPU \c FlowProblem does.
+     *
+     * Calls \c MaterialLaw::relativePermeabilities on the cell's
+     * \c MaterialLawParams. The \c BlackOilIntensiveQuantities later divides
+     * the result by the phase viscosity to obtain the mobility.
+     *
+     * Directional relative permeabilities are not supported by the GPU
+     * problem, so the \p dirMob output is left untouched.
+     */
+    template <class FluidState, class... Args>
+    OPM_HOST_DEVICE void updateRelperms(auto& mobility,
+                                        auto& /*dirMob*/,
+                                        FluidState& fluidState,
+                                        unsigned globalSpaceIdx) const
+    {
+        using ContainerT = std::decay_t<decltype(mobility)>;
+        const auto materialParams = materialLawParams(globalSpaceIdx);
+        EclMaterialLawManager::MaterialLaw::template relativePermeabilities<
+            ContainerT, FluidState, Args...>(mobility, materialParams, fluidState);
+    }
+
+    /*! \name Direct accessors for serialization to the GPU. */
+    //!\{
+    const EclMaterialLawManager& materialLawManager() const { return materialLawManager_; }
+    EclMaterialLawManager& materialLawManager() { return materialLawManager_; }
+    const Storage<Scalar>& porosityStorage() const { return porosity_; }
+    Storage<Scalar>& porosityStorage() { return porosity_; }
+    const Storage<Scalar>& rockCompressibilityStorage() const { return rockCompressibility_; }
+    Storage<Scalar>& rockCompressibilityStorage() { return rockCompressibility_; }
+    const Storage<Scalar>& rockReferencePressureStorage() const { return rockReferencePressure_; }
+    Storage<Scalar>& rockReferencePressureStorage() { return rockReferencePressure_; }
+    const Storage<Scalar>& maxOilSaturationStorage() const { return maxOilSaturation_; }
+    Storage<Scalar>& maxOilSaturationStorage() { return maxOilSaturation_; }
+    const Storage<Scalar>& maxOilVaporizationFactorStorage() const { return maxOilVaporizationFactor_; }
+    Storage<Scalar>& maxOilVaporizationFactorStorage() { return maxOilVaporizationFactor_; }
+    const Storage<Scalar>& maxGasDissolutionFactorStorage() const { return maxGasDissolutionFactor_; }
+    Storage<Scalar>& maxGasDissolutionFactorStorage() { return maxGasDissolutionFactor_; }
+    const EclThermalLawManager& thermalLawManager() const { return thermalLawManager_; }
+    EclThermalLawManager& thermalLawManager() { return thermalLawManager_; }
+    const Storage<Scalar>& rockFractionStorage() const { return rockFraction_; }
+    Storage<Scalar>& rockFractionStorage() { return rockFraction_; }
+    const Storage<int>& pvtRegionIndexStorage() const { return pvtRegionIndex_; }
+    Storage<int>& pvtRegionIndexStorage() { return pvtRegionIndex_; }
+    //!\}
+
+private:
+    template <class CpuProblem, class F>
+    static Storage<Scalar> extractRockField(const CpuProblem& cpu, F f)
+    {
+        const std::size_t n = cpu.model().numGridDof();
+        std::vector<Scalar> v(n);
+        for (std::size_t i = 0; i < n; ++i) {
+            v[i] = f(cpu, static_cast<unsigned>(i));
+        }
+        if constexpr (std::is_same_v<Storage<Scalar>,
+                                     ::Opm::VectorWithDefaultAllocator<Scalar>>) {
+            return Storage<Scalar>(v.begin(), v.end());
+        } else {
+            return Storage<Scalar>(v);
+        }
+    }
+
+    /*! \brief Build the per-cell rockFraction storage; empty when the
+     *         GpuFlowProblem instantiation has no thermal support. */
+    template <class CpuProblem, class F>
+    static Storage<Scalar> extractThermalScalarField(const CpuProblem& cpu, F f)
+    {
+        if constexpr (!hasThermal) {
+            return Storage<Scalar>{};
+        } else {
+            return extractRockField(cpu, f);
+        }
+    }
+
+    /*! \brief Build the per-cell pvtRegionIndex storage; empty when the
+     *         GpuFlowProblem instantiation has no thermal support. */
+    template <class CpuProblem, class F>
+    static Storage<int> extractThermalIntField(const CpuProblem& cpu, F f)
+    {
+        if constexpr (!hasThermal) {
+            return Storage<int>{};
+        } else {
+            const std::size_t n = cpu.model().numGridDof();
+            std::vector<int> v(n);
+            for (std::size_t i = 0; i < n; ++i) {
+                v[i] = f(cpu, static_cast<unsigned>(i));
+            }
+            if constexpr (std::is_same_v<Storage<int>,
+                                         ::Opm::VectorWithDefaultAllocator<int>>) {
+                return Storage<int>(v.begin(), v.end());
+            } else {
+                return Storage<int>(v);
+            }
+        }
+    }
+
+    /*! \brief Build the GPU thermal-law manager from a CPU FlowProblem.
+     *         Returns a default-constructed (empty) manager when this
+     *         GpuFlowProblem instantiation has no thermal support. */
+    template <class CpuProblem>
+    static EclThermalLawManager buildGpuThermalManager(const CpuProblem& cpu)
+    {
+        if constexpr (!hasThermal) {
+            return EclThermalLawManager{};
+        } else {
+            using FluidSystemTag = typename EclThermalLawManager::FluidSystem;
+            auto cpuMgr
+                = ::Opm::EclThermalLaw::buildCpuManagerFromFlowProblem<Scalar, FluidSystemTag>(
+                    cpu, cpu.model().numGridDof());
+            return ::Opm::gpuistl::copy_to_gpu(cpuMgr);
+        }
+    }
+
+    EclMaterialLawManager materialLawManager_{};
+    Storage<Scalar> porosity_{};
+    Storage<Scalar> rockCompressibility_{};
+    Storage<Scalar> rockReferencePressure_{};
+    Storage<Scalar> maxOilSaturation_{};
+    Storage<Scalar> maxOilVaporizationFactor_{};
+    Storage<Scalar> maxGasDissolutionFactor_{};
+    EclThermalLawManager thermalLawManager_{};
+    Storage<Scalar> rockFraction_{};
+    Storage<int> pvtRegionIndex_{};
+};
+
+} // namespace Opm
+
+namespace Opm::gpuistl {
+
+/*!
+ * \brief Copy a CPU GpuFlowProblem to GPU-resident GpuBuffer storage.
+ *
+ *  The material law manager is also moved to the GPU (via copy_to_gpu).
+ */
+template <class ScalarT, class CpuMaterialLawManager, class CpuThermalLawManager>
+auto copy_to_gpu(
+    const ::Opm::GpuFlowProblem<ScalarT,
+                                CpuMaterialLawManager,
+                                ::Opm::VectorWithDefaultAllocator,
+                                CpuThermalLawManager>& cpu)
+{
+    using GpuMaterialLawManagerBuffer
+        = decltype(::Opm::gpuistl::copy_to_gpu(cpu.materialLawManager()));
+    using GpuThermalLawManagerBuffer
+        = decltype(::Opm::gpuistl::copy_to_gpu(cpu.thermalLawManager()));
+    using GpuProblemType = ::Opm::GpuFlowProblem<ScalarT,
+                                                 GpuMaterialLawManagerBuffer,
+                                                 GpuBuffer,
+                                                 GpuThermalLawManagerBuffer>;
+
+    return GpuProblemType(::Opm::gpuistl::copy_to_gpu(cpu.materialLawManager()),
+                          GpuBuffer<ScalarT>(cpu.porosityStorage()),
+                          GpuBuffer<ScalarT>(cpu.rockCompressibilityStorage()),
+                          GpuBuffer<ScalarT>(cpu.rockReferencePressureStorage()),
+                          GpuBuffer<ScalarT>(cpu.maxOilSaturationStorage()),
+                          GpuBuffer<ScalarT>(cpu.maxOilVaporizationFactorStorage()),
+                          GpuBuffer<ScalarT>(cpu.maxGasDissolutionFactorStorage()),
+                          ::Opm::gpuistl::copy_to_gpu(cpu.thermalLawManager()),
+                          GpuBuffer<ScalarT>(cpu.rockFractionStorage()),
+                          GpuBuffer<int>(cpu.pvtRegionIndexStorage()));
+}
+
+/*!
+ * \brief Make a non-owning GpuView based GpuFlowProblem from an owning
+ *        GpuBuffer based GpuFlowProblem.
+ */
+template <class ScalarT, class GpuBufferMaterialLawManager, class GpuBufferThermalLawManager>
+auto make_view(::Opm::GpuFlowProblem<ScalarT,
+                                     GpuBufferMaterialLawManager,
+                                     GpuBuffer,
+                                     GpuBufferThermalLawManager>& buf)
+{
+    using GpuMaterialLawManagerView
+        = decltype(::Opm::gpuistl::make_view(buf.materialLawManager()));
+    using GpuThermalLawManagerView
+        = decltype(::Opm::gpuistl::make_view(buf.thermalLawManager()));
+    using GpuProblemView = ::Opm::GpuFlowProblem<ScalarT,
+                                                 GpuMaterialLawManagerView,
+                                                 GpuView,
+                                                 GpuThermalLawManagerView>;
+
+    auto toView = [](auto& storage) {
+        using T = typename std::decay_t<decltype(storage)>::value_type;
+        return GpuView<T>(storage.data(), storage.size());
+    };
+
+    return GpuProblemView(::Opm::gpuistl::make_view(buf.materialLawManager()),
+                          toView(buf.porosityStorage()),
+                          toView(buf.rockCompressibilityStorage()),
+                          toView(buf.rockReferencePressureStorage()),
+                          toView(buf.maxOilSaturationStorage()),
+                          toView(buf.maxOilVaporizationFactorStorage()),
+                          toView(buf.maxGasDissolutionFactorStorage()),
+                          ::Opm::gpuistl::make_view(buf.thermalLawManager()),
+                          toView(buf.rockFractionStorage()),
+                          toView(buf.pvtRegionIndexStorage()));
+}
+
+} // namespace Opm::gpuistl
+
+#endif // OPM_GPU_FLOW_PROBLEM_HPP
diff --git a/opm/simulators/flow/NewTranFluxModule.hpp b/opm/simulators/flow/NewTranFluxModule.hpp
index 83811e38cf9..1e2b57e0896 100644
--- a/opm/simulators/flow/NewTranFluxModule.hpp
+++ b/opm/simulators/flow/NewTranFluxModule.hpp
@@ -36,6 +36,7 @@
 
 #include <opm/common/ErrorMacros.hpp>
 #include <opm/common/OpmLog/OpmLog.hpp>
+#include <opm/common/utility/gpuDecorators.hpp>
 
 #include <opm/input/eclipse/EclipseState/Grid/FaceDir.hpp>
 
@@ -48,7 +49,6 @@
 #include <opm/models/blackoil/blackoilmoduleparams.hh>
 #include <opm/models/blackoil/blackoilconvectivemixingmodule.hh>
 
-#include <opm/common/utility/gpuDecorators.hpp>
 
 #include <array>
 
@@ -310,7 +310,7 @@ class NewTranExtensiveQuantities
         }
     }
 
-    template<class EvalType>
+    template<class EvalType, class ModuleParamsT = ModuleParams>
     OPM_HOST_DEVICE static void calculatePhasePressureDiff_(short& upIdx,
                                             short& dnIdx,
                                             EvalType& pressureDifference,
@@ -325,7 +325,7 @@ class NewTranExtensiveQuantities
                                             const unsigned globalIndexEx,
                                             const Scalar distZg,
                                             const Scalar thpres,
-                                            const ModuleParams& moduleParams)
+                                            const ModuleParamsT& moduleParams)
     {
 
         // check shortcut: if the mobility of the phase is zero in the interior as
diff --git a/opm/simulators/flow/SimplifiedFlowProblemGPU.hpp b/opm/simulators/flow/SimplifiedFlowProblemGPU.hpp
new file mode 100644
index 00000000000..2efc244f2d2
--- /dev/null
+++ b/opm/simulators/flow/SimplifiedFlowProblemGPU.hpp
@@ -0,0 +1,110 @@
+/*
+  Copyright 2026 Equinor ASA
+  This file is part of the Open Porous Media project (OPM).
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef OPM_SIMPLIFIED_FLOW_PROBLEM_GPU_HPP
+#define OPM_SIMPLIFIED_FLOW_PROBLEM_GPU_HPP
+
+#include <opm/common/utility/gpuistl_if_available.hpp>
+#include <opm/common/utility/VectorWithDefaultAllocator.hpp>
+
+namespace Opm {
+
+template<class Scalar, template <class> class Storage = Opm::VectorWithDefaultAllocator>
+class SimplifiedFlowProblemGPU
+{
+public:
+    using ModuleParams = BlackoilModuleParams<ConvectiveMixingModuleParam<Scalar, Storage>>;
+
+    SimplifiedFlowProblemGPU() = default;
+
+    SimplifiedFlowProblemGPU(Storage<Scalar> alpha0,
+                             Storage<Scalar> alpha1,
+                             Storage<Scalar> alpha2,
+                             ModuleParams moduleParams)
+        : alpha0_(alpha0)
+        , alpha1_(alpha1)
+        , alpha2_(alpha2)
+        , moduleParams_(moduleParams)
+    {}
+
+    OPM_HOST_DEVICE Scalar getAlpha(unsigned globalIndex, unsigned boundaryFaceIndex) const
+    {
+        assert(boundaryFaceIndex < 3 && "SOMETHING IS WRONG WITH BOUNDARYFACEINDEX");
+        if (boundaryFaceIndex == 0) {
+            return alpha0_[globalIndex];
+        } else if (boundaryFaceIndex == 1) {
+            return alpha1_[globalIndex];
+        } else if (boundaryFaceIndex == 2) {
+            return alpha2_[globalIndex];
+        } else {
+            OPM_THROW(std::logic_error, "Invalid boundary face index: " + std::to_string(boundaryFaceIndex));
+        }
+    }
+
+    OPM_HOST_DEVICE const ModuleParams& moduleParams() const { return moduleParams_; }
+    OPM_HOST_DEVICE ModuleParams& moduleParams() { return moduleParams_; }
+
+    Storage<Scalar>& alpha0() {
+        return alpha0_;
+    }
+
+    Storage<Scalar>& alpha1() {
+        return alpha1_;
+    }
+
+    Storage<Scalar>& alpha2() {
+        return alpha2_;
+    }
+
+private:
+    Storage<Scalar> alpha0_;
+    Storage<Scalar> alpha1_;
+    Storage<Scalar> alpha2_;
+    ModuleParams moduleParams_;
+};
+
+namespace gpuistl {
+
+    template<class Scalar>
+    SimplifiedFlowProblemGPU<Scalar, GpuBuffer>
+    copy_to_gpu(SimplifiedFlowProblemGPU<Scalar, Opm::VectorWithDefaultAllocator>& cpuProblem)
+    {
+        using ModuleParams = BlackoilModuleParams<ConvectiveMixingModuleParam<Scalar, GpuBuffer>>;
+        return SimplifiedFlowProblemGPU<Scalar, GpuBuffer>(
+            GpuBuffer<Scalar>(cpuProblem.alpha0()),
+            GpuBuffer<Scalar>(cpuProblem.alpha1()),
+            GpuBuffer<Scalar>(cpuProblem.alpha2()),
+            ModuleParams { copy_to_gpu(cpuProblem.moduleParams().convectiveMixingModuleParam) }
+        );
+    }
+
+    template<class Scalar>
+    SimplifiedFlowProblemGPU<Scalar, GpuView>
+    make_view(SimplifiedFlowProblemGPU<Scalar, GpuBuffer>& buffer)
+    {
+        using ModuleParams = BlackoilModuleParams<ConvectiveMixingModuleParam<Scalar, GpuView>>;
+        return SimplifiedFlowProblemGPU<Scalar, GpuView>(
+            make_view(buffer.alpha0()),
+            make_view(buffer.alpha1()),
+            make_view(buffer.alpha2()),
+            ModuleParams { make_view(buffer.moduleParams().convectiveMixingModuleParam) }
+        );
+    }
+
+} // namespace gpuistl
+
+} // namespace Opm
+
+#endif // OPM_SIMPLIFIED_FLOW_PROBLEM_GPU_HPP
diff --git a/opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp b/opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp
new file mode 100644
index 00000000000..a74438a0fa0
--- /dev/null
+++ b/opm/simulators/flow/SimplifiedGpuBlackOilModel.hpp
@@ -0,0 +1,237 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 2 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+
+  Consult the COPYING file in the top-level source directory of this
+  module for the precise wording of the license and the list of
+  copyright holders.
+*/
+/*!
+ * \file
+ *
+ * \copydoc Opm::FIBlackOilModel
+ */
+#ifndef SIMPLIFIED_BLACK_OIL_MODEL_HPP
+#define SIMPLIFIED_BLACK_OIL_MODEL_HPP
+
+#include <opm/models/blackoil/blackoilmodel.hh>
+#include <opm/models/utils/propertysystem.hh>
+
+#include <opm/common/ErrorMacros.hpp>
+#include <opm/models/utils/propertysystem.hh>
+
+#include <opm/grid/CpGrid.hpp>
+#include <opm/grid/utility/ElementChunks.hpp>
+
+#include <opm/models/blackoil/blackoilconvectivemixingmodule.hh>
+#include <opm/models/blackoil/blackoilmoduleparams.hh>
+#include <opm/models/parallel/threadmanager.hpp>
+#include <opm/simulators/utils/DeferredLoggingErrorHelpers.hpp>
+
+#include <opm/material/fluidmatrixinteractions/EclMultiplexerMaterialParams.hpp>
+
+#include <cstddef>
+#include <stdexcept>
+#include <type_traits>
+
+#ifdef _OPENMP
+#include <omp.h>
+#endif
+
+/*
+    This file implements a simplified version of the FIBlackOilModel
+    which can be used in a GPU environment.
+    This is developed while parallelizing the tpfa matrix assembly, so
+    only functionality needed there is implemented.
+    To start with this means just being able to access intensiveQuantities.
+*/
+
+namespace Opm
+{
+
+template <typename TypeTag, template <class> class Storage = Opm::VectorWithDefaultAllocator>
+class SimplifiedGpuFIBlackOilModel
+{
+public:
+    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
+    using TypeTagPublic = TypeTag;
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    SimplifiedGpuFIBlackOilModel(unsigned int nCells)
+        : cachedIntensiveQuantities0_(nCells)
+    {
+    }
+
+    // TODO: copy for now, but should be move!
+    SimplifiedGpuFIBlackOilModel(
+        const Storage<BlackOilIntensiveQuantities<TypeTag>>& cachedIntensiveQuantities0,
+        const Storage<BlackOilIntensiveQuantities<TypeTag>>& cachedIntensiveQuantities1)
+        : cachedIntensiveQuantities0_(cachedIntensiveQuantities0)
+        , cachedIntensiveQuantities1_(cachedIntensiveQuantities1)
+    {
+    }
+
+    SimplifiedGpuFIBlackOilModel() = default;
+
+    void invalidateAndUpdateIntensiveQuantities(unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "invalidateAndUpdateIntensiveQuantities should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    void invalidateAndUpdateIntensiveQuantitiesOverlap(unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "invalidateAndUpdateIntensiveQuantitiesOverlap should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    template <class GridSubDomain>
+    void
+    invalidateAndUpdateIntensiveQuantities(unsigned /* timeIdx */,
+                                           const GridSubDomain& /* gridSubDomain */) const
+    {
+        OPM_THROW(std::logic_error, "invalidateAndUpdateIntensiveQuantities with GridSubDomain should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    void updateFailed()
+    {
+        OPM_THROW(std::logic_error, "updateFailed should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    OPM_HOST_DEVICE const auto& intensiveQuantities(unsigned int globalIdx,
+                                                    unsigned int timeIdx) const
+    {
+        assert(timeIdx == 0
+               || timeIdx
+                   == 1); // TODO: do not use assert for this because it can be run in GPU kernel...
+        if (timeIdx == 0) {
+            return cachedIntensiveQuantities0_[globalIdx];
+        } else {
+            return cachedIntensiveQuantities1_[globalIdx];
+        }
+    }
+
+protected:
+    void updateCachedIntQuants(const unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "updateCachedIntQuants should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    template <class EMDArg>
+    void updateCachedIntQuants1(const unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "updateCachedIntQuants1 should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    template <class... Args>
+    void updateCachedIntQuantsLoop(const unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "updateCachedIntQuantsLoop should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+    template <class... Args>
+    void updateSingleCachedIntQuantUnchecked(const unsigned /* globalIdx */,
+                                             const unsigned /* timeIdx */) const
+    {
+        OPM_THROW(std::logic_error, "updateSingleCachedIntQuantUnchecked should not be called in SimplifiedGpuFIBlackOilModel");
+    }
+
+public:
+    // assumes --enable-storage-cache=false so that we need not worry about updating cpu-caches from
+    // gpu kernels
+    Storage<BlackOilIntensiveQuantities<TypeTag>> cachedIntensiveQuantities0_;
+    Storage<BlackOilIntensiveQuantities<TypeTag>> cachedIntensiveQuantities1_;
+};
+
+namespace gpuistl
+{
+    // For now we make a copy of the simplified CPU model because we need to set the fluid system
+    // pointer without breaking copy semantics
+    template <class TypeTag, typename GpuFluidSystem>
+    auto copy_to_gpu(const SimplifiedGpuFIBlackOilModel<TypeTag>& cpuModel, GpuFluidSystem* fsys)
+    {
+        using Scalar = typename SimplifiedGpuFIBlackOilModel<TypeTag>::Scalar;
+        // In this copy_to_gpu we need to take care of two things:
+        // 1) Copy the cachedIntensiveQuantities_ to GPU (go from vector to GpuBuffer to allocate
+        // things on GPU) 2) Ensure that the FluidSystem pointer inside each IntensiveQuantities
+        // points to a GPU FluidSystem
+        //    The pointer should be set before we move the entire thing to the GPU.
+
+        // set pointers
+        using CorrectTypeTagView =
+            typename ::Opm::Properties::TTag::to_gpu_type_t<TypeTag, GpuView>;
+        using CorrectBOIQ = BlackOilIntensiveQuantities<CorrectTypeTagView>;
+        using SimplifiedGpuBufferModel
+            = SimplifiedGpuFIBlackOilModel<CorrectTypeTagView, GpuBuffer>;
+
+        std::size_t nCells0 = cpuModel.cachedIntensiveQuantities0_.size();
+        std::size_t nCells1 = cpuModel.cachedIntensiveQuantities1_.size();
+
+        // CorrectBOIQ is not default-constructible (non-static FluidSystem requires a pointer at
+        // construction time). To enable parallel fill, we create a prototype from the first element
+        // and use it to pre-size the vector with valid objects, then overwrite in parallel.
+        // Assumption: all cells share the same fsys pointer, so the prototype object is a valid
+        // stand-in until it is overwritten.
+        std::vector<CorrectBOIQ> cpuIntQuantsWithGpuPtr0;
+        if (nCells0 > 0) {
+            CorrectBOIQ proto0 =
+                cpuModel.cachedIntensiveQuantities0_[0].template withOtherFluidSystem<CorrectTypeTagView>(fsys);
+            cpuIntQuantsWithGpuPtr0.resize(nCells0, proto0);
+
+
+#ifdef _OPENMP
+#pragma omp parallel for schedule(static)
+#endif
+            for (std::size_t i = 1; i < nCells0; ++i) {
+                cpuIntQuantsWithGpuPtr0[i] =
+                    cpuModel.cachedIntensiveQuantities0_[i].template withOtherFluidSystem<CorrectTypeTagView>(fsys);
+            }
+        }
+
+        std::vector<CorrectBOIQ> cpuIntQuantsWithGpuPtr1;
+        if (nCells1 > 0) {
+            CorrectBOIQ proto1 =
+                cpuModel.cachedIntensiveQuantities1_[0].template withOtherFluidSystem<CorrectTypeTagView>(fsys);
+            cpuIntQuantsWithGpuPtr1.resize(nCells1, proto1);
+
+#ifdef _OPENMP
+#pragma omp parallel for schedule(static)
+#endif
+            for (std::size_t i = 1; i < nCells1; ++i) {
+                cpuIntQuantsWithGpuPtr1[i] =
+                    cpuModel.cachedIntensiveQuantities1_[i].template withOtherFluidSystem<CorrectTypeTagView>(fsys);
+            }
+        }
+
+        GpuBuffer<CorrectBOIQ> gpuBuf0(cpuIntQuantsWithGpuPtr0);
+        GpuBuffer<CorrectBOIQ> gpuBuf1(cpuIntQuantsWithGpuPtr1);
+
+        // create new blackoil model providing a gpubuffer allocated version of the intQuants
+        auto result = SimplifiedGpuBufferModel(std::move(gpuBuf0), std::move(gpuBuf1));
+
+        return result;
+    }
+
+    template <typename LocalTypeTag>
+    auto make_view(SimplifiedGpuFIBlackOilModel<LocalTypeTag, GpuBuffer>& gpuSimplifiedGpuFIBlackOilModel)
+    {
+        return SimplifiedGpuFIBlackOilModel<LocalTypeTag, gpuistl::GpuView>(
+            make_view(gpuSimplifiedGpuFIBlackOilModel.cachedIntensiveQuantities0_),
+            make_view(gpuSimplifiedGpuFIBlackOilModel.cachedIntensiveQuantities1_));
+    }
+} // namespace gpuistl
+
+} // namespace Opm
+
+#endif // SIMPLIFIED_BLACK_OIL_MODEL_HPP
diff --git a/opm/simulators/flow/Transmissibility.hpp b/opm/simulators/flow/Transmissibility.hpp
index e5e18c11a3e..9bc3d6c62bc 100644
--- a/opm/simulators/flow/Transmissibility.hpp
+++ b/opm/simulators/flow/Transmissibility.hpp
@@ -102,6 +102,8 @@ class Transmissibility {
 
     Scalar thermalHalfTransBoundary(unsigned insideElemIdx, unsigned boundaryFaceIdx) const;
 
+    const std::map<std::pair<unsigned, unsigned>, Scalar>& getThermalHalfTransBoundary() const;
+
     /*!
      * \brief Return the diffusivity for the intersection between two elements.
      */
diff --git a/opm/simulators/flow/Transmissibility_impl.hpp b/opm/simulators/flow/Transmissibility_impl.hpp
index 4b78798723c..c268d2eed91 100644
--- a/opm/simulators/flow/Transmissibility_impl.hpp
+++ b/opm/simulators/flow/Transmissibility_impl.hpp
@@ -145,6 +145,13 @@ thermalHalfTransBoundary(unsigned insideElemIdx, unsigned boundaryFaceIdx) const
     return thermalHalfTransBoundary_.at(std::make_pair(insideElemIdx, boundaryFaceIdx));
 }
 
+template<class Grid, class GridView, class ElementMapper, class CartesianIndexMapper, class Scalar>
+const std::map<std::pair<unsigned, unsigned>, Scalar>& Transmissibility<Grid,GridView,ElementMapper,CartesianIndexMapper,Scalar>::
+getThermalHalfTransBoundary() const
+{
+    return thermalHalfTransBoundary_;
+}
+
 template<class Grid, class GridView, class ElementMapper, class CartesianIndexMapper, class Scalar>
 Scalar Transmissibility<Grid,GridView,ElementMapper,CartesianIndexMapper,Scalar>::
 diffusivity(unsigned elemIdx1, unsigned elemIdx2) const
diff --git a/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.cu b/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.cu
new file mode 100644
index 00000000000..994c4f2f5f5
--- /dev/null
+++ b/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.cu
@@ -0,0 +1,384 @@
+/*
+  Copyright 2026 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <config.h>
+
+// Tricks for older versions of ROCm that do not support alugrid or dune-fem
+// (mirrors test_blackoilintensivequantities_gpu.cu).
+#ifdef HAVE_DUNE_ALUGRID
+#undef HAVE_DUNE_ALUGRID
+#endif
+#define HAVE_DUNE_ALUGRID 0
+#ifdef HAVE_DUNE_FEM
+#undef HAVE_DUNE_FEM
+#endif
+#define HAVE_DUNE_FEM 0
+
+#include <cuda_runtime.h>
+
+#include <opm/common/utility/gpuDecorators.hpp>
+#include <opm/material/common/ResetLocale.hpp>
+#include <opm/material/fluidmatrixinteractions/EclDefaultMaterial.hpp>
+
+#include <opm/material/fluidmatrixinteractions/EclMaterialLawTwoPhaseTypes.hpp>
+#include <opm/material/fluidmatrixinteractions/EclTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterialParams.hpp>
+
+#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
+#include <opm/material/fluidsystems/BlackOilFluidSystemNonStatic.hpp>
+
+#include <opm/models/blackoil/blackoilintensivequantities.hh>
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
+#include <opm/models/blackoil/blackoilmodel.hh>
+#include <opm/models/blackoil/blackoilprimaryvariables.hh>
+#include <opm/models/discretization/common/nullfvbaseelementcontext.hh>
+#include <opm/models/discretization/common/fvbaseprimaryvariables.hh>
+#include <opm/models/discretization/common/tpfalinearizer.hh>
+
+#include <opm/simulators/flow/FlowProblemBlackoil.hpp>
+#include <opm/simulators/flow/FlowProblemBlackoilProperties.hpp>
+#include <opm/material/fluidmatrixinteractions/GpuEclMaterialLawManager.hpp>
+#include <opm/material/thermal/GpuEclThermalLawManager.hpp>
+#include <opm/simulators/flow/GpuFlowProblem.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuBuffer.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuView.hpp>
+#include <opm/simulators/linalg/gpuistl/detail/gpu_safe_call.hpp>
+
+#include <opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.hpp>
+
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuFlowGasWaterEnergyTypeTags.hpp>
+
+#include <opm/common/OpmLog/OpmLog.hpp>
+
+#include <chrono>
+#include <format>
+#include <optional>
+#include <vector>
+
+namespace {
+
+// Small helper to take a std::chrono::steady_clock timestamp.
+inline auto dispatcherNow()
+{
+    return std::chrono::steady_clock::now();
+}
+
+inline double dispatcherElapsedMs(const std::chrono::steady_clock::time_point& start,
+                                  const std::chrono::steady_clock::time_point& end)
+{
+    return std::chrono::duration<double, std::micro>(end - start).count()/ 1000.0;
+}
+
+} // namespace
+
+namespace Opm::gpuistl {
+
+namespace {
+
+using DispatcherCpuTag = Opm::Properties::TTag::FlowGasWaterEnergyProblem;
+using DispatcherGpuTag = Opm::Properties::TTag::FlowGasWaterEnergyDummyProblemGPU;
+
+using DispatcherScalar = Opm::GetPropType<DispatcherCpuTag, Opm::Properties::Scalar>;
+
+using DispatcherCpuFluidSystem = Opm::BlackOilFluidSystem<DispatcherScalar>;
+using DispatcherFluidSystemView
+    = Opm::BlackOilFluidSystemNonStatic<DispatcherScalar,
+                                        Opm::BlackOilDefaultFluidSystemIndices,
+                                        Opm::gpuistl::GpuView>;
+
+using DispatcherGpuPrimaryVariables
+    = Opm::BlackOilPrimaryVariables<DispatcherGpuTag, Opm::gpuistl::MiniVector>;
+using DispatcherGpuIntensiveQuantities = Opm::BlackOilIntensiveQuantities<DispatcherGpuTag>;
+
+using DispatcherCpuMaterialLawManager =
+    typename Opm::GetProp<DispatcherCpuTag, Opm::Properties::MaterialLaw>::EclMaterialLawManager;
+using DispatcherTraits = typename DispatcherCpuMaterialLawManager::MaterialLaw::Traits;
+using DispatcherTwoPhaseTraits =
+    Opm::TwoPhaseMaterialTraits<DispatcherScalar,
+                                DispatcherTraits::wettingPhaseIdx,
+                                DispatcherTraits::nonWettingPhaseIdx>;
+using DispatcherGpuPiecewiseLinearParamsBuf =
+    Opm::PiecewiseLinearTwoPhaseMaterialParams<DispatcherTwoPhaseTraits,
+                                               Opm::gpuistl::GpuView<const DispatcherScalar>>;
+using DispatcherGpuPiecewiseLinearLawBuf =
+    Opm::PiecewiseLinearTwoPhaseMaterial<DispatcherTwoPhaseTraits,
+                                         DispatcherGpuPiecewiseLinearParamsBuf>;
+using DispatcherGpuMaterialLawParamsBuf =
+    Opm::EclTwoPhaseMaterialParams<DispatcherTraits,
+                                   DispatcherGpuPiecewiseLinearParamsBuf,
+                                   DispatcherGpuPiecewiseLinearParamsBuf,
+                                   DispatcherGpuPiecewiseLinearParamsBuf,
+                                   Opm::gpuistl::ValueAsPointer>;
+using DispatcherGpuMaterialLawBuf =
+    Opm::EclTwoPhaseMaterial<DispatcherTraits,
+                             DispatcherGpuPiecewiseLinearLawBuf,
+                             DispatcherGpuPiecewiseLinearLawBuf,
+                             DispatcherGpuPiecewiseLinearLawBuf,
+                             DispatcherGpuMaterialLawParamsBuf>;
+using DispatcherGpuManagerBuf =
+    Opm::EclMaterialLaw::GpuManager<DispatcherTraits,
+                                    DispatcherGpuPiecewiseLinearLawBuf,
+                                    DispatcherGpuPiecewiseLinearLawBuf,
+                                    Opm::gpuistl::GpuBuffer,
+                                    DispatcherGpuMaterialLawBuf>;
+using DispatcherGpuThermalManagerBuf =
+    Opm::EclThermalLaw::GpuManager<DispatcherScalar,
+                                   DispatcherFluidSystemView,
+                                   Opm::gpuistl::GpuBuffer,
+                                   Opm::gpuistl::GpuView>;
+using DispatcherGpuFlowProblemBuf =
+    Opm::GpuFlowProblem<DispatcherScalar,
+                        DispatcherGpuManagerBuf,
+                        Opm::gpuistl::GpuBuffer,
+                        DispatcherGpuThermalManagerBuf>;
+using DispatcherGpuFlowProblemView =
+    decltype(Opm::gpuistl::make_view(std::declval<DispatcherGpuFlowProblemBuf&>()));
+
+template <class GpuProblem, class PrimaryVariablesT, class IntensiveQuantitiesT>
+__global__ void
+dispatcherUpdateAllCellsKernel(GpuProblem problem,
+                               Opm::gpuistl::GpuView<const PrimaryVariablesT> primaryVariables,
+                               Opm::gpuistl::GpuView<IntensiveQuantitiesT> outIntensiveQuantities,
+                               std::size_t numCells)
+{
+    const std::size_t i = static_cast<std::size_t>(blockIdx.x) * blockDim.x + threadIdx.x;
+    if (i >= numCells) {
+        return;
+    }
+    IntensiveQuantitiesT iq = outIntensiveQuantities[i];
+    iq.updateSaturations(primaryVariables[i], 0, Opm::LinearizationType{});
+    iq.update(problem, primaryVariables[i], static_cast<unsigned>(i), 0);
+    iq.updateEnergyQuantities_(problem, static_cast<unsigned>(i), 0u);
+    outIntensiveQuantities[i] = iq;
+}
+
+} // namespace
+
+// =============================================================================
+// Impl
+// =============================================================================
+template <class CpuTypeTag>
+struct GpuBlackoilIntensiveQuantitiesDispatcher<CpuTypeTag>::Impl {
+    bool initialized = false;
+    std::unique_ptr<DispatcherGpuFlowProblemBuf> problemBuf;
+    DispatcherGpuFlowProblemView problemView{};
+    DispatcherFluidSystemView* managedFluidSystemView = nullptr;
+    std::optional<DispatcherGpuIntensiveQuantities> prototype;
+    std::size_t callCount = 0;
+
+    // Cumulative per-stage timings (milliseconds, host-side).
+    double totalConvertMs = 0.0;
+    double totalH2DMs = 0.0;
+    double totalKernelMs = 0.0;
+    double totalD2HMs = 0.0;
+    double totalOverlayMs = 0.0;
+    double totalDofsProcessed = 0.0;
+
+    ~Impl()
+    {
+        if (managedFluidSystemView != nullptr) {
+            managedFluidSystemView->~DispatcherFluidSystemView();
+            (void)cudaFree(managedFluidSystemView);
+            managedFluidSystemView = nullptr;
+        }
+        if (callCount > 0u) {
+            const double totalMs =
+                totalConvertMs + totalH2DMs + totalKernelMs + totalD2HMs + totalOverlayMs;
+            const double avgConvertMs  = totalConvertMs  / static_cast<double>(callCount);
+            const double avgH2DMs      = totalH2DMs      / static_cast<double>(callCount);
+            const double avgKernelMs   = totalKernelMs   / static_cast<double>(callCount);
+            const double avgD2HMs      = totalD2HMs      / static_cast<double>(callCount);
+            const double avgOverlayMs  = totalOverlayMs  / static_cast<double>(callCount);
+            const double avgTotalMs    = totalMs          / static_cast<double>(callCount);
+            const double avgDofs       = totalDofsProcessed / static_cast<double>(callCount);
+            Opm::OpmLog::info(std::format(
+                "[GpuBlackoilIntensiveQuantitiesDispatcher] aggregate over {} call(s),"
+                " {} dof-updates:\n"
+                "  totals  : convert={:.3f}ms h2d={:.3f}ms kernel={:.3f}ms"
+                " d2h={:.3f}ms overlay={:.3f}ms total={:.3f}ms\n"
+                "  per-call: convert={:.3f}ms h2d={:.3f}ms kernel={:.3f}ms"
+                " d2h={:.3f}ms overlay={:.3f}ms total={:.3f}ms avg_dofs={:.1f}",
+                callCount,
+                static_cast<std::size_t>(totalDofsProcessed),
+                totalConvertMs, totalH2DMs, totalKernelMs, totalD2HMs, totalOverlayMs, totalMs,
+                avgConvertMs,   avgH2DMs,   avgKernelMs,   avgD2HMs,   avgOverlayMs,   avgTotalMs,
+                avgDofs));
+        }
+    }
+};
+
+template <class CpuTypeTag>
+GpuBlackoilIntensiveQuantitiesDispatcher<CpuTypeTag>::GpuBlackoilIntensiveQuantitiesDispatcher()
+    : impl_(std::make_unique<Impl>())
+{
+}
+
+template <class CpuTypeTag>
+GpuBlackoilIntensiveQuantitiesDispatcher<CpuTypeTag>::~GpuBlackoilIntensiveQuantitiesDispatcher()
+    = default;
+
+template <class CpuTypeTag>
+void GpuBlackoilIntensiveQuantitiesDispatcher<CpuTypeTag>::update(
+    const Problem& cpuProblem,
+    const PrimaryVariables* const* cpuPriVars,
+    IntensiveQuantities* const* outIQ,
+    std::size_t numDof)
+{
+    if (numDof == 0u) {
+        return;
+    }
+
+    if (!impl_->initialized) {
+        // Build the GPU FlowProblem from the CPU FlowProblem (one-time setup).
+        impl_->problemBuf = std::make_unique<DispatcherGpuFlowProblemBuf>(cpuProblem);
+        impl_->problemView = Opm::gpuistl::make_view(*impl_->problemBuf);
+
+        // Place the FluidSystemView in unified memory so its device pointer
+        // dereferences are valid both on host and device (mirrors the test).
+        auto& dynamicCpuFluidSystem = DispatcherCpuFluidSystem::getNonStaticInstance();
+        // The fluid-system buffer is owning device memory; leak it intentionally
+        // for the lifetime of the process via a function-local static.
+        using FsBufferType = decltype(Opm::gpuistl::copy_to_gpu(dynamicCpuFluidSystem));
+        static FsBufferType s_fsBuffer = Opm::gpuistl::copy_to_gpu(dynamicCpuFluidSystem);
+        auto fsView = Opm::gpuistl::make_view(s_fsBuffer);
+
+        DispatcherFluidSystemView* managed = nullptr;
+        OPM_GPU_SAFE_CALL(cudaMallocManaged(&managed, sizeof(DispatcherFluidSystemView)));
+        new (managed) DispatcherFluidSystemView(fsView);
+        impl_->managedFluidSystemView = managed;
+
+        // Build a default IntensiveQuantities prototype for the GPU side.
+        Opm::BlackOilIntensiveQuantities<DispatcherCpuTag> cpuPrototype;
+        impl_->prototype = cpuPrototype.template withOtherFluidSystem<DispatcherGpuTag>(
+            impl_->managedFluidSystemView);
+
+        impl_->initialized = true;
+        Opm::OpmLog::info(std::format(
+            "[GpuBlackoilIntensiveQuantitiesDispatcher] initialized for {} cells",
+            cpuProblem.model().numGridDof()));
+    }
+
+    // -------------------------------------------------------------------
+    // 1. Convert CPU primary variables to the dispatcher's GPU primary
+    //    variables (host-side).
+    // -------------------------------------------------------------------
+    const auto t0 = dispatcherNow();
+    std::vector<DispatcherGpuPrimaryVariables> hostPriVars;
+    hostPriVars.reserve(numDof);
+    for (std::size_t i = 0; i < numDof; ++i) {
+        // The BlackOilPrimaryVariables converting copy ctor handles the
+        // TypeTag/storage difference.
+        hostPriVars.emplace_back(*cpuPriVars[i]);
+    }
+    std::vector<DispatcherGpuIntensiveQuantities> hostIQ(numDof, *impl_->prototype);
+    const auto t1 = dispatcherNow();
+
+    // -------------------------------------------------------------------
+    // 2. Upload host buffers to the device (host-to-device copies are
+    //    embedded in the GpuBuffer ctors).
+    // -------------------------------------------------------------------
+    Opm::gpuistl::GpuBuffer<DispatcherGpuPrimaryVariables> primaryVariablesBuffer(hostPriVars);
+    Opm::gpuistl::GpuBuffer<DispatcherGpuIntensiveQuantities> intensiveQuantitiesBuffer(hostIQ);
+    OPM_GPU_SAFE_CALL(cudaDeviceSynchronize());
+    const auto t2 = dispatcherNow();
+
+    // -------------------------------------------------------------------
+    // 3. Launch the per-cell update kernel.
+    // -------------------------------------------------------------------
+    const unsigned blockSize = 64u;
+    const unsigned gridSize = static_cast<unsigned>((numDof + blockSize - 1u) / blockSize);
+
+    dispatcherUpdateAllCellsKernel<<<gridSize, blockSize>>>(
+        impl_->problemView,
+        Opm::gpuistl::GpuView<const DispatcherGpuPrimaryVariables>(
+            primaryVariablesBuffer.data(), primaryVariablesBuffer.size()),
+        Opm::gpuistl::GpuView<DispatcherGpuIntensiveQuantities>(
+            intensiveQuantitiesBuffer.data(), intensiveQuantitiesBuffer.size()),
+        numDof);
+    OPM_GPU_SAFE_CALL(cudaDeviceSynchronize());
+    OPM_GPU_SAFE_CALL(cudaGetLastError());
+    const auto t3 = dispatcherNow();
+
+    // -------------------------------------------------------------------
+    // 4. Read the GPU IntensiveQuantities back to host memory.
+    // -------------------------------------------------------------------
+    OPM_GPU_SAFE_CALL(cudaMemcpy(hostIQ.data(),
+                                 intensiveQuantitiesBuffer.data(),
+                                 numDof * sizeof(DispatcherGpuIntensiveQuantities),
+                                 cudaMemcpyDeviceToHost));
+    const auto t4 = dispatcherNow();
+
+    // -------------------------------------------------------------------
+    // 5. Field-by-field overlay onto the caller's CPU IntensiveQuantities.
+    //    The caller is expected to have run the CPU update first to
+    //    populate any fields the dispatcher does not overwrite (e.g.
+    //    \c mobility_, which the GPU relperm path currently leaves at 0).
+    // -------------------------------------------------------------------
+    for (std::size_t i = 0; i < numDof; ++i) {
+        outIQ[i]->overlayBlackOilFieldsFrom(hostIQ[i]);
+    }
+    const auto t5 = dispatcherNow();
+
+    // -------------------------------------------------------------------
+    // Per-call timings.
+    // -------------------------------------------------------------------
+    const double convertMs = dispatcherElapsedMs(t0, t1);
+    const double h2dMs     = dispatcherElapsedMs(t1, t2);
+    const double kernelMs  = dispatcherElapsedMs(t2, t3);
+    const double d2hMs     = dispatcherElapsedMs(t3, t4);
+    const double overlayMs = dispatcherElapsedMs(t4, t5);
+
+    impl_->totalConvertMs    += convertMs;
+    impl_->totalH2DMs        += h2dMs;
+    impl_->totalKernelMs     += kernelMs;
+    impl_->totalD2HMs        += d2hMs;
+    impl_->totalOverlayMs    += overlayMs;
+    impl_->totalDofsProcessed += static_cast<double>(numDof);
+
+    Opm::OpmLog::info(std::format(
+        "[GpuBlackoilIntensiveQuantitiesDispatcher] call={} dofs={}"
+        " convert={:.3f}ms h2d={:.3f}ms kernel={:.3f}ms d2h={:.3f}ms overlay={:.3f}ms total={:.3f}ms",
+        impl_->callCount, numDof,
+        convertMs, h2dMs, kernelMs, d2hMs, overlayMs,
+        convertMs + h2dMs + kernelMs + d2hMs + overlayMs));
+
+    ++impl_->callCount;
+}
+
+// =============================================================================
+// Explicit instantiation for the user-facing CO2STORE simulation TypeTag,
+// namely \c FlowGasWaterEnergyProblem (used by the Flow simulator binary
+// when a CO2STORE deck with WATER+GAS+THERMAL is loaded). The GPU-specific
+// property bindings live in \c GpuFlowGasWaterEnergyTypeTags.hpp.
+// =============================================================================
+template class GpuBlackoilIntensiveQuantitiesDispatcher<
+    Opm::Properties::TTag::FlowGasWaterEnergyProblem>;
+
+// =============================================================================
+// Explicit instantiation for the GPU-assembly simulation TypeTag
+// \c FlowGasWaterEnergyProblemGPU (used by the flow_gpu binary that runs both
+// matrix assembly and intensive-quantities computation on the GPU).
+// This TypeTag inherits all physics from \c FlowGasWaterEnergyProblem and
+// therefore has the same CPU-side Problem / PrimaryVariables /
+// IntensiveQuantities types; the GPU kernel dispatch internally still uses
+// the \c FlowGasWaterEnergyKernelBaseGPU / \c FlowGasWaterEnergyDummyProblemGPU
+// chain.
+// =============================================================================
+template class GpuBlackoilIntensiveQuantitiesDispatcher<
+    Opm::Properties::TTag::FlowGasWaterEnergyProblemGPU>;
+
+} // namespace Opm::gpuistl
diff --git a/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.hpp b/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.hpp
new file mode 100644
index 00000000000..d744810ace3
--- /dev/null
+++ b/opm/simulators/linalg/gpuistl/GpuBlackoilIntensiveQuantitiesDispatcher.hpp
@@ -0,0 +1,117 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  Copyright 2026 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef OPM_GPU_BLACKOIL_INTENSIVE_QUANTITIES_DISPATCHER_HPP
+#define OPM_GPU_BLACKOIL_INTENSIVE_QUANTITIES_DISPATCHER_HPP
+
+#if HAVE_CUDA
+
+#include <opm/models/utils/propertysystem.hh>
+
+#include <cstddef>
+#include <memory>
+
+namespace Opm::Properties::TTag {
+    struct FlowGasWaterEnergyProblem;
+    struct FlowGasWaterEnergyProblemGPU;
+}
+
+namespace Opm::gpuistl {
+
+/// Compile-time predicate: does this CPU \c TypeTag describe the specific
+/// CO2STORE configuration (FlowGasWaterEnergyProblem) that the GPU
+/// intensive-quantities dispatcher currently supports? Restricted to a
+/// single TypeTag so that explicit instantiations of the dispatcher
+/// remain manageable for the experimental prototype.
+template <class CpuTypeTag>
+struct GpuBlackoilIntensiveQuantitiesDispatcherSupport {
+    static constexpr bool value = false;
+};
+
+template <>
+struct GpuBlackoilIntensiveQuantitiesDispatcherSupport<
+    Opm::Properties::TTag::FlowGasWaterEnergyProblem> {
+    static constexpr bool value = true;
+};
+
+/// Enable the dispatcher for the GPU-assembly simulation TypeTag
+/// (\c FlowGasWaterEnergyProblemGPU, declared in FlowGasWaterEnergyTypeTag.hpp).
+/// This tag inherits all physics from \c FlowGasWaterEnergyProblem and adds
+/// GPU-specific assembly properties in \c flow_gpu.cu.
+template <>
+struct GpuBlackoilIntensiveQuantitiesDispatcherSupport<
+    Opm::Properties::TTag::FlowGasWaterEnergyProblemGPU> {
+    static constexpr bool value = true;
+};
+
+/// Runs the BlackOil intensive-quantities update on the GPU for a given set
+/// of degrees of freedom. The dispatcher is process-wide (one singleton per
+/// CPU \c TypeTag). It lazily constructs the GPU-side \c GpuFlowProblem
+/// from the supplied CPU problem on the first call.
+///
+/// On every call, primary variables for the requested DoFs are uploaded to
+/// the device, the per-cell update kernel from
+/// \c test_blackoilintensivequantities_gpu.cu is launched (one thread per
+/// DoF), and the resulting intensive quantities are read back to host
+/// memory, as the design plan in \c PLAN.md requires.
+///
+/// The class is a template on the CPU \c TypeTag and is explicitly
+/// instantiated in the \c .cu translation unit.
+template <class CpuTypeTag>
+class GpuBlackoilIntensiveQuantitiesDispatcher
+{
+public:
+    using Problem            = Opm::GetPropType<CpuTypeTag, Opm::Properties::Problem>;
+    using PrimaryVariables   = Opm::GetPropType<CpuTypeTag, Opm::Properties::PrimaryVariables>;
+    using IntensiveQuantities = Opm::GetPropType<CpuTypeTag, Opm::Properties::IntensiveQuantities>;
+
+    GpuBlackoilIntensiveQuantitiesDispatcher();
+    ~GpuBlackoilIntensiveQuantitiesDispatcher();
+
+    GpuBlackoilIntensiveQuantitiesDispatcher(const GpuBlackoilIntensiveQuantitiesDispatcher&) = delete;
+    GpuBlackoilIntensiveQuantitiesDispatcher&
+    operator=(const GpuBlackoilIntensiveQuantitiesDispatcher&) = delete;
+
+    /// Run the per-cell intensive-quantities update kernel on \p numDof
+    /// DoFs. \p cpuPriVars[i] points at the CPU primary variables for DoF
+    /// \c i. The GPU-computed BlackOil intensive quantities are written
+    /// onto \p outIQ[i] field-by-field via
+    /// \c BlackOilIntensiveQuantities::overlayBlackOilFieldsFrom (so the
+    /// caller is expected to have run the CPU update first to fill in any
+    /// fields the dispatcher does not overwrite, e.g. \c mobility_).
+    ///
+    /// Per-call host/device timings are accumulated and printed every call
+    /// to \c std::cout, prefixed with
+    /// \c "[GpuBlackoilIntensiveQuantitiesDispatcher]".
+    void update(const Problem& cpuProblem,
+                const PrimaryVariables* const* cpuPriVars,
+                IntensiveQuantities* const* outIQ,
+                std::size_t numDof);
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> impl_;
+};
+
+} // namespace Opm::gpuistl
+
+#endif // HAVE_CUDA
+
+#endif // OPM_GPU_BLACKOIL_INTENSIVE_QUANTITIES_DISPATCHER_HPP
diff --git a/opm/simulators/linalg/gpuistl/GpuFlowGasWaterEnergyTypeTags.hpp b/opm/simulators/linalg/gpuistl/GpuFlowGasWaterEnergyTypeTags.hpp
new file mode 100644
index 00000000000..407490ed6a0
--- /dev/null
+++ b/opm/simulators/linalg/gpuistl/GpuFlowGasWaterEnergyTypeTags.hpp
@@ -0,0 +1,246 @@
+// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+// vi: set et ts=4 sw=4 sts=4:
+/*
+  Copyright TODO ADD YEAR AND NAME OF AUTHOR
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/*!
+ * \file
+ *
+ * Shared GPU TypeTag derivations on top of the simulation-side
+ * \c FlowGasWaterEnergyProblem TypeTag (CO2STORE configuration).
+ *
+ * The intent is that GPU code (the dispatcher and the
+ * \c test_blackoilintensivequantities_gpu test) reuses the *exact* same
+ * TypeTag as the simulator and only overrides the small set of properties
+ * that have to change for the GPU build (storage container of the primary
+ * variables, the material law manager, the fluid system, the problem and
+ * the element context).
+ */
+#ifndef OPM_GPU_FLOW_GASWATER_ENERGY_TYPETAGS_HPP
+#define OPM_GPU_FLOW_GASWATER_ENERGY_TYPETAGS_HPP
+
+#if HAVE_CUDA
+
+#include <opm/material/fluidmatrixinteractions/EclMaterialLawTwoPhaseTypes.hpp>
+#include <opm/material/fluidmatrixinteractions/EclTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterialParams.hpp>
+
+#include <opm/material/fluidsystems/BlackOilFluidSystemNonStatic.hpp>
+
+#include <opm/models/blackoil/blackoilprimaryvariables.hh>
+#include <opm/models/discretization/common/nullfvbaseelementcontext.hh>
+
+#include <opm/material/thermal/EclSpecrockLaw.hpp>
+#include <opm/material/thermal/EclSpecrockLawParams.hpp>
+#include <opm/material/thermal/EclThconrLaw.hpp>
+#include <opm/material/thermal/EclThconrLawParams.hpp>
+
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+#include <opm/material/fluidmatrixinteractions/GpuEclMaterialLawManager.hpp>
+#include <opm/material/thermal/GpuEclThermalLawManager.hpp>
+#include <opm/simulators/flow/GpuFlowProblem.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuBuffer.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuView.hpp>
+#include <opm/simulators/linalg/gpuistl/MiniVector.hpp>
+#include <opm/simulators/linalg/gpuistl/gpu_smart_pointer.hpp>
+
+#include <tuple>
+
+namespace Opm::Properties {
+
+namespace TTag {
+
+/// Internal kernel-base TypeTag for the GPU intensive-quantities dispatcher.
+/// Inherits all property bindings from \c FlowGasWaterEnergyProblem and
+/// overrides the primary variables, material law, fluid system and thermal
+/// laws to their GPU-compatible (GpuView / MiniVector) equivalents.
+/// This tag is an implementation detail of the dispatcher; user code should
+/// use \c FlowGasWaterEnergyProblemGPU (declared in FlowGasWaterEnergyTypeTag.hpp)
+/// as the outer simulation TypeTag.
+struct FlowGasWaterEnergyKernelBaseGPU {
+    using InheritsFrom = std::tuple<FlowGasWaterEnergyProblem>;
+};
+
+/// A second derived TypeTag used for the per-cell intensive-quantities
+/// kernel: it additionally swaps in \c GpuFlowProblem and
+/// \c NullFvBaseElementContext so that the GPU device side has trivially
+/// copyable \c Problem / \c ElementContext types.
+struct FlowGasWaterEnergyDummyProblemGPU {
+    using InheritsFrom = std::tuple<FlowGasWaterEnergyKernelBaseGPU>;
+};
+
+} // namespace TTag
+
+// -----------------------------------------------------------------------
+// Diffusion / dispersion: not yet implemented in the GPU IntensiveQuantities
+// update path; force them off on the GPU TypeTag.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+    static constexpr bool value = false;
+};
+
+template <class TypeTag>
+struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+    static constexpr bool value = false;
+};
+
+// -----------------------------------------------------------------------
+// MaterialLaw: GPU-friendly EclTwoPhaseMaterial backed by GpuView storage.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct MaterialLaw<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+private:
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    using FluidSystem = GetPropType<TTag::FlowProblem, Properties::FluidSystem>;
+    using Traits = ThreePhaseMaterialTraits<Scalar,
+                                            /*wettingPhaseIdx=*/FluidSystem::waterPhaseIdx,
+                                            /*nonWettingPhaseIdx=*/FluidSystem::oilPhaseIdx,
+                                            /*gasPhaseIdx=*/FluidSystem::gasPhaseIdx,
+                                            getPropValue<TypeTag, Properties::EnableHysteresis>(),
+                                            getPropValue<TypeTag, Properties::EnableEndpointScaling>()>;
+    using TwoPhaseTraits = TwoPhaseMaterialTraits<Scalar,
+                                                  /*wettingPhaseIdx=*/Traits::wettingPhaseIdx,
+                                                  /*nonWettingPhaseIdx=*/Traits::nonWettingPhaseIdx>;
+    using TwoPhaseParams = ::Opm::PiecewiseLinearTwoPhaseMaterialParams<
+        TwoPhaseTraits, ::Opm::gpuistl::GpuView<const Scalar>>;
+    using TwoPhaseLaw = ::Opm::PiecewiseLinearTwoPhaseMaterial<TwoPhaseTraits, TwoPhaseParams>;
+    using GpuMaterialLawParams = ::Opm::EclTwoPhaseMaterialParams<
+        Traits, TwoPhaseParams, TwoPhaseParams, TwoPhaseParams, ::Opm::gpuistl::ValueAsPointer>;
+    using GpuMaterialLaw = ::Opm::EclTwoPhaseMaterial<
+        Traits, TwoPhaseLaw, TwoPhaseLaw, TwoPhaseLaw, GpuMaterialLawParams>;
+
+public:
+    using EclMaterialLawManager = ::Opm::EclMaterialLaw::GpuManager<
+        Traits, TwoPhaseLaw, TwoPhaseLaw, ::Opm::VectorWithDefaultAllocator, GpuMaterialLaw>;
+    using type = typename EclMaterialLawManager::MaterialLaw;
+};
+
+// -----------------------------------------------------------------------
+// PrimaryVariables: GPU build uses MiniVector storage so the type is
+// trivially copyable to the device.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct PrimaryVariables<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+    using type = ::Opm::BlackOilPrimaryVariables<TypeTag, ::Opm::gpuistl::MiniVector>;
+};
+
+// -----------------------------------------------------------------------
+// FluidSystem: non-static, GpuView-backed instantiation.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct FluidSystem<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+    using type = ::Opm::BlackOilFluidSystemNonStatic<
+        GetPropType<TTag::FlowProblem, Properties::Scalar>,
+        ::Opm::BlackOilDefaultFluidSystemIndices,
+        ::Opm::gpuistl::GpuView>;
+};
+
+template <class TypeTag>
+struct FluidSystem<TypeTag, TTag::FlowGasWaterEnergyDummyProblemGPU>
+{
+    using type = ::Opm::BlackOilFluidSystemNonStatic<
+        GetPropType<TTag::FlowProblem, Properties::Scalar>,
+        ::Opm::BlackOilDefaultFluidSystemIndices,
+        ::Opm::gpuistl::GpuView>;
+};
+
+// -----------------------------------------------------------------------
+// SolidEnergyLaw / ThermalConductionLaw: bind to the GPU-portable laws
+// (EclSpecrockLaw / EclThconrLaw). Both expose an
+// \c EclThermalLawManager nested typedef matching the convention used by
+// FlowBaseProblemProperties so existing GetProp<...>::EclThermalLawManager
+// chains keep working.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct SolidEnergyLaw<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+private:
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
+
+public:
+    using EclThermalLawManager = ::Opm::EclThermalLaw::GpuManager<
+        Scalar, FluidSystem, ::Opm::gpuistl::GpuView, ::Opm::gpuistl::GpuView>;
+
+    using type = ::Opm::EclSpecrockLaw<
+        Scalar,
+        ::Opm::EclSpecrockLawParams<Scalar, ::Opm::gpuistl::GpuView>>;
+};
+
+template <class TypeTag>
+struct ThermalConductionLaw<TypeTag, TTag::FlowGasWaterEnergyKernelBaseGPU>
+{
+private:
+    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
+    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
+
+public:
+    using EclThermalLawManager = ::Opm::EclThermalLaw::GpuManager<
+        Scalar, FluidSystem, ::Opm::gpuistl::GpuView, ::Opm::gpuistl::GpuView>;
+
+    using type = ::Opm::EclThconrLaw<Scalar, FluidSystem>;
+};
+
+// -----------------------------------------------------------------------
+// Problem: GpuFlowProblem (GpuView-backed) instead of FlowProblemBlackoil.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct Problem<TypeTag, TTag::FlowGasWaterEnergyDummyProblemGPU>
+{
+private:
+    using ScalarT = GetPropType<TypeTag, Properties::Scalar>;
+    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
+    using CpuMaterialLawManager =
+        typename Opm::GetProp<TypeTag, Opm::Properties::MaterialLaw>::EclMaterialLawManager;
+    using GpuViewMaterialLawManager =
+        ::Opm::EclMaterialLaw::GpuManager<typename CpuMaterialLawManager::Traits,
+                                          typename CpuMaterialLawManager::GasOilLaw,
+                                          typename CpuMaterialLawManager::OilWaterLaw,
+                                          ::Opm::gpuistl::GpuView,
+                                          typename CpuMaterialLawManager::MaterialLaw>;
+    using GpuViewThermalLawManager = ::Opm::EclThermalLaw::GpuManager<
+        ScalarT, FluidSystem, ::Opm::gpuistl::GpuView, ::Opm::gpuistl::GpuView>;
+
+public:
+    using type = ::Opm::GpuFlowProblem<ScalarT,
+                                       GpuViewMaterialLawManager,
+                                       ::Opm::gpuistl::GpuView,
+                                       GpuViewThermalLawManager>;
+};
+
+// -----------------------------------------------------------------------
+// ElementContext: trivially copyable GPU element context.
+// -----------------------------------------------------------------------
+template <class TypeTag>
+struct ElementContext<TypeTag, TTag::FlowGasWaterEnergyDummyProblemGPU>
+{
+    using type = ::Opm::NullFvBaseElementContext<TypeTag>;
+};
+
+} // namespace Opm::Properties
+
+#endif // HAVE_CUDA
+
+#endif // OPM_GPU_FLOW_GASWATER_ENERGY_TYPETAGS_HPP
diff --git a/opm/simulators/linalg/gpuistl/GpuView.hpp b/opm/simulators/linalg/gpuistl/GpuView.hpp
index 79940acb5a1..f454a4c3cc5 100644
--- a/opm/simulators/linalg/gpuistl/GpuView.hpp
+++ b/opm/simulators/linalg/gpuistl/GpuView.hpp
@@ -31,6 +31,8 @@
 
 #include <fmt/core.h>
 
+#include <iostream>
+
 namespace Opm::gpuistl
 {
 
@@ -80,7 +82,7 @@ class GpuView
      *
      * @param idx The index of the element
      */
-    __host__ __device__ T operator[](size_t idx) const {
+    __host__ __device__ const T& operator[](size_t idx) const {
 #ifndef NDEBUG
         assertInRange(idx);
 #endif
@@ -401,7 +403,14 @@ class GpuView
     {
 #if OPM_IS_INSIDE_DEVICE_FUNCTION
         // TODO: find a better way to handle exceptions in kernels, this will possibly be printed many times
-        assert(idx < m_numberOfElements && "The index provided was not in the range [0, buffersize-1]");
+        // assert(idx < m_numberOfElements && fmt::format("Index {} is out of range [0, {})", idx, m_numberOfElements - 1).c_str());
+        if (idx >= m_numberOfElements)
+        {
+            printf("Index %llu is out of range [0, %llu)\n",
+                (unsigned long long)idx,
+                (unsigned long long)m_numberOfElements);
+            assert(false && "Index is out of range");
+        }
 #else
         if (idx >= m_numberOfElements) {
             OPM_THROW(std::invalid_argument,
diff --git a/opm/simulators/wells/WellInterface_impl.hpp b/opm/simulators/wells/WellInterface_impl.hpp
index 2ade83466b4..5df0aebb570 100644
--- a/opm/simulators/wells/WellInterface_impl.hpp
+++ b/opm/simulators/wells/WellInterface_impl.hpp
@@ -28,6 +28,12 @@
 #include <opm/simulators/wells/WellInterface.hpp>
 #endif
 
+#include <iostream>
+#include <vector>
+#include <string>
+#include <ranges>
+#include <algorithm>
+
 #include <opm/common/Exceptions.hpp>
 
 #include <opm/input/eclipse/Schedule/ScheduleTypes.hpp>
@@ -307,7 +313,6 @@ namespace Opm
         }
         const bool oscillating =
             std::ranges::count(this->well_control_log_, from) >= this->param_.max_number_of_well_switches_;
-
         if (oscillating || this->wellUnderZeroRateTarget(groupStateHelper) || !(well_state.well(this->index_of_well_).status == WellStatus::OPEN)) {
            return false;
         }
diff --git a/tests/gpuistl/test_GpuSparseTable.cu b/tests/gpuistl/test_GpuSparseTable.cu
index a58020d1ed5..b7b8c2ff8f8 100644
--- a/tests/gpuistl/test_GpuSparseTable.cu
+++ b/tests/gpuistl/test_GpuSparseTable.cu
@@ -42,7 +42,7 @@
 
 
 __global__ void fetchSparseTableValuesInKernel(Opm::SparseTable<int, Opm::gpuistl::GpuView> tableView,
-                                               std::array<int, 6>* output)
+                                               std::array<int, 7>* output)
 {
     int idx = blockIdx.x * blockDim.x + threadIdx.x;
     if (idx == 0) {
@@ -53,6 +53,7 @@ __global__ void fetchSparseTableValuesInKernel(Opm::SparseTable<int, Opm::gpuist
                 (*output)[offset++] = e;
             }
         }
+        (*output)[offset++] = tableView.dataSize();
     }
 }
 
@@ -83,11 +84,11 @@ BOOST_AUTO_TEST_CASE(TestUsingSparseTableInKernel)
     auto gpuBufferTable = Opm::gpuistl::copy_to_gpu<int>(cpuTable);
     auto gpuTableView = Opm::gpuistl::make_view(gpuBufferTable);
 
-    auto valuesFetchedFromGpu = Opm::gpuistl::make_gpu_unique_ptr<std::array<int, 6>>({-1});
+    auto valuesFetchedFromGpu = Opm::gpuistl::make_gpu_unique_ptr<std::array<int, 7>>({-1});
 
     fetchSparseTableValuesInKernel<<<1, 1>>>(gpuTableView, valuesFetchedFromGpu.get());
 
-    auto hostValues = Opm::gpuistl::copyFromGPU<std::array<int, 6>>(valuesFetchedFromGpu);
+    auto hostValues = Opm::gpuistl::copyFromGPU<std::array<int, 7>>(valuesFetchedFromGpu);
 
     BOOST_CHECK_EQUAL(hostValues[0], 1);
     BOOST_CHECK_EQUAL(hostValues[1], 2);
@@ -95,4 +96,5 @@ BOOST_AUTO_TEST_CASE(TestUsingSparseTableInKernel)
     BOOST_CHECK_EQUAL(hostValues[3], 4);
     BOOST_CHECK_EQUAL(hostValues[4], 5);
     BOOST_CHECK_EQUAL(hostValues[5], 6);
+    BOOST_CHECK_EQUAL(hostValues[6], 6);
 }
diff --git a/tests/gpuistl/test_blackoilintensivequantities_gpu.cu b/tests/gpuistl/test_blackoilintensivequantities_gpu.cu
new file mode 100644
index 00000000000..f505bf92cd2
--- /dev/null
+++ b/tests/gpuistl/test_blackoilintensivequantities_gpu.cu
@@ -0,0 +1,1099 @@
+/*
+  Copyright 2025 Equinor ASA
+
+  This file is part of the Open Porous Media project (OPM).
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <config.h>
+
+// Tricks for older versions of ROCm that do not support alugrid
+// or dune fem. Note that these changes are only valid for this test file.
+#ifdef HAVE_DUNE_ALUGRID
+#undef HAVE_DUNE_ALUGRID
+#endif
+#define HAVE_DUNE_ALUGRID 0
+#ifdef HAVE_DUNE_FEM
+#undef HAVE_DUNE_FEM
+#endif
+#define HAVE_DUNE_FEM 0
+
+#include <opm/common/utility/gpuDecorators.hpp>
+#include <opm/material/common/ResetLocale.hpp>
+#include <opm/material/fluidmatrixinteractions/EclDefaultMaterial.hpp>
+#define HAVE_ECL_INPUT 1
+
+
+#define BOOST_TEST_MODULE TestBlackOilIntensiveQuantitiesGPU
+
+#include <boost/test/unit_test.hpp>
+#include <cuda.h>
+#include <cuda_runtime.h>
+#include <opm/common/ErrorMacros.hpp>
+#include <opm/models/blackoil/blackoilmodel.hh>
+#include <opm/models/blackoil/blackoilprimaryvariables.hh>
+#include <opm/models/discretization/common/fvbaseprimaryvariables.hh>
+#include <opm/models/discretization/common/tpfalinearizer.hh>
+#include <opm/models/io/dgfvanguard.hh>
+#include <opm/models/utils/start.hh>
+#include <opm/simulators/flow/Main.hpp>
+#include <opm/simulators/linalg/gpuistl/detail/gpu_safe_call.hpp>
+#include <opm/simulators/linalg/gpuistl/gpu_smart_pointer.hpp>
+#include <opm/input/eclipse/Deck/Deck.hpp>
+#include <opm/input/eclipse/EclipseState/EclipseState.hpp>
+#include <opm/input/eclipse/Parser/Parser.hpp>
+#include <opm/input/eclipse/Python/Python.hpp>
+#include <opm/input/eclipse/Schedule/Schedule.hpp>
+#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
+#include <opm/material/fluidsystems/BlackOilFluidSystemNonStatic.hpp>
+#include <opm/models/blackoil/blackoilintensivequantities.hh>
+#include <opm/models/nonlinear/newtonmethodparams.hpp>
+#include <opm/simulators/flow/equil/EquilibrationHelpers.hpp>
+#include <opm/simulators/flow/equil/InitStateEquil.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuBuffer.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuView.hpp>
+#include <opm/material/densead/Evaluation.hpp>
+#include <opm/models/utils/simulator.hh>
+#include <opm/simulators/flow/FlowProblemBlackoil.hpp>
+#include <opm/simulators/flow/FlowProblemBlackoilProperties.hpp>
+#include <opm/simulators/utils/moduleVersion.hpp>
+#include <opm/simulators/flow/BlackoilModelParameters.hpp>
+#include <opm/simulators/flow/FlowGenericVanguard.hpp>
+#include <opm/simulators/linalg/parallelbicgstabbackend.hh>
+#include <opm/simulators/wells/BlackoilWellModel.hpp>
+#include <opm/models/discretization/common/nullfvbaseelementcontext.hh>
+
+#include <opm/material/fluidmatrixinteractions/EclMaterialLawTwoPhaseTypes.hpp>
+#include <opm/material/fluidmatrixinteractions/EclTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterial.hpp>
+#include <opm/material/fluidmatrixinteractions/PiecewiseLinearTwoPhaseMaterialParams.hpp>
+#include <opm/models/blackoil/blackoillocalresidualtpfa.hh>
+
+#include <opm/material/fluidmatrixinteractions/GpuEclMaterialLawManager.hpp>
+#include <opm/material/thermal/GpuEclThermalLawManager.hpp>
+#include <opm/simulators/flow/GpuFlowProblem.hpp>
+
+#include <opm/simulators/flow/FlowGasWaterEnergyTypeTag.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuFlowGasWaterEnergyTypeTags.hpp>
+
+#include <chrono>
+#include <filesystem>
+#include <format>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+
+/// Build a CO2STORE WATER+GAS deck with the requested DIMENS. The grid is
+/// a uniform unit-cube grid; PERMX/PORO are constant. EQUIL gives the
+/// pressure profile so different cells (different depths) get different
+/// fluid states, exercising the per-cell update on both CPU and GPU.
+static std::string makeDeckString(int nx, int ny, int nz)
+{
+    const long total = static_cast<long>(nx) * ny * nz;
+    const long areal = static_cast<long>(nx) * ny;
+    std::ostringstream o;
+    o << "RUNSPEC\n"
+      << "DIMENS\n" << nx << ' ' << ny << ' ' << nz << " /\n"
+      << "EQLDIMS\n/\n"
+      << "TABDIMS\n/\n"
+      << "WATER\nGAS\nCO2STORE\nTHERMAL\nMETRIC\n"
+      << "GRID\n"
+      << "GRIDFILE\n0 0 /\n"
+      << "DX\n" << total << "*1 /\n"
+      << "DY\n" << total << "*1 /\n"
+      << "DZ\n" << total << "*1 /\n"
+      << "TOPS\n" << areal << "*0 /\n"
+      << "PERMX\n" << total << "*1013.25 /\n"
+      << "PORO\n" << total << "*0.25 /\n"
+      << "COPY\nPERMX PERMY /\nPERMX PERMZ /\n/\n"
+      << "THCONR\n" << total << "*1.5 /\n"
+      << "PROPS\n"
+      << "SGWFN\n"
+      << "0.000000E+00 0.000000E+00 1.000000E+00 3.060000E-02\n"
+      << "1.000000E+00 1.000000E+00 0.000000E+00 3.060000E-01 /\n"
+      << "SPECROCK\n20 2125.0  100 2125.0 /\n"
+      << "SOLUTION\n"
+      << "RPTRST\n'BASIC=0' /\n"
+      << "EQUIL\n0 300 100 0 0 0 1 1 0 /\n"
+      << "RTEMPVD\n0 36.12\n1000 70.0 /\n"
+      << "SCHEDULE\n"
+      << "RPTRST\n'BASIC=0' /\n"
+      << "TSTEP\n1 /";
+    return o.str();
+}
+
+
+static constexpr const char* deckString1 = "-- =============== RUNSPEC\n"
+                                           "RUNSPEC\n"
+                                           "DIMENS\n"
+                                           "3 3 3 /\n"
+                                           "EQLDIMS\n"
+                                           "/\n"
+                                           "TABDIMS\n"
+                                           "/\n"
+                                           "WATER\n"
+                                           "GAS\n"
+                                           "CO2STORE\n"
+                                           "THERMAL\n"
+                                           "METRIC\n"
+                                           "-- =============== GRID\n"
+                                           "GRID\n"
+                                           "GRIDFILE\n"
+                                           "0 0 /\n"
+                                           "DX\n"
+                                           "27*1 /\n"
+                                           "DY\n"
+                                           "27*1 /\n"
+                                           "DZ\n"
+                                           "27*1 /\n"
+                                           "TOPS\n"
+                                           "9*0 /\n"
+                                           "PERMX\n"
+                                           "27*1013.25 /\n"
+                                           "PORO\n"
+                                           "27*0.25 /\n"
+                                           "COPY\n"
+                                           "PERMX PERMY /\n"
+                                           "PERMX PERMZ /\n"
+                                           "/\n"
+                                           "THCONR\n"
+                                           "27*1.5 /\n"
+                                           "-- =============== PROPS\n"
+                                           "PROPS\n"
+                                           "SGWFN\n"
+                                           "0.000000E+00 0.000000E+00 1.000000E+00 3.060000E-02\n"
+                                           "1.000000E+00 1.000000E+00 0.000000E+00 3.060000E-01 /\n"
+                                           "SPECROCK\n"
+                                           "20 2125.0  100 2125.0 /\n"
+                                           "-- =============== SOLUTION\n"
+                                           "SOLUTION\n"
+                                           "RPTRST\n"
+                                           "'BASIC=0' /\n"
+                                           "EQUIL\n"
+                                           "0 300 100 0 0 0 1 1 0 /\n"
+                                           "RTEMPVD\n"
+                                           "0 36.12\n"
+                                           "1000 70.0 /\n"
+                                           "-- =============== SCHEDULE\n"
+                                           "SCHEDULE\n"
+                                           "RPTRST\n"
+                                           "'BASIC=0' /\n"
+                                           "TSTEP\n"
+                                           "1 /";
+
+using ScalarToUse = Opm::GetPropType<Opm::Properties::TTag::FlowProblem, Opm::Properties::Scalar>;
+
+using GpuB = Opm::gpuistl::GpuBuffer<double>;
+using GpuV = Opm::gpuistl::GpuView<double>;
+using FluidSystem = Opm::BlackOilFluidSystem<ScalarToUse>;
+using Evaluation = Opm::DenseAd::Evaluation<double, 2>;
+using BlackOilFluidSystemView
+    = Opm::BlackOilFluidSystemNonStatic<ScalarToUse,
+                                        Opm::BlackOilDefaultFluidSystemIndices,
+                                        Opm::gpuistl::GpuView>;
+
+template <class Value>
+OPM_HOST_DEVICE double asDouble(const Value& value)
+{
+    if constexpr (requires { value.value(); }) {
+        return static_cast<double>(value.value());
+    }
+    else {
+        return static_cast<double>(value);
+    }
+}
+
+/// Compare two scalar-or-Evaluation quantities. Always compares the value
+/// part. When \p checkDerivatives is true and both operands are
+/// `DenseAd::Evaluation`s, also checks every partial derivative using
+/// \c BOOST_CHECK_CLOSE with the supplied tolerance and increments
+/// \p derivativeComparisons by the number of partial derivatives compared.
+/// If \p checkDerivatives is true but the operands are not Evaluations,
+/// the test fails with \c BOOST_FAIL so a misconfigured derivative test
+/// cannot silently pass on plain scalars.
+template <class CpuValue, class GpuValue>
+void checkValueAndDerivatives(const CpuValue& cpuValue,
+                              const GpuValue& gpuValue,
+                              double tol,
+                              bool checkDerivatives,
+                              const char* label,
+                              std::size_t& derivativeComparisons)
+{
+    BOOST_CHECK_CLOSE(asDouble(cpuValue), asDouble(gpuValue), tol);
+
+    if (!checkDerivatives) {
+        return;
+    }
+
+    if constexpr (requires {
+                      CpuValue::numVars;
+                      cpuValue.derivative(0);
+                      GpuValue::numVars;
+                      gpuValue.derivative(0);
+                  })
+    {
+        static_assert(static_cast<int>(CpuValue::numVars)
+                          == static_cast<int>(GpuValue::numVars),
+                      "CPU and GPU Evaluation types must have the same numVars");
+        static_assert(static_cast<int>(CpuValue::numVars) > 0,
+                      "Derivative comparison requires at least one partial derivative");
+        for (int derivIdx = 0; derivIdx < CpuValue::numVars; ++derivIdx) {
+            const double cpuDerivative = static_cast<double>(cpuValue.derivative(derivIdx));
+            const double gpuDerivative = static_cast<double>(gpuValue.derivative(derivIdx));
+            BOOST_CHECK_MESSAGE(std::abs(cpuDerivative - gpuDerivative)
+                                    <= tol * (1.0 + std::abs(cpuDerivative)),
+                                label << " derivative[" << derivIdx
+                                      << "] cpu=" << cpuDerivative
+                                      << " gpu=" << gpuDerivative);
+            ++derivativeComparisons;
+        }
+    }
+    else {
+        BOOST_FAIL(std::string("checkDerivatives=true but ") + label
+                   + " is not a DenseAd::Evaluation");
+    }
+}
+
+template <class TypeTag>
+struct DummyProblem {
+
+
+    OPM_HOST_DEVICE DummyProblem() {
+        // empty
+    }
+
+    OPM_HOST_DEVICE ~DummyProblem() {
+        // empty
+    }
+
+    using EclMaterialLawManager =
+        typename Opm::GetProp<TypeTag, Opm::Properties::MaterialLaw>::EclMaterialLawManager;
+    using EclThermalLawManager =
+        typename Opm::GetProp<TypeTag, Opm::Properties::SolidEnergyLaw>::EclThermalLawManager;
+    struct MaterialLawParams {};
+
+    struct {
+        struct {
+            OPM_HOST_DEVICE Opm::LinearizationType getLinearizationType() const
+            {
+                return Opm::LinearizationType();
+            }
+        } lin_;
+
+        OPM_HOST_DEVICE auto linearizer() const
+        {
+            return lin_;
+        }
+    } model_;
+
+    OPM_HOST_DEVICE auto model() const
+    {
+        return model_;
+    }
+
+    OPM_HOST_DEVICE int satnumRegionIndex(std::size_t) const
+    {
+        return 0;
+    }
+    OPM_HOST_DEVICE const MaterialLawParams& materialLawParams(std::size_t) const
+    {
+        return materialLawParams_;
+    }
+    MaterialLawParams materialLawParams_;
+    OPM_HOST_DEVICE double rockCompressibility(std::size_t) const
+    {
+        return 0.0;
+    }
+    OPM_HOST_DEVICE double rockReferencePressure(std::size_t) const
+    {
+        return 0.0;
+    }
+    OPM_HOST_DEVICE double porosity(std::size_t, unsigned int) const
+    {
+        return 0.0;
+    }
+    OPM_HOST_DEVICE double maxOilVaporizationFactor(unsigned int, std::size_t) const
+    {
+        return 0.0;
+    }
+    OPM_HOST_DEVICE double maxGasDissolutionFactor(unsigned int, std::size_t) const
+    {
+        return 0.0;
+    }
+    OPM_HOST_DEVICE double maxOilSaturation(std::size_t) const
+    {
+        return 0.0;
+    }
+
+    template <class Evaluation>
+    OPM_HOST_DEVICE Evaluation rockCompPoroMultiplier(const auto&, std::size_t) const
+    {
+        return Evaluation(0.0);
+    }
+
+    template <class FluidState, class ...Args>
+    OPM_HOST_DEVICE void updateRelperms(auto& mobility, auto& dirMob, FluidState& fluidState, unsigned globalSpaceIdx) const
+    {
+    }
+
+    template <class Evaluation>
+    OPM_HOST_DEVICE Evaluation rockCompTransMultiplier(const auto&, std::size_t) const
+    {
+        return Evaluation(0.0);
+    }
+};
+
+namespace Opm
+{
+namespace Properties
+{
+namespace TTag
+{
+
+/// CPU side mirror of the simulation TypeTag, with diffusion/dispersion
+/// disabled because the simpler \c BlackOilIntensiveQuantities::update()
+/// overload used in this test does not support them. All other property
+/// bindings (Indices, MaterialLaw, FluidSystem, etc.) are inherited as-is
+/// from \c FlowGasWaterEnergyProblem.
+struct FlowGasWaterEnergyProblemTest {
+    using InheritsFrom = std::tuple<FlowGasWaterEnergyProblem>;
+};
+
+/// CPU TypeTag used by the real-deck test: identical to the production
+/// \c FlowGasWaterEnergyProblem (does not force-disable diffusion or
+/// dispersion) so that decks enabling those keywords can construct the
+/// simulator successfully.
+struct FlowGasWaterEnergyProblemTestRealDeck {
+    using InheritsFrom = std::tuple<FlowGasWaterEnergyProblem>;
+};
+
+} // namespace TTag
+
+template <class TypeTag>
+struct EnableDiffusion<TypeTag, TTag::FlowGasWaterEnergyProblemTest>
+{ static constexpr bool value = false; };
+
+template <class TypeTag>
+struct EnableDispersion<TypeTag, TTag::FlowGasWaterEnergyProblemTest>
+{ static constexpr bool value = false; };
+
+} // namespace Properties
+
+} // namespace Opm
+
+using TypeTag = Opm::Properties::TTag::FlowGasWaterEnergyProblemTest;
+using TypeNacht = Opm::Properties::TTag::FlowGasWaterEnergyDummyProblemGPU;
+// FlowGasWaterEnergyKernelBaseGPU is the GPU-kernel-side TypeTag with GpuView
+// FluidSystem; previously named FlowGasWaterEnergyProblemGPU in the dispatcher
+// internals.  Use it wherever a GpuView-backed ScalarFluidState is needed.
+using TypeTagGPU = Opm::Properties::TTag::FlowGasWaterEnergyKernelBaseGPU;
+
+template<class IndexTraits, class GpuProblem>
+__global__ void
+testUsingOnGPU(Opm::BlackOilFluidSystemNonStatic<double, IndexTraits, Opm::gpuistl::GpuView> fluidSystem,
+               Opm::BlackOilIntensiveQuantities<TypeNacht> intensiveQuantities,
+               Opm::BlackOilPrimaryVariables<TypeNacht, Opm::gpuistl::MiniVector> primaryVariables,
+               GpuProblem problem)
+{
+    printf("fluidSystem.phaseIsActive(0): %d\n", fluidSystem.phaseIsActive(0));
+    printf("fluidSystem.phaseIsActive(1): %d\n", fluidSystem.phaseIsActive(1));
+    printf("fluidSystem.phaseIsActive(2): %d\n", fluidSystem.phaseIsActive(2));
+    using ScalarFluidState = typename Opm::BlackOilIntensiveQuantities<TypeTagGPU>::ScalarFluidState;
+    ScalarFluidState state(fluidSystem);
+    printf("BlackOilState density before update: %f\n", asDouble(state.density(0)));
+
+    ScalarFluidState state2(fluidSystem);
+    primaryVariables.assignNaive(state2);
+    printf("BlackOilState density before update: %f\n", asDouble(state.density(0)));
+    intensiveQuantities.updateSaturations(primaryVariables, 0, Opm::LinearizationType{});
+    intensiveQuantities.update(problem, primaryVariables, 0, 0);
+
+    printf("BlackOilState density after update: %f\n", asDouble(state.density(0)));
+}
+
+__global__ void dummykernel()
+{
+    printf("Hello from dummy kernel!\n");
+}
+
+template <class GpuProblem, class PrimaryVariables, class IntensiveQuantities>
+__global__ void
+updateAllCellsKernel(GpuProblem problem,
+                     Opm::gpuistl::GpuView<const PrimaryVariables> primaryVariables,
+                     Opm::gpuistl::GpuView<IntensiveQuantities> outIntensiveQuantities,
+                     std::size_t numCells)
+{
+    const std::size_t i = static_cast<std::size_t>(blockIdx.x) * blockDim.x + threadIdx.x;
+    if (i >= numCells) {
+        return;
+    }
+    IntensiveQuantities intensiveQuantities = outIntensiveQuantities[i];
+    intensiveQuantities.updateSaturations(primaryVariables[i], 0, Opm::LinearizationType{});
+    intensiveQuantities.update(problem, primaryVariables[i], static_cast<unsigned>(i), 0);
+    intensiveQuantities.updateEnergyQuantities_(problem, static_cast<unsigned>(i), 0u);
+    outIntensiveQuantities[i] = intensiveQuantities;
+}
+
+/// One-shot global initialization of MPI, communicator, and parameter
+/// registration. Safe to call from multiple BOOST test cases; only the
+/// first call performs the work.
+static void initSimulatorOnce()
+{
+    static bool done = false;
+    if (done) {
+        return;
+    }
+    using namespace Opm;
+    int argc1 = boost::unit_test::framework::master_test_suite().argc;
+    char** argv1 = boost::unit_test::framework::master_test_suite().argv;
+#if HAVE_DUNE_FEM
+    Dune::Fem::MPIManager::initialize(argc1, argv1);
+#else
+    Dune::MPIHelper::instance(argc1, argv1);
+#endif
+    FlowGenericVanguard::setCommunication(std::make_unique<Opm::Parallel::Communication>());
+    Opm::ThreadManager::registerParameters();
+    Opm::NewtonMethodParams<double>::registerParameters();
+    BlackoilModelParameters<ScalarToUse>::registerParameters();
+    AdaptiveTimeStepping<TypeTag>::registerParameters();
+    Parameters::Register<Parameters::EnableTerminalOutput>(
+        "Dummy added for the well model to compile.");
+    registerAllParameters_<TypeTag>(/*finalizeRegistration=*/false);
+    // Also register parameters for the RealDeck TypeTag here so that all
+    // tests in the same process share a single (still-open) registration
+    // pass. Once endRegistration() (called via setupParameters_) closes
+    // registration, no further parameters can be added globally.
+    using RealDeckTypeTag = Opm::Properties::TTag::FlowGasWaterEnergyProblemTestRealDeck;
+    AdaptiveTimeStepping<RealDeckTypeTag>::registerParameters();
+    registerAllParameters_<RealDeckTypeTag>(/*finalizeRegistration=*/false);
+    Parameters::endRegistration();
+    done = true;
+}
+
+/// Run the per-cell intensive quantities update on both GPU and CPU for the
+/// deck stored at \p deckPath, optionally measuring wall-clock time on both
+/// sides.
+///
+/// Correctness is checked by comparing CPU vs GPU intensive quantities
+/// cell-by-cell at indices \p i = 0, \p sampleStride, 2*\p sampleStride, ...
+///
+/// \param deckPath        path to a CO2STORE WATER+GAS deck written to disk
+/// \param expectedNumCells number of grid cells the deck describes
+/// \param sampleStride    stride for sampled correctness; 1 means full check
+/// \param measureTiming   if true, prints CPU and GPU wall-clock to stdout
+static void runIntensiveQuantitiesTestForDeck(const std::string& deckPath,
+                                              std::size_t expectedNumCells,
+                                              std::size_t sampleStride,
+                                              bool measureTiming,
+                                              bool checkDerivatives = false)
+{
+    Opm::resetLocale();
+    initSimulatorOnce();
+
+    using namespace Opm;
+    using Simulator = Opm::GetPropType<TypeTag, Opm::Properties::Simulator>;
+
+    const auto filenameArg = std::string{"--ecl-deck-file-name="} + deckPath;
+    const char* argv2[] = {
+        "test_gpuflowproblem",
+        filenameArg.c_str(),
+        "--check-satfunc-consistency=false",
+    };
+    Opm::setupParameters_<TypeTag>(/*argc=*/sizeof(argv2) / sizeof(argv2[0]),
+                                   argv2,
+                                   /*registerParams=*/false,
+                                   /*allowUnused=*/true,
+                                   /*handleHelp=*/false,
+                                   /*myRank=*/0);
+
+    Opm::FlowGenericVanguard::readDeck(deckPath);
+    auto sim = std::make_unique<Simulator>();
+
+    auto& cpuProblem = sim->problem();
+    auto& dynamicFluidSystem = FluidSystem::getNonStaticInstance();
+
+    auto dynamicGpuFluidSystemBuffer  = ::Opm::gpuistl::copy_to_gpu(dynamicFluidSystem);
+    auto dynamicGpuFluidSystemView = ::Opm::gpuistl::make_view(dynamicGpuFluidSystemBuffer);
+
+    // Place the FluidSystemView in unified memory so that the device-side
+    // BlackOilFluidState pointer dereference is valid both on host and on
+    // device.
+    using FluidSystemViewType = std::decay_t<decltype(dynamicGpuFluidSystemView)>;
+    FluidSystemViewType* managedFluidSystemView = nullptr;
+    OPM_GPU_SAFE_CALL(cudaMallocManaged(&managedFluidSystemView, sizeof(FluidSystemViewType)));
+    new (managedFluidSystemView) FluidSystemViewType(dynamicGpuFluidSystemView);
+
+    using CpuMaterialLawManager = typename Opm::GetProp<TypeTag, Opm::Properties::MaterialLaw>::EclMaterialLawManager;
+    using Traits = typename CpuMaterialLawManager::MaterialLaw::Traits;
+    using TwoPhaseTraits = Opm::TwoPhaseMaterialTraits<ScalarToUse,
+                                                       Traits::wettingPhaseIdx,
+                                                       Traits::nonWettingPhaseIdx>;
+    using GpuPiecewiseLinearParams = Opm::PiecewiseLinearTwoPhaseMaterialParams<
+        TwoPhaseTraits, Opm::gpuistl::GpuView<const ScalarToUse>>;
+    using GpuPiecewiseLinearLaw = Opm::PiecewiseLinearTwoPhaseMaterial<TwoPhaseTraits, GpuPiecewiseLinearParams>;
+    using GpuMaterialLawParams = Opm::EclTwoPhaseMaterialParams<
+        Traits, GpuPiecewiseLinearParams, GpuPiecewiseLinearParams, GpuPiecewiseLinearParams,
+        Opm::gpuistl::ValueAsPointer>;
+    using GpuMaterialLaw = Opm::EclTwoPhaseMaterial<
+        Traits, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw,
+        GpuMaterialLawParams>;
+    using GpuManagerBuffer = Opm::EclMaterialLaw::GpuManager<
+        Traits, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw,
+        Opm::gpuistl::GpuBuffer, GpuMaterialLaw>;
+    using GpuThermalManagerBuffer = Opm::EclThermalLaw::GpuManager<
+        ScalarToUse, FluidSystemViewType,
+        Opm::gpuistl::GpuBuffer, Opm::gpuistl::GpuView>;
+    using GpuProblemBuffer = Opm::GpuFlowProblem<ScalarToUse, GpuManagerBuffer, Opm::gpuistl::GpuBuffer, GpuThermalManagerBuffer>;
+
+    GpuProblemBuffer gpuProblemBuffer(cpuProblem);
+    auto gpuProblemView = Opm::gpuistl::make_view(gpuProblemBuffer);
+
+    const std::size_t numCells = cpuProblem.model().numGridDof();
+    BOOST_REQUIRE_EQUAL(numCells, expectedNumCells);
+    BOOST_REQUIRE_GT(numCells, 0u);
+
+    using PrimaryVariablesCpu = Opm::GetPropType<TypeTag, Opm::Properties::PrimaryVariables>;
+    using PrimaryVariablesGpu = Opm::BlackOilPrimaryVariables<TypeNacht, Opm::gpuistl::MiniVector>;
+    using IntensiveQuantitiesCpu = Opm::BlackOilIntensiveQuantities<TypeTag>;
+    using IntensiveQuantitiesGpu = Opm::BlackOilIntensiveQuantities<TypeNacht>;
+
+    PrimaryVariablesCpu primaryVariablesCpu;
+    primaryVariablesCpu.setPrimaryVarsMeaningPressure(Opm::BlackOil::PressureMeaning::Pg);
+    PrimaryVariablesGpu primaryVariablesGpu(primaryVariablesCpu);
+    std::vector<PrimaryVariablesGpu> hostPrimaryVariablesGpu(numCells, primaryVariablesGpu);
+    Opm::gpuistl::GpuBuffer<PrimaryVariablesGpu> primaryVariablesBuffer(hostPrimaryVariablesGpu);
+
+    IntensiveQuantitiesCpu cpuIntensiveQuantitiesPrototype;
+    IntensiveQuantitiesGpu gpuIntensiveQuantitiesPrototype = cpuIntensiveQuantitiesPrototype.template withOtherFluidSystem<TypeNacht>(*managedFluidSystemView);
+    if (measureTiming) {
+        std::cout << std::format("[timing] sizeof(IntensiveQuantitiesGpu)={}  sizeof(IntensiveQuantitiesCpu)={}  "
+                                 "sizeof(PrimaryVariablesGpu)={}  cells={}  "
+                                 "approx GPU mem for IQ buffer={:.2f} MiB\n",
+                                 sizeof(IntensiveQuantitiesGpu), sizeof(IntensiveQuantitiesCpu),
+                                 sizeof(PrimaryVariablesGpu), numCells,
+                                 (sizeof(IntensiveQuantitiesGpu) * numCells) / (1024.0 * 1024.0));
+    }
+    std::vector<IntensiveQuantitiesGpu> hostIntensiveQuantities(numCells, gpuIntensiveQuantitiesPrototype);
+    Opm::gpuistl::GpuBuffer<IntensiveQuantitiesGpu> intensiveQuantitiesBuffer(hostIntensiveQuantities);
+
+    const unsigned blockSize = 64u;
+    const unsigned gridSize = static_cast<unsigned>((numCells + blockSize - 1u) / blockSize);
+
+    // Time the GPU kernel using CUDA events (excludes the host-to-device
+    // setup and device-to-host copy already done via GpuBuffer ctors above).
+    cudaEvent_t eventStart{}, eventStop{};
+    OPM_GPU_SAFE_CALL(cudaEventCreate(&eventStart));
+    OPM_GPU_SAFE_CALL(cudaEventCreate(&eventStop));
+    OPM_GPU_SAFE_CALL(cudaEventRecord(eventStart));
+    updateAllCellsKernel<<<gridSize, blockSize>>>(
+        gpuProblemView,
+        Opm::gpuistl::GpuView<const PrimaryVariablesGpu>(primaryVariablesBuffer.data(), primaryVariablesBuffer.size()),
+        Opm::gpuistl::GpuView<IntensiveQuantitiesGpu>(intensiveQuantitiesBuffer.data(), intensiveQuantitiesBuffer.size()),
+        numCells);
+    OPM_GPU_SAFE_CALL(cudaEventRecord(eventStop));
+    OPM_GPU_SAFE_CALL(cudaEventSynchronize(eventStop));
+    OPM_GPU_SAFE_CALL(cudaGetLastError());
+    float gpuMilliseconds = 0.0f;
+    OPM_GPU_SAFE_CALL(cudaEventElapsedTime(&gpuMilliseconds, eventStart, eventStop));
+    OPM_GPU_SAFE_CALL(cudaEventDestroy(eventStart));
+    OPM_GPU_SAFE_CALL(cudaEventDestroy(eventStop));
+
+    // CPU reference: same per-cell update on the host side using the full
+    // CPU problem; time it with std::chrono.
+    std::vector<IntensiveQuantitiesCpu> cpuIntensiveQuantities(numCells);
+    const auto cpuT0 = std::chrono::steady_clock::now();
+    for (std::size_t i = 0; i < numCells; ++i) {
+        cpuIntensiveQuantities[i].updateSaturations(primaryVariablesCpu, 0, Opm::LinearizationType{});
+        cpuIntensiveQuantities[i].update(cpuProblem, primaryVariablesCpu, static_cast<unsigned>(i), 0);
+    }
+    const auto cpuT1 = std::chrono::steady_clock::now();
+    const double cpuMilliseconds =
+        std::chrono::duration<double, std::milli>(cpuT1 - cpuT0).count();
+
+    if (measureTiming) {
+        std::cout << std::format("[timing] cells={}  CPU={:.3f} ms  GPU(kernel)={:.3f} ms  "
+                                 "speedup={:.2f}x\n",
+                                 numCells, cpuMilliseconds, gpuMilliseconds,
+                                 cpuMilliseconds / gpuMilliseconds);
+    }
+
+    // Bring GPU intensive quantities back and compare cells (sampled by sampleStride).
+    std::vector<IntensiveQuantitiesGpu> gpuIntensiveQuantitiesHost(numCells, gpuIntensiveQuantitiesPrototype);
+    OPM_GPU_SAFE_CALL(cudaMemcpy(gpuIntensiveQuantitiesHost.data(),
+                                 intensiveQuantitiesBuffer.data(),
+                                 numCells * sizeof(IntensiveQuantitiesGpu),
+                                 cudaMemcpyDeviceToHost));
+    BOOST_REQUIRE_EQUAL(gpuIntensiveQuantitiesHost.size(), numCells);
+
+    constexpr double tol = 1e-6;
+    // Active phase indices for CO2STORE WATER+GAS (oil disabled).
+    constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
+    constexpr unsigned gasPhaseIdx   = FluidSystem::gasPhaseIdx;
+    const unsigned activePhases[] = {waterPhaseIdx, gasPhaseIdx};
+
+    std::size_t checked = 0;
+    std::size_t derivativeComparisons = 0;
+    for (std::size_t i = 0; i < numCells; i += sampleStride) {
+        const auto& cpuIQ = cpuIntensiveQuantities[i];
+        const auto& gpuIQ = gpuIntensiveQuantitiesHost[i];
+        const auto& cpuFluidState = cpuIQ.fluidState();
+        const auto& gpuFluidState = gpuIQ.fluidState();
+
+        // Per-phase fluid state quantities for the active phases. Restricted
+        // to fields that are stored directly on the FluidState (no call into
+        // the underlying FluidSystem), since the GPU-side FluidState's
+        // FluidSystem holds device pointers (GpuView) that are not
+        // dereferenceable on the host.
+        for (unsigned p : activePhases) {
+            checkValueAndDerivatives(cpuFluidState.saturation(p),
+                                     gpuFluidState.saturation(p),
+                                     tol, checkDerivatives, "saturation",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFluidState.pressure(p),
+                                     gpuFluidState.pressure(p),
+                                     tol, checkDerivatives, "pressure",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFluidState.density(p),
+                                     gpuFluidState.density(p),
+                                     tol, checkDerivatives, "density",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFluidState.invB(p),
+                                     gpuFluidState.invB(p),
+                                     tol, checkDerivatives, "invB",
+                                     derivativeComparisons);
+            // Mobility now goes through the opm-common EclTwoPhaseMaterial
+            // (relativePermeabilities) on both CPU and GPU, so the values
+            // must agree to the same tolerance as the rest of the IQ.
+            checkValueAndDerivatives(cpuIQ.mobility(p),
+                                     gpuIQ.mobility(p),
+                                     tol, checkDerivatives, "mobility",
+                                     derivativeComparisons);
+        }
+
+        // Scalar / per-cell quantities. Both CPU and GPU FluidState configs
+        // have enableVapwat=true and enableDisgasInWater=true so Rsw/Rvw are
+        // stored on both sides.
+        checkValueAndDerivatives(cpuFluidState.Rsw(), gpuFluidState.Rsw(),
+                                 tol, checkDerivatives, "Rsw",
+                                 derivativeComparisons);
+        checkValueAndDerivatives(cpuFluidState.Rvw(), gpuFluidState.Rvw(),
+                                 tol, checkDerivatives, "Rvw",
+                                 derivativeComparisons);
+        BOOST_CHECK_EQUAL(static_cast<unsigned>(cpuFluidState.pvtRegionIndex()),
+                          static_cast<unsigned>(gpuFluidState.pvtRegionIndex()));
+
+        checkValueAndDerivatives(cpuIQ.porosity(), gpuIQ.porosity(),
+                                 tol, checkDerivatives, "porosity",
+                                 derivativeComparisons);
+        BOOST_CHECK_CLOSE(static_cast<double>(cpuIQ.referencePorosity()),
+                          static_cast<double>(gpuIQ.referencePorosity()), tol);
+        checkValueAndDerivatives(cpuIQ.rockCompTransMultiplier(),
+                                 gpuIQ.rockCompTransMultiplier(),
+                                 tol, checkDerivatives, "rockCompTransMultiplier",
+                                 derivativeComparisons);
+
+        ++checked;
+    }
+    BOOST_TEST_MESSAGE("Per-cell GPU vs CPU IQ comparison: checked "
+                       << checked << " / " << numCells << " cells");
+    if (checkDerivatives) {
+        BOOST_TEST_MESSAGE("Derivative comparisons performed: " << derivativeComparisons);
+        // Guard against silent regressions: if checkDerivatives is requested
+        // but the helper never actually compared a derivative (e.g. because
+        // the IQ types degraded to plain scalars), fail loudly.
+        BOOST_REQUIRE_GT(derivativeComparisons, 0u);
+    }
+}
+
+/// RAII wrapper around a temporary file. The file is deleted when the
+/// object goes out of scope.
+struct TemporaryFile {
+    std::filesystem::path path;
+    explicit TemporaryFile(std::string_view filename)
+        : path(std::filesystem::temp_directory_path() / filename) {}
+    ~TemporaryFile() { std::filesystem::remove(path); }
+    TemporaryFile(const TemporaryFile&) = delete;
+    TemporaryFile& operator=(const TemporaryFile&) = delete;
+};
+
+/// Variant of \c runIntensiveQuantitiesTestForDeck that takes the per-cell
+/// primary variables from the simulator's initial (EQUIL-driven) solution
+/// vector instead of using a single uniform prototype. This exercises the
+/// exact code path used by the dispatcher in production:
+/// \c BlackOilPrimaryVariables<TypeNacht>(cpuPrimaryVariables[i]) -> GPU
+/// kernel update -> compare CPU vs GPU IQ field-by-field. \p sampleStride
+/// controls how often we check (1 means every cell).
+static void runIntensiveQuantitiesTestFromSimulatorSolution(const std::string& deckPath,
+                                                            std::size_t sampleStride)
+{
+    Opm::resetLocale();
+
+    using namespace Opm;
+    using LocalTypeTag    = Opm::Properties::TTag::FlowGasWaterEnergyProblemTestRealDeck;
+    using LocalGpuTypeTag = Opm::Properties::TTag::FlowGasWaterEnergyDummyProblemGPU;
+    using Simulator = Opm::GetPropType<LocalTypeTag, Opm::Properties::Simulator>;
+
+    // Reuse the global init: it registers parameters for both TypeTags so
+    // this test works whether it runs first or after another test in the
+    // same process (parameter registration is closed after the first
+    // setupParameters_ call).
+    initSimulatorOnce();
+
+    const auto filenameArg = std::string{"--ecl-deck-file-name="} + deckPath;
+    const char* argv2[] = {
+        "test_gpuflowproblem",
+        filenameArg.c_str(),
+        "--check-satfunc-consistency=false",
+        "--enable-tuning=false",
+    };
+    Opm::setupParameters_<LocalTypeTag>(/*argc=*/sizeof(argv2) / sizeof(argv2[0]),
+                                        argv2,
+                                        /*registerParams=*/false,
+                                        /*allowUnused=*/true,
+                                        /*handleHelp=*/false,
+                                        /*myRank=*/0);
+
+    Opm::FlowGenericVanguard::readDeck(deckPath);
+    auto sim = std::make_unique<Simulator>();
+
+    // The Simulator constructor only calls finishInit; the solution vector
+    // is not yet EQUIL-populated. Trigger initial-solution application so
+    // model().solution(0)[i] holds the real per-cell primary variables.
+    sim->model().applyInitialSolution();
+
+    auto& cpuProblem = sim->problem();
+    auto& dynamicFluidSystem = FluidSystem::getNonStaticInstance();
+
+    BOOST_TEST_MESSAGE(std::format(
+        "FluidSystem phase activation: static[O={}, W={}, G={}]  dynamic[O={}, W={}, G={}]",
+        FluidSystem::phaseIsActive(FluidSystem::oilPhaseIdx),
+        FluidSystem::phaseIsActive(FluidSystem::waterPhaseIdx),
+        FluidSystem::phaseIsActive(FluidSystem::gasPhaseIdx),
+        dynamicFluidSystem.phaseIsActive(FluidSystem::oilPhaseIdx),
+        dynamicFluidSystem.phaseIsActive(FluidSystem::waterPhaseIdx),
+        dynamicFluidSystem.phaseIsActive(FluidSystem::gasPhaseIdx)));
+
+    auto dynamicGpuFluidSystemBuffer  = ::Opm::gpuistl::copy_to_gpu(dynamicFluidSystem);
+    auto dynamicGpuFluidSystemView = ::Opm::gpuistl::make_view(dynamicGpuFluidSystemBuffer);
+
+    using FluidSystemViewType = std::decay_t<decltype(dynamicGpuFluidSystemView)>;
+    FluidSystemViewType* managedFluidSystemView = nullptr;
+    OPM_GPU_SAFE_CALL(cudaMallocManaged(&managedFluidSystemView, sizeof(FluidSystemViewType)));
+    new (managedFluidSystemView) FluidSystemViewType(dynamicGpuFluidSystemView);
+
+    BOOST_TEST_MESSAGE(std::format(
+        "GPU fluid-system view phase activation: O={} W={} G={}",
+        managedFluidSystemView->phaseIsActive(FluidSystem::oilPhaseIdx),
+        managedFluidSystemView->phaseIsActive(FluidSystem::waterPhaseIdx),
+        managedFluidSystemView->phaseIsActive(FluidSystem::gasPhaseIdx)));
+
+    using CpuMaterialLawManager = typename Opm::GetProp<LocalTypeTag, Opm::Properties::MaterialLaw>::EclMaterialLawManager;
+    using Traits = typename CpuMaterialLawManager::MaterialLaw::Traits;
+    using TwoPhaseTraits = Opm::TwoPhaseMaterialTraits<ScalarToUse,
+                                                       Traits::wettingPhaseIdx,
+                                                       Traits::nonWettingPhaseIdx>;
+    using GpuPiecewiseLinearParams = Opm::PiecewiseLinearTwoPhaseMaterialParams<
+        TwoPhaseTraits, Opm::gpuistl::GpuView<const ScalarToUse>>;
+    using GpuPiecewiseLinearLaw = Opm::PiecewiseLinearTwoPhaseMaterial<TwoPhaseTraits, GpuPiecewiseLinearParams>;
+    using GpuMaterialLawParams = Opm::EclTwoPhaseMaterialParams<
+        Traits, GpuPiecewiseLinearParams, GpuPiecewiseLinearParams, GpuPiecewiseLinearParams,
+        Opm::gpuistl::ValueAsPointer>;
+    using GpuMaterialLaw = Opm::EclTwoPhaseMaterial<
+        Traits, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw,
+        GpuMaterialLawParams>;
+    using GpuManagerBuffer = Opm::EclMaterialLaw::GpuManager<
+        Traits, GpuPiecewiseLinearLaw, GpuPiecewiseLinearLaw,
+        Opm::gpuistl::GpuBuffer, GpuMaterialLaw>;
+    using GpuThermalManagerBuffer = Opm::EclThermalLaw::GpuManager<
+        ScalarToUse, FluidSystemViewType,
+        Opm::gpuistl::GpuBuffer, Opm::gpuistl::GpuView>;
+    using GpuProblemBuffer = Opm::GpuFlowProblem<ScalarToUse, GpuManagerBuffer, Opm::gpuistl::GpuBuffer, GpuThermalManagerBuffer>;
+
+    GpuProblemBuffer gpuProblemBuffer(cpuProblem);
+    auto gpuProblemView = Opm::gpuistl::make_view(gpuProblemBuffer);
+
+    const std::size_t numCells = cpuProblem.model().numGridDof();
+    BOOST_REQUIRE_GT(numCells, 0u);
+    BOOST_TEST_MESSAGE("Real-deck test: numCells=" << numCells);
+
+    using PrimaryVariablesCpu = Opm::GetPropType<LocalTypeTag, Opm::Properties::PrimaryVariables>;
+    using PrimaryVariablesGpu = Opm::BlackOilPrimaryVariables<LocalGpuTypeTag, Opm::gpuistl::MiniVector>;
+    using IntensiveQuantitiesCpu = Opm::BlackOilIntensiveQuantities<LocalTypeTag>;
+    using IntensiveQuantitiesGpu = Opm::BlackOilIntensiveQuantities<LocalGpuTypeTag>;
+
+    // Pull the EQUIL-initialized per-cell primary variables straight from
+    // the simulator's solution vector and convert them to the GPU
+    // PrimaryVariables type cell-by-cell.
+    const auto& cpuSolution = cpuProblem.model().solution(/*timeIdx=*/0);
+    BOOST_REQUIRE_EQUAL(cpuSolution.size(), numCells);
+    std::vector<PrimaryVariablesCpu> cpuPrimaryVariables(numCells);
+    std::vector<PrimaryVariablesGpu> hostPrimaryVariablesGpu;
+    hostPrimaryVariablesGpu.reserve(numCells);
+    for (std::size_t i = 0; i < numCells; ++i) {
+        cpuPrimaryVariables[i] = cpuSolution[i];
+        hostPrimaryVariablesGpu.emplace_back(cpuPrimaryVariables[i]);
+    }
+    Opm::gpuistl::GpuBuffer<PrimaryVariablesGpu> primaryVariablesBuffer(hostPrimaryVariablesGpu);
+
+    // Diagnostic: distribution of pressure-meaning values across cells.
+    {
+        std::array<std::size_t, 3> meaningCounts{0, 0, 0};
+        for (std::size_t i = 0; i < numCells; ++i) {
+            const auto m = cpuPrimaryVariables[i].primaryVarsMeaningPressure();
+            switch (m) {
+                case Opm::BlackOil::PressureMeaning::Pg: ++meaningCounts[0]; break;
+                case Opm::BlackOil::PressureMeaning::Po: ++meaningCounts[1]; break;
+                case Opm::BlackOil::PressureMeaning::Pw: ++meaningCounts[2]; break;
+                default: break;
+            }
+        }
+        BOOST_TEST_MESSAGE(std::format(
+            "PressureMeaning distribution (cells={}): Pg={} Po={} Pw={}",
+            numCells, meaningCounts[0], meaningCounts[1], meaningCounts[2]));
+    }
+    if (numCells > 0) {
+        const auto& pv0 = cpuPrimaryVariables[0];
+        BOOST_TEST_MESSAGE(std::format(
+            "Cell 0 PV: meaning(P={},W={},G={}) pvtRegion={}",
+            static_cast<int>(pv0.primaryVarsMeaningPressure()),
+            static_cast<int>(pv0.primaryVarsMeaningWater()),
+            static_cast<int>(pv0.primaryVarsMeaningGas()),
+            pv0.pvtRegionIndex()));
+        for (unsigned k = 0; k < pv0.size(); ++k) {
+            BOOST_TEST_MESSAGE(std::format("  pv[{}] = {}", k, double(pv0[k])));
+        }
+    }
+
+
+    IntensiveQuantitiesCpu cpuIntensiveQuantitiesPrototype;
+    IntensiveQuantitiesGpu gpuIntensiveQuantitiesPrototype =
+        cpuIntensiveQuantitiesPrototype.template withOtherFluidSystem<TypeNacht>(*managedFluidSystemView);
+    std::vector<IntensiveQuantitiesGpu> hostIntensiveQuantities(numCells, gpuIntensiveQuantitiesPrototype);
+    Opm::gpuistl::GpuBuffer<IntensiveQuantitiesGpu> intensiveQuantitiesBuffer(hostIntensiveQuantities);
+
+    const unsigned blockSize = 64u;
+    const unsigned gridSize = static_cast<unsigned>((numCells + blockSize - 1u) / blockSize);
+
+    updateAllCellsKernel<<<gridSize, blockSize>>>(
+        gpuProblemView,
+        Opm::gpuistl::GpuView<const PrimaryVariablesGpu>(
+            primaryVariablesBuffer.data(), primaryVariablesBuffer.size()),
+        Opm::gpuistl::GpuView<IntensiveQuantitiesGpu>(
+            intensiveQuantitiesBuffer.data(), intensiveQuantitiesBuffer.size()),
+        numCells);
+    OPM_GPU_SAFE_CALL(cudaDeviceSynchronize());
+    OPM_GPU_SAFE_CALL(cudaGetLastError());
+
+    // CPU reference: use the IntensiveQuantities the simulator itself
+    // computed during invalidateAndUpdateIntensiveQuantities(0). This is the
+    // exact CPU value that the production dispatcher path would overlay
+    // GPU-computed BlackOil fields onto, so it is a meaningful reference for
+    // the GPU comparison without requiring the (diffusion-incompatible)
+    // simpler IQ::update overload to compile here.
+    sim->model().invalidateAndUpdateIntensiveQuantities(/*timeIdx=*/0);
+    std::vector<IntensiveQuantitiesCpu> cpuIntensiveQuantities(numCells);
+    for (std::size_t i = 0; i < numCells; ++i) {
+        const auto* cached = sim->model().cachedIntensiveQuantities(static_cast<unsigned>(i), 0);
+        BOOST_REQUIRE(cached != nullptr);
+        cpuIntensiveQuantities[i] = *cached;
+    }
+
+    std::vector<IntensiveQuantitiesGpu> gpuIntensiveQuantitiesHost(numCells, gpuIntensiveQuantitiesPrototype);
+    OPM_GPU_SAFE_CALL(cudaMemcpy(gpuIntensiveQuantitiesHost.data(),
+                                 intensiveQuantitiesBuffer.data(),
+                                 numCells * sizeof(IntensiveQuantitiesGpu),
+                                 cudaMemcpyDeviceToHost));
+
+    constexpr double tol = 1e-6;
+    constexpr unsigned waterPhaseIdx = FluidSystem::waterPhaseIdx;
+    constexpr unsigned gasPhaseIdx   = FluidSystem::gasPhaseIdx;
+    const unsigned activePhases[] = {waterPhaseIdx, gasPhaseIdx};
+
+    std::size_t checked = 0;
+    std::size_t derivativeComparisons = 0;
+    std::size_t firstBadCell = static_cast<std::size_t>(-1);
+    for (std::size_t i = 0; i < numCells; i += sampleStride) {
+        const auto& cpuIQ = cpuIntensiveQuantities[i];
+        const auto& gpuIQ = gpuIntensiveQuantitiesHost[i];
+        const auto& cpuFs = cpuIQ.fluidState();
+        const auto& gpuFs = gpuIQ.fluidState();
+
+        // Probe non-finite values explicitly; report the first offender so
+        // we can debug the production simulator failure mode.
+        for (unsigned p : activePhases) {
+            const double cpuRho = asDouble(cpuFs.density(p));
+            const double gpuRho = asDouble(gpuFs.density(p));
+            const double cpuP   = asDouble(cpuFs.pressure(p));
+            const double gpuP   = asDouble(gpuFs.pressure(p));
+            const double cpuS   = asDouble(cpuFs.saturation(p));
+            const double gpuS   = asDouble(gpuFs.saturation(p));
+            if (!std::isfinite(gpuRho) || !std::isfinite(gpuP) || !std::isfinite(gpuS)) {
+                if (firstBadCell == static_cast<std::size_t>(-1)) {
+                    firstBadCell = i;
+                    BOOST_TEST_MESSAGE(std::format(
+                        "First non-finite GPU IQ at cell {} (phase {}): "
+                        "S(cpu={}, gpu={}) P(cpu={}, gpu={}) rho(cpu={}, gpu={})",
+                        i, p, cpuS, gpuS, cpuP, gpuP, cpuRho, gpuRho));
+                }
+            }
+        }
+
+        for (unsigned p : activePhases) {
+            checkValueAndDerivatives(cpuFs.saturation(p), gpuFs.saturation(p),
+                                     tol, /*checkDerivatives=*/false, "saturation",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFs.pressure(p), gpuFs.pressure(p),
+                                     tol, /*checkDerivatives=*/false, "pressure",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFs.density(p), gpuFs.density(p),
+                                     tol, /*checkDerivatives=*/false, "density",
+                                     derivativeComparisons);
+            checkValueAndDerivatives(cpuFs.invB(p), gpuFs.invB(p),
+                                     tol, /*checkDerivatives=*/false, "invB",
+                                     derivativeComparisons);
+            // mobility is intentionally NOT compared: the GPU dispatcher
+            // does not overlay it (left to the CPU-computed value in
+            // production).
+        }
+        checkValueAndDerivatives(cpuFs.Rsw(), gpuFs.Rsw(),
+                                 tol, /*checkDerivatives=*/false, "Rsw",
+                                 derivativeComparisons);
+        checkValueAndDerivatives(cpuFs.Rvw(), gpuFs.Rvw(),
+                                 tol, /*checkDerivatives=*/false, "Rvw",
+                                 derivativeComparisons);
+        BOOST_CHECK_EQUAL(static_cast<unsigned>(cpuFs.pvtRegionIndex()),
+                          static_cast<unsigned>(gpuFs.pvtRegionIndex()));
+        checkValueAndDerivatives(cpuIQ.porosity(), gpuIQ.porosity(),
+                                 tol, /*checkDerivatives=*/false, "porosity",
+                                 derivativeComparisons);
+        BOOST_CHECK_CLOSE(static_cast<double>(cpuIQ.referencePorosity()),
+                          static_cast<double>(gpuIQ.referencePorosity()), tol);
+
+        // Thermal IQ fields: temperature in the fluid state, and the three
+        // BlackOilEnergyIntensiveQuantities scalars (rockInternalEnergy,
+        // totalThermalConductivity, rockFraction). For FullyImplicitThermal
+        // the GPU dispatcher writes all of these via overlayBlackOilFieldsFrom,
+        // so they should match the CPU value field-by-field.
+        checkValueAndDerivatives(cpuFs.temperature(/*phaseIdx=*/0),
+                                 gpuFs.temperature(/*phaseIdx=*/0),
+                                 tol, /*checkDerivatives=*/false, "temperature",
+                                 derivativeComparisons);
+        checkValueAndDerivatives(cpuIQ.rockInternalEnergy(),
+                                 gpuIQ.rockInternalEnergy(),
+                                 tol, /*checkDerivatives=*/false, "rockInternalEnergy",
+                                 derivativeComparisons);
+        checkValueAndDerivatives(cpuIQ.totalThermalConductivity(),
+                                 gpuIQ.totalThermalConductivity(),
+                                 tol, /*checkDerivatives=*/false, "totalThermalConductivity",
+                                 derivativeComparisons);
+        BOOST_CHECK_CLOSE(static_cast<double>(cpuIQ.rockFraction()),
+                          static_cast<double>(gpuIQ.rockFraction()), tol);
+        for (unsigned p : activePhases) {
+            checkValueAndDerivatives(cpuFs.enthalpy(p), gpuFs.enthalpy(p),
+                                     tol, /*checkDerivatives=*/false, "enthalpy",
+                                     derivativeComparisons);
+        }
+        ++checked;
+    }
+    BOOST_TEST_MESSAGE("Real-deck per-cell GPU vs CPU IQ comparison: checked "
+                       << checked << " / " << numCells << " cells");
+}
+
+BOOST_AUTO_TEST_CASE(TestRealDeckGpuVsCpuFromSimulatorSolution)
+{
+    // Drive the per-cell IQ update with the EQUIL-initialized primary
+    // variables of the production CO2STORE deck the user reports diverges
+    // when the dispatcher is enabled. This reproduces the exact code path
+    // taken by the dispatcher in production (per-cell PrimaryVariables
+    // upload + GPU update + readback) and compares every IQ field against
+    // a CPU reference, so we can identify which field becomes non-finite.
+    //
+    // NOTE: this test must run BEFORE the synthetic-deck tests because the
+    // BlackOilFluidSystem singleton is global state that gets re-set by
+    // every readDeck call; running this after the synthetic tests in the
+    // same process leaves the static FluidSystem in a state that is
+    // inconsistent with the per-cell GPU FluidSystem copy taken here.
+    const std::string deckPath = "/workspaces/opm/thecaseiwant/deck/THECASEIWANT.DATA";
+    if (!std::filesystem::exists(deckPath)) {
+        BOOST_TEST_MESSAGE("Skipping: deck not found at " << deckPath);
+        return;
+    }
+    runIntensiveQuantitiesTestFromSimulatorSolution(deckPath, /*sampleStride=*/1u);
+}
+
+BOOST_AUTO_TEST_CASE(TestInstantiateGpuFlowProblem)
+{
+    // Persist the in-source two-phase WATER+GAS+CO2STORE deck to a file so
+    // the standard Vanguard read path can ingest it.
+    const TemporaryFile tempFile("test_blackoilintensivequantities_gpu.DATA");
+    {
+        std::ofstream f(tempFile.path);
+        f << deckString1;
+    }
+    runIntensiveQuantitiesTestForDeck(tempFile.path.string(),
+                                      /*expectedNumCells=*/27u,
+                                      /*sampleStride=*/1u,
+                                      /*measureTiming=*/false);
+}
+
+BOOST_AUTO_TEST_CASE(TestPerformanceGpuVsCpuLargeGrid)
+{
+    // 100^3 = 1'000'000 cells. Build a CO2STORE WATER+GAS deck with a uniform
+    // unit-cube grid and EQUIL initialization, then time the per-cell IQ
+    // update on both GPU and CPU. Correctness is checked at every 1000th
+    // cell (1000 sample points) so the test stays reasonably fast.
+    // 64^3 = 262'144 cells. Build a CO2STORE WATER+GAS deck with a uniform
+    // unit-cube grid and EQUIL initialization, then time the per-cell IQ
+    // update on both GPU and CPU. Correctness is checked at every 256th cell
+    // (~1024 sample points) so the test stays reasonably fast.
+    //
+    // NOTE: the upper grid size here is bounded by the per-cell device
+    // allocation pattern in GpuEclMaterialLawManager (one cudaMalloc per
+    // piecewise-linear sample array per cell, i.e. ~12 cudaMalloc per cell).
+    // With ROCm's typical 4 KiB allocation granularity, ~16 GiB of VRAM
+    // limits us to a few hundred thousand cells; a 1M-cell deck would
+    // require consolidating per-cell sample buffers (left as a future
+    // optimisation, since for a homogeneous deck all cells share the same
+    // SGWFN table).
+    constexpr int dim = 64;
+    constexpr std::size_t expected =
+        static_cast<std::size_t>(dim) * dim * dim;
+    const TemporaryFile tempFile("test_blackoilintensivequantities_gpu_1M.DATA");
+    {
+        std::ofstream f(tempFile.path);
+        f << makeDeckString(dim, dim, dim);
+    }
+    runIntensiveQuantitiesTestForDeck(tempFile.path.string(),
+                                      /*expectedNumCells=*/expected,
+                                      /*sampleStride=*/256u,
+                                      /*measureTiming=*/true);
+}
+
+BOOST_AUTO_TEST_CASE(TestGpuVsCpuIntensiveQuantitiesEvaluationDerivatives)
+{
+    // Re-runs the small (3x3x3) WATER+GAS+CO2STORE deck used by
+    // TestInstantiateGpuFlowProblem, but in addition to the value of every
+    // intensive-quantity field this test also compares every partial
+    // derivative of the underlying DenseAd::Evaluation between CPU and GPU.
+    // This guarantees that the GPU material-law / fluid-system evaluation
+    // chain is differentiated identically to the CPU one.
+    const TemporaryFile tempFile("test_blackoilintensivequantities_gpu_deriv.DATA");
+    {
+        std::ofstream f(tempFile.path);
+        f << deckString1;
+    }
+    runIntensiveQuantitiesTestForDeck(tempFile.path.string(),
+                                      /*expectedNumCells=*/27u,
+                                      /*sampleStride=*/1u,
+                                      /*measureTiming=*/false,
+                                      /*checkDerivatives=*/true);
+}
diff --git a/tests/gpuistl/test_gpu_ecl_thermal_law_manager.cu b/tests/gpuistl/test_gpu_ecl_thermal_law_manager.cu
new file mode 100644
index 00000000000..290a64a9edd
--- /dev/null
+++ b/tests/gpuistl/test_gpu_ecl_thermal_law_manager.cu
@@ -0,0 +1,214 @@
+/*
+  Copyright TODO ADD YEAR AND NAME OF AUTHOR
+
+  This file is part of the Open Porous Media project (OPM).
+
+  OPM is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  OPM is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <config.h>
+
+#define BOOST_TEST_MODULE TestGpuEclThermalLawManager
+
+#include <boost/test/unit_test.hpp>
+
+#include <cuda_runtime.h>
+
+#include <opm/material/common/EnsureFinalized.hpp>
+#include <opm/material/common/Tabulated1DFunction.hpp>
+#include <opm/material/densead/Evaluation.hpp>
+#include <opm/material/fluidsystems/BlackOilDefaultFluidSystemIndices.hpp>
+#include <opm/material/thermal/EclSpecrockLaw.hpp>
+#include <opm/material/thermal/EclSpecrockLawParams.hpp>
+#include <opm/material/thermal/EclThconrLaw.hpp>
+#include <opm/material/thermal/EclThconrLawParams.hpp>
+
+#include <opm/material/thermal/GpuEclThermalLawManager.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuBuffer.hpp>
+#include <opm/simulators/linalg/gpuistl/GpuView.hpp>
+#include <opm/simulators/linalg/gpuistl/detail/gpu_safe_call.hpp>
+
+#include <array>
+#include <vector>
+
+namespace {
+
+using Scalar = double;
+
+// A minimal stand-in fluid system. The thermal-conduction law only ever
+// asks the fluid system whether the gas phase is active and what its
+// phase index is. Both are compile-time constants.
+struct DummyFluidSystem {
+    static constexpr int numPhases = 3;
+    static constexpr int gasPhaseIdx = 2;
+    OPM_HOST_DEVICE static constexpr bool phaseIsActive(int phaseIdx)
+    {
+        return phaseIdx == gasPhaseIdx;
+    }
+};
+
+// A minimal stand-in fluid state with just enough surface area to feed
+// EclSpecrockLaw / EclThconrLaw / their GPU counterparts.
+template <class ScalarT>
+struct DummyFluidState {
+    using ValueType = ScalarT;
+    ScalarT temperature_ = 0;
+    ScalarT gasSaturation_ = 0;
+
+    OPM_HOST_DEVICE ScalarT temperature(int /*phaseIdx*/) const { return temperature_; }
+    OPM_HOST_DEVICE ScalarT saturation(int /*phaseIdx*/) const { return gasSaturation_; }
+    OPM_HOST_DEVICE DummyFluidSystem fluidSystem() const { return DummyFluidSystem{}; }
+};
+
+using GpuSpecrockParamsBuf = Opm::EclSpecrockLawParams<Scalar, Opm::gpuistl::GpuView>;
+using GpuSpecrockParamsView = Opm::EclSpecrockLawParams<Scalar, Opm::gpuistl::GpuView>;
+using GpuSpecrockLawView = Opm::EclSpecrockLaw<Scalar, GpuSpecrockParamsView>;
+using GpuThconrLaw = Opm::EclThconrLaw<Scalar, DummyFluidSystem>;
+
+using ManagerCpu = Opm::EclThermalLaw::GpuManager<Scalar, DummyFluidSystem>;
+using ManagerBuf
+    = Opm::EclThermalLaw::GpuManager<Scalar, DummyFluidSystem, Opm::gpuistl::GpuBuffer, Opm::gpuistl::GpuView>;
+using ManagerView
+    = Opm::EclThermalLaw::GpuManager<Scalar, DummyFluidSystem, Opm::gpuistl::GpuView, Opm::gpuistl::GpuView>;
+
+// Kernel: per-cell, evaluate solid internal energy from the law manager
+// at the supplied temperature, and total thermal conductivity at the
+// supplied gas saturation.
+__global__ void evaluateThermalKernel(ManagerView view,
+                                      const Scalar* temperatures,
+                                      const Scalar* gasSaturations,
+                                      Scalar* outSolidEnergy,
+                                      Scalar* outConductivity,
+                                      std::size_t numCells)
+{
+    const std::size_t i =
+        static_cast<std::size_t>(blockIdx.x) * blockDim.x + threadIdx.x;
+    if (i >= numCells) {
+        return;
+    }
+    DummyFluidState<Scalar> fs;
+    fs.temperature_ = temperatures[i];
+    fs.gasSaturation_ = gasSaturations[i];
+
+    const auto solidEnergyParams = view.solidEnergyLawParams(static_cast<unsigned>(i));
+    outSolidEnergy[i] =
+        GpuSpecrockLawView::solidInternalEnergy(solidEnergyParams, fs);
+
+    const auto thermalConductionParams =
+        view.thermalConductionLawParams(static_cast<unsigned>(i));
+    outConductivity[i] =
+        GpuThconrLaw::thermalConductivity(thermalConductionParams, fs);
+}
+
+} // namespace
+
+BOOST_AUTO_TEST_CASE(SpecrockAndThconrEvaluateMatchesCpu)
+{
+    // -- Build a synthetic two-region SPECROCK plus per-cell THCONR setup
+    //    on the host. Cells 0..2 belong to region 0, cells 3..5 to region 1.
+    constexpr std::size_t numCells = 6;
+
+    const std::vector<Scalar> regionTemperatures0 = { 280.0, 320.0, 360.0, 400.0 };
+    const std::vector<Scalar> regionEnergies0     = { 0.0,   4.0e7, 9.0e7, 1.5e8 };
+    const std::vector<Scalar> regionTemperatures1 = { 280.0, 350.0, 420.0 };
+    const std::vector<Scalar> regionEnergies1     = { 0.0,   3.5e7, 8.4e7 };
+
+    // Build a host-side CPU manager directly from the basic constructor.
+    Opm::EclSpecrockLawParams<Scalar> region0Params;
+    region0Params.setSamples(regionTemperatures0, regionEnergies0);
+    Opm::EclSpecrockLawParams<Scalar> region1Params;
+    region1Params.setSamples(regionTemperatures1, regionEnergies1);
+
+    std::vector<Opm::EclSpecrockLawParams<Scalar>> cpuSolidEnergyParams;
+    cpuSolidEnergyParams.push_back(region0Params);
+    cpuSolidEnergyParams.push_back(region1Params);
+
+    std::vector<int> cpuElementToRegion(numCells);
+    for (std::size_t i = 0; i < numCells; ++i) {
+        cpuElementToRegion[i] = (i < 3) ? 0 : 1;
+    }
+
+    std::vector<Opm::EclThconrLawParams<Scalar>> cpuThermalConductionParams(numCells);
+    for (std::size_t i = 0; i < numCells; ++i) {
+        cpuThermalConductionParams[i].setReferenceTotalThermalConductivity(
+            100.0 + 5.0 * static_cast<Scalar>(i));
+        cpuThermalConductionParams[i].setDTotalThermalConductivity_dSg(
+            0.20 + 0.01 * static_cast<Scalar>(i));
+        cpuThermalConductionParams[i].finalize();
+    }
+
+    ManagerCpu cpuManager(std::move(cpuSolidEnergyParams),
+                          std::move(cpuElementToRegion),
+                          std::move(cpuThermalConductionParams));
+
+    // -- Upload to the GPU and create a non-owning view.
+    auto bufManager = Opm::gpuistl::copy_to_gpu(cpuManager);
+    auto viewManager = Opm::gpuistl::make_view(bufManager);
+
+    // -- Pick a per-cell test temperature and gas saturation each.
+    std::array<Scalar, numCells> hostTemperatures = {
+        290.0, 310.0, 355.0, 285.0, 360.0, 410.0
+    };
+    std::array<Scalar, numCells> hostGasSaturations = {
+        0.0, 0.1, 0.25, 0.5, 0.75, 0.99
+    };
+
+    // -- Run the kernel.
+    Scalar* dT = nullptr;
+    Scalar* dSg = nullptr;
+    Scalar* dEnergy = nullptr;
+    Scalar* dConductivity = nullptr;
+    OPM_GPU_SAFE_CALL(cudaMalloc(&dT, numCells * sizeof(Scalar)));
+    OPM_GPU_SAFE_CALL(cudaMalloc(&dSg, numCells * sizeof(Scalar)));
+    OPM_GPU_SAFE_CALL(cudaMalloc(&dEnergy, numCells * sizeof(Scalar)));
+    OPM_GPU_SAFE_CALL(cudaMalloc(&dConductivity, numCells * sizeof(Scalar)));
+    OPM_GPU_SAFE_CALL(cudaMemcpy(dT, hostTemperatures.data(),
+                                 numCells * sizeof(Scalar), cudaMemcpyHostToDevice));
+    OPM_GPU_SAFE_CALL(cudaMemcpy(dSg, hostGasSaturations.data(),
+                                 numCells * sizeof(Scalar), cudaMemcpyHostToDevice));
+
+    evaluateThermalKernel<<<1, 32>>>(viewManager, dT, dSg, dEnergy, dConductivity, numCells);
+    OPM_GPU_SAFE_CALL(cudaDeviceSynchronize());
+    OPM_GPU_SAFE_CALL(cudaGetLastError());
+
+    std::array<Scalar, numCells> hostEnergyResult {};
+    std::array<Scalar, numCells> hostConductivityResult {};
+    OPM_GPU_SAFE_CALL(cudaMemcpy(hostEnergyResult.data(), dEnergy,
+                                 numCells * sizeof(Scalar), cudaMemcpyDeviceToHost));
+    OPM_GPU_SAFE_CALL(cudaMemcpy(hostConductivityResult.data(), dConductivity,
+                                 numCells * sizeof(Scalar), cudaMemcpyDeviceToHost));
+
+    OPM_GPU_SAFE_CALL(cudaFree(dT));
+    OPM_GPU_SAFE_CALL(cudaFree(dSg));
+    OPM_GPU_SAFE_CALL(cudaFree(dEnergy));
+    OPM_GPU_SAFE_CALL(cudaFree(dConductivity));
+
+    // -- Compare against the CPU manager.
+    for (std::size_t i = 0; i < numCells; ++i) {
+        DummyFluidState<Scalar> fs;
+        fs.temperature_ = hostTemperatures[i];
+        fs.gasSaturation_ = hostGasSaturations[i];
+
+        const auto& cpuSolidParams =
+            cpuManager.solidEnergyLawParams(static_cast<unsigned>(i));
+        const Scalar cpuEnergy =
+            Opm::EclSpecrockLaw<Scalar>::solidInternalEnergy(cpuSolidParams, fs);
+        BOOST_CHECK_CLOSE(cpuEnergy, hostEnergyResult[i], 1e-9);
+
+        const auto& cpuConductionParams =
+            cpuManager.thermalConductionLawParams(static_cast<unsigned>(i));
+        const Scalar cpuConductivity =
+            GpuThconrLaw::thermalConductivity(cpuConductionParams, fs);
+        BOOST_CHECK_CLOSE(cpuConductivity, hostConductivityResult[i], 1e-9);
+    }
+}
diff --git a/tests/very_simple_deck.DATA b/tests/very_simple_deck.DATA
new file mode 100644
index 00000000000..8c0623914ab
--- /dev/null
+++ b/tests/very_simple_deck.DATA
@@ -0,0 +1,53 @@
+-- =============== RUNSPEC
+RUNSPEC
+DIMENS
+3 3 3 /
+EQLDIMS
+/
+TABDIMS
+/
+WATER
+GAS
+CO2STORE
+METRIC
+
+-- =============== GRID
+GRID
+GRIDFILE
+0 0 /
+DX
+27*1 /
+DY
+27*1 /
+DZ
+27*1 /
+TOPS
+9*0 /
+PERMX
+27*1013.25 /
+PORO
+27*0.25 /
+COPY
+PERMX PERMY /
+PERMX PERMZ /
+/
+
+-- =============== PROPS
+PROPS
+SGWFN
+0.000000E+00 0.000000E+00 1.000000E+00 3.060000E-02
+1.000000E+00 1.000000E+00 0.000000E+00 3.060000E-01 /
+
+-- =============== SOLUTION
+SOLUTION
+RPTRST
+'BASIC=0' /
+EQUIL
+0 300 100 0 0 0 1 1 0 /
+
+-- =============== SCHEDULE
+SCHEDULE
+RPTRST
+'BASIC=0' /
+TSTEP
+1 /