diff --git a/internal/ceres/cgnr_solver.cc b/internal/ceres/cgnr_solver.cc
index 5374f51..015e170 100644
--- a/internal/ceres/cgnr_solver.cc
+++ b/internal/ceres/cgnr_solver.cc
@@ -224,13 +224,41 @@
 };
 
 class CERES_NO_EXPORT CudaIdentityPreconditioner final
-    : public ConjugateGradientsLinearOperator<CudaVector> {
+    : public CudaPreconditioner {
  public:
+  void Update(const CompressedRowSparseMatrix& A, const double* D) final {}
   void RightMultiplyAndAccumulate(const CudaVector& x, CudaVector& y) final {
     y.Axpby(1.0, x, 1.0);
   }
 };
 
+// This class wraps the existing CPU Jacobi preconditioner, caches the structure
+// of the block diagonal, and for each CGNR solve updates the values on the CPU
+// and then copies them over to the GPU.
+class CERES_NO_EXPORT CudaJacobiPreconditioner final
+    : public CudaPreconditioner {
+ public:
+  explicit CudaJacobiPreconditioner(ContextImpl* context,
+                                    const CompressedRowSparseMatrix& A) :
+      cpu_preconditioner_(A),
+      m_(context, cpu_preconditioner_.matrix()) {}
+  ~CudaJacobiPreconditioner() = default;
+
+  void Update(const CompressedRowSparseMatrix& A, const double* D) final {
+    cpu_preconditioner_.Update(A, D);
+    m_.CopyValuesFromCpu(cpu_preconditioner_.matrix());
+  }
+
+  void RightMultiplyAndAccumulate(
+      const CudaVector& x, CudaVector& y) final {
+    m_.RightMultiplyAndAccumulate(x, &y);
+  }
+
+ private:
+  BlockCRSJacobiPreconditioner cpu_preconditioner_;
+  CudaSparseMatrix m_;
+};
+
 CudaCgnrSolver::CudaCgnrSolver(LinearSolver::Options options)
     : options_(std::move(options)) {}
 
@@ -246,7 +274,8 @@
 std::unique_ptr<CudaCgnrSolver> CudaCgnrSolver::Create(
     LinearSolver::Options options, std::string* error) {
   CHECK(error != nullptr);
-  if (options.preconditioner_type != IDENTITY) {
+  if (options.preconditioner_type != IDENTITY &&
+      options.preconditioner_type != JACOBI) {
     *error =
         "CudaCgnrSolver does not support preconditioner type " +
         std::string(PreconditionerTypeToString(options.preconditioner_type)) +
@@ -270,6 +299,12 @@
     Atb_ = std::make_unique<CudaVector>(options_.context, A.num_cols());
     Ax_ = std::make_unique<CudaVector>(options_.context, A.num_rows());
     D_ = std::make_unique<CudaVector>(options_.context, A.num_cols());
+    if (options_.preconditioner_type == JACOBI) {
+      preconditioner_ =
+          std::make_unique<CudaJacobiPreconditioner>(options_.context, A);
+    } else {
+      preconditioner_ = std::make_unique<CudaIdentityPreconditioner>();
+    }
     for (int i = 0; i < 4; ++i) {
       scratch_[i] = new CudaVector(options_.context, A.num_cols());
     }
@@ -293,6 +328,8 @@
 
   CpuToGpuTransfer(*A, b, per_solve_options.D);
   event_logger.AddEvent("CPU to GPU Transfer");
+  preconditioner_->Update(*A, per_solve_options.D);
+  event_logger.AddEvent("Preconditioner Update");
 
   // Form z = Atb.
   Atb_->SetZero();
@@ -311,9 +348,8 @@
   cg_options.q_tolerance = per_solve_options.q_tolerance;
   cg_options.r_tolerance = per_solve_options.r_tolerance;
 
-  CudaIdentityPreconditioner preconditioner;
   summary = ConjugateGradientsSolver(
-      cg_options, lhs, *Atb_, preconditioner, scratch_, *x_);
+      cg_options, lhs, *Atb_, *preconditioner_, scratch_, *x_);
   x_->CopyTo(x);
   event_logger.AddEvent("Solve");
   return summary;
diff --git a/internal/ceres/cgnr_solver.h b/internal/ceres/cgnr_solver.h
index 9078d01..5111d80 100644
--- a/internal/ceres/cgnr_solver.h
+++ b/internal/ceres/cgnr_solver.h
@@ -33,6 +33,7 @@
 
 #include <memory>
 
+#include "ceres/conjugate_gradients_solver.h"
 #include "ceres/cuda_sparse_matrix.h"
 #include "ceres/cuda_vector.h"
 #include "ceres/internal/export.h"
@@ -71,6 +72,13 @@
 };
 
 #ifndef CERES_NO_CUDA
+class CudaPreconditioner : public
+    ConjugateGradientsLinearOperator<CudaVector> {
+ public:
+  virtual void Update(const CompressedRowSparseMatrix& A, const double* D) = 0;
+  virtual ~CudaPreconditioner() = default;
+};
+
 // A Cuda-accelerated version of CgnrSolver.
 // This solver assumes that the sparsity structure of A remains constant for its
 // lifetime.
@@ -99,6 +107,7 @@
   std::unique_ptr<CudaVector> Atb_;
   std::unique_ptr<CudaVector> Ax_;
   std::unique_ptr<CudaVector> D_;
+  std::unique_ptr<CudaPreconditioner> preconditioner_;
   CudaVector* scratch_[4] = {nullptr, nullptr, nullptr, nullptr};
 };
 #endif  // CERES_NO_CUDA
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 0656d34..c896e32 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -327,8 +327,14 @@
     return false;
   }
 
-  if (options.sparse_linear_algebra_library_type != CUDA_SPARSE &&
-      options.preconditioner_type == SUBSET) {
+  if (options.preconditioner_type == SUBSET) {
+    if (options.sparse_linear_algebra_library_type == CUDA_SPARSE) {
+      *error = 
+          "Can't use CGNR with preconditioner_type = SUBSET when "
+          "sparse_linear_algebra_library_type = CUDA_SPARSE.";
+      return false;
+    }
+
     if (options.residual_blocks_for_subset_preconditioner.empty()) {
       *error =
           "When using SUBSET preconditioner, "
@@ -350,13 +356,6 @@
           "CUDA_SPARSE because support was not enabled when Ceres was built.";
       return false;
     }
-    if (options.preconditioner_type != IDENTITY) {
-      *error = StringPrintf(
-          "Can't use CGNR with preconditioner_type = %s when "
-          "sparse_linear_algebra_library_type = CUDA_SPARSE.",
-          PreconditionerTypeToString(options.preconditioner_type));
-      return false;
-    }
   }
   return true;
 }
diff --git a/internal/ceres/solver_test.cc b/internal/ceres/solver_test.cc
index b796873..929e293 100644
--- a/internal/ceres/solver_test.cc
+++ b/internal/ceres/solver_test.cc
@@ -959,7 +959,8 @@
 
   options.dynamic_sparsity = false;
   options.use_mixed_precision_solves = false;
-  EXPECT_FALSE(options.IsValid(&message));
+  EXPECT_EQ(options.IsValid(&message),
+            IsSparseLinearAlgebraLibraryTypeAvailable(CUDA_SPARSE));
 
   options.dynamic_sparsity = true;
   options.use_mixed_precision_solves = false;