diff --git a/python/py_akantu.cc b/python/py_akantu.cc
index 14a11bffe..cf514abeb 100644
--- a/python/py_akantu.cc
+++ b/python/py_akantu.cc
@@ -1,113 +1,114 @@
 /* -------------------------------------------------------------------------- */
 #include "aka_config.hh"
 /* -------------------------------------------------------------------------- */
 #include "py_aka_common.hh"
 #include "py_aka_error.hh"
 #include "py_boundary_conditions.hh"
 #include "py_fe_engine.hh"
 #include "py_group_manager.hh"
 #include "py_mesh.hh"
 #include "py_model.hh"
 #include "py_parser.hh"
 
 #if defined(AKANTU_USE_IOHELPER)
 #include "py_dumpable.hh"
 #endif
 
 #if defined(AKANTU_SOLID_MECHANICS)
 #include "py_material.hh"
 #include "py_solid_mechanics_model.hh"
 #endif
 
 #if defined(AKANTU_HEAT_TRANSFER)
 #include "py_heat_transfer_model.hh"
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
 #include "py_solid_mechanics_model_cohesive.hh"
 #endif
 
 
 #if defined(AKANTU_PHASE_FIELD)
 #include "py_phase_field_model.hh"
 #endif
 
 /* -------------------------------------------------------------------------- */
 #include <aka_error.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 #include <iostream>
 /* -------------------------------------------------------------------------- */
 
 namespace py = pybind11;
 
 namespace akantu {
 void register_all(pybind11::module & mod) {
   register_initialize(mod);
   register_enums(mod);
   register_error(mod);
   register_functions(mod);
   register_parser(mod);
 
   register_group_manager(mod);
 #if defined(AKANTU_USE_IOHELPER)
   register_dumpable(mod);
 #endif
   register_mesh(mod);
 
   register_fe_engine(mod);
 
   register_boundary_conditions(mod);
   register_model(mod);
 #if defined(AKANTU_HEAT_TRANSFER)
   register_heat_transfer_model(mod);
 #endif
 
 #if defined(AKANTU_SOLID_MECHANICS)
   register_solid_mechanics_model(mod);
   register_material(mod);
 #endif
 
 #if defined(AKANTU_COHESIVE_ELEMENT)
   register_solid_mechanics_model_cohesive(mod);
 #endif
 
 #if defined(AKANTU_PHASE_FIELD)
   register_phase_field_model(mod);
+  register_phase_field_coupler(mod);
 #endif
 }
 } // namespace akantu
 
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
 PYBIND11_MODULE(py11_akantu, mod) {
   mod.doc() = "Akantu python interface";
 
   static py::exception<akantu::debug::Exception>
       akantu_exception(mod, "Exception");
 
   py::register_exception_translator([](std::exception_ptr ptr) {
     try {
       if (ptr) {
         std::rethrow_exception(ptr);
       }
     } catch (akantu::debug::Exception & e) {
       if (akantu::debug::debugger.printBacktrace()) {
         akantu::debug::printBacktrace();
       }
       akantu_exception(e.info().c_str());
     }
   });
 
   akantu::register_all(mod);
 
   mod.def("has_mpi", []() {
 #if defined(AKANTU_USE_MPI)
     return true;
 #else
     return false;
 #endif
   });
 
 } // Module akantu
diff --git a/python/py_phase_field_model.cc b/python/py_phase_field_model.cc
index 61cd00ff0..91cd30c42 100644
--- a/python/py_phase_field_model.cc
+++ b/python/py_phase_field_model.cc
@@ -1,99 +1,121 @@
 /* -------------------------------------------------------------------------- */
 #include "py_aka_array.hh"
 /* -------------------------------------------------------------------------- */
 #include <non_linear_solver.hh>
 #include <phase_field_model.hh>
+#include <coupler_solid_phasefield.hh>
 /* -------------------------------------------------------------------------- */
 #include <pybind11/pybind11.h>
 /* -------------------------------------------------------------------------- */
 namespace py = pybind11;
 /* -------------------------------------------------------------------------- */
 
 namespace akantu {
 
 /* -------------------------------------------------------------------------- */
 #define def_deprecated(func_name, mesg)                                        \
   def(func_name, [](py::args, py::kwargs) { AKANTU_ERROR(mesg); })
 
 #define def_function_nocopy(func_name)                                         \
   def(#func_name,                                                              \
       [](PhaseFieldModel & self) -> decltype(auto) {                           \
         return self.func_name();                                               \
       },                                                                       \
       py::return_value_policy::reference)
 
 #define def_function(func_name)                                                \
   def(#func_name, [](PhaseFieldModel & self) -> decltype(auto) {               \
     return self.func_name();                                                   \
   })
 /* -------------------------------------------------------------------------- */
 
 
 [[gnu::visibility("default")]] void
 register_phase_field_model(py::module & mod) {
 
   py::class_<PhaseFieldModelOptions>(mod, "PhaseFieldModelOptions")
     .def(py::init<AnalysisMethod>(),
 	 py::arg("analysis_method") = _static);
 
   
   py::class_<PhaseFieldModel, Model>(mod, "PhaseFieldModel",
 				     py::multiple_inheritance())
       .def(py::init<Mesh &, UInt, const ID &, const MemoryID &,
                     const ModelType>(),
            py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
            py::arg("id") = "phase_field_model", py::arg("memory_id") = 0,
            py::arg("model_type") = ModelType::_phase_field_model)
       .def("initFull",
            [](PhaseFieldModel & self,
               const PhaseFieldModelOptions & options) {
              self.initFull(options);
            },
            py::arg("_analysis_method") = PhaseFieldModelOptions())
       .def("initFull",
            [](PhaseFieldModel & self,
               const AnalysisMethod & analysis_method) {
              self.initFull(_analysis_method = analysis_method);
            },
            py::arg("_analysis_method"))
       .def_deprecated("applyDirichletBC", "Deprecated: use applyBC")
       .def("applyBC",
            [](PhaseFieldModel & self,
               BC::Dirichlet::DirichletFunctor & func,
               const std::string & element_group) {
              self.applyBC(func, element_group);
            })
       .def("applyBC",
            [](PhaseFieldModel & self, BC::Neumann::NeumannFunctor & func,
               const std::string & element_group) {
              self.applyBC(func, element_group);
            })
       .def("setTimeStep", &PhaseFieldModel::setTimeStep,
            py::arg("time_step"), py::arg("solver_id") = "")
       .def_function(assembleStiffnessMatrix)
       .def_function(assembleInternalForces)
       .def_function_nocopy(getDamage)
       .def_function_nocopy(getInternalForce)
       .def_function_nocopy(getBlockedDOFs)
       .def_function_nocopy(getMesh)
       .def("dump", py::overload_cast<>(&PhaseFieldModel::dump))
       .def("dump",
            py::overload_cast<const std::string &>(&PhaseFieldModel::dump))
       .def("dump", py::overload_cast<const std::string &, UInt>(
                        &PhaseFieldModel::dump))
       .def("dump", py::overload_cast<const std::string &, Real, UInt>(
                        &PhaseFieldModel::dump))
       .def("getPhaseField",
            py::overload_cast<UInt>(&PhaseFieldModel::getPhaseField),
            py::return_value_policy::reference)
       .def("getPhaseField",
            py::overload_cast<const std::string &>(
 	       &PhaseFieldModel::getPhaseField),
            py::return_value_policy::reference)
       .def("getPhaseFieldIndex", &PhaseFieldModel::getPhaseFieldIndex)
       .def("setPhaseFieldSelector", &PhaseFieldModel::setPhaseFieldSelector);
 
 }
   
 
+[[gnu::visibility("default")]] void
+register_phase_field_coupler(py::module & mod) {
+  
+  py::class_<CouplerSolidPhaseField, Model>(mod, "CouplerSolidPhaseField")
+      .def(py::init<Mesh &, UInt, const ID &, const MemoryID &,
+	   const ModelType>(),
+           py::arg("mesh"), py::arg("spatial_dimension") = _all_dimensions,
+           py::arg("id") = "coupler_solid_phasefield", py::arg("memory_id") = 0,
+	   py::arg("model_type") = ModelType::_coupler_solid_phasefield)
+      .def("solve", [](CouplerSolidPhaseField & self) { self.solve(); })
+      .def("getSolidMechanicsModel",
+           &CouplerSolidPhaseField::getSolidMechanicsModel,
+           py::return_value_policy::reference)
+      .def("getPhaseFieldModel",
+           &CouplerSolidPhaseField::getPhaseFieldModel,
+           py::return_value_policy::reference);
+
+}
+  
+
+  
 }
diff --git a/python/py_phase_field_model.hh b/python/py_phase_field_model.hh
index 3024da69c..984d01e0d 100644
--- a/python/py_phase_field_model.hh
+++ b/python/py_phase_field_model.hh
@@ -1,12 +1,13 @@
 #ifndef __AKANTU_PY_PHASE_FIELD_MODEL_HH__
 #define __AKANTU_PY_PHASE_FIELD_MODEL_HH__
 
 namespace pybind11 {
   struct module;
 }//namespace pybind11
 
 namespace akantu {
   void register_phase_field_model(pybind11::module & mod);
+  void register_phase_field_coupler(pybind11::module & mod);
 } // namespace akantu
 
 #endif // __AKANTU_PY_PHASE_FIELD_MODEL_HH__