diff --git a/CMakeLists.txt b/CMakeLists.txt
index ea39ad4..948bddb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,19 +32,19 @@
 cmake_minimum_required(VERSION 3.5)
 cmake_policy(VERSION 3.5)
 
-# Set the C++ version (must be >= C++11) when compiling Ceres.
+# Set the C++ version (must be >= C++14) when compiling Ceres.
 #
 # Reflect a user-specified (via -D) CMAKE_CXX_STANDARD if present, otherwise
-# default to C++11.
+# default to C++14.
 set(DEFAULT_CXX_STANDARD ${CMAKE_CXX_STANDARD})
 if (NOT DEFAULT_CXX_STANDARD)
-  set(DEFAULT_CXX_STANDARD 11)
+  set(DEFAULT_CXX_STANDARD 14)
 endif()
 set(CMAKE_CXX_STANDARD ${DEFAULT_CXX_STANDARD} CACHE STRING
-  "C++ standard (minimum 11)" FORCE)
+  "C++ standard (minimum 14)" FORCE)
 # Restrict CMAKE_CXX_STANDARD to the valid versions permitted and ensure that
 # if one was forced via -D that it is in the valid set.
-set(ALLOWED_CXX_STANDARDS 11 14 17 20)
+set(ALLOWED_CXX_STANDARDS 14 17 20)
 set_property(CACHE CMAKE_CXX_STANDARD PROPERTY STRINGS ${ALLOWED_CXX_STANDARDS})
 list(FIND ALLOWED_CXX_STANDARDS ${CMAKE_CXX_STANDARD} POSITION)
 if (POSITION LESS 0)
@@ -56,11 +56,13 @@
 set(CMAKE_CXX_STANDARD_REQUIRED ON CACHE BOOL "")
 mark_as_advanced(CMAKE_CXX_STANDARD_REQUIRED)
 
-# MSVC versions < 2013 did not fully support >= C++11.
+# MSVC versions < 2015 did not fully support >= C++14, and technically even
+# 2015 did not support a couple of smaller features
 if (CMAKE_CXX_COMPILER_ID MATCHES MSVC AND
-    CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+    CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0)
   message(FATAL_ERROR "Invalid CMAKE_CXX_COMPILER_VERSION: "
-    "${CMAKE_CXX_COMPILER_VERSION}. Ceres requires at least MSVC 2013 Update 4+")
+    "${CMAKE_CXX_COMPILER_VERSION}. Ceres requires at least MSVC 2015 for "
+    "C++14 support.")
 endif()
 
 # On macOS, add the Homebrew prefix (with appropriate suffixes) to the
diff --git a/bazel/ceres.bzl b/bazel/ceres.bzl
index e58f32e..9f12f1b 100644
--- a/bazel/ceres.bzl
+++ b/bazel/ceres.bzl
@@ -196,7 +196,7 @@
             "CERES_NO_ACCELERATE_SPARSE",
             "CERES_NO_LAPACK",
             "CERES_USE_EIGEN_SPARSE",
-            "CERES_USE_CXX11_THREADS",
+            "CERES_USE_CXX_THREADS",
         ],
         includes = [
             "config",
diff --git a/cmake/CeresCompileOptionsToComponents.cmake b/cmake/CeresCompileOptionsToComponents.cmake
index ccf0fa2..5be0fb2 100644
--- a/cmake/CeresCompileOptionsToComponents.cmake
+++ b/cmake/CeresCompileOptionsToComponents.cmake
@@ -84,6 +84,8 @@
     CERES_RESTRICT_SCHUR_SPECIALIZATION "SchurSpecializations")
   add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
     CERES_USE_OPENMP "OpenMP;Multithreading")
+  add_to_output_if_found(CURRENT_CERES_COMPILE_OPTIONS ${CERES_COMPONENTS_VAR}
+    CERES_USE_CXX_THREADS "Multithreading")
   # Remove duplicates of SparseLinearAlgebraLibrary if multiple sparse backends
   # are present.
   list(REMOVE_DUPLICATES ${CERES_COMPONENTS_VAR})
diff --git a/cmake/CeresThreadingModels.cmake b/cmake/CeresThreadingModels.cmake
index 24e8aab..571dd7d 100644
--- a/cmake/CeresThreadingModels.cmake
+++ b/cmake/CeresThreadingModels.cmake
@@ -29,7 +29,7 @@
 # Author: alexs.mac@gmail.com (Alex Stewart)
 
 # Ordered by expected preference.
-set(CERES_THREADING_MODELS "CXX11_THREADS;OPENMP;NO_THREADS")
+set(CERES_THREADING_MODELS "CXX_THREADS;OPENMP;NO_THREADS")
 
 function(find_available_ceres_threading_models CERES_THREADING_MODELS_AVAILABLE_VAR)
   set(CERES_THREADING_MODELS_AVAILABLE ${CERES_THREADING_MODELS})
@@ -48,7 +48,7 @@
 endfunction()
 
 macro(set_ceres_threading_model_to_cxx11_threads)
-  list(APPEND CERES_COMPILE_OPTIONS CERES_USE_CXX11_THREADS)
+  list(APPEND CERES_COMPILE_OPTIONS CERES_USE_CXX_THREADS)
 endmacro()
 
 macro(set_ceres_threading_model_to_openmp)
@@ -63,7 +63,7 @@
 endmacro()
 
 macro(set_ceres_threading_model CERES_THREADING_MODEL_TO_SET)
-  if ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "CXX11_THREADS")
+  if ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "CXX_THREADS")
     set_ceres_threading_model_to_cxx11_threads()
   elseif ("${CERES_THREADING_MODEL_TO_SET}" STREQUAL "OPENMP")
     set_ceres_threading_model_to_openmp()
diff --git a/cmake/config.h.in b/cmake/config.h.in
index 1caacfe..4a516f6 100644
--- a/cmake/config.h.in
+++ b/cmake/config.h.in
@@ -73,10 +73,10 @@
 
 // If defined, Ceres was compiled without multithreading support.
 @CERES_NO_THREADS@
-// If defined Ceres was compiled with OpenMP multithreading support.
+// If defined Ceres was compiled with OpenMP multithreading.
 @CERES_USE_OPENMP@
-// If defined Ceres was compiled with C++11 thread support.
-@CERES_USE_CXX11_THREADS@
+// If defined Ceres was compiled with modern C++ multithreading.
+@CERES_USE_CXX_THREADS@
 
 // If defined, Ceres was built as a shared library.
 @CERES_USING_SHARED_LIBRARY@
diff --git a/docs/source/features.rst b/docs/source/features.rst
index 348511d..724d6dc 100644
--- a/docs/source/features.rst
+++ b/docs/source/features.rst
@@ -54,8 +54,9 @@
     of Non-linear Conjugate Gradients, BFGS and LBFGS.
 
 * **Speed** - Ceres Solver has been extensively optimized, with C++
-  templating, hand written linear algebra routines and OpenMP or C++11 threads
-  based multithreading of the Jacobian evaluation and the linear solvers.
+  templating, hand written linear algebra routines and OpenMP or
+  modern C++ threads based multithreading of the Jacobian evaluation
+  and the linear solvers.
 
 * **Solution Quality** Ceres is the `best performing`_ solver on the NIST
   problem set used by Mondragon and Borchers for benchmarking
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
index d0e458f..2d844cb 100644
--- a/docs/source/installation.rst
+++ b/docs/source/installation.rst
@@ -23,9 +23,8 @@
 
   .. NOTE ::
 
-    All versions of Ceres > 1.14 require a **fully C++11-compliant**
-    compiler.  In versions <= 1.14, C++11 was an optional requirement
-    controlled by the ``CXX11 [Default: OFF]`` build option.
+    Starting with v2.0 Ceres requires a **fully C++14-compliant**
+    compiler.  In versions <= 1.14, C++11 was an optional requirement.
 
 Ceres relies on a number of open source libraries, some of which are
 optional. For details on customizing the build process, see
@@ -378,7 +377,7 @@
   <https://github.com/tbennun/ceres-windows>`_ for Ceres Solver by Tal
   Ben-Nun.
 
-On Windows, we support building with Visual Studio 2013 Release 4 or newer. Note
+On Windows, we support building with Visual Studio 2015.2 of newer. Note
 that the Windows port is less featureful and less tested than the
 Linux or Mac OS X versions due to the lack of an officially supported
 way of building SuiteSparse and CXSparse.  There are however a number
@@ -709,7 +708,7 @@
    gains in the ``SPARSE_SCHUR`` solver, you can disable some of the
    template specializations by turning this ``OFF``.
 
-#. ``CERES_THREADING_MODEL [Default: CXX11_THREADS > OPENMP > NO_THREADS]``:
+#. ``CERES_THREADING_MODEL [Default: CXX_THREADS > OPENMP > NO_THREADS]``:
    Multi-threading backend Ceres should be compiled with.  This will
    automatically be set to only accept the available subset of threading
    options in the CMake GUI.
@@ -904,8 +903,6 @@
 #. ``Multithreading``: Ceres built with *a* multithreading library.
    This is equivalent to (``CERES_THREAD != NO_THREADS``).
 
-#. ``C++11``: Ceres built with C++11.
-
 To specify one/multiple Ceres components use the ``COMPONENTS`` argument to
 `find_package()
 <http://www.cmake.org/cmake/help/v3.2/command/find_package.html>`_ like so:
diff --git a/docs/source/nnls_solving.rst b/docs/source/nnls_solving.rst
index afe5546..592ee41 100644
--- a/docs/source/nnls_solving.rst
+++ b/docs/source/nnls_solving.rst
@@ -2226,7 +2226,7 @@
    Number of threads actually used by the solver for Jacobian and
    residual evaluation. This number is not equal to
    :member:`Solver::Summary::num_threads_given` if none of `OpenMP`
-   or `CXX11_THREADS` is available.
+   or `CXX_THREADS` is available.
 
 .. member:: LinearSolverType Solver::Summary::linear_solver_type_given
 
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index a6b3f5d..27e736a 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -52,9 +52,7 @@
 
 add_executable(curve_fitting_c curve_fitting.c)
 target_link_libraries(curve_fitting_c Ceres::ceres)
-# Force CMake to link curve_fitting_c using the C linker, this is important
-# when Ceres was compiled using C++11 to ensure that -std=c++11 is not passed
-# through.
+# Force CMake to link curve_fitting_c using the C linker.
 set_target_properties(curve_fitting_c PROPERTIES LINKER_LANGUAGE C)
 # As this is a C file #including <math.h> we have to explicitly add the math
 # library (libm). Although some compilers (dependent upon options) will accept
diff --git a/include/ceres/cost_function_to_functor.h b/include/ceres/cost_function_to_functor.h
index cbd6186..1beeb90 100644
--- a/include/ceres/cost_function_to_functor.h
+++ b/include/ceres/cost_function_to_functor.h
@@ -89,12 +89,12 @@
 #include <cstdint>
 #include <numeric>
 #include <tuple>
+#include <utility>
 #include <vector>
 
 #include "ceres/cost_function.h"
 #include "ceres/dynamic_cost_function_to_functor.h"
 #include "ceres/internal/fixed_array.h"
-#include "ceres/internal/integer_sequence.h"
 #include "ceres/internal/parameter_dims.h"
 #include "ceres/internal/port.h"
 #include "ceres/types.h"
@@ -144,8 +144,8 @@
 
     // Extract parameter block pointers from params.
     using Indices =
-        internal::make_integer_sequence<int,
-                                        ParameterDims::kNumParameterBlocks>;
+        std::make_integer_sequence<int,
+                                   ParameterDims::kNumParameterBlocks>;
     std::array<const T*, ParameterDims::kNumParameterBlocks> parameter_blocks =
         GetParameterPointers<T>(params, Indices());
 
@@ -158,7 +158,7 @@
   template <typename T, typename Tuple, int... Indices>
   static std::array<const T*, ParameterDims::kNumParameterBlocks>
   GetParameterPointers(const Tuple& paramPointers,
-                       internal::integer_sequence<int, Indices...>) {
+                       std::integer_sequence<int, Indices...>) {
     return std::array<const T*, ParameterDims::kNumParameterBlocks>{
         {std::get<Indices>(paramPointers)...}};
   }
diff --git a/include/ceres/internal/algorithm.h b/include/ceres/internal/algorithm.h
deleted file mode 100644
index 3872055..0000000
--- a/include/ceres/internal/algorithm.h
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// -----------------------------------------------------------------------------
-// File: algorithm.h
-// -----------------------------------------------------------------------------
-//
-// This header file contains Google extensions to the standard <algorithm> C++
-// header.
-
-#ifndef CERES_PUBLIC_INTERNAL_ALGORITHM_H_
-#define CERES_PUBLIC_INTERNAL_ALGORITHM_H_
-
-#include <algorithm>
-#include <iterator>
-#include <type_traits>
-
-namespace ceres {
-namespace internal {
-
-// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
-struct EqualTo {
-  template <typename T, typename U>
-  bool operator()(const T& a, const U& b) const {
-    return a == b;
-  }
-};
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1,
-               InputIter1 last1,
-               InputIter2 first2,
-               InputIter2 last2,
-               Pred pred,
-               std::input_iterator_tag,
-               std::input_iterator_tag) {
-  while (true) {
-    if (first1 == last1) return first2 == last2;
-    if (first2 == last2) return false;
-    if (!pred(*first1, *first2)) return false;
-    ++first1;
-    ++first2;
-  }
-}
-
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool EqualImpl(InputIter1 first1,
-               InputIter1 last1,
-               InputIter2 first2,
-               InputIter2 last2,
-               Pred&& pred,
-               std::random_access_iterator_tag,
-               std::random_access_iterator_tag) {
-  return (last1 - first1 == last2 - first2) &&
-         std::equal(first1, last1, first2, std::forward<Pred>(pred));
-}
-
-// When we are using our own internal predicate that just applies operator==, we
-// forward to the non-predicate form of std::equal. This enables an optimization
-// in libstdc++ that can result in std::memcmp being used for integer types.
-template <typename InputIter1, typename InputIter2>
-bool EqualImpl(InputIter1 first1,
-               InputIter1 last1,
-               InputIter2 first2,
-               InputIter2 last2,
-               internal::EqualTo /* unused */,
-               std::random_access_iterator_tag,
-               std::random_access_iterator_tag) {
-  return (last1 - first1 == last2 - first2) &&
-         std::equal(first1, last1, first2);
-}
-
-// Compares the equality of two ranges specified by pairs of iterators, using
-// the given predicate, returning true iff for each corresponding iterator i1
-// and i2 in the first and second range respectively, pred(*i1, *i2) == true
-//
-// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
-// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
-// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
-// then the predicate is never invoked and the function returns false.
-//
-// This is a C++11-compatible implementation of C++14 `std::equal`.  See
-// https://en.cppreference.com/w/cpp/algorithm/equal for more information.
-template <typename InputIter1, typename InputIter2, typename Pred>
-bool equal(InputIter1 first1,
-           InputIter1 last1,
-           InputIter2 first2,
-           InputIter2 last2,
-           Pred&& pred) {
-  return internal::EqualImpl(
-      first1,
-      last1,
-      first2,
-      last2,
-      std::forward<Pred>(pred),
-      typename std::iterator_traits<InputIter1>::iterator_category{},
-      typename std::iterator_traits<InputIter2>::iterator_category{});
-}
-
-// Performs comparison of two ranges specified by pairs of iterators using
-// operator==.
-template <typename InputIter1, typename InputIter2>
-bool equal(InputIter1 first1,
-           InputIter1 last1,
-           InputIter2 first2,
-           InputIter2 last2) {
-  return internal::equal(first1, last1, first2, last2, internal::EqualTo{});
-}
-}  // namespace internal
-}  // namespace ceres
-#endif  // CERES_PUBLIC_INTERNAL_ALGORITHM_H_
\ No newline at end of file
diff --git a/include/ceres/internal/autodiff.h b/include/ceres/internal/autodiff.h
index 0603321..71b7bae 100644
--- a/include/ceres/internal/autodiff.h
+++ b/include/ceres/internal/autodiff.h
@@ -143,6 +143,7 @@
 #include <stddef.h>
 
 #include <array>
+#include <utility>
 
 #include "ceres/internal/array_selector.h"
 #include "ceres/internal/eigen.h"
@@ -213,14 +214,14 @@
 struct Make1stOrderPerturbations;
 
 template <int N, int... Ns, int ParameterIdx, int Offset>
-struct Make1stOrderPerturbations<integer_sequence<int, N, Ns...>,
+struct Make1stOrderPerturbations<std::integer_sequence<int, N, Ns...>,
                                  ParameterIdx,
                                  Offset> {
   template <typename T, typename JetT>
   inline static void Apply(T const* const* parameters, JetT* x) {
     Make1stOrderPerturbation<0, N, Offset, T, JetT>::Apply(
         parameters[ParameterIdx], x + Offset);
-    Make1stOrderPerturbations<integer_sequence<int, Ns...>,
+    Make1stOrderPerturbations<std::integer_sequence<int, Ns...>,
                               ParameterIdx + 1,
                               Offset + N>::Apply(parameters, x);
   }
@@ -228,7 +229,7 @@
 
 // End of 'recursion'. Nothing more to do.
 template <int ParameterIdx, int Total>
-struct Make1stOrderPerturbations<integer_sequence<int>, ParameterIdx, Total> {
+struct Make1stOrderPerturbations<std::integer_sequence<int>, ParameterIdx, Total> {
   template <typename T, typename JetT>
   static void Apply(T const* const* /* NOT USED */, JetT* /* NOT USED */) {}
 };
@@ -276,7 +277,7 @@
 struct Take1stOrderParts;
 
 template <int N, int... Ns, int ParameterIdx, int Offset>
-struct Take1stOrderParts<integer_sequence<int, N, Ns...>,
+struct Take1stOrderParts<std::integer_sequence<int, N, Ns...>,
                          ParameterIdx,
                          Offset> {
   template <typename JetT, typename T>
@@ -284,7 +285,7 @@
     if (jacobians[ParameterIdx]) {
       Take1stOrderPart<Offset, N>(num_outputs, output, jacobians[ParameterIdx]);
     }
-    Take1stOrderParts<integer_sequence<int, Ns...>,
+    Take1stOrderParts<std::integer_sequence<int, Ns...>,
                       ParameterIdx + 1,
                       Offset + N>::Apply(num_outputs, output, jacobians);
   }
@@ -292,7 +293,7 @@
 
 // End of 'recursion'. Nothing more to do.
 template <int ParameterIdx, int Offset>
-struct Take1stOrderParts<integer_sequence<int>, ParameterIdx, Offset> {
+struct Take1stOrderParts<std::integer_sequence<int>, ParameterIdx, Offset> {
   template <typename T, typename JetT>
   static void Apply(int /* NOT USED*/,
                     JetT* /* NOT USED*/,
diff --git a/include/ceres/internal/fixed_array.h b/include/ceres/internal/fixed_array.h
index 021851d..f8ef02d 100644
--- a/include/ceres/internal/fixed_array.h
+++ b/include/ceres/internal/fixed_array.h
@@ -39,7 +39,6 @@
 
 #include <Eigen/Core> // For Eigen::aligned_allocator
 
-#include "ceres/internal/algorithm.h"
 #include "ceres/internal/memory.h"
 #include "glog/logging.h"
 
@@ -312,7 +311,7 @@
   // Relational operators. Equality operators are elementwise using
   // `operator==`, while order operators order FixedArrays lexicographically.
   friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
-    return internal::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
   }
 
   friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
diff --git a/include/ceres/internal/integer_sequence.h b/include/ceres/internal/integer_sequence.h
deleted file mode 100644
index 3936b92..0000000
--- a/include/ceres/internal/integer_sequence.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2018 Google Inc. All rights reserved.
-// http://ceres-solver.org/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: jodebo_beck@gmx.de (Johannes Beck)
-//
-// This class mimics std::integer_sequence. That is the reason to follow the
-// naming convention of the stl and not the google one. Once Ceres switches
-// to c++ 14 this class can be removed.
-
-#ifndef CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
-#define CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
-
-#if __cplusplus >= 201402L
-// We have at least c++ 14 support. Use integer_sequence from the standard.
-// Sometimes the STL implementation uses a compiler intrinsic to generate
-// the sequences which will speed up compilation.
-#include <utility>
-
-namespace ceres {
-namespace internal {
-template <typename T, T... Ns>
-using integer_sequence = std::integer_sequence<T, Ns...>;
-
-template <typename T, T N>
-using make_integer_sequence = std::make_integer_sequence<T, N>;
-
-}  // namespace internal
-}  // namespace ceres
-#else
-
-namespace ceres {
-namespace internal {
-
-template <typename T, T... Ns>
-struct integer_sequence {
-  using value_type = T;
-};
-
-// Implementation of make_integer_sequence.
-//
-// Recursively instantiate make_integer_sequence_impl until Ns
-// contains the sequence 0, 1, ..., Total-1.
-//
-// Example for Total = 4:
-//                            T    CurIdx, Total, Ns...
-// make_integer_sequence_impl<int, 0,      4                >
-// make_integer_sequence_impl<int, 1,      4,     0         >
-// make_integer_sequence_impl<int, 2,      4,     0, 1      >
-// make_integer_sequence_impl<int, 3,      4,     0, 1, 2   >
-// make_integer_sequence_impl<int, 4,      4,     0, 1, 2, 3>
-//                                                ^^^^^^^^^^
-//                                                resulting sequence.
-//
-// The implemented algorithm has linear complexity for simplicity. A O(log(N))
-// implementation can be found e.g. here:
-// https://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence
-template <typename T, T CurIdx, T Total, T... Ns>
-struct make_integer_sequence_impl {
-  using type = typename make_integer_sequence_impl<T, CurIdx + 1, Total, Ns...,
-                                                   CurIdx>::type;
-};
-
-// End of 'recursion' when CurIdx reaches Total. All indices 0, 1, ..., N-1 are
-// contained in Ns. The final integer_sequence is created here.
-template <typename T, T Total, T... Ns>
-struct make_integer_sequence_impl<T, Total, Total, Ns...> {
-  using type = integer_sequence<T, Ns...>;
-};
-
-// A helper alias template to simplify creation of integer_sequence with 0, 1,
-// ..., N-1 as Ns:
-template <typename T, T N>
-using make_integer_sequence =
-    typename make_integer_sequence_impl<T, 0, N>::type;
-
-}  // namespace internal
-}  // namespace ceres
-
-#endif
-
-#endif  // CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_H_
diff --git a/include/ceres/internal/integer_sequence_algorithm.h b/include/ceres/internal/integer_sequence_algorithm.h
index bdeab93..170acac 100644
--- a/include/ceres/internal/integer_sequence_algorithm.h
+++ b/include/ceres/internal/integer_sequence_algorithm.h
@@ -35,7 +35,7 @@
 #ifndef CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_ALGORITHM_H_
 #define CERES_PUBLIC_INTERNAL_INTEGER_SEQUENCE_ALGORITHM_H_
 
-#include "integer_sequence.h"
+#include <utility>
 
 namespace ceres {
 namespace internal {
@@ -61,33 +61,33 @@
 
 // Strip of and sum the first number.
 template <typename T, T N, T... Ns>
-struct SumImpl<integer_sequence<T, N, Ns...>> {
-  static constexpr T Value = N + SumImpl<integer_sequence<T, Ns...>>::Value;
+struct SumImpl<std::integer_sequence<T, N, Ns...>> {
+  static constexpr T Value = N + SumImpl<std::integer_sequence<T, Ns...>>::Value;
 };
 
 // Strip of and sum the first two numbers.
 template <typename T, T N1, T N2, T... Ns>
-struct SumImpl<integer_sequence<T, N1, N2, Ns...>> {
+struct SumImpl<std::integer_sequence<T, N1, N2, Ns...>> {
   static constexpr T Value =
-      N1 + N2 + SumImpl<integer_sequence<T, Ns...>>::Value;
+      N1 + N2 + SumImpl<std::integer_sequence<T, Ns...>>::Value;
 };
 
 // Strip of and sum the first four numbers.
 template <typename T, T N1, T N2, T N3, T N4, T... Ns>
-struct SumImpl<integer_sequence<T, N1, N2, N3, N4, Ns...>> {
+struct SumImpl<std::integer_sequence<T, N1, N2, N3, N4, Ns...>> {
   static constexpr T Value =
-      N1 + N2 + N3 + N4 + SumImpl<integer_sequence<T, Ns...>>::Value;
+      N1 + N2 + N3 + N4 + SumImpl<std::integer_sequence<T, Ns...>>::Value;
 };
 
 // Only one number is left. 'Value' is just that number ('recursion' ends).
 template <typename T, T N>
-struct SumImpl<integer_sequence<T, N>> {
+struct SumImpl<std::integer_sequence<T, N>> {
   static constexpr T Value = N;
 };
 
 // No number is left. 'Value' is the identity element (for sum this is zero).
 template <typename T>
-struct SumImpl<integer_sequence<T>> {
+struct SumImpl<std::integer_sequence<T>> {
   static constexpr T Value = T(0);
 };
 
@@ -129,16 +129,16 @@
 struct ExclusiveScanImpl;
 
 template <typename T, T Sum, T N, T... Ns, T... Rs>
-struct ExclusiveScanImpl<T, Sum, integer_sequence<T, N, Ns...>,
-                         integer_sequence<T, Rs...>> {
+struct ExclusiveScanImpl<T, Sum, std::integer_sequence<T, N, Ns...>,
+                         std::integer_sequence<T, Rs...>> {
   using Type =
-      typename ExclusiveScanImpl<T, Sum + N, integer_sequence<T, Ns...>,
-                                 integer_sequence<T, Rs..., Sum>>::Type;
+      typename ExclusiveScanImpl<T, Sum + N, std::integer_sequence<T, Ns...>,
+                                 std::integer_sequence<T, Rs..., Sum>>::Type;
 };
 
 // End of 'recursion'. The resulting type is SeqOut.
 template <typename T, T Sum, typename SeqOut>
-struct ExclusiveScanImpl<T, Sum, integer_sequence<T>, SeqOut> {
+struct ExclusiveScanImpl<T, Sum, std::integer_sequence<T>, SeqOut> {
   using Type = SeqOut;
 };
 
@@ -152,7 +152,7 @@
 
  public:
   using Type =
-      typename ExclusiveScanImpl<T, T(0), Seq, integer_sequence<T>>::Type;
+      typename ExclusiveScanImpl<T, T(0), Seq, std::integer_sequence<T>>::Type;
 };
 
 // Helper to use exclusive scan without typename.
diff --git a/include/ceres/internal/numeric_diff.h b/include/ceres/internal/numeric_diff.h
index 211fa82..fb2e00b 100644
--- a/include/ceres/internal/numeric_diff.h
+++ b/include/ceres/internal/numeric_diff.h
@@ -36,6 +36,7 @@
 #define CERES_PUBLIC_INTERNAL_NUMERIC_DIFF_H_
 
 #include <cstring>
+#include <utility>
 
 #include "Eigen/Dense"
 #include "Eigen/StdVector"
@@ -437,7 +438,7 @@
 
 template <typename ParameterDims, int N, int... Ns, int ParameterIdx>
 struct EvaluateJacobianForParameterBlocks<ParameterDims,
-                                          integer_sequence<int, N, Ns...>,
+                                          std::integer_sequence<int, N, Ns...>,
                                           ParameterIdx> {
   template <NumericDiffMethodType method,
             int kNumResiduals,
@@ -468,7 +469,7 @@
     }
 
     return EvaluateJacobianForParameterBlocks<ParameterDims,
-                                              integer_sequence<int, Ns...>,
+                                              std::integer_sequence<int, Ns...>,
                                               ParameterIdx + 1>::
         template Apply<method, kNumResiduals>(functor,
                                               residuals_at_eval_point,
@@ -481,7 +482,7 @@
 
 // End of 'recursion'. Nothing more to do.
 template <typename ParameterDims, int ParameterIdx>
-struct EvaluateJacobianForParameterBlocks<ParameterDims, integer_sequence<int>,
+struct EvaluateJacobianForParameterBlocks<ParameterDims, std::integer_sequence<int>,
                                           ParameterIdx> {
   template <NumericDiffMethodType method, int kNumResiduals,
             typename CostFunctor>
diff --git a/include/ceres/internal/parameter_dims.h b/include/ceres/internal/parameter_dims.h
index 2272e8d..2402106 100644
--- a/include/ceres/internal/parameter_dims.h
+++ b/include/ceres/internal/parameter_dims.h
@@ -32,8 +32,8 @@
 #define CERES_PUBLIC_INTERNAL_PARAMETER_DIMS_H_
 
 #include <array>
+#include <utility>
 
-#include "ceres/internal/integer_sequence.h"
 #include "ceres/internal/integer_sequence_algorithm.h"
 
 namespace ceres {
@@ -41,16 +41,16 @@
 
 // Checks, whether the given parameter block sizes are valid. Valid means every
 // dimension is bigger than zero.
-constexpr bool IsValidParameterDimensionSequence(integer_sequence<int>) {
+constexpr bool IsValidParameterDimensionSequence(std::integer_sequence<int>) {
   return true;
 }
 
 template <int N, int... Ts>
 constexpr bool IsValidParameterDimensionSequence(
-    integer_sequence<int, N, Ts...>) {
+    std::integer_sequence<int, N, Ts...>) {
   return (N <= 0) ? false
                   : IsValidParameterDimensionSequence(
-                        integer_sequence<int, Ts...>());
+                        std::integer_sequence<int, Ts...>());
 }
 
 // Helper class that represents the parameter dimensions. The parameter
@@ -66,7 +66,7 @@
 template <bool IsDynamic, int... Ns>
 class ParameterDims {
  public:
-  using Parameters = integer_sequence<int, Ns...>;
+  using Parameters = std::integer_sequence<int, Ns...>;
 
   // The parameter dimensions are only valid if all parameter block dimensions
   // are greater than zero.
@@ -82,7 +82,7 @@
                 "At least one parameter block must be specified.");
 
   static constexpr int kNumParameters =
-      Sum<integer_sequence<int, Ns...>>::Value;
+      Sum<std::integer_sequence<int, Ns...>>::Value;
 
   static constexpr int GetDim(int dim) { return params_[dim]; }
 
@@ -98,7 +98,7 @@
  private:
   template <typename T, int... Indices>
   static inline std::array<T*, kNumParameterBlocks> GetUnpackedParameters(
-      T* ptr, integer_sequence<int, Indices...>) {
+      T* ptr, std::integer_sequence<int, Indices...>) {
     return std::array<T*, kNumParameterBlocks>{{ptr + Indices...}};
   }
 
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index 07bb505..958b0d1 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -35,19 +35,19 @@
 #include "ceres/internal/config.h"
 
 #if defined(CERES_USE_OPENMP)
-#  if defined(CERES_USE_CXX11_THREADS) || defined(CERES_NO_THREADS)
-#    error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX11_THREADS and CERES_NO_THREADS
+#  if defined(CERES_USE_CXX_THREADS) || defined(CERES_NO_THREADS)
+#    error CERES_USE_OPENMP is mutually exclusive to CERES_USE_CXX_THREADS and CERES_NO_THREADS
 #  endif
-#elif defined(CERES_USE_CXX11_THREADS)
+#elif defined(CERES_USE_CXX_THREADS)
 #  if defined(CERES_USE_OPENMP) || defined(CERES_NO_THREADS)
-#    error CERES_USE_CXX11_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX11_THREADS and CERES_NO_THREADS
+#    error CERES_USE_CXX_THREADS is mutually exclusive to CERES_USE_OPENMP, CERES_USE_CXX_THREADS and CERES_NO_THREADS
 #  endif
 #elif defined(CERES_NO_THREADS)
-#  if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX11_THREADS)
-#    error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX11_THREADS
+#  if defined(CERES_USE_OPENMP) || defined(CERES_USE_CXX_THREADS)
+#    error CERES_NO_THREADS is mutually exclusive to CERES_USE_OPENMP and CERES_USE_CXX_THREADS
 #  endif
 #else
-#  error One of CERES_USE_OPENMP, CERES_USE_CXX11_THREADS or CERES_NO_THREADS must be defined.
+#  error One of CERES_USE_OPENMP, CERES_USE_CXX_THREADS or CERES_NO_THREADS must be defined.
 #endif
 
 // CERES_NO_SPARSE should be automatically defined by config.h if Ceres was
diff --git a/include/ceres/internal/variadic_evaluate.h b/include/ceres/internal/variadic_evaluate.h
index 26428d0..046832c 100644
--- a/include/ceres/internal/variadic_evaluate.h
+++ b/include/ceres/internal/variadic_evaluate.h
@@ -36,6 +36,7 @@
 #include <stddef.h>
 
 #include <type_traits>
+#include <utility>
 
 #include "ceres/cost_function.h"
 #include "ceres/internal/parameter_dims.h"
@@ -47,7 +48,7 @@
 template <typename Functor, typename T, int... Indices>
 inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
                                  T* output, std::false_type /*is_dynamic*/,
-                                 integer_sequence<int, Indices...>) {
+                                 std::integer_sequence<int, Indices...>) {
   static_assert(sizeof...(Indices),
                 "Invalid number of parameter blocks. At least one parameter "
                 "block must be specified.");
@@ -58,7 +59,7 @@
 template <typename Functor, typename T>
 inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
                                  T* output, std::true_type /*is_dynamic*/,
-                                 integer_sequence<int>) {
+                                 std::integer_sequence<int>) {
   return functor(input, output);
 }
 
@@ -67,7 +68,7 @@
 inline bool VariadicEvaluateImpl(const Functor& functor, T const* const* input,
                                  T* output, const void* /* NOT USED */) {
   using ParameterBlockIndices =
-      make_integer_sequence<int, ParameterDims::kNumParameterBlocks>;
+      std::make_integer_sequence<int, ParameterDims::kNumParameterBlocks>;
   using IsDynamic = std::integral_constant<bool, ParameterDims::kIsDynamic>;
   return VariadicEvaluateImpl(functor, input, output, IsDynamic(),
                               ParameterBlockIndices());
diff --git a/internal/ceres/CMakeLists.txt b/internal/ceres/CMakeLists.txt
index 80125c9..1ff9217 100644
--- a/internal/ceres/CMakeLists.txt
+++ b/internal/ceres/CMakeLists.txt
@@ -30,7 +30,7 @@
 
 # Avoid 'xxx.cc has no symbols' warnings from source files which are 'empty'
 # when their enclosing #ifdefs are disabled.
-if (CERES_THREADING_MODEL STREQUAL "CXX11_THREADS")
+if (CERES_THREADING_MODEL STREQUAL "CXX_THREADS")
   set(CERES_PARALLEL_FOR_SRC parallel_for_cxx.cc thread_pool.cc)
 elseif (CERES_THREADING_MODEL STREQUAL "OPENMP")
   set(CERES_PARALLEL_FOR_SRC parallel_for_openmp.cc)
@@ -397,7 +397,6 @@
              ${Ceres_SOURCE_DIR}/data)
   endmacro (CERES_TEST)
 
-  ceres_test(algorithm)
   ceres_test(array_utils)
   ceres_test(array_selector)
   ceres_test(autodiff)
@@ -442,7 +441,6 @@
   ceres_test(implicit_schur_complement)
   ceres_test(inner_product_computer)
   ceres_test(invert_psd_matrix)
-  ceres_test(integer_sequence)
   ceres_test(integer_sequence_algorithm)
   ceres_test(is_close)
   ceres_test(iterative_refiner)
diff --git a/internal/ceres/algorithm_test.cc b/internal/ceres/algorithm_test.cc
deleted file mode 100644
index c131563..0000000
--- a/internal/ceres/algorithm_test.cc
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "ceres/internal/algorithm.h"
-
-#include <algorithm>
-#include <list>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(EqualTest, DefaultComparisonRandomAccess) {
-  std::vector<int> v1{1, 2, 3};
-  std::vector<int> v2 = v1;
-  std::vector<int> v3 = {1, 2};
-  std::vector<int> v4 = {1, 2, 4};
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, DefaultComparison) {
-  std::list<int> lst1{1, 2, 3};
-  std::list<int> lst2 = lst1;
-  std::list<int> lst3{1, 2};
-  std::list<int> lst4{1, 2, 4};
-
-  EXPECT_TRUE(ceres::internal::equal(
-      lst1.begin(), lst1.end(), lst2.begin(), lst2.end()));
-  EXPECT_FALSE(ceres::internal::equal(
-      lst1.begin(), lst1.end(), lst3.begin(), lst3.end()));
-  EXPECT_FALSE(ceres::internal::equal(
-      lst1.begin(), lst1.end(), lst4.begin(), lst4.end()));
-}
-
-TEST(EqualTest, EmptyRange) {
-  std::vector<int> v1{1, 2, 3};
-  std::vector<int> empty1;
-  std::vector<int> empty2;
-
-  EXPECT_FALSE(ceres::internal::equal(
-      v1.begin(), v1.end(), empty1.begin(), empty1.end()));
-  EXPECT_FALSE(ceres::internal::equal(
-      empty1.begin(), empty1.end(), v1.begin(), v1.end()));
-  EXPECT_TRUE(ceres::internal::equal(
-      empty1.begin(), empty1.end(), empty2.begin(), empty2.end()));
-}
-
-TEST(EqualTest, MixedIterTypes) {
-  std::vector<int> v1{1, 2, 3};
-  std::list<int> lst1{v1.begin(), v1.end()};
-  std::list<int> lst2{1, 2, 4};
-  std::list<int> lst3{1, 2};
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), lst1.begin(), lst1.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), lst2.begin(), lst2.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), lst3.begin(), lst3.end()));
-}
-
-TEST(EqualTest, MixedValueTypes) {
-  std::vector<int> v1{1, 2, 3};
-  std::vector<char> v2{1, 2, 3};
-  std::vector<char> v3{1, 2};
-  std::vector<char> v4{1, 2, 4};
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, WeirdIterators) {
-  std::vector<bool> v1{true, false};
-  std::vector<bool> v2 = v1;
-  std::vector<bool> v3{true};
-  std::vector<bool> v4{true, true, true};
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
-}
-
-TEST(EqualTest, CustomComparison) {
-  int n[] = {1, 2, 3, 4};
-  std::vector<int*> v1{&n[0], &n[1], &n[2]};
-  std::vector<int*> v2 = v1;
-  std::vector<int*> v3{&n[0], &n[1], &n[3]};
-  std::vector<int*> v4{&n[0], &n[1]};
-
-  auto eq = [](int* a, int* b) { return *a == *b; };
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), eq));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v3.begin(), v3.end(), eq));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v4.begin(), v4.end(), eq));
-}
-
-TEST(EqualTest, MoveOnlyPredicate) {
-  std::vector<int> v1{1, 2, 3};
-  std::vector<int> v2{4, 5, 6};
-
-  // move-only equality predicate
-  struct Eq {
-    Eq() = default;
-    Eq(Eq&&) = default;
-    Eq(const Eq&) = delete;
-    Eq& operator=(const Eq&) = delete;
-    bool operator()(const int a, const int b) const { return a == b; }
-  };
-
-  EXPECT_TRUE(
-      ceres::internal::equal(v1.begin(), v1.end(), v1.begin(), v1.end(), Eq()));
-  EXPECT_FALSE(
-      ceres::internal::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), Eq()));
-}
-
-struct CountingTrivialPred {
-  int* count;
-  bool operator()(int, int) const {
-    ++*count;
-    return true;
-  }
-};
-
-TEST(EqualTest, RandomAccessComplexity) {
-  std::vector<int> v1{1, 1, 3};
-  std::vector<int> v2 = v1;
-  std::vector<int> v3{1, 2};
-
-  do {
-    int count = 0;
-    ceres::internal::equal(v1.begin(),
-                           v1.end(),
-                           v2.begin(),
-                           v2.end(),
-                           CountingTrivialPred{&count});
-    EXPECT_LE(count, 3);
-  } while (std::next_permutation(v2.begin(), v2.end()));
-
-  int count = 0;
-  ceres::internal::equal(
-      v1.begin(), v1.end(), v3.begin(), v3.end(), CountingTrivialPred{&count});
-  EXPECT_EQ(count, 0);
-}
-}  // namespace
diff --git a/internal/ceres/concurrent_queue_test.cc b/internal/ceres/concurrent_queue_test.cc
index 698966a..ce6d687 100644
--- a/internal/ceres/concurrent_queue_test.cc
+++ b/internal/ceres/concurrent_queue_test.cc
@@ -31,7 +31,7 @@
 // This include must come before any #ifndef check on Ceres compile options.
 #include "ceres/internal/port.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 
 #include <chrono>
 #include <thread>
@@ -304,4 +304,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/context_impl.cc b/internal/ceres/context_impl.cc
index 1b9662f..622f33a 100644
--- a/internal/ceres/context_impl.cc
+++ b/internal/ceres/context_impl.cc
@@ -34,9 +34,9 @@
 namespace internal {
 
 void ContextImpl::EnsureMinimumThreads(int num_threads) {
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   thread_pool.Resize(num_threads);
-#endif  // CERES_USE_CXX11_THREADS
+#endif  // CERES_USE_CXX_THREADS
 
 }
 }  // namespace internal
diff --git a/internal/ceres/context_impl.h b/internal/ceres/context_impl.h
index d83b77a..5c03ad7 100644
--- a/internal/ceres/context_impl.h
+++ b/internal/ceres/context_impl.h
@@ -36,9 +36,9 @@
 
 #include "ceres/context.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 #include "ceres/thread_pool.h"
-#endif  // CERES_USE_CXX11_THREADS
+#endif  // CERES_USE_CXX_THREADS
 
 namespace ceres {
 namespace internal {
@@ -51,14 +51,14 @@
 
   virtual ~ContextImpl() {}
 
-  // When compiled with C++11 threading support, resize the thread pool to have
+  // When compiled with C++ threading support, resize the thread pool to have
   // at min(num_thread, num_hardware_threads) where num_hardware_threads is
   // defined by the hardware.  Otherwise this call is a no-op.
   void EnsureMinimumThreads(int num_threads);
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   ThreadPool thread_pool;
-#endif  // CERES_USE_CXX11_THREADS
+#endif  // CERES_USE_CXX_THREADS
 };
 
 }  // namespace internal
diff --git a/internal/ceres/integer_sequence_algorithm_test.cc b/internal/ceres/integer_sequence_algorithm_test.cc
index a6c85d0..af42a91 100644
--- a/internal/ceres/integer_sequence_algorithm_test.cc
+++ b/internal/ceres/integer_sequence_algorithm_test.cc
@@ -31,39 +31,40 @@
 #include "ceres/internal/integer_sequence_algorithm.h"
 
 #include <type_traits>
+#include <utility>
 
 namespace ceres {
 namespace internal {
 
 // Unit tests for summation of integer sequence.
-static_assert(Sum<integer_sequence<int>>::Value == 0,
+static_assert(Sum<std::integer_sequence<int>>::Value == 0,
               "Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2>>::Value == 2,
+static_assert(Sum<std::integer_sequence<int, 2>>::Value == 2,
               "Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3>>::Value == 5,
+static_assert(Sum<std::integer_sequence<int, 2, 3>>::Value == 5,
               "Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10>>::Value == 15,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10>>::Value == 15,
               "Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10, 4>>::Value == 19,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10, 4>>::Value == 19,
               "Unit test of summing up an integer sequence failed.");
-static_assert(Sum<integer_sequence<int, 2, 3, 10, 4, 1>>::Value == 20,
+static_assert(Sum<std::integer_sequence<int, 2, 3, 10, 4, 1>>::Value == 20,
               "Unit test of summing up an integer sequence failed.");
 
 // Unit tests for exclusive scan of integer sequence.
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int>>,
-                           integer_sequence<int>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int>>,
+                           std::integer_sequence<int>>::value,
               "Unit test of calculating the exclusive scan of an integer "
               "sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2>>,
-                           integer_sequence<int, 0>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2>>,
+                           std::integer_sequence<int, 0>>::value,
               "Unit test of calculating the exclusive scan of an integer "
               "sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2, 1>>,
-                           integer_sequence<int, 0, 2>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2, 1>>,
+                           std::integer_sequence<int, 0, 2>>::value,
               "Unit test of calculating the exclusive scan of an integer "
               "sequence failed.");
-static_assert(std::is_same<ExclusiveScan<integer_sequence<int, 2, 1, 10>>,
-                           integer_sequence<int, 0, 2, 3>>::value,
+static_assert(std::is_same<ExclusiveScan<std::integer_sequence<int, 2, 1, 10>>,
+                           std::integer_sequence<int, 0, 2, 3>>::value,
               "Unit test of calculating the exclusive scan of an integer "
               "sequence failed.");
 
diff --git a/internal/ceres/integer_sequence_test.cc b/internal/ceres/integer_sequence_test.cc
deleted file mode 100644
index ab3559a..0000000
--- a/internal/ceres/integer_sequence_test.cc
+++ /dev/null
@@ -1,58 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2018 Google Inc. All rights reserved.
-// http://ceres-solver.org/
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are met:
-//
-// * Redistributions of source code must retain the above copyright notice,
-//   this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above copyright notice,
-//   this list of conditions and the following disclaimer in the documentation
-//   and/or other materials provided with the distribution.
-// * Neither the name of Google Inc. nor the names of its contributors may be
-//   used to endorse or promote products derived from this software without
-//   specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-//
-// Author: jodebo_beck@gmx.de (Johannes Beck)
-
-#include "ceres/internal/integer_sequence.h"
-
-#include <type_traits>
-
-namespace ceres {
-namespace internal {
-
-// Unit test for integer_sequence<...>::value_type
-static_assert(std::is_same<integer_sequence<unsigned int, 0>::value_type,
-                           unsigned int>::value,
-              "Unit test of integer sequence value type failed.");
-
-// Unit tests for make_integer_sequence
-static_assert(
-    std::is_same<make_integer_sequence<int, 0>, integer_sequence<int>>::value,
-    "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 1>,
-                           integer_sequence<int, 0>>::value,
-              "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 2>,
-                           integer_sequence<int, 0, 1>>::value,
-              "Unit test of make integer sequence failed.");
-static_assert(std::is_same<make_integer_sequence<int, 3>,
-                           integer_sequence<int, 0, 1, 2>>::value,
-              "Unit test of make integer sequence failed.");
-
-}  // namespace internal
-}  // namespace ceres
diff --git a/internal/ceres/parallel_for_cxx.cc b/internal/ceres/parallel_for_cxx.cc
index b6ef709..8e358f5 100644
--- a/internal/ceres/parallel_for_cxx.cc
+++ b/internal/ceres/parallel_for_cxx.cc
@@ -31,7 +31,7 @@
 // This include must come before any #ifndef check on Ceres compile options.
 #include "ceres/internal/port.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 
 #include "ceres/parallel_for.h"
 
@@ -244,4 +244,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/parameter_dims_test.cc b/internal/ceres/parameter_dims_test.cc
index f33536f..c832260 100644
--- a/internal/ceres/parameter_dims_test.cc
+++ b/internal/ceres/parameter_dims_test.cc
@@ -26,28 +26,29 @@
 
 #include <gtest/gtest.h>
 #include <type_traits>
+#include <utility>
 
 namespace ceres {
 namespace internal {
 
 // Is valid parameter dims unit test
-static_assert(IsValidParameterDimensionSequence(integer_sequence<int>()) ==
+static_assert(IsValidParameterDimensionSequence(std::integer_sequence<int>()) ==
                   true,
               "Unit test of is valid parameter dimension sequence failed.");
 static_assert(
-    IsValidParameterDimensionSequence(integer_sequence<int, 2, 1>()) == true,
+    IsValidParameterDimensionSequence(std::integer_sequence<int, 2, 1>()) == true,
     "Unit test of is valid parameter dimension sequence failed.");
 static_assert(
-    IsValidParameterDimensionSequence(integer_sequence<int, 0, 1>()) == false,
+    IsValidParameterDimensionSequence(std::integer_sequence<int, 0, 1>()) == false,
     "Unit test of is valid parameter dimension sequence failed.");
 static_assert(
-    IsValidParameterDimensionSequence(integer_sequence<int, 3, 0>()) == false,
+    IsValidParameterDimensionSequence(std::integer_sequence<int, 3, 0>()) == false,
     "Unit test of is valid parameter dimension sequence failed.");
 
 // Static parameter dims unit test
 static_assert(
     std::is_same<StaticParameterDims<4, 2, 1>::Parameters,
-                 integer_sequence<int, 4, 2, 1>>::value == true,
+                 std::integer_sequence<int, 4, 2, 1>>::value == true,
     "Unit test of type 'parameters' for static parameter dims failed.");
 
 static_assert(StaticParameterDims<4, 2, 1>::kIsValid == true,
diff --git a/internal/ceres/program_evaluator.h b/internal/ceres/program_evaluator.h
index 5daface..97ee590 100644
--- a/internal/ceres/program_evaluator.h
+++ b/internal/ceres/program_evaluator.h
@@ -43,7 +43,7 @@
 // residual jacobians are written directly into their final position in the
 // block sparse matrix by the user's CostFunction; there is no copying.
 //
-// The evaluation is threaded with OpenMP or C++11 threads.
+// The evaluation is threaded with OpenMP or C++ threads.
 //
 // The EvaluatePreparer and JacobianWriter interfaces are as follows:
 //
diff --git a/internal/ceres/program_test.cc b/internal/ceres/program_test.cc
index 74dcd75..be6ad87 100644
--- a/internal/ceres/program_test.cc
+++ b/internal/ceres/program_test.cc
@@ -33,6 +33,7 @@
 #include <cmath>
 #include <limits>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "ceres/internal/integer_sequence_algorithm.h"
@@ -69,7 +70,7 @@
   bool Evaluate(double const* const* parameters,
                 double* residuals,
                 double** jacobians) const final {
-    const int kNumParameters = Sum<integer_sequence<int, Ns...>>::Value;
+    const int kNumParameters = Sum<std::integer_sequence<int, Ns...>>::Value;
 
     for (int i = 0; i < kNumResiduals; ++i) {
       residuals[i] = kNumResiduals + kNumParameters;
diff --git a/internal/ceres/stringprintf.cc b/internal/ceres/stringprintf.cc
index b3b7474..7a21f0e 100644
--- a/internal/ceres/stringprintf.cc
+++ b/internal/ceres/stringprintf.cc
@@ -43,28 +43,6 @@
 
 using std::string;
 
-// va_copy() was defined in the C99 standard.  However, it did not appear in the
-// C++ standard until C++11.  This means that if Ceres is being compiled with a
-// strict pre-C++11 standard (e.g. -std=c++03), va_copy() will NOT be defined,
-// as we are using the C++ compiler (it would however be defined if we were
-// using the C compiler).  Note however that both GCC & Clang will in fact
-// define va_copy() when compiling for C++ if the C++ standard is not explicitly
-// specified (i.e. no -std=c++<XX> arg), even though it should not strictly be
-// defined unless -std=c++11 (or greater) was passed.
-#if !defined(va_copy)
-#if defined (__GNUC__)
-// On GCC/Clang, if va_copy() is not defined (C++ standard < C++11 explicitly
-// specified), use the internal __va_copy() version, which should be present
-// in even very old GCC versions.
-#define va_copy(d, s) __va_copy(d, s)
-#else
-// Some older versions of MSVC do not have va_copy(), in which case define it.
-// Although this is required for older MSVC versions, it should also work for
-// other non-GCC/Clang compilers which also do not defined va_copy().
-#define va_copy(d, s) ((d) = (s))
-#endif  // defined (__GNUC__)
-#endif  // !defined(va_copy)
-
 void StringAppendV(string* dst, const char* format, va_list ap) {
   // First try with a small fixed size buffer
   char space[1024];
diff --git a/internal/ceres/thread_pool.cc b/internal/ceres/thread_pool.cc
index 991da30..5a52c9d 100644
--- a/internal/ceres/thread_pool.cc
+++ b/internal/ceres/thread_pool.cc
@@ -31,7 +31,7 @@
 // This include must come before any #ifndef check on Ceres compile options.
 #include "ceres/internal/port.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 
 #include "ceres/thread_pool.h"
 
@@ -113,4 +113,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_pool_test.cc b/internal/ceres/thread_pool_test.cc
index 2b1bf87..48ba9d1 100644
--- a/internal/ceres/thread_pool_test.cc
+++ b/internal/ceres/thread_pool_test.cc
@@ -31,7 +31,7 @@
 // This include must come before any #ifndef check on Ceres compile options.
 #include "ceres/internal/port.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 
 #include "ceres/thread_pool.h"
 
@@ -197,4 +197,4 @@
 }  // namespace internal
 }  // namespace ceres
 
-#endif // CERES_USE_CXX11_THREADS
+#endif // CERES_USE_CXX_THREADS
diff --git a/internal/ceres/thread_token_provider.cc b/internal/ceres/thread_token_provider.cc
index 337217b..b04cf84 100644
--- a/internal/ceres/thread_token_provider.cc
+++ b/internal/ceres/thread_token_provider.cc
@@ -39,7 +39,7 @@
 
 ThreadTokenProvider::ThreadTokenProvider(int num_threads) {
   (void)num_threads;
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   for (int i = 0; i < num_threads; i++) {
     pool_.Push(i);
   }
@@ -56,7 +56,7 @@
   return 0;
 #endif
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   int thread_id;
   CHECK(pool_.Wait(&thread_id));
   return thread_id;
@@ -66,7 +66,7 @@
 
 void ThreadTokenProvider::Release(int thread_id) {
   (void)thread_id;
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   pool_.Push(thread_id);
 #endif
 
diff --git a/internal/ceres/thread_token_provider.h b/internal/ceres/thread_token_provider.h
index f6298b7..06dc043 100644
--- a/internal/ceres/thread_token_provider.h
+++ b/internal/ceres/thread_token_provider.h
@@ -34,15 +34,15 @@
 #include "ceres/internal/config.h"
 #include "ceres/internal/port.h"
 
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
 #include "ceres/concurrent_queue.h"
 #endif
 
 namespace ceres {
 namespace internal {
 
-// Helper for C++11 thread number identification that is similar to
-// omp_get_thread_num() behaviour. This is necessary to support C++11
+// Helper for C++ thread number identification that is similar to
+// omp_get_thread_num() behaviour. This is necessary to support C++
 // threading with a sequential thread id. This is used to access preallocated
 // resources in the parallelized code parts.  The sequence of tokens varies from
 // 0 to num_threads - 1 that can be acquired to identify the thread in a thread
@@ -78,7 +78,7 @@
   void Release(int thread_id);
 
  private:
-#ifdef CERES_USE_CXX11_THREADS
+#ifdef CERES_USE_CXX_THREADS
   // This queue initially holds a sequence from 0..num_threads-1. Every
   // Acquire() call the first number is removed from here. When the token is not
   // needed anymore it shall be given back with corresponding Release()