diff --git a/python/dune/perftool/pdelab/driver.py b/python/dune/perftool/pdelab/driver.py
index f413b1f20fac6d2ba8f72f8ab1474113f51b629e..54bc9b4b997ccbc882ef284aeffedba73f8106ec 100644
--- a/python/dune/perftool/pdelab/driver.py
+++ b/python/dune/perftool/pdelab/driver.py
@@ -192,7 +192,7 @@ def typedef_grid(name):
             include_file("dune/alugrid/grid.hh", filetag="driver")
         else:
             raise ValueError("Cant match your geometry with a DUNE grid. Please report bug.")
-    return "typedef {} {};".format(gridt, name)
+    return "using {} = {};".format(name, gridt)
 
 
 @symbol
@@ -219,7 +219,7 @@ def name_grid():
 @preamble
 def typedef_leafview(name):
     grid = type_grid()
-    return "typedef {}::LeafGridView {};".format(grid, name)
+    return "using {} = {}::LeafGridView;".format(name, grid)
 
 
 @symbol
@@ -245,7 +245,7 @@ def name_leafview():
 def typedef_vtkwriter(name):
     include_file("dune/grid/io/file/vtk/subsamplingvtkwriter.hh", filetag="driver")
     gv = type_leafview()
-    return "typedef Dune::SubsamplingVTKWriter<{}> {};".format(gv, name)
+    return "using {} = Dune::SubsamplingVTKWriter<{}>;".format(name, gv)
 
 
 @symbol
@@ -283,7 +283,7 @@ def name_vtkwriter():
 @preamble
 def typedef_domainfield(name):
     gridt = type_grid()
-    return "typedef {}::ctype {};".format(gridt, name)
+    return "using {} = {}::ctype;".format(name, gridt)
 
 
 @symbol
@@ -294,7 +294,7 @@ def type_domainfield():
 
 @preamble
 def typedef_range(name):
-    return "typedef double {};".format(name)
+    return "using {} = double;".format(name)
 
 
 @symbol
@@ -311,18 +311,18 @@ def typedef_fem(expr, name):
     dim = name_dimension()
     if isPk(expr):
         include_file("dune/pdelab/finiteelementmap/pkfem.hh", filetag="driver")
-        return "typedef Dune::PDELab::PkLocalFiniteElementMap<{}, {}, {}, {}> {};".format(gv, df, r, expr._degree, name)
+        return "using {} = Dune::PDELab::PkLocalFiniteElementMap<{}, {}, {}, {}>;".format(name, gv, df, r, expr._degree)
     if isQk(expr):
         include_file("dune/pdelab/finiteelementmap/qkfem.hh", filetag="driver")
-        return "typedef Dune::PDELab::QkLocalFiniteElementMap<{}, {}, {}, {}> {};".format(gv, df, r, expr._degree, name)
+        return "using {} = Dune::PDELab::QkLocalFiniteElementMap<{}, {}, {}, {}>;".format(name, gv, df, r, expr._degree)
     if isDG(expr):
         if isQuadrilateral(expr):
             include_file("dune/pdelab/finiteelementmap/qkdg.hh", filetag="driver")
             # TODO allow switching the basis here!
-            return "typedef Dune::PDELab::QkDGLocalFiniteElementMap<{}, {}, {}, {}> {};".format(df, r, expr._degree, dim, name)
+            return "using {} = Dune::PDELab::QkDGLocalFiniteElementMap<{}, {}, {}, {}>;".format(name, df, r, expr._degree, dim)
         if isSimplical(expr):
             include_file("dune/pdelab/finiteelementmap/opbfem.hh", filetag="driver")
-            return "typedef Dune::PDELab::OPBLocalFiniteElementMap<{}, {}, {}, {}, Dune::GeometryType::simplex> {};".format(df, r, expr._degree, dim, name)
+            return "using {} = Dune::PDELab::OPBLocalFiniteElementMap<{}, {}, {}, {}, Dune::GeometryType::simplex>;".format(name, df, r, expr._degree, dim)
         raise NotImplementedError("Geometry type not known in code generation")
 
     raise NotImplementedError("FEM not implemented in dune-perftool")
@@ -355,7 +355,7 @@ def name_fem(expr):
 @preamble
 def typedef_vectorbackend(name):
     include_file("dune/pdelab/backend/istl.hh", filetag="driver")
-    return "typedef Dune::PDELab::istl::VectorBackend<Dune::PDELab::istl::Blocking::none, 1> {};".format(name)
+    return "using {} = Dune::PDELab::istl::VectorBackend<Dune::PDELab::istl::Blocking::none, 1>;".format(name)
 
 
 @symbol
@@ -372,12 +372,12 @@ def type_orderingtag():
 @preamble
 def typedef_dirichlet_constraintsassembler(name):
     include_file("dune/pdelab/constraints/conforming.hh", filetag="driver")
-    return "typedef Dune::PDELab::ConformingDirichletConstraints {};".format(name)
+    return "using {} = Dune::PDELab::ConformingDirichletConstraints;".format(name)
 
 
 @preamble
 def typedef_no_constraintsassembler(name):
-    return "typedef Dune::PDELab::NoConstraints {};".format(name)
+    return "using {} = Dune::PDELab::NoConstraints;".format(name)
 
 
 @symbol
@@ -394,7 +394,7 @@ def type_constraintsassembler(dirichlet):
 def typedef_constraintscontainer(element, name):
     gfs = type_gfs(element)
     r = type_range()
-    return "typedef {}::ConstraintsContainer<{}>::Type {};".format(gfs, r, name)
+    return "using {} = {}::ConstraintsContainer<{}>::Type;".format(name, gfs, r)
 
 
 @symbol
@@ -516,7 +516,7 @@ def typedef_gfs(element, dirichlet, name):
         gv = type_leafview()
         fem = type_fem(element)
         cass = type_constraintsassembler(dirichlet)
-        return "typedef Dune::PDELab::GridFunctionSpace<{}, {}, {}, {}> {};".format(gv, fem, cass, vb, name)
+        return "using {} = Dune::PDELab::GridFunctionSpace<{}, {}, {}, {}>;".format(name, gv, fem, cass, vb)
     if isinstance(element, (VectorElement, TensorElement)):
         include_file("dune/pdelab/gridfunctionspace/vectorgridfunctionspace.hh", filetag="driver")
         gv = type_leafview()
@@ -524,11 +524,11 @@ def typedef_gfs(element, dirichlet, name):
         # TODO implement symmetry here
         dim = element.num_sub_elements()
         cass = type_constraintsassembler(dirichlet)
-        return "typedef Dune::PDELab::VectorGridFunctionSpace<{}, {}, {}, {}, {}, {}> {};".format(gv, fem, dim, vb, vb, cass, name)
+        return "using {} = Dune::PDELab::VectorGridFunctionSpace<{}, {}, {}, {}, {}, {}>;".format(name, gv, fem, dim, vb, vb, cass)
     if isinstance(element, MixedElement):
         ot = type_orderingtag()
         args = ", ".join(type_gfs(e) for e in element.sub_elements())
-        return "typedef Dune::PDELab::CompositeGridFunctionSpace<{}, {}, {}> {};".format(vb, ot, args, name)
+        return "using {} = Dune::PDELab::CompositeGridFunctionSpace<{}, {}, {}>;".format(name, vb, ot, args)
     if isinstance(element, EnrichedElement):
         raise NotImplementedError("Dune does not support enriched elements!")
     if isinstance(element, RestrictedElement):
@@ -591,7 +591,7 @@ def name_dofestimate():
 @preamble
 def typedef_matrixbackend(name):
     include_file("dune/pdelab/backend/istl.hh", filetag="driver")
-    return "typedef Dune::PDELab::istl::BCRSMatrixBackend<> {};".format(name)
+    return "using {} = Dune::PDELab::istl::BCRSMatrixBackend<>;".format(name)
 
 
 @symbol
@@ -639,7 +639,7 @@ def name_parameters(formdata):
 def typedef_localoperator(name, formdata):
     # No Parameter class here, yet
     # params = type_parameters()
-    # return "typedef LocalOperator<{}> {};".format(params, name)
+    # return "using {} = LocalOperator<{}>;".format(name, params)
     ugfs = type_gfs(_driver_data['form'].coefficients()[0].ufl_element())
     vgfs = type_gfs(_driver_data['form'].arguments()[0].ufl_element())
     from dune.perftool.generation import get_global_context_value
@@ -684,7 +684,7 @@ def typedef_gridoperator(name, formdata):
     df = type_domainfield()
     r = type_range()
     include_file("dune/pdelab/gridoperator/gridoperator.hh", filetag="driver")
-    return "typedef Dune::PDELab::GridOperator<{}, {}, {}, {}, {}, {}, {}, {}, {}> {};".format(ugfs, vgfs, lop, mb, df, r, r, ucc, vcc, name)
+    return "using {} = Dune::PDELab::GridOperator<{}, {}, {}, {}, {}, {}, {}, {}, {}>;".format(name, ugfs, vgfs, lop, mb, df, r, r, ucc, vcc)
 
 
 @symbol
@@ -719,7 +719,7 @@ def name_gridoperator(formdata):
 @preamble
 def typedef_vector(name, formdata):
     go_type = type_gridoperator(formdata)
-    return "typedef {}::Traits::Domain {};".format(go_type, name)
+    return "using {} = {}::Traits::Domain;".format(name, go_type)
 
 
 @symbol
@@ -885,7 +885,7 @@ def name_vector_from_solution_expression():
 @preamble
 def typedef_linearsolver(name):
     include_file("dune/pdelab/backend/istl.hh", filetag="driver")
-    return "typedef Dune::PDELab::ISTLBackend_SEQ_UMFPack {};".format(name)
+    return "using {} = Dune::PDELab::ISTLBackend_SEQ_UMFPack;".format(name)
 
 
 @symbol
@@ -924,7 +924,7 @@ def typedef_stationarylinearproblemsolver(name):
     gotype = type_gridoperator(_driver_data['formdata'])
     lstype = type_linearsolver()
     xtype = type_vector(_driver_data['formdata'])
-    return "typedef Dune::PDELab::StationaryLinearProblemSolver<{}, {}, {}> {};".format(gotype, lstype, xtype, name)
+    return "using {} = Dune::PDELab::StationaryLinearProblemSolver<{}, {}, {}>;".format(name, gotype, lstype, xtype)
 
 
 @symbol
@@ -955,7 +955,7 @@ def typedef_stationarynonlinearproblemsolver(name, go_type):
     include_file("dune/pdelab/newton/newton.hh", filetag="driver")
     ls_type = type_linearsolver()
     x_type = type_vector(_driver_data['formdata'])
-    return "typedef Dune::PDELab::Newton<{}, {}, {}> {};".format(go_type, ls_type, x_type, name)
+    return "using {} = Dune::PDELab::Newton<{}, {}, {}>;".format(name, go_type, ls_type, x_type)
 
 
 @symbol
@@ -983,9 +983,9 @@ def typedef_timesteppingmethod(name):
     r_type = type_range()
     explicit = get_option('explicit_time_stepping')
     if explicit:
-        return "typedef Dune::PDELab::ExplicitEulerParameter<{}> {};".format(r_type, name)
+        return "using {} = Dune::PDELab::ExplicitEulerParameter<{}>;".format(name, r_type)
     else:
-        return "typedef Dune::PDELab::OneStepThetaParameter<{}> {};".format(r_type, name)
+        return "using {} = Dune::PDELab::OneStepThetaParameter<{}>;".format(name, r_type)
 
 
 @symbol
@@ -1017,9 +1017,9 @@ def typedef_instationarygridoperator(name):
     mass_go_type = type_gridoperator(_driver_data['mass_formdata'])
     explicit = get_option('explicit_time_stepping')
     if explicit:
-        return "typedef Dune::PDELab::OneStepGridOperator<{},{},false> {};".format(go_type, mass_go_type, name)
+        return "using {} = Dune::PDELab::OneStepGridOperator<{},{},false>;".format(name, go_type, mass_go_type)
     else:
-        return "typedef Dune::PDELab::OneStepGridOperator<{},{}> {};".format(go_type, mass_go_type, name)
+        return "using {} = Dune::PDELab::OneStepGridOperator<{},{}>;".format(name, go_type, mass_go_type)
 
 
 @symbol
@@ -1048,7 +1048,7 @@ def typedef_onestepmethod(name):
     igo_type = type_instationarygridoperator()
     snp_type = type_stationarynonlinearproblemssolver(igo_type)
     vector_type = type_vector(_driver_data['formdata'])
-    return "typedef Dune::PDELab::OneStepMethod<{}, {}, {}, {}, {}> {};".format(r_type, igo_type, snp_type, vector_type, vector_type, name)
+    return "using {} = Dune::PDELab::OneStepMethod<{}, {}, {}, {}, {}>;".format(name, r_type, igo_type, snp_type, vector_type, vector_type)
 
 
 @symbol
@@ -1079,7 +1079,7 @@ def typedef_explicitonestepmethod(name):
     igo_type = type_instationarygridoperator()
     ls_type = type_linearsolver()
     vector_type = type_vector(_driver_data['formdata'])
-    return "typedef Dune::PDELab::ExplicitOneStepMethod<{}, {}, {}, {}> {};".format(r_type, igo_type, ls_type, vector_type, name)
+    return "using {} = Dune::PDELab::ExplicitOneStepMethod<{}, {}, {}, {}>;".format(name, r_type, igo_type, ls_type, vector_type)
 
 
 @symbol
@@ -1213,7 +1213,7 @@ def type_discrete_grid_function(gfs):
 @preamble
 def define_discrete_grid_function(gfs, vector_name, dgf_name):
     dgf_type = type_discrete_grid_function(gfs)
-    return ["typedef Dune::PDELab::DiscreteGridFunction<decltype({}),decltype({})> {};".format(gfs, vector_name, dgf_type),
+    return ["using {} = Dune::PDELab::DiscreteGridFunction<decltype({}),decltype({})>;".format(dgf_type, gfs, vector_name),
             "{} {}({},{});".format(dgf_type, dgf_name, gfs, vector_name)]
 
 
@@ -1260,7 +1260,7 @@ def typedef_difference_squared_adapter(name, tree_path):
     vector = name_vector(formdata)
     dgf = name_discrete_grid_function(gfs, vector)
 
-    return 'typedef DifferenceSquaredAdapter<decltype({}), decltype({})> {};'.format(solution_function, dgf, name)
+    return 'using {} = DifferenceSquaredAdapter<decltype({}), decltype({})>;'.format(name, solution_function, dgf)
 
 
 @symbol
@@ -1386,7 +1386,7 @@ def print_matrix():
     t_v = type_vector(formdata)
 
     return ["if ({}.get<bool>(\"printmatrix\", false)) {{".format(ini),
-            "  typedef typename {}::Traits::Jacobian M;".format(t_go),
+            "  using M = typename {}::Traits::Jacobian;".format(t_go),
             "  M m({});".format(n_go),
             "  {}.jacobian({},m);".format(n_go, v),
             "  using Dune::PDELab::Backend::native;",
@@ -1466,7 +1466,7 @@ def name_time():
 def typedef_vtk_sequence_writer(name):
     include_file("dune/grid/io/file/vtk/vtksequencewriter.hh", filetag="driver")
     gv_type = type_leafview()
-    return "typedef Dune::VTKSequenceWriter<{}> {};".format(gv_type, name)
+    return "using {} = Dune::VTKSequenceWriter<{}>;".format(name, gv_type)
 
 
 @symbol