diff --git a/.gitmodules b/.gitmodules
index 9b2afbe..e15103c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -2,3 +2,7 @@
 	path = third_party/googletest
 	url = https://github.com/google/googletest.git
 	branch = v1.14.x
+[submodule "third_party/abseil-cpp"]
+	path = third_party/abseil-cpp
+	url = https://github.com/abseil/abseil-cpp
+	branch = lts_2024_01_16
diff --git a/BUILD b/BUILD
index 4b18cb9..386fc58 100644
--- a/BUILD
+++ b/BUILD
@@ -30,7 +30,6 @@
 #
 # These are Bazel rules to build Ceres. It's currently in Alpha state, and does
 # not support parameterization around threading choice or sparse backends.
-
 load("//:bazel/ceres.bzl", "ceres_library")
 
 ceres_library(
@@ -44,20 +43,10 @@
         "evaluator_test_utils.cc",
         "numeric_diff_test_utils.cc",
         "test_util.cc",
-        "gmock_gtest_all.cc",
-        "gmock_main.cc",
-        "gmock/gmock.h",
-        "gmock/mock-log.h",
-        "gtest/gtest.h",
     ]],
-    hdrs = [
-        "internal/ceres/gmock/gmock.h",
-        "internal/ceres/gmock/mock-log.h",
-        "internal/ceres/gtest/gtest.h",
-    ],
     copts = [
         "-Wno-sign-compare",
-        "-DCERES_TEST_SRCDIR_SUFFIX=\\\"data/\\\"",
+        "-DCERES_TEST_SRCDIR_SUFFIX=\\\"_main/data/\\\"",
     ],
     includes = [
         "internal",
@@ -65,7 +54,7 @@
     ],
     deps = [
         "//:ceres",
-        "@com_github_gflags_gflags//:gflags",
+        "@googletest//:gtest_main",
     ],
 )
 
@@ -156,22 +145,10 @@
     "visibility",
 ]
 
-TEST_COPTS = [
-    # Needed to silence GFlags complaints.
-    "-Wno-sign-compare",
-
-    # These two warnings don't work well in conjunction with GMock, and
-    # trigger incorrectly on parts of rotation_test. For now, disable them,
-    # but in the future disable these warnings only for rotation_test.
-    # TODO(keir): When the tests are macro-ified, apply these selectively.
-    "-Wno-address",
-]
-
 TEST_DEPS = [
     "//:ceres",
     "//:test_util",
-    "@com_gitlab_libeigen_eigen//:eigen",
-    "@com_github_gflags_gflags//:gflags",
+    "@eigen//:eigen",
 ]
 
 # Instantiate all the tests with a template.
@@ -179,7 +156,6 @@
     name = test_name + "_test",
     timeout = "short",
     srcs = ["internal/ceres/" + test_name + "_test.cc"],
-    copts = TEST_COPTS,
     deps = TEST_DEPS,
 ) for test_name in CERES_TESTS]
 
@@ -193,8 +169,6 @@
     name = test_filename.split("/")[-1][:-3],  # Remove .cc.
     timeout = "long",
     srcs = [test_filename],
-    copts = TEST_COPTS,
-
     # This is the data set that is bundled for the testing.
     data = [":data/problem-16-22106-pre.txt"],
     deps = TEST_DEPS,
@@ -206,9 +180,16 @@
 [cc_binary(
     name = benchmark_name,
     srcs = ["internal/ceres/" + benchmark_name + ".cc"],
-    copts = TEST_COPTS,
-    deps = TEST_DEPS + ["@com_github_google_benchmark//:benchmark"],
+    copts = ["-mllvm -inlinehint-threshold=1000000"],
+    deps = TEST_DEPS + ["@google_benchmark//:benchmark"],
+
 ) for benchmark_name in [
+    "evaluation_benchmark",
+    "invert_psd_matrix_benchmark",
+    "schur_eliminator_benchmark",
+    "jet_operator_benchmark",
+    "dense_linear_solver_benchmark",
+    "parallel_vector_operations_benchmark",
     "small_blas_gemm_benchmark",
     "small_blas_gemv_benchmark",
 ]]
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b92437c..8986f44 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,6 +32,12 @@
 cmake_minimum_required(VERSION 3.16...3.29)
 project(Ceres C CXX)
 
+# In the normal course of things, we would not need the following
+# constraint. However, if we do not set the standard, then
+# std::basic_string_view is not available, which absl depends on and
+# linking the test fails.
+set(CMAKE_CXX_STANDARD 17)
+
 # NOTE: The following CMake variables must be applied consistently to all
 # targets in project to avoid visibility warnings by placing the variables at
 # the project top.
@@ -94,8 +100,6 @@
 include(CMakeDependentOption)
 include(PrettyPrintCMakeList)
 
-option(MINIGLOG "Use a stripped down version of glog." OFF)
-option(GFLAGS "Enable Google Flags." ON)
 option(SUITESPARSE "Enable SuiteSparse." ON)
 if (APPLE)
   option(ACCELERATESPARSE
@@ -144,14 +148,10 @@
       "requires at least iOS version 7.0")
   endif()
 
-  update_cache_variable(MINIGLOG ON)
-  message(STATUS "Building for iOS: Forcing use of miniglog instead of glog.")
-
   # Apple claims that the BLAS call dsyrk_ is a private API, and will not allow
   # you to submit to the Apple Store if the symbol is present.
   update_cache_variable(LAPACK OFF)
-  message(STATUS "Building for iOS: SuiteSparse, LAPACK, gflags "
-    "are not available.")
+  message(STATUS "Building for iOS: SuiteSparse, LAPACK are not available.")
 
   update_cache_variable(BUILD_EXAMPLES OFF)
   message(STATUS "Building for iOS: Will not build examples.")
@@ -159,6 +159,23 @@
 
 unset(CERES_COMPILE_OPTIONS)
 
+# Abseil
+#
+# TODO: We are currently adding the submodule unconditionally. Going
+# foward, this should be replaced with a more sophisticated logic,
+# where we use the system installed version of abseil if it is more
+# recent than the version we are tracking. This will also affect how
+# we are installing ceres.
+
+# ABSL plans to enable this flag to be on by default in the future. If
+# it is not set, then it issues a warning. We force enable it, both to
+# silence the warning but to also be safe going forward.
+set(ABSL_PROPAGATE_CXX_STD ON CACHE BOOL "Use CMake C++ standard meta
+features (e.g. cxx_std_14) that propagate to targets that link to
+Abseil")
+add_subdirectory(third_party/abseil-cpp)
+
+
 # Eigen.
 # Eigen delivers Eigen3Config.cmake since v3.3.3
 find_package(Eigen3 3.3 REQUIRED)
@@ -419,68 +436,6 @@
   message("  ================================================================")
 endif()
 
-# GFlags.
-if (GFLAGS)
-  # Don't search with REQUIRED as we can continue without gflags.
-  find_package(gflags 2.2.0)
-  if (gflags_FOUND)
-    if (TARGET gflags)
-      message("-- Found Google Flags (gflags) version ${gflags_VERSION}: ${gflags_DIR}")
-    else()
-      message("-- Detected version of gflags: ${gflags_VERSION} does not define "
-        "expected gflags CMake target which should be exported by gflags 2.2+. "
-        "Building without gflags.")
-      update_cache_variable(GFLAGS OFF)
-    endif()
-  else (gflags_FOUND)
-    message("-- Did not find Google Flags (gflags), Building without gflags.")
-    update_cache_variable(GFLAGS OFF)
-  endif (gflags_FOUND)
-endif()
-if (NOT GFLAGS)
-  message("-- Use of gflags disabled - no tests or tools will be built!")
-endif()
-
-# MiniGLog.
-if (MINIGLOG)
-  message("-- Compiling minimal glog substitute into Ceres.")
-  set(GLOG_INCLUDE_DIRS internal/ceres/miniglog)
-  set(MINIGLOG_MAX_LOG_LEVEL 2 CACHE STRING "The maximum message severity level to be logged")
-  add_definitions("-DMAX_LOG_LEVEL=${MINIGLOG_MAX_LOG_LEVEL}")
-  message("-- Using minimal glog substitute (include): ${GLOG_INCLUDE_DIRS}")
-  message("-- Max log level for minimal glog substitute: ${MINIGLOG_MAX_LOG_LEVEL}")
-
-  # Mark as advanced (remove from default GUI view) the glog search
-  # variables in case user disables MINIGLOG, FindGlog did not find it, so
-  # made search variables visible in GUI for user to set, but then user enables
-  # MINIGLOG instead of setting them.
-  mark_as_advanced(FORCE GLOG_INCLUDE_DIR
-                         GLOG_LIBRARY)
-else (MINIGLOG)
-  unset(MINIGLOG_MAX_LOG_LEVEL CACHE)
-  # Don't search with REQUIRED so that configuration continues if not found and
-  # we can output an error messages explaining MINIGLOG option.
-  find_package(Glog)
-  if (NOT GLOG_FOUND)
-    message(FATAL_ERROR "Can't find Google Log (glog). Please set either: "
-      "glog_DIR (newer CMake built versions of glog) or GLOG_INCLUDE_DIR & "
-      "GLOG_LIBRARY or enable MINIGLOG option to use minimal glog "
-      "implementation.")
-  endif(NOT GLOG_FOUND)
-  # By default, assume gflags was found, updating the message if it was not.
-  set(GLOG_GFLAGS_DEPENDENCY_MESSAGE
-    " Assuming glog was built with gflags support as gflags was found. "
-    "This will make gflags a public dependency of Ceres.")
-  if (NOT gflags_FOUND)
-    set(GLOG_GFLAGS_DEPENDENCY_MESSAGE
-      " Assuming glog was NOT built with gflags support as gflags was "
-      "not found.  If glog was built with gflags, please set the "
-      "gflags search locations such that it can be found by Ceres.  "
-      "Otherwise, Ceres may fail to link due to missing gflags symbols.")
-  endif(NOT gflags_FOUND)
-  message("-- Found Google Log (glog)." ${GLOG_GFLAGS_DEPENDENCY_MESSAGE})
-endif (MINIGLOG)
-
 if (NOT SCHUR_SPECIALIZATIONS)
   list(APPEND CERES_COMPILE_OPTIONS CERES_RESTRICT_SCHUR_SPECIALIZATION)
   message("-- Disabling Schur specializations (faster compiles)")
@@ -669,13 +624,6 @@
 install(DIRECTORY ${Ceres_BINARY_DIR}/${CMAKE_INSTALL_INCLUDEDIR}/
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
-if (MINIGLOG)
-  # Install miniglog header if being used as logging #includes appear in
-  # installed public Ceres headers.
-  install(FILES ${Ceres_SOURCE_DIR}/internal/ceres/miniglog/glog/logging.h
-          DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/ceres/internal/miniglog/glog)
-endif (MINIGLOG)
-
 # Ceres supports two mechanisms by which it can be detected & imported into
 # client code which uses CMake via find_package(Ceres):
 #
@@ -718,9 +666,12 @@
 # when read in by a client project as part of find_package(Ceres) creates
 # imported library targets for Ceres (with dependency relations) which can be
 # used in target_link_libraries() calls in the client project to use Ceres.
-install(EXPORT CeresExport
-        NAMESPACE Ceres::
-        DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR} FILE CeresTargets.cmake)
+#
+# TODO: Re-enable this
+#
+#install(EXPORT CeresExport
+#        NAMESPACE Ceres::
+#        DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR} FILE CeresTargets.cmake)
 
 # Save the relative path from the installed CeresConfig.cmake file to the
 # install prefix.  We do not save an absolute path in case the installed package
@@ -749,12 +700,6 @@
         DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
 install(FILES "${Ceres_BINARY_DIR}/CeresConfigVersion.cmake"
         DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
-if (GLOG_FOUND AND NOT FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-  # Version of glog detected was not built with CMake, install our glog module
-  # file to enable detection in CeresConfig.
-  install(FILES "${Ceres_SOURCE_DIR}/cmake/FindGlog.cmake"
-          DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
-endif()
 
 if (PROVIDE_UNINSTALL_TARGET)
   # Create an uninstall target to remove all installed files.
diff --git a/MODULE.bazel b/MODULE.bazel
new file mode 100644
index 0000000..aedb0dd
--- /dev/null
+++ b/MODULE.bazel
@@ -0,0 +1,6 @@
+# MODULE.bazel
+
+bazel_dep(name = "abseil-cpp", version = "20240116.2")
+bazel_dep(name = "googletest", version = "1.14.0")
+bazel_dep(name = "eigen", version = "3.4.0")
+bazel_dep(name = "google_benchmark", version = "1.8.4")
diff --git a/WORKSPACE b/WORKSPACE
index 40a84a3..4622d4e 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -31,74 +31,3 @@
 # Bazel workspace file to enable building Ceres with Bazel.
 
 workspace(name = "com_google_ceres_solver")
-
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-# External dependency: Google Flags; has Bazel build already.
-http_archive(
-    name = "com_github_gflags_gflags",
-    sha256 = "6e16c8bc91b1310a44f3965e616383dbda48f83e8c1eaa2370a215057b00cabe",
-    strip_prefix = "gflags-77592648e3f3be87d6c7123eb81cbad75f9aef5a",
-    urls = [
-        "https://mirror.bazel.build/github.com/gflags/gflags/archive/77592648e3f3be87d6c7123eb81cbad75f9aef5a.tar.gz",
-        "https://github.com/gflags/gflags/archive/77592648e3f3be87d6c7123eb81cbad75f9aef5a.tar.gz",
-    ],
-)
-
-# External dependency: Google Log; has Bazel build already.
-http_archive(
-    name = "com_github_google_glog",
-    sha256 = "7083af285bed3995b5dc2c982f7de39bced9f0e6fd78d631f3285490922a0c3d",
-    strip_prefix = "glog-3106945d8d3322e5cbd5658d482c9ffed2d892c0",
-    urls = [
-        "https://github.com/drigz/glog/archive/3106945d8d3322e5cbd5658d482c9ffed2d892c0.tar.gz",
-    ],
-)
-
-# External dependency: Eigen; has no Bazel build.
-http_archive(
-    name = "com_gitlab_libeigen_eigen",
-    sha256 = "0215c6593c4ee9f1f7f28238c4e8995584ebf3b556e9dbf933d84feb98d5b9ef",
-    strip_prefix = "eigen-3.3.8",
-    urls = [
-        "https://gitlab.com/libeigen/eigen/-/archive/3.3.8/eigen-3.3.8.tar.bz2",
-    ],
-    build_file_content =
-"""
-# TODO(keir): Replace this with a better version, like from TensorFlow.
-# See https://github.com/ceres-solver/ceres-solver/issues/337.
-cc_library(
-    name = 'eigen',
-    srcs = [],
-    includes = ['.'],
-    hdrs = glob(['Eigen/**']),
-    visibility = ['//visibility:public'],
-)
-"""
-)
-
-# External dependency: Google Benchmark; has no Bazel build.
-http_archive(
-    name = "com_github_google_benchmark",
-    urls = ["https://github.com/google/benchmark/archive/56f52ee228783547f544d9ac4a533574b9010e3f.zip"],
-    sha256 = "8c1c6e90cd320b07504fabb86400f390faff2e599183ebd9396908817968ae79",
-    strip_prefix = "benchmark-56f52ee228783547f544d9ac4a533574b9010e3f",
-    build_file_content =
-"""
-cc_library(
-    name = "benchmark",
-    srcs = glob([
-        "src/*.h",
-        "src/*.cc",
-    ]),
-    hdrs = glob(["include/benchmark/*.h"]),
-    copts = [
-        "-DHAVE_STD_REGEX",
-    ],
-    includes = [
-        "include",
-    ],
-    visibility = ["//visibility:public"],
-)
-"""
-)
diff --git a/bazel/ceres.bzl b/bazel/ceres.bzl
index 2e5759e..b0e4c5c 100644
--- a/bazel/ceres.bzl
+++ b/bazel/ceres.bzl
@@ -140,14 +140,15 @@
 # TODO(rodrigoq): add support to configure Ceres into various permutations,
 # like SuiteSparse or not, threading or not, glog or not, and so on.
 # See https://github.com/ceres-solver/ceres-solver/issues/335.
-def ceres_library(name,
-                  restrict_schur_specializations=False):
+def ceres_library(
+        name,
+        restrict_schur_specializations = False):
     # The path to internal/ depends on whether Ceres is the main workspace or
     # an external repository.
-    if native.repository_name() != '@':
-        internal = 'external/%s/internal' % native.repository_name().lstrip('@')
+    if native.repository_name() != "@":
+        internal = "external/%s/internal" % native.repository_name().lstrip("@")
     else:
-        internal = 'internal'
+        internal = "internal"
 
     # The fixed-size Schur eliminator template instantiations incur a large
     # binary size penalty, and are slow to compile, so support disabling them.
@@ -185,11 +186,7 @@
                 "config/ceres/internal/config.h",
                 "config/ceres/internal/export.h",
             ]),
-        copts = [
-            "-I" + internal,
-            "-Wunused-parameter",
-            "-Wno-sign-compare",
-        ] + schur_eliminator_copts,
+        copts = schur_eliminator_copts,
 
         # These include directories and defines are propagated to other targets
         # depending on Ceres.
@@ -198,23 +195,26 @@
         # part of a Skylark Ceres target macro.
         # https://github.com/ceres-solver/ceres-solver/issues/396
         defines = [
-            "CERES_EXPORT=",
             "CERES_NO_ACCELERATE_SPARSE",
             "CERES_NO_CHOLMOD_PARTITION",
             "CERES_NO_CUDA",
+            "CERES_NO_CUDSS",
             "CERES_NO_EIGEN_METIS",
             "CERES_NO_EXPORT=",
             "CERES_NO_LAPACK",
             "CERES_NO_SUITESPARSE",
             "CERES_USE_EIGEN_SPARSE",
+            "CERES_EXPORT=",
         ],
         includes = [
             "config",
             "include",
+            "internal",
         ],
         visibility = ["//visibility:public"],
         deps = [
-            "@com_gitlab_libeigen_eigen//:eigen",
-            "@com_github_google_glog//:glog",
+            "@eigen//:eigen",
+            "@abseil-cpp//absl/log",
+            "@abseil-cpp//absl/log:check",
         ],
     )
diff --git a/cmake/CeresConfig.cmake.in b/cmake/CeresConfig.cmake.in
index b929c82..4acc8cf 100644
--- a/cmake/CeresConfig.cmake.in
+++ b/cmake/CeresConfig.cmake.in
@@ -217,57 +217,6 @@
     "Eigen3_DIR.")
 endif (Eigen3_FOUND)
 
-# glog (and maybe gflags).
-#
-# Flags set during configuration and build of Ceres.
-set(CERES_USES_MINIGLOG @MINIGLOG@)
-set(CERES_GLOG_VERSION @glog_VERSION@)
-set(CERES_GLOG_WAS_BUILT_WITH_CMAKE @FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION@)
-
-set(CERES_USES_GFLAGS @GFLAGS@)
-set(CERES_GFLAGS_VERSION @gflags_VERSION@)
-
-if (CERES_USES_MINIGLOG)
-  # Output message at standard log level (not the lower STATUS) so that
-  # the message is output in GUI during configuration to warn user.
-  ceres_message("-- Found Ceres compiled with miniglog substitute "
-    "for glog, beware this will likely cause problems if glog is later linked.")
-else(CERES_USES_MINIGLOG)
-  if (CERES_GLOG_WAS_BUILT_WITH_CMAKE)
-    find_package(glog ${CERES_GLOG_VERSION} CONFIG QUIET)
-    set(GLOG_FOUND ${glog_FOUND})
-  else()
-    # Version of glog against which Ceres was built was not built with CMake,
-    # use the exported glog find_package() module from Ceres to find it again.
-    # Append the locations of glog when Ceres was built to the search path hints.
-    list(APPEND GLOG_INCLUDE_DIR_HINTS "@GLOG_INCLUDE_DIR@")
-    get_filename_component(CERES_BUILD_GLOG_LIBRARY_DIR "@GLOG_LIBRARY@" PATH)
-    list(APPEND GLOG_LIBRARY_DIR_HINTS ${CERES_BUILD_GLOG_LIBRARY_DIR})
-
-    # Search quietly s/t we control the timing of the error message if not found.
-    find_package(Glog QUIET)
-  endif()
-
-  if (GLOG_FOUND)
-    ceres_message(STATUS "Found required Ceres dependency: glog")
-  else()
-    ceres_report_not_found("Missing required Ceres dependency: glog.")
-  endif()
-
-  # gflags is only a public dependency of Ceres via glog, thus is not required
-  # if Ceres was built with MINIGLOG.
-  if (CERES_USES_GFLAGS)
-    # Search quietly s/t we control the timing of the error message if not found.
-    find_package(gflags ${CERES_GFLAGS_VERSION} QUIET)
-    if (gflags_FOUND AND TARGET gflags)
-      ceres_message(STATUS "Found required Ceres dependency: gflags")
-    else()
-      ceres_report_not_found("Missing required Ceres "
-        "dependency: gflags (not found, or not found as exported CMake target).")
-    endif()
-  endif()
-endif(CERES_USES_MINIGLOG)
-
 # Import exported Ceres targets, if they have not already been imported.
 if (NOT TARGET ceres AND NOT Ceres_BINARY_DIR)
   include(${CERES_CURRENT_CONFIG_DIR}/CeresTargets.cmake)
diff --git a/cmake/FindGlog.cmake b/cmake/FindGlog.cmake
deleted file mode 100644
index 2ef6914..0000000
--- a/cmake/FindGlog.cmake
+++ /dev/null
@@ -1,384 +0,0 @@
-# Ceres Solver - A fast non-linear least squares minimizer
-# Copyright 2023 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: alexs.mac@gmail.com (Alex Stewart)
-#
-
-# FindGlog.cmake - Find Google glog logging library.
-#
-# This module defines the following variables:
-#
-# GLOG_FOUND: TRUE iff glog is found.
-# GLOG_INCLUDE_DIRS: Include directories for glog.
-# GLOG_LIBRARIES: Libraries required to link glog.
-# FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION: True iff the version of glog found
-#                                           was built & installed / exported
-#                                           as a CMake package.
-#
-# The following variables control the behaviour of this module:
-#
-# GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION: TRUE/FALSE, iff TRUE then
-#                           then prefer using an exported CMake configuration
-#                           generated by glog > 0.3.4 over searching for the
-#                           glog components manually.  Otherwise (FALSE)
-#                           ignore any exported glog CMake configurations and
-#                           always perform a manual search for the components.
-#                           Default: TRUE iff user does not define this variable
-#                           before we are called, and does NOT specify either
-#                           GLOG_INCLUDE_DIR_HINTS or GLOG_LIBRARY_DIR_HINTS
-#                           otherwise FALSE.
-# GLOG_INCLUDE_DIR_HINTS: List of additional directories in which to
-#                         search for glog includes, e.g: /timbuktu/include.
-# GLOG_LIBRARY_DIR_HINTS: List of additional directories in which to
-#                         search for glog libraries, e.g: /timbuktu/lib.
-#
-# The following variables are also defined by this module, but in line with
-# CMake recommended FindPackage() module style should NOT be referenced directly
-# by callers (use the plural variables detailed above instead).  These variables
-# do however affect the behaviour of the module via FIND_[PATH/LIBRARY]() which
-# are NOT re-called (i.e. search for library is not repeated) if these variables
-# are set with valid values _in the CMake cache_. This means that if these
-# variables are set directly in the cache, either by the user in the CMake GUI,
-# or by the user passing -DVAR=VALUE directives to CMake when called (which
-# explicitly defines a cache variable), then they will be used verbatim,
-# bypassing the HINTS variables and other hard-coded search locations.
-#
-# GLOG_INCLUDE_DIR: Include directory for glog, not including the
-#                   include directory of any dependencies.
-# GLOG_LIBRARY: glog library, not including the libraries of any
-#               dependencies.
-
-# Reset CALLERS_CMAKE_FIND_LIBRARY_PREFIXES to its value when
-# FindGlog was invoked.
-macro(GLOG_RESET_FIND_LIBRARY_PREFIX)
-  if (MSVC AND CALLERS_CMAKE_FIND_LIBRARY_PREFIXES)
-    set(CMAKE_FIND_LIBRARY_PREFIXES "${CALLERS_CMAKE_FIND_LIBRARY_PREFIXES}")
-  endif()
-endmacro(GLOG_RESET_FIND_LIBRARY_PREFIX)
-
-# Called if we failed to find glog or any of it's required dependencies,
-# unsets all public (designed to be used externally) variables and reports
-# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument.
-macro(GLOG_REPORT_NOT_FOUND REASON_MSG)
-  unset(GLOG_FOUND)
-  unset(GLOG_INCLUDE_DIRS)
-  unset(GLOG_LIBRARIES)
-  # Make results of search visible in the CMake GUI if glog has not
-  # been found so that user does not have to toggle to advanced view.
-  mark_as_advanced(CLEAR GLOG_INCLUDE_DIR
-                         GLOG_LIBRARY)
-
-  glog_reset_find_library_prefix()
-
-  # Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage()
-  # use the camelcase library name, not uppercase.
-  if (Glog_FIND_QUIETLY)
-    message(STATUS "Failed to find glog - " ${REASON_MSG} ${ARGN})
-  elseif (Glog_FIND_REQUIRED)
-    message(FATAL_ERROR "Failed to find glog - " ${REASON_MSG} ${ARGN})
-  else()
-    # Neither QUIETLY nor REQUIRED, use no priority which emits a message
-    # but continues configuration and allows generation.
-    message("-- Failed to find glog - " ${REASON_MSG} ${ARGN})
-  endif ()
-  return()
-endmacro(GLOG_REPORT_NOT_FOUND)
-
-# glog_message([mode] "message text")
-#
-# Wraps the standard cmake 'message' command, but suppresses output
-# if the QUIET flag was passed to the find_package(Glog ...) call.
-function(GLOG_MESSAGE)
-  if (NOT Glog_FIND_QUIETLY)
-    message(${ARGN})
-  endif()
-endfunction()
-
-# Protect against any alternative find_package scripts for this library having
-# been called previously (in a client project) which set GLOG_FOUND, but not
-# the other variables we require / set here which could cause the search logic
-# here to fail.
-unset(GLOG_FOUND)
-
-# -----------------------------------------------------------------
-# By default, if the user has expressed no preference for using an exported
-# glog CMake configuration over performing a search for the installed
-# components, and has not specified any hints for the search locations, then
-# prefer a glog exported configuration if available.
-if (NOT DEFINED GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION
-    AND NOT GLOG_INCLUDE_DIR_HINTS
-    AND NOT GLOG_LIBRARY_DIR_HINTS)
-  glog_message(STATUS "No preference for use of exported glog CMake "
-    "configuration set, and no hints for include/library directories provided. "
-    "Defaulting to preferring an installed/exported glog CMake configuration "
-    "if available.")
-  set(GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION TRUE)
-endif()
-
-# On macOS, add the Homebrew prefix (with appropriate suffixes) to the
-# respective HINTS directories (after any user-specified locations).  This
-# handles Homebrew installations into non-standard locations (not /usr/local).
-# We do not use CMAKE_PREFIX_PATH for this as given the search ordering of
-# find_xxx(), doing so would override any user-specified HINTS locations with
-# the Homebrew version if it exists.
-if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
-  find_program(HOMEBREW_EXECUTABLE brew)
-  mark_as_advanced(FORCE HOMEBREW_EXECUTABLE)
-  if (HOMEBREW_EXECUTABLE)
-    # Detected a Homebrew install, query for its install prefix.
-    execute_process(COMMAND ${HOMEBREW_EXECUTABLE} --prefix
-      OUTPUT_VARIABLE HOMEBREW_INSTALL_PREFIX
-      OUTPUT_STRIP_TRAILING_WHITESPACE)
-    glog_message(STATUS "Detected Homebrew with install prefix: "
-      "${HOMEBREW_INSTALL_PREFIX}, adding to CMake search paths.")
-    list(APPEND GLOG_INCLUDE_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/include")
-    list(APPEND GLOG_LIBRARY_DIR_HINTS "${HOMEBREW_INSTALL_PREFIX}/lib")
-  endif()
-endif()
-
-if (GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION)
-  # Try to find an exported CMake configuration for glog, as generated by
-  # glog versions > 0.3.4
-  #
-  # We search twice, s/t we can invert the ordering of precedence used by
-  # find_package() for exported package build directories, and installed
-  # packages (found via CMAKE_SYSTEM_PREFIX_PATH), listed as items 6) and 7)
-  # respectively in [1].
-  #
-  # By default, exported build directories are (in theory) detected first, and
-  # this is usually the case on Windows.  However, on OS X & Linux, the install
-  # path (/usr/local) is typically present in the PATH environment variable
-  # which is checked in item 4) in [1] (i.e. before both of the above, unless
-  # NO_SYSTEM_ENVIRONMENT_PATH is passed).  As such on those OSs installed
-  # packages are usually detected in preference to exported package build
-  # directories.
-  #
-  # To ensure a more consistent response across all OSs, and as users usually
-  # want to prefer an installed version of a package over a locally built one
-  # where both exist (esp. as the exported build directory might be removed
-  # after installation), we first search with NO_CMAKE_PACKAGE_REGISTRY which
-  # means any build directories exported by the user are ignored, and thus
-  # installed directories are preferred.  If this fails to find the package
-  # we then research again, but without NO_CMAKE_PACKAGE_REGISTRY, so any
-  # exported build directories will now be detected.
-  #
-  # To prevent confusion on Windows, we also pass NO_CMAKE_BUILDS_PATH (which
-  # is item 5) in [1]), to not preferentially use projects that were built
-  # recently with the CMake GUI to ensure that we always prefer an installed
-  # version if available.
-  #
-  # NOTE: We use the NAMES option as glog erroneously uses 'google-glog' as its
-  #       project name when built with CMake, but exports itself as just 'glog'.
-  #       On Linux/OS X this does not break detection as the project name is
-  #       not used as part of the install path for the CMake package files,
-  #       e.g. /usr/local/lib/cmake/glog, where the <glog> suffix is hardcoded
-  #       in glog's CMakeLists.  However, on Windows the project name *is*
-  #       part of the install prefix: C:/Program Files/google-glog/[include,lib].
-  #       However, by default CMake checks:
-  #       C:/Program Files/<FIND_PACKAGE_ARGUMENT_NAME='glog'> which does not
-  #       exist and thus detection fails.  Thus we use the NAMES to force the
-  #       search to use both google-glog & glog.
-  #
-  # [1] http://www.cmake.org/cmake/help/v2.8.11/cmake.html#command:find_package
-  find_package(glog QUIET
-                    NAMES google-glog glog
-                    HINTS ${glog_DIR} ${HOMEBREW_INSTALL_PREFIX}
-                    NO_MODULE
-                    NO_CMAKE_PACKAGE_REGISTRY
-                    NO_CMAKE_BUILDS_PATH)
-  if (glog_FOUND)
-    glog_message(STATUS "Found installed version of glog: ${glog_DIR}")
-  else()
-    # Failed to find an installed version of glog, repeat search allowing
-    # exported build directories.
-    glog_message(STATUS "Failed to find installed glog CMake configuration, "
-      "searching for glog build directories exported with CMake.")
-    # Again pass NO_CMAKE_BUILDS_PATH, as we know that glog is exported and
-    # do not want to treat projects built with the CMake GUI preferentially.
-    find_package(glog QUIET
-                      NAMES google-glog glog
-                      NO_MODULE
-                      NO_CMAKE_BUILDS_PATH)
-    if (glog_FOUND)
-      glog_message(STATUS "Found exported glog build directory: ${glog_DIR}")
-    endif(glog_FOUND)
-  endif(glog_FOUND)
-
-  set(FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION ${glog_FOUND})
-
-  if (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-    glog_message(STATUS "Detected glog version: ${glog_VERSION}")
-    set(GLOG_FOUND ${glog_FOUND})
-    # glog wraps the include directories into the exported glog::glog target.
-    set(GLOG_INCLUDE_DIR "")
-    set(GLOG_LIBRARY glog::glog)
-  else (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-    glog_message(STATUS "Failed to find an installed/exported CMake "
-      "configuration for glog, will perform search for installed glog "
-      "components.")
-  endif (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-endif(GLOG_PREFER_EXPORTED_GLOG_CMAKE_CONFIGURATION)
-
-if (NOT GLOG_FOUND)
-  # Either failed to find an exported glog CMake configuration, or user
-  # told us not to use one.  Perform a manual search for all glog components.
-
-  # Handle possible presence of lib prefix for libraries on MSVC, see
-  # also GLOG_RESET_FIND_LIBRARY_PREFIX().
-  if (MSVC)
-    # Preserve the caller's original values for CMAKE_FIND_LIBRARY_PREFIXES
-    # s/t we can set it back before returning.
-    set(CALLERS_CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}")
-    # The empty string in this list is important, it represents the case when
-    # the libraries have no prefix (shared libraries / DLLs).
-    set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "" "${CMAKE_FIND_LIBRARY_PREFIXES}")
-  endif (MSVC)
-
-  # Search user-installed locations first, so that we prefer user installs
-  # to system installs where both exist.
-  list(APPEND GLOG_CHECK_INCLUDE_DIRS
-    /usr/local/include
-    /usr/local/homebrew/include # Mac OS X
-    /opt/local/var/macports/software # Mac OS X.
-    /opt/local/include
-    /usr/include)
-  # Windows (for C:/Program Files prefix).
-  list(APPEND GLOG_CHECK_PATH_SUFFIXES
-    glog/include
-    glog/Include
-    Glog/include
-    Glog/Include
-    google-glog/include # CMake installs with project name prefix.
-    google-glog/Include)
-
-  list(APPEND GLOG_CHECK_LIBRARY_DIRS
-    /usr/local/lib
-    /usr/local/homebrew/lib # Mac OS X.
-    /opt/local/lib
-    /usr/lib)
-  # Windows (for C:/Program Files prefix).
-  list(APPEND GLOG_CHECK_LIBRARY_SUFFIXES
-    glog/lib
-    glog/Lib
-    Glog/lib
-    Glog/Lib
-    google-glog/lib # CMake installs with project name prefix.
-    google-glog/Lib)
-
-  # Search supplied hint directories first if supplied.
-  find_path(GLOG_INCLUDE_DIR
-    NAMES glog/logging.h
-    HINTS ${GLOG_INCLUDE_DIR_HINTS}
-    PATHS ${GLOG_CHECK_INCLUDE_DIRS}
-    PATH_SUFFIXES ${GLOG_CHECK_PATH_SUFFIXES})
-  if (NOT GLOG_INCLUDE_DIR OR
-      NOT EXISTS ${GLOG_INCLUDE_DIR})
-    glog_report_not_found(
-      "Could not find glog include directory, set GLOG_INCLUDE_DIR "
-      "to directory containing glog/logging.h")
-  endif (NOT GLOG_INCLUDE_DIR OR
-    NOT EXISTS ${GLOG_INCLUDE_DIR})
-
-  find_library(GLOG_LIBRARY NAMES glog
-    HINTS ${GLOG_LIBRARY_DIR_HINTS}
-    PATHS ${GLOG_CHECK_LIBRARY_DIRS}
-    PATH_SUFFIXES ${GLOG_CHECK_LIBRARY_SUFFIXES})
-  if (NOT GLOG_LIBRARY OR
-      NOT EXISTS ${GLOG_LIBRARY})
-    glog_report_not_found(
-      "Could not find glog library, set GLOG_LIBRARY "
-      "to full path to libglog.")
-  endif (NOT GLOG_LIBRARY OR
-    NOT EXISTS ${GLOG_LIBRARY})
-
-  # Mark internally as found, then verify. GLOG_REPORT_NOT_FOUND() unsets
-  # if called.
-  set(GLOG_FOUND TRUE)
-
-  # Glog does not seem to provide any record of the version in its
-  # source tree, thus cannot extract version.
-
-  # Catch case when caller has set GLOG_INCLUDE_DIR in the cache / GUI and
-  # thus FIND_[PATH/LIBRARY] are not called, but specified locations are
-  # invalid, otherwise we would report the library as found.
-  if (GLOG_INCLUDE_DIR AND
-      NOT EXISTS ${GLOG_INCLUDE_DIR}/glog/logging.h)
-    glog_report_not_found(
-      "Caller defined GLOG_INCLUDE_DIR:"
-      " ${GLOG_INCLUDE_DIR} does not contain glog/logging.h header.")
-  endif (GLOG_INCLUDE_DIR AND
-    NOT EXISTS ${GLOG_INCLUDE_DIR}/glog/logging.h)
-  # TODO: This regex for glog library is pretty primitive, we use lowercase
-  #       for comparison to handle Windows using CamelCase library names, could
-  #       this check be better?
-  string(TOLOWER "${GLOG_LIBRARY}" LOWERCASE_GLOG_LIBRARY)
-  if (GLOG_LIBRARY AND
-      NOT "${LOWERCASE_GLOG_LIBRARY}" MATCHES ".*glog[^/]*")
-    glog_report_not_found(
-      "Caller defined GLOG_LIBRARY: "
-      "${GLOG_LIBRARY} does not match glog.")
-  endif (GLOG_LIBRARY AND
-    NOT "${LOWERCASE_GLOG_LIBRARY}" MATCHES ".*glog[^/]*")
-
-  # add glog::glog target
-  add_library(glog::glog INTERFACE IMPORTED)
-  target_include_directories(glog::glog INTERFACE ${GLOG_INCLUDE_DIRS})
-  target_link_libraries(glog::glog INTERFACE ${GLOG_LIBRARY})
-
-  glog_reset_find_library_prefix()
-
-endif(NOT GLOG_FOUND)
-
-# Set standard CMake FindPackage variables if found.
-if (GLOG_FOUND)
-  set(GLOG_INCLUDE_DIRS ${GLOG_INCLUDE_DIR})
-  set(GLOG_LIBRARIES ${GLOG_LIBRARY})
-endif (GLOG_FOUND)
-
-# If we are using an exported CMake glog target, the include directories are
-# wrapped into the target itself, and do not have to be (and are not)
-# separately specified.  In which case, we should not add GLOG_INCLUDE_DIRS
-# to the list of required variables in order that glog be reported as found.
-if (FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-  set(GLOG_REQUIRED_VARIABLES GLOG_LIBRARIES)
-else()
-  set(GLOG_REQUIRED_VARIABLES GLOG_INCLUDE_DIRS GLOG_LIBRARIES)
-endif()
-
-# Handle REQUIRED / QUIET optional arguments.
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Glog DEFAULT_MSG
-  ${GLOG_REQUIRED_VARIABLES})
-
-# Only mark internal variables as advanced if we found glog, otherwise
-# leave them visible in the standard GUI for the user to set manually.
-if (GLOG_FOUND)
-  mark_as_advanced(FORCE GLOG_INCLUDE_DIR
-                         GLOG_LIBRARY
-                         glog_DIR) # Autogenerated by find_package(glog)
-endif (GLOG_FOUND)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8af2077..27a903c 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -29,28 +29,28 @@
 # Author: keir@google.com (Keir Mierle)
 
 add_executable(helloworld helloworld.cc)
-target_link_libraries(helloworld PRIVATE Ceres::ceres)
+target_link_libraries(helloworld PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(helloworld_numeric_diff helloworld_numeric_diff.cc)
-target_link_libraries(helloworld_numeric_diff PRIVATE Ceres::ceres)
+target_link_libraries(helloworld_numeric_diff PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(helloworld_analytic_diff helloworld_analytic_diff.cc)
-target_link_libraries(helloworld_analytic_diff PRIVATE Ceres::ceres)
+target_link_libraries(helloworld_analytic_diff PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(curve_fitting curve_fitting.cc)
-target_link_libraries(curve_fitting PRIVATE Ceres::ceres)
+target_link_libraries(curve_fitting PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(rosenbrock rosenbrock.cc)
-target_link_libraries(rosenbrock PRIVATE Ceres::ceres)
+target_link_libraries(rosenbrock PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(rosenbrock_analytic_diff rosenbrock_analytic_diff.cc)
-target_link_libraries(rosenbrock_analytic_diff PRIVATE Ceres::ceres)
+target_link_libraries(rosenbrock_analytic_diff PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(rosenbrock_numeric_diff rosenbrock_numeric_diff.cc)
-target_link_libraries(rosenbrock_numeric_diff PRIVATE Ceres::ceres)
+target_link_libraries(rosenbrock_numeric_diff PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(curve_fitting_c curve_fitting.c)
-target_link_libraries(curve_fitting_c PRIVATE Ceres::ceres)
+target_link_libraries(curve_fitting_c PRIVATE absl::log_initialize Ceres::ceres)
 # Force CMake to link curve_fitting_c using the C++ linker.
 set_target_properties(curve_fitting_c PROPERTIES LINKER_LANGUAGE CXX)
 # As this is a C file #including <math.h> we have to explicitly add the math
@@ -61,64 +61,64 @@
 endif (HAVE_LIBM)
 
 add_executable(ellipse_approximation ellipse_approximation.cc)
-target_link_libraries(ellipse_approximation PRIVATE Ceres::ceres)
+target_link_libraries(ellipse_approximation PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(robust_curve_fitting robust_curve_fitting.cc)
-target_link_libraries(robust_curve_fitting PRIVATE Ceres::ceres)
+target_link_libraries(robust_curve_fitting PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(simple_bundle_adjuster simple_bundle_adjuster.cc)
-target_link_libraries(simple_bundle_adjuster PRIVATE Ceres::ceres)
+target_link_libraries(simple_bundle_adjuster PRIVATE absl::log_initialize Ceres::ceres )
 
 add_executable(bicubic_interpolation bicubic_interpolation.cc)
-target_link_libraries(bicubic_interpolation PRIVATE Ceres::ceres)
+target_link_libraries(bicubic_interpolation PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(bicubic_interpolation_analytic bicubic_interpolation_analytic.cc)
-target_link_libraries(bicubic_interpolation_analytic PRIVATE Ceres::ceres)
+target_link_libraries(bicubic_interpolation_analytic PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(iteration_callback_example iteration_callback_example.cc)
-target_link_libraries(iteration_callback_example PRIVATE Ceres::ceres)
+target_link_libraries(iteration_callback_example PRIVATE absl::log_initialize Ceres::ceres)
 
 add_executable(evaluation_callback_example evaluation_callback_example.cc)
-target_link_libraries(evaluation_callback_example PRIVATE Ceres::ceres)
+target_link_libraries(evaluation_callback_example PRIVATE absl::log_initialize Ceres::ceres)
 
-if (GFLAGS)
-  add_executable(powell powell.cc)
-  target_link_libraries(powell PRIVATE Ceres::ceres gflags)
 
-  add_executable(nist nist.cc)
-  target_link_libraries(nist PRIVATE Ceres::ceres gflags)
-  if (HAVE_BIGOBJ)
-    target_compile_options(nist PRIVATE /bigobj)
-  endif()
+add_executable(powell powell.cc)
+target_link_libraries(powell PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(more_garbow_hillstrom more_garbow_hillstrom.cc)
-  target_link_libraries(more_garbow_hillstrom PRIVATE Ceres::ceres gflags)
+add_executable(nist nist.cc)
+target_link_libraries(nist PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
+if (HAVE_BIGOBJ)
+  target_compile_options(nist PRIVATE /bigobj)
+endif()
 
-  add_executable(circle_fit circle_fit.cc)
-  target_link_libraries(circle_fit PRIVATE Ceres::ceres gflags)
+add_executable(more_garbow_hillstrom more_garbow_hillstrom.cc)
+target_link_libraries(more_garbow_hillstrom PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(bundle_adjuster
-                 bundle_adjuster.cc
-                 bal_problem.cc)
-  target_link_libraries(bundle_adjuster PRIVATE Ceres::ceres gflags)
+add_executable(circle_fit circle_fit.cc)
+target_link_libraries(circle_fit PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(libmv_bundle_adjuster
-                 libmv_bundle_adjuster.cc)
-  target_link_libraries(libmv_bundle_adjuster PRIVATE Ceres::ceres gflags)
+add_executable(bundle_adjuster
+  bundle_adjuster.cc
+  bal_problem.cc)
+target_link_libraries(bundle_adjuster PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(libmv_homography
-                 libmv_homography.cc)
-  target_link_libraries(libmv_homography PRIVATE Ceres::ceres gflags)
+add_executable(libmv_bundle_adjuster
+  libmv_bundle_adjuster.cc)
+target_link_libraries(libmv_bundle_adjuster PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(denoising
-                 denoising.cc
-                 fields_of_experts.cc)
-  target_link_libraries(denoising PRIVATE Ceres::ceres gflags)
+add_executable(libmv_homography
+  libmv_homography.cc)
+target_link_libraries(libmv_homography PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
 
-  add_executable(robot_pose_mle
-                 robot_pose_mle.cc)
-  target_link_libraries(robot_pose_mle PRIVATE Ceres::ceres gflags)
-endif (GFLAGS)
+add_executable(denoising
+  denoising.cc
+  fields_of_experts.cc)
+target_link_libraries(denoising PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
+
+add_executable(robot_pose_mle
+  robot_pose_mle.cc)
+target_link_libraries(robot_pose_mle PRIVATE absl::log_initialize absl::flags absl::flags_parse Ceres::ceres)
+
 
 add_subdirectory(sampled_function)
 add_subdirectory(slam)
diff --git a/examples/bal_problem.cc b/examples/bal_problem.cc
index ccf7449..d6cb2b7 100644
--- a/examples/bal_problem.cc
+++ b/examples/bal_problem.cc
@@ -39,8 +39,9 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/rotation.h"
-#include "glog/logging.h"
 
 namespace ceres::examples {
 namespace {
diff --git a/examples/bicubic_interpolation.cc b/examples/bicubic_interpolation.cc
index 21b3c7e..a5f4f19 100644
--- a/examples/bicubic_interpolation.cc
+++ b/examples/bicubic_interpolation.cc
@@ -39,9 +39,10 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
 #include "ceres/cubic_interpolation.h"
-#include "glog/logging.h"
 
 using Grid = ceres::Grid2D<double>;
 using Interpolator = ceres::BiCubicInterpolator<Grid>;
@@ -87,7 +88,7 @@
 }
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
   // Problem sizes
   const int kGridRowsHalf = 9;
   const int kGridColsHalf = 11;
diff --git a/examples/bicubic_interpolation_analytic.cc b/examples/bicubic_interpolation_analytic.cc
index 4b79d56..716b4c8 100644
--- a/examples/bicubic_interpolation_analytic.cc
+++ b/examples/bicubic_interpolation_analytic.cc
@@ -39,9 +39,10 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
 #include "ceres/cubic_interpolation.h"
-#include "glog/logging.h"
 
 using Grid = ceres::Grid2D<double>;
 using Interpolator = ceres::BiCubicInterpolator<Grid>;
@@ -98,7 +99,7 @@
 }
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
   // Problem sizes
   const int kGridRowsHalf = 9;
   const int kGridColsHalf = 11;
diff --git a/examples/bundle_adjuster.cc b/examples/bundle_adjuster.cc
index 8df0d8a..ecec6bf 100644
--- a/examples/bundle_adjuster.cc
+++ b/examples/bundle_adjuster.cc
@@ -60,85 +60,88 @@
 #include <thread>
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "bal_problem.h"
 #include "ceres/ceres.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 #include "snavely_reprojection_error.h"
 
 // clang-format makes the gflags definitions too verbose
 // clang-format off
 
-DEFINE_string(input, "", "Input File name");
-DEFINE_string(trust_region_strategy, "levenberg_marquardt",
+ABSL_FLAG(std::string, input, "", "Input File name");
+ABSL_FLAG(std::string, trust_region_strategy, "levenberg_marquardt",
               "Options are: levenberg_marquardt, dogleg.");
-DEFINE_string(dogleg, "traditional_dogleg", "Options are: traditional_dogleg,"
+ABSL_FLAG(std::string, dogleg, "traditional_dogleg", "Options are: traditional_dogleg,"
               "subspace_dogleg.");
 
-DEFINE_bool(inner_iterations, false, "Use inner iterations to non-linearly "
+ABSL_FLAG(bool, inner_iterations, false, "Use inner iterations to non-linearly "
             "refine each successful trust region step.");
 
-DEFINE_string(blocks_for_inner_iterations, "automatic", "Options are: "
+ABSL_FLAG(std::string, blocks_for_inner_iterations, "automatic", "Options are: "
               "automatic, cameras, points, cameras,points, points,cameras");
 
-DEFINE_string(linear_solver, "sparse_schur", "Options are: "
+ABSL_FLAG(std::string, linear_solver, "sparse_schur", "Options are: "
               "sparse_schur, dense_schur, iterative_schur, "
               "sparse_normal_cholesky, dense_qr, dense_normal_cholesky, "
               "and cgnr.");
-DEFINE_bool(explicit_schur_complement, false, "If using ITERATIVE_SCHUR "
+ABSL_FLAG(bool, explicit_schur_complement, false, "If using ITERATIVE_SCHUR "
             "then explicitly compute the Schur complement.");
-DEFINE_string(preconditioner, "jacobi", "Options are: "
+ABSL_FLAG(std::string, preconditioner, "jacobi", "Options are: "
               "identity, jacobi, schur_jacobi, schur_power_series_expansion, cluster_jacobi, "
               "cluster_tridiagonal.");
-DEFINE_string(visibility_clustering, "canonical_views",
+ABSL_FLAG(std::string, visibility_clustering, "canonical_views",
               "single_linkage, canonical_views");
-DEFINE_bool(use_spse_initialization, false,
+ABSL_FLAG(bool, use_spse_initialization, false,
             "Use power series expansion to initialize the solution in ITERATIVE_SCHUR linear solver.");
 
-DEFINE_string(sparse_linear_algebra_library, "suite_sparse",
+ABSL_FLAG(std::string, sparse_linear_algebra_library, "suite_sparse",
               "Options are: suite_sparse, accelerate_sparse, eigen_sparse and cuda_sparse");
-DEFINE_string(dense_linear_algebra_library, "eigen",
+ABSL_FLAG(std::string, dense_linear_algebra_library, "eigen",
               "Options are: eigen, lapack, and cuda");
-DEFINE_string(ordering_type, "amd", "Options are: amd, nesdis");
-DEFINE_string(linear_solver_ordering, "user",
+ABSL_FLAG(std::string, ordering_type, "amd", "Options are: amd, nesdis");
+ABSL_FLAG(std::string, linear_solver_ordering, "user",
               "Options are: automatic and user");
 
-DEFINE_bool(use_quaternions, false, "If true, uses quaternions to represent "
+ABSL_FLAG(bool, use_quaternions, false, "If true, uses quaternions to represent "
             "rotations. If false, angle axis is used.");
-DEFINE_bool(use_manifolds, false, "For quaternions, use a manifold.");
-DEFINE_bool(robustify, false, "Use a robust loss function.");
+ABSL_FLAG(bool, use_manifolds, false, "For quaternions, use a manifold.");
+ABSL_FLAG(bool, robustify, false, "Use a robust loss function.");
 
-DEFINE_double(eta, 1e-2, "Default value for eta. Eta determines the "
+ABSL_FLAG(double, eta, 1e-2, "Default value for eta. Eta determines the "
               "accuracy of each linear solve of the truncated newton step. "
               "Changing this parameter can affect solve performance.");
 
-DEFINE_int32(num_threads, -1, "Number of threads. -1 = std::thread::hardware_concurrency.");
-DEFINE_int32(num_iterations, 5, "Number of iterations.");
-DEFINE_int32(max_linear_solver_iterations, 500, "Maximum number of iterations"
+ABSL_FLAG(int32_t, num_threads, -1, "Number of threads. -1 = std::thread::hardware_concurrency.");
+ABSL_FLAG(int32_t, num_iterations, 5, "Number of iterations.");
+ABSL_FLAG(int32_t, max_linear_solver_iterations, 500, "Maximum number of iterations"
             " for solution of linear system.");
-DEFINE_double(spse_tolerance, 0.1,
+ABSL_FLAG(double, spse_tolerance, 0.1,
              "Tolerance to reach during the iterations of power series expansion initialization or preconditioning.");
-DEFINE_int32(max_num_spse_iterations, 5,
+ABSL_FLAG(int32_t, max_num_spse_iterations, 5,
              "Maximum number of iterations for power series expansion initialization or preconditioning.");
-DEFINE_double(max_solver_time, 1e32, "Maximum solve time in seconds.");
-DEFINE_bool(nonmonotonic_steps, false, "Trust region algorithm can use"
+ABSL_FLAG(double, max_solver_time, 1e32, "Maximum solve time in seconds.");
+ABSL_FLAG(bool, nonmonotonic_steps, false, "Trust region algorithm can use"
             " nonmonotic steps.");
 
-DEFINE_double(rotation_sigma, 0.0, "Standard deviation of camera rotation "
+ABSL_FLAG(double, rotation_sigma, 0.0, "Standard deviation of camera rotation "
               "perturbation.");
-DEFINE_double(translation_sigma, 0.0, "Standard deviation of the camera "
+ABSL_FLAG(double, translation_sigma, 0.0, "Standard deviation of the camera "
               "translation perturbation.");
-DEFINE_double(point_sigma, 0.0, "Standard deviation of the point "
+ABSL_FLAG(double, point_sigma, 0.0, "Standard deviation of the point "
               "perturbation.");
-DEFINE_int32(random_seed, 38401, "Random seed used to set the state "
+ABSL_FLAG(int32_t, random_seed, 38401, "Random seed used to set the state "
              "of the pseudo random number generator used to generate "
              "the perturbations.");
-DEFINE_bool(line_search, false, "Use a line search instead of trust region "
+ABSL_FLAG(bool, line_search, false, "Use a line search instead of trust region "
             "algorithm.");
-DEFINE_bool(mixed_precision_solves, false, "Use mixed precision solves.");
-DEFINE_int32(max_num_refinement_iterations, 0, "Iterative refinement iterations");
-DEFINE_string(initial_ply, "", "Export the BAL file data as a PLY file.");
-DEFINE_string(final_ply, "", "Export the refined BAL file data as a PLY "
+ABSL_FLAG(bool, mixed_precision_solves, false, "Use mixed precision solves.");
+ABSL_FLAG(int32_t, max_num_refinement_iterations, 0, "Iterative refinement iterations");
+ABSL_FLAG(std::string, initial_ply, "", "Export the BAL file data as a PLY file.");
+ABSL_FLAG(std::string, final_ply, "", "Export the refined BAL file data as a PLY "
               "file.");
 // clang-format on
 
@@ -146,35 +149,35 @@
 namespace {
 
 void SetLinearSolver(Solver::Options* options) {
-  CHECK(StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
+  CHECK(StringToLinearSolverType(absl::GetFlag(FLAGS_linear_solver),
                                  &options->linear_solver_type));
-  CHECK(StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
+  CHECK(StringToPreconditionerType(absl::GetFlag(FLAGS_preconditioner),
                                    &options->preconditioner_type));
   CHECK(StringToVisibilityClusteringType(
-      CERES_GET_FLAG(FLAGS_visibility_clustering),
+      absl::GetFlag(FLAGS_visibility_clustering),
       &options->visibility_clustering_type));
   CHECK(StringToSparseLinearAlgebraLibraryType(
-      CERES_GET_FLAG(FLAGS_sparse_linear_algebra_library),
+      absl::GetFlag(FLAGS_sparse_linear_algebra_library),
       &options->sparse_linear_algebra_library_type));
   CHECK(StringToDenseLinearAlgebraLibraryType(
-      CERES_GET_FLAG(FLAGS_dense_linear_algebra_library),
+      absl::GetFlag(FLAGS_dense_linear_algebra_library),
       &options->dense_linear_algebra_library_type));
   CHECK(
-      StringToLinearSolverOrderingType(CERES_GET_FLAG(FLAGS_ordering_type),
+      StringToLinearSolverOrderingType(absl::GetFlag(FLAGS_ordering_type),
                                        &options->linear_solver_ordering_type));
   options->use_explicit_schur_complement =
-      CERES_GET_FLAG(FLAGS_explicit_schur_complement);
+      absl::GetFlag(FLAGS_explicit_schur_complement);
   options->use_mixed_precision_solves =
-      CERES_GET_FLAG(FLAGS_mixed_precision_solves);
+      absl::GetFlag(FLAGS_mixed_precision_solves);
   options->max_num_refinement_iterations =
-      CERES_GET_FLAG(FLAGS_max_num_refinement_iterations);
+      absl::GetFlag(FLAGS_max_num_refinement_iterations);
   options->max_linear_solver_iterations =
-      CERES_GET_FLAG(FLAGS_max_linear_solver_iterations);
+      absl::GetFlag(FLAGS_max_linear_solver_iterations);
   options->use_spse_initialization =
-      CERES_GET_FLAG(FLAGS_use_spse_initialization);
-  options->spse_tolerance = CERES_GET_FLAG(FLAGS_spse_tolerance);
+      absl::GetFlag(FLAGS_use_spse_initialization);
+  options->spse_tolerance = absl::GetFlag(FLAGS_spse_tolerance);
   options->max_num_spse_iterations =
-      CERES_GET_FLAG(FLAGS_max_num_spse_iterations);
+      absl::GetFlag(FLAGS_max_num_spse_iterations);
 }
 
 void SetOrdering(BALProblem* bal_problem, Solver::Options* options) {
@@ -187,7 +190,7 @@
   double* cameras = bal_problem->mutable_cameras();
 
   if (options->use_inner_iterations) {
-    if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) == "cameras") {
+    if (absl::GetFlag(FLAGS_blocks_for_inner_iterations) == "cameras") {
       LOG(INFO) << "Camera blocks for inner iterations";
       options->inner_iteration_ordering =
           std::make_shared<ParameterBlockOrdering>();
@@ -195,7 +198,7 @@
         options->inner_iteration_ordering->AddElementToGroup(
             cameras + camera_block_size * i, 0);
       }
-    } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) == "points") {
+    } else if (absl::GetFlag(FLAGS_blocks_for_inner_iterations) == "points") {
       LOG(INFO) << "Point blocks for inner iterations";
       options->inner_iteration_ordering =
           std::make_shared<ParameterBlockOrdering>();
@@ -203,7 +206,7 @@
         options->inner_iteration_ordering->AddElementToGroup(
             points + point_block_size * i, 0);
       }
-    } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+    } else if (absl::GetFlag(FLAGS_blocks_for_inner_iterations) ==
                "cameras,points") {
       LOG(INFO) << "Camera followed by point blocks for inner iterations";
       options->inner_iteration_ordering =
@@ -216,7 +219,7 @@
         options->inner_iteration_ordering->AddElementToGroup(
             points + point_block_size * i, 1);
       }
-    } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+    } else if (absl::GetFlag(FLAGS_blocks_for_inner_iterations) ==
                "points,cameras") {
       LOG(INFO) << "Point followed by camera blocks for inner iterations";
       options->inner_iteration_ordering =
@@ -229,12 +232,12 @@
         options->inner_iteration_ordering->AddElementToGroup(
             points + point_block_size * i, 0);
       }
-    } else if (CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations) ==
+    } else if (absl::GetFlag(FLAGS_blocks_for_inner_iterations) ==
                "automatic") {
       LOG(INFO) << "Choosing automatic blocks for inner iterations";
     } else {
       LOG(FATAL) << "Unknown block type for inner iterations: "
-                 << CERES_GET_FLAG(FLAGS_blocks_for_inner_iterations);
+                 << absl::GetFlag(FLAGS_blocks_for_inner_iterations);
     }
   }
 
@@ -247,7 +250,7 @@
   // This can either be done by specifying a
   // Options::linear_solver_ordering or having Ceres figure it out
   // automatically using a greedy maximum independent set algorithm.
-  if (CERES_GET_FLAG(FLAGS_linear_solver_ordering) == "user") {
+  if (absl::GetFlag(FLAGS_linear_solver_ordering) == "user") {
     auto* ordering = new ceres::ParameterBlockOrdering;
 
     // The points come before the cameras.
@@ -266,32 +269,31 @@
 }
 
 void SetMinimizerOptions(Solver::Options* options) {
-  options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
+  options->max_num_iterations = absl::GetFlag(FLAGS_num_iterations);
   options->minimizer_progress_to_stdout = true;
-  if (CERES_GET_FLAG(FLAGS_num_threads) == -1) {
+  if (absl::GetFlag(FLAGS_num_threads) == -1) {
     const int num_available_threads =
         static_cast<int>(std::thread::hardware_concurrency());
     if (num_available_threads > 0) {
       options->num_threads = num_available_threads;
     }
   } else {
-    options->num_threads = CERES_GET_FLAG(FLAGS_num_threads);
+    options->num_threads = absl::GetFlag(FLAGS_num_threads);
   }
   CHECK_GE(options->num_threads, 1);
 
-  options->eta = CERES_GET_FLAG(FLAGS_eta);
-  options->max_solver_time_in_seconds = CERES_GET_FLAG(FLAGS_max_solver_time);
-  options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
-  if (CERES_GET_FLAG(FLAGS_line_search)) {
+  options->eta = absl::GetFlag(FLAGS_eta);
+  options->max_solver_time_in_seconds = absl::GetFlag(FLAGS_max_solver_time);
+  options->use_nonmonotonic_steps = absl::GetFlag(FLAGS_nonmonotonic_steps);
+  if (absl::GetFlag(FLAGS_line_search)) {
     options->minimizer_type = ceres::LINE_SEARCH;
   }
 
   CHECK(StringToTrustRegionStrategyType(
-      CERES_GET_FLAG(FLAGS_trust_region_strategy),
+      absl::GetFlag(FLAGS_trust_region_strategy),
       &options->trust_region_strategy_type));
-  CHECK(
-      StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg), &options->dogleg_type));
-  options->use_inner_iterations = CERES_GET_FLAG(FLAGS_inner_iterations);
+  CHECK(StringToDoglegType(absl::GetFlag(FLAGS_dogleg), &options->dogleg_type));
+  options->use_inner_iterations = absl::GetFlag(FLAGS_inner_iterations);
 }
 
 void SetSolverOptionsFromFlags(BALProblem* bal_problem,
@@ -315,7 +317,7 @@
     CostFunction* cost_function;
     // Each Residual block takes a point and a camera as input and
     // outputs a 2 dimensional residual.
-    cost_function = (CERES_GET_FLAG(FLAGS_use_quaternions))
+    cost_function = (absl::GetFlag(FLAGS_use_quaternions))
                         ? SnavelyReprojectionErrorWithQuaternions::Create(
                               observations[2 * i + 0], observations[2 * i + 1])
                         : SnavelyReprojectionError::Create(
@@ -323,7 +325,7 @@
 
     // If enabled use Huber's loss function.
     LossFunction* loss_function =
-        CERES_GET_FLAG(FLAGS_robustify) ? new HuberLoss(1.0) : nullptr;
+        absl::GetFlag(FLAGS_robustify) ? new HuberLoss(1.0) : nullptr;
 
     // Each observation corresponds to a pair of a camera and a point
     // which are identified by camera_index()[i] and point_index()[i]
@@ -334,8 +336,8 @@
     problem->AddResidualBlock(cost_function, loss_function, camera, point);
   }
 
-  if (CERES_GET_FLAG(FLAGS_use_quaternions) &&
-      CERES_GET_FLAG(FLAGS_use_manifolds)) {
+  if (absl::GetFlag(FLAGS_use_quaternions) &&
+      absl::GetFlag(FLAGS_use_manifolds)) {
     Manifold* camera_manifold =
         new ProductManifold<QuaternionManifold, EuclideanManifold<6>>{};
     for (int i = 0; i < bal_problem->num_cameras(); ++i) {
@@ -345,19 +347,19 @@
 }
 
 void SolveProblem(const char* filename) {
-  BALProblem bal_problem(filename, CERES_GET_FLAG(FLAGS_use_quaternions));
+  BALProblem bal_problem(filename, absl::GetFlag(FLAGS_use_quaternions));
 
-  if (!CERES_GET_FLAG(FLAGS_initial_ply).empty()) {
-    bal_problem.WriteToPLYFile(CERES_GET_FLAG(FLAGS_initial_ply));
+  if (!absl::GetFlag(FLAGS_initial_ply).empty()) {
+    bal_problem.WriteToPLYFile(absl::GetFlag(FLAGS_initial_ply));
   }
 
   Problem problem;
 
-  srand(CERES_GET_FLAG(FLAGS_random_seed));
+  srand(absl::GetFlag(FLAGS_random_seed));
   bal_problem.Normalize();
-  bal_problem.Perturb(CERES_GET_FLAG(FLAGS_rotation_sigma),
-                      CERES_GET_FLAG(FLAGS_translation_sigma),
-                      CERES_GET_FLAG(FLAGS_point_sigma));
+  bal_problem.Perturb(absl::GetFlag(FLAGS_rotation_sigma),
+                      absl::GetFlag(FLAGS_translation_sigma),
+                      absl::GetFlag(FLAGS_point_sigma));
 
   BuildProblem(&bal_problem, &problem);
   Solver::Options options;
@@ -369,8 +371,8 @@
   Solve(options, &problem, &summary);
   std::cout << summary.FullReport() << "\n";
 
-  if (!CERES_GET_FLAG(FLAGS_final_ply).empty()) {
-    bal_problem.WriteToPLYFile(CERES_GET_FLAG(FLAGS_final_ply));
+  if (!absl::GetFlag(FLAGS_final_ply).empty()) {
+    bal_problem.WriteToPLYFile(absl::GetFlag(FLAGS_final_ply));
   }
 }
 
@@ -378,17 +380,17 @@
 }  // namespace ceres::examples
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
 
-  if (CERES_GET_FLAG(FLAGS_input).empty()) {
+  if (absl::GetFlag(FLAGS_input).empty()) {
     LOG(ERROR) << "Usage: bundle_adjuster --input=bal_problem";
     return 1;
   }
 
-  CHECK(CERES_GET_FLAG(FLAGS_use_quaternions) ||
-        !CERES_GET_FLAG(FLAGS_use_manifolds))
+  CHECK(absl::GetFlag(FLAGS_use_quaternions) ||
+        !absl::GetFlag(FLAGS_use_manifolds))
       << "--use_manifolds can only be used with --use_quaternions.";
-  ceres::examples::SolveProblem(CERES_GET_FLAG(FLAGS_input).c_str());
+  ceres::examples::SolveProblem(absl::GetFlag(FLAGS_input).c_str());
   return 0;
 }
diff --git a/examples/circle_fit.cc b/examples/circle_fit.cc
index fd848d9..45cf5e3 100644
--- a/examples/circle_fit.cc
+++ b/examples/circle_fit.cc
@@ -53,14 +53,18 @@
 #include <cstdio>
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
-DEFINE_double(robust_threshold,
-              0.0,
-              "Robust loss parameter. Set to 0 for normal squared error (no "
-              "robustification).");
+ABSL_FLAG(double,
+          robust_threshold,
+          0.0,
+          "Robust loss parameter. Set to 0 for normal squared error (no "
+          "robustification).");
 
 // The cost for a single sample. The returned residual is related to the
 // distance of the point from the circle (passed in as x, y, m parameters).
@@ -102,8 +106,8 @@
 };
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
 
   double x, y, r;
   if (scanf("%lg %lg %lg", &x, &y, &r) != 3) {
@@ -124,8 +128,8 @@
 
   // Configure the loss function.
   ceres::LossFunction* loss = nullptr;
-  if (CERES_GET_FLAG(FLAGS_robust_threshold)) {
-    loss = new ceres::CauchyLoss(CERES_GET_FLAG(FLAGS_robust_threshold));
+  if (absl::GetFlag(FLAGS_robust_threshold)) {
+    loss = new ceres::CauchyLoss(absl::GetFlag(FLAGS_robust_threshold));
   }
 
   // Add the residuals.
diff --git a/examples/curve_fitting.cc b/examples/curve_fitting.cc
index 105402e..c7593fb 100644
--- a/examples/curve_fitting.cc
+++ b/examples/curve_fitting.cc
@@ -31,8 +31,8 @@
 // This example fits the curve f(x;m,c) = e^(m * x + c) to data, minimizing the
 // sum squared loss.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // Data generated using the following octave code.
 //   randn('seed', 23497);
@@ -132,8 +132,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-
+  absl::InitializeLog();
   const double initial_m = 0.0;
   const double initial_c = 0.0;
   double m = initial_m;
diff --git a/examples/denoising.cc b/examples/denoising.cc
index dc13d19..5f826d8 100644
--- a/examples/denoising.cc
+++ b/examples/denoising.cc
@@ -46,61 +46,81 @@
 #include <string>
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "fields_of_experts.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 #include "pgm_image.h"
 
-DEFINE_string(input, "", "File to which the output image should be written");
-DEFINE_string(foe_file, "", "FoE file to use");
-DEFINE_string(output, "", "File to which the output image should be written");
-DEFINE_double(sigma, 20.0, "Standard deviation of noise");
-DEFINE_string(trust_region_strategy,
-              "levenberg_marquardt",
-              "Options are: levenberg_marquardt, dogleg.");
-DEFINE_string(dogleg,
-              "traditional_dogleg",
-              "Options are: traditional_dogleg,"
-              "subspace_dogleg.");
-DEFINE_string(linear_solver,
-              "sparse_normal_cholesky",
-              "Options are: "
-              "sparse_normal_cholesky and cgnr.");
-DEFINE_string(preconditioner,
-              "jacobi",
-              "Options are: "
-              "identity, jacobi, subset");
-DEFINE_string(sparse_linear_algebra_library,
-              "suite_sparse",
-              "Options are: suite_sparse, cx_sparse and eigen_sparse");
-DEFINE_double(eta,
-              1e-2,
-              "Default value for eta. Eta determines the "
-              "accuracy of each linear solve of the truncated newton step. "
-              "Changing this parameter can affect solve performance.");
-DEFINE_int32(num_threads, 1, "Number of threads.");
-DEFINE_int32(num_iterations, 10, "Number of iterations.");
-DEFINE_bool(nonmonotonic_steps,
-            false,
-            "Trust region algorithm can use"
-            " nonmonotic steps.");
-DEFINE_bool(inner_iterations,
-            false,
-            "Use inner iterations to non-linearly "
-            "refine each successful trust region step.");
-DEFINE_bool(mixed_precision_solves, false, "Use mixed precision solves.");
-DEFINE_int32(max_num_refinement_iterations,
-             0,
-             "Iterative refinement iterations");
-DEFINE_bool(line_search,
-            false,
-            "Use a line search instead of trust region "
-            "algorithm.");
-DEFINE_double(subset_fraction,
-              0.2,
-              "The fraction of residual blocks to use for the"
-              " subset preconditioner.");
+ABSL_FLAG(std::string,
+          input,
+          "",
+          "File to which the output image should be written");
+ABSL_FLAG(std::string, foe_file, "", "FoE file to use");
+ABSL_FLAG(std::string,
+          output,
+          "",
+          "File to which the output image should be written");
+ABSL_FLAG(double, sigma, 20.0, "Standard deviation of noise");
+ABSL_FLAG(std::string,
+          trust_region_strategy,
+          "levenberg_marquardt",
+          "Options are: levenberg_marquardt, dogleg.");
+ABSL_FLAG(std::string,
+          dogleg,
+          "traditional_dogleg",
+          "Options are: traditional_dogleg,"
+          "subspace_dogleg.");
+ABSL_FLAG(std::string,
+          linear_solver,
+          "sparse_normal_cholesky",
+          "Options are: "
+          "sparse_normal_cholesky and cgnr.");
+ABSL_FLAG(std::string,
+          preconditioner,
+          "jacobi",
+          "Options are: "
+          "identity, jacobi, subset");
+ABSL_FLAG(std::string,
+          sparse_linear_algebra_library,
+          "suite_sparse",
+          "Options are: suite_sparse, cx_sparse and eigen_sparse");
+ABSL_FLAG(double,
+          eta,
+          1e-2,
+          "Default value for eta. Eta determines the "
+          "accuracy of each linear solve of the truncated newton step. "
+          "Changing this parameter can affect solve performance.");
+ABSL_FLAG(int32_t, num_threads, 1, "Number of threads.");
+ABSL_FLAG(int32_t, num_iterations, 10, "Number of iterations.");
+ABSL_FLAG(bool,
+          nonmonotonic_steps,
+          false,
+          "Trust region algorithm can use"
+          " nonmonotic steps.");
+ABSL_FLAG(bool,
+          inner_iterations,
+          false,
+          "Use inner iterations to non-linearly "
+          "refine each successful trust region step.");
+ABSL_FLAG(bool, mixed_precision_solves, false, "Use mixed precision solves.");
+ABSL_FLAG(int32_t,
+          max_num_refinement_iterations,
+          0,
+          "Iterative refinement iterations");
+ABSL_FLAG(bool,
+          line_search,
+          false,
+          "Use a line search instead of trust region "
+          "algorithm.");
+ABSL_FLAG(double,
+          subset_fraction,
+          0.2,
+          "The fraction of residual blocks to use for the"
+          " subset preconditioner.");
 
 namespace ceres::examples {
 namespace {
@@ -133,9 +153,9 @@
                    Problem* problem,
                    PGMImage<double>* solution) {
   // Create the data term
-  CHECK_GT(CERES_GET_FLAG(FLAGS_sigma), 0.0);
+  CHECK_GT(absl::GetFlag(FLAGS_sigma), 0.0);
   const double coefficient =
-      1 / (2.0 * CERES_GET_FLAG(FLAGS_sigma) * CERES_GET_FLAG(FLAGS_sigma));
+      1 / (2.0 * absl::GetFlag(FLAGS_sigma) * absl::GetFlag(FLAGS_sigma));
   for (int index = 0; index < image.NumPixels(); ++index) {
     ceres::CostFunction* cost_function = new QuadraticCostFunction(
         coefficient, image.PixelFromLinearIndex(index));
@@ -175,35 +195,34 @@
 }
 
 void SetLinearSolver(Solver::Options* options) {
-  CHECK(StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
+  CHECK(StringToLinearSolverType(absl::GetFlag(FLAGS_linear_solver),
                                  &options->linear_solver_type));
-  CHECK(StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
+  CHECK(StringToPreconditionerType(absl::GetFlag(FLAGS_preconditioner),
                                    &options->preconditioner_type));
   CHECK(StringToSparseLinearAlgebraLibraryType(
-      CERES_GET_FLAG(FLAGS_sparse_linear_algebra_library),
+      absl::GetFlag(FLAGS_sparse_linear_algebra_library),
       &options->sparse_linear_algebra_library_type));
   options->use_mixed_precision_solves =
-      CERES_GET_FLAG(FLAGS_mixed_precision_solves);
+      absl::GetFlag(FLAGS_mixed_precision_solves);
   options->max_num_refinement_iterations =
-      CERES_GET_FLAG(FLAGS_max_num_refinement_iterations);
+      absl::GetFlag(FLAGS_max_num_refinement_iterations);
 }
 
 void SetMinimizerOptions(Solver::Options* options) {
-  options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
+  options->max_num_iterations = absl::GetFlag(FLAGS_num_iterations);
   options->minimizer_progress_to_stdout = true;
-  options->num_threads = CERES_GET_FLAG(FLAGS_num_threads);
-  options->eta = CERES_GET_FLAG(FLAGS_eta);
-  options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
-  if (CERES_GET_FLAG(FLAGS_line_search)) {
+  options->num_threads = absl::GetFlag(FLAGS_num_threads);
+  options->eta = absl::GetFlag(FLAGS_eta);
+  options->use_nonmonotonic_steps = absl::GetFlag(FLAGS_nonmonotonic_steps);
+  if (absl::GetFlag(FLAGS_line_search)) {
     options->minimizer_type = ceres::LINE_SEARCH;
   }
 
   CHECK(StringToTrustRegionStrategyType(
-      CERES_GET_FLAG(FLAGS_trust_region_strategy),
+      absl::GetFlag(FLAGS_trust_region_strategy),
       &options->trust_region_strategy_type));
-  CHECK(
-      StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg), &options->dogleg_type));
-  options->use_inner_iterations = CERES_GET_FLAG(FLAGS_inner_iterations);
+  CHECK(StringToDoglegType(absl::GetFlag(FLAGS_dogleg), &options->dogleg_type));
+  options->use_inner_iterations = absl::GetFlag(FLAGS_inner_iterations);
 }
 
 // Solves the FoE problem using Ceres and post-processes it to make sure the
@@ -230,7 +249,7 @@
     std::default_random_engine engine;
     std::uniform_real_distribution<> distribution(0, 1);  // rage 0 - 1
     for (auto residual_block : residual_blocks) {
-      if (distribution(engine) <= CERES_GET_FLAG(FLAGS_subset_fraction)) {
+      if (distribution(engine) <= absl::GetFlag(FLAGS_subset_fraction)) {
         options.residual_blocks_for_subset_preconditioner.insert(
             residual_block);
       }
@@ -255,15 +274,15 @@
 
 int main(int argc, char** argv) {
   using namespace ceres::examples;
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
 
-  if (CERES_GET_FLAG(FLAGS_input).empty()) {
+  if (absl::GetFlag(FLAGS_input).empty()) {
     std::cerr << "Please provide an image file name using -input.\n";
     return 1;
   }
 
-  if (CERES_GET_FLAG(FLAGS_foe_file).empty()) {
+  if (absl::GetFlag(FLAGS_foe_file).empty()) {
     std::cerr << "Please provide a Fields of Experts file name using -foe_file."
                  "\n";
     return 1;
@@ -271,16 +290,16 @@
 
   // Load the Fields of Experts filters from file.
   FieldsOfExperts foe;
-  if (!foe.LoadFromFile(CERES_GET_FLAG(FLAGS_foe_file))) {
-    std::cerr << "Loading \"" << CERES_GET_FLAG(FLAGS_foe_file)
+  if (!foe.LoadFromFile(absl::GetFlag(FLAGS_foe_file))) {
+    std::cerr << "Loading \"" << absl::GetFlag(FLAGS_foe_file)
               << "\" failed.\n";
     return 2;
   }
 
   // Read the images
-  PGMImage<double> image(CERES_GET_FLAG(FLAGS_input));
+  PGMImage<double> image(absl::GetFlag(FLAGS_input));
   if (image.width() == 0) {
-    std::cerr << "Reading \"" << CERES_GET_FLAG(FLAGS_input) << "\" failed.\n";
+    std::cerr << "Reading \"" << absl::GetFlag(FLAGS_input) << "\" failed.\n";
     return 3;
   }
   PGMImage<double> solution(image.width(), image.height());
@@ -291,9 +310,9 @@
 
   SolveProblem(&problem, &solution);
 
-  if (!CERES_GET_FLAG(FLAGS_output).empty()) {
-    CHECK(solution.WriteToFile(CERES_GET_FLAG(FLAGS_output)))
-        << "Writing \"" << CERES_GET_FLAG(FLAGS_output) << "\" failed.";
+  if (!absl::GetFlag(FLAGS_output).empty()) {
+    CHECK(solution.WriteToFile(absl::GetFlag(FLAGS_output)))
+        << "Writing \"" << absl::GetFlag(FLAGS_output) << "\" failed.";
   }
 
   return 0;
diff --git a/examples/ellipse_approximation.cc b/examples/ellipse_approximation.cc
index 6fa8f1c..1b462e7 100644
--- a/examples/ellipse_approximation.cc
+++ b/examples/ellipse_approximation.cc
@@ -39,8 +39,9 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // Data generated with the following Python code.
 //   import numpy as np
@@ -378,8 +379,7 @@
 }
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-
+  absl::InitializeLog();
   // Problem configuration.
   const int num_segments = 151;
   const double regularization_weight = 1e-2;
diff --git a/examples/evaluation_callback_example.cc b/examples/evaluation_callback_example.cc
index 6dbf932..7ca1412 100644
--- a/examples/evaluation_callback_example.cc
+++ b/examples/evaluation_callback_example.cc
@@ -47,8 +47,9 @@
 #include <iostream>
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // Data generated using the following octave code.
 //   randn('seed', 23497);
@@ -224,7 +225,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   const double initial_m = 0.0;
   const double initial_c = 0.0;
diff --git a/examples/helloworld.cc b/examples/helloworld.cc
index 40c2f2c..48182ce 100644
--- a/examples/helloworld.cc
+++ b/examples/helloworld.cc
@@ -33,8 +33,8 @@
 // Minimize 0.5 (10 - x)^2 using jacobian matrix computed using
 // automatic differentiation.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // A templated cost functor that implements the residual r = 10 -
 // x. The method operator() is templated so that we can then use an
@@ -49,7 +49,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   // The variable to solve for with its initial value. It will be
   // mutated in place by the solver.
diff --git a/examples/helloworld_analytic_diff.cc b/examples/helloworld_analytic_diff.cc
index b4826a2..dcbe2ad 100644
--- a/examples/helloworld_analytic_diff.cc
+++ b/examples/helloworld_analytic_diff.cc
@@ -34,8 +34,8 @@
 
 #include <vector>
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // A CostFunction implementing analytically derivatives for the
 // function f(x) = 10 - x.
@@ -72,7 +72,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   // The variable to solve for with its initial value. It will be
   // mutated in place by the solver.
diff --git a/examples/helloworld_numeric_diff.cc b/examples/helloworld_numeric_diff.cc
index 4ed9ca6..2b9894c 100644
--- a/examples/helloworld_numeric_diff.cc
+++ b/examples/helloworld_numeric_diff.cc
@@ -31,8 +31,8 @@
 // Minimize 0.5 (10 - x)^2 using jacobian matrix computed using
 // numeric differentiation.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // A cost functor that implements the residual r = 10 - x.
 struct CostFunctor {
@@ -43,7 +43,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   // The variable to solve for with its initial value. It will be
   // mutated in place by the solver.
diff --git a/examples/iteration_callback_example.cc b/examples/iteration_callback_example.cc
index 0be2f36..e2deada 100644
--- a/examples/iteration_callback_example.cc
+++ b/examples/iteration_callback_example.cc
@@ -35,8 +35,8 @@
 
 #include <iostream>
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // Data generated using the following octave code.
 //   randn('seed', 23497);
@@ -156,7 +156,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   const double initial_m = 0.0;
   const double initial_c = 0.0;
diff --git a/examples/libmv_bundle_adjuster.cc b/examples/libmv_bundle_adjuster.cc
index 9315ed7..69a3e0e 100644
--- a/examples/libmv_bundle_adjuster.cc
+++ b/examples/libmv_bundle_adjuster.cc
@@ -113,20 +113,24 @@
 
 #endif
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "ceres/rotation.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
 using Mat3 = Eigen::Matrix<double, 3, 3>;
 using Vec6 = Eigen::Matrix<double, 6, 1>;
 using Vec3 = Eigen::Vector3d;
 using Vec4 = Eigen::Vector4d;
 
-DEFINE_string(input, "", "Input File name");
-DEFINE_string(refine_intrinsics,
-              "",
-              "Camera intrinsics to be refined. Options are: none, radial.");
+ABSL_FLAG(std::string, input, "", "Input File name");
+ABSL_FLAG(std::string,
+          refine_intrinsics,
+          "",
+          "Camera intrinsics to be refined. Options are: none, radial.");
 
 namespace {
 
@@ -791,10 +795,10 @@
 }  // namespace
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
 
-  if (CERES_GET_FLAG(FLAGS_input).empty()) {
+  if (absl::GetFlag(FLAGS_input).empty()) {
     LOG(ERROR) << "Usage: libmv_bundle_adjuster --input=blender_problem";
     return EXIT_FAILURE;
   }
@@ -805,7 +809,7 @@
   bool is_image_space;
   std::vector<Marker> all_markers;
 
-  if (!ReadProblemFromFile(CERES_GET_FLAG(FLAGS_input),
+  if (!ReadProblemFromFile(absl::GetFlag(FLAGS_input),
                            camera_intrinsics,
                            &all_cameras,
                            &all_points,
@@ -829,14 +833,14 @@
   // declare which intrinsics need to be refined and in this case
   // refining flags does not depend on problem at all.
   int bundle_intrinsics = BUNDLE_NO_INTRINSICS;
-  if (CERES_GET_FLAG(FLAGS_refine_intrinsics).empty()) {
+  if (absl::GetFlag(FLAGS_refine_intrinsics).empty()) {
     if (is_image_space) {
       bundle_intrinsics = BUNDLE_FOCAL_LENGTH | BUNDLE_RADIAL;
     }
   } else {
-    if (CERES_GET_FLAG(FLAGS_refine_intrinsics) == "radial") {
+    if (absl::GetFlag(FLAGS_refine_intrinsics) == "radial") {
       bundle_intrinsics = BUNDLE_FOCAL_LENGTH | BUNDLE_RADIAL;
-    } else if (CERES_GET_FLAG(FLAGS_refine_intrinsics) != "none") {
+    } else if (absl::GetFlag(FLAGS_refine_intrinsics) != "none") {
       LOG(ERROR) << "Unsupported value for refine-intrinsics";
       return EXIT_FAILURE;
     }
diff --git a/examples/libmv_homography.cc b/examples/libmv_homography.cc
index b7c9eda..951cf96 100644
--- a/examples/libmv_homography.cc
+++ b/examples/libmv_homography.cc
@@ -62,8 +62,9 @@
 
 #include <utility>
 
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 using EigenDouble = Eigen::NumTraits<double>;
 
@@ -358,7 +359,7 @@
 }  // namespace
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   Mat x1(2, 100);
   for (int i = 0; i < x1.cols(); ++i) {
diff --git a/examples/more_garbow_hillstrom.cc b/examples/more_garbow_hillstrom.cc
index f15e576..59f0abc 100644
--- a/examples/more_garbow_hillstrom.cc
+++ b/examples/more_garbow_hillstrom.cc
@@ -55,22 +55,28 @@
 #include <sstream>   // NOLINT
 #include <string>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
-DEFINE_string(problem, "all", "Which problem to solve");
-DEFINE_bool(use_numeric_diff,
-            false,
-            "Use numeric differentiation instead of automatic"
-            " differentiation.");
-DEFINE_string(numeric_diff_method,
-              "ridders",
-              "When using numeric differentiation, selects algorithm. Options "
-              "are: central, forward, ridders.");
-DEFINE_int32(ridders_extrapolations,
-             3,
-             "Maximal number of extrapolations in Ridders' method.");
+ABSL_FLAG(std::string, problem, "all", "Which problem to solve");
+ABSL_FLAG(bool,
+          use_numeric_diff,
+          false,
+          "Use numeric differentiation instead of automatic"
+          " differentiation.");
+ABSL_FLAG(std::string,
+          numeric_diff_method,
+          "ridders",
+          "When using numeric differentiation, selects algorithm. Options "
+          "are: central, forward, ridders.");
+ABSL_FLAG(int32_t,
+          ridders_extrapolations,
+          3,
+          "Maximal number of extrapolations in Ridders' method.");
 
 namespace ceres::examples {
 
@@ -78,50 +84,50 @@
 
 static void SetNumericDiffOptions(ceres::NumericDiffOptions* options) {
   options->max_num_ridders_extrapolations =
-      CERES_GET_FLAG(FLAGS_ridders_extrapolations);
+      absl::GetFlag(FLAGS_ridders_extrapolations);
 }
 
-#define BEGIN_MGH_PROBLEM(name, num_parameters, num_residuals)               \
-  struct name {                                                              \
-    static constexpr int kNumParameters = num_parameters;                    \
-    static const double initial_x[kNumParameters];                           \
-    static const double lower_bounds[kNumParameters];                        \
-    static const double upper_bounds[kNumParameters];                        \
-    static const double constrained_optimal_cost;                            \
-    static const double unconstrained_optimal_cost;                          \
-    static CostFunction* Create() {                                          \
-      if (CERES_GET_FLAG(FLAGS_use_numeric_diff)) {                          \
-        ceres::NumericDiffOptions options;                                   \
-        SetNumericDiffOptions(&options);                                     \
-        if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "central") {        \
-          return new NumericDiffCostFunction<name,                           \
-                                             ceres::CENTRAL,                 \
-                                             num_residuals,                  \
-                                             num_parameters>(                \
-              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);      \
-        } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "forward") { \
-          return new NumericDiffCostFunction<name,                           \
-                                             ceres::FORWARD,                 \
-                                             num_residuals,                  \
-                                             num_parameters>(                \
-              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);      \
-        } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "ridders") { \
-          return new NumericDiffCostFunction<name,                           \
-                                             ceres::RIDDERS,                 \
-                                             num_residuals,                  \
-                                             num_parameters>(                \
-              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);      \
-        } else {                                                             \
-          LOG(ERROR) << "Invalid numeric diff method specified";             \
-          return nullptr;                                                    \
-        }                                                                    \
-      } else {                                                               \
-        return new AutoDiffCostFunction<name,                                \
-                                        num_residuals,                       \
-                                        num_parameters>();                   \
-      }                                                                      \
-    }                                                                        \
-    template <typename T>                                                    \
+#define BEGIN_MGH_PROBLEM(name, num_parameters, num_residuals)              \
+  struct name {                                                             \
+    static constexpr int kNumParameters = num_parameters;                   \
+    static const double initial_x[kNumParameters];                          \
+    static const double lower_bounds[kNumParameters];                       \
+    static const double upper_bounds[kNumParameters];                       \
+    static const double constrained_optimal_cost;                           \
+    static const double unconstrained_optimal_cost;                         \
+    static CostFunction* Create() {                                         \
+      if (absl::GetFlag(FLAGS_use_numeric_diff)) {                          \
+        ceres::NumericDiffOptions options;                                  \
+        SetNumericDiffOptions(&options);                                    \
+        if (absl::GetFlag(FLAGS_numeric_diff_method) == "central") {        \
+          return new NumericDiffCostFunction<name,                          \
+                                             ceres::CENTRAL,                \
+                                             num_residuals,                 \
+                                             num_parameters>(               \
+              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);     \
+        } else if (absl::GetFlag(FLAGS_numeric_diff_method) == "forward") { \
+          return new NumericDiffCostFunction<name,                          \
+                                             ceres::FORWARD,                \
+                                             num_residuals,                 \
+                                             num_parameters>(               \
+              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);     \
+        } else if (absl::GetFlag(FLAGS_numeric_diff_method) == "ridders") { \
+          return new NumericDiffCostFunction<name,                          \
+                                             ceres::RIDDERS,                \
+                                             num_residuals,                 \
+                                             num_parameters>(               \
+              new name, ceres::TAKE_OWNERSHIP, num_residuals, options);     \
+        } else {                                                            \
+          LOG(ERROR) << "Invalid numeric diff method specified";            \
+          return nullptr;                                                   \
+        }                                                                   \
+      } else {                                                              \
+        return new AutoDiffCostFunction<name,                               \
+                                        num_residuals,                      \
+                                        num_parameters>();                  \
+      }                                                                     \
+    }                                                                       \
+    template <typename T>                                                   \
     bool operator()(const T* const x, T* residual) const {
 // clang-format off
 
@@ -584,8 +590,8 @@
 }  // namespace ceres::examples
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
   using ceres::examples::Solve;
 
   int unconstrained_problems = 0;
@@ -596,8 +602,8 @@
 
 #define UNCONSTRAINED_SOLVE(n)                              \
   ss << "Unconstrained Problem " << n << " : ";             \
-  if (CERES_GET_FLAG(FLAGS_problem) == #n ||                \
-      CERES_GET_FLAG(FLAGS_problem) == "all") {             \
+  if (absl::GetFlag(FLAGS_problem) == #n ||                 \
+      absl::GetFlag(FLAGS_problem) == "all") {              \
     unconstrained_problems += 3;                            \
     if (Solve<ceres::examples::TestProblem##n>(false, 0)) { \
       unconstrained_successes += 1;                         \
@@ -645,8 +651,8 @@
 
 #define CONSTRAINED_SOLVE(n)                               \
   ss << "Constrained Problem " << n << " : ";              \
-  if (CERES_GET_FLAG(FLAGS_problem) == #n ||               \
-      CERES_GET_FLAG(FLAGS_problem) == "all") {            \
+  if (absl::GetFlag(FLAGS_problem) == #n ||                \
+      absl::GetFlag(FLAGS_problem) == "all") {             \
     constrained_problems += 1;                             \
     if (Solve<ceres::examples::TestProblem##n>(true, 0)) { \
       constrained_successes += 1;                          \
diff --git a/examples/nist.cc b/examples/nist.cc
index b92c918..48d5697 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -79,80 +79,112 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "ceres/tiny_solver.h"
 #include "ceres/tiny_solver_cost_function_adapter.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
-DEFINE_bool(use_tiny_solver, false, "Use TinySolver instead of Ceres::Solver");
-DEFINE_string(nist_data_dir,
-              "",
-              "Directory containing the NIST non-linear regression examples");
-DEFINE_string(minimizer,
-              "trust_region",
-              "Minimizer type to use, choices are: line_search & trust_region");
-DEFINE_string(trust_region_strategy,
-              "levenberg_marquardt",
-              "Options are: levenberg_marquardt, dogleg");
-DEFINE_string(dogleg,
-              "traditional_dogleg",
-              "Options are: traditional_dogleg, subspace_dogleg");
-DEFINE_string(linear_solver,
-              "dense_qr",
-              "Options are: sparse_cholesky, dense_qr, dense_normal_cholesky "
-              "and cgnr");
-DEFINE_string(dense_linear_algebra_library,
-              "eigen",
-              "Options are: eigen, lapack, and cuda.");
-DEFINE_string(preconditioner, "jacobi", "Options are: identity, jacobi");
-DEFINE_string(line_search,
-              "wolfe",
-              "Line search algorithm to use, choices are: armijo and wolfe.");
-DEFINE_string(line_search_direction,
-              "lbfgs",
-              "Line search direction algorithm to use, choices: lbfgs, bfgs");
-DEFINE_int32(max_line_search_iterations,
-             20,
-             "Maximum number of iterations for each line search.");
-DEFINE_int32(max_line_search_restarts,
-             10,
-             "Maximum number of restarts of line search direction algorithm.");
-DEFINE_string(line_search_interpolation,
-              "cubic",
-              "Degree of polynomial approximation in line search, choices are: "
-              "bisection, quadratic & cubic.");
-DEFINE_int32(lbfgs_rank,
-             20,
-             "Rank of L-BFGS inverse Hessian approximation in line search.");
-DEFINE_bool(approximate_eigenvalue_bfgs_scaling,
-            false,
-            "Use approximate eigenvalue scaling in (L)BFGS line search.");
-DEFINE_double(sufficient_decrease,
-              1.0e-4,
-              "Line search Armijo sufficient (function) decrease factor.");
-DEFINE_double(sufficient_curvature_decrease,
-              0.9,
-              "Line search Wolfe sufficient curvature decrease factor.");
-DEFINE_int32(num_iterations, 10000, "Number of iterations");
-DEFINE_bool(nonmonotonic_steps,
-            false,
-            "Trust region algorithm can use nonmonotic steps");
-DEFINE_double(initial_trust_region_radius, 1e4, "Initial trust region radius");
-DEFINE_bool(use_numeric_diff,
-            false,
-            "Use numeric differentiation instead of automatic "
-            "differentiation.");
-DEFINE_string(numeric_diff_method,
-              "ridders",
-              "When using numeric differentiation, selects algorithm. Options "
-              "are: central, forward, ridders.");
-DEFINE_double(ridders_step_size,
-              1e-9,
-              "Initial step size for Ridders numeric differentiation.");
-DEFINE_int32(ridders_extrapolations,
-             3,
-             "Maximal number of Ridders extrapolations.");
+ABSL_FLAG(bool,
+          use_tiny_solver,
+          false,
+          "Use TinySolver instead of Ceres::Solver");
+ABSL_FLAG(std::string,
+          nist_data_dir,
+          "",
+          "Directory containing the NIST non-linear regression examples");
+ABSL_FLAG(std::string,
+          minimizer,
+          "trust_region",
+          "Minimizer type to use, choices are: line_search & trust_region");
+ABSL_FLAG(std::string,
+          trust_region_strategy,
+          "levenberg_marquardt",
+          "Options are: levenberg_marquardt, dogleg");
+ABSL_FLAG(std::string,
+          dogleg,
+          "traditional_dogleg",
+          "Options are: traditional_dogleg, subspace_dogleg");
+ABSL_FLAG(std::string,
+          linear_solver,
+          "dense_qr",
+          "Options are: sparse_cholesky, dense_qr, dense_normal_cholesky "
+          "and cgnr");
+ABSL_FLAG(std::string,
+          dense_linear_algebra_library,
+          "eigen",
+          "Options are: eigen, lapack, and cuda.");
+ABSL_FLAG(std::string,
+          preconditioner,
+          "jacobi",
+          "Options are: identity, jacobi");
+ABSL_FLAG(std::string,
+          line_search,
+          "wolfe",
+          "Line search algorithm to use, choices are: armijo and wolfe.");
+ABSL_FLAG(std::string,
+          line_search_direction,
+          "lbfgs",
+          "Line search direction algorithm to use, choices: lbfgs, bfgs");
+ABSL_FLAG(int32_t,
+          max_line_search_iterations,
+          20,
+          "Maximum number of iterations for each line search.");
+ABSL_FLAG(int32_t,
+          max_line_search_restarts,
+          10,
+          "Maximum number of restarts of line search direction algorithm.");
+ABSL_FLAG(std::string,
+          line_search_interpolation,
+          "cubic",
+          "Degree of polynomial approximation in line search, choices are: "
+          "bisection, quadratic & cubic.");
+ABSL_FLAG(int32_t,
+          lbfgs_rank,
+          20,
+          "Rank of L-BFGS inverse Hessian approximation in line search.");
+ABSL_FLAG(bool,
+          approximate_eigenvalue_bfgs_scaling,
+          false,
+          "Use approximate eigenvalue scaling in (L)BFGS line search.");
+ABSL_FLAG(double,
+          sufficient_decrease,
+          1.0e-4,
+          "Line search Armijo sufficient (function) decrease factor.");
+ABSL_FLAG(double,
+          sufficient_curvature_decrease,
+          0.9,
+          "Line search Wolfe sufficient curvature decrease factor.");
+ABSL_FLAG(int32_t, num_iterations, 10000, "Number of iterations");
+ABSL_FLAG(bool,
+          nonmonotonic_steps,
+          false,
+          "Trust region algorithm can use nonmonotic steps");
+ABSL_FLAG(double,
+          initial_trust_region_radius,
+          1e4,
+          "Initial trust region radius");
+ABSL_FLAG(bool,
+          use_numeric_diff,
+          false,
+          "Use numeric differentiation instead of automatic "
+          "differentiation.");
+ABSL_FLAG(std::string,
+          numeric_diff_method,
+          "ridders",
+          "When using numeric differentiation, selects algorithm. Options "
+          "are: central, forward, ridders.");
+ABSL_FLAG(double,
+          ridders_step_size,
+          1e-9,
+          "Initial step size for Ridders numeric differentiation.");
+ABSL_FLAG(int32_t,
+          ridders_extrapolations,
+          3,
+          "Maximal number of Ridders extrapolations.");
 
 namespace ceres::examples {
 namespace {
@@ -456,50 +488,50 @@
 
 static void SetNumericDiffOptions(ceres::NumericDiffOptions* options) {
   options->max_num_ridders_extrapolations =
-      CERES_GET_FLAG(FLAGS_ridders_extrapolations);
+      absl::GetFlag(FLAGS_ridders_extrapolations);
   options->ridders_relative_initial_step_size =
-      CERES_GET_FLAG(FLAGS_ridders_step_size);
+      absl::GetFlag(FLAGS_ridders_step_size);
 }
 
 void SetMinimizerOptions(ceres::Solver::Options* options) {
-  CHECK(ceres::StringToMinimizerType(CERES_GET_FLAG(FLAGS_minimizer),
+  CHECK(ceres::StringToMinimizerType(absl::GetFlag(FLAGS_minimizer),
                                      &options->minimizer_type));
-  CHECK(ceres::StringToLinearSolverType(CERES_GET_FLAG(FLAGS_linear_solver),
+  CHECK(ceres::StringToLinearSolverType(absl::GetFlag(FLAGS_linear_solver),
                                         &options->linear_solver_type));
   CHECK(StringToDenseLinearAlgebraLibraryType(
-      CERES_GET_FLAG(FLAGS_dense_linear_algebra_library),
+      absl::GetFlag(FLAGS_dense_linear_algebra_library),
       &options->dense_linear_algebra_library_type));
-  CHECK(ceres::StringToPreconditionerType(CERES_GET_FLAG(FLAGS_preconditioner),
+  CHECK(ceres::StringToPreconditionerType(absl::GetFlag(FLAGS_preconditioner),
                                           &options->preconditioner_type));
   CHECK(ceres::StringToTrustRegionStrategyType(
-      CERES_GET_FLAG(FLAGS_trust_region_strategy),
+      absl::GetFlag(FLAGS_trust_region_strategy),
       &options->trust_region_strategy_type));
-  CHECK(ceres::StringToDoglegType(CERES_GET_FLAG(FLAGS_dogleg),
+  CHECK(ceres::StringToDoglegType(absl::GetFlag(FLAGS_dogleg),
                                   &options->dogleg_type));
   CHECK(ceres::StringToLineSearchDirectionType(
-      CERES_GET_FLAG(FLAGS_line_search_direction),
+      absl::GetFlag(FLAGS_line_search_direction),
       &options->line_search_direction_type));
-  CHECK(ceres::StringToLineSearchType(CERES_GET_FLAG(FLAGS_line_search),
+  CHECK(ceres::StringToLineSearchType(absl::GetFlag(FLAGS_line_search),
                                       &options->line_search_type));
   CHECK(ceres::StringToLineSearchInterpolationType(
-      CERES_GET_FLAG(FLAGS_line_search_interpolation),
+      absl::GetFlag(FLAGS_line_search_interpolation),
       &options->line_search_interpolation_type));
 
-  options->max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
-  options->use_nonmonotonic_steps = CERES_GET_FLAG(FLAGS_nonmonotonic_steps);
+  options->max_num_iterations = absl::GetFlag(FLAGS_num_iterations);
+  options->use_nonmonotonic_steps = absl::GetFlag(FLAGS_nonmonotonic_steps);
   options->initial_trust_region_radius =
-      CERES_GET_FLAG(FLAGS_initial_trust_region_radius);
-  options->max_lbfgs_rank = CERES_GET_FLAG(FLAGS_lbfgs_rank);
+      absl::GetFlag(FLAGS_initial_trust_region_radius);
+  options->max_lbfgs_rank = absl::GetFlag(FLAGS_lbfgs_rank);
   options->line_search_sufficient_function_decrease =
-      CERES_GET_FLAG(FLAGS_sufficient_decrease);
+      absl::GetFlag(FLAGS_sufficient_decrease);
   options->line_search_sufficient_curvature_decrease =
-      CERES_GET_FLAG(FLAGS_sufficient_curvature_decrease);
+      absl::GetFlag(FLAGS_sufficient_curvature_decrease);
   options->max_num_line_search_step_size_iterations =
-      CERES_GET_FLAG(FLAGS_max_line_search_iterations);
+      absl::GetFlag(FLAGS_max_line_search_iterations);
   options->max_num_line_search_direction_restarts =
-      CERES_GET_FLAG(FLAGS_max_line_search_restarts);
+      absl::GetFlag(FLAGS_max_line_search_restarts);
   options->use_approximate_eigenvalue_bfgs_scaling =
-      CERES_GET_FLAG(FLAGS_approximate_eigenvalue_bfgs_scaling);
+      absl::GetFlag(FLAGS_approximate_eigenvalue_bfgs_scaling);
   options->function_tolerance = std::numeric_limits<double>::epsilon();
   options->gradient_tolerance = std::numeric_limits<double>::epsilon();
   options->parameter_tolerance = std::numeric_limits<double>::epsilon();
@@ -527,22 +559,22 @@
                                  const int num_observations) {
   auto* model = new Model(predictor.data(), response.data(), num_observations);
   ceres::CostFunction* cost_function = nullptr;
-  if (CERES_GET_FLAG(FLAGS_use_numeric_diff)) {
+  if (absl::GetFlag(FLAGS_use_numeric_diff)) {
     ceres::NumericDiffOptions options;
     SetNumericDiffOptions(&options);
-    if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "central") {
+    if (absl::GetFlag(FLAGS_numeric_diff_method) == "central") {
       cost_function = new NumericDiffCostFunction<Model,
                                                   ceres::CENTRAL,
                                                   ceres::DYNAMIC,
                                                   num_parameters>(
           model, ceres::TAKE_OWNERSHIP, num_observations, options);
-    } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "forward") {
+    } else if (absl::GetFlag(FLAGS_numeric_diff_method) == "forward") {
       cost_function = new NumericDiffCostFunction<Model,
                                                   ceres::FORWARD,
                                                   ceres::DYNAMIC,
                                                   num_parameters>(
           model, ceres::TAKE_OWNERSHIP, num_observations, options);
-    } else if (CERES_GET_FLAG(FLAGS_numeric_diff_method) == "ridders") {
+    } else if (absl::GetFlag(FLAGS_numeric_diff_method) == "ridders") {
       cost_function = new NumericDiffCostFunction<Model,
                                                   ceres::RIDDERS,
                                                   ceres::DYNAMIC,
@@ -583,7 +615,7 @@
 template <typename Model, int num_parameters>
 int RegressionDriver(const std::string& filename) {
   NISTProblem nist_problem(
-      JoinPath(CERES_GET_FLAG(FLAGS_nist_data_dir), filename));
+      JoinPath(absl::GetFlag(FLAGS_nist_data_dir), filename));
   CHECK_EQ(num_parameters, nist_problem.num_parameters());
 
   Matrix predictor = nist_problem.predictor();
@@ -604,7 +636,7 @@
     double initial_cost;
     double final_cost;
 
-    if (!CERES_GET_FLAG(FLAGS_use_tiny_solver)) {
+    if (!absl::GetFlag(FLAGS_use_tiny_solver)) {
       ceres::Problem problem;
       problem.AddResidualBlock(
           cost_function, nullptr, initial_parameters.data());
@@ -620,7 +652,7 @@
       using Solver = ceres::TinySolver<
           ceres::TinySolverCostFunctionAdapter<Eigen::Dynamic, num_parameters>>;
       Solver solver;
-      solver.options.max_num_iterations = CERES_GET_FLAG(FLAGS_num_iterations);
+      solver.options.max_num_iterations = absl::GetFlag(FLAGS_num_iterations);
       solver.options.gradient_tolerance =
           std::numeric_limits<double>::epsilon();
       solver.options.parameter_tolerance =
@@ -657,7 +689,7 @@
 }
 
 void SolveNISTProblems() {
-  if (CERES_GET_FLAG(FLAGS_nist_data_dir).empty()) {
+  if (absl::GetFlag(FLAGS_nist_data_dir).empty()) {
     LOG(FATAL) << "Must specify the directory containing the NIST problems";
   }
 
@@ -709,8 +741,8 @@
 }  // namespace ceres::examples
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
   ceres::examples::SolveNISTProblems();
   return 0;
 }
diff --git a/examples/pgm_image.h b/examples/pgm_image.h
index 033ab4d..0f14901 100644
--- a/examples/pgm_image.h
+++ b/examples/pgm_image.h
@@ -41,7 +41,7 @@
 #include <string>
 #include <vector>
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres::examples {
 
diff --git a/examples/powell.cc b/examples/powell.cc
index a4ca1b7..c46cff7 100644
--- a/examples/powell.cc
+++ b/examples/powell.cc
@@ -46,9 +46,11 @@
 
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
 struct F1 {
   template <typename T>
@@ -86,14 +88,14 @@
   }
 };
 
-DEFINE_string(minimizer,
-              "trust_region",
-              "Minimizer type to use, choices are: line_search & trust_region");
+ABSL_FLAG(std::string,
+          minimizer,
+          "trust_region",
+          "Minimizer type to use, choices are: line_search & trust_region");
 
 int main(int argc, char** argv) {
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-  google::InitGoogleLogging(argv[0]);
-
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
   double x1 = 3.0;
   double x2 = -1.0;
   double x3 = 0.0;
@@ -114,9 +116,9 @@
 
   ceres::Solver::Options options;
   LOG_IF(FATAL,
-         !ceres::StringToMinimizerType(CERES_GET_FLAG(FLAGS_minimizer),
+         !ceres::StringToMinimizerType(absl::GetFlag(FLAGS_minimizer),
                                        &options.minimizer_type))
-      << "Invalid minimizer: " << CERES_GET_FLAG(FLAGS_minimizer)
+      << "Invalid minimizer: " << absl::GetFlag(FLAGS_minimizer)
       << ", valid options are: trust_region and line_search.";
 
   options.max_num_iterations = 100;
diff --git a/examples/robot_pose_mle.cc b/examples/robot_pose_mle.cc
index cc60e14..223a0bb 100644
--- a/examples/robot_pose_mle.cc
+++ b/examples/robot_pose_mle.cc
@@ -131,27 +131,34 @@
 #include <random>
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "ceres/dynamic_autodiff_cost_function.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 
-DEFINE_double(corridor_length,
-              30.0,
-              "Length of the corridor that the robot is travelling down.");
+ABSL_FLAG(double,
+          corridor_length,
+          30.0,
+          "Length of the corridor that the robot is travelling down.");
 
-DEFINE_double(pose_separation,
-              0.5,
-              "The distance that the robot traverses between successive "
-              "odometry updates.");
+ABSL_FLAG(double,
+          pose_separation,
+          0.5,
+          "The distance that the robot traverses between successive "
+          "odometry updates.");
 
-DEFINE_double(odometry_stddev,
-              0.1,
-              "The standard deviation of odometry error of the robot.");
+ABSL_FLAG(double,
+          odometry_stddev,
+          0.1,
+          "The standard deviation of odometry error of the robot.");
 
-DEFINE_double(range_stddev,
-              0.01,
-              "The standard deviation of range readings of the robot.");
+ABSL_FLAG(double,
+          range_stddev,
+          0.01,
+          "The standard deviation of range readings of the robot.");
 
 // The stride length of the dynamic_autodiff_cost_function evaluator.
 static constexpr int kStride = 10;
@@ -171,7 +178,7 @@
 
   static OdometryCostFunction* Create(const double odometry_value) {
     return new OdometryCostFunction(new OdometryConstraint(
-        odometry_value, CERES_GET_FLAG(FLAGS_odometry_stddev)));
+        odometry_value, absl::GetFlag(FLAGS_odometry_stddev)));
   }
 
   const double odometry_mean;
@@ -211,8 +218,8 @@
     auto* constraint =
         new RangeConstraint(pose_index,
                             range_reading,
-                            CERES_GET_FLAG(FLAGS_range_stddev),
-                            CERES_GET_FLAG(FLAGS_corridor_length));
+                            absl::GetFlag(FLAGS_range_stddev),
+                            absl::GetFlag(FLAGS_corridor_length));
     auto* cost_function = new RangeCostFunction(constraint);
     // Add all the parameter blocks that affect this constraint.
     parameter_blocks->clear();
@@ -235,23 +242,23 @@
 void SimulateRobot(std::vector<double>* odometry_values,
                    std::vector<double>* range_readings) {
   const int num_steps =
-      static_cast<int>(ceil(CERES_GET_FLAG(FLAGS_corridor_length) /
-                            CERES_GET_FLAG(FLAGS_pose_separation)));
+      static_cast<int>(ceil(absl::GetFlag(FLAGS_corridor_length) /
+                            absl::GetFlag(FLAGS_pose_separation)));
   std::mt19937 prng;
   std::normal_distribution<double> odometry_noise(
-      0.0, CERES_GET_FLAG(FLAGS_odometry_stddev));
+      0.0, absl::GetFlag(FLAGS_odometry_stddev));
   std::normal_distribution<double> range_noise(
-      0.0, CERES_GET_FLAG(FLAGS_range_stddev));
+      0.0, absl::GetFlag(FLAGS_range_stddev));
 
   // The robot starts out at the origin.
   double robot_location = 0.0;
   for (int i = 0; i < num_steps; ++i) {
     const double actual_odometry_value =
-        std::min(CERES_GET_FLAG(FLAGS_pose_separation),
-                 CERES_GET_FLAG(FLAGS_corridor_length) - robot_location);
+        std::min(absl::GetFlag(FLAGS_pose_separation),
+                 absl::GetFlag(FLAGS_corridor_length) - robot_location);
     robot_location += actual_odometry_value;
     const double actual_range =
-        CERES_GET_FLAG(FLAGS_corridor_length) - robot_location;
+        absl::GetFlag(FLAGS_corridor_length) - robot_location;
     const double observed_odometry =
         actual_odometry_value + odometry_noise(prng);
     const double observed_range = actual_range + range_noise(prng);
@@ -268,9 +275,9 @@
   for (int i = 0; i < odometry_readings.size(); ++i) {
     robot_location += odometry_readings[i];
     const double range_error = robot_location + range_readings[i] -
-                               CERES_GET_FLAG(FLAGS_corridor_length);
+                               absl::GetFlag(FLAGS_corridor_length);
     const double odometry_error =
-        CERES_GET_FLAG(FLAGS_pose_separation) - odometry_readings[i];
+        absl::GetFlag(FLAGS_pose_separation) - odometry_readings[i];
     printf("%4d: %8.3f %8.3f %8.3f %8.3f %8.3f\n",
            static_cast<int>(i),
            robot_location,
@@ -284,13 +291,13 @@
 }  // namespace
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
   // Make sure that the arguments parsed are all positive.
-  CHECK_GT(CERES_GET_FLAG(FLAGS_corridor_length), 0.0);
-  CHECK_GT(CERES_GET_FLAG(FLAGS_pose_separation), 0.0);
-  CHECK_GT(CERES_GET_FLAG(FLAGS_odometry_stddev), 0.0);
-  CHECK_GT(CERES_GET_FLAG(FLAGS_range_stddev), 0.0);
+  CHECK_GT(absl::GetFlag(FLAGS_corridor_length), 0.0);
+  CHECK_GT(absl::GetFlag(FLAGS_pose_separation), 0.0);
+  CHECK_GT(absl::GetFlag(FLAGS_odometry_stddev), 0.0);
+  CHECK_GT(absl::GetFlag(FLAGS_range_stddev), 0.0);
 
   std::vector<double> odometry_values;
   std::vector<double> range_readings;
diff --git a/examples/robust_curve_fitting.cc b/examples/robust_curve_fitting.cc
index e08b0df..dcb205e 100644
--- a/examples/robust_curve_fitting.cc
+++ b/examples/robust_curve_fitting.cc
@@ -34,8 +34,9 @@
 // the use of a robust loss function (CauchyLoss) to reduce the influence of the
 // outliers on the fit.
 
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // Data generated using the following octave code.
 //   randn('seed', 23497);
@@ -136,7 +137,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   const double initial_m = 0.0;
   const double initial_c = 0.0;
diff --git a/examples/rosenbrock.cc b/examples/rosenbrock.cc
index a382ccd..df609a0 100644
--- a/examples/rosenbrock.cc
+++ b/examples/rosenbrock.cc
@@ -32,8 +32,8 @@
 // (https://en.wikipedia.org/wiki/Rosenbrock_function) using
 // GradientProblemSolver using automatically computed derivatives.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // f(x,y) = (1-x)^2 + 100(y - x^2)^2;
 struct Rosenbrock {
@@ -53,7 +53,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   double parameters[2] = {-1.2, 1.0};
 
diff --git a/examples/rosenbrock_analytic_diff.cc b/examples/rosenbrock_analytic_diff.cc
index 65e49eb..5b7c30d 100644
--- a/examples/rosenbrock_analytic_diff.cc
+++ b/examples/rosenbrock_analytic_diff.cc
@@ -32,8 +32,8 @@
 // (https://en.wikipedia.org/wiki/Rosenbrock_function) using
 // GradientProblemSolver using analytic derivatives.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // f(x,y) = (1-x)^2 + 100(y - x^2)^2;
 class Rosenbrock final : public ceres::FirstOrderFunction {
@@ -58,7 +58,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   double parameters[2] = {-1.2, 1.0};
 
diff --git a/examples/rosenbrock_numeric_diff.cc b/examples/rosenbrock_numeric_diff.cc
index a711b2f..4115669 100644
--- a/examples/rosenbrock_numeric_diff.cc
+++ b/examples/rosenbrock_numeric_diff.cc
@@ -33,8 +33,10 @@
 // GradientProblemSolver using derivatives computed using numeric
 // differentiation.
 
+#include <iostream>
+
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 
 // f(x,y) = (1-x)^2 + 100(y - x^2)^2;
 struct Rosenbrock {
@@ -55,7 +57,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
 
   double parameters[2] = {-1.2, 1.0};
 
diff --git a/examples/sampled_function/CMakeLists.txt b/examples/sampled_function/CMakeLists.txt
index 1013753..65f9249 100644
--- a/examples/sampled_function/CMakeLists.txt
+++ b/examples/sampled_function/CMakeLists.txt
@@ -29,4 +29,4 @@
 # Author: vitus@google.com (Michael Vitus)
 
 add_executable(sampled_function sampled_function.cc)
-target_link_libraries(sampled_function PRIVATE Ceres::ceres)
+target_link_libraries(sampled_function PRIVATE absl::log_initialize Ceres::ceres)
diff --git a/examples/sampled_function/sampled_function.cc b/examples/sampled_function/sampled_function.cc
index 40e9c1f..9c4c970 100644
--- a/examples/sampled_function/sampled_function.cc
+++ b/examples/sampled_function/sampled_function.cc
@@ -31,9 +31,9 @@
 // A simple example of optimizing a sampled function by using cubic
 // interpolation.
 
+#include "absl/log/initialize.h"
 #include "ceres/ceres.h"
 #include "ceres/cubic_interpolation.h"
-#include "glog/logging.h"
 
 using Interpolator = ceres::CubicInterpolator<ceres::Grid1D<double>>;
 
@@ -59,8 +59,7 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-
+  absl::InitializeLog();
   // Evaluate the function f(x) = (x - 4.5)^2;
   const int kNumSamples = 10;
   double values[kNumSamples];
diff --git a/examples/simple_bundle_adjuster.cc b/examples/simple_bundle_adjuster.cc
index bb0ba1c..3350e3d 100644
--- a/examples/simple_bundle_adjuster.cc
+++ b/examples/simple_bundle_adjuster.cc
@@ -39,6 +39,8 @@
 #include <cstdio>
 #include <iostream>
 
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "ceres/rotation.h"
 
@@ -173,7 +175,8 @@
 };
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
+  absl::InitializeLog();
+
   if (argc != 2) {
     std::cerr << "usage: simple_bundle_adjuster <bal_problem>\n";
     return 1;
diff --git a/examples/slam/common/read_g2o.h b/examples/slam/common/read_g2o.h
index 490b054..2999339 100644
--- a/examples/slam/common/read_g2o.h
+++ b/examples/slam/common/read_g2o.h
@@ -36,7 +36,8 @@
 #include <fstream>
 #include <string>
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace ceres::examples {
 
diff --git a/examples/slam/pose_graph_2d/CMakeLists.txt b/examples/slam/pose_graph_2d/CMakeLists.txt
index 87943ec..c6cfb80 100644
--- a/examples/slam/pose_graph_2d/CMakeLists.txt
+++ b/examples/slam/pose_graph_2d/CMakeLists.txt
@@ -28,12 +28,10 @@
 #
 # Author: vitus@google.com (Michael Vitus)
 
-if (GFLAGS)
-  add_executable(pose_graph_2d
-    angle_manifold.h
-    normalize_angle.h
-    pose_graph_2d.cc
-    pose_graph_2d_error_term.h
-    types.h)
-  target_link_libraries(pose_graph_2d PRIVATE Ceres::ceres gflags)
-endif (GFLAGS)
+add_executable(pose_graph_2d
+  angle_manifold.h
+  normalize_angle.h
+  pose_graph_2d.cc
+  pose_graph_2d_error_term.h
+  types.h)
+target_link_libraries(pose_graph_2d PRIVATE absl::flags absl::flags_parse absl::log absl::check absl::log_initialize Ceres::ceres)
diff --git a/examples/slam/pose_graph_2d/pose_graph_2d.cc b/examples/slam/pose_graph_2d/pose_graph_2d.cc
index 3ebae3f..fe7d16d 100644
--- a/examples/slam/pose_graph_2d/pose_graph_2d.cc
+++ b/examples/slam/pose_graph_2d/pose_graph_2d.cc
@@ -39,15 +39,21 @@
 #include <string>
 #include <vector>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "angle_manifold.h"
 #include "ceres/ceres.h"
 #include "common/read_g2o.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 #include "pose_graph_2d_error_term.h"
 #include "types.h"
 
-DEFINE_string(input, "", "The pose graph definition filename in g2o format.");
+ABSL_FLAG(std::string,
+          input,
+          "",
+          "The pose graph definition filename in g2o format.");
 
 namespace ceres::examples {
 namespace {
@@ -143,16 +149,19 @@
 }  // namespace ceres::examples
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
 
-  CHECK(FLAGS_input != "") << "Need to specify the filename to read.";
+  if (absl::GetFlag(FLAGS_input).empty()) {
+    LOG(ERROR) << "Usage pose_graph_3d --input=<filename>";
+    return 1;
+  }
 
   std::map<int, ceres::examples::Pose2d> poses;
   std::vector<ceres::examples::Constraint2d> constraints;
-
-  CHECK(ceres::examples::ReadG2oFile(FLAGS_input, &poses, &constraints))
-      << "Error reading the file: " << FLAGS_input;
+  CHECK(ceres::examples::ReadG2oFile(
+      absl::GetFlag(FLAGS_input), &poses, &constraints))
+      << "Error reading the file: " << absl::GetFlag(FLAGS_input);
 
   std::cout << "Number of poses: " << poses.size() << '\n';
   std::cout << "Number of constraints: " << constraints.size() << '\n';
diff --git a/examples/slam/pose_graph_3d/CMakeLists.txt b/examples/slam/pose_graph_3d/CMakeLists.txt
index 544b00e..d1fbae6 100644
--- a/examples/slam/pose_graph_3d/CMakeLists.txt
+++ b/examples/slam/pose_graph_3d/CMakeLists.txt
@@ -28,7 +28,5 @@
 #
 # Author: vitus@google.com (Michael Vitus)
 
-if (GFLAGS)
-  add_executable(pose_graph_3d pose_graph_3d.cc)
-  target_link_libraries(pose_graph_3d PRIVATE Ceres::ceres gflags)
-endif (GFLAGS)
+add_executable(pose_graph_3d pose_graph_3d.cc)
+target_link_libraries(pose_graph_3d PRIVATE absl::flags absl::flags_parse absl::log absl::check absl::log_initialize Ceres::ceres)
diff --git a/examples/slam/pose_graph_3d/pose_graph_3d.cc b/examples/slam/pose_graph_3d/pose_graph_3d.cc
index 522e2a1..783f685 100644
--- a/examples/slam/pose_graph_3d/pose_graph_3d.cc
+++ b/examples/slam/pose_graph_3d/pose_graph_3d.cc
@@ -32,14 +32,20 @@
 #include <iostream>
 #include <string>
 
+#include "absl/flags/flag.h"
+#include "absl/flags/parse.h"
+#include "absl/log/check.h"
+#include "absl/log/initialize.h"
+#include "absl/log/log.h"
 #include "ceres/ceres.h"
 #include "common/read_g2o.h"
-#include "gflags/gflags.h"
-#include "glog/logging.h"
 #include "pose_graph_3d_error_term.h"
 #include "types.h"
 
-DEFINE_string(input, "", "The pose graph definition filename in g2o format.");
+ABSL_FLAG(std::string,
+          input,
+          "",
+          "The pose graph definition filename in g2o format.");
 
 namespace ceres::examples {
 namespace {
@@ -135,16 +141,19 @@
 }  // namespace ceres::examples
 
 int main(int argc, char** argv) {
-  google::InitGoogleLogging(argv[0]);
-  GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
-
-  CHECK(FLAGS_input != "") << "Need to specify the filename to read.";
+  absl::InitializeLog();
+  absl::ParseCommandLine(argc, argv);
+  if (absl::GetFlag(FLAGS_input).empty()) {
+    LOG(ERROR) << "Usage pose_graph_3d --input=<filename>";
+    return 1;
+  }
 
   ceres::examples::MapOfPoses poses;
   ceres::examples::VectorOfConstraints constraints;
 
-  CHECK(ceres::examples::ReadG2oFile(FLAGS_input, &poses, &constraints))
-      << "Error reading the file: " << FLAGS_input;
+  CHECK(ceres::examples::ReadG2oFile(
+      absl::GetFlag(FLAGS_input), &poses, &constraints))
+      << "Error reading the file: " << absl::GetFlag(FLAGS_input);
 
   std::cout << "Number of poses: " << poses.size() << '\n';
   std::cout << "Number of constraints: " << constraints.size() << '\n';
diff --git a/include/ceres/cost_function_to_functor.h b/include/ceres/cost_function_to_functor.h
index 573508e..a2ca6d8 100644
--- a/include/ceres/cost_function_to_functor.h
+++ b/include/ceres/cost_function_to_functor.h
@@ -92,11 +92,11 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/cost_function.h"
 #include "ceres/dynamic_cost_function_to_functor.h"
 #include "ceres/internal/parameter_dims.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/cubic_interpolation.h b/include/ceres/cubic_interpolation.h
index f165d2b..29f246b 100644
--- a/include/ceres/cubic_interpolation.h
+++ b/include/ceres/cubic_interpolation.h
@@ -32,8 +32,8 @@
 #define CERES_PUBLIC_CUBIC_INTERPOLATION_H_
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/dynamic_autodiff_cost_function.h b/include/ceres/dynamic_autodiff_cost_function.h
index 2b8724d..7b4e876 100644
--- a/include/ceres/dynamic_autodiff_cost_function.h
+++ b/include/ceres/dynamic_autodiff_cost_function.h
@@ -38,11 +38,11 @@
 #include <type_traits>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/dynamic_cost_function.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/jet.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/dynamic_cost_function_to_functor.h b/include/ceres/dynamic_cost_function_to_functor.h
index 45ed90f..331d367 100644
--- a/include/ceres/dynamic_cost_function_to_functor.h
+++ b/include/ceres/dynamic_cost_function_to_functor.h
@@ -36,11 +36,11 @@
 #include <numeric>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/dynamic_cost_function.h"
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/internal/fixed_array.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/dynamic_numeric_diff_cost_function.h b/include/ceres/dynamic_numeric_diff_cost_function.h
index 1ce384f..2cd0e9c 100644
--- a/include/ceres/dynamic_numeric_diff_cost_function.h
+++ b/include/ceres/dynamic_numeric_diff_cost_function.h
@@ -40,13 +40,13 @@
 #include <type_traits>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/dynamic_cost_function.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/numeric_diff.h"
 #include "ceres/internal/parameter_dims.h"
 #include "ceres/numeric_diff_options.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/gradient_checker.h b/include/ceres/gradient_checker.h
index 77f2c8e..765d53c 100644
--- a/include/ceres/gradient_checker.h
+++ b/include/ceres/gradient_checker.h
@@ -45,7 +45,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/manifold.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/internal/autodiff.h b/include/ceres/internal/autodiff.h
index 8b02a2b..e437417 100644
--- a/include/ceres/internal/autodiff.h
+++ b/include/ceres/internal/autodiff.h
@@ -144,6 +144,7 @@
 #include <cstddef>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "ceres/internal/array_selector.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
@@ -151,7 +152,6 @@
 #include "ceres/internal/variadic_evaluate.h"
 #include "ceres/jet.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 // If the number of parameters exceeds this values, the corresponding jets are
 // placed on the heap. This will reduce performance by a factor of 2-5 on
diff --git a/include/ceres/internal/fixed_array.h b/include/ceres/internal/fixed_array.h
index 0e35f63..7c1b65d 100644
--- a/include/ceres/internal/fixed_array.h
+++ b/include/ceres/internal/fixed_array.h
@@ -38,8 +38,8 @@
 #include <tuple>
 #include <type_traits>
 
+#include "absl/log/check.h"
 #include "ceres/internal/memory.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/include/ceres/internal/householder_vector.h b/include/ceres/internal/householder_vector.h
index dd8361c..3398d00 100644
--- a/include/ceres/internal/householder_vector.h
+++ b/include/ceres/internal/householder_vector.h
@@ -32,7 +32,7 @@
 #define CERES_PUBLIC_INTERNAL_HOUSEHOLDER_VECTOR_H_
 
 #include "Eigen/Core"
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres::internal {
 
diff --git a/include/ceres/internal/numeric_diff.h b/include/ceres/internal/numeric_diff.h
index ba28bec..4031631 100644
--- a/include/ceres/internal/numeric_diff.h
+++ b/include/ceres/internal/numeric_diff.h
@@ -40,12 +40,12 @@
 
 #include "Eigen/Dense"
 #include "Eigen/StdVector"
+#include "absl/log/check.h"
 #include "ceres/cost_function.h"
 #include "ceres/internal/fixed_array.h"
 #include "ceres/internal/variadic_evaluate.h"
 #include "ceres/numeric_diff_options.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index d78ed51..b74ca21 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -45,10 +45,6 @@
 #define CERES_DEPRECATED_WITH_MSG(message) [[deprecated(message)]]
 #endif
 
-#ifndef CERES_GET_FLAG
-#define CERES_GET_FLAG(X) X
-#endif
-
 // Indicates whether C++20 is currently active
 #ifndef CERES_HAS_CPP20
 #if __cplusplus >= 202002L || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
diff --git a/include/ceres/line_manifold.h b/include/ceres/line_manifold.h
index dad9737..64b61ba 100644
--- a/include/ceres/line_manifold.h
+++ b/include/ceres/line_manifold.h
@@ -38,13 +38,13 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/internal/householder_vector.h"
 #include "ceres/internal/sphere_manifold_functions.h"
 #include "ceres/manifold.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 // This provides a manifold for lines, where the line is
diff --git a/include/ceres/loss_function.h b/include/ceres/loss_function.h
index b8582f8..51e372d 100644
--- a/include/ceres/loss_function.h
+++ b/include/ceres/loss_function.h
@@ -80,7 +80,6 @@
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/manifold.h b/include/ceres/manifold.h
index 9bd6459..ec4eff0 100644
--- a/include/ceres/manifold.h
+++ b/include/ceres/manifold.h
@@ -38,10 +38,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/numeric_diff_first_order_function.h b/include/ceres/numeric_diff_first_order_function.h
index 525f197..612ace9 100644
--- a/include/ceres/numeric_diff_first_order_function.h
+++ b/include/ceres/numeric_diff_first_order_function.h
@@ -36,6 +36,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "ceres/first_order_function.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
@@ -44,7 +45,6 @@
 #include "ceres/internal/variadic_evaluate.h"
 #include "ceres/numeric_diff_options.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/ordered_groups.h b/include/ceres/ordered_groups.h
index d15d22d..9ae8499 100644
--- a/include/ceres/ordered_groups.h
+++ b/include/ceres/ordered_groups.h
@@ -36,8 +36,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/problem.h b/include/ceres/problem.h
index 4c6fd1b..f587594 100644
--- a/include/ceres/problem.h
+++ b/include/ceres/problem.h
@@ -46,7 +46,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/internal/port.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/rotation.h b/include/ceres/rotation.h
index 0cccfa7..367a7d0 100644
--- a/include/ceres/rotation.h
+++ b/include/ceres/rotation.h
@@ -48,9 +48,9 @@
 #include <algorithm>
 #include <cmath>
 
+#include "absl/log/check.h"
 #include "ceres/constants.h"
 #include "ceres/internal/euler_angles.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/sphere_manifold.h b/include/ceres/sphere_manifold.h
index 1c7458b..06983a0 100644
--- a/include/ceres/sphere_manifold.h
+++ b/include/ceres/sphere_manifold.h
@@ -38,13 +38,13 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/internal/householder_vector.h"
 #include "ceres/internal/sphere_manifold_functions.h"
 #include "ceres/manifold.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/include/ceres/tiny_solver_cost_function_adapter.h b/include/ceres/tiny_solver_cost_function_adapter.h
index 166f03f..39ba266 100644
--- a/include/ceres/tiny_solver_cost_function_adapter.h
+++ b/include/ceres/tiny_solver_cost_function_adapter.h
@@ -32,8 +32,8 @@
 #define CERES_PUBLIC_TINY_SOLVER_COST_FUNCTION_ADAPTER_H_
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
 #include "ceres/cost_function.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/CMakeLists.txt b/internal/ceres/CMakeLists.txt
index 6c1fe93..f30ba00 100644
--- a/internal/ceres/CMakeLists.txt
+++ b/internal/ceres/CMakeLists.txt
@@ -19,7 +19,7 @@
 # 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
+# CONSEQUENTIAblockL 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)
@@ -37,6 +37,9 @@
 # Make dependency visible to the parent CMakeLists.txt
 set(Threads_DEPENDENCY "find_dependency (Threads)" PARENT_SCOPE)
 
+list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES absl::log)
+list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES absl::check)
+
 # Source files that contain public symbols and live in the ceres namespaces.
 # Such symbols are expected to be marked with CERES_EXPORT and the files below
 # sorted in lexicographical order.
@@ -54,14 +57,6 @@
 
 # Also depend on the header files so that they appear in IDEs.
 file(GLOB CERES_INTERNAL_HDRS *.h)
-if (MINIGLOG)
-  file(GLOB MINIGLOG_HDRS miniglog/glog/*.h)
-  list(APPEND CERES_INTERNAL_HDRS ${MINIGLOG_HDRS})
-  if (ANDROID)
-    list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES log)
-  endif()
-endif()
-
 # Depend also on public headers so they appear in IDEs.
 file(GLOB CERES_PUBLIC_HDRS ${Ceres_SOURCE_DIR}/include/ceres/*.h)
 file(GLOB CERES_PUBLIC_INTERNAL_HDRS ${Ceres_SOURCE_DIR}/include/ceres/internal/*.h)
@@ -85,18 +80,6 @@
 set_source_files_properties(${CERES_INTERNAL_SCHUR_FILES} PROPERTIES
   SKIP_UNITY_BUILD_INCLUSION ON)
 
-if (NOT MINIGLOG AND GLOG_FOUND)
-  list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES ${GLOG_LIBRARIES})
-  if (gflags_FOUND)
-    # If glog & gflags are both found, we assume that glog was built with
-    # gflags, as it is awkward to perform a try_compile() to verify this
-    # when gflags is an imported target (as it is in newer versions).
-    # As glog #includes gflags/gflags.h in glog/logging.h if compiled with
-    # gflags, it is thus a public dependency for Ceres in this case.
-    list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES gflags)
-  endif()
-endif (NOT MINIGLOG AND GLOG_FOUND)
-
 if (SUITESPARSE AND SuiteSparse_FOUND)
   # Define version information for use in Solver::FullReport.
   add_definitions(-DCERES_SUITESPARSE_VERSION="${SuiteSparse_VERSION}")
@@ -253,11 +236,6 @@
     ${CERES_PUBLIC_HDRS}
     ${CERES_PUBLIC_INTERNAL_HDRS})
 
-# Primarily for Android, but optionally for others, compile the minimal
-# glog implementation into Ceres.
-if (MINIGLOG)
-  list(APPEND CERES_LIBRARY_SOURCE miniglog/glog/logging.cc)
-endif (MINIGLOG)
 
 # Ceres C++ compiler flags can be too strict for an external library code
 # which we do not maintain.
@@ -340,30 +318,12 @@
 # dependencies to be added to the Ceres target.
 set(CERES_LIBRARY_PRIVATE_DEPENDENCIES_INCLUDE_DIRS "")
 set(CERES_LIBRARY_PUBLIC_DEPENDENCIES_INCLUDE_DIRS "")
-if (MINIGLOG)
-  # Force the miniglog headers to the front of the public include directories
-  # to protect against the case when the user has glog installed in a standard
-  # location (specifically the same as the Ceres install location) but compiled
-  # Ceres with MINIGLOG anyway.  Otherwise: "glog/logging.h" in the public Ceres
-  # headers used in client code would match the installed version of glog, not
-  # the miniglog headers, and the client application would fail to link.
-  #
-  # Note that this is an imperfect fix, as we cannot control the include
-  # directories in client projects, and they could easily invert this ordering
-  # themselves (intentionally or otherwise) and so break their build.
-  target_include_directories(ceres BEFORE PUBLIC
-    $<BUILD_INTERFACE:${Ceres_SOURCE_DIR}/internal/ceres/miniglog>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/ceres/internal/miniglog>)
-elseif (NOT FOUND_INSTALLED_GLOG_CMAKE_CONFIGURATION)
-  # Only append glog include directories if the glog found was not a CMake
-  # exported target that already includes them.
-  list(APPEND CERES_LIBRARY_PUBLIC_DEPENDENCIES_INCLUDE_DIRS
-    ${GLOG_INCLUDE_DIRS})
-endif()
+
 if (ACCELERATESPARSE)
   list(APPEND CERES_LIBRARY_PRIVATE_DEPENDENCIES_INCLUDE_DIRS
     ${AccelerateSparse_INCLUDE_DIRS})
 endif()
+
 # Add include locations for optional dependencies to the Ceres target without
 # duplication.
 list(REMOVE_DUPLICATES CERES_LIBRARY_PRIVATE_DEPENDENCIES_INCLUDE_DIRS)
@@ -391,6 +351,16 @@
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
 
 if (BUILD_TESTING)
+  # Now that we have absl as a dependency, it would make sense to tell
+  # googletest to use absl also, but doing so seems to be problematic
+  # for now, since if there is a version of absl and re2 installed in
+  # the system then we start getting errors because we maybe using the
+  # absl from our submodule, but the re2 installed on the system only
+  # sees the absl installed on the system. It is possible that we will
+  # need to include re2 as a submodule also, for the following to
+  # work.
+
+  # set(GTEST_HAS_ABSL ON CACHE BOOL "Use ABSL when building gtest")
   add_subdirectory(${Ceres_SOURCE_DIR}/third_party/googletest ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/googletest)
 
   add_library(test_util STATIC
diff --git a/internal/ceres/accelerate_sparse.cc b/internal/ceres/accelerate_sparse.cc
index 0baadc0..753bf98 100644
--- a/internal/ceres/accelerate_sparse.cc
+++ b/internal/ceres/accelerate_sparse.cc
@@ -38,11 +38,12 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/accelerate_sparse.h"
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
+#include "ceres/stringprintf.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 
 #define CASESTR(x) \
   case x:          \
diff --git a/internal/ceres/block_jacobian_writer.cc b/internal/ceres/block_jacobian_writer.cc
index 5a769cb..e29bc1b 100644
--- a/internal/ceres/block_jacobian_writer.cc
+++ b/internal/ceres/block_jacobian_writer.cc
@@ -34,6 +34,8 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_evaluate_preparer.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
diff --git a/internal/ceres/block_random_access_dense_matrix.cc b/internal/ceres/block_random_access_dense_matrix.cc
index b8be51b..3e7d86a 100644
--- a/internal/ceres/block_random_access_dense_matrix.cc
+++ b/internal/ceres/block_random_access_dense_matrix.cc
@@ -35,7 +35,6 @@
 
 #include "ceres/internal/eigen.h"
 #include "ceres/parallel_vector_ops.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/block_random_access_diagonal_matrix.cc b/internal/ceres/block_random_access_diagonal_matrix.cc
index 643dbf1..b657266 100644
--- a/internal/ceres/block_random_access_diagonal_matrix.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix.cc
@@ -37,13 +37,13 @@
 #include <vector>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/internal/export.h"
 #include "ceres/parallel_for.h"
 #include "ceres/parallel_vector_ops.h"
 #include "ceres/stl_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/block_random_access_diagonal_matrix_test.cc b/internal/ceres/block_random_access_diagonal_matrix_test.cc
index f665bd8..9590d1b 100644
--- a/internal/ceres/block_random_access_diagonal_matrix_test.cc
+++ b/internal/ceres/block_random_access_diagonal_matrix_test.cc
@@ -36,7 +36,6 @@
 
 #include "Eigen/Cholesky"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/block_random_access_sparse_matrix.cc b/internal/ceres/block_random_access_sparse_matrix.cc
index b9f8b36..6694d06 100644
--- a/internal/ceres/block_random_access_sparse_matrix.cc
+++ b/internal/ceres/block_random_access_sparse_matrix.cc
@@ -36,11 +36,12 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/internal/export.h"
 #include "ceres/parallel_vector_ops.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/block_random_access_sparse_matrix_test.cc b/internal/ceres/block_random_access_sparse_matrix_test.cc
index 0bb39f1..3740682 100644
--- a/internal/ceres/block_random_access_sparse_matrix_test.cc
+++ b/internal/ceres/block_random_access_sparse_matrix_test.cc
@@ -37,7 +37,6 @@
 #include <vector>
 
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/block_sparse_matrix.cc b/internal/ceres/block_sparse_matrix.cc
index 2efee39..0878988 100644
--- a/internal/ceres/block_sparse_matrix.cc
+++ b/internal/ceres/block_sparse_matrix.cc
@@ -37,6 +37,8 @@
 #include <random>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_structure.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/eigen.h"
@@ -44,7 +46,6 @@
 #include "ceres/parallel_vector_ops.h"
 #include "ceres/small_blas.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 
 #ifndef CERES_NO_CUDA
 #include "cuda_runtime.h"
diff --git a/internal/ceres/block_sparse_matrix.h b/internal/ceres/block_sparse_matrix.h
index 2e45488..126b5aa 100644
--- a/internal/ceres/block_sparse_matrix.h
+++ b/internal/ceres/block_sparse_matrix.h
@@ -184,7 +184,7 @@
 class CERES_NO_EXPORT BlockSparseMatrixData {
  public:
   explicit BlockSparseMatrixData(const BlockSparseMatrix& m)
-      : block_structure_(m.block_structure()), values_(m.values()){};
+      : block_structure_(m.block_structure()), values_(m.values()) {};
 
   BlockSparseMatrixData(const CompressedRowBlockStructure* block_structure,
                         const double* values)
diff --git a/internal/ceres/block_sparse_matrix_test.cc b/internal/ceres/block_sparse_matrix_test.cc
index 4a524f9..c27146d 100644
--- a/internal/ceres/block_sparse_matrix_test.cc
+++ b/internal/ceres/block_sparse_matrix_test.cc
@@ -41,7 +41,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -158,16 +157,16 @@
   void SetUp() final {
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(2);
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     a_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
 
     problem = CreateLinearLeastSquaresProblemFromId(1);
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     b_.reset(down_cast<TripletSparseMatrix*>(problem->A.release()));
 
-    CHECK_EQ(a_->num_rows(), b_->num_rows());
-    CHECK_EQ(a_->num_cols(), b_->num_cols());
-    CHECK_EQ(a_->num_nonzeros(), b_->num_nonzeros());
+    ASSERT_EQ(a_->num_rows(), b_->num_rows());
+    ASSERT_EQ(a_->num_cols(), b_->num_cols());
+    ASSERT_EQ(a_->num_nonzeros(), b_->num_nonzeros());
     context_.EnsureMinimumThreads(kNumThreads);
 
     BlockSparseMatrix::RandomMatrixOptions options;
@@ -350,7 +349,7 @@
     if (t == -1) {
       a_->AppendRows(*m);
     } else if (t > 0) {
-      CHECK_GE(block_structure->rows.size(), t);
+      ASSERT_GE(block_structure->rows.size(), t);
       a_->DeleteRowBlocks(t);
     }
 
diff --git a/internal/ceres/block_structure.cc b/internal/ceres/block_structure.cc
index 70f68b2..b327453 100644
--- a/internal/ceres/block_structure.cc
+++ b/internal/ceres/block_structure.cc
@@ -32,7 +32,7 @@
 
 #include <vector>
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/bundle_adjustment_test_util.h b/internal/ceres/bundle_adjustment_test_util.h
index 48b833b..0b2b8fb 100644
--- a/internal/ceres/bundle_adjustment_test_util.h
+++ b/internal/ceres/bundle_adjustment_test_util.h
@@ -37,6 +37,7 @@
 #include <cstdlib>
 #include <string>
 
+#include "absl/log/log.h"
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/internal/export.h"
 #include "ceres/ordered_groups.h"
@@ -46,7 +47,6 @@
 #include "ceres/stringprintf.h"
 #include "ceres/test_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 namespace internal {
diff --git a/internal/ceres/c_api.cc b/internal/ceres/c_api.cc
index 56e1324..13a1226 100644
--- a/internal/ceres/c_api.cc
+++ b/internal/ceres/c_api.cc
@@ -39,20 +39,21 @@
 #include <string>
 #include <vector>
 
+// #include "absl/log/initialize.h"
 #include "ceres/cost_function.h"
 #include "ceres/loss_function.h"
 #include "ceres/problem.h"
 #include "ceres/solver.h"
 #include "ceres/types.h"  // for std
-#include "glog/logging.h"
 
 using ceres::Problem;
 
 void ceres_init() {
-  // This is not ideal, but it's not clear what to do if there is no gflags and
-  // no access to command line arguments.
-  char message[] = "<unknown>";
-  google::InitGoogleLogging(message);
+  // TODO(sameeragarwal): This is currently broken, because if I include this,
+  // then I need to link absl::log_initialize into c_api_test, since
+  // Ceres::ceres does not link into it.
+  //
+  // absl::InitializeLog();
 }
 
 ceres_problem_t* ceres_create_problem() {
diff --git a/internal/ceres/c_api_test.cc b/internal/ceres/c_api_test.cc
index 9386765..7aab9f6 100644
--- a/internal/ceres/c_api_test.cc
+++ b/internal/ceres/c_api_test.cc
@@ -32,7 +32,6 @@
 
 #include <cmath>
 
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 // Duplicated from curve_fitting.cc.
diff --git a/internal/ceres/callbacks.cc b/internal/ceres/callbacks.cc
index e6e0644..9412431 100644
--- a/internal/ceres/callbacks.cc
+++ b/internal/ceres/callbacks.cc
@@ -34,9 +34,9 @@
 #include <iostream>  // NO LINT
 #include <string>
 
+#include "absl/log/log.h"
 #include "ceres/program.h"
 #include "ceres/stringprintf.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/canonical_views_clustering.cc b/internal/ceres/canonical_views_clustering.cc
index d74e570..15459e1 100644
--- a/internal/ceres/canonical_views_clustering.cc
+++ b/internal/ceres/canonical_views_clustering.cc
@@ -35,10 +35,11 @@
 #include <unordered_set>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/graph.h"
 #include "ceres/internal/export.h"
 #include "ceres/map_util.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/cgnr_solver.cc b/internal/ceres/cgnr_solver.cc
index da63484..06c19d6 100644
--- a/internal/ceres/cgnr_solver.cc
+++ b/internal/ceres/cgnr_solver.cc
@@ -33,6 +33,8 @@
 #include <memory>
 #include <utility>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_jacobi_preconditioner.h"
 #include "ceres/conjugate_gradients_solver.h"
 #include "ceres/cuda_sparse_matrix.h"
@@ -41,7 +43,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/subset_preconditioner.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils.cc b/internal/ceres/compressed_col_sparse_matrix_utils.cc
index 5a25e31..c4b7067 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils.cc
@@ -33,8 +33,8 @@
 #include <algorithm>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
index b1c8219..5e0601f 100644
--- a/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
+++ b/internal/ceres/compressed_col_sparse_matrix_utils_test.cc
@@ -37,7 +37,6 @@
 #include "Eigen/SparseCore"
 #include "ceres/internal/export.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/compressed_row_sparse_matrix.cc b/internal/ceres/compressed_row_sparse_matrix.cc
index 21697f8..2e4d647 100644
--- a/internal/ceres/compressed_row_sparse_matrix.cc
+++ b/internal/ceres/compressed_row_sparse_matrix.cc
@@ -37,12 +37,13 @@
 #include <random>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/context_impl.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/export.h"
 #include "ceres/parallel_for.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 namespace {
diff --git a/internal/ceres/compressed_row_sparse_matrix.h b/internal/ceres/compressed_row_sparse_matrix.h
index 36c8895..1a83924 100644
--- a/internal/ceres/compressed_row_sparse_matrix.h
+++ b/internal/ceres/compressed_row_sparse_matrix.h
@@ -40,7 +40,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/compressed_row_sparse_matrix_test.cc b/internal/ceres/compressed_row_sparse_matrix_test.cc
index b6bcdb7..d528d1f 100644
--- a/internal/ceres/compressed_row_sparse_matrix_test.cc
+++ b/internal/ceres/compressed_row_sparse_matrix_test.cc
@@ -44,7 +44,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -74,7 +73,7 @@
   void SetUp() final {
     auto problem = CreateLinearLeastSquaresProblemFromId(1);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
 
     tsm.reset(down_cast<TripletSparseMatrix*>(problem->A.release()));
     crsm = CompressedRowSparseMatrix::FromTripletSparseMatrix(*tsm);
diff --git a/internal/ceres/concurrent_queue.h b/internal/ceres/concurrent_queue.h
index 5f490ab..972781d 100644
--- a/internal/ceres/concurrent_queue.h
+++ b/internal/ceres/concurrent_queue.h
@@ -36,7 +36,7 @@
 #include <queue>
 #include <thread>
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/conditioned_cost_function.cc b/internal/ceres/conditioned_cost_function.cc
index 5c826a9..8f42f4b 100644
--- a/internal/ceres/conditioned_cost_function.cc
+++ b/internal/ceres/conditioned_cost_function.cc
@@ -34,10 +34,10 @@
 
 #include <cstddef>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/stl_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/conjugate_gradients_solver.h b/internal/ceres/conjugate_gradients_solver.h
index 84383ea..fb343ea 100644
--- a/internal/ceres/conjugate_gradients_solver.h
+++ b/internal/ceres/conjugate_gradients_solver.h
@@ -46,7 +46,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/corrector.cc b/internal/ceres/corrector.cc
index d9b80cd..0d3007c 100644
--- a/internal/ceres/corrector.cc
+++ b/internal/ceres/corrector.cc
@@ -33,8 +33,8 @@
 #include <cmath>
 #include <cstddef>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/covariance_impl.cc b/internal/ceres/covariance_impl.cc
index 6e8362d..c9c292f 100644
--- a/internal/ceres/covariance_impl.cc
+++ b/internal/ceres/covariance_impl.cc
@@ -42,6 +42,8 @@
 #include "Eigen/SVD"
 #include "Eigen/SparseCore"
 #include "Eigen/SparseQR"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/covariance.h"
@@ -55,7 +57,6 @@
 #include "ceres/residual_block.h"
 #include "ceres/suitesparse.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 40d9b0e..49e5d6f 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -38,6 +38,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/cost_function.h"
diff --git a/internal/ceres/cubic_interpolation_test.cc b/internal/ceres/cubic_interpolation_test.cc
index c02951e..ace9b2b 100644
--- a/internal/ceres/cubic_interpolation_test.cc
+++ b/internal/ceres/cubic_interpolation_test.cc
@@ -33,7 +33,6 @@
 #include <memory>
 
 #include "ceres/jet.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/cuda_block_sparse_crs_view.cc b/internal/ceres/cuda_block_sparse_crs_view.cc
index 7564d52..c356005 100644
--- a/internal/ceres/cuda_block_sparse_crs_view.cc
+++ b/internal/ceres/cuda_block_sparse_crs_view.cc
@@ -32,6 +32,8 @@
 
 #ifndef CERES_NO_CUDA
 
+#include "absl/log/check.h"
+#include "absl/log/logging.h"
 #include "ceres/cuda_kernels_bsm_to_crs.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/cuda_block_sparse_crs_view_test.cc b/internal/ceres/cuda_block_sparse_crs_view_test.cc
index 7d7d46c..75643d7 100644
--- a/internal/ceres/cuda_block_sparse_crs_view_test.cc
+++ b/internal/ceres/cuda_block_sparse_crs_view_test.cc
@@ -30,11 +30,10 @@
 
 #include "ceres/cuda_block_sparse_crs_view.h"
 
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-
 #include <numeric>
 
+#include "gtest/gtest.h"
+
 #ifndef CERES_NO_CUDA
 
 namespace ceres::internal {
@@ -42,7 +41,7 @@
  protected:
   void SetUp() final {
     std::string message;
-    CHECK(context_.InitCuda(&message))
+    ASSERT_TRUE(context_.InitCuda(&message))
         << "InitCuda() failed because: " << message;
 
     BlockSparseMatrix::RandomMatrixOptions options;
diff --git a/internal/ceres/cuda_block_structure_test.cc b/internal/ceres/cuda_block_structure_test.cc
index daff431..c5538d1 100644
--- a/internal/ceres/cuda_block_structure_test.cc
+++ b/internal/ceres/cuda_block_structure_test.cc
@@ -32,13 +32,11 @@
 
 #ifndef CERES_NO_CUDA
 
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-
 #include <numeric>
 
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/cuda_block_structure.h"
+#include "gtest/gtest.h"
 
 namespace ceres::internal {
 
@@ -46,7 +44,7 @@
  protected:
   void SetUp() final {
     std::string message;
-    CHECK(context_.InitCuda(&message))
+    ASSERT_TRUE(context_.InitCuda(&message))
         << "InitCuda() failed because: " << message;
 
     BlockSparseMatrix::RandomMatrixOptions options;
diff --git a/internal/ceres/cuda_buffer.h b/internal/ceres/cuda_buffer.h
index 95504ca..c5756ea 100644
--- a/internal/ceres/cuda_buffer.h
+++ b/internal/ceres/cuda_buffer.h
@@ -40,8 +40,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "cuda_runtime.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 // An encapsulated buffer to maintain GPU memory, and handle transfers between
diff --git a/internal/ceres/cuda_dense_cholesky_test.cc b/internal/ceres/cuda_dense_cholesky_test.cc
index b74a75a..d767a89 100644
--- a/internal/ceres/cuda_dense_cholesky_test.cc
+++ b/internal/ceres/cuda_dense_cholesky_test.cc
@@ -33,7 +33,6 @@
 #include "ceres/dense_cholesky.h"
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/cuda_dense_qr_test.cc b/internal/ceres/cuda_dense_qr_test.cc
index b1f25e2..e833db0 100644
--- a/internal/ceres/cuda_dense_qr_test.cc
+++ b/internal/ceres/cuda_dense_qr_test.cc
@@ -32,7 +32,6 @@
 
 #include "ceres/dense_qr.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/cuda_kernels_vector_ops_test.cc b/internal/ceres/cuda_kernels_vector_ops_test.cc
index e6116f7..f32d1d2 100644
--- a/internal/ceres/cuda_kernels_vector_ops_test.cc
+++ b/internal/ceres/cuda_kernels_vector_ops_test.cc
@@ -40,7 +40,6 @@
 #include "ceres/cuda_buffer.h"
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/cuda_partitioned_block_sparse_crs_view_test.cc b/internal/ceres/cuda_partitioned_block_sparse_crs_view_test.cc
index ddfdeef..e23b429 100644
--- a/internal/ceres/cuda_partitioned_block_sparse_crs_view_test.cc
+++ b/internal/ceres/cuda_partitioned_block_sparse_crs_view_test.cc
@@ -30,8 +30,7 @@
 
 #include "ceres/cuda_partitioned_block_sparse_crs_view.h"
 
-#include <glog/logging.h>
-#include <gtest/gtest.h>
+#include "gtest/gtest.h"
 
 #ifndef CERES_NO_CUDA
 
@@ -122,13 +121,13 @@
   // Fill positions in E sub-matrix
   int num_nonzeros = 0;
   for (int i = 0; i < options.num_row_blocks_e; ++i) {
-    CHECK_GE(block_structure->rows[i].cells.size(), 1);
+    ASSERT_GE(block_structure->rows[i].cells.size(), 1);
     block_structure->rows[i].cells[0].position = num_nonzeros;
     const int col_block_size =
         block_structure->cols[block_structure->rows[i].cells[0].block_id].size;
     const int row_block_size = block_structure->rows[i].block.size;
     num_nonzeros += row_block_size * col_block_size;
-    CHECK_GE(num_nonzeros, 0);
+    ASSERT_GE(num_nonzeros, 0);
   }
   // Fill positions in F sub-matrix
   for (int i = 0; i < options.num_row_blocks_f; ++i) {
@@ -138,7 +137,7 @@
       cell.position = num_nonzeros;
       const int col_block_size = block_structure->cols[cell.block_id].size;
       num_nonzeros += row_block_size * col_block_size;
-      CHECK_GE(num_nonzeros, 0);
+      ASSERT_GE(num_nonzeros, 0);
     }
   }
   // Populate values
@@ -156,7 +155,7 @@
  protected:
   void SetUp() final {
     std::string message;
-    CHECK(context_.InitCuda(&message))
+    ASSERT_TRUE(context_.InitCuda(&message))
         << "InitCuda() failed because: " << message;
 
     RandomPartitionedMatrixOptions options;
diff --git a/internal/ceres/cuda_sparse_matrix_test.cc b/internal/ceres/cuda_sparse_matrix_test.cc
index 774829b..c8ee429 100644
--- a/internal/ceres/cuda_sparse_matrix_test.cc
+++ b/internal/ceres/cuda_sparse_matrix_test.cc
@@ -39,7 +39,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -51,15 +50,15 @@
  protected:
   void SetUp() final {
     std::string message;
-    CHECK(context_.InitCuda(&message))
+    ASSERT_TRUE(context_.InitCuda(&message))
         << "InitCuda() failed because: " << message;
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(2);
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
-    CHECK(A_ != nullptr);
-    CHECK(problem->b != nullptr);
-    CHECK(problem->x != nullptr);
+    ASSERT_TRUE(A_ != nullptr);
+    ASSERT_TRUE(problem->b != nullptr);
+    ASSERT_TRUE(problem->x != nullptr);
     b_.resize(A_->num_rows());
     for (int i = 0; i < A_->num_rows(); ++i) {
       b_[i] = problem->b[i];
@@ -68,8 +67,8 @@
     for (int i = 0; i < A_->num_cols(); ++i) {
       x_[i] = problem->x[i];
     }
-    CHECK_EQ(A_->num_rows(), b_.rows());
-    CHECK_EQ(A_->num_cols(), x_.rows());
+    ASSERT_EQ(A_->num_rows(), b_.rows());
+    ASSERT_EQ(A_->num_cols(), x_.rows());
   }
 
   std::unique_ptr<BlockSparseMatrix> A_;
@@ -119,7 +118,8 @@
 
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   auto A1_crs = CompressedRowSparseMatrix::FromTripletSparseMatrix(A1);
   CudaSparseMatrix A_gpu(&context, *A1_crs);
   CudaVector b_gpu(&context, A1.num_cols());
@@ -157,7 +157,8 @@
 
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   auto A_crs = CompressedRowSparseMatrix::FromTripletSparseMatrix(A);
   CudaSparseMatrix A_gpu(&context, *A_crs);
   CudaVector b_gpu(&context, A.num_cols());
@@ -187,7 +188,8 @@
 
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   auto A_crs = CompressedRowSparseMatrix::FromTripletSparseMatrix(A);
   CudaSparseMatrix A_gpu(&context, *A_crs);
   CudaVector b_gpu(&context, A.num_rows());
@@ -242,7 +244,8 @@
 
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   auto A_crs = CompressedRowSparseMatrix::FromTripletSparseMatrix(A);
   CudaSparseMatrix A_gpu(&context, *A_crs);
   CudaVector b_gpu(&context, N);
diff --git a/internal/ceres/cuda_streamed_buffer_test.cc b/internal/ceres/cuda_streamed_buffer_test.cc
index 4837005..02ce3eb 100644
--- a/internal/ceres/cuda_streamed_buffer_test.cc
+++ b/internal/ceres/cuda_streamed_buffer_test.cc
@@ -32,12 +32,10 @@
 
 #ifndef CERES_NO_CUDA
 
-#include <glog/logging.h>
-#include <gtest/gtest.h>
-
 #include <numeric>
 
 #include "ceres/cuda_streamed_buffer.h"
+#include "gtest/gtest.h"
 
 namespace ceres::internal {
 
@@ -48,7 +46,8 @@
   const int kInputSize = kMaxTemporaryArraySize * 7 + 3;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
 
   std::vector<int> inputs(kInputSize);
   std::vector<int> outputs(kInputSize, -1);
@@ -62,22 +61,22 @@
                                                  int offset,
                                                  cudaStream_t stream) {
                               batches.emplace_back(offset, size);
-                              CHECK_EQ(cudaSuccess,
-                                       cudaMemcpyAsync(outputs.data() + offset,
-                                                       device_pointer,
-                                                       sizeof(int) * size,
-                                                       cudaMemcpyDeviceToHost,
-                                                       stream));
+                              ASSERT_EQ(cudaSuccess,
+                                        cudaMemcpyAsync(outputs.data() + offset,
+                                                        device_pointer,
+                                                        sizeof(int) * size,
+                                                        cudaMemcpyDeviceToHost,
+                                                        stream));
                             });
   // All operations in all streams should be completed when CopyToGpu returns
   // control to the callee
   for (int i = 0; i < ContextImpl::kNumCudaStreams; ++i) {
-    CHECK_EQ(cudaSuccess, cudaStreamQuery(context.streams_[i]));
+    ASSERT_EQ(cudaSuccess, cudaStreamQuery(context.streams_[i]));
   }
 
   // Check if every element was visited
   for (int i = 0; i < kInputSize; ++i) {
-    CHECK_EQ(outputs[i], i);
+    ASSERT_EQ(outputs[i], i);
   }
 
   // Check if there is no overlap between batches
@@ -86,14 +85,14 @@
   for (int i = 0; i < num_batches; ++i) {
     const auto [begin, size] = batches[i];
     const int end = begin + size;
-    CHECK_GE(begin, 0);
-    CHECK_LT(begin, kInputSize);
+    ASSERT_GE(begin, 0);
+    ASSERT_LT(begin, kInputSize);
 
-    CHECK_GT(size, 0);
-    CHECK_LE(end, kInputSize);
+    ASSERT_GT(size, 0);
+    ASSERT_LE(end, kInputSize);
 
     if (i + 1 == num_batches) continue;
-    CHECK_EQ(end, batches[i + 1].first);
+    ASSERT_EQ(end, batches[i + 1].first);
   }
 }
 
@@ -104,14 +103,15 @@
   const int kInputSize = kMaxTemporaryArraySize * 7 + 3;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
 
   int* inputs;
   int* outputs;
-  CHECK_EQ(cudaSuccess,
-           cudaHostAlloc(
-               &inputs, sizeof(int) * kInputSize, cudaHostAllocWriteCombined));
-  CHECK_EQ(
+  ASSERT_EQ(cudaSuccess,
+            cudaHostAlloc(
+                &inputs, sizeof(int) * kInputSize, cudaHostAllocWriteCombined));
+  ASSERT_EQ(
       cudaSuccess,
       cudaHostAlloc(&outputs, sizeof(int) * kInputSize, cudaHostAllocDefault));
 
@@ -126,22 +126,22 @@
                                                 int offset,
                                                 cudaStream_t stream) {
                               batches.emplace_back(offset, size);
-                              CHECK_EQ(cudaSuccess,
-                                       cudaMemcpyAsync(outputs + offset,
-                                                       device_pointer,
-                                                       sizeof(int) * size,
-                                                       cudaMemcpyDeviceToHost,
-                                                       stream));
+                              ASSERT_EQ(cudaSuccess,
+                                        cudaMemcpyAsync(outputs + offset,
+                                                        device_pointer,
+                                                        sizeof(int) * size,
+                                                        cudaMemcpyDeviceToHost,
+                                                        stream));
                             });
   // All operations in all streams should be completed when CopyToGpu returns
   // control to the callee
   for (int i = 0; i < ContextImpl::kNumCudaStreams; ++i) {
-    CHECK_EQ(cudaSuccess, cudaStreamQuery(context.streams_[i]));
+    ASSERT_EQ(cudaSuccess, cudaStreamQuery(context.streams_[i]));
   }
 
   // Check if every element was visited
   for (int i = 0; i < kInputSize; ++i) {
-    CHECK_EQ(outputs[i], i);
+    ASSERT_EQ(outputs[i], i);
   }
 
   // Check if there is no overlap between batches
@@ -150,18 +150,18 @@
   for (int i = 0; i < num_batches; ++i) {
     const auto [begin, size] = batches[i];
     const int end = begin + size;
-    CHECK_GE(begin, 0);
-    CHECK_LT(begin, kInputSize);
+    ASSERT_GE(begin, 0);
+    ASSERT_LT(begin, kInputSize);
 
-    CHECK_GT(size, 0);
-    CHECK_LE(end, kInputSize);
+    ASSERT_GT(size, 0);
+    ASSERT_LE(end, kInputSize);
 
     if (i + 1 == num_batches) continue;
-    CHECK_EQ(end, batches[i + 1].first);
+    ASSERT_EQ(end, batches[i + 1].first);
   }
 
-  CHECK_EQ(cudaSuccess, cudaFreeHost(inputs));
-  CHECK_EQ(cudaSuccess, cudaFreeHost(outputs));
+  ASSERT_EQ(cudaSuccess, cudaFreeHost(inputs));
+  ASSERT_EQ(cudaSuccess, cudaFreeHost(outputs));
 }
 
 }  // namespace ceres::internal
diff --git a/internal/ceres/cuda_vector_test.cc b/internal/ceres/cuda_vector_test.cc
index 8dcb4b7..0ea4703 100644
--- a/internal/ceres/cuda_vector_test.cc
+++ b/internal/ceres/cuda_vector_test.cc
@@ -34,7 +34,6 @@
 
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -45,7 +44,8 @@
 TEST(CudaVector, Creation) {
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x(&context, 1000);
   EXPECT_EQ(x.num_rows(), 1000);
   EXPECT_NE(x.data(), nullptr);
@@ -56,7 +56,8 @@
   x << 1, 2, 3;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector y(&context, 10);
   y.CopyFromCpu(x);
   EXPECT_EQ(y.num_rows(), 3);
@@ -70,7 +71,8 @@
 TEST(CudaVector, Move) {
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector y(&context, 10);
   const auto y_data = y.data();
   const auto y_descr = y.descr();
@@ -89,7 +91,8 @@
   x << 1, 2, 3;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 3);
   x_gpu.CopyFromCpu(x);
 
@@ -111,7 +114,8 @@
   y << 100, 10, 1;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   CudaVector y_gpu(&context, 10);
   x_gpu.CopyFromCpu(x);
@@ -126,7 +130,8 @@
   x << 1, 2, 3;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   x_gpu.CopyFromCpu(x);
 
@@ -144,7 +149,8 @@
   x << 1, 1, 1, 1;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   x_gpu.CopyFromCpu(x);
 
@@ -162,7 +168,8 @@
 TEST(CudaVector, Resize) {
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   EXPECT_EQ(x_gpu.num_rows(), 10);
   x_gpu.Resize(4);
@@ -176,7 +183,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -197,7 +205,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -218,7 +227,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -239,7 +249,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -258,7 +269,8 @@
   x << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -279,7 +291,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   CudaVector z_gpu(&context, 4);
@@ -301,7 +314,8 @@
   x << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector z_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -322,7 +336,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   CudaVector y_gpu(&context, 10);
   x_gpu.CopyFromCpu(x);
@@ -343,7 +358,8 @@
   y << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
@@ -362,7 +378,8 @@
   x << 100, 10, 1, 0;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 10);
   x_gpu.CopyFromCpu(x);
 
@@ -383,7 +400,8 @@
   D << 4, 3, 2, 1;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   CudaVector y_gpu(&context, 4);
   CudaVector D_gpu(&context, 4);
@@ -404,7 +422,8 @@
   x << 1, 2, 3, 4;
   ContextImpl context;
   std::string message;
-  CHECK(context.InitCuda(&message)) << "InitCuda() failed because: " << message;
+  ASSERT_TRUE(context.InitCuda(&message))
+      << "InitCuda() failed because: " << message;
   CudaVector x_gpu(&context, 4);
   x_gpu.CopyFromCpu(x);
 
diff --git a/internal/ceres/dense_cholesky.cc b/internal/ceres/dense_cholesky.cc
index 5a3e7e2..7ecff03 100644
--- a/internal/ceres/dense_cholesky.cc
+++ b/internal/ceres/dense_cholesky.cc
@@ -36,8 +36,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/internal/config.h"
 #include "ceres/iterative_refiner.h"
+#include "ceres/stringprintf.h"
 
 #ifndef CERES_NO_CUDA
 #include "ceres/context_impl.h"
diff --git a/internal/ceres/dense_cholesky.h b/internal/ceres/dense_cholesky.h
index 04a5dd5..4f55c58 100644
--- a/internal/ceres/dense_cholesky.h
+++ b/internal/ceres/dense_cholesky.h
@@ -43,7 +43,7 @@
 #include "ceres/context_impl.h"
 #include "ceres/cuda_buffer.h"
 #include "ceres/linear_solver.h"
-#include "glog/logging.h"
+
 #ifndef CERES_NO_CUDA
 #include "ceres/context_impl.h"
 #include "cuda_runtime.h"
diff --git a/internal/ceres/dense_cholesky_test.cc b/internal/ceres/dense_cholesky_test.cc
index 1b2e42d..b5972ef 100644
--- a/internal/ceres/dense_cholesky_test.cc
+++ b/internal/ceres/dense_cholesky_test.cc
@@ -42,7 +42,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/iterative_refiner.h"
 #include "ceres/linear_solver.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -78,7 +77,7 @@
 #ifndef CERES_NO_CUDA
   options.context = &context;
   std::string error;
-  CHECK(context.InitCuda(&error)) << error;
+  ASSERT_TRUE(context.InitCuda(&error)) << error;
 #endif  // CERES_NO_CUDA
   options.dense_linear_algebra_library_type = ::testing::get<0>(GetParam());
   options.use_mixed_precision_solves = ::testing::get<1>(GetParam());
diff --git a/internal/ceres/dense_linear_solver_test.cc b/internal/ceres/dense_linear_solver_test.cc
index 79d2543..9cece56 100644
--- a/internal/ceres/dense_linear_solver_test.cc
+++ b/internal/ceres/dense_linear_solver_test.cc
@@ -37,7 +37,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/dense_qr.cc b/internal/ceres/dense_qr.cc
index fbbcadc..c4c7b6f 100644
--- a/internal/ceres/dense_qr.cc
+++ b/internal/ceres/dense_qr.cc
@@ -34,6 +34,8 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/log.h"
+
 #ifndef CERES_NO_CUDA
 #include "ceres/context_impl.h"
 #include "cublas_v2.h"
diff --git a/internal/ceres/dense_qr.h b/internal/ceres/dense_qr.h
index 0ba17c4..af35827 100644
--- a/internal/ceres/dense_qr.h
+++ b/internal/ceres/dense_qr.h
@@ -45,7 +45,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/linear_solver.h"
-#include "glog/logging.h"
 
 #ifndef CERES_NO_CUDA
 #include "ceres/context_impl.h"
diff --git a/internal/ceres/dense_qr_test.cc b/internal/ceres/dense_qr_test.cc
index 155570c..f287d35 100644
--- a/internal/ceres/dense_qr_test.cc
+++ b/internal/ceres/dense_qr_test.cc
@@ -39,7 +39,6 @@
 #include "Eigen/Dense"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -70,7 +69,7 @@
 #ifndef CERES_NO_CUDA
   options.context = &context;
   std::string error;
-  CHECK(context.InitCuda(&error)) << error;
+  ASSERT_TRUE(context.InitCuda(&error)) << error;
 #endif  // CERES_NO_CUDA
   options.dense_linear_algebra_library_type = GetParam();
   const double kEpsilon = std::numeric_limits<double>::epsilon() * 1.5e4;
diff --git a/internal/ceres/dense_sparse_matrix.cc b/internal/ceres/dense_sparse_matrix.cc
index e0c917c..c33aa45 100644
--- a/internal/ceres/dense_sparse_matrix.cc
+++ b/internal/ceres/dense_sparse_matrix.cc
@@ -33,10 +33,10 @@
 #include <algorithm>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/dense_sparse_matrix_test.cc b/internal/ceres/dense_sparse_matrix_test.cc
index 0e50b62..cead9dd 100644
--- a/internal/ceres/dense_sparse_matrix_test.cc
+++ b/internal/ceres/dense_sparse_matrix_test.cc
@@ -40,7 +40,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -72,7 +71,7 @@
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(1);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
 
     tsm.reset(down_cast<TripletSparseMatrix*>(problem->A.release()));
     dsm = std::make_unique<DenseSparseMatrix>(*tsm);
diff --git a/internal/ceres/detect_structure.cc b/internal/ceres/detect_structure.cc
index e82d70f..d2b4a4c 100644
--- a/internal/ceres/detect_structure.cc
+++ b/internal/ceres/detect_structure.cc
@@ -30,8 +30,9 @@
 
 #include "ceres/detect_structure.h"
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/detect_structure_test.cc b/internal/ceres/detect_structure_test.cc
index e4e3f1d..155c025 100644
--- a/internal/ceres/detect_structure_test.cc
+++ b/internal/ceres/detect_structure_test.cc
@@ -32,7 +32,6 @@
 
 #include "Eigen/Core"
 #include "ceres/block_structure.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/dogleg_strategy.cc b/internal/ceres/dogleg_strategy.cc
index 877d8d9..ef45a0b 100644
--- a/internal/ceres/dogleg_strategy.cc
+++ b/internal/ceres/dogleg_strategy.cc
@@ -34,6 +34,8 @@
 #include <cmath>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/array_utils.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
@@ -42,7 +44,6 @@
 #include "ceres/sparse_matrix.h"
 #include "ceres/trust_region_strategy.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 namespace {
diff --git a/internal/ceres/dogleg_strategy_test.cc b/internal/ceres/dogleg_strategy_test.cc
index b256f3e..26db26c 100644
--- a/internal/ceres/dogleg_strategy_test.cc
+++ b/internal/ceres/dogleg_strategy_test.cc
@@ -37,7 +37,6 @@
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
 #include "ceres/trust_region_strategy.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
index 4081c9c..0eea9e5 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix.cc
@@ -32,6 +32,8 @@
 
 #include <cstring>
 
+#include "absl/log/check.h"
+
 namespace ceres::internal {
 
 DynamicCompressedRowSparseMatrix::DynamicCompressedRowSparseMatrix(
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
index 6dd0adf..0d147c4 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.cc
@@ -38,6 +38,7 @@
 #include <utility>
 
 #include "Eigen/SparseCore"
+#include "absl/log/log.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
index e5e8a28..6b8fa52 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver.h
@@ -71,7 +71,7 @@
                                             double* rhs_and_solution);
 
   LinearSolver::Summary SolveImplUsingCuda(CompressedRowSparseMatrix* A,
-                                            double* rhs_and_solution);
+                                           double* rhs_and_solution);
 
   const LinearSolver::Options options_;
 };
diff --git a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
index 4afd372..100d574 100644
--- a/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/dynamic_sparse_normal_cholesky_solver_test.cc
@@ -39,7 +39,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/dynamic_sparsity_test.cc b/internal/ceres/dynamic_sparsity_test.cc
index ae56037..5928389 100644
--- a/internal/ceres/dynamic_sparsity_test.cc
+++ b/internal/ceres/dynamic_sparsity_test.cc
@@ -35,8 +35,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/eigensparse.cc b/internal/ceres/eigensparse.cc
index 7ed401d..67b6ec5 100644
--- a/internal/ceres/eigensparse.cc
+++ b/internal/ceres/eigensparse.cc
@@ -44,6 +44,7 @@
 
 #include "Eigen/SparseCholesky"
 #include "Eigen/SparseCore"
+#include "absl/log/log.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/linear_solver.h"
 
diff --git a/internal/ceres/evaluator.cc b/internal/ceres/evaluator.cc
index 9226dc5..516d701 100644
--- a/internal/ceres/evaluator.cc
+++ b/internal/ceres/evaluator.cc
@@ -33,6 +33,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/block_evaluate_preparer.h"
 #include "ceres/block_jacobian_writer.h"
 #include "ceres/compressed_row_jacobian_writer.h"
@@ -44,7 +45,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/program_evaluator.h"
 #include "ceres/scratch_evaluate_preparer.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
@@ -65,8 +65,8 @@
     case SPARSE_SCHUR:
     case ITERATIVE_SCHUR: {
       return std::make_unique<
-            ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>>(
-            options, program);
+          ProgramEvaluator<BlockEvaluatePreparer, BlockJacobianWriter>>(
+          options, program);
     }
     case CGNR: {
       if (options.sparse_linear_algebra_library_type == CUDA_SPARSE) {
diff --git a/internal/ceres/evaluator_test.cc b/internal/ceres/evaluator_test.cc
index 43e8872..8987d0b 100644
--- a/internal/ceres/evaluator_test.cc
+++ b/internal/ceres/evaluator_test.cc
@@ -37,6 +37,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
 #include "ceres/crs_matrix.h"
diff --git a/internal/ceres/file.cc b/internal/ceres/file.cc
index 60d35fa..81b3160 100644
--- a/internal/ceres/file.cc
+++ b/internal/ceres/file.cc
@@ -35,7 +35,7 @@
 #include <cstdio>
 #include <string>
 
-#include "glog/logging.h"
+#include "absl/log/log.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/float_suitesparse.cc b/internal/ceres/float_suitesparse.cc
index 6016bad..cea5c4a 100644
--- a/internal/ceres/float_suitesparse.cc
+++ b/internal/ceres/float_suitesparse.cc
@@ -32,6 +32,8 @@
 
 #include <memory>
 
+#include "absl/log/log.h"
+
 #if !defined(CERES_NO_SUITESPARSE)
 
 namespace ceres::internal {
diff --git a/internal/ceres/gradient_checker.cc b/internal/ceres/gradient_checker.cc
index f49803c..131e4c2 100644
--- a/internal/ceres/gradient_checker.cc
+++ b/internal/ceres/gradient_checker.cc
@@ -39,6 +39,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/is_close.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index 2a20470..509ea18 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -37,11 +37,11 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/cost_function.h"
 #include "ceres/problem.h"
 #include "ceres/solver.h"
 #include "ceres/test_util.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -176,7 +176,7 @@
                             const std::vector<int>& parameter_sizes,
                             const std::vector<int>& local_parameter_sizes,
                             int residual_size) {
-  CHECK_EQ(parameter_sizes.size(), local_parameter_sizes.size());
+  ASSERT_EQ(parameter_sizes.size(), local_parameter_sizes.size());
   int num_parameters = parameter_sizes.size();
   ASSERT_EQ(residual_size, results.residuals.size());
   ASSERT_EQ(num_parameters, results.local_jacobians.size());
@@ -329,7 +329,7 @@
   }
 
   void AddParameter(const Matrix& residual_J_param) {
-    CHECK_EQ(num_residuals(), residual_J_param.rows());
+    ASSERT_EQ(num_residuals(), residual_J_param.rows());
     residual_J_params_.push_back(residual_J_param);
     mutable_parameter_block_sizes()->push_back(residual_J_param.cols());
   }
@@ -337,9 +337,9 @@
   /// Add offset to the given Jacobian before returning it from Evaluate(),
   /// thus introducing an error in the computation.
   void SetJacobianOffset(size_t index, Matrix offset) {
-    CHECK_LT(index, residual_J_params_.size());
-    CHECK_EQ(residual_J_params_[index].rows(), offset.rows());
-    CHECK_EQ(residual_J_params_[index].cols(), offset.cols());
+    ASSERT_LT(index, residual_J_params_.size());
+    ASSERT_EQ(residual_J_params_[index].rows(), offset.rows());
+    ASSERT_EQ(residual_J_params_[index].cols(), offset.cols());
     jacobian_offsets_[index] = offset;
   }
 
diff --git a/internal/ceres/gradient_checking_cost_function.cc b/internal/ceres/gradient_checking_cost_function.cc
index 8ca449b..50a6447 100644
--- a/internal/ceres/gradient_checking_cost_function.cc
+++ b/internal/ceres/gradient_checking_cost_function.cc
@@ -40,6 +40,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/dynamic_numeric_diff_cost_function.h"
 #include "ceres/gradient_checker.h"
 #include "ceres/internal/eigen.h"
@@ -50,7 +52,6 @@
 #include "ceres/residual_block.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/gradient_checking_cost_function_test.cc b/internal/ceres/gradient_checking_cost_function_test.cc
index 545fcd2..7dd334e 100644
--- a/internal/ceres/gradient_checking_cost_function_test.cc
+++ b/internal/ceres/gradient_checking_cost_function_test.cc
@@ -36,6 +36,8 @@
 #include <random>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/cost_function.h"
 #include "ceres/loss_function.h"
 #include "ceres/manifold.h"
@@ -45,7 +47,6 @@
 #include "ceres/residual_block.h"
 #include "ceres/sized_cost_function.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -328,8 +329,8 @@
 // array and have the same Manifold objects.
 static void ParameterBlocksAreEquivalent(const ParameterBlock* left,
                                          const ParameterBlock* right) {
-  CHECK(left != nullptr);
-  CHECK(right != nullptr);
+  ASSERT_TRUE(left != nullptr);
+  ASSERT_TRUE(right != nullptr);
   EXPECT_EQ(left->user_state(), right->user_state());
   EXPECT_EQ(left->Size(), right->Size());
   EXPECT_EQ(left->Size(), right->Size());
diff --git a/internal/ceres/gradient_problem.cc b/internal/ceres/gradient_problem.cc
index ee228b8..486c99a 100644
--- a/internal/ceres/gradient_problem.cc
+++ b/internal/ceres/gradient_problem.cc
@@ -32,7 +32,7 @@
 
 #include <memory>
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/gradient_problem_solver.cc b/internal/ceres/gradient_problem_solver.cc
index ad2ea13..d78a719 100644
--- a/internal/ceres/gradient_problem_solver.cc
+++ b/internal/ceres/gradient_problem_solver.cc
@@ -34,6 +34,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/log.h"
 #include "ceres/callbacks.h"
 #include "ceres/gradient_problem.h"
 #include "ceres/gradient_problem_evaluator.h"
diff --git a/internal/ceres/graph.h b/internal/ceres/graph.h
index 4f8dfb9..9b28b06 100644
--- a/internal/ceres/graph.h
+++ b/internal/ceres/graph.h
@@ -36,11 +36,11 @@
 #include <unordered_set>
 #include <utility>
 
+#include "absl/log/check.h"
 #include "ceres/internal/export.h"
 #include "ceres/map_util.h"
 #include "ceres/pair_hash.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/graph_algorithms.h b/internal/ceres/graph_algorithms.h
index 4ebc8b3..3019f0b 100644
--- a/internal/ceres/graph_algorithms.h
+++ b/internal/ceres/graph_algorithms.h
@@ -40,10 +40,10 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/graph.h"
 #include "ceres/internal/export.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/householder_vector_test.cc b/internal/ceres/householder_vector_test.cc
index 7d69789..ff87ffd 100644
--- a/internal/ceres/householder_vector_test.cc
+++ b/internal/ceres/householder_vector_test.cc
@@ -31,7 +31,6 @@
 #include "ceres/internal/householder_vector.h"
 
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/implicit_schur_complement.cc b/internal/ceres/implicit_schur_complement.cc
index a633529..053a9e5 100644
--- a/internal/ceres/implicit_schur_complement.cc
+++ b/internal/ceres/implicit_schur_complement.cc
@@ -31,6 +31,7 @@
 #include "ceres/implicit_schur_complement.h"
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
@@ -38,7 +39,6 @@
 #include "ceres/parallel_for.h"
 #include "ceres/parallel_vector_ops.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/implicit_schur_complement_test.cc b/internal/ceres/implicit_schur_complement_test.cc
index 35519fc..1944e9d 100644
--- a/internal/ceres/implicit_schur_complement_test.cc
+++ b/internal/ceres/implicit_schur_complement_test.cc
@@ -44,7 +44,6 @@
 #include "ceres/schur_eliminator.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -58,7 +57,7 @@
   void SetUp() final {
     auto problem = CreateLinearLeastSquaresProblemFromId(2);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
     b_ = std::move(problem->b);
     D_ = std::move(problem->D);
@@ -86,7 +85,7 @@
 
     std::unique_ptr<SchurEliminatorBase> eliminator =
         SchurEliminatorBase::Create(options);
-    CHECK(eliminator != nullptr);
+    ASSERT_TRUE(eliminator != nullptr);
     const bool kFullRankETE = true;
     eliminator->Init(num_eliminate_blocks_, kFullRankETE, bs);
 
diff --git a/internal/ceres/inner_product_computer_test.cc b/internal/ceres/inner_product_computer_test.cc
index 89fe518..0b716ad 100644
--- a/internal/ceres/inner_product_computer_test.cc
+++ b/internal/ceres/inner_product_computer_test.cc
@@ -35,10 +35,10 @@
 #include <random>
 
 #include "Eigen/SparseCore"
+#include "absl/log/log.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/triplet_sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
diff --git a/internal/ceres/invert_psd_matrix.h b/internal/ceres/invert_psd_matrix.h
index bc74900..21ba2dc 100644
--- a/internal/ceres/invert_psd_matrix.h
+++ b/internal/ceres/invert_psd_matrix.h
@@ -33,7 +33,6 @@
 
 #include "Eigen/Dense"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/iterative_refiner_test.cc b/internal/ceres/iterative_refiner_test.cc
index 3b7bfd2..a2557f2 100644
--- a/internal/ceres/iterative_refiner_test.cc
+++ b/internal/ceres/iterative_refiner_test.cc
@@ -33,11 +33,12 @@
 #include <utility>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/dense_cholesky.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/sparse_cholesky.h"
 #include "ceres/sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/iterative_schur_complement_solver.cc b/internal/ceres/iterative_schur_complement_solver.cc
index bcfb6e4..23318bb 100644
--- a/internal/ceres/iterative_schur_complement_solver.cc
+++ b/internal/ceres/iterative_schur_complement_solver.cc
@@ -36,6 +36,8 @@
 #include <vector>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/conjugate_gradients_solver.h"
@@ -50,7 +52,6 @@
 #include "ceres/types.h"
 #include "ceres/visibility_based_preconditioner.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/iterative_schur_complement_solver_test.cc b/internal/ceres/iterative_schur_complement_solver_test.cc
index c5d67de..5529060 100644
--- a/internal/ceres/iterative_schur_complement_solver_test.cc
+++ b/internal/ceres/iterative_schur_complement_solver_test.cc
@@ -48,7 +48,6 @@
 #include "ceres/schur_eliminator.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -64,7 +63,7 @@
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(problem_id);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
     b_ = std::move(problem->b);
     D_ = std::move(problem->D);
diff --git a/internal/ceres/jet_test.cc b/internal/ceres/jet_test.cc
index 7f67bd6..f94f995 100644
--- a/internal/ceres/jet_test.cc
+++ b/internal/ceres/jet_test.cc
@@ -35,9 +35,9 @@
 #include <cfenv>
 #include <cmath>
 
+#include "absl/log/log.h"
 #include "ceres/stringprintf.h"
 #include "ceres/test_util.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
diff --git a/internal/ceres/levenberg_marquardt_strategy.cc b/internal/ceres/levenberg_marquardt_strategy.cc
index 37bc6f4..9e25466 100644
--- a/internal/ceres/levenberg_marquardt_strategy.cc
+++ b/internal/ceres/levenberg_marquardt_strategy.cc
@@ -34,6 +34,8 @@
 #include <cmath>
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/array_utils.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
@@ -42,7 +44,6 @@
 #include "ceres/sparse_matrix.h"
 #include "ceres/trust_region_strategy.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/levenberg_marquardt_strategy_test.cc b/internal/ceres/levenberg_marquardt_strategy_test.cc
index 4be742c..78bbd8c 100644
--- a/internal/ceres/levenberg_marquardt_strategy_test.cc
+++ b/internal/ceres/levenberg_marquardt_strategy_test.cc
@@ -32,10 +32,10 @@
 
 #include <memory>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_solver.h"
 #include "ceres/trust_region_strategy.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index eb2c7c9..749345a 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -39,6 +39,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/evaluator.h"
 #include "ceres/function_sample.h"
 #include "ceres/internal/eigen.h"
@@ -46,7 +48,6 @@
 #include "ceres/polynomial.h"
 #include "ceres/stringprintf.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/line_search_direction.cc b/internal/ceres/line_search_direction.cc
index 62fcc81..b4e8a33 100644
--- a/internal/ceres/line_search_direction.cc
+++ b/internal/ceres/line_search_direction.cc
@@ -32,11 +32,12 @@
 
 #include <memory>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/line_search_minimizer.h"
 #include "ceres/low_rank_inverse_hessian.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index 58a4bf9..41ca31a 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -48,6 +48,8 @@
 #include <vector>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/array_utils.h"
 #include "ceres/evaluator.h"
 #include "ceres/internal/eigen.h"
@@ -57,7 +59,6 @@
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 namespace {
diff --git a/internal/ceres/line_search_minimizer.h b/internal/ceres/line_search_minimizer.h
index f3621d9..af601d9 100644
--- a/internal/ceres/line_search_minimizer.h
+++ b/internal/ceres/line_search_minimizer.h
@@ -36,7 +36,6 @@
 #include "ceres/minimizer.h"
 #include "ceres/solver.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/line_search_minimizer_test.cc b/internal/ceres/line_search_minimizer_test.cc
index 3b15ae8..d5c2c69 100644
--- a/internal/ceres/line_search_minimizer_test.cc
+++ b/internal/ceres/line_search_minimizer_test.cc
@@ -32,7 +32,6 @@
 #include <cstdlib>
 
 #include "ceres/ceres.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/linear_least_squares_problems.cc b/internal/ceres/linear_least_squares_problems.cc
index 36cffec..3a525fd 100644
--- a/internal/ceres/linear_least_squares_problems.cc
+++ b/internal/ceres/linear_least_squares_problems.cc
@@ -35,6 +35,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
@@ -42,7 +44,6 @@
 #include "ceres/stringprintf.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/linear_operator.cc b/internal/ceres/linear_operator.cc
index f4c2c5e..669dbad 100644
--- a/internal/ceres/linear_operator.cc
+++ b/internal/ceres/linear_operator.cc
@@ -30,7 +30,7 @@
 
 #include "ceres/linear_operator.h"
 
-#include <glog/logging.h>
+#include "absl/log/log.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/linear_solver.cc b/internal/ceres/linear_solver.cc
index 4ba0b75..2200450 100644
--- a/internal/ceres/linear_solver.cc
+++ b/internal/ceres/linear_solver.cc
@@ -32,6 +32,8 @@
 
 #include <memory>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/cgnr_solver.h"
 #include "ceres/dense_normal_cholesky_solver.h"
 #include "ceres/dense_qr_solver.h"
@@ -41,7 +43,6 @@
 #include "ceres/schur_complement_solver.h"
 #include "ceres/sparse_normal_cholesky_solver.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index 1d5338f..d6e0804 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -40,6 +40,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/casts.h"
 #include "ceres/compressed_row_sparse_matrix.h"
@@ -50,7 +51,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/loss_function.cc b/internal/ceres/loss_function.cc
index 82563c8..4af4f1a 100644
--- a/internal/ceres/loss_function.cc
+++ b/internal/ceres/loss_function.cc
@@ -37,6 +37,8 @@
 #include <cstddef>
 #include <limits>
 
+#include "absl/log/check.h"
+
 namespace ceres {
 
 LossFunction::~LossFunction() = default;
diff --git a/internal/ceres/loss_function_test.cc b/internal/ceres/loss_function_test.cc
index 1fd492b..743099f 100644
--- a/internal/ceres/loss_function_test.cc
+++ b/internal/ceres/loss_function_test.cc
@@ -32,7 +32,6 @@
 
 #include <cstddef>
 
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -45,7 +44,7 @@
 // callback with estimates obtained by symmetric finite differencing
 // of rho(s).
 void AssertLossFunctionIsValid(const LossFunction& loss, double s) {
-  CHECK_GT(s, 0);
+  ASSERT_GT(s, 0);
 
   // Evaluate rho(s), rho'(s) and rho''(s).
   double rho[3];
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index 14559b6..490f3d4 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -32,8 +32,8 @@
 
 #include <list>
 
+#include "absl/log/log.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/manifold.cc b/internal/ceres/manifold.cc
index c4895fd..bfb2a22 100644
--- a/internal/ceres/manifold.cc
+++ b/internal/ceres/manifold.cc
@@ -3,9 +3,9 @@
 #include <algorithm>
 #include <cmath>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/fixed_array.h"
-#include "glog/logging.h"
 
 namespace ceres {
 namespace {
diff --git a/internal/ceres/map_util.h b/internal/ceres/map_util.h
index aee2bf5..c9adfd8 100644
--- a/internal/ceres/map_util.h
+++ b/internal/ceres/map_util.h
@@ -35,8 +35,8 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/miniglog/glog/logging.cc b/internal/ceres/miniglog/glog/logging.cc
deleted file mode 100644
index 0863f61..0000000
--- a/internal/ceres/miniglog/glog/logging.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 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: keir@google.com (Keir Mierle)
-
-#include "glog/logging.h"
-
-namespace google {
-
-// This is the set of log sinks. This must be in a separate library to ensure
-// that there is only one instance of this across the entire program.
-std::set<google::LogSink*> log_sinks_global;
-
-}  // namespace google
diff --git a/internal/ceres/miniglog/glog/logging.h b/internal/ceres/miniglog/glog/logging.h
deleted file mode 100644
index 5604bd4..0000000
--- a/internal/ceres/miniglog/glog/logging.h
+++ /dev/null
@@ -1,438 +0,0 @@
-// Ceres Solver - A fast non-linear least squares minimizer
-// Copyright 2015 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: settinger@google.com (Scott Ettinger)
-//         mierle@gmail.com (Keir Mierle)
-//
-// Simplified Glog style logging with Android support. Supported macros in
-// decreasing severity level per line:
-//
-//   VLOG(2), VLOG(N)
-//   VLOG(1),
-//   LOG(INFO), VLOG(0), LG
-//   LOG(WARNING),
-//   LOG(ERROR),
-//   LOG(FATAL),
-//
-// With VLOG(n), the output is directed to one of the 5 Android log levels:
-//
-//   2 - Verbose
-//   1 - Debug
-//   0 - Info
-//  -1 - Warning
-//  -2 - Error
-//  -3 - Fatal
-//
-// Any logging of level 2 and above is directed to the Verbose level. All
-// Android log output is tagged with the string "native".
-//
-// If the symbol ANDROID is not defined, all output goes to std::cerr.
-// This allows code to be built on a different system for debug.
-//
-// Portions of this code are taken from the GLOG package.  This code is only a
-// small subset of the GLOG functionality. Notable differences from GLOG
-// behavior include lack of support for displaying unprintable characters and
-// lack of stack trace information upon failure of the CHECK macros.  On
-// non-Android systems, log output goes to std::cerr and is not written to a
-// file.
-//
-// CHECK macros are defined to test for conditions within code.  Any CHECK that
-// fails will log the failure and terminate the application.
-// e.g. CHECK_GE(3, 2) will pass while CHECK_GE(3, 4) will fail after logging
-//      "Check failed 3 >= 4".
-//
-// The following CHECK macros are defined:
-//
-//   CHECK(condition)        - fails if condition is false and logs condition.
-//   CHECK_NOTNULL(variable) - fails if the variable is nullptr.
-//
-// The following binary check macros are also defined :
-//
-//   Macro                     Operator equivalent
-//   --------------------      -------------------
-//   CHECK_EQ(val1, val2)      val1 == val2
-//   CHECK_NE(val1, val2)      val1 != val2
-//   CHECK_GT(val1, val2)      val1 > val2
-//   CHECK_GE(val1, val2)      val1 >= val2
-//   CHECK_LT(val1, val2)      val1 < val2
-//   CHECK_LE(val1, val2)      val1 <= val2
-//
-// Debug only versions of all of the check macros are also defined.  These
-// macros generate no code in a release build, but avoid unused variable
-// warnings / errors.
-//
-// To use the debug only versions, prepend a D to the normal check macros, e.g.
-// DCHECK_EQ(a, b).
-
-#ifndef CERCES_INTERNAL_MINIGLOG_GLOG_LOGGING_H_
-#define CERCES_INTERNAL_MINIGLOG_GLOG_LOGGING_H_
-
-#ifdef ANDROID
-#include <android/log.h>
-#endif  // ANDROID
-
-#include <algorithm>
-#include <ctime>
-#include <fstream>
-#include <iostream>
-#include <set>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "ceres/internal/disable_warnings.h"
-#include "ceres/internal/export.h"
-
-// Log severity level constants.
-// clang-format off
-const int FATAL   = -3;
-const int ERROR   = -2;
-const int WARNING = -1;
-const int INFO    =  0;
-// clang-format on
-
-// ------------------------- Glog compatibility ------------------------------
-
-namespace google {
-
-using LogSeverity = int;
-// clang-format off
-const int INFO    = ::INFO;
-const int WARNING = ::WARNING;
-const int ERROR   = ::ERROR;
-const int FATAL   = ::FATAL;
-// clang-format on
-
-// Sink class used for integration with mock and test functions. If sinks are
-// added, all log output is also sent to each sink through the send function.
-// In this implementation, WaitTillSent() is called immediately after the send.
-// This implementation is not thread safe.
-class CERES_EXPORT LogSink {
- public:
-  virtual ~LogSink() = default;
-  virtual void send(LogSeverity severity,
-                    const char* full_filename,
-                    const char* base_filename,
-                    int line,
-                    const struct tm* tm_time,
-                    const char* message,
-                    size_t message_len) = 0;
-  virtual void WaitTillSent() = 0;
-};
-
-// Global set of log sinks. The actual object is defined in logging.cc.
-extern CERES_EXPORT std::set<LogSink*> log_sinks_global;
-
-inline void InitGoogleLogging(const char* /* argv */) {
-  // Do nothing; this is ignored.
-}
-
-// Note: the Log sink functions are not thread safe.
-inline void AddLogSink(LogSink* sink) {
-  // TODO(settinger): Add locks for thread safety.
-  log_sinks_global.insert(sink);
-}
-inline void RemoveLogSink(LogSink* sink) { log_sinks_global.erase(sink); }
-
-}  // namespace google
-
-// ---------------------------- Logger Class --------------------------------
-
-// Class created for each use of the logging macros.
-// The logger acts as a stream and routes the final stream contents to the
-// Android logcat output at the proper filter level.  If ANDROID is not
-// defined, output is directed to std::cerr.  This class should not
-// be directly instantiated in code, rather it should be invoked through the
-// use of the log macros LG, LOG, or VLOG.
-class CERES_EXPORT MessageLogger {
- public:
-  MessageLogger(const char* file, int line, const char* tag, int severity)
-      : file_(file), line_(line), tag_(tag), severity_(severity) {
-    // Pre-pend the stream with the file and line number.
-    StripBasename(std::string(file), &filename_only_);
-    stream_ << filename_only_ << ":" << line << " ";
-  }
-
-  // Output the contents of the stream to the proper channel on destruction.
-  ~MessageLogger() {
-    stream_ << "\n";
-
-#ifdef ANDROID
-    static const int android_log_levels[] = {
-        ANDROID_LOG_FATAL,    // LOG(FATAL)
-        ANDROID_LOG_ERROR,    // LOG(ERROR)
-        ANDROID_LOG_WARN,     // LOG(WARNING)
-        ANDROID_LOG_INFO,     // LOG(INFO), LG, VLOG(0)
-        ANDROID_LOG_DEBUG,    // VLOG(1)
-        ANDROID_LOG_VERBOSE,  // VLOG(2) .. VLOG(N)
-    };
-
-    // Bound the logging level.
-    const int kMaxVerboseLevel = 2;
-    int android_level_index =
-        std::min(std::max(FATAL, severity_), kMaxVerboseLevel) - FATAL;
-    int android_log_level = android_log_levels[android_level_index];
-
-    // Output the log string the Android log at the appropriate level.
-    __android_log_write(android_log_level, tag_.c_str(), stream_.str().c_str());
-
-    // Indicate termination if needed.
-    if (severity_ == FATAL) {
-      __android_log_write(ANDROID_LOG_FATAL, tag_.c_str(), "terminating.\n");
-    }
-#else
-    // If not building on Android, log all output to std::cerr.
-    std::cerr << stream_.str();
-#endif  // ANDROID
-
-    LogToSinks(severity_);
-    WaitForSinks();
-
-    // Android logging at level FATAL does not terminate execution, so abort()
-    // is still required to stop the program.
-    if (severity_ == FATAL) {
-      abort();
-    }
-  }
-
-  // Return the stream associated with the logger object.
-  std::stringstream& stream() { return stream_; }
-
- private:
-  void LogToSinks(int severity) {
-    time_t rawtime;
-    time(&rawtime);
-
-    struct tm timeinfo;
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-    // On Windows, use secure localtime_s not localtime.
-    localtime_s(&timeinfo, &rawtime);
-#else
-    // On non-Windows systems, use threadsafe localtime_r not localtime.
-    localtime_r(&rawtime, &timeinfo);
-#endif
-
-    std::set<google::LogSink*>::iterator iter;
-    // Send the log message to all sinks.
-    for (iter = google::log_sinks_global.begin();
-         iter != google::log_sinks_global.end();
-         ++iter) {
-      (*iter)->send(severity,
-                    file_.c_str(),
-                    filename_only_.c_str(),
-                    line_,
-                    &timeinfo,
-                    stream_.str().c_str(),
-                    stream_.str().size());
-    }
-  }
-
-  void WaitForSinks() {
-    // TODO(settinger): Add locks for thread safety.
-    std::set<google::LogSink*>::iterator iter;
-
-    // Call WaitTillSent() for all sinks.
-    for (iter = google::log_sinks_global.begin();
-         iter != google::log_sinks_global.end();
-         ++iter) {
-      (*iter)->WaitTillSent();
-    }
-  }
-
-  void StripBasename(const std::string& full_path, std::string* filename) {
-    // TODO(settinger): Add support for OSs with different path separators.
-    const char kSeparator = '/';
-    size_t pos = full_path.rfind(kSeparator);
-    if (pos != std::string::npos) {
-      *filename = full_path.substr(pos + 1, std::string::npos);
-    } else {
-      *filename = full_path;
-    }
-  }
-
-  std::string file_;
-  std::string filename_only_;
-  int line_;
-  std::string tag_;
-  std::stringstream stream_;
-  int severity_;
-};
-
-// ---------------------- Logging Macro definitions --------------------------
-
-// This class is used to explicitly ignore values in the conditional
-// logging macros.  This avoids compiler warnings like "value computed
-// is not used" and "statement has no effect".
-class CERES_EXPORT LoggerVoidify {
- public:
-  // This has to be an operator with a precedence lower than << but
-  // higher than ?:
-  void operator&(const std::ostream& s) {}
-};
-
-// Log only if condition is met.  Otherwise evaluates to void.
-// clang-format off
-#define LOG_IF(severity, condition) \
-    !(condition) ? (void) 0 : LoggerVoidify() & \
-      MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
-// clang-format on
-
-// Log only if condition is NOT met.  Otherwise evaluates to void.
-#define LOG_IF_FALSE(severity, condition) LOG_IF(severity, !(condition))
-
-// LG is a convenient shortcut for LOG(INFO). Its use is in new
-// google3 code is discouraged and the following shortcut exists for
-// backward compatibility with existing code.
-// clang-format off
-#ifdef MAX_LOG_LEVEL
-#  define LOG(n)  LOG_IF(n, n <= MAX_LOG_LEVEL)
-#  define VLOG(n) LOG_IF(n, n <= MAX_LOG_LEVEL)
-#  define LG      LOG_IF(INFO, INFO <= MAX_LOG_LEVEL)
-#  define VLOG_IF(n, condition) LOG_IF(n, (n <= MAX_LOG_LEVEL) && condition)
-#else
-#  define LOG(n)  MessageLogger((char *)__FILE__, __LINE__, "native", n).stream()    // NOLINT
-#  define VLOG(n) MessageLogger((char *)__FILE__, __LINE__, "native", n).stream()    // NOLINT
-#  define LG      MessageLogger((char *)__FILE__, __LINE__, "native", INFO).stream() // NOLINT
-#  define VLOG_IF(n, condition) LOG_IF(n, condition)
-#endif
-
-// Currently, VLOG is always on for levels below MAX_LOG_LEVEL.
-#ifndef MAX_LOG_LEVEL
-#  define VLOG_IS_ON(x) (1)
-#else
-#  define VLOG_IS_ON(x) (x <= MAX_LOG_LEVEL)
-#endif
-
-#ifndef NDEBUG
-#  define DLOG LOG
-#else
-#  define DLOG(severity) true ? (void) 0 : LoggerVoidify() & \
-      MessageLogger((char *)__FILE__, __LINE__, "native", severity).stream()
-#endif
-// clang-format on
-
-// Log a message and terminate.
-template <class T>
-void LogMessageFatal(const char* file, int line, const T& message) {
-  MessageLogger((char*)__FILE__, __LINE__, "native", FATAL).stream() << message;
-}
-
-// ---------------------------- CHECK macros ---------------------------------
-
-// Check for a given boolean condition.
-#define CHECK(condition) \
-  LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
-
-#ifndef NDEBUG
-// Debug only version of CHECK
-#define DCHECK(condition) \
-  LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
-#else
-// Optimized version - generates no code.
-#define DCHECK(condition) \
-  if (false) LOG_IF_FALSE(FATAL, condition) << "Check failed: " #condition " "
-#endif  // NDEBUG
-
-// ------------------------- CHECK_OP macros ---------------------------------
-
-// Generic binary operator check macro. This should not be directly invoked,
-// instead use the binary comparison macros defined below.
-#define CHECK_OP(val1, val2, op)        \
-  LOG_IF_FALSE(FATAL, ((val1)op(val2))) \
-      << "Check failed: " #val1 " " #op " " #val2 " "
-
-// clang-format off
-
-// Check_op macro definitions
-#define CHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
-#define CHECK_NE(val1, val2) CHECK_OP(val1, val2, !=)
-#define CHECK_LE(val1, val2) CHECK_OP(val1, val2, <=)
-#define CHECK_LT(val1, val2) CHECK_OP(val1, val2, <)
-#define CHECK_GE(val1, val2) CHECK_OP(val1, val2, >=)
-#define CHECK_GT(val1, val2) CHECK_OP(val1, val2, >)
-
-#ifndef NDEBUG
-// Debug only versions of CHECK_OP macros.
-#  define DCHECK_EQ(val1, val2) CHECK_OP(val1, val2, ==)
-#  define DCHECK_NE(val1, val2) CHECK_OP(val1, val2, !=)
-#  define DCHECK_LE(val1, val2) CHECK_OP(val1, val2, <=)
-#  define DCHECK_LT(val1, val2) CHECK_OP(val1, val2, <)
-#  define DCHECK_GE(val1, val2) CHECK_OP(val1, val2, >=)
-#  define DCHECK_GT(val1, val2) CHECK_OP(val1, val2, >)
-#else
-// These versions generate no code in optimized mode.
-#  define DCHECK_EQ(val1, val2) if (false) CHECK_OP(val1, val2, ==)
-#  define DCHECK_NE(val1, val2) if (false) CHECK_OP(val1, val2, !=)
-#  define DCHECK_LE(val1, val2) if (false) CHECK_OP(val1, val2, <=)
-#  define DCHECK_LT(val1, val2) if (false) CHECK_OP(val1, val2, <)
-#  define DCHECK_GE(val1, val2) if (false) CHECK_OP(val1, val2, >=)
-#  define DCHECK_GT(val1, val2) if (false) CHECK_OP(val1, val2, >)
-#endif  // NDEBUG
-
-// clang-format on
-
-// ---------------------------CHECK_NOTNULL macros ---------------------------
-
-// Helpers for CHECK_NOTNULL(). Two are necessary to support both raw pointers
-// and smart pointers.
-template <typename T>
-T& CheckNotNullCommon(const char* file, int line, const char* names, T& t) {
-  if (t == nullptr) {
-    LogMessageFatal(file, line, std::string(names));
-  }
-  return t;
-}
-
-template <typename T>
-T* CheckNotNull(const char* file, int line, const char* names, T* t) {
-  return CheckNotNullCommon(file, line, names, t);
-}
-
-template <typename T>
-T& CheckNotNull(const char* file, int line, const char* names, T& t) {
-  return CheckNotNullCommon(file, line, names, t);
-}
-
-// Check that a pointer is not null.
-#define CHECK_NOTNULL(val) \
-  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non nullptr", (val))
-
-#ifndef NDEBUG
-// Debug only version of CHECK_NOTNULL
-#define DCHECK_NOTNULL(val) \
-  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non nullptr", (val))
-#else
-// Optimized version - generates no code.
-#define DCHECK_NOTNULL(val) \
-  if (false)                \
-  CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non nullptr", (val))
-#endif  // NDEBUG
-
-#include "ceres/internal/reenable_warnings.h"
-
-#endif  // CERCES_INTERNAL_MINIGLOG_GLOG_LOGGING_H_
diff --git a/internal/ceres/minimizer.cc b/internal/ceres/minimizer.cc
index 5317388..1a8a3ba 100644
--- a/internal/ceres/minimizer.cc
+++ b/internal/ceres/minimizer.cc
@@ -32,10 +32,10 @@
 
 #include <memory>
 
+#include "absl/log/log.h"
 #include "ceres/line_search_minimizer.h"
 #include "ceres/trust_region_minimizer.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/normal_prior.cc b/internal/ceres/normal_prior.cc
index c8a7a27..29fb92c 100644
--- a/internal/ceres/normal_prior.cc
+++ b/internal/ceres/normal_prior.cc
@@ -34,9 +34,9 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/numeric_diff_cost_function_test.cc b/internal/ceres/numeric_diff_cost_function_test.cc
index 0c9074a..235c266 100644
--- a/internal/ceres/numeric_diff_cost_function_test.cc
+++ b/internal/ceres/numeric_diff_cost_function_test.cc
@@ -43,7 +43,6 @@
 #include "ceres/numeric_diff_test_utils.h"
 #include "ceres/test_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/parallel_for.h b/internal/ceres/parallel_for.h
index 11db1fb..97fc95e 100644
--- a/internal/ceres/parallel_for.h
+++ b/internal/ceres/parallel_for.h
@@ -35,12 +35,12 @@
 #include <mutex>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/context_impl.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/parallel_invoke.h"
 #include "ceres/partition_range_for_parallel_for.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/parallel_for_benchmark.cc b/internal/ceres/parallel_for_benchmark.cc
index 3bfdb87..870ef18 100644
--- a/internal/ceres/parallel_for_benchmark.cc
+++ b/internal/ceres/parallel_for_benchmark.cc
@@ -26,11 +26,11 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // POSSIBILITY OF SUCH DAMAGE.
 
+#include "absl/log/check.h"
 #include "benchmark/benchmark.h"
 #include "ceres/context_impl.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/parallel_for.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/parallel_for_test.cc b/internal/ceres/parallel_for_test.cc
index 46f5a0f..9b10ac5 100644
--- a/internal/ceres/parallel_for_test.cc
+++ b/internal/ceres/parallel_for_test.cc
@@ -40,10 +40,10 @@
 #include <tuple>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/context_impl.h"
 #include "ceres/internal/config.h"
 #include "ceres/parallel_vector_ops.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -489,7 +489,7 @@
     Vector x = Vector::Random(kVectorSize);
     ParallelSetZero(&context, num_threads, x);
 
-    CHECK_EQ(x.squaredNorm(), 0.);
+    ASSERT_EQ(x.squaredNorm(), 0.);
   }
 }
 
diff --git a/internal/ceres/parallel_invoke.cc b/internal/ceres/parallel_invoke.cc
index 0e387c5..79e4eeb 100644
--- a/internal/ceres/parallel_invoke.cc
+++ b/internal/ceres/parallel_invoke.cc
@@ -36,10 +36,10 @@
 #include <mutex>
 #include <tuple>
 
+#include "absl/log/check.h"
 #include "ceres/internal/config.h"
 #include "ceres/parallel_for.h"
 #include "ceres/parallel_vector_ops.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/parallel_utils_test.cc b/internal/ceres/parallel_utils_test.cc
index bea6f0d..b1f6b86 100644
--- a/internal/ceres/parallel_utils_test.cc
+++ b/internal/ceres/parallel_utils_test.cc
@@ -31,7 +31,6 @@
 #include "ceres/parallel_utils.h"
 
 #include "ceres/internal/config.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/parallel_vector_operations_benchmark.cc b/internal/ceres/parallel_vector_operations_benchmark.cc
index 8b55def..2f6e28f 100644
--- a/internal/ceres/parallel_vector_operations_benchmark.cc
+++ b/internal/ceres/parallel_vector_operations_benchmark.cc
@@ -36,7 +36,7 @@
 // Older versions of benchmark library (for example, one shipped with
 // ubuntu 20.04) do not support range generation and range products
 #define VECTOR_SIZES(num_threads)    \
-      Args({1 << 7, num_threads})    \
+  Args({1 << 7, num_threads})        \
       ->Args({1 << 8, num_threads})  \
       ->Args({1 << 9, num_threads})  \
       ->Args({1 << 10, num_threads}) \
diff --git a/internal/ceres/parameter_block.h b/internal/ceres/parameter_block.h
index 925d1c4..db4011f 100644
--- a/internal/ceres/parameter_block.h
+++ b/internal/ceres/parameter_block.h
@@ -39,13 +39,14 @@
 #include <string>
 #include <unordered_set>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/array_utils.h"
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/manifold.h"
 #include "ceres/stringprintf.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/parameter_block_ordering.cc b/internal/ceres/parameter_block_ordering.cc
index 2b8bf6e..5bac2fd 100644
--- a/internal/ceres/parameter_block_ordering.cc
+++ b/internal/ceres/parameter_block_ordering.cc
@@ -36,6 +36,7 @@
 #include <unordered_set>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/graph.h"
 #include "ceres/graph_algorithms.h"
 #include "ceres/map_util.h"
@@ -43,7 +44,6 @@
 #include "ceres/program.h"
 #include "ceres/residual_block.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/parameter_dims_test.cc b/internal/ceres/parameter_dims_test.cc
index 58d2500..54dd073 100644
--- a/internal/ceres/parameter_dims_test.cc
+++ b/internal/ceres/parameter_dims_test.cc
@@ -24,11 +24,11 @@
 
 #include "ceres/internal/parameter_dims.h"
 
-#include <gtest/gtest.h>
-
 #include <type_traits>
 #include <utility>
 
+#include "gtest/gtest.h"
+
 namespace ceres {
 namespace internal {
 
diff --git a/internal/ceres/partitioned_matrix_view.cc b/internal/ceres/partitioned_matrix_view.cc
index cffdbc5..5257e22 100644
--- a/internal/ceres/partitioned_matrix_view.cc
+++ b/internal/ceres/partitioned_matrix_view.cc
@@ -39,10 +39,12 @@
 //
 // This file is generated using generate_template_specializations.py.
 
+#include "ceres/partitioned_matrix_view.h"
+
 #include <memory>
 
+#include "absl/log/log.h"
 #include "ceres/linear_solver.h"
-#include "ceres/partitioned_matrix_view.h"
 
 namespace ceres::internal {
 
@@ -51,134 +53,98 @@
 std::unique_ptr<PartitionedMatrixViewBase> PartitionedMatrixViewBase::Create(
     const LinearSolver::Options& options, const BlockSparseMatrix& matrix) {
 #ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 2)) {
-    return std::make_unique<PartitionedMatrixView<2,2, 2>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 2)) {
+    return std::make_unique<PartitionedMatrixView<2, 2, 2>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<2,2, 3>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<2, 2, 3>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<2,2, 4>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<2, 2, 4>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2)) {
-    return std::make_unique<PartitionedMatrixView<2,2, Eigen::Dynamic>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 2)) {
+    return std::make_unique<PartitionedMatrixView<2, 2, Eigen::Dynamic>>(
+        options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<2,3, 3>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<2, 3, 3>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<2,3, 4>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<2, 3, 4>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 6)) {
-    return std::make_unique<PartitionedMatrixView<2,3, 6>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 6)) {
+    return std::make_unique<PartitionedMatrixView<2, 3, 6>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 9)) {
-    return std::make_unique<PartitionedMatrixView<2,3, 9>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 9)) {
+    return std::make_unique<PartitionedMatrixView<2, 3, 9>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<2,3, Eigen::Dynamic>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<2, 3, Eigen::Dynamic>>(
+        options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<2,4, 3>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, 3>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<2,4, 4>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, 4>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 6)) {
-    return std::make_unique<PartitionedMatrixView<2,4, 6>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 6)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, 6>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 8)) {
-    return std::make_unique<PartitionedMatrixView<2,4, 8>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 8)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, 8>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 9)) {
-    return std::make_unique<PartitionedMatrixView<2,4, 9>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 9)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, 9>>(options, matrix);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<2,4, Eigen::Dynamic>>(
-                   options, matrix);
+  if ((options.row_block_size == 2) && (options.e_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<2, 4, Eigen::Dynamic>>(
+        options, matrix);
   }
   if (options.row_block_size == 2) {
-    return std::make_unique<PartitionedMatrixView<2,Eigen::Dynamic, Eigen::Dynamic>>(
-                   options, matrix);
+    return std::make_unique<
+        PartitionedMatrixView<2, Eigen::Dynamic, Eigen::Dynamic>>(options,
+                                                                  matrix);
   }
-  if ((options.row_block_size == 3) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<3,3, 3>>(
-                   options, matrix);
+  if ((options.row_block_size == 3) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<3, 3, 3>>(options, matrix);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 2)) {
-    return std::make_unique<PartitionedMatrixView<4,4, 2>>(
-                   options, matrix);
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 2)) {
+    return std::make_unique<PartitionedMatrixView<4, 4, 2>>(options, matrix);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
-    return std::make_unique<PartitionedMatrixView<4,4, 3>>(
-                   options, matrix);
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
+    return std::make_unique<PartitionedMatrixView<4, 4, 3>>(options, matrix);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<4,4, 4>>(
-                   options, matrix);
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<4, 4, 4>>(options, matrix);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4)) {
-    return std::make_unique<PartitionedMatrixView<4,4, Eigen::Dynamic>>(
-                   options, matrix);
+  if ((options.row_block_size == 4) && (options.e_block_size == 4)) {
+    return std::make_unique<PartitionedMatrixView<4, 4, Eigen::Dynamic>>(
+        options, matrix);
   }
 
 #endif
   VLOG(1) << "Template specializations not found for <"
           << options.row_block_size << "," << options.e_block_size << ","
           << options.f_block_size << ">";
-  return std::make_unique<PartitionedMatrixView<Eigen::Dynamic,
-                                                Eigen::Dynamic,
-                                                Eigen::Dynamic>>(
+  return std::make_unique<
+      PartitionedMatrixView<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic>>(
       options, matrix);
 };
 
diff --git a/internal/ceres/partitioned_matrix_view.h b/internal/ceres/partitioned_matrix_view.h
index 8589a3b..8fa8e5a 100644
--- a/internal/ceres/partitioned_matrix_view.h
+++ b/internal/ceres/partitioned_matrix_view.h
@@ -48,7 +48,6 @@
 #include "ceres/internal/export.h"
 #include "ceres/linear_solver.h"
 #include "ceres/small_blas.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/partitioned_matrix_view_impl.h b/internal/ceres/partitioned_matrix_view_impl.h
index bd02439..322d00f 100644
--- a/internal/ceres/partitioned_matrix_view_impl.h
+++ b/internal/ceres/partitioned_matrix_view_impl.h
@@ -33,6 +33,7 @@
 #include <memory>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
 #include "ceres/internal/eigen.h"
@@ -40,7 +41,6 @@
 #include "ceres/partition_range_for_parallel_for.h"
 #include "ceres/partitioned_matrix_view.h"
 #include "ceres/small_blas.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/partitioned_matrix_view_test.cc b/internal/ceres/partitioned_matrix_view_test.cc
index 3addba6..72ad1c4 100644
--- a/internal/ceres/partitioned_matrix_view_test.cc
+++ b/internal/ceres/partitioned_matrix_view_test.cc
@@ -36,12 +36,12 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/block_structure.h"
 #include "ceres/casts.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/linear_least_squares_problems.h"
 #include "ceres/sparse_matrix.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres {
@@ -65,7 +65,7 @@
     const int problem_id = ::testing::get<0>(GetParam());
     const int num_threads = ::testing::get<1>(GetParam());
     auto problem = CreateLinearLeastSquaresProblemFromId(problem_id);
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A_ = std::move(problem->A);
     auto block_sparse = down_cast<BlockSparseMatrix*>(A_.get());
 
@@ -173,8 +173,8 @@
   const int num_col_blocks_f = pmv_->num_col_blocks_f();
   const int num_col_blocks_e = pmv_->num_col_blocks_e();
 
-  CHECK_EQ(block_diagonal_ff->num_rows(), num_cols_f);
-  CHECK_EQ(block_diagonal_ff->num_cols(), num_cols_f);
+  ASSERT_EQ(block_diagonal_ff->num_rows(), num_cols_f);
+  ASSERT_EQ(block_diagonal_ff->num_cols(), num_cols_f);
 
   EXPECT_EQ(bs_diagonal->cols.size(), num_col_blocks_f);
   EXPECT_EQ(bs_diagonal->rows.size(), num_col_blocks_f);
@@ -212,8 +212,8 @@
   const int num_cols_e = pmv_->num_cols_e();
   const int num_col_blocks_e = pmv_->num_col_blocks_e();
 
-  CHECK_EQ(block_diagonal_ee->num_rows(), num_cols_e);
-  CHECK_EQ(block_diagonal_ee->num_cols(), num_cols_e);
+  ASSERT_EQ(block_diagonal_ee->num_rows(), num_cols_e);
+  ASSERT_EQ(block_diagonal_ee->num_cols(), num_cols_e);
 
   EXPECT_EQ(bs->cols.size(), num_col_blocks_e);
   EXPECT_EQ(bs->rows.size(), num_col_blocks_e);
diff --git a/internal/ceres/polynomial.cc b/internal/ceres/polynomial.cc
index 8e99e34..db3a404 100644
--- a/internal/ceres/polynomial.cc
+++ b/internal/ceres/polynomial.cc
@@ -36,9 +36,10 @@
 #include <vector>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/function_sample.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/preconditioner.cc b/internal/ceres/preconditioner.cc
index 0b9ce96..7c51976 100644
--- a/internal/ceres/preconditioner.cc
+++ b/internal/ceres/preconditioner.cc
@@ -30,7 +30,7 @@
 
 #include "ceres/preconditioner.h"
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/preprocessor.cc b/internal/ceres/preprocessor.cc
index 83c05d4..33fb7fb 100644
--- a/internal/ceres/preprocessor.cc
+++ b/internal/ceres/preprocessor.cc
@@ -32,6 +32,7 @@
 
 #include <memory>
 
+#include "absl/log/log.h"
 #include "ceres/callbacks.h"
 #include "ceres/gradient_checking_cost_function.h"
 #include "ceres/line_search_preprocessor.h"
diff --git a/internal/ceres/problem_impl.cc b/internal/ceres/problem_impl.cc
index 52575ee..eafbb20 100644
--- a/internal/ceres/problem_impl.cc
+++ b/internal/ceres/problem_impl.cc
@@ -41,6 +41,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/casts.h"
 #include "ceres/compressed_row_jacobian_writer.h"
 #include "ceres/compressed_row_sparse_matrix.h"
@@ -61,7 +63,6 @@
 #include "ceres/scratch_evaluate_preparer.h"
 #include "ceres/stl_util.h"
 #include "ceres/stringprintf.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 namespace {
diff --git a/internal/ceres/problem_test.cc b/internal/ceres/problem_test.cc
index ebf15cd..29524d1 100644
--- a/internal/ceres/problem_test.cc
+++ b/internal/ceres/problem_test.cc
@@ -35,6 +35,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/casts.h"
 #include "ceres/cost_function.h"
@@ -324,7 +325,7 @@
   }
 
   // Check that the destructor was called only once.
-  CHECK_EQ(num_destructions, 1);
+  ASSERT_EQ(num_destructions, 1);
 }
 
 TEST(Problem, GetCostFunctionForResidualBlock) {
@@ -369,13 +370,13 @@
     EXPECT_EQ(2, problem.NumResidualBlocks());
 
     problem.RemoveResidualBlock(r_yz);
-    CHECK_EQ(num_destructions, 1);
+    ASSERT_EQ(num_destructions, 1);
     problem.RemoveResidualBlock(r_wz);
-    CHECK_EQ(num_destructions, 2);
+    ASSERT_EQ(num_destructions, 2);
 
     EXPECT_EQ(0, problem.NumResidualBlocks());
   }
-  CHECK_EQ(num_destructions, 2);
+  ASSERT_EQ(num_destructions, 2);
 }
 
 // Make the dynamic problem tests (e.g. for removing residual blocks)
@@ -1162,7 +1163,7 @@
 
 // Convert a CRSMatrix to a dense Eigen matrix.
 static void CRSToDenseMatrix(const CRSMatrix& input, Matrix* output) {
-  CHECK(output != nullptr);
+  ASSERT_TRUE(output != nullptr);
   Matrix& m = *output;
   m.resize(input.num_rows, input.num_cols);
   m.setZero();
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index 268c477..6753df9 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -63,7 +63,8 @@
 #include "Eigen/OrderingMethods"
 #endif
 
-#include "glog/logging.h"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/residual_block_utils.cc b/internal/ceres/residual_block_utils.cc
index 91370d8..54c41fb 100644
--- a/internal/ceres/residual_block_utils.cc
+++ b/internal/ceres/residual_block_utils.cc
@@ -35,13 +35,13 @@
 #include <limits>
 #include <string>
 
+#include "absl/log/check.h"
 #include "ceres/array_utils.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/parameter_block.h"
 #include "ceres/residual_block.h"
 #include "ceres/stringprintf.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/rotation_test.cc b/internal/ceres/rotation_test.cc
index f1ea071..ffa5ff3 100644
--- a/internal/ceres/rotation_test.cc
+++ b/internal/ceres/rotation_test.cc
@@ -38,6 +38,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "ceres/constants.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/euler_angles.h"
@@ -46,7 +47,6 @@
 #include "ceres/jet.h"
 #include "ceres/stringprintf.h"
 #include "ceres/test_util.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
@@ -648,7 +648,7 @@
       }
     }
   }
-  CHECK_EQ(7, n_tests);
+  ASSERT_EQ(7, n_tests);
 }
 
 // Test that a random rotation produces an orthonormal rotation
diff --git a/internal/ceres/schur_complement_solver_test.cc b/internal/ceres/schur_complement_solver_test.cc
index 7c5ce28..de00508 100644
--- a/internal/ceres/schur_complement_solver_test.cc
+++ b/internal/ceres/schur_complement_solver_test.cc
@@ -42,7 +42,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -53,7 +52,7 @@
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(problem_id);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
     b = std::move(problem->b);
     D = std::move(problem->D);
diff --git a/internal/ceres/schur_eliminator.cc b/internal/ceres/schur_eliminator.cc
index cb079b5..86d6a2c 100644
--- a/internal/ceres/schur_eliminator.cc
+++ b/internal/ceres/schur_eliminator.cc
@@ -39,10 +39,12 @@
 //
 // This file is generated using generate_template_specializations.py.
 
+#include "ceres/schur_eliminator.h"
+
 #include <memory>
 
+#include "absl/log/log.h"
 #include "ceres/linear_solver.h"
-#include "ceres/schur_eliminator.h"
 
 namespace ceres::internal {
 
@@ -51,103 +53,84 @@
 std::unique_ptr<SchurEliminatorBase> SchurEliminatorBase::Create(
     const LinearSolver::Options& options) {
 #ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 2)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 2)) {
     return std::make_unique<SchurEliminator<2, 2, 2>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 3)) {
     return std::make_unique<SchurEliminator<2, 2, 3>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 4)) {
     return std::make_unique<SchurEliminator<2, 2, 4>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2)) {
     return std::make_unique<SchurEliminator<2, 2, Eigen::Dynamic>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
     return std::make_unique<SchurEliminator<2, 3, 3>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 4)) {
     return std::make_unique<SchurEliminator<2, 3, 4>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 6)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 6)) {
     return std::make_unique<SchurEliminator<2, 3, 6>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 9)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 9)) {
     return std::make_unique<SchurEliminator<2, 3, 9>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3)) {
     return std::make_unique<SchurEliminator<2, 3, Eigen::Dynamic>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
     return std::make_unique<SchurEliminator<2, 4, 3>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
     return std::make_unique<SchurEliminator<2, 4, 4>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 6)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 6)) {
     return std::make_unique<SchurEliminator<2, 4, 6>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 8)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 8)) {
     return std::make_unique<SchurEliminator<2, 4, 8>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 9)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 9)) {
     return std::make_unique<SchurEliminator<2, 4, 9>>(options);
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4)) {
     return std::make_unique<SchurEliminator<2, 4, Eigen::Dynamic>>(options);
   }
   if (options.row_block_size == 2) {
-    return std::make_unique<SchurEliminator<2, Eigen::Dynamic, Eigen::Dynamic>>(options);
+    return std::make_unique<SchurEliminator<2, Eigen::Dynamic, Eigen::Dynamic>>(
+        options);
   }
-  if ((options.row_block_size == 3) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 3) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
     return std::make_unique<SchurEliminator<3, 3, 3>>(options);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 2)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 2)) {
     return std::make_unique<SchurEliminator<4, 4, 2>>(options);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
     return std::make_unique<SchurEliminator<4, 4, 3>>(options);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
     return std::make_unique<SchurEliminator<4, 4, 4>>(options);
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4)) {
     return std::make_unique<SchurEliminator<4, 4, Eigen::Dynamic>>(options);
   }
 
@@ -155,9 +138,8 @@
   VLOG(1) << "Template specializations not found for <"
           << options.row_block_size << "," << options.e_block_size << ","
           << options.f_block_size << ">";
-  return std::make_unique<SchurEliminator<Eigen::Dynamic,
-                                          Eigen::Dynamic,
-                                          Eigen::Dynamic>>(options);
+  return std::make_unique<
+      SchurEliminator<Eigen::Dynamic, Eigen::Dynamic, Eigen::Dynamic>>(options);
 }
 
 }  // namespace ceres::internal
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index ef5ce66..f018b42 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -54,6 +54,7 @@
 #include <map>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
 #include "ceres/block_random_access_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/block_structure.h"
@@ -67,7 +68,6 @@
 #include "ceres/small_blas.h"
 #include "ceres/stl_util.h"
 #include "ceres/thread_token_provider.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/schur_eliminator_test.cc b/internal/ceres/schur_eliminator_test.cc
index bdf8b8c..7821289 100644
--- a/internal/ceres/schur_eliminator_test.cc
+++ b/internal/ceres/schur_eliminator_test.cc
@@ -47,7 +47,6 @@
 #include "ceres/test_util.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 // TODO(sameeragarwal): Reduce the size of these tests and redo the
@@ -59,7 +58,7 @@
  protected:
   void SetUpFromId(int id) {
     auto problem = CreateLinearLeastSquaresProblemFromId(id);
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     SetupHelper(problem.get());
   }
 
diff --git a/internal/ceres/schur_jacobi_preconditioner.cc b/internal/ceres/schur_jacobi_preconditioner.cc
index fbe258d..83505dd 100644
--- a/internal/ceres/schur_jacobi_preconditioner.cc
+++ b/internal/ceres/schur_jacobi_preconditioner.cc
@@ -34,11 +34,11 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "ceres/block_random_access_diagonal_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/linear_solver.h"
 #include "ceres/schur_eliminator.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/schur_templates.cc b/internal/ceres/schur_templates.cc
index 95df671..56b0055 100644
--- a/internal/ceres/schur_templates.cc
+++ b/internal/ceres/schur_templates.cc
@@ -39,9 +39,10 @@
 //
 // This file is generated using generate_template_specializations.py.
 
-#include "ceres/internal/eigen.h"
 #include "ceres/schur_templates.h"
 
+#include "ceres/internal/eigen.h"
+
 namespace ceres {
 namespace internal {
 
@@ -56,118 +57,103 @@
   *e_block_size = Eigen::Dynamic;
   *f_block_size = Eigen::Dynamic;
 #ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 2)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 2)) {
     *row_block_size = 2;
     *e_block_size = 2;
     *f_block_size = 2;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 3)) {
     *row_block_size = 2;
     *e_block_size = 2;
     *f_block_size = 3;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2) &&
+      (options.f_block_size == 4)) {
     *row_block_size = 2;
     *e_block_size = 2;
     *f_block_size = 4;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 2)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 2)) {
     *row_block_size = 2;
     *e_block_size = 2;
     *f_block_size = Eigen::Dynamic;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
     *row_block_size = 2;
     *e_block_size = 3;
     *f_block_size = 3;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 4)) {
     *row_block_size = 2;
     *e_block_size = 3;
     *f_block_size = 4;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 6)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 6)) {
     *row_block_size = 2;
     *e_block_size = 3;
     *f_block_size = 6;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 9)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3) &&
+      (options.f_block_size == 9)) {
     *row_block_size = 2;
     *e_block_size = 3;
     *f_block_size = 9;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 3)) {
     *row_block_size = 2;
     *e_block_size = 3;
     *f_block_size = Eigen::Dynamic;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = 3;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = 4;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 6)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 6)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = 6;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 8)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 8)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = 8;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 9)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4) &&
+      (options.f_block_size == 9)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = 9;
     return;
   }
-  if ((options.row_block_size == 2) &&
-     (options.e_block_size == 4)) {
+  if ((options.row_block_size == 2) && (options.e_block_size == 4)) {
     *row_block_size = 2;
     *e_block_size = 4;
     *f_block_size = Eigen::Dynamic;
@@ -179,40 +165,35 @@
     *f_block_size = Eigen::Dynamic;
     return;
   }
-  if ((options.row_block_size == 3) &&
-     (options.e_block_size == 3) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 3) && (options.e_block_size == 3) &&
+      (options.f_block_size == 3)) {
     *row_block_size = 3;
     *e_block_size = 3;
     *f_block_size = 3;
     return;
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 2)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 2)) {
     *row_block_size = 4;
     *e_block_size = 4;
     *f_block_size = 2;
     return;
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 3)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 3)) {
     *row_block_size = 4;
     *e_block_size = 4;
     *f_block_size = 3;
     return;
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4) &&
-     (options.f_block_size == 4)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4) &&
+      (options.f_block_size == 4)) {
     *row_block_size = 4;
     *e_block_size = 4;
     *f_block_size = 4;
     return;
   }
-  if ((options.row_block_size == 4) &&
-     (options.e_block_size == 4)) {
+  if ((options.row_block_size == 4) && (options.e_block_size == 4)) {
     *row_block_size = 4;
     *e_block_size = 4;
     *f_block_size = Eigen::Dynamic;
diff --git a/internal/ceres/small_blas.h b/internal/ceres/small_blas.h
index fb8d7fa..20fedf6 100644
--- a/internal/ceres/small_blas.h
+++ b/internal/ceres/small_blas.h
@@ -35,9 +35,9 @@
 #ifndef CERES_INTERNAL_SMALL_BLAS_H_
 #define CERES_INTERNAL_SMALL_BLAS_H_
 
+#include "absl/log/check.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
-#include "glog/logging.h"
 #include "small_blas_generic.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index fadb17b..a8de046 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -38,6 +38,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/casts.h"
 #include "ceres/context.h"
 #include "ceres/context_impl.h"
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index 52bd594..0a83a34 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -36,6 +36,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/evaluation_callback.h"
 #include "ceres/manifold.h"
diff --git a/internal/ceres/sparse_cholesky.cc b/internal/ceres/sparse_cholesky.cc
index ecfeb29..f20aa99 100644
--- a/internal/ceres/sparse_cholesky.cc
+++ b/internal/ceres/sparse_cholesky.cc
@@ -33,6 +33,7 @@
 #include <memory>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "ceres/accelerate_sparse.h"
 #include "ceres/cuda_sparse_cholesky.h"
 #include "ceres/eigensparse.h"
diff --git a/internal/ceres/sparse_cholesky.h b/internal/ceres/sparse_cholesky.h
index 53f475a..0b2a3a4 100644
--- a/internal/ceres/sparse_cholesky.h
+++ b/internal/ceres/sparse_cholesky.h
@@ -41,7 +41,6 @@
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
 #include "ceres/linear_solver.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/sparse_cholesky_test.cc b/internal/ceres/sparse_cholesky_test.cc
index bb5c7c8..10efd28 100644
--- a/internal/ceres/sparse_cholesky_test.cc
+++ b/internal/ceres/sparse_cholesky_test.cc
@@ -44,7 +44,6 @@
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/iterative_refiner.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
diff --git a/internal/ceres/sparse_normal_cholesky_solver_test.cc b/internal/ceres/sparse_normal_cholesky_solver_test.cc
index 2ff3f6e..987272e 100644
--- a/internal/ceres/sparse_normal_cholesky_solver_test.cc
+++ b/internal/ceres/sparse_normal_cholesky_solver_test.cc
@@ -38,7 +38,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -56,7 +55,7 @@
     std::unique_ptr<LinearLeastSquaresProblem> problem =
         CreateLinearLeastSquaresProblemFromId(2);
 
-    CHECK(problem != nullptr);
+    ASSERT_TRUE(problem != nullptr);
     A_.reset(down_cast<BlockSparseMatrix*>(problem->A.release()));
     b_ = std::move(problem->b);
     D_ = std::move(problem->D);
diff --git a/internal/ceres/subset_preconditioner.cc b/internal/ceres/subset_preconditioner.cc
index 068f6ce..52b79f7 100644
--- a/internal/ceres/subset_preconditioner.cc
+++ b/internal/ceres/subset_preconditioner.cc
@@ -34,6 +34,7 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/inner_product_computer.h"
 #include "ceres/linear_solver.h"
diff --git a/internal/ceres/subset_preconditioner_test.cc b/internal/ceres/subset_preconditioner_test.cc
index b73274c..4849264 100644
--- a/internal/ceres/subset_preconditioner_test.cc
+++ b/internal/ceres/subset_preconditioner_test.cc
@@ -40,7 +40,6 @@
 #include "ceres/inner_product_computer.h"
 #include "ceres/internal/config.h"
 #include "ceres/internal/eigen.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/suitesparse.cc b/internal/ceres/suitesparse.cc
index d93dd8d..3595b29 100644
--- a/internal/ceres/suitesparse.cc
+++ b/internal/ceres/suitesparse.cc
@@ -37,9 +37,11 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/log.h"
 #include "ceres/compressed_col_sparse_matrix_utils.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/linear_solver.h"
+#include "ceres/stringprintf.h"
 #include "ceres/suitesparse.h"
 #include "ceres/triplet_sparse_matrix.h"
 #include "cholmod.h"
diff --git a/internal/ceres/suitesparse.h b/internal/ceres/suitesparse.h
index 703ee87..57d1d78 100644
--- a/internal/ceres/suitesparse.h
+++ b/internal/ceres/suitesparse.h
@@ -49,7 +49,6 @@
 #include "ceres/linear_solver.h"
 #include "ceres/sparse_cholesky.h"
 #include "cholmod.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/system_test.cc b/internal/ceres/system_test.cc
index 6134995..53c4451 100644
--- a/internal/ceres/system_test.cc
+++ b/internal/ceres/system_test.cc
@@ -40,7 +40,6 @@
 #include "ceres/solver.h"
 #include "ceres/test_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/test_util.cc b/internal/ceres/test_util.cc
index 05d24c3..a9d4335 100644
--- a/internal/ceres/test_util.cc
+++ b/internal/ceres/test_util.cc
@@ -35,11 +35,12 @@
 #include <algorithm>
 #include <cmath>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/file.h"
 #include "ceres/internal/port.h"
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 // This macro is used to inject additional path information specific
diff --git a/internal/ceres/thread_pool_test.cc b/internal/ceres/thread_pool_test.cc
index fa321b0..b794c3e 100644
--- a/internal/ceres/thread_pool_test.cc
+++ b/internal/ceres/thread_pool_test.cc
@@ -35,8 +35,8 @@
 #include <mutex>
 #include <thread>
 
+#include "absl/log/log.h"
 #include "ceres/internal/config.h"
-#include "glog/logging.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
diff --git a/internal/ceres/triplet_sparse_matrix.cc b/internal/ceres/triplet_sparse_matrix.cc
index 4bb6685..554ece9 100644
--- a/internal/ceres/triplet_sparse_matrix.cc
+++ b/internal/ceres/triplet_sparse_matrix.cc
@@ -34,12 +34,13 @@
 #include <memory>
 #include <random>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/compressed_row_sparse_matrix.h"
 #include "ceres/crs_matrix.h"
 #include "ceres/internal/eigen.h"
 #include "ceres/internal/export.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/trust_region_minimizer.cc b/internal/ceres/trust_region_minimizer.cc
index d76f677..9d9b8e8 100644
--- a/internal/ceres/trust_region_minimizer.cc
+++ b/internal/ceres/trust_region_minimizer.cc
@@ -40,6 +40,8 @@
 #include <vector>
 
 #include "Eigen/Core"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/array_utils.h"
 #include "ceres/coordinate_descent_minimizer.h"
 #include "ceres/eigen_vector_ops.h"
@@ -50,7 +52,6 @@
 #include "ceres/stringprintf.h"
 #include "ceres/types.h"
 #include "ceres/wall_time.h"
-#include "glog/logging.h"
 
 // Helper macro to simplify some of the control flow.
 #define RETURN_IF_ERROR_AND_LOG(expr)                            \
diff --git a/internal/ceres/trust_region_minimizer_test.cc b/internal/ceres/trust_region_minimizer_test.cc
index 94c7162..ca28675 100644
--- a/internal/ceres/trust_region_minimizer_test.cc
+++ b/internal/ceres/trust_region_minimizer_test.cc
@@ -38,6 +38,8 @@
 #include <cmath>
 #include <memory>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/autodiff_cost_function.h"
 #include "ceres/cost_function.h"
 #include "ceres/dense_qr_solver.h"
diff --git a/internal/ceres/trust_region_step_evaluator.cc b/internal/ceres/trust_region_step_evaluator.cc
index a2333a0..5c10c05 100644
--- a/internal/ceres/trust_region_step_evaluator.cc
+++ b/internal/ceres/trust_region_step_evaluator.cc
@@ -33,8 +33,6 @@
 #include <algorithm>
 #include <limits>
 
-#include "glog/logging.h"
-
 namespace ceres::internal {
 
 TrustRegionStepEvaluator::TrustRegionStepEvaluator(
diff --git a/internal/ceres/trust_region_strategy.cc b/internal/ceres/trust_region_strategy.cc
index da5a337..530fc30 100644
--- a/internal/ceres/trust_region_strategy.cc
+++ b/internal/ceres/trust_region_strategy.cc
@@ -34,6 +34,7 @@
 
 #include <memory>
 
+#include "absl/log/log.h"
 #include "ceres/dogleg_strategy.h"
 #include "ceres/levenberg_marquardt_strategy.h"
 
diff --git a/internal/ceres/types.cc b/internal/ceres/types.cc
index e000560..4bbd602 100644
--- a/internal/ceres/types.cc
+++ b/internal/ceres/types.cc
@@ -34,8 +34,8 @@
 #include <cctype>
 #include <string>
 
+#include "absl/log/log.h"
 #include "ceres/internal/config.h"
-#include "glog/logging.h"
 
 namespace ceres {
 
diff --git a/internal/ceres/visibility.cc b/internal/ceres/visibility.cc
index 6c10fb2..05ac8b0 100644
--- a/internal/ceres/visibility.cc
+++ b/internal/ceres/visibility.cc
@@ -39,10 +39,11 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_structure.h"
 #include "ceres/graph.h"
 #include "ceres/pair_hash.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/visibility_based_preconditioner.cc b/internal/ceres/visibility_based_preconditioner.cc
index 34d6e0c..0f46a87 100644
--- a/internal/ceres/visibility_based_preconditioner.cc
+++ b/internal/ceres/visibility_based_preconditioner.cc
@@ -41,6 +41,8 @@
 #include <vector>
 
 #include "Eigen/Dense"
+#include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "ceres/block_random_access_sparse_matrix.h"
 #include "ceres/block_sparse_matrix.h"
 #include "ceres/canonical_views_clustering.h"
@@ -50,7 +52,6 @@
 #include "ceres/schur_eliminator.h"
 #include "ceres/single_linkage_clustering.h"
 #include "ceres/visibility.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/internal/ceres/visibility_based_preconditioner_test.cc b/internal/ceres/visibility_based_preconditioner_test.cc
index 4d52753..1cbad17 100644
--- a/internal/ceres/visibility_based_preconditioner_test.cc
+++ b/internal/ceres/visibility_based_preconditioner_test.cc
@@ -44,7 +44,6 @@
 #include "ceres/stringprintf.h"
 #include "ceres/test_util.h"
 #include "ceres/types.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
@@ -73,7 +72,7 @@
 //     D_.reset(problem->D.release());
 
 //     const CompressedRowBlockStructure* bs =
-//         CHECK_NOTNULL(A_->block_structure());
+//         ASSERT_TRUE(A_->block_structure()!=nullptr);
 //     const int num_col_blocks = bs->cols.size();
 
 //     num_cols_ = A_->num_cols();
diff --git a/internal/ceres/visibility_test.cc b/internal/ceres/visibility_test.cc
index 3efc77c..871ab56 100644
--- a/internal/ceres/visibility_test.cc
+++ b/internal/ceres/visibility_test.cc
@@ -37,7 +37,6 @@
 
 #include "ceres/block_structure.h"
 #include "ceres/graph.h"
-#include "glog/logging.h"
 #include "gtest/gtest.h"
 
 namespace ceres::internal {
diff --git a/internal/ceres/wall_time.cc b/internal/ceres/wall_time.cc
index 2f4cf28..f42f1ea 100644
--- a/internal/ceres/wall_time.cc
+++ b/internal/ceres/wall_time.cc
@@ -32,6 +32,7 @@
 
 #include <ctime>
 
+#include "absl/log/log.h"
 #include "ceres/internal/config.h"
 
 #ifdef _WIN32
@@ -40,6 +41,8 @@
 #include <sys/time.h>
 #endif
 
+#include "ceres/stringprintf.h"
+
 namespace ceres::internal {
 
 double WallTimeInSeconds() {
diff --git a/internal/ceres/wall_time.h b/internal/ceres/wall_time.h
index f99052b..8878f9b 100644
--- a/internal/ceres/wall_time.h
+++ b/internal/ceres/wall_time.h
@@ -36,8 +36,6 @@
 
 #include "ceres/internal/disable_warnings.h"
 #include "ceres/internal/export.h"
-#include "ceres/stringprintf.h"
-#include "glog/logging.h"
 
 namespace ceres::internal {
 
diff --git a/package.xml b/package.xml
index 9d43e43..a6abe4c 100644
--- a/package.xml
+++ b/package.xml
@@ -44,8 +44,6 @@
   <build_depend>gfortran</build_depend>
   <build_depend>suitesparse</build_depend>
   <depend>eigen</depend>
-  <depend>libgflags-dev</depend>
-  <depend>libgoogle-glog-dev</depend>
 
   <export>
     <build_type>cmake</build_type>
diff --git a/third_party/abseil-cpp b/third_party/abseil-cpp
new file mode 160000
index 0000000..d7aaad8
--- /dev/null
+++ b/third_party/abseil-cpp
@@ -0,0 +1 @@
+Subproject commit d7aaad83b488fd62bd51c81ecf16cd938532cc0a