--- a/Makefile.in
+++ b/Makefile.in
@@ -1096,8 +1096,7 @@
 	numeric/interval.hpp \
 	LICENSE_1_0.txt \
 	limits.hpp non_type.hpp type.hpp
-THIRDHDR = \
-	$(BOOSTHDR:%=gecode/third-party/boost/%)
+THIRDHDR =
 
 #
 # COLLECTING ALL
--- a/gecode/float.hh
+++ b/gecode/float.hh
@@ -77,7 +77,7 @@
 #endif
 
 // Include interval implementation
-#include <gecode/third-party/boost/numeric/interval.hpp>
+#include <boost/numeric/interval.hpp>
 
 /**
  * \namespace Gecode::Float
@@ -135,7 +135,7 @@
    *
    */
   /// Rounding operations that keep upward mode between calls
-  typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
+  typedef boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
     RoundingControl;
 
   /**
@@ -266,7 +266,7 @@
    * \ingroup TaskModelFloatVars
    */
   class Rounding : public
-    gecode_boost::numeric::interval_lib::save_state<RoundingBase> {};
+    boost::numeric::interval_lib::save_state<RoundingBase> {};
 
 
 }}
@@ -410,11 +410,11 @@
     /// Used rounding policies
     typedef Float::Rounding R;
     /// Used checking policy
-    typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum> P;
+    typedef boost::numeric::interval_lib::checking_strict<FloatNum> P;
     /// Implementation type for float value
-    typedef gecode_boost::numeric::interval
+    typedef boost::numeric::interval
       <FloatNum,
-       gecode_boost::numeric::interval_lib::policies<R, P> >
+       boost::numeric::interval_lib::policies<R, P> >
     FloatValImpType;
     /// Implementation of float value
     FloatValImpType x;
--- a/gecode/float/num.hpp
+++ b/gecode/float/num.hpp
@@ -35,27 +35,27 @@
 
   forceinline FloatNum
   pi_half_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_half_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
   }
   forceinline FloatNum
   pi_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
   }
   forceinline FloatNum
   pi_twice_lower(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
   }
   forceinline FloatNum
   pi_twice_upper(void) {
-    return gecode_boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
+    return boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
   }
 }
 
--- a/gecode/float/val.hpp
+++ b/gecode/float/val.hpp
@@ -76,7 +76,7 @@
   }
   forceinline FloatNum
   FloatVal::size(void) const {
-    return gecode_boost::numeric::width(x);
+    return boost::numeric::width(x);
   }
   forceinline FloatNum
   FloatVal::med(void) const {
@@ -86,20 +86,20 @@
 
   forceinline bool
   FloatVal::tight(void) const {
-    return (gecode_boost::numeric::singleton(x) ||
+    return (boost::numeric::singleton(x) ||
             (nextafter(x.lower(),x.upper()) == x.upper()));
   }
   forceinline bool
   FloatVal::singleton(void) const {
-    return gecode_boost::numeric::singleton(x);
+    return boost::numeric::singleton(x);
   }
   forceinline bool
   FloatVal::in(FloatNum n) const {
-    return gecode_boost::numeric::in(n,x);
+    return boost::numeric::in(n,x);
   }
   forceinline bool
   FloatVal::zero_in(void) const {
-    return gecode_boost::numeric::zero_in(x);
+    return boost::numeric::zero_in(x);
   }
 
   forceinline FloatVal
@@ -108,17 +108,17 @@
   }
   forceinline FloatVal
   FloatVal::pi_half(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi_half<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi_half<FloatValImpType>());
     return p;
   }
   forceinline FloatVal
   FloatVal::pi(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi<FloatValImpType>());
     return p;
   }
   forceinline FloatVal
   FloatVal::pi_twice(void) {
-    FloatVal p(gecode_boost::numeric::interval_lib::pi_twice<FloatValImpType>());
+    FloatVal p(boost::numeric::interval_lib::pi_twice<FloatValImpType>());
     return p;
   }
 
@@ -227,7 +227,7 @@
   operator <(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x < y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -235,7 +235,7 @@
   operator <(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x < y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -244,7 +244,7 @@
   operator <=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x <= y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -252,7 +252,7 @@
   operator <=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x <= y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -261,7 +261,7 @@
   operator >(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x > y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -269,7 +269,7 @@
   operator >(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x > y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -278,7 +278,7 @@
   operator >=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x >= y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -286,7 +286,7 @@
   operator >=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x >= y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -295,13 +295,13 @@
   operator ==(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x == y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
   inline bool
   operator ==(const FloatVal& x, const FloatNum& y) {
-    if (!gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
+    if (!boost::numeric::interval_lib::checking_strict<FloatNum>
         ::is_empty(x.x.lower(), x.x.upper())) {
       if ((x.x.lower() == y) && (x.x.upper() == y))
         return true;
@@ -318,7 +318,7 @@
   operator !=(const FloatVal& x, const FloatVal& y) {
     try {
       return x.x != y.x;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
@@ -326,7 +326,7 @@
   operator !=(const FloatVal& x, const FloatNum& y) {
     try {
       return x.x != y;
-    } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
+    } catch (boost::numeric::interval_lib::comparison_error&) {
       return false;
     }
   }
--- a/gecode/float/arithmetic/pow-nroot.hpp
+++ b/gecode/float/arithmetic/pow-nroot.hpp
@@ -70,9 +70,9 @@
   /// Return a downward-rounded positive integer power
   forceinline FloatNum
   positive_pow_down(FloatNum x, int n) {
-    typedef gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum>
+    typedef boost::numeric::interval_lib::rounded_arith_std<FloatNum>
       DirectRoundingBase;
-    typedef gecode_boost::numeric::interval_lib::save_state<DirectRoundingBase>
+    typedef boost::numeric::interval_lib::save_state<DirectRoundingBase>
       DirectRounding;
     DirectRounding r;
     FloatNum y = 1.0;
--- a/test/float/arithmetic.cpp
+++ b/test/float/arithmetic.cpp
@@ -57,19 +57,19 @@
      private:
        template<class Policy>
        static bool boost_operations(void) {
-         typedef gecode_boost::numeric::interval<Gecode::FloatNum,
-           gecode_boost::numeric::interval_lib::policies<Policy,
-             gecode_boost::numeric::interval_lib::checking_strict<
+         typedef boost::numeric::interval<Gecode::FloatNum,
+           boost::numeric::interval_lib::policies<Policy,
+             boost::numeric::interval_lib::checking_strict<
                Gecode::FloatNum>>> Interval;
          const int mode = std::fegetround();
          // Boost fmod uses its unprotected policy for nested arithmetic.
-         const Interval remainder = gecode_boost::numeric::fmod(
+         const Interval remainder = boost::numeric::fmod(
            Interval(5.0,5.0),Interval(3.0,3.0));
          bool result = (remainder.lower() == 2.0) &&
            (remainder.upper() == 2.0) && (std::fegetround() == mode);
 #ifdef GECODE_HAS_MPFR
          // Unprotected policies must retain Gecode's MPFR operations.
-         const Interval sine = gecode_boost::numeric::sin(Interval(0.5));
+         const Interval sine = boost::numeric::sin(Interval(0.5));
          result &= (sine.lower() <= 0.479425538604203) &&
            (sine.upper() >= 0.479425538604203) &&
            (std::fegetround() == mode);
@@ -104,7 +104,7 @@
              result &= std::fegetround() == enclosing;
              result &= boost_operations<Gecode::Float::Rounding>();
              result &= boost_operations<
-               gecode_boost::numeric::interval_lib::save_state<
+               boost::numeric::interval_lib::save_state<
                  Gecode::Float::Rounding>>();
            }
            if (std::fegetround() != mode) {
