diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7f88fb4..f6bf905 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -498,7 +498,7 @@
   add_definitions("-D_USE_MATH_DEFINES")
   # Disable signed/unsigned int conversion warnings.
   add_compile_options("/wd4018" "/wd4267")
-  # Disable warning about using struct/class for the same symobl.
+  # Disable warning about using struct/class for the same symbol.
   add_compile_options("/wd4099")
   # Disable warning about the insecurity of using "std::copy".
   add_compile_options("/wd4996")
@@ -609,7 +609,7 @@
   $<$<CXX_COMPILER_ID:MSVC>:/wd4996>)
 
 if (CMAKE_VERSION VERSION_LESS 3.12)
-  # Disable the definiton of min/max macros within the project
+  # Disable the definition of min/max macros within the project
   if (WIN32)
     add_definitions (-DNOMINMAX)
   endif (WIN32)
diff --git a/bazel/ceres.bzl b/bazel/ceres.bzl
index e60865e..fad2754 100644
--- a/bazel/ceres.bzl
+++ b/bazel/ceres.bzl
@@ -184,7 +184,7 @@
             "-I" + internal,
             "-Wno-sign-compare",
 
-            # Disable warnings about deprecated interfraces while we are
+            # Disable warnings about deprecated interfaces while we are
             # transitioning from LocalParameterization to Manifolds.
             "-Wno-deprecated-declarations",
         ] + schur_eliminator_copts,
diff --git a/cmake/iOS.cmake b/cmake/iOS.cmake
index 1bb514c..0773d13 100644
--- a/cmake/iOS.cmake
+++ b/cmake/iOS.cmake
@@ -257,7 +257,7 @@
 
 set(CMAKE_C_FLAGS
   "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -fobjc-abi-version=2 -fobjc-arc ${CMAKE_C_FLAGS}")
-# Hidden visibilty is required for C++ on iOS.
+# Hidden visibility is required for C++ on iOS.
 set(CMAKE_CXX_FLAGS
   "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -fobjc-abi-version=2 -fobjc-arc ${CMAKE_CXX_FLAGS}")
 set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG -O3 -fomit-frame-pointer -ffast-math ${CMAKE_CXX_FLAGS_RELEASE}")
diff --git a/docs/source/automatic_derivatives.rst b/docs/source/automatic_derivatives.rst
index e15e911..26fceb0 100644
--- a/docs/source/automatic_derivatives.rst
+++ b/docs/source/automatic_derivatives.rst
@@ -298,7 +298,7 @@
 
 There is no single solution to this problem. In some cases one needs
 to reason explicitly about the points where indeterminacy may occur
-and use alternate expressions using `L'Hopital's rule
+and use alternate expressions using `L'Hôpital's rule
 <https://en.wikipedia.org/wiki/L'H%C3%B4pital's_rule>`_ (see for
 example some of the conversion routines in `rotation.h
 <https://github.com/ceres-solver/ceres-solver/blob/master/include/ceres/rotation.h>`_. In
diff --git a/docs/source/gradient_solver.rst b/docs/source/gradient_solver.rst
index dfe1822..cb27cd1 100644
--- a/docs/source/gradient_solver.rst
+++ b/docs/source/gradient_solver.rst
@@ -136,7 +136,7 @@
    Choices are ``ARMIJO`` and ``WOLFE`` (strong Wolfe conditions).
    Note that in order for the assumptions underlying the ``BFGS`` and
    ``LBFGS`` line search direction algorithms to be guaranteed to be
-   satisifed, the ``WOLFE`` line search should be used.
+   satisfied, the ``WOLFE`` line search should be used.
 
 .. member:: NonlinearConjugateGradientType GradientProblemSolver::Options::nonlinear_conjugate_gradient_type
 
@@ -205,7 +205,7 @@
   low-sensitivity parameters. It can also reduce the robustness of the
   solution to errors in the Jacobians.
 
-.. member:: LineSearchIterpolationType GradientProblemSolver::Options::line_search_interpolation_type
+.. member:: LineSearchInterpolationType GradientProblemSolver::Options::line_search_interpolation_type
 
    Default: ``CUBIC``
 
diff --git a/docs/source/gradient_tutorial.rst b/docs/source/gradient_tutorial.rst
index bd3ebf5..fb26cb7 100644
--- a/docs/source/gradient_tutorial.rst
+++ b/docs/source/gradient_tutorial.rst
@@ -139,7 +139,7 @@
 
 
 If you are unable to use automatic differentiation for some reason
-(say beacause you need to call an external library), then you can
+(say because you need to call an external library), then you can
 use numeric differentiation. In that case the functor is defined as
 follows [#f2]_.
 
diff --git a/docs/source/installation.rst b/docs/source/installation.rst
index f0329f4..fa845c1 100644
--- a/docs/source/installation.rst
+++ b/docs/source/installation.rst
@@ -69,7 +69,7 @@
 
 - `SuiteSparse <http://faculty.cse.tamu.edu/davis/suitesparse.html>`_
   4.0 or later. Needed for solving large sparse linear
-  systems. **Optional; strongly recomended for large scale bundle
+  systems. **Optional; strongly recommended for large scale bundle
   adjustment**
 
   .. NOTE ::
diff --git a/docs/source/interfacing_with_autodiff.rst b/docs/source/interfacing_with_autodiff.rst
index e7bcfd7..59bc798 100644
--- a/docs/source/interfacing_with_autodiff.rst
+++ b/docs/source/interfacing_with_autodiff.rst
@@ -148,7 +148,7 @@
 ------------------------------------------------
 
 Now suppose we are given a function :code:`ComputeDistortionValue`
-thatis able to compute its value and optionally its Jacobian on demand
+that is able to compute its value and optionally its Jacobian on demand
 and has the following signature:
 
 .. code-block:: c++
diff --git a/docs/source/nnls_covariance.rst b/docs/source/nnls_covariance.rst
index c85bedd..b86b5f6 100644
--- a/docs/source/nnls_covariance.rst
+++ b/docs/source/nnls_covariance.rst
@@ -166,7 +166,7 @@
       moderately fast algorithm suitable for small to medium sized
       matrices. For best performance we recommend using
       ``SuiteSparseQR`` which is enabled by setting
-      :member:`Covaraince::Options::sparse_linear_algebra_library_type`
+      :member:`Covariance::Options::sparse_linear_algebra_library_type`
       to ``SUITE_SPARSE``.
 
       ``SPARSE_QR`` cannot compute the covariance if the
@@ -238,7 +238,7 @@
       .. math:: \frac{\sigma_{\text{min}}}{\sigma_{\text{max}}}  < \sqrt{\text{min_reciprocal_condition_number}}
 
       where :math:`\sigma_{\text{min}}` and
-      :math:`\sigma_{\text{max}}` are the minimum and maxiumum
+      :math:`\sigma_{\text{max}}` are the minimum and maximum
       singular values of :math:`J` respectively.
 
    2. ``SPARSE_QR``
diff --git a/docs/source/nnls_modeling.rst b/docs/source/nnls_modeling.rst
index c6b7987..832e292 100644
--- a/docs/source/nnls_modeling.rst
+++ b/docs/source/nnls_modeling.rst
@@ -1582,7 +1582,7 @@
 
 is the ambient space representation. Here :math:`q_0` is the scalar
 part. :math:`q_1` is the coefficient of :math:`i`, :math:`q_2` is the
-coefficient of :math:`j`, and :math:`q_3` is the coeffcient of
+coefficient of :math:`j`, and :math:`q_3` is the coefficient of
 :math:`k`. Where:
 
 .. math::
@@ -2113,7 +2113,7 @@
 scale of the vector does not matter, i.e., elements of the
 projective space :math:`\mathbb{P}^{n-1}`. It assumes that the last
 coordinate of the :math:`n`-vector is the *scalar* component of the
-homogenous vector, i.e., *finite* points in this representation are
+homogeneous vector, i.e., *finite* points in this representation are
 those for which the *scalar* component is non-zero.
 
 Further, ``HomogeneousVectorParameterization::Plus`` preserves the
@@ -2235,7 +2235,7 @@
             q_delta[3] = delta[2];
           }
 
-          Quaternionproduct(q_delta, x, x_plus_delta);
+          QuaternionProduct(q_delta, x, x_plus_delta);
           return true;
         }
       };
@@ -2262,7 +2262,7 @@
       :class:`LocalParameterization` to :class:`Manifolds` in the
       Ceres Solver API. During this period, :class:`Problem` will
       support using both :class:`Manifold` and
-      :class:`LocalParameterization` objects interchangably. In
+      :class:`LocalParameterization` objects interchangeably. In
       particular, adding a :class:`LocalParameterization` to a
       parameter block is the same as adding a :class:`Manifold` to
       that parameter block. For methods in the API affected by this
@@ -2551,7 +2551,7 @@
 
    Repeated calls with the same arguments are ignored. Repeated calls
    with the same double pointer but a different size results in a crash
-   (unless :member:`Solver::Options::diable_all_safety_checks` is set to ``true``).
+   (unless :member:`Solver::Options::disable_all_safety_checks` is set to ``true``).
 
    Repeated calls with the same double pointer and size but different
    :class:`LocalParameterization` is equivalent to calling
@@ -2577,7 +2577,7 @@
 
    Repeated calls with the same arguments are ignored. Repeated calls
    with the same double pointer but a different size results in a crash
-   (unless :member:`Solver::Options::diable_all_safety_checks` is set to true).
+   (unless :member:`Solver::Options::disable_all_safety_checks` is set to true).
 
    Repeated calls with the same double pointer and size but different
    :class:`Manifold` is equivalent to calling `SetManifold(manifold)`,
@@ -2680,7 +2680,7 @@
 
    It is acceptable to set the same :class:`LocalParameterization` for
    multiple parameter blocks; the Problem destructor is careful to
-   delete :class:`LocalParamaterizations` only once.
+   delete :class:`LocalParameterizations` only once.
 
 .. function:: LocalParameterization* Problem::GetParameterization(const double* values) const
 
diff --git a/docs/source/nnls_solving.rst b/docs/source/nnls_solving.rst
index a3225db..ce10a11 100644
--- a/docs/source/nnls_solving.rst
+++ b/docs/source/nnls_solving.rst
@@ -493,7 +493,7 @@
 problems. Ceres uses the sparse Cholesky factorization routines in
 Professor Tim Davis' ``SuiteSparse`` or ``CXSparse`` packages [Chen]_
 or the sparse Cholesky factorization algorithm in ``Eigen`` (which
-incidently is a port of the algorithm implemented inside ``CXSparse``)
+incidentally is a port of the algorithm implemented inside ``CXSparse``)
 
 .. _section-cgnr:
 
@@ -921,7 +921,7 @@
    Choices are ``ARMIJO`` and ``WOLFE`` (strong Wolfe conditions).
    Note that in order for the assumptions underlying the ``BFGS`` and
    ``LBFGS`` line search direction algorithms to be guaranteed to be
-   satisifed, the ``WOLFE`` line search should be used.
+   satisfied, the ``WOLFE`` line search should be used.
 
 .. member:: NonlinearConjugateGradientType Solver::Options::nonlinear_conjugate_gradient_type
 
@@ -1332,7 +1332,7 @@
    dense linear algebra library which may or may not be available.
 
    This setting affects the ``DENSE_QR``, ``DENSE_NORMAL_CHOLESKY``
-   and ``DENSE_SCHUR`` solvers. For small to moderate sized probem
+   and ``DENSE_SCHUR`` solvers. For small to moderate sized problem
    ``EIGEN`` is a fine choice but for large problems, an optimized
    ``LAPACK + BLAS`` or ``CUDA`` implementation can make a substantial
    difference in performance.
diff --git a/docs/source/numerical_derivatives.rst b/docs/source/numerical_derivatives.rst
index 57b46bf..609c84b 100644
--- a/docs/source/numerical_derivatives.rst
+++ b/docs/source/numerical_derivatives.rst
@@ -326,7 +326,7 @@
 Compared to the *correct* value :math:`Df(1.0) = 140.73773557129658`,
 :math:`A(5, 1)` has a relative error of :math:`10^{-13}`. For
 comparison, the relative error for the central difference formula with
-the same stepsize (:math:`0.01/2^4 = 0.000625`) is :math:`10^{-5}`.
+the same step size (:math:`0.01/2^4 = 0.000625`) is :math:`10^{-5}`.
 
 The above tableau is the basis of Ridders' method for numeric
 differentiation. The full implementation is an adaptive scheme that
diff --git a/examples/bal_problem.cc b/examples/bal_problem.cc
index d59bfed..99bc075 100644
--- a/examples/bal_problem.cc
+++ b/examples/bal_problem.cc
@@ -78,7 +78,7 @@
     return;
   };
 
-  // This wil die horribly on invalid files. Them's the breaks.
+  // This will die horribly on invalid files. Them's the breaks.
   FscanfOrDie(fptr, "%d", &num_cameras_);
   FscanfOrDie(fptr, "%d", &num_points_);
   FscanfOrDie(fptr, "%d", &num_observations_);
diff --git a/examples/bundle_adjuster.cc b/examples/bundle_adjuster.cc
index 5cab693..d03c2ff 100644
--- a/examples/bundle_adjuster.cc
+++ b/examples/bundle_adjuster.cc
@@ -120,7 +120,7 @@
               "perturbation.");
 DEFINE_int32(random_seed, 38401, "Random seed used to set the state "
              "of the pseudo random number generator used to generate "
-             "the pertubations.");
+             "the perturbations.");
 DEFINE_bool(line_search, false, "Use a line search instead of trust region "
             "algorithm.");
 DEFINE_bool(mixed_precision_solves, false, "Use mixed precision solves.");
@@ -298,7 +298,7 @@
     LossFunction* loss_function =
         CERES_GET_FLAG(FLAGS_robustify) ? new HuberLoss(1.0) : nullptr;
 
-    // Each observation correponds to a pair of a camera and a point
+    // Each observation corresponds to a pair of a camera and a point
     // which are identified by camera_index()[i] and point_index()[i]
     // respectively.
     double* camera =
diff --git a/examples/denoising.cc b/examples/denoising.cc
index a62b447..6cb08d1 100644
--- a/examples/denoising.cc
+++ b/examples/denoising.cc
@@ -33,7 +33,7 @@
 // Note that for good denoising results the weighting between the data term
 // and the Fields of Experts term needs to be adjusted. This is discussed
 // in [1]. This program assumes Gaussian noise. The noise model can be changed
-// by substituing another function for QuadraticCostFunction.
+// by substituting another function for QuadraticCostFunction.
 //
 // [1] S. Roth and M.J. Black. "Fields of Experts." International Journal of
 //     Computer Vision, 82(2):205--229, 2009.
diff --git a/examples/fields_of_experts.cc b/examples/fields_of_experts.cc
index 81dd937..01fa17a 100644
--- a/examples/fields_of_experts.cc
+++ b/examples/fields_of_experts.cc
@@ -28,7 +28,7 @@
 //
 // Author: strandmark@google.com (Petter Strandmark)
 //
-// Class for loading the data required for descibing a Fields of Experts (FoE)
+// Class for loading the data required for describing a Fields of Experts (FoE)
 // model.
 
 #include "fields_of_experts.h"
diff --git a/examples/fields_of_experts.h b/examples/fields_of_experts.h
index 65242a9..25e3ff1 100644
--- a/examples/fields_of_experts.h
+++ b/examples/fields_of_experts.h
@@ -28,7 +28,7 @@
 //
 // Author: strandmark@google.com (Petter Strandmark)
 //
-// Class for loading the data required for descibing a Fields of Experts (FoE)
+// Class for loading the data required for describing a Fields of Experts (FoE)
 // model. The Fields of Experts regularization consists of terms of the type
 //
 //   alpha * log(1 + (1/2)*sum(F .* X)^2),
diff --git a/examples/libmv_bundle_adjuster.cc b/examples/libmv_bundle_adjuster.cc
index 4f00406..dd36875 100644
--- a/examples/libmv_bundle_adjuster.cc
+++ b/examples/libmv_bundle_adjuster.cc
@@ -60,7 +60,7 @@
 // Image number shall be greater or equal to zero. Order of cameras does not
 // matter and gaps are possible.
 //
-// Every 3D point is decribed by:
+// Every 3D point is described by:
 //
 //  - Track number point belongs to (single 4 bytes integer value).
 //  - 3D position vector, 3-component vector of float values.
diff --git a/examples/libmv_homography.cc b/examples/libmv_homography.cc
index b795ab1..7bfcd8b 100644
--- a/examples/libmv_homography.cc
+++ b/examples/libmv_homography.cc
@@ -380,10 +380,10 @@
 
   Mat x2 = x1;
   for (int i = 0; i < x2.cols(); ++i) {
-    Vec3 homogenous_x1 = Vec3(x1(0, i), x1(1, i), 1.0);
-    Vec3 homogenous_x2 = homography_matrix * homogenous_x1;
-    x2(0, i) = homogenous_x2(0) / homogenous_x2(2);
-    x2(1, i) = homogenous_x2(1) / homogenous_x2(2);
+    Vec3 homogeneous_x1 = Vec3(x1(0, i), x1(1, i), 1.0);
+    Vec3 homogeneous_x2 = homography_matrix * homogeneous_x1;
+    x2(0, i) = homogeneous_x2(0) / homogeneous_x2(2);
+    x2(1, i) = homogeneous_x2(1) / homogeneous_x2(2);
 
     // Apply some noise so algebraic estimation is not good enough.
     x2(0, i) += static_cast<double>(rand() % 1000) / 5000.0;
diff --git a/examples/nist.cc b/examples/nist.cc
index 593feee..05c15b2 100644
--- a/examples/nist.cc
+++ b/examples/nist.cc
@@ -117,7 +117,7 @@
              "Maximum number of restarts of line search direction algorithm.");
 DEFINE_string(line_search_interpolation,
               "cubic",
-              "Degree of polynomial aproximation in line search, choices are: "
+              "Degree of polynomial approximation in line search, choices are: "
               "bisection, quadratic & cubic.");
 DEFINE_int32(lbfgs_rank,
              20,
@@ -179,7 +179,7 @@
     } else {
       const char* start = p;
       while (++p != end && *p != delim) {
-        // Skip to the next occurence of the delimiter.
+        // Skip to the next occurrence of the delimiter.
       }
       *it++ = string(start, p - start);
     }
@@ -250,7 +250,7 @@
       final_parameters_(0, parameter_id) = atof(pieces[2 + kNumTries].c_str());
     }
 
-    // Certfied cost
+    // Certified cost
     SkipLines(ifs, 1);
     GetAndSplitLine(ifs, &pieces);
     certified_cost_ = atof(pieces[4].c_str()) / 2.0;
diff --git a/examples/robot_pose_mle.cc b/examples/robot_pose_mle.cc
index 5fb4749..c199b89 100644
--- a/examples/robot_pose_mle.cc
+++ b/examples/robot_pose_mle.cc
@@ -50,7 +50,7 @@
 //
 // There are two types of residuals in this problem:
 // 1) The OdometryConstraint residual, that accounts for the odometry readings
-//    between successive pose estimatess of the robot.
+//    between successive pose estimates of the robot.
 // 2) The RangeConstraint residual, that accounts for the errors in the observed
 //    range readings from each pose.
 //
@@ -97,14 +97,14 @@
 // timesteps 0 to i for that variable, both inclusive.
 //
 // Bayes' rule is used to derive eq. 3 from 2, and the independence of
-// odometry observations and range readings is expolited to derive 4 from 3.
+// odometry observations and range readings is exploited to derive 4 from 3.
 //
 // Thus, the Belief, up to scale, is factored as a product of a number of
 // terms, two for each pose, where for each pose term there is one term for the
 // range reading, P(y_i | u*_(0:i) and one term for the odometry reading,
 // P(u*_i | u_i) . Note that the term for the range reading is dependent on all
 // odometry values u*_(0:i), while the odometry term, P(u*_i | u_i) depends only
-// on a single value, u_i. Both the range reading as well as odoemtry
+// on a single value, u_i. Both the range reading as well as odometry
 // probability terms are modeled as the Normal distribution, and have the form:
 //
 // p(x) \propto \exp{-((x - x_mean) / x_stddev)^2}
@@ -123,7 +123,7 @@
 // variable, and will be computed by an AutoDiffCostFunction, while the term
 // for the range reading will depend on all previous odometry observations, and
 // will be computed by a DynamicAutoDiffCostFunction since the number of
-// odoemtry observations will only be known at run time.
+// odometry observations will only be known at run time.
 
 #include <cmath>
 #include <cstdio>
diff --git a/examples/slam/common/read_g2o.h b/examples/slam/common/read_g2o.h
index 18c0a20..6583c6d 100644
--- a/examples/slam/common/read_g2o.h
+++ b/examples/slam/common/read_g2o.h
@@ -59,7 +59,7 @@
   return true;
 }
 
-// Reads the contraints between two vertices in the pose graph
+// Reads the constraints between two vertices in the pose graph
 template <typename Constraint, typename Allocator>
 void ReadConstraint(std::ifstream* infile,
                     std::vector<Constraint, Allocator>* constraints) {
diff --git a/include/ceres/cost_function_to_functor.h b/include/ceres/cost_function_to_functor.h
index 08a8050..127a615 100644
--- a/include/ceres/cost_function_to_functor.h
+++ b/include/ceres/cost_function_to_functor.h
@@ -120,7 +120,7 @@
     if (parameter_block_sizes.size() == num_parameter_blocks) {
       for (int block = 0; block < num_parameter_blocks; ++block) {
         CHECK_EQ(ParameterDims::GetDim(block), parameter_block_sizes[block])
-            << "Parameter block size missmatch. The specified static parameter "
+            << "Parameter block size mismatch. The specified static parameter "
                "block dimension does not match the one from the cost function.";
       }
     }
diff --git a/include/ceres/covariance.h b/include/ceres/covariance.h
index 00d00bd..612e036 100644
--- a/include/ceres/covariance.h
+++ b/include/ceres/covariance.h
@@ -280,7 +280,7 @@
     //
     //      min_sigma / max_sigma < sqrt(min_reciprocal_condition_number)
     //
-    //    where min_sigma and max_sigma are the minimum and maxiumum
+    //    where min_sigma and max_sigma are the minimum and maximum
     //    singular values of J respectively.
     //
     // 2. SPARSE_QR
diff --git a/include/ceres/cubic_interpolation.h b/include/ceres/cubic_interpolation.h
index 3ca6b11..4704bff 100644
--- a/include/ceres/cubic_interpolation.h
+++ b/include/ceres/cubic_interpolation.h
@@ -368,7 +368,7 @@
 //
 //   f001, f002, f011, f012, ...
 //
-// A commonly occuring example are color images (RGB) where the three
+// A commonly occurring example are color images (RGB) where the three
 // channels are stored interleaved.
 //
 // If kInterleaved = false, then it is stored as
diff --git a/include/ceres/gradient_problem.h b/include/ceres/gradient_problem.h
index b6a8b86..6a36bea 100644
--- a/include/ceres/gradient_problem.h
+++ b/include/ceres/gradient_problem.h
@@ -94,7 +94,7 @@
 // NOTE: We are currently in the process of transitioning from
 // LocalParameterization to Manifolds in the Ceres API. During this period,
 // GradientProblem will support using both Manifold and LocalParameterization
-// objects interchangably. For methods in the API affected by this change, see
+// objects interchangeably. For methods in the API affected by this change, see
 // their documentation below.
 class CERES_EXPORT GradientProblem {
  public:
diff --git a/include/ceres/internal/sphere_manifold_functions.h b/include/ceres/internal/sphere_manifold_functions.h
index 934d86a..f9af5ec 100644
--- a/include/ceres/internal/sphere_manifold_functions.h
+++ b/include/ceres/internal/sphere_manifold_functions.h
@@ -115,18 +115,18 @@
       AmbientSpaceDim == Eigen::Dynamic ? Eigen::Dynamic : AmbientSpaceDim - 1;
   using AmbientVector = Eigen::Matrix<double, AmbientSpaceDim, 1>;
 
-  const int tanget_size = v.size() - 1;
+  const int tangent_size = v.size() - 1;
 
   const AmbientVector hy = ApplyHouseholderVector(y, v, beta) / x.norm();
 
   // Calculate y - x. See B.2 p.25 equation (108).
-  double y_last = hy[tanget_size];
-  double hy_norm = hy.template head<TangentSpaceDim>(tanget_size).norm();
+  double y_last = hy[tangent_size];
+  double hy_norm = hy.template head<TangentSpaceDim>(tangent_size).norm();
   if (hy_norm == 0.0) {
     y_minus_x->setZero();
   } else {
     *y_minus_x = 2.0 * std::atan2(hy_norm, y_last) / hy_norm *
-                 hy.template head<TangentSpaceDim>(tanget_size);
+                 hy.template head<TangentSpaceDim>(tangent_size);
   }
 }
 
diff --git a/include/ceres/jet.h b/include/ceres/jet.h
index 3f5311b..2aefdc6 100644
--- a/include/ceres/jet.h
+++ b/include/ceres/jet.h
@@ -802,7 +802,7 @@
 inline Jet<T, N> erf(const Jet<T, N>& x) {
   // We evaluate the constant as follows:
   //   2 / sqrt(pi) = 1 / sqrt(atan(1.))
-  // On POSIX sytems it is defined as M_2_SQRTPI, but this is not
+  // On POSIX systems it is defined as M_2_SQRTPI, but this is not
   // portable and the type may not be T.  The above expression
   // evaluates to full precision with IEEE arithmetic and, since it's
   // constant, the compiler can generate exactly the same code.  gcc
diff --git a/include/ceres/problem.h b/include/ceres/problem.h
index 819fa45..cbb1dff 100644
--- a/include/ceres/problem.h
+++ b/include/ceres/problem.h
@@ -122,7 +122,7 @@
 // NOTE: We are currently in the process of transitioning from
 // LocalParameterization to Manifolds in the Ceres API. During this period,
 // Problem will support using both Manifold and LocalParameterization objects
-// interchangably. In particular, adding a LocalParameterization to a parameter
+// interchangeably. In particular, adding a LocalParameterization to a parameter
 // block is the same as adding a Manifold to that parameter block. For methods
 // in the API affected by this change, see their documentation below.
 class CERES_EXPORT Problem {
@@ -276,7 +276,7 @@
   //
   // Repeated calls with the same arguments are ignored. Repeated calls
   // with the same double pointer but a different size results in a crash
-  // (unless Solver::Options::diable_all_safety_checks is set to true).
+  // (unless Solver::Options::disable_all_safety_checks is set to true).
   //
   // Repeated calls with the same double pointer and size but different
   // LocalParameterization is equivalent to calling
@@ -308,7 +308,7 @@
   //
   // Repeated calls with the same arguments are ignored. Repeated calls
   // with the same double pointer but a different size results in a crash
-  // (unless Solver::Options::diable_all_safety_checks is set to true).
+  // (unless Solver::Options::disable_all_safety_checks is set to true).
   //
   // Repeated calls with the same double pointer and size but different Manifold
   // is equivalent to calling SetManifold(manifold), i.e., any previously
@@ -377,7 +377,7 @@
   //
   // It is acceptable to set the same LocalParameterization for multiple
   // parameter blocks; the destructor is careful to delete
-  // LocalParamaterizations only once.
+  // LocalParameterizations only once.
   //
   // NOTE:
   // ----
@@ -493,7 +493,7 @@
       "instead.")
   int ParameterBlockLocalSize(const double* values) const;
 
-  // The dimenion of the tangent space of the LocalParameterization or Manifold
+  // The dimension of the tangent space of the LocalParameterization or Manifold
   // for the parameter block. If there is no LocalParameterization or Manifold
   // associated with this parameter block, then ParameterBlockTangentSize =
   // ParameterBlockSize.
diff --git a/include/ceres/rotation.h b/include/ceres/rotation.h
index 5107990..8cdd3fc 100644
--- a/include/ceres/rotation.h
+++ b/include/ceres/rotation.h
@@ -60,7 +60,7 @@
 //
 // the expression  M(i, j) is equivalent to
 //
-//   arrary[i * row_stride + j * col_stride]
+//   array[i * row_stride + j * col_stride]
 //
 // Conversion functions to and from rotation matrices accept
 // MatrixAdapters to permit using row-major and column-major layouts,
diff --git a/include/ceres/tiny_solver_autodiff_function.h b/include/ceres/tiny_solver_autodiff_function.h
index 3e3675f..b961295 100644
--- a/include/ceres/tiny_solver_autodiff_function.h
+++ b/include/ceres/tiny_solver_autodiff_function.h
@@ -171,7 +171,7 @@
   const CostFunctor& cost_functor_;
 
   // The number of residuals at runtime.
-  // This will be overriden if NUM_RESIDUALS == Eigen::Dynamic.
+  // This will be overridden if NUM_RESIDUALS == Eigen::Dynamic.
   int num_residuals_ = kNumResiduals;
 
   // To evaluate the cost function with jets, temporary storage is needed. These
diff --git a/internal/ceres/accelerate_sparse.cc b/internal/ceres/accelerate_sparse.cc
index 74adfaf..53ba3a0 100644
--- a/internal/ceres/accelerate_sparse.cc
+++ b/internal/ceres/accelerate_sparse.cc
@@ -61,7 +61,7 @@
     CASESTR(SparseParameterError);
     CASESTR(SparseStatusReleased);
     default:
-      return "UKNOWN";
+      return "UNKNOWN";
   }
 }
 }  // namespace.
diff --git a/internal/ceres/block_jacobian_writer.h b/internal/ceres/block_jacobian_writer.h
index 4ed0e66..00dcb36 100644
--- a/internal/ceres/block_jacobian_writer.h
+++ b/internal/ceres/block_jacobian_writer.h
@@ -50,7 +50,7 @@
 class Program;
 class SparseMatrix;
 
-// TODO(sameeragarwal): This class needs documemtation.
+// TODO(sameeragarwal): This class needs documentation.
 class CERES_NO_EXPORT BlockJacobianWriter {
  public:
   BlockJacobianWriter(const Evaluator::Options& options, Program* program);
diff --git a/internal/ceres/compressed_row_sparse_matrix.cc b/internal/ceres/compressed_row_sparse_matrix.cc
index 7a08c6f..40f8d14 100644
--- a/internal/ceres/compressed_row_sparse_matrix.cc
+++ b/internal/ceres/compressed_row_sparse_matrix.cc
@@ -48,7 +48,7 @@
 namespace {
 
 // Helper functor used by the constructor for reordering the contents
-// of a TripletSparseMatrix. This comparator assumes thay there are no
+// of a TripletSparseMatrix. This comparator assumes that there are no
 // duplicates in the pair of arrays rows and cols, i.e., there is no
 // indices i and j (not equal to each other) s.t.
 //
diff --git a/internal/ceres/compressed_row_sparse_matrix.h b/internal/ceres/compressed_row_sparse_matrix.h
index 3d7d385..522734c 100644
--- a/internal/ceres/compressed_row_sparse_matrix.h
+++ b/internal/ceres/compressed_row_sparse_matrix.h
@@ -165,7 +165,7 @@
   // given bounds.
   //
   // Then we walk the block structure of the resulting matrix, and with
-  // probability block_density detemine whether they are structurally
+  // probability block_density determine whether they are structurally
   // zero or not. If the answer is no, then we generate entries for the
   // block which are distributed normally.
   struct RandomMatrixOptions {
@@ -209,7 +209,7 @@
   StorageType storage_type_;
 
   // If the matrix has an underlying block structure, then it can also
-  // carry with it row and column block sizes. This is auxilliary and
+  // carry with it row and column block sizes. This is auxiliary and
   // optional information for use by algorithms operating on the
   // matrix. The class itself does not make use of this information in
   // any way.
diff --git a/internal/ceres/conjugate_gradients_solver.h b/internal/ceres/conjugate_gradients_solver.h
index 1ea9646..c5efac7 100644
--- a/internal/ceres/conjugate_gradients_solver.h
+++ b/internal/ceres/conjugate_gradients_solver.h
@@ -43,8 +43,8 @@
 class LinearOperator;
 
 // This class implements the now classical Conjugate Gradients
-// algorithm of Hestenes & Stiefel for solving postive semidefinite
-// linear sytems. Optionally it can use a preconditioner also to
+// algorithm of Hestenes & Stiefel for solving positive semidefinite
+// linear systems. Optionally it can use a preconditioner also to
 // reduce the condition number of the linear system and improve the
 // convergence rate. Modern references for Conjugate Gradients are the
 // books by Yousef Saad and Trefethen & Bau. This implementation of CG
diff --git a/internal/ceres/covariance_impl.cc b/internal/ceres/covariance_impl.cc
index 9e1bfaa..15a454f 100644
--- a/internal/ceres/covariance_impl.cc
+++ b/internal/ceres/covariance_impl.cc
@@ -189,7 +189,7 @@
   const int* cols_begin = cols + rows[row_begin];
 
   // The only part that requires work is walking the compressed column
-  // vector to determine where the set of columns correspnding to the
+  // vector to determine where the set of columns corresponding to the
   // covariance block begin.
   int offset = 0;
   while (cols_begin[offset] != col_begin && offset < row_size) {
diff --git a/internal/ceres/covariance_test.cc b/internal/ceres/covariance_test.cc
index 84afced..ad9fe0a 100644
--- a/internal/ceres/covariance_test.cc
+++ b/internal/ceres/covariance_test.cc
@@ -1161,7 +1161,7 @@
   //  -15 -18  3   6  13  0
   //    6  -4  0   0   0 29
 
-  // 3.4142 is the smallest eigen value of J'J. The following matrix
+  // 3.4142 is the smallest eigenvalue of J'J. The following matrix
   // was obtained by dropping the eigenvector corresponding to this
   // eigenvalue.
   // clang-format off
diff --git a/internal/ceres/dense_cholesky.cc b/internal/ceres/dense_cholesky.cc
index dec0de1..bd20e8c 100644
--- a/internal/ceres/dense_cholesky.cc
+++ b/internal/ceres/dense_cholesky.cc
@@ -268,7 +268,7 @@
                                                      double* solution,
                                                      std::string* message) {
   if (factorize_result_ != LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS) {
-    *message = "Factorize did not complete succesfully previously.";
+    *message = "Factorize did not complete successfully previously.";
     return factorize_result_;
   }
   rhs_.CopyToGpuAsync(rhs, num_cols_, stream_);
diff --git a/internal/ceres/dense_cholesky.h b/internal/ceres/dense_cholesky.h
index 5866d38..d561079 100644
--- a/internal/ceres/dense_cholesky.h
+++ b/internal/ceres/dense_cholesky.h
@@ -170,7 +170,7 @@
   // Required for error handling with cuSOLVER.
   CudaBuffer<int> error_;
   // Cache the result of Factorize to ensure that when Solve is called, the
-  // factiorization of lhs is valid.
+  // factorization of lhs is valid.
   LinearSolverTerminationType factorize_result_ = LINEAR_SOLVER_FATAL_ERROR;
 };
 
diff --git a/internal/ceres/dense_qr.cc b/internal/ceres/dense_qr.cc
index 8d02368..b2d9bb8 100644
--- a/internal/ceres/dense_qr.cc
+++ b/internal/ceres/dense_qr.cc
@@ -98,7 +98,7 @@
 // a is a column major lda x n.
 // b is a column major matrix of ldb x nrhs
 //
-// info = 0 succesful.
+// info = 0 successful.
 //      = -i < 0 i^th argument is an illegal value.
 //      = i > 0, i^th diagonal element of A is zero.
 extern "C" void dtrtrs_(const char* uplo, const char* trans, const char* diag,
@@ -382,7 +382,7 @@
                                                double* solution,
                                                std::string* message) {
   if (factorize_result_ != LinearSolverTerminationType::LINEAR_SOLVER_SUCCESS) {
-    *message = "Factorize did not complete succesfully previously.";
+    *message = "Factorize did not complete successfully previously.";
     return factorize_result_;
   }
   rhs_.CopyToGpuAsync(rhs, num_rows_, stream_);
diff --git a/internal/ceres/dynamic_compressed_row_finalizer.h b/internal/ceres/dynamic_compressed_row_finalizer.h
index ebb3839..56e81ee 100644
--- a/internal/ceres/dynamic_compressed_row_finalizer.h
+++ b/internal/ceres/dynamic_compressed_row_finalizer.h
@@ -28,8 +28,8 @@
 //
 // Author: richie.stebbing@gmail.com (Richard Stebbing)
 
-#ifndef CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALIZER_H_
-#define CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALIZER_H_
+#ifndef CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_FINALIZER_H_
+#define CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_FINALIZER_H_
 
 #include "ceres/casts.h"
 #include "ceres/dynamic_compressed_row_sparse_matrix.h"
@@ -47,4 +47,4 @@
 
 }  // namespace ceres::internal
 
-#endif  // CERES_INTERNAL_DYNAMIC_COMPRESED_ROW_FINALISER_H_
+#endif  // CERES_INTERNAL_DYNAMIC_COMPRESSED_ROW_FINALISER_H_
diff --git a/internal/ceres/dynamic_compressed_row_jacobian_writer.h b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
index 42ac05b..010d5ee 100644
--- a/internal/ceres/dynamic_compressed_row_jacobian_writer.h
+++ b/internal/ceres/dynamic_compressed_row_jacobian_writer.h
@@ -67,7 +67,7 @@
 
   // Write only the non-zero jacobian entries for a residual block
   // (specified by `residual_id`) into `base_jacobian`, starting at the row
-  // specifed by `residual_offset`.
+  // specified by `residual_offset`.
   //
   // This method is thread-safe over residual blocks (each `residual_id`).
   void Write(int residual_id,
diff --git a/internal/ceres/dynamic_compressed_row_sparse_matrix.h b/internal/ceres/dynamic_compressed_row_sparse_matrix.h
index 0094f7e..65a309d 100644
--- a/internal/ceres/dynamic_compressed_row_sparse_matrix.h
+++ b/internal/ceres/dynamic_compressed_row_sparse_matrix.h
@@ -52,7 +52,7 @@
 class CERES_NO_EXPORT DynamicCompressedRowSparseMatrix final
     : public CompressedRowSparseMatrix {
  public:
-  // Set the number of rows and columns for the underlyig
+  // Set the number of rows and columns for the underlying
   // `CompressedRowSparseMatrix` and set the initial number of maximum non-zero
   // entries. Note that following the insertion of entries, when `Finalize`
   // is called the number of non-zeros is determined and all internal
@@ -73,7 +73,7 @@
 
   // Insert an entry at a given row and column position. This method is
   // thread-safe across rows i.e. different threads can insert values
-  // simultaneously into different rows. It should be emphasised that this
+  // simultaneously into different rows. It should be emphasized that this
   // method always inserts a new entry and does not check for existing
   // entries at the specified row and column position. Duplicate entries
   // for a given row and column position will result in undefined
diff --git a/internal/ceres/function_sample.h b/internal/ceres/function_sample.h
index 85074c2..ce3bc06 100644
--- a/internal/ceres/function_sample.h
+++ b/internal/ceres/function_sample.h
@@ -82,7 +82,7 @@
   //
   // where d is the search direction.
   double gradient;
-  // True if the evaluation of the gradient was sucessful and the
+  // True if the evaluation of the gradient was successful and the
   // value is a finite number.
   bool gradient_is_valid;
 };
diff --git a/internal/ceres/gradient_checker_test.cc b/internal/ceres/gradient_checker_test.cc
index 208a0a7..fcc4892 100644
--- a/internal/ceres/gradient_checker_test.cc
+++ b/internal/ceres/gradient_checker_test.cc
@@ -331,7 +331,7 @@
   }
 
   /// Add offset to the given Jacobian before returning it from Evaluate(),
-  /// thus introducing an error in the comutation.
+  /// 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());
diff --git a/internal/ceres/gradient_problem_test.cc b/internal/ceres/gradient_problem_test.cc
index a3d18e7..123ec75 100644
--- a/internal/ceres/gradient_problem_test.cc
+++ b/internal/ceres/gradient_problem_test.cc
@@ -76,7 +76,7 @@
   EXPECT_EQ(x * x, cost);
 }
 
-TEST(GradientProblem, EvalutaionWithParameterizationAndNoGradient) {
+TEST(GradientProblem, EvaluationWithParameterizationAndNoGradient) {
   ceres::GradientProblem problem(new QuadraticTestFunction(),
                                  new IdentityParameterization(1));
   double x = 7.0;
@@ -104,7 +104,7 @@
   EXPECT_EQ(2.0 * x, gradient);
 }
 
-TEST(GradientProblem, EvalutaionWithManifoldAndNoGradient) {
+TEST(GradientProblem, EvaluationWithManifoldAndNoGradient) {
   ceres::GradientProblem problem(new QuadraticTestFunction(),
                                  new EuclideanManifold<1>);
   double x = 7.0;
diff --git a/internal/ceres/implicit_schur_complement.h b/internal/ceres/implicit_schur_complement.h
index 601f2e6..75e05a4 100644
--- a/internal/ceres/implicit_schur_complement.h
+++ b/internal/ceres/implicit_schur_complement.h
@@ -81,10 +81,10 @@
 // (which for our purposes is an easily inverted block diagonal
 // matrix), it can be done in terms of matrix vector products with E,
 // F and (E'E)^-1. This class implements this functionality and other
-// auxilliary bits needed to implement a CG solver on the Schur
+// auxiliary bits needed to implement a CG solver on the Schur
 // complement using the PartitionedMatrixView object.
 //
-// THREAD SAFETY: This class is nqot thread safe. In particular, the
+// THREAD SAFETY: This class is not thread safe. In particular, the
 // RightMultiply (and the LeftMultiply) methods are not thread safe as
 // they depend on mutable arrays used for the temporaries needed to
 // compute the product y += Sx;
diff --git a/internal/ceres/inner_product_computer.cc b/internal/ceres/inner_product_computer.cc
index 1500817..6660b38 100644
--- a/internal/ceres/inner_product_computer.cc
+++ b/internal/ceres/inner_product_computer.cc
@@ -263,7 +263,7 @@
     if (previous->row == current->row) {
       // if the current and previous terms are in the same row block,
       // then they differ in the column block, in which case advance
-      // col_nnz by the column size of the prevous term.
+      // col_nnz by the column size of the previous term.
       col_nnz += col_blocks[previous->col].size;
     } else {
       // If we have moved to a new row-block , then col_nnz is zero,
diff --git a/internal/ceres/invert_psd_matrix_benchmark.cc b/internal/ceres/invert_psd_matrix_benchmark.cc
index 017d331..eb8deb1 100644
--- a/internal/ceres/invert_psd_matrix_benchmark.cc
+++ b/internal/ceres/invert_psd_matrix_benchmark.cc
@@ -9,7 +9,7 @@
 //   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 materils provided with the distribution.
+//   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.
diff --git a/internal/ceres/iterative_schur_complement_solver.h b/internal/ceres/iterative_schur_complement_solver.h
index c39a94e..ea54d8e 100644
--- a/internal/ceres/iterative_schur_complement_solver.h
+++ b/internal/ceres/iterative_schur_complement_solver.h
@@ -52,7 +52,7 @@
 // The algorithm used by this solver was developed in a series of
 // papers - "Agarwal et al, Bundle Adjustment in the Large, ECCV 2010"
 // and "Wu et al, Multicore Bundle Adjustment, submitted to CVPR
-// 2011" at the Univeristy of Washington.
+// 2011" at the University of Washington.
 //
 // The key idea is that one can run Conjugate Gradients on the Schur
 // Complement system without explicitly forming the Schur Complement
diff --git a/internal/ceres/jet_test.cc b/internal/ceres/jet_test.cc
index fe9dbf3..1c85d01 100644
--- a/internal/ceres/jet_test.cc
+++ b/internal/ceres/jet_test.cc
@@ -378,7 +378,7 @@
     J x = MakeJet(1e-16, 1e-8, 1e-4);
     EXPECT_THAT(log1p(x),
                 IsAlmostEqualTo(MakeJet(9.9999999999999998e-17, 1e-8, 1e-4)));
-    // log(1 + x) collapes to 0
+    // log(1 + x) collapses to 0
     J v = log(J{1} + x);
     EXPECT_TRUE(v.a == 0);
   }
@@ -391,7 +391,7 @@
   {  // expm1(x) does not loose precision for small x
     J x = MakeJet(9.9999999999999998e-17, 1e-8, 1e-4);
     EXPECT_THAT(expm1(x), IsAlmostEqualTo(MakeJet(1e-16, 1e-8, 1e-4)));
-    // exp(x) - 1 collapes to 0
+    // exp(x) - 1 collapses to 0
     J v = exp(x) - J{1};
     EXPECT_TRUE(v.a == 0);
   }
diff --git a/internal/ceres/line_search.cc b/internal/ceres/line_search.cc
index 7bd9c85..68d6bbe 100644
--- a/internal/ceres/line_search.cc
+++ b/internal/ceres/line_search.cc
@@ -426,7 +426,7 @@
     // shrank the bracket width until it was below our minimum tolerance.
     // As these are 'artificial' constraints, and we would otherwise fail to
     // produce a valid point when ArmijoLineSearch would succeed, we return the
-    // point with the lowest cost found thus far which satsifies the Armijo
+    // point with the lowest cost found thus far which satisfies the Armijo
     // condition (but not the Wolfe conditions).
     summary->optimal_point = bracket_low;
     summary->success = true;
@@ -448,8 +448,8 @@
   // defined by bracket_low & bracket_high, which satisfy:
   //
   //   1. The interval bounded by step sizes: bracket_low.x & bracket_high.x
-  //      contains step sizes that satsify the strong Wolfe conditions.
-  //   2. bracket_low.x is of all the step sizes evaluated *which satisifed the
+  //      contains step sizes that satisfy the strong Wolfe conditions.
+  //   2. bracket_low.x is of all the step sizes evaluated *which satisfied the
   //      Armijo sufficient decrease condition*, the one which generated the
   //      smallest function value, i.e. bracket_low.value <
   //      f(all other steps satisfying Armijo).
@@ -493,7 +493,7 @@
 // Or, searching was stopped due to an 'artificial' constraint, i.e. not
 // a condition imposed / required by the underlying algorithm, but instead an
 // engineering / implementation consideration. But a step which exceeds the
-// minimum step size, and satsifies the Armijo condition was still found,
+// minimum step size, and satisfies the Armijo condition was still found,
 // and should thus be used [zoom not required].
 //
 // Returns false if no step size > minimum step size was found which
@@ -517,7 +517,7 @@
   // As we require the gradient to evaluate the Wolfe condition, we always
   // calculate it together with the value, irrespective of the interpolation
   // type.  As opposed to only calculating the gradient after the Armijo
-  // condition is satisifed, as the computational saving from this approach
+  // condition is satisfied, as the computational saving from this approach
   // would be slight (perhaps even negative due to the extra call).  Also,
   // always calculating the value & gradient together protects against us
   // reporting invalid solutions if the cost function returns slightly different
@@ -820,7 +820,7 @@
     // As we require the gradient to evaluate the Wolfe condition, we always
     // calculate it together with the value, irrespective of the interpolation
     // type.  As opposed to only calculating the gradient after the Armijo
-    // condition is satisifed, as the computational saving from this approach
+    // condition is satisfied, as the computational saving from this approach
     // would be slight (perhaps even negative due to the extra call).  Also,
     // always calculating the value & gradient together protects against us
     // reporting invalid solutions if the cost function returns slightly
diff --git a/internal/ceres/line_search_direction.cc b/internal/ceres/line_search_direction.cc
index ae77065..e93d3e9 100644
--- a/internal/ceres/line_search_direction.cc
+++ b/internal/ceres/line_search_direction.cc
@@ -241,7 +241,7 @@
         //
         // The original origin of this rescaling trick is somewhat unclear, the
         // earliest reference appears to be Oren [1], however it is widely
-        // discussed without specific attributation in various texts including
+        // discussed without specific attribution in various texts including
         // [2] (p143).
         //
         // [1] Oren S.S., Self-scaling variable metric (SSVM) algorithms
diff --git a/internal/ceres/line_search_minimizer.cc b/internal/ceres/line_search_minimizer.cc
index b3b2d19..a75de18 100644
--- a/internal/ceres/line_search_minimizer.cc
+++ b/internal/ceres/line_search_minimizer.cc
@@ -30,7 +30,7 @@
 //
 // Generic loop for line search based optimization algorithms.
 //
-// This is primarily inpsired by the minFunc packaged written by Mark
+// This is primarily inspired by the minFunc packaged written by Mark
 // Schmidt.
 //
 // http://www.di.ens.fr/~mschmidt/Software/minFunc.html
diff --git a/internal/ceres/linear_solver.h b/internal/ceres/linear_solver.h
index d8f3646..b07f53d 100644
--- a/internal/ceres/linear_solver.h
+++ b/internal/ceres/linear_solver.h
@@ -328,7 +328,7 @@
   ExecutionSummary execution_summary_;
 };
 
-// Linear solvers that depend on acccess to the low level structure of
+// Linear solvers that depend on access to the low level structure of
 // a SparseMatrix.
 // clang-format off
 typedef TypedLinearSolver<BlockSparseMatrix>         BlockSparseMatrixSolver;          // NOLINT
diff --git a/internal/ceres/local_parameterization_test.cc b/internal/ceres/local_parameterization_test.cc
index 38dbe2b..cf54758 100644
--- a/internal/ceres/local_parameterization_test.cc
+++ b/internal/ceres/local_parameterization_test.cc
@@ -603,19 +603,19 @@
   bool operator()(const Scalar* p_x,
                   const Scalar* p_delta,
                   Scalar* p_x_plus_delta) const {
-    static constexpr int kTangetSpaceDim = AmbientSpaceDim - 1;
+    static constexpr int kTangentSpaceDim = AmbientSpaceDim - 1;
     Eigen::Map<const Eigen::Matrix<Scalar, AmbientSpaceDim, 1>> origin_point(
         p_x);
     Eigen::Map<const Eigen::Matrix<Scalar, AmbientSpaceDim, 1>> dir(
         p_x + AmbientSpaceDim);
-    Eigen::Map<const Eigen::Matrix<Scalar, kTangetSpaceDim, 1>>
+    Eigen::Map<const Eigen::Matrix<Scalar, kTangentSpaceDim, 1>>
         delta_origin_point(p_delta);
     Eigen::Map<Eigen::Matrix<Scalar, AmbientSpaceDim, 1>>
         origin_point_plus_delta(p_x_plus_delta);
 
     HomogeneousVectorParameterizationPlus<AmbientSpaceDim> dir_plus;
     dir_plus(dir.data(),
-             p_delta + kTangetSpaceDim,
+             p_delta + kTangentSpaceDim,
              p_x_plus_delta + AmbientSpaceDim);
 
     Eigen::Matrix<Scalar, AmbientSpaceDim, 1> v;
diff --git a/internal/ceres/low_rank_inverse_hessian.cc b/internal/ceres/low_rank_inverse_hessian.cc
index 3e2368f..42827e2 100644
--- a/internal/ceres/low_rank_inverse_hessian.cc
+++ b/internal/ceres/low_rank_inverse_hessian.cc
@@ -158,7 +158,7 @@
     //
     // The original origin of this rescaling trick is somewhat unclear, the
     // earliest reference appears to be Oren [1], however it is widely discussed
-    // without specific attributation in various texts including [2] (p143/178).
+    // without specific attribution in various texts including [2] (p143/178).
     //
     // [1] Oren S.S., Self-scaling variable metric (SSVM) algorithms Part II:
     //     Implementation and experiments, Management Science,
diff --git a/internal/ceres/normal_prior.cc b/internal/ceres/normal_prior.cc
index abefb5b..00d2f60 100644
--- a/internal/ceres/normal_prior.cc
+++ b/internal/ceres/normal_prior.cc
@@ -55,7 +55,7 @@
   VectorRef r(residuals, num_residuals());
   // The following line should read
   // r = A_ * (p - b_);
-  // The extra eval is to get around a bug in the eigen library.
+  // The extra eval is to get around a bug in the Eigen library.
   r = A_ * (p - b_).eval();
   if ((jacobians != nullptr) && (jacobians[0] != nullptr)) {
     MatrixRef(jacobians[0], num_residuals(), parameter_block_sizes()[0]) = A_;
diff --git a/internal/ceres/parallel_for_cxx.cc b/internal/ceres/parallel_for_cxx.cc
index f4fd415..df2f619 100644
--- a/internal/ceres/parallel_for_cxx.cc
+++ b/internal/ceres/parallel_for_cxx.cc
@@ -158,8 +158,8 @@
 // it on every iteration of the for loop. The thread ID is guaranteed to be in
 // [0, num_threads).
 //
-// A performance analysis has shown this implementation is onpar with OpenMP and
-// TBB.
+// A performance analysis has shown this implementation is on par with OpenMP
+// and TBB.
 void ParallelFor(ContextImpl* context,
                  int start,
                  int end,
diff --git a/internal/ceres/parameter_block_ordering.h b/internal/ceres/parameter_block_ordering.h
index 166fadc..f73ef2c 100644
--- a/internal/ceres/parameter_block_ordering.h
+++ b/internal/ceres/parameter_block_ordering.h
@@ -46,8 +46,8 @@
 class ParameterBlock;
 
 // Uses an approximate independent set ordering to order the parameter
-// blocks of a problem so that it is suitable for use with Schur
-// complement based solvers. The output variable ordering contains an
+// blocks of a problem so that it is suitable for use with Schur-
+// complement-based solvers. The output variable ordering contains an
 // ordering of the parameter blocks and the return value is size of
 // the independent set or the number of e_blocks (see
 // schur_complement_solver.h for an explanation). Constant parameters
diff --git a/internal/ceres/reorder_program.cc b/internal/ceres/reorder_program.cc
index 4e75c3f..a4f7c35 100644
--- a/internal/ceres/reorder_program.cc
+++ b/internal/ceres/reorder_program.cc
@@ -288,7 +288,7 @@
   // of the bucket. The filling order among the buckets is dictated by the
   // residual blocks. This loop uses the offsets as counters; subtracting one
   // from each offset as a residual block is placed in the bucket. When the
-  // filling is finished, the offset pointerts should have shifted down one
+  // filling is finished, the offset pointers should have shifted down one
   // entry (this is verified below).
   vector<ResidualBlock*> reordered_residual_blocks(
       (*residual_blocks).size(), static_cast<ResidualBlock*>(nullptr));
@@ -325,7 +325,7 @@
   return true;
 }
 
-// Pre-order the columns corresponding to the schur complement if
+// Pre-order the columns corresponding to the Schur complement if
 // possible.
 static void MaybeReorderSchurComplementColumnsUsingSuiteSparse(
     const ParameterBlockOrdering& parameter_block_ordering, Program* program) {
diff --git a/internal/ceres/reorder_program_test.cc b/internal/ceres/reorder_program_test.cc
index 828aa25..0fbab4e 100644
--- a/internal/ceres/reorder_program_test.cc
+++ b/internal/ceres/reorder_program_test.cc
@@ -165,7 +165,7 @@
 }
 
 #ifndef CERES_NO_SUITESPARSE
-class ReorderProgramFoSparseCholeskyUsingSuiteSparseTest
+class ReorderProgramForSparseCholeskyUsingSuiteSparseTest
     : public ::testing::Test {
  protected:
   void SetUp() override {
@@ -204,7 +204,7 @@
   double z_;
 };
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
+TEST_F(ReorderProgramForSparseCholeskyUsingSuiteSparseTest,
        EverythingInGroupZero) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 0);
@@ -214,7 +214,7 @@
   ComputeAndValidateOrdering(linear_solver_ordering);
 }
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, ContiguousGroups) {
+TEST_F(ReorderProgramForSparseCholeskyUsingSuiteSparseTest, ContiguousGroups) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 0);
   linear_solver_ordering.AddElementToGroup(&y_, 1);
@@ -223,7 +223,7 @@
   ComputeAndValidateOrdering(linear_solver_ordering);
 }
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest, GroupsWithGaps) {
+TEST_F(ReorderProgramForSparseCholeskyUsingSuiteSparseTest, GroupsWithGaps) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 0);
   linear_solver_ordering.AddElementToGroup(&y_, 2);
@@ -232,7 +232,7 @@
   ComputeAndValidateOrdering(linear_solver_ordering);
 }
 
-TEST_F(ReorderProgramFoSparseCholeskyUsingSuiteSparseTest,
+TEST_F(ReorderProgramForSparseCholeskyUsingSuiteSparseTest,
        NonContiguousStartingAtTwo) {
   ParameterBlockOrdering linear_solver_ordering;
   linear_solver_ordering.AddElementToGroup(&x_, 2);
diff --git a/internal/ceres/residual_block_test.cc b/internal/ceres/residual_block_test.cc
index 2864ee1..8f99b23 100644
--- a/internal/ceres/residual_block_test.cc
+++ b/internal/ceres/residual_block_test.cc
@@ -74,7 +74,7 @@
   }
 };
 
-TEST(ResidualBlock, EvaluteWithNoLossFunctionOrManifolds) {
+TEST(ResidualBlock, EvaluateWithNoLossFunctionOrManifolds) {
   double scratch[64];
 
   // Prepare the parameter blocks.
@@ -199,7 +199,7 @@
   }
 };
 
-TEST(ResidualBlock, EvaluteWithManifolds) {
+TEST(ResidualBlock, EvaluateWithManifolds) {
   double scratch[64];
 
   // Prepare the parameter blocks.
diff --git a/internal/ceres/residual_block_utils_test.cc b/internal/ceres/residual_block_utils_test.cc
index 2254619..54c23b8 100644
--- a/internal/ceres/residual_block_utils_test.cc
+++ b/internal/ceres/residual_block_utils_test.cc
@@ -66,7 +66,7 @@
             is_good);
 }
 
-// A CostFunction that behaves normaly, i.e., it computes numerically
+// A CostFunction that behaves normally, i.e., it computes numerically
 // valid residuals and jacobians.
 class GoodCostFunction : public SizedCostFunction<1, 1> {
  public:
diff --git a/internal/ceres/schur_complement_solver.h b/internal/ceres/schur_complement_solver.h
index 0d069eb..cbccc75 100644
--- a/internal/ceres/schur_complement_solver.h
+++ b/internal/ceres/schur_complement_solver.h
@@ -65,7 +65,7 @@
 //
 //  E y + F z = b
 //
-// Where x = [y;z] is a partition of the variables.  The paritioning
+// Where x = [y;z] is a partition of the variables.  The partitioning
 // of the variables is such that, E'E is a block diagonal
 // matrix. Further, the rows of A are ordered so that for every
 // variable block in y, all the rows containing that variable block
diff --git a/internal/ceres/schur_eliminator.h b/internal/ceres/schur_eliminator.h
index 75be5ae..87cc5a8 100644
--- a/internal/ceres/schur_eliminator.h
+++ b/internal/ceres/schur_eliminator.h
@@ -168,9 +168,9 @@
  public:
   virtual ~SchurEliminatorBase();
 
-  // Initialize the eliminator. It is the user's responsibilty to call
+  // Initialize the eliminator. It is the user's responsibility to call
   // this function before calling Eliminate or BackSubstitute. It is
-  // also the caller's responsibilty to ensure that the
+  // also the caller's responsibility to ensure that the
   // CompressedRowBlockStructure object passed to this method is the
   // same one (or is equivalent to) the one associated with the
   // BlockSparseMatrix objects below.
@@ -446,7 +446,7 @@
     const CompressedRowBlockStructure* bs = A.block_structure();
     const double* values = A.values();
 
-    // Add the diagonal to the schur complement.
+    // Add the diagonal to the Schur complement.
     if (D != nullptr) {
       typename EigenTypes<kFBlockSize>::ConstVectorRef diag(
           D + bs->cols[num_eliminate_blocks_].position, kFBlockSize);
@@ -478,7 +478,7 @@
       const Chunk& chunk = chunks_[i];
       const int e_block_id = bs->rows[chunk.start].cells.front().block_id;
 
-      // Naming covention, e_t_e = e_block.transpose() * e_block;
+      // Naming convention, e_t_e = e_block.transpose() * e_block;
       Eigen::Matrix<double, kEBlockSize, kEBlockSize> e_t_e;
       Eigen::Matrix<double, kEBlockSize, kFBlockSize> e_t_f;
       Eigen::Matrix<double, kEBlockSize, 1> e_t_b;
diff --git a/internal/ceres/schur_eliminator_impl.h b/internal/ceres/schur_eliminator_impl.h
index 9ad0ebd..62b7487 100644
--- a/internal/ceres/schur_eliminator_impl.h
+++ b/internal/ceres/schur_eliminator_impl.h
@@ -106,7 +106,7 @@
   }
 
   // TODO(sameeragarwal): Now that we may have subset block structure,
-  // we need to make sure that we account for the fact that somep
+  // we need to make sure that we account for the fact that some
   // point blocks only have a "diagonal" row and nothing more.
   //
   // This likely requires a slightly different algorithm, which works
@@ -300,7 +300,7 @@
             thread_id, bs, inverse_ete, buffer, chunk.buffer_layout, lhs);
       });
 
-  // For rows with no e_blocks, the schur complement update reduces to
+  // For rows with no e_blocks, the Schur complement update reduces to
   // S += F'F.
   NoEBlockRowsUpdate(A, b, uneliminated_row_begins_, lhs, rhs);
 }
@@ -432,7 +432,7 @@
 //
 //   ete = y11 * y11' + y12 * y12'
 //
-// and the off diagonal blocks in the Guass Newton Hessian.
+// and the off diagonal blocks in the Gauss Newton Hessian.
 //
 //   buffer = [y11'(z11 + z12), y12' * z22, y11' * z51]
 //
@@ -562,7 +562,7 @@
   }
 }
 
-// For rows with no e_blocks, the schur complement update reduces to S
+// For rows with no e_blocks, the Schur complement update reduces to S
 // += F'F. This function iterates over the rows of A with no e_block,
 // and calls NoEBlockRowOuterProduct on each row.
 template <int kRowBlockSize, int kEBlockSize, int kFBlockSize>
@@ -595,7 +595,7 @@
 }
 
 // A row r of A, which has no e_blocks gets added to the Schur
-// Complement as S += r r'. This function is responsible for computing
+// complement as S += r r'. This function is responsible for computing
 // the contribution of a single row r to the Schur complement. It is
 // very similar in structure to EBlockRowOuterProduct except for
 // one difference. It does not use any of the template
diff --git a/internal/ceres/small_blas_test.cc b/internal/ceres/small_blas_test.cc
index 78fc3c3..6fa30a5 100644
--- a/internal/ceres/small_blas_test.cc
+++ b/internal/ceres/small_blas_test.cc
@@ -103,7 +103,7 @@
 
 #undef MATRIX_FUN_TY
 
-// Initializes matrix entires.
+// Initializes matrix entries.
 static void initMatrix(Matrix& mat) {
   for (int i = 0; i < mat.rows(); ++i) {
     for (int j = 0; j < mat.cols(); ++j) {
diff --git a/internal/ceres/suitesparse.cc b/internal/ceres/suitesparse.cc
index bac5327..06b4379 100644
--- a/internal/ceres/suitesparse.cc
+++ b/internal/ceres/suitesparse.cc
@@ -228,7 +228,7 @@
   const int num_col_blocks = col_blocks.size();
 
   // Arrays storing the compressed column structure of the matrix
-  // incoding the block sparsity of A.
+  // encoding the block sparsity of A.
   vector<int> block_cols;
   vector<int> block_rows;
 
diff --git a/internal/ceres/suitesparse.h b/internal/ceres/suitesparse.h
index f7bf3b1..816d2f1 100644
--- a/internal/ceres/suitesparse.h
+++ b/internal/ceres/suitesparse.h
@@ -90,7 +90,7 @@
 
   // Functions for building cholmod_sparse objects from sparse
   // matrices stored in triplet form. The matrix A is not
-  // modifed. Called owns the result.
+  // modified. Called owns the result.
   cholmod_sparse* CreateSparseMatrix(TripletSparseMatrix* A);
 
   // This function works like CreateSparseMatrix, except that the
diff --git a/internal/ceres/trust_region_preprocessor_test.cc b/internal/ceres/trust_region_preprocessor_test.cc
index 5938502..fd329a9 100644
--- a/internal/ceres/trust_region_preprocessor_test.cc
+++ b/internal/ceres/trust_region_preprocessor_test.cc
@@ -73,7 +73,7 @@
   EXPECT_FALSE(preprocessor.Preprocess(options, &problem, &pp));
 }
 
-TEST(TrustRegionPreprocessor, ParamterBlockIsInfeasible) {
+TEST(TrustRegionPreprocessor, ParameterBlockIsInfeasible) {
   ProblemImpl problem;
   double x = 3.0;
   problem.AddParameterBlock(&x, 1);