diff --git a/CMakeLists.txt b/CMakeLists.txt
index f11e579..9bd1e90 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -771,6 +771,12 @@
               "${Ceres_SOURCE_DIR}/cmake/FindGlog.cmake"
         DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
 
+# Install codegen cmake scripts
+install(FILES "${Ceres_SOURCE_DIR}/cmake/codegen_include.h.in"
+              "${Ceres_SOURCE_DIR}/cmake/generate_code_for_functor.cc.in"
+              "${Ceres_SOURCE_DIR}/cmake/CeresCodeGeneration.cmake"
+        DESTINATION ${RELATIVE_CMAKECONFIG_INSTALL_DIR})
+
 if (PROVIDE_UNINSTALL_TARGET)
   # Create an uninstall target to remove all installed files.
   configure_file("${Ceres_SOURCE_DIR}/cmake/uninstall.cmake.in"
diff --git a/cmake/CeresCodeGeneration.cmake b/cmake/CeresCodeGeneration.cmake
new file mode 100644
index 0000000..f3819ce
--- /dev/null
+++ b/cmake/CeresCodeGeneration.cmake
@@ -0,0 +1,153 @@
+# Ceres Solver - A fast non-linear least squares minimizer
+# Copyright 2019 Google Inc. All rights reserved.
+# http://ceres-solver.org/
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of Google Inc. nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Author: darius.rueckert@fau.de (Darius Rueckert)
+
+# The directory containing the following files
+#   - codegen_include.h.in
+#   - generate_code_from_functor.cc.in
+set(CODEGEN_CMAKE_SCRIPT_DIR "${CMAKE_CURRENT_LIST_DIR}")
+
+# Generates C-code implementation of Ceres' CostFunction::Evaluate() API from a
+# templated C++ cost functor derived from ceres::CodegenCostFunction using
+# autodiff. The resulting implementation replaces the direct instantiation of
+# autodiff in client code, typically resulting in improved performance.
+#
+# Parameters:
+#
+# NAME
+#     The name of the cost functor. The name must exactly match the C++ type
+#     name of the functor. This is also the name of the CMake output target.
+# NAMESPACE [optional]
+#     The C++ namespace of the cost functor type. For example, if the full
+#     type name is ceres::BundleAdjust, then NAME should be "BundleAdjust"
+#     and NAMESPACE should be "ceres".
+# INPUT_FILE
+#     The path to the header defining the cost functor <NAME>.
+# OUTPUT_DIRECTORY [default = "generated"]
+#     The relative output directory of the generated header file. This is the
+#     prefix that has to be added to the #include of the generated files, i.e:
+#     #include "<OUTPUT_DIRECTORY>/<GENERATED_FILE.h>"
+
+#
+# Example Usage:
+#   ceres_generate_cost_function_implementation_for_functor(
+#       NAME SquareFunctor
+#       INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/square_functor.h
+#       )
+#   add_executable(helloworld_codegen helloworld_codegen.cc )
+#   target_link_libraries(helloworld_codegen ceres SquareFunctor)
+function(ceres_generate_cost_function_implementation_for_functor)
+  # Define and parse arguments
+  set(OPTIONAL_ARGS)
+  set(ONE_VALUE_ARGS NAME INPUT_FILE OUTPUT_DIRECTORY NAMESPACE)
+  set(MULTI_VALUE_ARGS)
+  cmake_parse_arguments(
+    COST_FUNCTOR "${OPTIONAL_ARGS}" "${ONE_VALUE_ARGS}"
+    "${MULTI_VALUE_ARGS}" ${ARGN} )
+
+  # Default value of the output directory
+  set(OUTPUT_DIRECTORY "generated")
+  if(COST_FUNCTOR_OUTPUT_DIRECTORY)
+    set(OUTPUT_DIRECTORY "${COST_FUNCTOR_OUTPUT_DIRECTORY}")
+  endif()
+
+  set(CALLER_CODEGEN_BUILD_DIR "${PROJECT_BINARY_DIR}/codegen")
+  set(CALLER_CODEGEN_INCLUDE_DIR "${CALLER_CODEGEN_BUILD_DIR}/include/")
+
+  file(MAKE_DIRECTORY
+    "${CALLER_CODEGEN_BUILD_DIR}")
+  file(MAKE_DIRECTORY
+    "${CALLER_CODEGEN_INCLUDE_DIR}/${OUTPUT_DIRECTORY}")
+  file(MAKE_DIRECTORY
+    "${CALLER_CODEGEN_BUILD_DIR}/src")
+
+  # Convert the input file to an absolute path and check if it exists
+  get_filename_component(
+    COST_FUNCTOR_INPUT_FILE "${COST_FUNCTOR_INPUT_FILE}" REALPATH)
+  if(NOT EXISTS "${COST_FUNCTOR_INPUT_FILE}")
+    message(FATAL_ERROR
+      "Could not find codegen input file ${COST_FUNCTOR_INPUT_FILE}")
+  endif()
+
+
+  # The full C++ type name of the cost functor. This is used inside the
+  # generator to create an object of it.
+  set(FULL_CXX_FUNCTOR_TYPE_NAME "${COST_FUNCTOR_NAME}")
+  if(COST_FUNCTOR_NAMESPACE)
+    set(FULL_CXX_FUNCTOR_TYPE_NAME
+      "${COST_FUNCTOR_NAMESPACE}::${FULL_CXX_FUNCTOR_TYPE_NAME}")
+  endif()
+
+  # 1. Generate a wrapper include file which is included by the user.
+  #    This is required, because
+  #      - It must exist during compiliation of the code generator (otherwise
+  #        the #include will fail)
+  #      - We don't want to have the users add macros to their code
+  string(TOLOWER "${COST_FUNCTOR_NAME}" LOWER_CASE_FUNCTOR_NAME)
+  set(INCLUDE_FILE
+    "${CALLER_CODEGEN_INCLUDE_DIR}/${OUTPUT_DIRECTORY}/${LOWER_CASE_FUNCTOR_NAME}.h")
+  configure_file("${CODEGEN_CMAKE_SCRIPT_DIR}/codegen_include.inc.in" "${INCLUDE_FILE}")
+
+  # 2. Generate the source file for the code generator
+  set(GENERATOR_SOURCE
+    "${CALLER_CODEGEN_BUILD_DIR}/src/${LOWER_CASE_FUNCTOR_NAME}_code_generator.cc")
+  set(GENERATED_EVALUATION_IMPL_FILE
+    "${CALLER_CODEGEN_INCLUDE_DIR}/${OUTPUT_DIRECTORY}/${LOWER_CASE_FUNCTOR_NAME}_evaluate_impl.inc")
+  configure_file(
+    "${CODEGEN_CMAKE_SCRIPT_DIR}/generate_code_for_functor.cc.in" "${GENERATOR_SOURCE}")
+
+  # 3. Build the executable that generates the autodiff code
+  set(GENERATOR_TARGET ${COST_FUNCTOR_NAME}_generator)
+  add_executable(${GENERATOR_TARGET} "${GENERATOR_SOURCE}")
+  target_link_libraries(${GENERATOR_TARGET} ceres)
+  set_target_properties(${GENERATOR_TARGET} PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY "${CALLER_CODEGEN_BUILD_DIR}/bin")
+  target_compile_definitions(${GENERATOR_TARGET} PRIVATE -DCERES_CODEGEN)
+  target_include_directories(${GENERATOR_TARGET}
+    PRIVATE "${CALLER_CODEGEN_INCLUDE_DIR}")
+
+  # 4. Execute the program from (3.) using a custom command
+  add_custom_command(OUTPUT "${GENERATED_EVALUATION_IMPL_FILE}"
+    COMMAND ${GENERATOR_TARGET}
+    DEPENDS "${COST_FUNCTOR_INPUT_FILE}"
+    VERBATIM
+    )
+  set(GENERATE_TARGET ${COST_FUNCTOR_NAME}_generate)
+  add_custom_target(${GENERATE_TARGET} DEPENDS "${GENERATED_EVALUATION_IMPL_FILE}" VERBATIM)
+
+  # 5. Create an output target which can be used by the client. This is required,
+  #    because custom targets can't have include directories.
+  set(OUTPUT_TARGET ${COST_FUNCTOR_NAME})
+  add_library(${OUTPUT_TARGET} INTERFACE)
+  target_include_directories(
+    ${OUTPUT_TARGET} INTERFACE "${CALLER_CODEGEN_INCLUDE_DIR}")
+  target_sources(
+    ${OUTPUT_TARGET} INTERFACE "${INCLUDE_FILE}" "${GENERATED_EVALUATION_IMPL_FILE}")
+  add_dependencies(${OUTPUT_TARGET} ${GENERATE_TARGET})
+endfunction()
diff --git a/cmake/CeresConfig.cmake.in b/cmake/CeresConfig.cmake.in
index ced7daf..fd84dd2 100644
--- a/cmake/CeresConfig.cmake.in
+++ b/cmake/CeresConfig.cmake.in
@@ -166,6 +166,10 @@
 include(CMakeFindDependencyMacro)
 find_dependency(Threads)
 
+# Import code generation functions s/t they are available for use in client code
+# if find_package(Ceres) is successful.
+include(CeresCodeGeneration.cmake)
+
 # Eigen.
 # Flag set during configuration and build of Ceres.
 set(CERES_EIGEN_VERSION @EIGEN3_VERSION_STRING@)
diff --git a/cmake/codegen_include.inc.in b/cmake/codegen_include.inc.in
new file mode 100644
index 0000000..f52485b
--- /dev/null
+++ b/cmake/codegen_include.inc.in
@@ -0,0 +1,10 @@
+// This file is generated by Ceres autodiff code generation.
+// http://ceres-solver.org/
+
+#ifdef CERES_CODEGEN
+// Included by generator during generation of autodiff evaluation implementation,
+// by definition the generated implementation does not yet exist to be imported.
+#else
+// Included from client code, import generated implementation.
+#include "@OUTPUT_DIRECTORY@/@LOWER_CASE_FUNCTOR_NAME@_evaluate_impl.inc"
+#endif
diff --git a/cmake/generate_code_for_functor.cc.in b/cmake/generate_code_for_functor.cc.in
new file mode 100644
index 0000000..2ae2640
--- /dev/null
+++ b/cmake/generate_code_for_functor.cc.in
@@ -0,0 +1,27 @@
+// This file is generated by Ceres autodiff code generation."
+// http://ceres-solver.org/
+
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "ceres/codegen/generate_code_for_functor.h"
+#include "@COST_FUNCTOR_INPUT_FILE@"
+
+int main() {
+  const std::vector<std::string> lines =
+      ceres::GenerateCodeForFunctor<@FULL_CXX_FUNCTOR_TYPE_NAME@>(
+          ceres::AutoDiffCodeGenOptions());
+  const std::string output_file = "@GENERATED_EVALUATION_IMPL_FILE@";
+  std::ofstream stream(output_file);
+  if (!stream.is_open()) {
+    std::cerr << "Could not open file " << output_file << std::endl;
+    return EXIT_FAILURE;
+  }
+  for (auto line : lines) {
+    stream << line << std::endl;
+  }
+  return EXIT_SUCCESS;
+}
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index e2f4df4..f185d19 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -73,8 +73,15 @@
 target_link_libraries(simple_bundle_adjuster ceres)
 
 if(CODE_GENERATION)
-  add_executable(autodiff_codegen autodiff_codegen.cc)
-  target_link_libraries(autodiff_codegen ceres)
+  include(CeresCodeGeneration)
+  ceres_generate_cost_function_implementation_for_functor(
+    NAME HelloWorldCostFunction
+    INPUT_FILE helloworld_cost_function.h
+    OUTPUT_DIRECTORY examples
+    NAMESPACE helloworld
+    )
+  add_executable(helloworld_codegen helloworld_codegen.cc )
+  target_link_libraries(helloworld_codegen ceres HelloWorldCostFunction)
 endif(CODE_GENERATION)
 
 if (GFLAGS)
diff --git a/examples/autodiff_codegen.cc b/examples/helloworld_codegen.cc
similarity index 69%
copy from examples/autodiff_codegen.cc
copy to examples/helloworld_codegen.cc
index 7813ac4..6aa0792 100644
--- a/examples/autodiff_codegen.cc
+++ b/examples/helloworld_codegen.cc
@@ -29,27 +29,37 @@
 // Author: darius.rueckert@fau.de (Darius Rueckert)
 //
 // A simple example showing how to generate code for a cost functor
-//
-// We recommend to use the CMake integration instead of using
-// GenerateCodeForFunctor directly.
-//
-#include "ceres/codegen/autodiff.h"
 
-struct SquareFunctor {
-  template <typename T>
-  bool operator()(const T* x, T* residual) const {
-    residual[0] = x[0] * x[0];
-    isfinite(x[0]);
-    return true;
-  }
-};
+#include "ceres/ceres.h"
+#include "glog/logging.h"
+#include "helloworld_cost_function.h"
+
+using ceres::CostFunction;
+using ceres::Problem;
+using ceres::Solve;
+using ceres::Solver;
 
 int main(int argc, char** argv) {
-  std::vector<std::string> code =
-      ceres::GenerateCodeForFunctor<SquareFunctor, 1, 1>(
-          ceres::AutoDiffCodeGenOptions());
-  for (auto str : code) {
-    std::cout << str << std::endl;
-  }
+  google::InitGoogleLogging(argv[0]);
+
+  // The variable to solve for with its initial value. It will be
+  // mutated in place by the solver.
+  double x = 0.5;
+  const double initial_x = x;
+
+  Problem problem;
+
+  const double kTargetValue = 10.0;
+  CostFunction* cost_function =
+      new helloworld::HelloWorldCostFunction(kTargetValue);
+  problem.AddResidualBlock(cost_function, NULL, &x);
+
+  Solver::Options options;
+  options.minimizer_progress_to_stdout = true;
+  Solver::Summary summary;
+  Solve(options, &problem, &summary);
+
+  std::cout << summary.BriefReport() << "\n";
+  std::cout << "x : " << initial_x << " -> " << x << "\n";
   return 0;
 }
diff --git a/examples/autodiff_codegen.cc b/examples/helloworld_cost_function.h
similarity index 72%
rename from examples/autodiff_codegen.cc
rename to examples/helloworld_cost_function.h
index 7813ac4..764d6c7 100644
--- a/examples/autodiff_codegen.cc
+++ b/examples/helloworld_cost_function.h
@@ -28,28 +28,29 @@
 //
 // Author: darius.rueckert@fau.de (Darius Rueckert)
 //
-// A simple example showing how to generate code for a cost functor
-//
-// We recommend to use the CMake integration instead of using
-// GenerateCodeForFunctor directly.
-//
-#include "ceres/codegen/autodiff.h"
+#include "ceres/codegen/codegen_cost_function.h"
 
-struct SquareFunctor {
+namespace helloworld {
+
+struct HelloWorldCostFunction : public ceres::CodegenCostFunction<1, 1> {
+  // We need a default constructor, because code is generated for the cost
+  // functor and not a specific instantiation of it.
+  HelloWorldCostFunction() = default;
+  explicit HelloWorldCostFunction(double target_value)
+      : target_value_(target_value) {}
+
   template <typename T>
   bool operator()(const T* x, T* residual) const {
-    residual[0] = x[0] * x[0];
-    isfinite(x[0]);
+    residual[0] = CERES_LOCAL_VARIABLE(T, target_value_) - x[0];
     return true;
   }
+
+// The include file name is automatically generated as
+// "<output_dir>/<lower_case_class_name>.h"
+#include "examples/helloworldcostfunction.h"
+
+ private:
+  double target_value_;
 };
 
-int main(int argc, char** argv) {
-  std::vector<std::string> code =
-      ceres::GenerateCodeForFunctor<SquareFunctor, 1, 1>(
-          ceres::AutoDiffCodeGenOptions());
-  for (auto str : code) {
-    std::cout << str << std::endl;
-  }
-  return 0;
-}
+}  // namespace helloworld
diff --git a/include/ceres/codegen/codegen_cost_function.h b/include/ceres/codegen/codegen_cost_function.h
new file mode 100644
index 0000000..57df088
--- /dev/null
+++ b/include/ceres/codegen/codegen_cost_function.h
@@ -0,0 +1,90 @@
+// Ceres Solver - A fast non-linear least squares minimizer
+// Copyright 2019 Google Inc. All rights reserved.
+// http://code.google.com/p/ceres-solver/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors may be
+//   used to endorse or promote products derived from this software without
+//   specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: darius.rueckert@fau.de (Darius Rueckert)
+//
+#ifndef CERES_PUBLIC_CODEGEN_COST_FUNCTION_H_
+#define CERES_PUBLIC_CODEGEN_COST_FUNCTION_H_
+
+#include "ceres/codegen/macros.h"
+#include "ceres/sized_cost_function.h"
+
+namespace ceres {
+
+// This is the interface for automatically generating cost functor derivative
+// code. The template parameters are identical to those of SizedCostFunction<>.
+// The behaviour of this class changes between code generation and problem
+// solving.
+//
+// During code generation (when CERES_CODEGEN is defined), this class doesn't do
+// anything. The templated operator() from your derived cost functor is used.
+//
+// After code generation (when CERES_CODEGEN is not defined), this class is a
+// SizedCostFunction. The required Evaluate() function was generated and must be
+// included into your cost functor.
+//
+// Usage Example:
+//
+//   #include "ceres/codegen/cost_function.h"
+//
+//   struct HelloWorldCostFunction : public ceres::CodegenCostFunction<1, 1> {
+//     // A default constructor is required, because the code generator has to
+//     // create an object of the cost function.
+//     HelloWorldCostFunction() = default;
+//     template <typename T>
+//     bool operator()(const T* x, T* residual) const {
+//       residual[0] = x[0] * x[0];
+//       return true;
+//     }
+//   #include "examples/helloworldcostfunction.h"
+//   };
+
+template <int kNumResiduals_, int... Ns>
+class CodegenCostFunction
+#ifdef CERES_CODEGEN
+// During code generation we can't derive from SizedCostFunction.
+// The variadic evaluation with Jets would try to call the empty Evaluate()
+// instead of the templated functor.
+#else
+    : public SizedCostFunction<kNumResiduals_, Ns...>
+#endif
+{
+ public:
+  static constexpr int kNumResiduals = kNumResiduals_;
+  static_assert(kNumResiduals > 0,
+                "Cost functions must have at least one residual block.");
+  static_assert(kNumResiduals != DYNAMIC,
+                "Code generation for dynamic residuals is not yet supported.");
+  static_assert(internal::StaticParameterDims<Ns...>::kIsValid,
+                "Invalid parameter block dimension detected. Each parameter "
+                "block dimension must be bigger than zero.");
+  using ParameterDims = internal::StaticParameterDims<Ns...>;
+};
+
+}  // namespace ceres
+#endif  // CERES_PUBLIC_CODEGEN_COST_FUNCTION_H_
diff --git a/include/ceres/codegen/autodiff.h b/include/ceres/codegen/generate_code_for_functor.h
similarity index 88%
rename from include/ceres/codegen/autodiff.h
rename to include/ceres/codegen/generate_code_for_functor.h
index 0a2a65d..31ccdb2 100644
--- a/include/ceres/codegen/autodiff.h
+++ b/include/ceres/codegen/generate_code_for_functor.h
@@ -42,18 +42,17 @@
 struct AutoDiffCodeGenOptions {};
 
 // TODO(darius): Documentation
-template <typename CostFunctor, int kNumResiduals, int... Ns>
+template <typename DerivedCostFunctor>
 std::vector<std::string> GenerateCodeForFunctor(
     const AutoDiffCodeGenOptions& options) {
-  static_assert(kNumResiduals != DYNAMIC,
-                "A dynamic number of residuals is currently not supported.");
   // Define some types and shortcuts to make the code below more readable.
-  using ParameterDims = internal::StaticParameterDims<Ns...>;
+  using ParameterDims = typename DerivedCostFunctor::ParameterDims;
   using Parameters = typename ParameterDims::Parameters;
   // Instead of using scalar Jets, we use Jets of ExpressionRef which record
   // their own operations during evaluation.
   using ExpressionRef = internal::ExpressionRef;
   using ExprJet = Jet<ExpressionRef, ParameterDims::kNumParameters>;
+  constexpr int kNumResiduals = DerivedCostFunctor::kNumResiduals;
   constexpr int kNumParameters = ParameterDims::kNumParameters;
   constexpr int kNumParameterBlocks = ParameterDims::kNumParameterBlocks;
 
@@ -61,7 +60,11 @@
   // Code is generated for the CostFunctor and not an instantiation of it. This
   // is different to AutoDiffCostFunction, which computes the derivatives for
   // a specific object.
-  CostFunctor functor;
+  static_assert(std::is_default_constructible<DerivedCostFunctor>::value,
+                "Cost functors used in code generation must have a default "
+                "constructor. If you are using local variables, make sure to "
+                "wrap them into the CERES_LOCAL_VARIABLE macro.");
+  DerivedCostFunctor functor;
 
   // During recording phase all operations on ExpressionRefs are recorded to an
   // internal data structure, the ExpressionGraph. This ExpressionGraph is then
@@ -164,7 +167,7 @@
     internal::CodeGenerator::Options generator_options;
     generator_options.function_name =
         "void EvaluateResidual(double const* const* parameters, double* "
-        "residuals)";
+        "residuals) const";
     internal::CodeGenerator gen(residual_graph, generator_options);
     std::vector<std::string> code = gen.Generate();
     output.insert(output.end(), code.begin(), code.end());
@@ -179,7 +182,7 @@
     generator_options.function_name =
         "void EvaluateResidualAndJacobian(double const* const* parameters, "
         "double* "
-        "residuals, double** jacobians)";
+        "residuals, double** jacobians) const";
     internal::CodeGenerator gen(residual_and_jacobian_graph, generator_options);
     std::vector<std::string> code = gen.Generate();
     output.insert(output.end(), code.begin(), code.end());
@@ -193,8 +196,12 @@
   // in SizedCostFunctions.
   output.emplace_back("bool Evaluate(double const* const* parameters,");
   output.emplace_back("              double* residuals,");
-  output.emplace_back("              double** jacobians) {");
-  output.emplace_back("   if (jacobians) {");
+  output.emplace_back("              double** jacobians) const {");
+
+  output.emplace_back("   if (!jacobians) {");
+  output.emplace_back("     EvaluateResidual(parameters, residuals);");
+  output.emplace_back("     return true;");
+  output.emplace_back("   }");
 
   // Create a tmp array of all jacobians and use it for evaluation.
   // The generated code for a <2,3,1,2> cost functor is:
@@ -204,19 +211,19 @@
   //       jacobians_data + 6,
   //       jacobians_data + 8,
   //   };
-  output.emplace_back("     double jacobians_data[" +
+  output.emplace_back("   double jacobians_data[" +
                       std::to_string(kNumParameters * kNumResiduals) + "];");
-  output.emplace_back("     double* jacobians_ptrs[] = {");
+  output.emplace_back("   double* jacobians_ptrs[] = {");
   for (int i = 0, total_param_id = 0; i < kNumParameterBlocks;
        total_param_id += ParameterDims::GetDim(i), ++i) {
-    output.emplace_back("       jacobians_data + " +
+    output.emplace_back("     jacobians_data + " +
                         std::to_string(kNumResiduals * total_param_id) + ",");
   }
-  output.emplace_back("     };");
+  output.emplace_back("   };");
 
   // Evaluate into the tmp array.
   output.emplace_back(
-      "     EvaluateResidualAndJacobian(parameters, residuals, "
+      "   EvaluateResidualAndJacobian(parameters, residuals, "
       "jacobians_ptrs);");
 
   // Copy the computed jacobians into the output array. Add an if-statement to
@@ -238,18 +245,15 @@
   //      }
   //    }
   for (int i = 0; i < kNumParameterBlocks; ++i) {
-    output.emplace_back("     if (jacobians[" + std::to_string(i) + "]) {");
+    output.emplace_back("   if (jacobians[" + std::to_string(i) + "]) {");
     output.emplace_back(
-        "       for (int i = 0; i < " +
+        "     for (int i = 0; i < " +
         std::to_string(ParameterDims::GetDim(i) * kNumResiduals) + "; ++i) {");
-    output.emplace_back("         jacobians[" + std::to_string(i) +
+    output.emplace_back("       jacobians[" + std::to_string(i) +
                         "][i] = jacobians_ptrs[" + std::to_string(i) + "][i];");
-    output.emplace_back("       }");
     output.emplace_back("     }");
+    output.emplace_back("   }");
   }
-  output.emplace_back("     return true;");
-  output.emplace_back("   }");
-  output.emplace_back("   EvaluateResidual(parameters, residuals);");
   output.emplace_back("   return true;");
   output.emplace_back("}");