diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4b2f4bd..a9224cb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -395,31 +395,28 @@
 INCLUDE(CheckIncludeFileCXX)
 CHECK_INCLUDE_FILE_CXX(unordered_map HAVE_STD_UNORDERED_MAP_HEADER)
 IF (HAVE_STD_UNORDERED_MAP_HEADER)
-  # Even so we've found unordered_map header file it doesn't
-  # mean unordered_map and unordered_set will be declared in
-  # std namespace.
+  # Finding the unordered_map header doesn't mean that unordered_map
+  # is in std namespace.
   #
-  # Namely, MSVC 2008 have unordered_map header which declares
-  # unordered_map class in std::tr1 namespace. In order to support
-  # this, we do extra check to see which exactly namespace is
-  # to be used.
-
+  # In particular, MSVC 2008 has unordered_map declared in std::tr1.
+  # In order to support this, we do an extra check to see which
+  # namespace should be used.
   INCLUDE(CheckCXXSourceCompiles)
   CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>
-                            int main() {
-                              std::unordered_map<int, int> map;
-                              return 0;
-                            }"
+                             int main() {
+                               std::unordered_map<int, int> map;
+                               return 0;
+                             }"
                             HAVE_UNORDERED_MAP_IN_STD_NAMESPACE)
   IF (HAVE_UNORDERED_MAP_IN_STD_NAMESPACE)
     ADD_DEFINITIONS(-DCERES_STD_UNORDERED_MAP)
     MESSAGE("-- Found unordered_map/set in std namespace.")
   ELSE (HAVE_UNORDERED_MAP_IN_STD_NAMESPACE)
     CHECK_CXX_SOURCE_COMPILES("#include <unordered_map>
-                              int main() {
-                                std::tr1::unordered_map<int, int> map;
-                                return 0;
-                              }"
+                               int main() {
+                                 std::tr1::unordered_map<int, int> map;
+                                 return 0;
+                               }"
                               HAVE_UNORDERED_MAP_IN_TR1_NAMESPACE)
     IF (HAVE_UNORDERED_MAP_IN_TR1_NAMESPACE)
       ADD_DEFINITIONS(-DCERES_STD_UNORDERED_MAP_IN_TR1_NAMESPACE)
@@ -432,17 +429,63 @@
     ENDIF (HAVE_UNORDERED_MAP_IN_TR1_NAMESPACE)
   ENDIF (HAVE_UNORDERED_MAP_IN_STD_NAMESPACE)
 ELSE (HAVE_STD_UNORDERED_MAP_HEADER)
-  CHECK_INCLUDE_FILE_CXX("tr1/unordered_map" UNORDERED_MAP_IN_TR1_NAMESPACE)
-  IF (UNORDERED_MAP_IN_TR1_NAMESPACE)
+  CHECK_INCLUDE_FILE_CXX("tr1/unordered_map" HAVE_TR1_UNORDERED_MAP_HEADER)
+  IF (HAVE_TR1_UNORDERED_MAP_HEADER)
     ADD_DEFINITIONS(-DCERES_TR1_UNORDERED_MAP)
     MESSAGE("-- Found tr1/unordered_map/set in std::tr1 namespace.")
-  ELSE (UNORDERED_MAP_IN_TR1_NAMESPACE)
+  ELSE (HAVE_TR1_UNORDERED_MAP_HEADE)
     MESSAGE("-- Unable to find <unordered_map> or <tr1/unordered_map>. ")
     MESSAGE("-- Replacing unordered_map/set with map/set (warning: slower!)")
     ADD_DEFINITIONS(-DCERES_NO_UNORDERED_MAP)
-  ENDIF (UNORDERED_MAP_IN_TR1_NAMESPACE)
+  ENDIF (HAVE_TR1_UNORDERED_MAP_HEADER)
 ENDIF (HAVE_STD_UNORDERED_MAP_HEADER)
 
+CHECK_INCLUDE_FILE_CXX(memory HAVE_STD_MEMORY_HEADER)
+IF (HAVE_STD_MEMORY_HEADER)
+  # Finding the memory header doesn't mean that shared_ptr is in std
+  # namespace.
+  #
+  # In particular, MSVC 2008 has shared_ptr declared in std::tr1.  In
+  # order to support this, we do an extra check to see which namespace
+  # should be used.
+  INCLUDE(CheckCXXSourceCompiles)
+  CHECK_CXX_SOURCE_COMPILES("#include <memory>
+                             int main() {
+                               std::shared_ptr<int> int_ptr;
+                               return 0;
+                             }"
+                            HAVE_SHARED_PTR_IN_STD_NAMESPACE)
+
+  IF (HAVE_SHARED_PTR_IN_STD_NAMESPACE)
+    ADD_DEFINITIONS(-DCERES_STD_SHARED_PTR)
+    MESSAGE("-- Found shared_ptr in std namespace.")
+  ELSE (HAVE_SHARED_PTR_IN_STD_NAMESPACE)
+    CHECK_CXX_SOURCE_COMPILES("#include <memory>
+                               int main() {
+                                 std::tr1::shared_ptr<int> int_ptr;
+                                 return 0;
+                               }"
+                              HAVE_SHARED_PTR_IN_TR1_NAMESPACE)
+    IF (HAVE_SHARED_PTR_IN_TR1_NAMESPACE)
+      ADD_DEFINITIONS(-DCERES_STD_SHARED_PTR_IN_TR1_NAMESPACE)
+      MESSAGE("-- Found shared_ptr in std::tr1 namespace.")
+    ELSE (HAVE_SHARED_PTR_IN_TR1_NAMESPACE)
+      MESSAGE(FATAL_ERROR "-- Found <memory> but cannot find either "
+                          "std::shared_ptr or std::tr1::shared_ptr")
+      ADD_DEFINITIONS(-DCERES_NO_SHARED_PTR)
+    ENDIF (HAVE_SHARED_PTR_IN_TR1_NAMESPACE)
+  ENDIF (HAVE_SHARED_PTR_IN_STD_NAMESPACE)
+ELSE (HAVE_STD_MEMORY_HEADER)
+  CHECK_INCLUDE_FILE_CXX("tr1/memory" HAVE_TR1_MEMORY_HEADER)
+  IF (HAVE_TR1_MEMORY_HEADER)
+    ADD_DEFINITIONS(-DCERES_TR1_SHARED_PTR)
+    MESSAGE("-- Found tr1/memory in std::tr1 namespace.")
+  ELSE (HAVE_TR1_MEMORY_HEADER)
+    MESSAGE(FATAL_ERROR "-- Unable to find <memory> or <tr1/memory>. ")
+  ENDIF (HAVE_TR1_MEMORY_HEADER)
+ENDIF (HAVE_STD_MEMORY_HEADER)
+
+
 INCLUDE_DIRECTORIES(
   include
   internal
diff --git a/examples/bundle_adjuster.cc b/examples/bundle_adjuster.cc
index fb82719..70a9640 100644
--- a/examples/bundle_adjuster.cc
+++ b/examples/bundle_adjuster.cc
@@ -151,19 +151,19 @@
   if (options->use_inner_iterations) {
     if (FLAGS_blocks_for_inner_iterations == "cameras") {
       LOG(INFO) << "Camera blocks for inner iterations";
-      options->inner_iteration_ordering = new ParameterBlockOrdering;
+      options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
         options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 0);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "points") {
       LOG(INFO) << "Point blocks for inner iterations";
-      options->inner_iteration_ordering = new ParameterBlockOrdering;
+      options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_points; ++i) {
         options->inner_iteration_ordering->AddElementToGroup(points + point_block_size * i, 0);
       }
     } else if (FLAGS_blocks_for_inner_iterations == "cameras,points") {
       LOG(INFO) << "Camera followed by point blocks for inner iterations";
-      options->inner_iteration_ordering = new ParameterBlockOrdering;
+      options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
         options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 0);
       }
@@ -172,7 +172,7 @@
       }
     } else if (FLAGS_blocks_for_inner_iterations == "points,cameras") {
       LOG(INFO) << "Point followed by camera blocks for inner iterations";
-      options->inner_iteration_ordering = new ParameterBlockOrdering;
+      options->inner_iteration_ordering.reset(new ParameterBlockOrdering);
       for (int i = 0; i < num_cameras; ++i) {
         options->inner_iteration_ordering->AddElementToGroup(cameras + camera_block_size * i, 1);
       }
@@ -221,7 +221,7 @@
     }
   }
 
-  options->linear_solver_ordering = ordering;
+  options->linear_solver_ordering.reset(ordering);
 }
 
 void SetMinimizerOptions(Solver::Options* options) {
diff --git a/include/ceres/internal/port.h b/include/ceres/internal/port.h
index a9fe247..721996c 100644
--- a/include/ceres/internal/port.h
+++ b/include/ceres/internal/port.h
@@ -33,6 +33,13 @@
 
 #include <string>
 
+#if defined(CERES_STD_SHARED_PTR) || defined(CERES_STD_SHARED_PTR_IN_TR1_NAMESPACE)
+#include <memory>
+#else
+#include <tr1/memory>
+#endif
+
+
 namespace ceres {
 
 // It is unfortunate that this import of the entire standard namespace is
@@ -45,6 +52,14 @@
 // "string" implementation in the global namespace.
 using std::string;
 
+#if defined(CERES_STD_SHARED_PTR)
+using std::shared_ptr;
+#endif
+
+#if defined(CERES_STD_SHARED_PTR_IN_TR1_NAMESPACE) || defined(SHARED_PTR_IN_TR1_NAMESPACE)
+using std::tr1::shared_ptr;
+#endif
+
 }  // namespace ceres
 
 #endif  // CERES_PUBLIC_INTERNAL_PORT_H_
diff --git a/include/ceres/solver.h b/include/ceres/solver.h
index f0d5be6..c5bfadc 100644
--- a/include/ceres/solver.h
+++ b/include/ceres/solver.h
@@ -107,7 +107,6 @@
 
 
       num_linear_solver_threads = 1;
-      linear_solver_ordering = NULL;
       use_postordering = false;
       min_linear_solver_iterations = 1;
       max_linear_solver_iterations = 500;
@@ -115,7 +114,6 @@
       jacobi_scaling = true;
       use_inner_iterations = false;
       inner_iteration_tolerance = 1e-3;
-      inner_iteration_ordering = NULL;
       logging_type = PER_MINIMIZER_ITERATION;
       minimizer_progress_to_stdout = false;
       trust_region_problem_dump_directory = "/tmp";
@@ -126,7 +124,6 @@
       update_state_every_iteration = false;
     }
 
-    ~Options();
     // Minimizer options ----------------------------------------
 
     // Ceres supports the two major families of optimization strategies -
@@ -480,10 +477,7 @@
     // the parameter blocks into two groups, one for the points and one
     // for the cameras, where the group containing the points has an id
     // smaller than the group containing cameras.
-    //
-    // Once assigned, Solver::Options owns this pointer and will
-    // deallocate the memory when destroyed.
-    ParameterBlockOrdering* linear_solver_ordering;
+    shared_ptr<ParameterBlockOrdering> linear_solver_ordering;
 
     // Sparse Cholesky factorization algorithms use a fill-reducing
     // ordering to permute the columns of the Jacobian matrix. There
@@ -576,7 +570,7 @@
     //    the lower numbered groups are optimized before the higher
     //    number groups. Each group must be an independent set. Not
     //    all parameter blocks need to be present in the ordering.
-    ParameterBlockOrdering* inner_iteration_ordering;
+    shared_ptr<ParameterBlockOrdering> inner_iteration_ordering;
 
     // Generally speaking, inner iterations make significant progress
     // in the early stages of the solve and then their contribution
diff --git a/internal/ceres/solver.cc b/internal/ceres/solver.cc
index 36c58b3..53a9b4b 100644
--- a/internal/ceres/solver.cc
+++ b/internal/ceres/solver.cc
@@ -56,11 +56,6 @@
 
 }  // namespace
 
-Solver::Options::~Options() {
-  delete linear_solver_ordering;
-  delete inner_iteration_ordering;
-}
-
 Solver::~Solver() {}
 
 void Solver::Solve(const Solver::Options& options,
diff --git a/internal/ceres/solver_impl.cc b/internal/ceres/solver_impl.cc
index 9c5a2b0..e85ffbf 100644
--- a/internal/ceres/solver_impl.cc
+++ b/internal/ceres/solver_impl.cc
@@ -565,14 +565,12 @@
   summary->minimizer_type = TRUST_REGION;
 
   SummarizeGivenProgram(*original_program, summary);
-  SummarizeOrdering(original_options.linear_solver_ordering,
+  SummarizeOrdering(original_options.linear_solver_ordering.get(),
                     &(summary->linear_solver_ordering_given));
-  SummarizeOrdering(original_options.inner_iteration_ordering,
+  SummarizeOrdering(original_options.inner_iteration_ordering.get(),
                     &(summary->inner_iteration_ordering_given));
 
   Solver::Options options(original_options);
-  options.linear_solver_ordering = NULL;
-  options.inner_iteration_ordering = NULL;
 
 #ifndef CERES_USE_OPENMP
   if (options.num_threads > 1) {
@@ -636,17 +634,14 @@
     problem_impl = gradient_checking_problem_impl.get();
   }
 
-  if (original_options.linear_solver_ordering != NULL) {
-    if (!IsOrderingValid(original_options, problem_impl, &summary->message)) {
+  if (options.linear_solver_ordering.get() != NULL) {
+    if (!IsOrderingValid(options, problem_impl, &summary->message)) {
       LOG(ERROR) << summary->message;
       return;
     }
     event_logger.AddEvent("CheckOrdering");
-    options.linear_solver_ordering =
-        new ParameterBlockOrdering(*original_options.linear_solver_ordering);
-    event_logger.AddEvent("CopyOrdering");
   } else {
-    options.linear_solver_ordering = new ParameterBlockOrdering;
+    options.linear_solver_ordering.reset(new ParameterBlockOrdering);
     const ProblemImpl::ParameterMap& parameter_map =
         problem_impl->parameter_map();
     for (ProblemImpl::ParameterMap::const_iterator it = parameter_map.begin();
@@ -657,13 +652,6 @@
     event_logger.AddEvent("ConstructOrdering");
   }
 
-  if (original_options.inner_iteration_ordering != NULL) {
-    // Make a copy, as the options struct takes ownership of the
-    // ordering objects.
-    options.inner_iteration_ordering =
-        new ParameterBlockOrdering(*original_options.inner_iteration_ordering);
-  }
-
   // Create the three objects needed to minimize: the transformed program, the
   // evaluator, and the linear solver.
   scoped_ptr<Program> reduced_program(CreateReducedProgram(&options,
@@ -676,7 +664,7 @@
     return;
   }
 
-  SummarizeOrdering(options.linear_solver_ordering,
+  SummarizeOrdering(options.linear_solver_ordering.get(),
                     &(summary->linear_solver_ordering_used));
   SummarizeReducedProgram(*reduced_program, summary);
 
@@ -839,8 +827,7 @@
   // refactored to deal with the various bits of cleanups related to
   // line search.
   options.linear_solver_type = CGNR;
-  options.linear_solver_ordering = NULL;
-  options.inner_iteration_ordering = NULL;
+
 
 #ifndef CERES_USE_OPENMP
   if (options.num_threads > 1) {
@@ -860,15 +847,13 @@
     return;
   }
 
-  if (original_options.linear_solver_ordering != NULL) {
-    if (!IsOrderingValid(original_options, problem_impl, &summary->message)) {
+  if (options.linear_solver_ordering.get() != NULL) {
+    if (!IsOrderingValid(options, problem_impl, &summary->message)) {
       LOG(ERROR) << summary->message;
       return;
     }
-    options.linear_solver_ordering =
-        new ParameterBlockOrdering(*original_options.linear_solver_ordering);
   } else {
-    options.linear_solver_ordering = new ParameterBlockOrdering;
+    options.linear_solver_ordering.reset(new ParameterBlockOrdering);
     const ProblemImpl::ParameterMap& parameter_map =
         problem_impl->parameter_map();
     for (ProblemImpl::ParameterMap::const_iterator it = parameter_map.begin();
@@ -878,6 +863,7 @@
     }
   }
 
+
   original_program->SetParameterBlockStatePtrsToUserStatePtrs();
 
   // If the user requests gradient checking, construct a new
@@ -1134,16 +1120,16 @@
                                           ProblemImpl* problem_impl,
                                           double* fixed_cost,
                                           string* error) {
-  CHECK_NOTNULL(options->linear_solver_ordering);
+  CHECK_NOTNULL(options->linear_solver_ordering.get());
   Program* original_program = problem_impl->mutable_program();
   scoped_ptr<Program> transformed_program(new Program(*original_program));
 
   ParameterBlockOrdering* linear_solver_ordering =
-      options->linear_solver_ordering;
+      options->linear_solver_ordering.get();
   const int min_group_id =
       linear_solver_ordering->group_to_elements().begin()->first;
   ParameterBlockOrdering* inner_iteration_ordering =
-      options->inner_iteration_ordering;
+      options->inner_iteration_ordering.get();
   if (!RemoveFixedBlocksFromProgram(transformed_program.get(),
                                     linear_solver_ordering,
                                     inner_iteration_ordering,
@@ -1216,7 +1202,7 @@
 LinearSolver* SolverImpl::CreateLinearSolver(Solver::Options* options,
                                              string* error) {
   CHECK_NOTNULL(options);
-  CHECK_NOTNULL(options->linear_solver_ordering);
+  CHECK_NOTNULL(options->linear_solver_ordering.get());
   CHECK_NOTNULL(error);
 
   if (options->trust_region_strategy_type == DOGLEG) {
@@ -1486,7 +1472,7 @@
   scoped_ptr<ParameterBlockOrdering> inner_iteration_ordering;
   ParameterBlockOrdering* ordering_ptr  = NULL;
 
-  if (options.inner_iteration_ordering == NULL) {
+  if (options.inner_iteration_ordering.get() == NULL) {
     // Find a recursive decomposition of the Hessian matrix as a set
     // of independent sets of decreasing size and invert it. This
     // seems to work better in practice, i.e., Cameras before
@@ -1513,7 +1499,7 @@
         return NULL;
       }
     }
-    ordering_ptr = options.inner_iteration_ordering;
+    ordering_ptr = options.inner_iteration_ordering.get();
   }
 
   if (!inner_iteration_minimizer->Init(program,
diff --git a/internal/ceres/solver_impl_test.cc b/internal/ceres/solver_impl_test.cc
index 671edb0..c2f8c22 100644
--- a/internal/ceres/solver_impl_test.cc
+++ b/internal/ceres/solver_impl_test.cc
@@ -326,7 +326,7 @@
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = linear_solver_ordering;
+  options.linear_solver_ordering.reset(linear_solver_ordering);
 
   const vector<ResidualBlock*>& residual_blocks =
       problem.program().residual_blocks();
@@ -388,7 +388,7 @@
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = linear_solver_ordering;
+  options.linear_solver_ordering.reset(linear_solver_ordering);
 
   // Create the reduced program. This should remove the fixed block "z",
   // marking the index to -1 at the same time. x and y also get indices.
@@ -457,7 +457,7 @@
 
   Solver::Options options;
   options.linear_solver_type = DENSE_SCHUR;
-  options.linear_solver_ordering = linear_solver_ordering;
+  options.linear_solver_ordering.reset(linear_solver_ordering);
 
   string message;
   scoped_ptr<Program> reduced_program(
@@ -541,7 +541,7 @@
   Solver::Options options;
   options.linear_solver_type = SPARSE_NORMAL_CHOLESKY;
   // CreateLinearSolver assumes a non-empty ordering.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   EXPECT_FALSE(SolverImpl::CreateLinearSolver(&options, &message));
 }
@@ -552,7 +552,7 @@
   options.linear_solver_type = DENSE_QR;
   options.max_linear_solver_iterations = -1;
   // CreateLinearSolver assumes a non-empty ordering.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   EXPECT_EQ(SolverImpl::CreateLinearSolver(&options, &message),
             static_cast<LinearSolver*>(NULL));
@@ -563,7 +563,7 @@
   options.linear_solver_type = DENSE_QR;
   options.min_linear_solver_iterations = -1;
   // CreateLinearSolver assumes a non-empty ordering.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   EXPECT_EQ(SolverImpl::CreateLinearSolver(&options, &message),
             static_cast<LinearSolver*>(NULL));
@@ -574,7 +574,7 @@
   options.linear_solver_type = DENSE_QR;
   options.min_linear_solver_iterations = 10;
   options.max_linear_solver_iterations = 5;
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   EXPECT_EQ(SolverImpl::CreateLinearSolver(&options, &message),
             static_cast<LinearSolver*>(NULL));
@@ -586,7 +586,7 @@
   options.num_linear_solver_threads = 2;
   // The Schur type solvers can only be created with the Ordering
   // contains at least one elimination group.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   double x;
   double y;
   options.linear_solver_ordering->AddElementToGroup(&x, 0);
@@ -604,7 +604,7 @@
   Solver::Options options;
   options.trust_region_strategy_type = DOGLEG;
   // CreateLinearSolver assumes a non-empty ordering.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   options.linear_solver_type = ITERATIVE_SCHUR;
   EXPECT_EQ(SolverImpl::CreateLinearSolver(&options, &message),
@@ -620,7 +620,7 @@
   scoped_ptr<LinearSolver> solver;
   options.linear_solver_type = DENSE_QR;
   // CreateLinearSolver assumes a non-empty ordering.
-  options.linear_solver_ordering = new ParameterBlockOrdering;
+  options.linear_solver_ordering.reset(new ParameterBlockOrdering);
   string message;
   solver.reset(SolverImpl::CreateLinearSolver(&options, &message));
   EXPECT_EQ(options.linear_solver_type, DENSE_QR);
diff --git a/internal/ceres/system_test.cc b/internal/ceres/system_test.cc
index eb2e24c..f4b9ff3 100644
--- a/internal/ceres/system_test.cc
+++ b/internal/ceres/system_test.cc
@@ -140,8 +140,7 @@
     options.num_linear_solver_threads = config.num_threads;
 
     if (config.use_automatic_ordering) {
-      delete options.linear_solver_ordering;
-      options.linear_solver_ordering = NULL;
+      options.linear_solver_ordering.reset();
     }
 
     LOG(INFO) << "Running solver configuration: "
@@ -398,7 +397,7 @@
       problem_.AddResidualBlock(cost_function, NULL, camera, point);
     }
 
-    options_.linear_solver_ordering = new ParameterBlockOrdering;
+    options_.linear_solver_ordering.reset(new ParameterBlockOrdering);
 
     // The points come before the cameras.
     for (int i = 0; i < num_points_; ++i) {
diff --git a/jni/Android.mk b/jni/Android.mk
index 09657aa..6c4d69d 100644
--- a/jni/Android.mk
+++ b/jni/Android.mk
@@ -29,44 +29,44 @@
 # Author: settinger@google.com (Scott Ettinger)
 #         keir@google.com (Keir Mierle)
 #
-# Builds Ceres for Android, using the standard toolchain (not standalone). It
-# uses STLPort instead of GNU C++. This is useful for anyone wishing to ship
-# GPL-free code. This cannot build the tests or other parts of Ceres; only the
-# core libraries. If you need a more complete Ceres build, consider using the
-# CMake toolchain (noting that the standalone toolchain doesn't work with
-# STLPort).
+# Builds Ceres for Android, using the standard toolchain (not
+# standalone). It uses LLVM's libc++ as the standard library. It is a
+# modern BSD licensed implementation of the standard c++ library. We
+# do this to avoid any licensing issues that may arise from using
+# GCC's libstdc++ which is licensed under GPL3.
 #
-# You will have to specify the environment EIGEN_PATH to point to the Eigen
-# sources when building. For example:
+# Building
+# --------
+#
+# You will have to specify the environment EIGEN_PATH to point to the
+# Eigen sources when building. For example:
 #
 #   EIGEN_PATH=/home/keir/src/eigen-3.0.5 ndk-build -j
 #
-# It is also possible to specify CERES_EXTRA_DEFINES, in case you need to pass
-# more definitions to the C compiler.
+# It is also possible to specify CERES_EXTRA_DEFINES, in case you need
+# to pass more definitions to the C compiler.
 #
-# IMPORTANT:
-#
-# The shared library built at the bottom is fake, broken, and empty. It exists
-# only to force ndk-build to build the shared library. This shouldn't be
-# necessary, but if it is missing, then ndk-build will do nothing when asked to
-# build. The produced .so library is NON-FUNCTIONAL since it has no Ceres
-# function-level dependencies. Instead, copy the static library:
+# Using the library
+# -----------------
+# Copy the static library:
 #
 #   ../obj/local/armeabi-v7a/libceres.a
 #
-# into your own project, then link it into your binary in your Android.mk file.
+# into your own project, then link it into your binary in your
+# Android.mk file.
 #
-# Reducing binary size:
-#
-# This build includes the Schur specializations, which cause binary bloat. If
-# you don't need them for your application, consider adding:
+# Reducing binary size
+# --------------------
+# This build includes the Schur specializations, which increase the
+# size of the binary. If you don't need them for your application,
+# consider adding:
 #
 #   -DCERES_RESTRICT_SCHUR_SPECIALIZATION
 #
 # to the LOCAL_CFLAGS variable below.
 #
-# Changing the logging library:
-#
+# Changing the logging library
+# ----------------------------
 # Ceres Solver ships with a replacement for glog that provides a
 # simple and small implementation that builds on Android. However, if
 # you wish to supply a header only version yourself, then you may
@@ -99,13 +99,10 @@
                 -DCERES_NO_GFLAGS \
                 -DCERES_NO_THREADS \
                 -DCERES_NO_CXSPARSE \
-                -DCERES_NO_UNORDERED_MAP \
+                -DCERES_STD_UNORDERED_MAP \
+                -DCERES_STD_SHARED_PTR   \
                 -DCERES_WORK_AROUND_ANDROID_NDK_COMPILER_BUG
 
-# On Android NDK 8b, GCC gives spurrious warnings about ABI incompatibility for
-# which there is no solution. Hide the warning instead.
-LOCAL_CFLAGS += -Wno-psabi
-
 LOCAL_SRC_FILES := $(CERES_SRC_PATH)/array_utils.cc \
                    $(CERES_SRC_PATH)/blas.cc \
                    $(CERES_SRC_PATH)/block_evaluate_preparer.cc \
@@ -187,6 +184,7 @@
                    $(CERES_SRC_PATH)/generated/schur_eliminator_2_4_3.cc \
                    $(CERES_SRC_PATH)/generated/schur_eliminator_2_4_4.cc \
                    $(CERES_SRC_PATH)/generated/schur_eliminator_2_4_d.cc \
+                   $(CERES_SRC_PATH)/generated/schur_eliminator_2_d_d.cc \
                    $(CERES_SRC_PATH)/generated/schur_eliminator_4_4_2.cc \
                    $(CERES_SRC_PATH)/generated/schur_eliminator_4_4_3.cc \
                    $(CERES_SRC_PATH)/generated/schur_eliminator_4_4_4.cc \
@@ -203,6 +201,7 @@
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_2_4_3.cc \
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_2_4_4.cc \
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_2_4_d.cc \
+                   $(CERES_SRC_PATH)/generated/partitioned_matrix_view_2_d_d.cc \
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_4_4_2.cc \
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_4_4_3.cc \
                    $(CERES_SRC_PATH)/generated/partitioned_matrix_view_4_4_4.cc \
@@ -214,11 +213,3 @@
 
 LOCAL_MODULE := ceres
 include $(BUILD_STATIC_LIBRARY)
-
-# This is a fake library; see the file header comments.
-include $(CLEAR_VARS)
-LOCAL_C_INCLUDES := $(CERES_INCLUDE_PATHS)
-LOCAL_C_INCLUDES += $(EIGEN_PATH)
-LOCAL_MODULE := forces_static_ceres_build_do_not_use
-LOCAL_STATIC_LIBRARIES := ceres
-include $(BUILD_SHARED_LIBRARY)
diff --git a/jni/Application.mk b/jni/Application.mk
index 462823d..ec40293 100644
--- a/jni/Application.mk
+++ b/jni/Application.mk
@@ -33,6 +33,7 @@
 APP_CPPFLAGS += -fno-rtti
 APP_OPTIM := release
 
-# Don't use GNU libstdc++; instead use STLPort, which is free of GPL3 issues.
-APP_STL := stlport_static
+# Use libc++ from LLVM. It is a modern BSD licensed implementation of
+# the standard C++ library.
+APP_STL := c++_static
 APP_ABI := armeabi-v7a