diff --git a/.clang-tidy b/.clang-tidy
index a375f76141..d3ecf33b9d 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -21,6 +21,7 @@ Checks: |
   modernize-avoid-bind,
   modernize-loop-convert,
   modernize-make-shared,
+  modernize-make-unique,
   modernize-redundant-void-arg,
   modernize-replace-auto-ptr,
   modernize-replace-disallow-copy-and-assign-macro,
@@ -35,6 +36,7 @@ Checks: |
   modernize-use-noexcept,
   modernize-use-nullptr,
   modernize-use-override,
+  modernize-use-transparent-functors,
   modernize-use-using,
   readability-avoid-const-params-in-decls,
   readability-braces-around-statements,
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index eb2fcf2b67..d0342c41c3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -99,7 +99,7 @@ jobs:
             cmake-args: -DCMAKE_CXX_STANDARD=14
           - runs-on: macos-15-intel
             python-version: '3.13'
-            cmake-args: -DCMAKE_CXX_STANDARD=11
+            cmake-args: -DCMAKE_CXX_STANDARD=14
           - runs-on: macos-latest
             python-version: '3.12'
             cmake-args: -DCMAKE_CXX_STANDARD=17 -DPYBIND11_DISABLE_HANDLE_TYPE_NAME_DEFAULT_IMPLEMENTATION=ON
@@ -152,7 +152,7 @@ jobs:
       python-version: ${{ matrix.python-version }}
       cmake-args: ${{ matrix.cmake-args }}
 
-  # This checks inplace builds with C++11
+  # This checks inplace builds with C++14
   inplace:
     if: github.event.pull_request.draft == false
     strategy:
@@ -254,12 +254,15 @@ jobs:
         run: uv tool install ninja
 
       - name: Configure via preset
-        run: cmake --preset venv -DPYBIND11_CREATE_WITH_UV="${{ matrix.python-version }}"
+        run: >
+          cmake --preset venv
+          -DPYBIND11_CREATE_WITH_UV="${{ matrix.python-version }}"
+          -DCMAKE_CXX_STANDARD=14
 
-      - name: Build C++11
+      - name: Build C++14
         run: cmake --build --preset venv
 
-      - name: Python tests C++11
+      - name: Python tests C++14
         run: cmake --build --preset testsvenv -t pytest
 
   # Testing on clang using the excellent silkeh clang docker images
@@ -536,43 +539,43 @@ jobs:
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
         python3 -m pip install -r tests/requirements.txt
 
-    - name: Configure C++11
+    - name: Configure C++14
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
-        cmake -S . -B build-11     \
+        cmake -S . -B build-14     \
         -DPYBIND11_WERROR=ON    \
         -DDOWNLOAD_CATCH=ON     \
         -DDOWNLOAD_EIGEN=OFF    \
-        -DCMAKE_CXX_STANDARD=11             \
+        -DCMAKE_CXX_STANDARD=14             \
         -DCMAKE_CXX_COMPILER=$(which icpc)  \
         -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)")
 
-    - name: Build C++11
+    - name: Build C++14
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
-        cmake --build build-11 -j 2 -v
+        cmake --build build-14 -j 2 -v
 
-    - name: Python tests C++11
+    - name: Python tests C++14
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
         sudo service apport stop
-        cmake --build build-11 --target check
+        cmake --build build-14 --target check
 
-    - name: C++ tests C++11
+    - name: C++ tests C++14
       timeout-minutes: 3
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
-        cmake --build build-11 --target cpptest
+        cmake --build build-14 --target cpptest
 
-    - name: Interface test C++11
+    - name: Interface test C++14
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
-        cmake --build build-11 --target test_cmake_build
+        cmake --build build-14 --target test_cmake_build
 
     - name: Visibility test
       run: |
         set +e; source /opt/intel/oneapi/setvars.sh; set -e
-        cmake --build build-11 --target test_cross_module_rtti
+        cmake --build build-14 --target test_cross_module_rtti
 
     - name: Configure C++17
       run: |
@@ -659,7 +662,7 @@ jobs:
         -DPYBIND11_WERROR=ON
         -DDOWNLOAD_CATCH=ON
         -DDOWNLOAD_EIGEN=ON
-        -DCMAKE_CXX_STANDARD=11
+        -DCMAKE_CXX_STANDARD=14
         -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)")
 
     - name: Build
@@ -810,7 +813,7 @@ jobs:
         -DDOWNLOAD_CATCH=ON
         -DDOWNLOAD_EIGEN=ON
         ${{ matrix.args }}
-    - name: Build C++11
+    - name: Build C++14
       run: cmake --build build -j 2
 
     - name: Python tests
@@ -859,7 +862,7 @@ jobs:
         -DDOWNLOAD_CATCH=ON
         -DDOWNLOAD_EIGEN=ON
         ${{ matrix.args }}
-    - name: Build C++11
+    - name: Build C++14
       run: cmake --build build --config Debug -j 2
 
     - name: Python tests
@@ -969,25 +972,25 @@ jobs:
 
     - uses: actions/checkout@v7
 
-    - name: Configure C++11
+    - name: Configure C++14
       # LTO leads to many undefined reference like
       # `pybind11::detail::function_call::function_call(pybind11::detail::function_call&&)
       run: >-
-        cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=11 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON
+        cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=14 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON
         -DPYTHON_EXECUTABLE=$(python -c "import sys; print(sys.executable)")
         -S . -B build
 
-    - name: Build C++11
+    - name: Build C++14
       run: cmake --build build -j 2
 
-    - name: Python tests C++11
+    - name: Python tests C++14
       run: cmake --build build --target pytest -j 2
 
-    - name: C++11 tests
+    - name: C++14 tests
       timeout-minutes: 3
       run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build --target cpptest -j 2
 
-    - name: Interface test C++11
+    - name: Interface test C++14
       run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build --target test_cmake_build
 
     - name: Visibility test
@@ -996,31 +999,6 @@ jobs:
     - name: Clean directory
       run: git clean -fdx
 
-    - name: Configure C++14
-      run: >-
-        cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=14 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON
-        -DPYTHON_EXECUTABLE=$(python -c "import sys; print(sys.executable)")
-        -S . -B build2
-
-    - name: Build C++14
-      run: cmake --build build2 -j 2
-
-    - name: Python tests C++14
-      run: cmake --build build2 --target pytest -j 2
-
-    - name: C++14 tests
-      timeout-minutes: 3
-      run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build2 --target cpptest -j 2
-
-    - name: Interface test C++14
-      run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build2 --target test_cmake_build
-
-    - name: Visibility test
-      run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build2 --target test_cross_module_rtti
-
-    - name: Clean directory
-      run: git clean -fdx
-
     - name: Configure C++17
       run: >-
         cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=17 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON
diff --git a/.github/workflows/upstream.yml b/.github/workflows/upstream.yml
index 7ad8c99014..2ac1fd9a63 100644
--- a/.github/workflows/upstream.yml
+++ b/.github/workflows/upstream.yml
@@ -49,28 +49,28 @@ jobs:
         cmake --version
         pip list
 
-    # First build - C++11 mode and inplace
-    - name: Configure C++11
+    # First build - C++14 mode and inplace
+    - name: Configure C++14
       run: >
-        cmake -S . -B build11
+        cmake -S . -B build14
         -DPYBIND11_WERROR=ON
         -DDOWNLOAD_CATCH=ON
         -DDOWNLOAD_EIGEN=ON
-        -DCMAKE_CXX_STANDARD=11
+        -DCMAKE_CXX_STANDARD=14
         -DCMAKE_BUILD_TYPE=Debug
 
-    - name: Build C++11
-      run: cmake --build build11 -j 2
+    - name: Build C++14
+      run: cmake --build build14 -j 2
 
-    - name: Python tests C++11
-      run: cmake --build build11 --target pytest -j 2
+    - name: Python tests C++14
+      run: cmake --build build14 --target pytest -j 2
 
-    - name: C++11 tests
+    - name: C++14 tests
       timeout-minutes: 3
-      run: cmake --build build11  --target cpptest -j 2
+      run: cmake --build build14  --target cpptest -j 2
 
-    - name: Interface test C++11
-      run: cmake --build build11 --target test_cmake_build
+    - name: Interface test C++14
+      run: cmake --build build14 --target test_cmake_build
 
     # Second build - C++17 mode and in a build directory
     - name: Configure C++17
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 65f794a49d..2ef6af928f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -294,8 +294,7 @@ if(NOT TARGET pybind11_headers)
     pybind11_headers ${pybind11_system} INTERFACE $<BUILD_INTERFACE:${pybind11_INCLUDE_DIR}>
                                                   $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
-  target_compile_features(pybind11_headers INTERFACE cxx_inheriting_constructors cxx_user_literals
-                                                     cxx_right_angle_brackets)
+  target_compile_features(pybind11_headers INTERFACE cxx_std_14)
   if(NOT "${PYBIND11_INTERNALS_VERSION}" STREQUAL "")
     target_compile_definitions(
       pybind11_headers INTERFACE "PYBIND11_INTERNALS_VERSION=${PYBIND11_INTERNALS_VERSION}")
diff --git a/docs/advanced/deprecated.rst b/docs/advanced/deprecated.rst
index c9f4a2e666..fde0423f47 100644
--- a/docs/advanced/deprecated.rst
+++ b/docs/advanced/deprecated.rst
@@ -3,8 +3,8 @@
 Deprecated
 ##########
 
-Support for C++11 is deprecated and will be removed in a future version. Please
-use at least C++14.
+Support for C++11 was removed in pybind11 3.1. Please use at least C++14;
+C++17 or newer is recommended.
 
 Support for FindPythonLibs (not available in CMake 3.26+ mode) is deprecated
 and will be removed in a future version. The default mode is also going to
diff --git a/docs/basics.rst b/docs/basics.rst
index 7f77f201fe..8bf0d12f04 100644
--- a/docs/basics.rst
+++ b/docs/basics.rst
@@ -143,7 +143,7 @@ On Linux, the above example can be compiled using the following command:
 
 .. code-block:: bash
 
-    $ c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3 -m pybind11 --extension-suffix)
+    $ c++ -O3 -Wall -shared -std=c++14 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3 -m pybind11 --extension-suffix)
 
 .. note::
 
diff --git a/docs/classes.rst b/docs/classes.rst
index 97ad72f3f6..a24e182f77 100644
--- a/docs/classes.rst
+++ b/docs/classes.rst
@@ -414,8 +414,7 @@ The overload signatures are also visible in the method's docstring:
      |
      |      Set the pet's name
 
-If you have a C++14 compatible compiler [#cpp14]_, you can use an alternative
-syntax to cast the overloaded function:
+You can also use an alternative syntax to cast the overloaded function:
 
 .. code-block:: cpp
 
@@ -439,20 +438,6 @@ on constness, the ``py::const_`` tag should be used:
        .def("foo_mutable", py::overload_cast<int, float>(&Widget::foo))
        .def("foo_const",   py::overload_cast<int, float>(&Widget::foo, py::const_));
 
-If you prefer the ``py::overload_cast`` syntax but have a C++11 compatible compiler only,
-you can use ``py::detail::overload_cast_impl`` with an additional set of parentheses:
-
-.. code-block:: cpp
-
-    template <typename... Args>
-    using overload_cast_ = pybind11::detail::overload_cast_impl<Args...>;
-
-    py::class_<Pet>(m, "Pet")
-        .def("set", overload_cast_<int>()(&Pet::set), "Set the pet's age")
-        .def("set", overload_cast_<const std::string &>()(&Pet::set), "Set the pet's name");
-
-.. [#cpp14] A compiler which supports the ``-std=c++14`` flag.
-
 .. note::
 
     To define multiple overloaded constructors, simply declare one after the
diff --git a/docs/compiling.rst b/docs/compiling.rst
index a6bee86ffe..8c8ec2af72 100644
--- a/docs/compiling.rst
+++ b/docs/compiling.rst
@@ -78,7 +78,7 @@ that. Your ``meson.build`` file would look something like this:
        'cpp',
        version: '0.1.0',
        default_options: [
-           'cpp_std=c++11',
+           'cpp_std=c++14',
        ],
    )
 
@@ -649,7 +649,7 @@ On Linux, you can compile an example such as the one given in
 
 .. code-block:: bash
 
-    $ c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix)
+    $ c++ -O3 -Wall -shared -std=c++14 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix)
 
 The ``python3 -m pybind11 --includes`` command fetches the include paths for
 both pybind11 and Python headers. This assumes that pybind11 has been installed
@@ -663,7 +663,7 @@ building the module:
 
 .. code-block:: bash
 
-    $ c++ -O3 -Wall -shared -std=c++11 -undefined dynamic_lookup $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix)
+    $ c++ -O3 -Wall -shared -std=c++14 -undefined dynamic_lookup $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix)
 
 For quick tests, the command line tool can also produce the full set of flags
 for you, based on ``python-config``:
diff --git a/include/pybind11/attr.h b/include/pybind11/attr.h
index d337595a0b..5daef10d73 100644
--- a/include/pybind11/attr.h
+++ b/include/pybind11/attr.h
@@ -677,28 +677,24 @@ struct process_attributes {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
         PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
         using expander = int[];
-        (void) expander{
-            0, ((void) process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
+        (void) expander{0, ((void) process_attribute<std::decay_t<Args>>::init(args, r), 0)...};
     }
     static void init(const Args &...args, type_record *r) {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
         PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
         using expander = int[];
-        (void) expander{0,
-                        (process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
+        (void) expander{0, (process_attribute<std::decay_t<Args>>::init(args, r), 0)...};
     }
     static void precall(function_call &call) {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call);
         using expander = int[];
-        (void) expander{0,
-                        (process_attribute<typename std::decay<Args>::type>::precall(call), 0)...};
+        (void) expander{0, (process_attribute<std::decay_t<Args>>::precall(call), 0)...};
     }
     static void postcall(function_call &call, handle fn_ret) {
         PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call, fn_ret);
         PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(fn_ret);
         using expander = int[];
-        (void) expander{
-            0, (process_attribute<typename std::decay<Args>::type>::postcall(call, fn_ret), 0)...};
+        (void) expander{0, (process_attribute<std::decay_t<Args>>::postcall(call, fn_ret), 0)...};
     }
 };
 
diff --git a/include/pybind11/cast.h b/include/pybind11/cast.h
index 1d857a0ed5..a6bf8389be 100644
--- a/include/pybind11/cast.h
+++ b/include/pybind11/cast.h
@@ -49,17 +49,18 @@ typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster
     return caster.operator result_t();
 }
 template <typename T>
-typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
+typename make_caster<T>::template cast_op_type<std::add_rvalue_reference_t<T>>
 cast_op(make_caster<T> &&caster) {
-    using result_t = typename make_caster<T>::template cast_op_type<
-        typename std::add_rvalue_reference<T>::type>; // See PR #4893
+    using result_t =
+        typename make_caster<T>::template cast_op_type<std::add_rvalue_reference_t<T>>; // See PR
+                                                                                        // #4893
     return std::move(caster).operator result_t();
 }
 
 template <typename EnumType>
 class type_caster_enum_type {
 private:
-    using Underlying = typename std::underlying_type<EnumType>::type;
+    using Underlying = std::underlying_type_t<EnumType>;
 
 public:
     static constexpr auto name = const_name<EnumType>();
@@ -167,11 +168,10 @@ class type_caster<std::reference_wrapper<type>> {
     using reference_t = type &;
     using subcaster_cast_op_type = typename caster_t::template cast_op_type<reference_t>;
 
-    static_assert(
-        std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value
-            || std::is_same<reference_t, subcaster_cast_op_type>::value,
-        "std::reference_wrapper<T> caster requires T to have a caster with an "
-        "`operator T &()` or `operator const T &()`");
+    static_assert(std::is_same<std::remove_const_t<type> &, subcaster_cast_op_type>::value
+                      || std::is_same<reference_t, subcaster_cast_op_type>::value,
+                  "std::reference_wrapper<T> caster requires T to have a caster with an "
+                  "`operator T &()` or `operator const T &()`");
 
 public:
     bool load(handle src, bool convert) { return subcaster.load(src, convert); }
@@ -230,9 +230,8 @@ using is_std_char_type = any_of<std::is_same<CharT, char>, /* std::string */
 template <typename T>
 struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
     using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
-    using _py_type_1 = conditional_t<std::is_signed<T>::value,
-                                     _py_type_0,
-                                     typename std::make_unsigned<_py_type_0>::type>;
+    using _py_type_1
+        = conditional_t<std::is_signed<T>::value, _py_type_0, std::make_unsigned_t<_py_type_0>>;
     using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
 
 public:
@@ -310,39 +309,39 @@ struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_t
     }
 
     template <typename U = T>
-    static typename std::enable_if<std::is_floating_point<U>::value, handle>::type
+    static std::enable_if_t<std::is_floating_point<U>::value, handle>
     cast(U src, return_value_policy /* policy */, handle /* parent */) {
         return PyFloat_FromDouble((double) src);
     }
 
     template <typename U = T>
-    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value
-                                       && (sizeof(U) <= sizeof(long)),
-                                   handle>::type
+    static std::enable_if_t<!std::is_floating_point<U>::value && std::is_signed<U>::value
+                                && (sizeof(U) <= sizeof(long)),
+                            handle>
     cast(U src, return_value_policy /* policy */, handle /* parent */) {
         return PYBIND11_LONG_FROM_SIGNED((long) src);
     }
 
     template <typename U = T>
-    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
-                                       && (sizeof(U) <= sizeof(unsigned long)),
-                                   handle>::type
+    static std::enable_if_t<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
+                                && (sizeof(U) <= sizeof(unsigned long)),
+                            handle>
     cast(U src, return_value_policy /* policy */, handle /* parent */) {
         return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src);
     }
 
     template <typename U = T>
-    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_signed<U>::value
-                                       && (sizeof(U) > sizeof(long)),
-                                   handle>::type
+    static std::enable_if_t<!std::is_floating_point<U>::value && std::is_signed<U>::value
+                                && (sizeof(U) > sizeof(long)),
+                            handle>
     cast(U src, return_value_policy /* policy */, handle /* parent */) {
         return PyLong_FromLongLong((long long) src);
     }
 
     template <typename U = T>
-    static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
-                                       && (sizeof(U) > sizeof(unsigned long)),
-                                   handle>::type
+    static std::enable_if_t<!std::is_floating_point<U>::value && std::is_unsigned<U>::value
+                                && (sizeof(U) > sizeof(unsigned long)),
+                            handle>
     cast(U src, return_value_policy /* policy */, handle /* parent */) {
         return PyLong_FromUnsignedLongLong((unsigned long long) src);
     }
@@ -1269,13 +1268,12 @@ struct move_only_holder_caster<
     }
 
     template <typename T_>
-    using cast_op_type
-        = conditional_t<std::is_same<typename std::remove_volatile<T_>::type,
-                                     const std::unique_ptr<type, deleter> &>::value
-                            || std::is_same<typename std::remove_volatile<T_>::type,
-                                            const std::unique_ptr<const type, deleter> &>::value,
-                        const std::unique_ptr<type, deleter> &,
-                        std::unique_ptr<type, deleter>>;
+    using cast_op_type = conditional_t<
+        std::is_same<std::remove_volatile_t<T_>, const std::unique_ptr<type, deleter> &>::value
+            || std::is_same<std::remove_volatile_t<T_>,
+                            const std::unique_ptr<const type, deleter> &>::value,
+        const std::unique_ptr<type, deleter> &,
+        std::unique_ptr<type, deleter>>;
 
     explicit operator std::unique_ptr<type, deleter>() {
         if (typeinfo->holder_enum_v == detail::holder_enum_t::smart_holder) {
@@ -1738,7 +1736,7 @@ template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> =
 object cast(T &&value,
             return_value_policy policy = return_value_policy::automatic_reference,
             handle parent = handle()) {
-    using no_ref_T = typename std::remove_reference<T>::type;
+    using no_ref_T = std::remove_reference_t<T>;
     if (policy == return_value_policy::automatic) {
         policy = std::is_pointer<no_ref_T>::value     ? return_value_policy::take_ownership
                  : std::is_lvalue_reference<T>::value ? return_value_policy::copy
diff --git a/include/pybind11/detail/argument_vector.h b/include/pybind11/detail/argument_vector.h
index 6e2c2ec481..41da4872d7 100644
--- a/include/pybind11/detail/argument_vector.h
+++ b/include/pybind11/detail/argument_vector.h
@@ -31,7 +31,7 @@ PYBIND11_WARNING_DISABLE_MSVC(4127)
 PYBIND11_NAMESPACE_BEGIN(detail)
 
 // Shared implementation utility for our small_vector-like containers.
-// We support C++11 and C++14, so we cannot use
+// We support C++14, so we cannot use
 // std::variant. Union with the tag packed next to the inline
 // array's size is smaller anyway, allowing 1 extra handle of
 // inline storage for free. Compare the layouts (1 line per
diff --git a/include/pybind11/detail/common.h b/include/pybind11/detail/common.h
index 740001db78..e52871284d 100644
--- a/include/pybind11/detail/common.h
+++ b/include/pybind11/detail/common.h
@@ -72,6 +72,10 @@
 #    endif
 #endif
 
+#if !defined(PYBIND11_CPP14)
+#    error "pybind11 requires C++14 or newer"
+#endif
+
 // These PYBIND11_HAS_... macros are consolidated in pybind11/detail/common.h
 // to simplify backward compatibility handling for users (e.g., via #ifdef checks):
 #define PYBIND11_HAS_TYPE_CASTER_STD_FUNCTION_SPECIALIZATIONS 1
@@ -109,10 +113,8 @@
 
 // Compiler version assertions
 #if defined(__INTEL_COMPILER)
-#    if __INTEL_COMPILER < 1800
-#        error pybind11 requires Intel C++ compiler v18 or newer
-#    elif __INTEL_COMPILER < 1900 && defined(PYBIND11_CPP14)
-#        error pybind11 supports only C++11 with Intel C++ compiler v18. Use v19 or newer for C++14.
+#    if __INTEL_COMPILER < 1900
+#        error pybind11 requires Intel C++ compiler v19 or newer
 #    endif
 /* The following pragma cannot be pop'ed:
    https://community.intel.com/t5/Intel-C-Compiler/Inline-and-no-inline-warning/td-p/1216764 */
@@ -179,10 +181,8 @@
 // For unknown reasons all PYBIND11_DEPRECATED member trigger a warning when declared
 // whether it is used or not
 #    define PYBIND11_DEPRECATED(reason)
-#elif defined(PYBIND11_CPP14)
-#    define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
 #else
-#    define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
+#    define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
 #endif
 
 #if defined(PYBIND11_CPP17)
@@ -203,9 +203,8 @@
 #    if defined(PYBIND11_CPP17) && __has_include(<optional>)
 #        define PYBIND11_HAS_OPTIONAL 1
 #    endif
-// std::experimental::optional (but not allowed in c++11 mode)
-#    if defined(PYBIND11_CPP14) && (__has_include(<experimental/optional>) && \
-                                 !__has_include(<optional>))
+// std::experimental::optional
+#    if __has_include(<experimental/optional>) && !__has_include(<optional>)
 #        define PYBIND11_HAS_EXP_OPTIONAL 1
 #    endif
 // std::variant
@@ -706,22 +705,11 @@ static_assert(std::is_standard_layout<instance>::value,
 template <typename>
 struct always_false : std::false_type {};
 
-/// from __cpp_future__ import (convenient aliases from C++14/17)
-#if defined(PYBIND11_CPP14)
+/// Convenient aliases from C++14
 using std::conditional_t;
 using std::enable_if_t;
 using std::remove_cv_t;
 using std::remove_reference_t;
-#else
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, typename T, typename F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-template <typename T>
-using remove_cv_t = typename std::remove_cv<T>::type;
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-#endif
 
 #if defined(PYBIND11_CPP20) && defined(__cpp_lib_remove_cvref)
 using std::remove_cvref;
@@ -740,56 +728,8 @@ template <typename T, typename U>
 using is_same_ignoring_cvref = std::is_same<detail::remove_cvref_t<T>, U>;
 
 /// Index sequences
-#if defined(PYBIND11_CPP14)
 using std::index_sequence;
 using std::make_index_sequence;
-#else
-template <size_t...>
-struct index_sequence {};
-// Comments about the algorithm below.
-//
-// Credit: This is based on an algorithm by taocpp here:
-//    https://github.com/taocpp/sequences/blob/main/include/tao/seq/make_integer_sequence.hpp
-// but significantly simplified.
-//
-// We build up a sequence S by repeatedly doubling its length and sometimes adding 1 to the end.
-// E.g. if the current S is 0...3, then we either go to 0...7 or 0...8 on the next pass.
-// The goal is to end with S = 0...N-1.
-// The key insight is that the times we need to add an additional digit to S correspond
-// exactly to the 1's in the binary representation of the number N.
-//
-// Invariants:
-// - digit is a power of 2
-// - N_digit_is_1 is whether N's binary representation has a 1 in that digit's position.
-// - end <= N
-// - S is 0...end-1.
-// - if digit > 0, end * digit * 2 <= N < (end+1) * digit * 2
-//
-// The process starts with digit > N, end = 0, and S is empty.
-// The process concludes with digit=0, in which case, end == N and S is 0...N-1.
-
-template <size_t digit, bool N_digit_is_1, size_t N, size_t end, size_t... S> // N_digit_is_1=false
-struct make_index_sequence_impl
-    : make_index_sequence_impl<digit / 2, (N & (digit / 2)) != 0, N, 2 * end, S..., (S + end)...> {
-};
-template <size_t digit, size_t N, size_t end, size_t... S>
-struct make_index_sequence_impl<digit, true, N, end, S...>
-    : make_index_sequence_impl<digit / 2,
-                               (N & (digit / 2)) != 0,
-                               N,
-                               2 * end + 1,
-                               S...,
-                               (S + end)...,
-                               2 * end> {};
-template <size_t N, size_t end, size_t... S>
-struct make_index_sequence_impl<0, false, N, end, S...> {
-    using type = index_sequence<S...>;
-};
-constexpr size_t next_power_of_2(size_t N) { return N == 0 ? 1 : next_power_of_2(N >> 1) << 1; }
-template <size_t N>
-using make_index_sequence =
-    typename make_index_sequence_impl<next_power_of_2(N), false, N, 0>::type;
-#endif
 
 /// Make an index sequence of the indices of true arguments
 template <typename ISeq, size_t, bool...>
@@ -917,45 +857,38 @@ template <typename...>
 struct type_list {};
 
 /// Compile-time integer sum
-#ifdef __cpp_fold_expressions
 template <typename... Ts>
 constexpr size_t constexpr_sum(Ts... ns) {
-    return (0 + ... + size_t{ns});
-}
-#else
-constexpr size_t constexpr_sum() { return 0; }
-template <typename T, typename... Ts>
-constexpr size_t constexpr_sum(T n, Ts... ns) {
-    return size_t{n} + constexpr_sum(ns...);
-}
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(constexpr_impl)
-/// Implementation details for constexpr functions
-constexpr int first(int i) { return i; }
-template <typename T, typename... Ts>
-constexpr int first(int i, T v, Ts... vs) {
-    return v ? i : first(i + 1, vs...);
-}
-
-constexpr int last(int /*i*/, int result) { return result; }
-template <typename T, typename... Ts>
-constexpr int last(int i, int result, T v, Ts... vs) {
-    return last(i + 1, v ? i : result, vs...);
+    size_t result = 0;
+    for (size_t n : {size_t{0}, size_t{ns}...}) {
+        result += n;
+    }
+    return result;
 }
-PYBIND11_NAMESPACE_END(constexpr_impl)
 
 /// Return the index of the first type in Ts which satisfies Predicate<T>.
 /// Returns sizeof...(Ts) if none match.
 template <template <typename> class Predicate, typename... Ts>
 constexpr int constexpr_first() {
-    return constexpr_impl::first(0, Predicate<Ts>::value...);
+    constexpr bool matches[] = {Predicate<Ts>::value..., false};
+    for (int i = 0; i < static_cast<int>(sizeof...(Ts)); ++i) {
+        if (matches[i]) {
+            return i;
+        }
+    }
+    return static_cast<int>(sizeof...(Ts));
 }
 
 /// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
 template <template <typename> class Predicate, typename... Ts>
 constexpr int constexpr_last() {
-    return constexpr_impl::last(0, -1, Predicate<Ts>::value...);
+    constexpr bool matches[] = {Predicate<Ts>::value..., false};
+    for (int i = static_cast<int>(sizeof...(Ts)) - 1; i >= 0; --i) {
+        if (matches[i]) {
+            return i;
+        }
+    }
+    return -1;
 }
 
 /// Return the Nth element from the parameter pack
@@ -1059,9 +992,8 @@ struct is_input_iterator<T,
     : std::true_type {};
 
 template <typename T>
-using is_function_pointer
-    = bool_constant<std::is_pointer<T>::value
-                    && std::is_function<typename std::remove_pointer<T>::type>::value>;
+using is_function_pointer = bool_constant<std::is_pointer<T>::value
+                                          && std::is_function<std::remove_pointer_t<T>>::value>;
 
 template <typename F>
 struct strip_function_object {
@@ -1277,29 +1209,18 @@ struct overload_cast_impl {
 };
 PYBIND11_NAMESPACE_END(detail)
 
-// overload_cast requires variable templates: C++14
-#if defined(PYBIND11_CPP14)
-#    define PYBIND11_OVERLOAD_CAST 1
+#define PYBIND11_OVERLOAD_CAST 1
 /// Syntax sugar for resolving overloaded function pointers:
 ///  - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
 ///  - sweet:   overload_cast<Arg0, Arg1, Arg2>(&Class::func)
 template <typename... Args>
 static constexpr detail::overload_cast_impl<Args...> overload_cast{};
-#endif
 
 /// Const member function selector for overload_cast
 ///  - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
 ///  - sweet:   overload_cast<Arg>(&Class::func, const_)
 static constexpr auto const_ = std::true_type{};
 
-#if !defined(PYBIND11_CPP14) // no overload_cast: providing something that static_assert-fails:
-template <typename... Args>
-struct overload_cast {
-    static_assert(detail::deferred_t<std::false_type, Args...>::value,
-                  "pybind11::overload_cast<...> requires compiling in C++14 mode");
-};
-#endif // overload_cast
-
 PYBIND11_NAMESPACE_BEGIN(detail)
 
 // Adaptor for converting arbitrary container arguments into a vector; implicitly convertible from
diff --git a/include/pybind11/detail/init.h b/include/pybind11/detail/init.h
index a1083f8457..ae2f66bd62 100644
--- a/include/pybind11/detail/init.h
+++ b/include/pybind11/detail/init.h
@@ -388,17 +388,9 @@ struct factory<Func, void_type (*)(), Return(Args...), void_type()> {
     // instance, or the alias needs to be constructible from a `Class &&` argument.
     template <typename Class, typename... Extra>
     void execute(Class &cl, const Extra &...extra) && {
-#if defined(PYBIND11_CPP14)
         cl.def(
             "__init__",
-            [func = std::move(class_factory)]
-#else
-        auto &func = class_factory;
-        cl.def(
-            "__init__",
-            [func]
-#endif
-            (value_and_holder &v_h, Args... args) {
+            [func = std::move(class_factory)](value_and_holder &v_h, Args... args) {
                 construct<Class>(
                     v_h, func(std::forward<Args>(args)...), Py_TYPE(v_h.inst) != v_h.type->type);
             },
@@ -435,18 +427,10 @@ struct factory<CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> {
         static_assert(Class::has_alias,
                       "The two-argument version of `py::init()` can "
                       "only be used if the class has an alias");
-#if defined(PYBIND11_CPP14)
-        cl.def(
-            "__init__",
-            [class_func = std::move(class_factory), alias_func = std::move(alias_factory)]
-#else
-        auto &class_func = class_factory;
-        auto &alias_func = alias_factory;
         cl.def(
             "__init__",
-            [class_func, alias_func]
-#endif
-            (value_and_holder &v_h, CArgs... args) {
+            [class_func = std::move(class_factory),
+             alias_func = std::move(alias_factory)](value_and_holder &v_h, CArgs... args) {
                 if (Py_TYPE(v_h.inst) == v_h.type->type) {
                     // If the instance type equals the registered type we don't have inheritance,
                     // so don't need the alias and can construct using the class function:
@@ -524,17 +508,9 @@ struct pickle_factory<Get, Set, RetState(Self), NewInstance(ArgState)> {
     void execute(Class &cl, const Extra &...extra) && {
         cl.def("__getstate__", std::move(get), pos_only());
 
-#if defined(PYBIND11_CPP14)
-        cl.def(
-            "__setstate__",
-            [func = std::move(set)]
-#else
-        auto &func = set;
         cl.def(
             "__setstate__",
-            [func]
-#endif
-            (value_and_holder &v_h, ArgState state) {
+            [func = std::move(set)](value_and_holder &v_h, ArgState state) {
                 setstate<Class>(
                     v_h, func(std::forward<ArgState>(state)), Py_TYPE(v_h.inst) != v_h.type->type);
             },
diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
index 295485ffab..d79e36b7ce 100644
--- a/include/pybind11/detail/internals.h
+++ b/include/pybind11/detail/internals.h
@@ -626,7 +626,7 @@ std::pair<Payload *, bool> atomic_get_or_create_in_state_dict(const char *key,
         // Storage doesn't exist yet, create a new one.
         // Use unique_ptr for exception safety: if capsule creation throws, the storage is
         // automatically deleted.
-        auto storage_ptr = std::unique_ptr<Payload>(new Payload{});
+        auto storage_ptr = std::make_unique<Payload>();
         auto new_capsule
             = capsule(storage_ptr.get(),
                       // The destructor will be called when the capsule is GC'ed.
@@ -753,7 +753,7 @@ class internals_pp_manager {
         // Assume the GIL is held here. May call back into Python. We cannot hold the lock with our
         // mutex here. So there may be multiple threads creating the content at the same time. Only
         // one will install its content to pp below. Others will be freed when going out of scope.
-        auto tmp = std::unique_ptr<InternalsType>(new InternalsType());
+        auto tmp = std::make_unique<InternalsType>();
 
         {
             // Lock scope must not include Python calls, which may require the GIL and cause
diff --git a/include/pybind11/detail/struct_smart_holder.h b/include/pybind11/detail/struct_smart_holder.h
index 5d7c31cdaf..3efcb4ebfd 100644
--- a/include/pybind11/detail/struct_smart_holder.h
+++ b/include/pybind11/detail/struct_smart_holder.h
@@ -108,12 +108,12 @@ inline guarded_delete *get_guarded_delete(const std::shared_ptr<void> &ptr) {
 
 using get_guarded_delete_fn = guarded_delete *(*) (const std::shared_ptr<void> &);
 
-template <typename T, typename std::enable_if<std::is_destructible<T>::value, int>::type = 0>
+template <typename T, std::enable_if_t<std::is_destructible<T>::value, int> = 0>
 inline void std_default_delete_if_destructible(void *raw_ptr) {
     std::default_delete<T>{}(static_cast<T *>(raw_ptr));
 }
 
-template <typename T, typename std::enable_if<!std::is_destructible<T>::value, int>::type = 0>
+template <typename T, std::enable_if_t<!std::is_destructible<T>::value, int> = 0>
 inline void std_default_delete_if_destructible(void *) {
     // This noop operator is needed to avoid a compilation error (for `delete raw_ptr;`), but
     // throwing an exception from a destructor will std::terminate the process. Therefore the
@@ -273,7 +273,7 @@ struct smart_holder {
             }
             static_assert(std::is_copy_constructible<D>::value,
                           "Required for compatibility with smart_holder functionality.");
-            return std::unique_ptr<D>(new D(custom_deleter_ptr->deleter));
+            return std::make_unique<D>(custom_deleter_ptr->deleter);
         }
         return nullptr;
     }
diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
index 161b9884fa..73836d844c 100644
--- a/include/pybind11/detail/type_caster_base.h
+++ b/include/pybind11/detail/type_caster_base.h
@@ -842,7 +842,7 @@ struct shared_ptr_trampoline_self_life_support {
 
 template <typename T,
           typename D,
-          typename std::enable_if<std::is_default_constructible<D>::value, int>::type = 0>
+          std::enable_if_t<std::is_default_constructible<D>::value, int> = 0>
 inline std::unique_ptr<T, D> unique_with_deleter(T *raw_ptr, std::unique_ptr<D> &&deleter) {
     if (deleter == nullptr) {
         return std::unique_ptr<T, D>(raw_ptr);
@@ -852,7 +852,7 @@ inline std::unique_ptr<T, D> unique_with_deleter(T *raw_ptr, std::unique_ptr<D>
 
 template <typename T,
           typename D,
-          typename std::enable_if<!std::is_default_constructible<D>::value, int>::type = 0>
+          std::enable_if_t<!std::is_default_constructible<D>::value, int> = 0>
 inline std::unique_ptr<T, D> unique_with_deleter(T *raw_ptr, std::unique_ptr<D> &&deleter) {
     if (deleter == nullptr) {
         pybind11_fail("smart_holder_type_casters: deleter is not default constructible and no"
@@ -1361,8 +1361,8 @@ inline object cpp_conduit_method(handle self,
  */
 template <typename T>
 using cast_op_type = conditional_t<std::is_pointer<remove_reference_t<T>>::value,
-                                   typename std::add_pointer<intrinsic_t<T>>::type,
-                                   typename std::add_lvalue_reference<intrinsic_t<T>>::type>;
+                                   std::add_pointer_t<intrinsic_t<T>>,
+                                   std::add_lvalue_reference_t<intrinsic_t<T>>>;
 
 /**
  * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
@@ -1373,11 +1373,11 @@ using cast_op_type = conditional_t<std::is_pointer<remove_reference_t<T>>::value
  */
 template <typename T>
 using movable_cast_op_type
-    = conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
-                    typename std::add_pointer<intrinsic_t<T>>::type,
+    = conditional_t<std::is_pointer<std::remove_reference_t<T>>::value,
+                    std::add_pointer_t<intrinsic_t<T>>,
                     conditional_t<std::is_rvalue_reference<T>::value,
-                                  typename std::add_rvalue_reference<intrinsic_t<T>>::type,
-                                  typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
+                                  std::add_rvalue_reference_t<intrinsic_t<T>>,
+                                  std::add_lvalue_reference_t<intrinsic_t<T>>>>;
 
 // Does the container have a mapped type and is it recursive?
 // Implemented by specializations below.
@@ -1390,8 +1390,7 @@ struct container_mapped_type_traits {
 template <typename Container>
 struct container_mapped_type_traits<
     Container,
-    typename std::enable_if<
-        std::is_same<typename Container::mapped_type, Container>::value>::type> {
+    std::enable_if_t<std::is_same<typename Container::mapped_type, Container>::value>> {
     static constexpr bool has_mapped_type = true;
     static constexpr bool has_recursive_mapped_type = true;
 };
@@ -1399,8 +1398,7 @@ struct container_mapped_type_traits<
 template <typename Container>
 struct container_mapped_type_traits<
     Container,
-    typename std::enable_if<
-        negation<std::is_same<typename Container::mapped_type, Container>>::value>::type> {
+    std::enable_if_t<negation<std::is_same<typename Container::mapped_type, Container>>::value>> {
     static constexpr bool has_mapped_type = true;
     static constexpr bool has_recursive_mapped_type = false;
 };
@@ -1416,8 +1414,7 @@ struct container_value_type_traits : std::false_type {
 template <typename Container>
 struct container_value_type_traits<
     Container,
-    typename std::enable_if<
-        std::is_same<typename Container::value_type, Container>::value>::type> {
+    std::enable_if_t<std::is_same<typename Container::value_type, Container>::value>> {
     static constexpr bool has_value_type = true;
     static constexpr bool has_recursive_value_type = true;
 };
@@ -1425,8 +1422,7 @@ struct container_value_type_traits<
 template <typename Container>
 struct container_value_type_traits<
     Container,
-    typename std::enable_if<
-        negation<std::is_same<typename Container::value_type, Container>>::value>::type> {
+    std::enable_if_t<negation<std::is_same<typename Container::value_type, Container>>::value>> {
     static constexpr bool has_value_type = true;
     static constexpr bool has_recursive_value_type = false;
 };
@@ -1461,8 +1457,8 @@ struct impl_type_to_check_recursively {
  */
 template <typename A, typename B>
 struct impl_type_to_check_recursively<std::pair<A, B>, /* is_this_a_map = */ true> {
-    using if_recursive = typename std::remove_const<A>::type;
-    using if_not_recursive = std::pair<typename std::remove_const<A>::type, B>;
+    using if_recursive = std::remove_const_t<A>;
+    using if_not_recursive = std::pair<std::remove_const_t<A>, B>;
 };
 
 /*
@@ -1476,7 +1472,7 @@ struct impl_recursive_container_traits {
 template <typename Container>
 struct impl_recursive_container_traits<
     Container,
-    typename std::enable_if<container_value_type_traits<Container>::has_value_type>::type> {
+    std::enable_if_t<container_value_type_traits<Container>::has_value_type>> {
     static constexpr bool is_recursive
         = container_mapped_type_traits<Container>::has_recursive_mapped_type
           || container_value_type_traits<Container>::has_recursive_value_type;
@@ -1489,14 +1485,14 @@ struct impl_recursive_container_traits<
      *    should be removed.
      *
      */
-    using type_to_check_recursively = typename std::conditional<
+    using type_to_check_recursively = std::conditional_t<
         is_recursive,
         typename impl_type_to_check_recursively<
             typename Container::value_type,
             container_mapped_type_traits<Container>::has_mapped_type>::if_recursive,
         typename impl_type_to_check_recursively<
             typename Container::value_type,
-            container_mapped_type_traits<Container>::has_mapped_type>::if_not_recursive>::type;
+            container_mapped_type_traits<Container>::has_mapped_type>::if_not_recursive>;
 };
 
 /*
diff --git a/include/pybind11/eigen/tensor.h b/include/pybind11/eigen/tensor.h
index e5c8441032..041c5b6fba 100644
--- a/include/pybind11/eigen/tensor.h
+++ b/include/pybind11/eigen/tensor.h
@@ -492,8 +492,8 @@ struct type_caster<Eigen::TensorMap<Type, Options>,
 
 #if EIGEN_VERSION_AT_LEAST(3, 4, 0)
 
-    static constexpr bool needs_writeable = !std::is_const<typename std::remove_pointer<
-        typename get_storage_pointer_type<MapType>::SPT>::type>::value;
+    static constexpr bool needs_writeable = !std::is_const<
+        std::remove_pointer_t<typename get_storage_pointer_type<MapType>::SPT>>::value;
 #else
     // Handle Eigen bug
     static constexpr bool needs_writeable = !std::is_const<Type>::value;
diff --git a/include/pybind11/functional.h b/include/pybind11/functional.h
index c06fabe0d6..907cad5ba4 100644
--- a/include/pybind11/functional.h
+++ b/include/pybind11/functional.h
@@ -33,7 +33,8 @@ struct func_handle {
     }
 };
 
-// to emulate 'move initialization capture' in C++11
+// Shared base for the func_wrapper specializations below and any user-provided
+// ones (see PYBIND11_HAS_TYPE_CASTER_STD_FUNCTION_SPECIALIZATIONS).
 struct func_wrapper_base {
     func_handle hfunc;
     explicit func_wrapper_base(func_handle &&hf) noexcept : hfunc(hf) {}
diff --git a/include/pybind11/iostream.h b/include/pybind11/iostream.h
index df7fa3c381..c07a0d8e8f 100644
--- a/include/pybind11/iostream.h
+++ b/include/pybind11/iostream.h
@@ -248,10 +248,10 @@ class OstreamRedirect {
 
     void enter() {
         if (do_stdout_) {
-            redirect_stdout.reset(new scoped_ostream_redirect());
+            redirect_stdout = std::make_unique<scoped_ostream_redirect>();
         }
         if (do_stderr_) {
-            redirect_stderr.reset(new scoped_estream_redirect());
+            redirect_stderr = std::make_unique<scoped_estream_redirect>();
         }
     }
 
diff --git a/include/pybind11/native_enum.h b/include/pybind11/native_enum.h
index af166d0c86..9c3156b89e 100644
--- a/include/pybind11/native_enum.h
+++ b/include/pybind11/native_enum.h
@@ -20,7 +20,7 @@ PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 template <typename EnumType>
 class native_enum : public detail::native_enum_data {
 public:
-    using Underlying = typename std::underlying_type<EnumType>::type;
+    using Underlying = std::underlying_type_t<EnumType>;
 
     native_enum(handle parent_scope,
                 const char *name,
diff --git a/include/pybind11/numpy.h b/include/pybind11/numpy.h
index 22e11bcbad..dd3d42bd4d 100644
--- a/include/pybind11/numpy.h
+++ b/include/pybind11/numpy.h
@@ -158,7 +158,7 @@ struct numpy_internals {
 
     template <typename T>
     numpy_type_info *get_type_info(bool throw_if_missing = true) {
-        return get_type_info(typeid(typename std::remove_cv<T>::type), throw_if_missing);
+        return get_type_info(typeid(std::remove_cv_t<T>), throw_if_missing);
     }
 };
 
@@ -715,12 +715,11 @@ class unchecked_reference {
     /// shapes
     template <bool Dyn = Dynamic>
     enable_if_t<!Dyn, ssize_t> size() const {
-        return std::accumulate(
-            shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies<ssize_t>());
+        return std::accumulate(shape_.begin(), shape_.end(), (ssize_t) 1, std::multiplies<>());
     }
     template <bool Dyn = Dynamic>
     enable_if_t<Dyn, ssize_t> size() const {
-        return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
+        return std::accumulate(shape_, shape_ + ndim(), (ssize_t) 1, std::multiplies<>());
     }
 
     /// Returns the total number of bytes used by the referenced data.  Note that the actual span
@@ -881,14 +880,14 @@ class dtype : public object {
     /// Return dtype associated with a C++ type.
     template <typename T>
     static dtype of() {
-        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::dtype();
+        return detail::npy_format_descriptor<std::remove_cv_t<T>>::dtype();
     }
 
     /// Return the type number associated with a C++ type.
     /// This is the constexpr equivalent of `dtype::of<T>().num()`.
     template <typename T>
     static constexpr int num_of() {
-        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::value;
+        return detail::npy_format_descriptor<std::remove_cv_t<T>>::value;
     }
 
     /// Size of the data type in bytes.
@@ -1129,7 +1128,7 @@ class array : public buffer {
 
     /// Total number of elements
     ssize_t size() const {
-        return std::accumulate(shape(), shape() + ndim(), (ssize_t) 1, std::multiplies<ssize_t>());
+        return std::accumulate(shape(), shape() + ndim(), (ssize_t) 1, std::multiplies<>());
     }
 
     /// Byte size of a single element
@@ -1528,7 +1527,7 @@ class array_t : public array {
 template <typename T>
 struct format_descriptor<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
     static std::string format() {
-        return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::format();
+        return detail::npy_format_descriptor<std::remove_cv_t<T>>::format();
     }
 };
 
@@ -1544,8 +1543,7 @@ struct format_descriptor<std::array<char, N>> {
 template <typename T>
 struct format_descriptor<T, detail::enable_if_t<std::is_enum<T>::value>> {
     static std::string format() {
-        return format_descriptor<
-            typename std::remove_cv<typename std::underlying_type<T>::type>::type>::format();
+        return format_descriptor<std::remove_cv_t<std::underlying_type_t<T>>>::format();
     }
 };
 
@@ -1662,7 +1660,7 @@ struct npy_format_descriptor<T, enable_if_t<array_info<T>::is_array>> {
 template <typename T>
 struct npy_format_descriptor<T, enable_if_t<std::is_enum<T>::value>> {
 private:
-    using base_descr = npy_format_descriptor<typename std::underlying_type<T>::type>;
+    using base_descr = npy_format_descriptor<std::underlying_type_t<T>>;
 
 public:
     static constexpr auto name = base_descr::name;
@@ -1767,10 +1765,8 @@ struct npy_format_descriptor {
     }
 
     static void register_dtype(any_container<field_descriptor> fields) {
-        register_structured_dtype(std::move(fields),
-                                  typeid(typename std::remove_cv<T>::type),
-                                  sizeof(T),
-                                  &direct_converter);
+        register_structured_dtype(
+            std::move(fields), typeid(std::remove_cv_t<T>), sizeof(T), &direct_converter);
     }
 
 private:
@@ -2155,8 +2151,8 @@ struct vectorize_helper {
 public:
     template <typename T,
               // SFINAE to prevent shadowing the copy constructor.
-              typename = detail::enable_if_t<
-                  !std::is_same<vectorize_helper, typename std::decay<T>::type>::value>>
+              typename
+              = detail::enable_if_t<!std::is_same<vectorize_helper, std::decay_t<T>>::value>>
     explicit vectorize_helper(T &&f) : f(std::forward<T>(f)) {}
 
     object operator()(typename vectorize_arg<Args>::type... args) {
@@ -2173,7 +2169,7 @@ struct vectorize_helper {
     // with "/permissive-" flag when arg_call_types is manually inlined.
     using arg_call_types = std::tuple<typename vectorize_arg<Args>::call_type...>;
     template <size_t Index>
-    using param_n_t = typename std::tuple_element<Index, arg_call_types>::type;
+    using param_n_t = std::tuple_element_t<Index, arg_call_types>;
 
     using returned_array = vectorize_returned_array<Func, Return, Args...>;
 
@@ -2205,8 +2201,7 @@ struct vectorize_helper {
         auto trivial = broadcast(buffers, nd, shape);
         auto ndim = (size_t) nd;
 
-        size_t size
-            = std::accumulate(shape.begin(), shape.end(), (size_t) 1, std::multiplies<size_t>());
+        size_t size = std::accumulate(shape.begin(), shape.end(), (size_t) 1, std::multiplies<>());
 
         // If all arguments are 0-dimension arrays (i.e. single values) return a plain value (i.e.
         // not wrapped in an array).
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
index eebb130694..3937d9bdb3 100644
--- a/include/pybind11/pybind11.h
+++ b/include/pybind11/pybind11.h
@@ -1,5 +1,5 @@
 /*
-    pybind11/pybind11.h: Main header file of the C++11 python
+    pybind11/pybind11.h: Main header file of the C++14 python
     binding generator library
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -262,25 +262,20 @@ inline std::string generate_type_signature() {
 #    define PYBIND11_COMPAT_STRDUP strdup
 #endif
 
-#define PYBIND11_READABLE_FUNCTION_SIGNATURE_EXPR                                                 \
-    detail::const_name("(") + cast_in::arg_names + detail::const_name(") -> ") + cast_out::name
-
 // We factor out readable function signatures to a specific template
 // so that they don't get duplicated across different instantiations of
 // cpp_function::initialize (which is templated on more types).
 template <typename cast_in, typename cast_out>
 class ReadableFunctionSignature {
-public:
-    using sig_type = decltype(PYBIND11_READABLE_FUNCTION_SIGNATURE_EXPR);
-
 private:
-    // We have to repeat PYBIND11_READABLE_FUNCTION_SIGNATURE_EXPR in decltype()
-    // because C++11 doesn't allow functions to return `auto`. (We don't
-    // know the type because it's some variant of detail::descr<N> with
-    // unknown N.)
-    static constexpr sig_type sig() { return PYBIND11_READABLE_FUNCTION_SIGNATURE_EXPR; }
+    // The type is some variant of detail::descr<N> with an N dependent on the casters.
+    static constexpr auto sig() {
+        return detail::const_name("(") + cast_in::arg_names + detail::const_name(") -> ")
+               + cast_out::name;
+    }
 
 public:
+    using sig_type = decltype(sig());
     static constexpr sig_type kSig = sig();
     // We can only stash the result of detail::descr::types() in a
     // constexpr variable if we aren't on MSVC (see
@@ -290,7 +285,6 @@ class ReadableFunctionSignature {
     static constexpr types_type kTypes = sig_type::types();
 #endif
 };
-#undef PYBIND11_READABLE_FUNCTION_SIGNATURE_EXPR
 
 // Prior to C++17, we don't have inline variables, so we have to
 // provide an out-of-line definition of the class member.
@@ -654,7 +648,7 @@ class cpp_function : public function {
         static constexpr const auto &types
             = detail::ReadableFunctionSignature<cast_in, cast_out>::kTypes;
 #else
-        PYBIND11_DESCR_CONSTEXPR auto types = std::decay<decltype(signature)>::type::types();
+        PYBIND11_DESCR_CONSTEXPR auto types = std::decay_t<decltype(signature)>::types();
 #endif
 
         /* Register the function with Python from generic (non-templated) code */
@@ -2143,7 +2137,7 @@ struct both_t_and_d_use_type_caster_base<
 // This prevents disowning of the Python object owning the raw pointer member.
 template <typename T, typename D>
 struct property_cpp_function_sh_raw_ptr_member {
-    using drp = typename std::remove_pointer<D>::type;
+    using drp = std::remove_pointer_t<D>;
 
     template <typename PM, must_be_member_function_pointer<PM> = 0>
     static cpp_function readonly(PM pm, const handle &hdl) {
@@ -2190,12 +2184,11 @@ struct property_cpp_function_sh_member_held_by_value {
         type_info *tinfo = get_type_info(typeid(T), /*throw_if_missing=*/true);
         if (tinfo->holder_enum_v == holder_enum_t::smart_holder) {
             return cpp_function(
-                [pm](handle c_hdl) -> std::shared_ptr<typename std::add_const<D>::type> {
+                [pm](handle c_hdl) -> std::shared_ptr<std::add_const_t<D>> {
                     std::shared_ptr<T> c_sp
                         = type_caster<std::shared_ptr<T>>::shared_ptr_with_responsible_parent(
                             c_hdl);
-                    return std::shared_ptr<typename std::add_const<D>::type>(c_sp,
-                                                                             &(c_sp.get()->*pm));
+                    return std::shared_ptr<std::add_const_t<D>>(c_sp, &(c_sp.get()->*pm));
                 },
                 is_method(hdl));
         }
@@ -3183,7 +3176,7 @@ class enum_ : public class_<Type> {
     using Base::attr;
     using Base::def_property_readonly;
     using Base::def_property_readonly_static;
-    using Underlying = typename std::underlying_type<Type>::type;
+    using Underlying = std::underlying_type_t<Type>;
     // Scalar is the integer representation of underlying type
     using Scalar = detail::conditional_t<detail::any_of<detail::is_std_char_type<Underlying>,
                                                         std::is_same<Underlying, bool>>::value,
@@ -3298,9 +3291,8 @@ class enum_ : public class_<Type> {
     // def(const char *, ...) template as ambiguous with enum_::def(const char *, ...).
     template <typename T,
               typename... Extra,
-              detail::enable_if_t<
-                  !std::is_convertible<typename std::decay<T>::type, const char *>::value,
-                  int> = 0>
+              detail::enable_if_t<!std::is_convertible<std::decay_t<T>, const char *>::value, int>
+              = 0>
     enum_ &def(T &&op, const Extra &...extra) {
         Base::def(std::forward<T>(op), extra...);
         return *this;
diff --git a/include/pybind11/stl_bind.h b/include/pybind11/stl_bind.h
index 360c2cd7bc..8b782cf347 100644
--- a/include/pybind11/stl_bind.h
+++ b/include/pybind11/stl_bind.h
@@ -150,7 +150,7 @@ void vector_modifiers(
         "Add an item to the end of the list");
 
     cl.def(init([](const iterable &it) {
-        auto v = std::unique_ptr<Vector>(new Vector());
+        auto v = std::make_unique<Vector>();
         v->reserve(len_hint(it));
         for (handle h : it) {
             v->push_back(h.cast<T>());
diff --git a/pybind11/setup_helpers.py b/pybind11/setup_helpers.py
index 66a3eec0d4..ea92182c5f 100644
--- a/pybind11/setup_helpers.py
+++ b/pybind11/setup_helpers.py
@@ -1,5 +1,5 @@
 """
-This module provides helpers for C++11+ projects using pybind11.
+This module provides helpers for C++14+ projects using pybind11.
 
 LICENSE:
 
@@ -88,7 +88,7 @@
 
 class Pybind11Extension(_Extension):
     """
-    Build a C++11+ Extension module with pybind11. This automatically adds the
+    Build a C++14+ Extension module with pybind11. This automatically adds the
     recommended flags when you init the extension and assumes C++ sources - you
     can further modify the options yourself.
 
@@ -120,7 +120,7 @@ def _add_ldflags(self, flags: list[str]) -> None:
         self.extra_link_args[:0] = flags
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        self._cxx_level = 0
+        self._cxx_level: str | int | None = 0
         cxx_std = kwargs.pop("cxx_std", 0)
 
         if "language" not in kwargs:
@@ -158,7 +158,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         self._add_cflags(cflags)
 
     @property
-    def cxx_std(self) -> int:
+    def cxx_std(self) -> str | int | None:
         """
         The CXX standard level. If set, will add the required flags. If left at
         0, it will trigger an automatic search when pybind11's build_ext is
@@ -169,16 +169,16 @@ def cxx_std(self) -> int:
         return self._cxx_level
 
     @cxx_std.setter
-    def cxx_std(self, level: int) -> None:
+    def cxx_std(self, level: str | int | None) -> None:
+        if isinstance(level, int) and level != 0 and level < 14:
+            msg = "pybind11 requires C++14 or newer"
+            raise ValueError(msg)
+
         if self._cxx_level:
             warnings.warn(
                 "You cannot safely change the cxx_level after setting it!", stacklevel=2
             )
 
-        # MSVC only has 14 and later modes, so force a valid flag here.
-        if WIN and level == 11:
-            level = 14
-
         self._cxx_level = level
 
         if not level:
@@ -194,7 +194,9 @@ def cxx_std(self, level: int) -> None:
             # setting for general use. However, never set higher than the
             # current macOS version!
             current_macos = tuple(int(x) for x in platform.mac_ver()[0].split(".")[:2])
-            desired_macos = (10, 9) if level < 17 else (10, 14)
+            desired_macos = (
+                (10, 9) if isinstance(level, int) and level < 17 else (10, 14)
+            )
             macos_string = ".".join(str(x) for x in min(current_macos, desired_macos))
             macosx_min = f"-mmacosx-version-min={macos_string}"
             cflags += [macosx_min]
@@ -247,19 +249,19 @@ def has_flag(compiler: Any, flag: str) -> bool:
 @lru_cache
 def auto_cpp_level(compiler: Any) -> str | int:
     """
-    Return the max supported C++ std level (17, 14, or 11). Returns latest on Windows.
+    Return the max supported C++ std level (17 or 14). Returns latest on Windows.
     """
 
     if WIN:
         return "latest"
 
-    levels = [17, 14, 11]
+    levels = [17, 14]
 
     for level in levels:
         if has_flag(compiler, STD_TMPL.format(level)):
             return level
 
-    msg = "Unsupported compiler -- at least C++11 support is needed!"
+    msg = "Unsupported compiler -- at least C++14 support is needed!"
     raise RuntimeError(msg)
 
 
diff --git a/tests/extra_setuptools/test_setuphelper.py b/tests/extra_setuptools/test_setuphelper.py
index 22c0c76f5d..b0a9128c8b 100644
--- a/tests/extra_setuptools/test_setuphelper.py
+++ b/tests/extra_setuptools/test_setuphelper.py
@@ -13,7 +13,7 @@
 
 
 @pytest.mark.parametrize("parallel", [False, True])
-@pytest.mark.parametrize("std", [11, 0])
+@pytest.mark.parametrize("std", [14, 0])
 def test_simple_setup_py(monkeypatch, tmpdir, parallel, std):
     monkeypatch.chdir(tmpdir)
     monkeypatch.syspath_prepend(MAIN_DIR)
@@ -110,6 +110,14 @@ def test_simple_setup_py(monkeypatch, tmpdir, parallel, std):
     )
 
 
+def test_cxx_std_too_old(monkeypatch):
+    monkeypatch.syspath_prepend(MAIN_DIR)
+    from pybind11.setup_helpers import Pybind11Extension
+
+    with pytest.raises(ValueError, match=r"pybind11 requires C\+\+14 or newer"):
+        Pybind11Extension("example", ["example.cpp"], cxx_std=11)
+
+
 def test_intree_extensions(monkeypatch, tmpdir):
     monkeypatch.syspath_prepend(MAIN_DIR)
 
diff --git a/tests/pybind11_tests.cpp b/tests/pybind11_tests.cpp
index 5dacd7aeb6..d96ba56ff0 100644
--- a/tests/pybind11_tests.cpp
+++ b/tests/pybind11_tests.cpp
@@ -68,10 +68,8 @@ const char *cpp_std() {
         "C++20";
 #elif defined(PYBIND11_CPP17)
         "C++17";
-#elif defined(PYBIND11_CPP14)
-        "C++14";
 #else
-        "C++11";
+        "C++14";
 #endif
 }
 
diff --git a/tests/test_class.cpp b/tests/test_class.cpp
index 84efb800db..79944497e1 100644
--- a/tests/test_class.cpp
+++ b/tests/test_class.cpp
@@ -20,6 +20,7 @@
 #include "local_bindings.h"
 #include "pybind11_tests.h"
 
+#include <memory>
 #include <utility>
 
 PYBIND11_WARNING_DISABLE_MSVC(4324)
@@ -259,13 +260,11 @@ TEST_SUBMODULE(class_, m) {
     // test_override_static
     // #511: problem with inheritance + overwritten def_static
     struct MyBase {
-        static std::unique_ptr<MyBase> make() { return std::unique_ptr<MyBase>(new MyBase()); }
+        static std::unique_ptr<MyBase> make() { return std::make_unique<MyBase>(); }
     };
 
     struct MyDerived : MyBase {
-        static std::unique_ptr<MyDerived> make() {
-            return std::unique_ptr<MyDerived>(new MyDerived());
-        }
+        static std::unique_ptr<MyDerived> make() { return std::make_unique<MyDerived>(); }
     };
 
     py::class_<MyBase>(m, "MyBase").def_static("make", &MyBase::make);
diff --git a/tests/test_class_sh_basic.cpp b/tests/test_class_sh_basic.cpp
index d9cbe1f6be..fdfe166b4f 100644
--- a/tests/test_class_sh_basic.cpp
+++ b/tests/test_class_sh_basic.cpp
@@ -84,7 +84,7 @@ std::shared_ptr<atyp const> rtrn_shcp() { return std::shared_ptr<atyp const>(new
 std::string pass_shmp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; } // NOLINT
 std::string pass_shcp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; } // NOLINT
 
-std::unique_ptr<atyp>       rtrn_uqmp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
+std::unique_ptr<atyp>       rtrn_uqmp() { return std::make_unique<atyp      >("rtrn_uqmp"); }
 std::unique_ptr<atyp const> rtrn_uqcp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
 
 std::string pass_uqmp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
@@ -232,7 +232,7 @@ TEST_SUBMODULE(class_sh_basic, m) {
     // Make sure unique_ptr type caster accept automatic_reference return value policy.
     m.def(
         "rtrn_uq_automatic_reference",
-        []() { return std::unique_ptr<atyp>(new atyp("rtrn_uq_automatic_reference")); },
+        []() { return std::make_unique<atyp>("rtrn_uq_automatic_reference"); },
         pybind11::return_value_policy::automatic_reference);
 
     m.def("pass_shared_ptr_ptr", [](std::shared_ptr<atyp> *) {});
diff --git a/tests/test_class_sh_factory_constructors.cpp b/tests/test_class_sh_factory_constructors.cpp
index 0718b569ff..4c81f96b6c 100644
--- a/tests/test_class_sh_factory_constructors.cpp
+++ b/tests/test_class_sh_factory_constructors.cpp
@@ -41,7 +41,7 @@ atyp_mptr*       rtrn_mptr() { return new atyp_mptr{"Mptr"}; }
 std::shared_ptr<atyp_shmp>       rtrn_shmp() { return std::make_shared<atyp_shmp>(atyp_shmp{"Shmp"}); }
 std::shared_ptr<atyp_shcp const> rtrn_shcp() { return std::shared_ptr<atyp_shcp const>(new atyp_shcp{"Shcp"}); }
 
-std::unique_ptr<atyp_uqmp>       rtrn_uqmp() { return std::unique_ptr<atyp_uqmp      >(new atyp_uqmp{"Uqmp"}); }
+std::unique_ptr<atyp_uqmp>       rtrn_uqmp() { return std::make_unique<atyp_uqmp      >(atyp_uqmp{"Uqmp"}); }
 std::unique_ptr<atyp_uqcp const> rtrn_uqcp() { return std::unique_ptr<atyp_uqcp const>(new atyp_uqcp{"Uqcp"}); }
 
 struct sddm : std::default_delete<atyp_udmp      > {};
@@ -135,7 +135,7 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
             return p;
         }))
         .def(py::init([](int i, int j) {
-            auto p = std::unique_ptr<with_alias_alias>(new with_alias_alias);
+            auto p = std::make_unique<with_alias_alias>();
             p->val = i * 100 + j * 10;
             return p;
         }))
@@ -144,11 +144,10 @@ TEST_SUBMODULE(class_sh_factory_constructors, m) {
             p->val = i * 100 + j * 10 + k;
             return p;
         }))
-        .def(py::init(
-            [](int, int, int, int) { return std::unique_ptr<with_alias>(new with_alias); },
-            [](int, int, int, int) {
-                return std::unique_ptr<with_alias>(new with_alias); // Invalid alias factory.
-            }))
+        .def(py::init([](int, int, int, int) { return std::make_unique<with_alias>(); },
+                      [](int, int, int, int) {
+                          return std::make_unique<with_alias>(); // Invalid alias factory.
+                      }))
         .def(py::init([](int, int, int, int, int) { return std::make_shared<with_alias>(); },
                       [](int, int, int, int, int) {
                           return std::make_shared<with_alias>(); // Invalid alias factory.
diff --git a/tests/test_class_sh_mi_thunks.cpp b/tests/test_class_sh_mi_thunks.cpp
index 0d1672cfb6..ee11e1e709 100644
--- a/tests/test_class_sh_mi_thunks.cpp
+++ b/tests/test_class_sh_mi_thunks.cpp
@@ -77,7 +77,7 @@ std::shared_ptr<VBase> make_diamond_as_vbase_shared_ptr() {
 }
 
 std::unique_ptr<VBase> make_diamond_as_vbase_unique_ptr() {
-    auto uqptr = std::unique_ptr<Diamond>(new Diamond);
+    auto uqptr = std::make_unique<Diamond>();
     return uqptr; // upcast
 }
 
@@ -132,7 +132,7 @@ class Tiger : virtual public Cat {
         return std::make_shared<Tiger>(*this); // upcast
     }
     std::unique_ptr<Animal> clone_unique_ptr() const override {
-        return std::unique_ptr<Tiger>(new Tiger(*this)); // upcast
+        return std::make_unique<Tiger>(*this); // upcast
     }
 };
 
@@ -142,7 +142,7 @@ TEST_SUBMODULE(class_sh_mi_thunks, m) {
     using namespace test_class_sh_mi_thunks;
 
     m.def("ptrdiff_drvd_base0", []() {
-        auto drvd = std::unique_ptr<Derived>(new Derived);
+        auto drvd = std::make_unique<Derived>();
         auto *base0 = dynamic_cast<Base0 *>(drvd.get());
         return std::ptrdiff_t(reinterpret_cast<char *>(drvd.get())
                               - reinterpret_cast<char *>(base0));
@@ -168,7 +168,7 @@ TEST_SUBMODULE(class_sh_mi_thunks, m) {
     });
 
     m.def("get_drvd_as_base0_unique_ptr", []() {
-        auto drvd = std::unique_ptr<Derived>(new Derived);
+        auto drvd = std::make_unique<Derived>();
         auto base0 = std::unique_ptr<Base0>(std::move(drvd));
         return base0;
     });
diff --git a/tests/test_class_sh_trampoline_shared_from_this.cpp b/tests/test_class_sh_trampoline_shared_from_this.cpp
index dc6bf1c72a..86e569ef8d 100644
--- a/tests/test_class_sh_trampoline_shared_from_this.cpp
+++ b/tests/test_class_sh_trampoline_shared_from_this.cpp
@@ -94,7 +94,7 @@ void pass_unique_ptr_rref(std::unique_ptr<Sft> &&) {
 Sft *make_pure_cpp_sft_raw_ptr(const std::string &history_seed) { return new Sft{history_seed}; }
 
 std::unique_ptr<Sft> make_pure_cpp_sft_unq_ptr(const std::string &history_seed) {
-    return std::unique_ptr<Sft>(new Sft{history_seed});
+    return std::make_unique<Sft>(history_seed);
 }
 
 std::shared_ptr<Sft> make_pure_cpp_sft_shd_ptr(const std::string &history_seed) {
diff --git a/tests/test_class_sh_unique_ptr_member.cpp b/tests/test_class_sh_unique_ptr_member.cpp
index 50c505a655..8abf7d16e2 100644
--- a/tests/test_class_sh_unique_ptr_member.cpp
+++ b/tests/test_class_sh_unique_ptr_member.cpp
@@ -17,9 +17,7 @@ class pointee { // NOT copyable.
     pointee &operator=(pointee &&) = delete;
 };
 
-inline std::unique_ptr<pointee> make_unique_pointee() {
-    return std::unique_ptr<pointee>(new pointee);
-}
+inline std::unique_ptr<pointee> make_unique_pointee() { return std::make_unique<pointee>(); }
 
 class ptr_owner {
 public:
diff --git a/tests/test_cmake_build/installed_target/CMakeLists.txt b/tests/test_cmake_build/installed_target/CMakeLists.txt
index a66f8adda0..6f529c3190 100644
--- a/tests/test_cmake_build/installed_target/CMakeLists.txt
+++ b/tests/test_cmake_build/installed_target/CMakeLists.txt
@@ -7,6 +7,8 @@ message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
 
 add_library(test_installed_target MODULE ../main.cpp)
 
+# Verify that the installed interface promotes a consumer that initially requests C++11.
+set_target_properties(test_installed_target PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
 target_link_libraries(test_installed_target PRIVATE pybind11::module)
 
 # If a pybind11 option is on, main.cpp checks that the matching macro reached this
diff --git a/tests/test_cmake_build/subdirectory_target/CMakeLists.txt b/tests/test_cmake_build/subdirectory_target/CMakeLists.txt
index 29b0234856..b193a2f117 100644
--- a/tests/test_cmake_build/subdirectory_target/CMakeLists.txt
+++ b/tests/test_cmake_build/subdirectory_target/CMakeLists.txt
@@ -13,6 +13,8 @@ add_subdirectory("${pybind11_SOURCE_DIR}" pybind11)
 add_library(test_subdirectory_target MODULE ../main.cpp)
 set_target_properties(test_subdirectory_target PROPERTIES OUTPUT_NAME test_cmake_build)
 
+# Verify that pybind11's interface requirement promotes a consumer that initially requests C++11.
+set_target_properties(test_subdirectory_target PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
 target_link_libraries(test_subdirectory_target PRIVATE pybind11::module)
 
 # If a pybind11 option is on, main.cpp checks that the matching macro reached this
diff --git a/tests/test_copy_move.cpp b/tests/test_copy_move.cpp
index ed1bf61e95..0948857c48 100644
--- a/tests/test_copy_move.cpp
+++ b/tests/test_copy_move.cpp
@@ -13,6 +13,7 @@
 #include "constructor_stats.h"
 #include "pybind11_tests.h"
 
+#include <memory>
 #include <type_traits>
 
 template <typename derived>
@@ -319,7 +320,7 @@ TEST_SUBMODULE(copy_move_policies, m) {
     // `py::return_value_policy::move`
     m.def(
         "get_moveissue1",
-        [](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
+        [](int i) { return std::make_unique<MoveIssue1>(i); },
         py::return_value_policy::move);
     m.def("get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
 
diff --git a/tests/test_cross_module_rtti/CMakeLists.txt b/tests/test_cross_module_rtti/CMakeLists.txt
index c9b95bfba1..71451a4592 100644
--- a/tests/test_cross_module_rtti/CMakeLists.txt
+++ b/tests/test_cross_module_rtti/CMakeLists.txt
@@ -36,7 +36,7 @@ add_library(test_cross_module_rtti_lib::test_cross_module_rtti_lib ALIAS
             test_cross_module_rtti_lib)
 target_include_directories(test_cross_module_rtti_lib PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 target_include_directories(test_cross_module_rtti_lib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-target_compile_features(test_cross_module_rtti_lib PUBLIC cxx_std_11)
+target_compile_features(test_cross_module_rtti_lib PUBLIC cxx_std_14)
 
 generate_export_header(test_cross_module_rtti_lib)
 
diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp
index 10f6843202..8c7623530b 100644
--- a/tests/test_smart_ptr.cpp
+++ b/tests/test_smart_ptr.cpp
@@ -11,6 +11,8 @@
 #include "object.h"
 #include "pybind11_tests.h"
 
+#include <memory>
+
 // This breaks on PYBIND11_DECLARE_HOLDER_TYPE
 PYBIND11_WARNING_DISABLE_GCC("-Wpedantic")
 
@@ -438,8 +440,7 @@ void wrap(py::module_ &m) {
     m.def("return_std_shared_ptr_example_drvd",
           // NOLINTNEXTLINE(modernize-make-shared)
           []() { return std::shared_ptr<example_drvd>(new example_drvd()); });
-    m.def("return_std_unique_ptr_example_drvd",
-          []() { return std::unique_ptr<example_drvd>(new example_drvd()); });
+    m.def("return_std_unique_ptr_example_drvd", []() { return std::make_unique<example_drvd>(); });
 }
 
 } // namespace holder_caster_traits_test
diff --git a/tests/test_with_catch/test_subinterpreter.cpp b/tests/test_with_catch/test_subinterpreter.cpp
index 570519e641..3c2c10f076 100644
--- a/tests/test_with_catch/test_subinterpreter.cpp
+++ b/tests/test_with_catch/test_subinterpreter.cpp
@@ -13,6 +13,7 @@ PYBIND11_WARNING_DISABLE_MSVC(4996)
 #    include <cstdlib>
 #    include <fstream>
 #    include <functional>
+#    include <memory>
 #    include <thread>
 #    include <utility>
 
@@ -438,7 +439,7 @@ TEST_CASE("Multiple Subinterpreters") {
             REQUIRE(sub1_int != main_int);
 
             // while the old one is active, create a new one
-            psi2.reset(new py::subinterpreter(py::subinterpreter::create()));
+            psi2 = std::make_unique<py::subinterpreter>(py::subinterpreter::create());
         }
 
         {
diff --git a/tools/pybind11Common.cmake b/tools/pybind11Common.cmake
index d75fb67520..8aea516700 100644
--- a/tools/pybind11Common.cmake
+++ b/tools/pybind11Common.cmake
@@ -169,23 +169,21 @@ set_property(
 # Warn or error if old variable name used
 if(PYBIND11_CPP_STANDARD)
   string(REGEX MATCH [[..$]] VAL "${PYBIND11_CPP_STANDARD}")
-  if(CMAKE_CXX_STANDARD)
+  set(supported_standards 14 17 20)
+  if(NOT "${VAL}" IN_LIST supported_standards)
+    message(FATAL_ERROR "PYBIND11_CPP_STANDARD should be replaced with CMAKE_CXX_STANDARD "
+                        "(${VAL} is below pybind11's C++14 minimum or is not supported)")
+  elseif(CMAKE_CXX_STANDARD)
     if(NOT CMAKE_CXX_STANDARD STREQUAL VAL)
       message(WARNING "CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} does not match "
                       "PYBIND11_CPP_STANDARD=${PYBIND11_CPP_STANDARD}, "
                       "please remove PYBIND11_CPP_STANDARD from your cache")
     endif()
   else()
-    set(supported_standards 11 14 17 20)
-    if("${VAL}" IN_LIST supported_standards)
-      message(WARNING "USE -DCMAKE_CXX_STANDARD=${VAL} instead of PYBIND11_CPP_STANDARD")
-      set(CMAKE_CXX_STANDARD
-          ${VAL}
-          CACHE STRING "From PYBIND11_CPP_STANDARD")
-    else()
-      message(FATAL_ERROR "PYBIND11_CPP_STANDARD should be replaced with CMAKE_CXX_STANDARD "
-                          "(last two chars: ${VAL} not understood as a valid CXX std)")
-    endif()
+    message(WARNING "USE -DCMAKE_CXX_STANDARD=${VAL} instead of PYBIND11_CPP_STANDARD")
+    set(CMAKE_CXX_STANDARD
+        ${VAL}
+        CACHE STRING "From PYBIND11_CPP_STANDARD")
   endif()
 endif()