diff --git a/dumux/common/fixedlengthspline_.hh b/dumux/common/fixedlengthspline_.hh
index 54311f6f12c196200231fc5086410cfa692f82f3..bb939e5a183e00ebe2a970521a4fe31fc0102e06 100644
--- a/dumux/common/fixedlengthspline_.hh
+++ b/dumux/common/fixedlengthspline_.hh
@@ -25,7 +25,6 @@
 
 #include <dune/common/fvector.hh>
 #include <dune/common/fmatrix.hh>
-#include <dune/common/tuples.hh>
 #include <dune/istl/btdmatrix.hh>
 
 #include "splinecommon_.hh"
@@ -185,8 +184,8 @@ public:
      * This method uses a single STL-compatible container of sampling
      * points, which are assumed to be tuple-like objects storing the
      * X and Y coordinates.  "tuple-like" means that the objects
-     * provide access to the x values via Dune::get<0>(obj) and to the
-     * y value via Dune::get<1>(obj) (e.g. std::tuple or
+     * provide access to the x values via std::get<0>(obj) and to the
+     * y value via std::get<1>(obj) (e.g. std::tuple or
      * std::pair). "STL-compatible" means that the container provides
      * access to iterators using the begin(), end() methods and also
      * provides a size() method. Also, the number of entries in the X
@@ -202,8 +201,8 @@ public:
         typename XYContainer::const_iterator it = points.begin();
         typename XYContainer::const_iterator endIt = points.end();
         for (int i = 0; it != endIt; ++i, ++it) {
-            xPos_[i] = Dune::get<0>(*it);
-            yPos_[i] = Dune::get<1>(*it);
+            xPos_[i] = std::get<0>(*it);
+            yPos_[i] = std::get<1>(*it);
         }
 
         // make a full spline
@@ -326,8 +325,8 @@ public:
      * This method uses a single STL-compatible container of sampling
      * points, which are assumed to be tuple-like objects storing the
      * X and Y coordinates.  "tuple-like" means that the objects
-     * provide access to the x values via Dune::get<0>(obj) and to the
-     * y value via Dune::get<1>(obj) (e.g. std::tuple or
+     * provide access to the x values via std::get<0>(obj) and to the
+     * y value via std::get<1>(obj) (e.g. std::tuple or
      * std::pair). "STL-compatible" means that the container provides
      * access to iterators using the begin(), end() methods and also
      * provides a size() method. Also, the number of entries in the X
@@ -341,8 +340,8 @@ public:
         typename XYContainer::const_iterator it = points.begin();
         typename XYContainer::const_iterator endIt = points.end();
         for (int i = 0; it != endIt; ++i, ++it) {
-            xPos_[i] = Dune::get<0>(*it);
-            yPos_[i] = Dune::get<1>(*it);
+            xPos_[i] = std::get<0>(*it);
+            yPos_[i] = std::get<1>(*it);
         }
 
         // make a natural spline
diff --git a/dumux/common/spline.hh b/dumux/common/spline.hh
index 96ee1f0bf3969df03ab46c05eb431acffe2150cc..a42ada6b09fe66b140075394c5ae75da7e362f3d 100644
--- a/dumux/common/spline.hh
+++ b/dumux/common/spline.hh
@@ -475,10 +475,10 @@ public:
         typename TupleContainer::const_iterator it1 = it0;
         ++it1;
 
-        set(Dune::get<0>(*it0),
-            Dune::get<1>(*it0),
-            Dune::get<0>(*it1),
-            Dune::get<1>(*it1),
+        set(std::get<0>(*it0),
+            std::get<1>(*it0),
+            std::get<0>(*it1),
+            std::get<1>(*it1),
             m0, m1);
     }
 
diff --git a/dumux/common/splinecommon_.hh b/dumux/common/splinecommon_.hh
index 4dab68c951a5215c659bb6ae72b10167ffd8876e..d9edd7f6860543e8fbdba25d7417fc6d41562746 100644
--- a/dumux/common/splinecommon_.hh
+++ b/dumux/common/splinecommon_.hh
@@ -27,7 +27,6 @@
 #include <cassert>
 
 #include <dune/common/exceptions.hh>
-#include <dune/common/tuples.hh>
 #include <dune/common/float_cmp.hh>
 
 #include "valgrind.hh"
@@ -366,7 +365,7 @@ protected:
         ListIterator it = srcBegin;
         ++it;
         bool reverse = false;
-        if (Dune::get<0>(*srcBegin) > Dune::get<0>(*it))
+        if (std::get<0>(*srcBegin) > std::get<0>(*it))
             reverse = true;
         --it;
 
@@ -375,8 +374,8 @@ protected:
             int idx = i;
             if (reverse)
                 idx = numSamples - i - 1;
-            destX[i] = Dune::get<0>(*it);
-            destY[i] = Dune::get<1>(*it);
+            destX[i] = std::get<0>(*it);
+            destY[i] = std::get<1>(*it);
         }
     }
 
diff --git a/dumux/common/variablelengthspline_.hh b/dumux/common/variablelengthspline_.hh
index be8adf10f68edd07b160c747776b2336ab40620b..80877c7cf2da470fc688fbcab24ee7290150c16d 100644
--- a/dumux/common/variablelengthspline_.hh
+++ b/dumux/common/variablelengthspline_.hh
@@ -25,7 +25,6 @@
 
 #include <dune/common/fvector.hh>
 #include <dune/common/fmatrix.hh>
-#include <dune/common/tuples.hh>
 #include <dune/istl/bvector.hh>
 #include <dune/istl/btdmatrix.hh>
 
@@ -187,8 +186,8 @@ public:
      * This method uses a single STL-compatible container of sampling
      * points, which are assumed to be tuple-like objects storing the
      * X and Y coordinates.  "tuple-like" means that the objects
-     * provide access to the x values via Dune::get<0>(obj) and to the
-     * y value via Dune::get<1>(obj) (e.g. std::tuple or
+     * provide access to the x values via std::get<0>(obj) and to the
+     * y value via std::get<1>(obj) (e.g. std::tuple or
      * std::pair). "STL-compatible" means that the container provides
      * access to iterators using the begin(), end() methods and also
      * provides a size() method. Also, the number of entries in the X
@@ -204,8 +203,8 @@ public:
         typename XYContainer::const_iterator it = points.begin();
         typename XYContainer::const_iterator endIt = points.end();
         for (int i = 0; it != endIt; ++i, ++it) {
-            xPos_[i] = Dune::get<0>(*it);
-            yPos_[i] = Dune::get<1>(*it);
+            xPos_[i] = std::get<0>(*it);
+            yPos_[i] = std::get<1>(*it);
         }
 
         // make a full spline
@@ -334,8 +333,8 @@ public:
      * This method uses a single STL-compatible container of sampling
      * points, which are assumed to be tuple-like objects storing the
      * X and Y coordinates.  "tuple-like" means that the objects
-     * provide access to the x values via Dune::get<0>(obj) and to the
-     * y value via Dune::get<1>(obj) (e.g. std::tuple or
+     * provide access to the x values via std::get<0>(obj) and to the
+     * y value via std::get<1>(obj) (e.g. std::tuple or
      * std::pair). "STL-compatible" means that the container provides
      * access to iterators using the begin(), end() methods and also
      * provides a size() method. Also, the number of entries in the X
@@ -349,8 +348,8 @@ public:
         typename XYContainer::const_iterator it = points.begin();
         typename XYContainer::const_iterator endIt = points.end();
         for (int i = 0; it != endIt; ++i, ++it) {
-            xPos_[i] = Dune::get<0>(*it);
-            yPos_[i] = Dune::get<1>(*it);
+            xPos_[i] = std::get<0>(*it);
+            yPos_[i] = std::get<1>(*it);
         }
 
         // make a natural spline
diff --git a/dumux/linear/overlappingbcrsmatrix.hh b/dumux/linear/overlappingbcrsmatrix.hh
index 1aa8dee459249025e7bfb434e6a25ccb1ba2a1cb..1946d3326cf21385b8e6d9f79f623ef6a4f5a7b5 100644
--- a/dumux/linear/overlappingbcrsmatrix.hh
+++ b/dumux/linear/overlappingbcrsmatrix.hh
@@ -314,7 +314,7 @@ private:
         typename ForeignOverlapWithPeer::const_iterator endIt = peerOverlap.end();
         int i = 0;
         for (; it != endIt; ++it, ++i) {
-            int rowIdx = Dune::get<0>(*it);
+            int rowIdx = std::get<0>(*it);
             assert(overlap_->isDomesticIndexFor(peerRank, rowIdx));
 
             typedef typename BCRSMatrix::ConstColIterator ColIt;
@@ -342,7 +342,7 @@ private:
         i = 0;
         it = peerOverlap.begin();
         for (; it != endIt; ++it) {
-            int rowIdx = Dune::get<0>(*it);
+            int rowIdx = std::get<0>(*it);
             assert(overlap_->isDomesticIndexFor(peerRank, rowIdx));
 
             typedef typename BCRSMatrix::ConstColIterator ColIt;