diff --git a/src/common/advice/index.hpp b/src/common/advice/index.hpp
index 63abbfa5e..41309469b 100644
--- a/src/common/advice/index.hpp
+++ b/src/common/advice/index.hpp
@@ -154,7 +154,8 @@ namespace advice {
       struct Entry
         : pair<Binding::Matcher, POA*>
         , boost::equality_comparable<Entry, POA,
-          boost::equality_comparable<Entry> >
+          boost::equality_comparable<Entry>
+        >
         {
           explicit
           Entry (POA& elm)
diff --git a/src/common/interfaceproxy.cpp b/src/common/interfaceproxy.cpp
index f09a62448..1f3220f38 100644
--- a/src/common/interfaceproxy.cpp
+++ b/src/common/interfaceproxy.cpp
@@ -55,7 +55,7 @@ namespace facade {
   class Holder;
   
   template<class FA, class I>
-  class Holder<InstanceHandle<I,FA> >
+  class Holder<InstanceHandle<I,FA>>
     : Accessor<FA>
     , protected FA
     {
diff --git a/src/common/query/defs-registry.hpp b/src/common/query/defs-registry.hpp
index a4449d328..41e3a91a8 100644
--- a/src/common/query/defs-registry.hpp
+++ b/src/common/query/defs-registry.hpp
@@ -141,7 +141,7 @@ namespace query  {
     struct Slot
       : public TableEntry
       {
-        typedef std::set<Record<TAR> > Registry;
+        typedef std::set<Record<TAR>> Registry;
         
         Registry registry;
         static size_t index; ///< where to find this Slot in every Table
diff --git a/src/gui/model/clip-track.cpp b/src/gui/model/clip-track.cpp
index fe71b2dfd..aad942e0c 100644
--- a/src/gui/model/clip-track.cpp
+++ b/src/gui/model/clip-track.cpp
@@ -49,7 +49,7 @@ namespace model {
     return os.str();
   }
 
-  lumiera::observable_list< shared_ptr<Clip> >&
+  lumiera::observable_list<shared_ptr<Clip>>&
   ClipTrack::getClipList()
   {
     return clips;
diff --git a/src/gui/model/clip-track.hpp b/src/gui/model/clip-track.hpp
index 24169a04e..9ebd049f0 100644
--- a/src/gui/model/clip-track.hpp
+++ b/src/gui/model/clip-track.hpp
@@ -55,12 +55,12 @@ namespace model {
     /**
      * Gets the list of clips associated with this track.
      */
-    lumiera::observable_list<shared_ptr<Clip> >&
+    lumiera::observable_list<shared_ptr<Clip>>&
     getClipList(void);
 
   private:
 
-    lumiera::observable_list<shared_ptr<Clip> > clips;
+    lumiera::observable_list<shared_ptr<Clip>> clips;
 
   };
 
diff --git a/src/gui/model/parent-track.cpp b/src/gui/model/parent-track.cpp
index 750edeacf..b7fc61ad1 100644
--- a/src/gui/model/parent-track.cpp
+++ b/src/gui/model/parent-track.cpp
@@ -32,13 +32,13 @@ ParentTrack::ParentTrack()
 {
 }
 
-const std::list<shared_ptr<Track> >&
+const std::list<shared_ptr<Track>>&
 ParentTrack::get_child_tracks() const
 {
   return tracks.get_list();
 }
 
-lumiera::observable_list<shared_ptr<Track> >&
+lumiera::observable_list<shared_ptr<Track>>&
 ParentTrack::get_child_track_list()
 {
   return tracks;
diff --git a/src/gui/model/parent-track.hpp b/src/gui/model/parent-track.hpp
index 12053e321..f378e3b8e 100644
--- a/src/gui/model/parent-track.hpp
+++ b/src/gui/model/parent-track.hpp
@@ -53,13 +53,13 @@ public:
   /**
    * Gets a read-only reference to the the list of child tracks.
    */
-  const std::list<shared_ptr<Track> >&
+  const std::list<shared_ptr<Track>>&
     get_child_tracks() const;
 
   /**
    * Gets read-write access to the list of child tracks.
    */
-  lumiera::observable_list<shared_ptr<Track> >&
+  lumiera::observable_list<shared_ptr<Track>>&
     get_child_track_list();
 
   /**
@@ -91,7 +91,7 @@ protected:
   /**
    * The internal list of child tracks of this parent.
    */
-  lumiera::observable_list<shared_ptr<Track> > tracks;
+  lumiera::observable_list<shared_ptr<Track>> tracks;
 };
 
 }   // namespace model
diff --git a/src/gui/widget/timeline-widget.cpp b/src/gui/widget/timeline-widget.cpp
index 40016d796..0fb05122b 100644
--- a/src/gui/widget/timeline-widget.cpp
+++ b/src/gui/widget/timeline-widget.cpp
@@ -189,7 +189,7 @@ namespace widget {
     return playbackPeriodDragReleasedSignal;
   }
   
-  sigc::signal<void, shared_ptr<timeline::Track> >
+  sigc::signal<void, shared_ptr<timeline::Track>>
   TimelineWidget::hovering_track_changed_signal() const
   {
     return hoveringTrackChangedSignal;
@@ -368,7 +368,7 @@ namespace widget {
   TimelineWidget::remove_orphaned_tracks()
   {
     std::map<shared_ptr<model::Track>,
-      shared_ptr<timeline::Track> >
+      shared_ptr<timeline::Track>>
       orphan_track_map(trackMap);
     
     // Remove all tracks which are still present in the sequence
@@ -378,7 +378,7 @@ namespace widget {
     
     // orphan_track_map now contains all the orphaned tracks
     // Remove them
-    std::pair<shared_ptr<model::Track>, shared_ptr<timeline::Track> >
+    std::pair<shared_ptr<model::Track>, shared_ptr<timeline::Track>>
       pair; 
     BOOST_FOREACH( pair, orphan_track_map )
       {
@@ -393,7 +393,7 @@ namespace widget {
   TimelineWidget::search_orphaned_tracks_in_branch(
       shared_ptr<model::Track> modelTrack,
       std::map<shared_ptr<model::Track>,
-      shared_ptr<timeline::Track> > &orphan_track_map)
+      shared_ptr<timeline::Track>>& orphan_track_map)
   {
     REQUIRE(modelTrack);
     
@@ -417,7 +417,7 @@ namespace widget {
     REQUIRE(modelTrack != sequence()); // The sequence isn't
                                         // really a track
     
-    std::map<shared_ptr<model::Track>, shared_ptr<timeline::Track> >::
+    std::map<shared_ptr<model::Track>, shared_ptr<timeline::Track>>::
       const_iterator iterator = trackMap.find(modelTrack);
     if (iterator == trackMap.end())
       {
diff --git a/src/gui/widget/timeline-widget.hpp b/src/gui/widget/timeline-widget.hpp
index bd7ba41c8..b6404b14f 100644
--- a/src/gui/widget/timeline-widget.hpp
+++ b/src/gui/widget/timeline-widget.hpp
@@ -127,8 +127,8 @@ namespace widget {
       
     public:
       /* ===== Signals ===== */
-      typedef sigc::signal<void, shared_ptr<timeline::TimelineState> > TimelineStateChangeSignal;
-      typedef sigc::signal<void, shared_ptr<timeline::Track> > HoveringTrackChangedSignal;
+      using TimelineStateChangeSignal  = sigc::signal<void, shared_ptr<timeline::TimelineState>>;
+      using HoveringTrackChangedSignal = sigc::signal<void, shared_ptr<timeline::Track>>;
       
       sigc::signal<void, lib::time::Time> mouse_hover_signal() const;
       
@@ -202,7 +202,7 @@ namespace widget {
       void
       search_orphaned_tracks_in_branch (shared_ptr<model::Track> modelTrack,
                                         std::map<shared_ptr<model::Track>,
-                                        shared_ptr<timeline::Track> > &orphan_track_map);
+                                        shared_ptr<timeline::Track>>& orphan_track_map);
       
       /**
        * Looks up a timeline UI track in trackMap that corresponds to a
@@ -270,7 +270,7 @@ namespace widget {
        * @deprecated for #955
        */
       std::map<shared_ptr<model::Track>
-              ,shared_ptr<timeline::Track> >
+              ,shared_ptr<timeline::Track>>
         trackMap;
         
       shared_ptr<timeline::Track> hoveringTrack;
diff --git a/src/gui/widget/timeline/timeline-clip-track.cpp b/src/gui/widget/timeline/timeline-clip-track.cpp
index e734cad10..04d4f92f1 100644
--- a/src/gui/widget/timeline/timeline-clip-track.cpp
+++ b/src/gui/widget/timeline/timeline-clip-track.cpp
@@ -68,7 +68,7 @@ namespace timeline {
     cairo->stroke();
     
     // Draw all clips
-    std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip> > pair; 
+    std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>> pair; 
     BOOST_FOREACH (pair, clipMap)
       {
         pair.second->draw(cairo, window);
@@ -78,7 +78,7 @@ namespace timeline {
   shared_ptr<timeline::Clip>
   ClipTrack::getClipAt(Time position) const
   {
-    std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip> >
+    std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>>
       pair; 
     BOOST_FOREACH (pair, clipMap)
       {
@@ -127,7 +127,8 @@ namespace timeline {
   ClipTrack::removeOrphanedClips ()
   {
     std::map< shared_ptr<model::Clip>,
-              shared_ptr<timeline::Clip> >
+              shared_ptr<timeline::Clip>
+            >
       orphanClipMap (clipMap);
     
     // Remove all clips which are still present in the sequence
@@ -137,7 +138,7 @@ namespace timeline {
     
     // orphanClipMap now contains all the orphaned clips
     // Remove them
-    std::pair< shared_ptr<model::Clip>, shared_ptr<timeline::Clip> >
+    std::pair<shared_ptr<model::Clip>, shared_ptr<timeline::Clip>>
       pair; 
     BOOST_FOREACH (pair, orphanClipMap)
       {
diff --git a/src/gui/window-manager.cpp b/src/gui/window-manager.cpp
index 0ef951a17..ed37c142c 100644
--- a/src/gui/window-manager.cpp
+++ b/src/gui/window-manager.cpp
@@ -103,7 +103,7 @@ namespace gui {
     REQUIRE(event);
     REQUIRE(event->window);
     
-    list< shared_ptr<WorkspaceWindow> >::iterator iterator = windowList.begin();
+    list<shared_ptr<WorkspaceWindow>>::iterator iterator{windowList.begin()};
     
     while (iterator != windowList.end())
       {
@@ -141,8 +141,7 @@ namespace gui {
   {
     bool enable = windowList.size() > 1;
     
-    list< shared_ptr<WorkspaceWindow> >::iterator iterator = 
-      windowList.begin();
+    list<shared_ptr<WorkspaceWindow>>::iterator iterator{windowList.begin()};
     
     while (iterator != windowList.end())
       {
diff --git a/src/lib/element-tracker.hpp b/src/lib/element-tracker.hpp
index 5e7bdfd44..5724ee189 100644
--- a/src/lib/element-tracker.hpp
+++ b/src/lib/element-tracker.hpp
@@ -90,11 +90,11 @@ namespace lib {
    */
   template<typename ELM>
   class ElementTracker
-    : public lib::RefArrayVector<P<ELM> >
+    : public lib::RefArrayVector<P<ELM>>
     {
-      typedef std::vector<P<ELM> > _Vec;
-      typedef typename _Vec::iterator Iter;
-      typedef typename _Vec::const_iterator CIter;
+      using  _Vec = std::vector<P<ELM>>;
+      using  Iter = typename _Vec::iterator;
+      using CIter = typename _Vec::const_iterator;
       
     public:
      ~ElementTracker()
diff --git a/src/lib/handle.hpp b/src/lib/handle.hpp
index 7aff95119..9da0dd9e5 100644
--- a/src/lib/handle.hpp
+++ b/src/lib/handle.hpp
@@ -68,7 +68,7 @@ namespace lib {
    */
   template<class IMP>
   class Handle 
-    : public lib::BoolCheckable<Handle<IMP> >
+    : public lib::BoolCheckable<Handle<IMP>>
     {
     protected:
       typedef std::shared_ptr<IMP> SmPtr;
diff --git a/src/lib/iter-adapter-ptr-deref.hpp b/src/lib/iter-adapter-ptr-deref.hpp
index 65fc9e440..93968457b 100644
--- a/src/lib/iter-adapter-ptr-deref.hpp
+++ b/src/lib/iter-adapter-ptr-deref.hpp
@@ -85,7 +85,7 @@ namespace lib {
    */
   template<class IT>
   class PtrDerefIter
-    : public lib::BoolCheckable<PtrDerefIter<IT> >
+    : public lib::BoolCheckable<PtrDerefIter<IT>>
     {
       IT i_;  ///< nested source iterator
       
@@ -230,7 +230,7 @@ namespace lib {
    */
   template<class IT>
   class AddressExposingIter
-    : public lib::BoolCheckable<AddressExposingIter<IT> >
+    : public lib::BoolCheckable<AddressExposingIter<IT>>
     {
       typedef typename IT::pointer _Ptr;
       
diff --git a/src/lib/iter-adapter-stl.hpp b/src/lib/iter-adapter-stl.hpp
index 861bd7ccc..1a97f5527 100644
--- a/src/lib/iter-adapter-stl.hpp
+++ b/src/lib/iter-adapter-stl.hpp
@@ -55,7 +55,7 @@ namespace iter_stl {
    */
   template<typename IT>
   class DistinctIter
-    : public lib::BoolCheckable<DistinctIter<IT> >
+    : public lib::BoolCheckable<DistinctIter<IT>>
     {
     public:
       typedef typename IT::value_type value_type;
@@ -205,16 +205,16 @@ namespace iter_stl {
     template<class IT, typename SEL>
     struct _MapSubSelector
       {
-        typedef WrappedStlIter< Wrapped_PickKey<IT> > PickKey;
-        typedef WrappedStlIter< Wrapped_PickVal<IT> > PickVal;
+        typedef WrappedStlIter< Wrapped_PickKey<IT>> PickKey;
+        typedef WrappedStlIter< Wrapped_PickVal<IT>> PickVal;
       };
     
     /** especially for const iterators we need to use \c const& and \c const* */
     template<class IT, typename SEL>
     struct _MapSubSelector<IT, SEL const&>
       {
-        typedef WrappedStlIter< Wrapped_PickKey<IT> >      PickKey; // Key is always const for maps
-        typedef WrappedStlIter< Wrapped_PickConstVal<IT> > PickVal;
+        typedef WrappedStlIter< Wrapped_PickKey<IT>>      PickKey; // Key is always const for maps
+        typedef WrappedStlIter< Wrapped_PickConstVal<IT>> PickVal;
       };
     
     
@@ -415,7 +415,7 @@ namespace iter_stl {
    */
   template<typename VAL>
   class IterSnapshot
-    : public lib::BoolCheckable<IterSnapshot<VAL> >
+    : public lib::BoolCheckable<IterSnapshot<VAL>>
     {
       typedef std::vector<VAL> Sequence;
       
diff --git a/src/lib/iter-adapter.hpp b/src/lib/iter-adapter.hpp
index 7b0ce5bcb..befcccf4d 100644
--- a/src/lib/iter-adapter.hpp
+++ b/src/lib/iter-adapter.hpp
@@ -157,7 +157,7 @@ namespace lib {
    */
   template<class POS, class CON>
   class IterAdapter
-    : public lib::BoolCheckable<IterAdapter<POS,CON> >
+    : public lib::BoolCheckable<IterAdapter<POS,CON>>
     {
       CON source_;
       mutable POS pos_;
@@ -298,7 +298,7 @@ namespace lib {
    */
   template<typename T, class ST =T>
   class IterStateWrapper
-    : public lib::BoolCheckable<IterStateWrapper<T,ST> >
+    : public lib::BoolCheckable<IterStateWrapper<T,ST>>
     {
       ST core_;
       
@@ -422,7 +422,7 @@ namespace lib {
    */
   template<class IT>
   class RangeIter
-    : public lib::BoolCheckable<RangeIter<IT> >
+    : public lib::BoolCheckable<RangeIter<IT>>
     {
       IT p_;
       IT e_;
@@ -648,7 +648,7 @@ namespace lib {
   struct IterType;
   
   template<template<class,class> class Iter, class TY, class CON>
-  struct IterType<Iter<TY,CON> >
+  struct IterType<Iter<TY,CON>>
     {
       typedef CON Container;
       typedef TY  ElemType;
@@ -661,7 +661,7 @@ namespace lib {
     };
   
   template<class IT>
-  struct IterType<RangeIter<IT> >
+  struct IterType<RangeIter<IT>>
     : IterType<IT>
     {
       template<class T2>
@@ -677,7 +677,7 @@ namespace lib {
   /** wrapper to declare exposed values const */
   template<class IT>
   class ConstIter
-    : public lib::BoolCheckable<ConstIter<IT> >
+    : public lib::BoolCheckable<ConstIter<IT>>
     {
       IT i_;  ///< nested source iterator
       
diff --git a/src/lib/iter-explorer.hpp b/src/lib/iter-explorer.hpp
index cda3b3adc..408ea78f2 100644
--- a/src/lib/iter-explorer.hpp
+++ b/src/lib/iter-explorer.hpp
@@ -450,7 +450,7 @@ namespace lib {
     class ChainedIters;
     
     template<class ITI>
-    class ChainedIters<ITI,     typename enable_if< _is_iterator_of_iterators<ITI> >::type
+    class ChainedIters<ITI,     typename enable_if< _is_iterator_of_iterators<ITI>>::type
                       >
       : public IterStateWrapper<typename ITI::value_type::value_type 
                                ,ChainedIteratorImpl<ITI, typename ITI::value_type>
@@ -471,7 +471,7 @@ namespace lib {
      *       of the given iterator is itself an iterator
      */ 
     template<class SEQ>
-    class ChainedIters<SEQ,     typename disable_if< _is_iterator_of_iterators<SEQ> >::type
+    class ChainedIters<SEQ,     typename disable_if< _is_iterator_of_iterators<SEQ>>::type
                       > 
       : public IterStateWrapper<typename SEQ::value_type
                                ,ChainedIteratorImpl<IterStack<SEQ>, SEQ>
@@ -940,10 +940,10 @@ namespace lib {
   /* ==== convenient builder free functions ==== */
   
   template<class IT>
-  inline IterExplorer<iter_explorer::WrappedSequence<IT> >
+  inline IterExplorer<iter_explorer::WrappedSequence<IT>>
   exploreIter (IT const& srcSeq)
   {
-    return IterExplorer<iter_explorer::WrappedSequence<IT> > (srcSeq);
+    return IterExplorer<iter_explorer::WrappedSequence<IT>> (srcSeq);
   }
   
   
diff --git a/src/lib/iter-stack.hpp b/src/lib/iter-stack.hpp
index a7cb82bc8..6b42e0122 100644
--- a/src/lib/iter-stack.hpp
+++ b/src/lib/iter-stack.hpp
@@ -118,7 +118,7 @@ namespace lib {
    */
   template<class TY>
   struct IterStack
-    : IterStateWrapper<TY, IterDequeStorage<TY> >
+    : IterStateWrapper<TY, IterDequeStorage<TY>>
     {
       
       // using default create and copy operations
@@ -165,7 +165,7 @@ namespace lib {
    */
   template<class TY>
   struct IterQueue
-    : IterStateWrapper<TY, IterDequeStorage<TY> >
+    : IterStateWrapper<TY, IterDequeStorage<TY>>
     {
       
       // using default create and copy operations
diff --git a/src/lib/itertools.hpp b/src/lib/itertools.hpp
index b23501466..1b36dafb4 100644
--- a/src/lib/itertools.hpp
+++ b/src/lib/itertools.hpp
@@ -147,7 +147,7 @@ namespace lib {
    */
   template<class CORE>
   class IterTool
-    : public lib::BoolCheckable<IterTool<CORE> >
+    : public lib::BoolCheckable<IterTool<CORE>>
     {
       
     protected: /* == iteration control == */
@@ -315,7 +315,7 @@ namespace lib {
    */
   template<class IT>
   class FilterIter
-    : public IterTool<FilterCore<IT> >
+    : public IterTool<FilterCore<IT>>
     {
       typedef FilterCore<IT> _Filter;
       typedef IterTool<_Filter> _Impl;
@@ -609,7 +609,7 @@ namespace lib {
    */
   template<class IT, class VAL>
   class TransformIter
-    : public IterTool<TransformingCore<IT,VAL> >
+    : public IterTool<TransformingCore<IT,VAL>>
     {
       typedef TransformingCore<IT,VAL> _Trafo;
       typedef IterTool<_Trafo> _IteratorImpl;
@@ -636,19 +636,19 @@ namespace lib {
     template<typename SIG>
     struct _ProducedOutput
       {
-        typedef typename FunctionSignature<function<SIG> >::Ret Type;
+        typedef typename FunctionSignature<function<SIG>>::Ret Type;
       };
     
     template<typename SIG>
-    struct _ProducedOutput<function<SIG> >
+    struct _ProducedOutput<function<SIG>>
       {
-        typedef typename FunctionSignature<function<SIG> >::Ret Type;
+        typedef typename FunctionSignature<function<SIG>>::Ret Type;
       };
     
     template<typename FUN>
     struct _ProducedOutput<FUN*>
       {
-        typedef typename FunctionSignature<function<FUN> >::Ret Type;
+        typedef typename FunctionSignature<function<FUN>>::Ret Type;
       };
   }
   
diff --git a/src/lib/meta/configflags.hpp b/src/lib/meta/configflags.hpp
index b80dae229..b7d8ba9ec 100644
--- a/src/lib/meta/configflags.hpp
+++ b/src/lib/meta/configflags.hpp
@@ -105,7 +105,7 @@ namespace meta{
           , uint f4
           , uint IGN
           >
-  struct ConfigSetFlag<Fl, Config<f1,f2,f3,f4,IGN> >
+  struct ConfigSetFlag<Fl, Config<f1,f2,f3,f4,IGN>>
     {
       typedef lib::meta::Config<Fl,f1,f2,f3,f4> Config;
     };
@@ -158,7 +158,7 @@ namespace meta{
   struct FlagInfo;
   
   template<uint ff, class FLAGS>
-  struct FlagInfo<Node<Flag<ff>, FLAGS> >
+  struct FlagInfo<Node<Flag<ff>, FLAGS>>
     {
       enum{ BITS = maxC< ff,  FlagInfo<FLAGS>::BITS> ::VAL
           , CODE =  (1<<ff) | FlagInfo<FLAGS>::CODE
@@ -181,7 +181,7 @@ namespace meta{
     };
   
   template<class CONF, class TAIL>
-  struct FlagInfo<Node<CONF, TAIL> >
+  struct FlagInfo<Node<CONF, TAIL>>
     {
       typedef typename CONF::Flags ThisFlags;
       enum{ 
diff --git a/src/lib/meta/function-closure.hpp b/src/lib/meta/function-closure.hpp
index 9485da941..fc55fdabf 100644
--- a/src/lib/meta/function-closure.hpp
+++ b/src/lib/meta/function-closure.hpp
@@ -476,10 +476,10 @@ namespace func{
   template<typename SIG>
   class TupleApplicator
     {
-      typedef typename FunctionSignature< function<SIG> >::Args Args;
-      typedef typename FunctionSignature< function<SIG> >::Ret  Ret;
+      using Args = typename FunctionSignature< function<SIG>>::Args;
+      using Ret  = typename FunctionSignature< function<SIG>>::Ret;
       
-      typedef function<Ret()> BoundFunc;
+      using BoundFunc = function<Ret()>;
       
       enum { ARG_CNT = count<typename Args::List>::value };
       
diff --git a/src/lib/meta/function-erasure.hpp b/src/lib/meta/function-erasure.hpp
index f8b632047..9c888754b 100644
--- a/src/lib/meta/function-erasure.hpp
+++ b/src/lib/meta/function-erasure.hpp
@@ -139,7 +139,7 @@ namespace meta{
       function<SIG>&
       getFun ()  const
         {
-          return get<function<SIG> >();
+          return get<function<SIG>>();
         }
       
       
diff --git a/src/lib/meta/function.hpp b/src/lib/meta/function.hpp
index 771e05879..5569c6e3b 100644
--- a/src/lib/meta/function.hpp
+++ b/src/lib/meta/function.hpp
@@ -226,33 +226,33 @@ namespace meta{
   template<typename SIG>
   struct _Fun
     {
-      typedef typename FunctionSignature<function<SIG> >::Ret Ret;
-      typedef typename FunctionSignature<function<SIG> >::Args Args;
-      typedef                                             SIG  Sig;
+      typedef typename FunctionSignature<function<SIG>>::Ret  Ret;
+      typedef typename FunctionSignature<function<SIG>>::Args Args;
+      typedef                                            SIG  Sig;
     };
   /** Specialisation for using a function pointer */
   template<typename SIG>
   struct _Fun<SIG*>
     {
-      typedef typename FunctionSignature<function<SIG> >::Ret Ret;
-      typedef typename FunctionSignature<function<SIG> >::Args Args;
-      typedef                                             SIG  Sig;
+      typedef typename FunctionSignature<function<SIG>>::Ret  Ret;
+      typedef typename FunctionSignature<function<SIG>>::Args Args;
+      typedef                                            SIG  Sig;
     };
   /** Specialisation when using a function reference */
   template<typename SIG>
   struct _Fun<SIG&>
     {
-      typedef typename FunctionSignature<function<SIG> >::Ret Ret;
-      typedef typename FunctionSignature<function<SIG> >::Args Args;
-      typedef                                             SIG  Sig;
+      typedef typename FunctionSignature<function<SIG>>::Ret  Ret;
+      typedef typename FunctionSignature<function<SIG>>::Args Args;
+      typedef                                            SIG  Sig;
     };
   /** Specialisation for passing a functor */
   template<typename SIG>
-  struct _Fun<function<SIG> >
+  struct _Fun<function<SIG>>
     {
-      typedef typename FunctionSignature<function<SIG> >::Ret Ret;
-      typedef typename FunctionSignature<function<SIG> >::Args Args;
-      typedef                                             SIG  Sig;
+      typedef typename FunctionSignature<function<SIG>>::Ret  Ret;
+      typedef typename FunctionSignature<function<SIG>>::Args Args;
+      typedef                                            SIG  Sig;
     };
   
   /** Specialisations for member function pointers */
@@ -407,7 +407,7 @@ namespace meta{
   template< typename RET
           , typename A1
           >
-  struct FunctionTypedef<RET, Types<A1> >
+  struct FunctionTypedef<RET, Types<A1>>
   {
     typedef function<RET(A1)> Func;
     typedef          RET Sig(A1);
@@ -418,7 +418,7 @@ namespace meta{
           , typename A1
           , typename A2
           >
-  struct FunctionTypedef<RET, Types<A1,A2> >
+  struct FunctionTypedef<RET, Types<A1,A2>>
   {
     typedef function<RET(A1,A2)> Func;
     typedef          RET Sig(A1,A2);
@@ -430,7 +430,7 @@ namespace meta{
           , typename A2
           , typename A3
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3>>
   {
     typedef function<RET(A1,A2,A3)> Func;
     typedef          RET Sig(A1,A2,A3);
@@ -443,7 +443,7 @@ namespace meta{
           , typename A3
           , typename A4
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4>>
   {
     typedef function<RET(A1,A2,A3,A4)> Func;
     typedef          RET Sig(A1,A2,A3,A4);
@@ -457,7 +457,7 @@ namespace meta{
           , typename A4
           , typename A5
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5>>
   {
     typedef function<RET(A1,A2,A3,A4,A5)> Func;
     typedef          RET Sig(A1,A2,A3,A4,A5);
@@ -472,7 +472,7 @@ namespace meta{
           , typename A5
           , typename A6
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6>>
   {
     typedef function<RET(A1,A2,A3,A4,A5,A6)> Func;
     typedef          RET Sig(A1,A2,A3,A4,A5,A6);
@@ -488,7 +488,7 @@ namespace meta{
           , typename A6
           , typename A7
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7>>
   {
     typedef function<RET(A1,A2,A3,A4,A5,A6,A7)> Func;
     typedef          RET Sig(A1,A2,A3,A4,A5,A6,A7);
@@ -505,7 +505,7 @@ namespace meta{
           , typename A7
           , typename A8
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8>>
   {
     typedef function<RET(A1,A2,A3,A4,A5,A6,A7,A8)> Func;
     typedef          RET Sig(A1,A2,A3,A4,A5,A6,A7,A8);
@@ -523,7 +523,7 @@ namespace meta{
           , typename A8
           , typename A9
           >
-  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,A9> >
+  struct FunctionTypedef<RET, Types<A1,A2,A3,A4,A5,A6,A7,A8,A9>>
   {
     typedef function<RET(A1,A2,A3,A4,A5,A6,A7,A8,A9)> Func;
     typedef          RET Sig(A1,A2,A3,A4,A5,A6,A7,A8,A9);
diff --git a/src/lib/meta/maybe-compare.hpp b/src/lib/meta/maybe-compare.hpp
index 502259a26..cfa89ff6c 100644
--- a/src/lib/meta/maybe-compare.hpp
+++ b/src/lib/meta/maybe-compare.hpp
@@ -53,7 +53,7 @@ namespace meta{
    *  we'll use our private hack, which at least detects equivalence 
    *  in \em some cases... */
   template<typename SIG>
-  struct Comparator<function<SIG> >
+  struct Comparator<function<SIG>>
     {
       static bool
       equals (function<SIG> const& f1, function<SIG> const& f2)
diff --git a/src/lib/meta/trait-special.hpp b/src/lib/meta/trait-special.hpp
index 3bc3e5c53..8a18b6d19 100644
--- a/src/lib/meta/trait-special.hpp
+++ b/src/lib/meta/trait-special.hpp
@@ -34,7 +34,7 @@ namespace lib {
 namespace meta {
   
   
-  /** the tr1 hashtable(s) are notoriously difficult to handle
+  /** the std hashtable(s) are notoriously difficult to handle
    *  when it comes to detecting capabilities by metaprogramming,
    *  because the're built up from a generic baseclass and especially
    *  inherit their iterator-types as template specialisations.
@@ -42,7 +42,7 @@ namespace meta {
    *  Thus we provide fixed diagnostics to bypass the traits check.
    */
   template<typename KEY, typename VAL, typename HASH>
-  struct can_STL_ForEach<std::unordered_map<KEY,VAL,HASH> >
+  struct can_STL_ForEach<std::unordered_map<KEY,VAL,HASH>>
     {
       enum { value = true };
     };
diff --git a/src/lib/meta/trait.hpp b/src/lib/meta/trait.hpp
index e9920f9c1..31879b94c 100644
--- a/src/lib/meta/trait.hpp
+++ b/src/lib/meta/trait.hpp
@@ -145,7 +145,7 @@ namespace meta {
     };
   
   template<typename X>
-  struct Unwrap<boost::reference_wrapper<X> >
+  struct Unwrap<boost::reference_wrapper<X>>
     {
       typedef X  Type;
       
@@ -157,7 +157,7 @@ namespace meta {
     };
   
   template<typename X>
-  struct Unwrap<std::reference_wrapper<X> >
+  struct Unwrap<std::reference_wrapper<X>>
     {
       typedef X  Type;
       
@@ -169,7 +169,7 @@ namespace meta {
     };
   
   template<typename X>
-  struct Unwrap<std::shared_ptr<X> >
+  struct Unwrap<std::shared_ptr<X>>
     {
       typedef X  Type;
       
@@ -182,7 +182,7 @@ namespace meta {
     };
   
   template<typename X, class B>
-  struct Unwrap<P<X, B> >
+  struct Unwrap<P<X, B>>
     {
       typedef X  Type;
       
diff --git a/src/lib/meta/typelist-manip.hpp b/src/lib/meta/typelist-manip.hpp
index b6ab6ca9d..a5e02d51e 100644
--- a/src/lib/meta/typelist-manip.hpp
+++ b/src/lib/meta/typelist-manip.hpp
@@ -130,7 +130,7 @@ namespace meta {
     struct Append<Node<TY,TYPES>, TAIL>    { typedef Node<TY,  typename Append<TYPES,  TAIL>::List>  List; };
     
     template<class TY, class TYPES>
-    struct Append<NullType, Node<TY,TYPES> >   { typedef Node<TY,TYPES>   List; };
+    struct Append<NullType, Node<TY,TYPES>>    { typedef Node<TY,TYPES>   List; };
     
     template<class TY, class TYPES>
     struct Append<Node<TY,TYPES>, NullType>    { typedef Node<TY,TYPES>   List; };
@@ -155,11 +155,11 @@ namespace meta {
     struct SplitLast<NullType>             { typedef NullType Type;
                                              typedef NullType List; };
     template<class TY>
-    struct SplitLast<Node<TY,NullType> >   { typedef TY       Type;
+    struct SplitLast<Node<TY,NullType>>    { typedef TY       Type;
                                              typedef NullType List; };
     
     template<class TY, class TYPES>
-    struct SplitLast<Node<TY,TYPES> >      { typedef typename SplitLast<TYPES>::Type Type;
+    struct SplitLast<Node<TY,TYPES>>       { typedef typename SplitLast<TYPES>::Type Type;
                                              typedef typename Append< TY,
                                                                       typename SplitLast<TYPES>::List
                                                                     >::List 
@@ -211,7 +211,7 @@ namespace meta {
     struct Dissect;
     
     template<class T, class TYPES>
-    struct Dissect<Node<T,TYPES> >
+    struct Dissect<Node<T,TYPES>>
       {
         typedef Node<T,TYPES>                  List;  ///< the complete list
         typedef T                              Head;  ///< first element
@@ -253,7 +253,7 @@ namespace meta {
     template< class T
             , class TY, class TYPES
             >
-    struct PrefixAll<T, Node<TY,TYPES> >   { typedef Node< typename Append<T,TY>::List
+    struct PrefixAll<T, Node<TY,TYPES>>    { typedef Node< typename Append<T,TY>::List
                                                          , typename PrefixAll<T,TYPES>::List
                                                          >     List; };
     
@@ -313,7 +313,7 @@ namespace meta {
     template<class F>
     struct FlagOnOff
       { 
-        typedef Node<F, Node<NullType,NullType> >  List;
+        typedef Node<F, Node<NullType,NullType>>  List;
       };
     
     
diff --git a/src/lib/meta/typelist-util.hpp b/src/lib/meta/typelist-util.hpp
index 029baee5e..01f710569 100644
--- a/src/lib/meta/typelist-util.hpp
+++ b/src/lib/meta/typelist-util.hpp
@@ -65,7 +65,7 @@ namespace meta {
         enum{ value = 0 };
       };
     template<class TY, class TYPES>
-    struct count<Node<TY,TYPES> >
+    struct count<Node<TY,TYPES>>
       {
         enum{ value = 1 + count<TYPES>::value };
       };
@@ -82,7 +82,7 @@ namespace meta {
         static constexpr int value = 0;
       };
     template<class TY, class TYPES>
-    struct maxSize<Node<TY,TYPES> >
+    struct maxSize<Node<TY,TYPES>>
       {
         static constexpr size_t thisval = sizeof(TY);
         static constexpr size_t nextval = maxSize<TYPES>::value;
@@ -101,13 +101,13 @@ namespace meta {
       };
     
     template<typename TY, typename TYPES>
-    struct IsInList<TY, Node<TY,TYPES> >
+    struct IsInList<TY, Node<TY,TYPES>>
       {
         enum{ value = true };
       };
     
     template<typename TY, typename XX, typename TYPES>
-    struct IsInList<TY, Node<XX,TYPES> >
+    struct IsInList<TY, Node<XX,TYPES>>
       {
         enum{ value = IsInList<TY,TYPES>::value };
       };
diff --git a/src/lib/observable-list.hpp b/src/lib/observable-list.hpp
index 7b750f761..c61315827 100644
--- a/src/lib/observable-list.hpp
+++ b/src/lib/observable-list.hpp
@@ -36,7 +36,7 @@ namespace lumiera
  * An observable_list is an STL list with an inbuilt sigc++ signal that
  * allows observers to be notified when changes are made to the list.
  */
-template<class T, class Allocator = std::allocator<T> >
+template<class T, class Allocator = std::allocator<T>>
 class observable_list
 {
 public:
diff --git a/src/lib/opaque-holder.hpp b/src/lib/opaque-holder.hpp
index 15e2b7fe6..ddbe8ae48 100644
--- a/src/lib/opaque-holder.hpp
+++ b/src/lib/opaque-holder.hpp
@@ -192,7 +192,7 @@ namespace lib {
                            ///< how to access the contents via a common interface?
     >
   class InPlaceAnyHolder
-    : public BoolCheckable<InPlaceAnyHolder<siz, AccessPolicy> >
+    : public BoolCheckable<InPlaceAnyHolder<siz, AccessPolicy>>
     {
       typedef typename AccessPolicy::Base * BaseP;
       
@@ -515,9 +515,9 @@ namespace lib {
     , size_t siz = sizeof(BA)
     >
   class OpaqueHolder
-    : public InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> >
+    : public InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA>>
     {
-      typedef InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA> > InPlaceHolder;
+      typedef InPlaceAnyHolder<siz, InPlaceAnyHolder_useCommonBase<BA>> InPlaceHolder;
       
     public:
       OpaqueHolder() : InPlaceHolder() {}
diff --git a/src/lib/optional-ref.hpp b/src/lib/optional-ref.hpp
index 71ce7393d..d9371fccd 100644
--- a/src/lib/optional-ref.hpp
+++ b/src/lib/optional-ref.hpp
@@ -53,7 +53,7 @@ namespace lib {
    */
   template<typename T>
   class OptionalRef
-    : public lib::BoolCheckable<OptionalRef<T> >
+    : public lib::BoolCheckable<OptionalRef<T>>
     {
       T* ref_;
       
diff --git a/src/lib/p.hpp b/src/lib/p.hpp
index aed836011..7506aba48 100644
--- a/src/lib/p.hpp
+++ b/src/lib/p.hpp
@@ -73,7 +73,7 @@ namespace lib {
    *       pointee causes an dynamic cast. Thus the pointee types
    *       need to support RTTI.
    */
-  template<class TAR, class BASE =shared_ptr<TAR> >
+  template<class TAR, class BASE =shared_ptr<TAR>>
   class P
     : public BASE
     {
diff --git a/src/lib/scoped-holder-transfer.hpp b/src/lib/scoped-holder-transfer.hpp
index 58508f393..d7d6e119e 100644
--- a/src/lib/scoped-holder-transfer.hpp
+++ b/src/lib/scoped-holder-transfer.hpp
@@ -65,7 +65,7 @@ namespace lib {
    *   when the pointer isn'T \c NULL
    * 
    */
-  template<class TY, class PAR = std::allocator<TY> >
+  template<class TY, class PAR = std::allocator<TY>>
   class Allocator_TransferNoncopyable
     {
       typedef Allocator_TransferNoncopyable<TY,PAR> _ThisType;
diff --git a/src/lib/sync.hpp b/src/lib/sync.hpp
index e5a862754..319544cb9 100644
--- a/src/lib/sync.hpp
+++ b/src/lib/sync.hpp
@@ -264,7 +264,7 @@ namespace lib {
     
     template<class MTX>
     class Condition
-      : public Mutex<Wrapped_Condition<MTX> >
+      : public Mutex<Wrapped_Condition<MTX>>
       {
         typedef Wrapped_Condition<MTX> Cond;
         
diff --git a/src/lib/test/depend-4test.hpp b/src/lib/test/depend-4test.hpp
index 5178ab56d..968376e05 100644
--- a/src/lib/test/depend-4test.hpp
+++ b/src/lib/test/depend-4test.hpp
@@ -74,7 +74,7 @@ namespace test{
     
     
     template<class MOCK>
-    struct ServiceInterface<MOCK, typename enable_if< defines_ServiceInterface<MOCK> >::type>
+    struct ServiceInterface<MOCK, typename enable_if< defines_ServiceInterface<MOCK>>::type>
       {
         typedef typename MOCK::ServiceInterface Type;
       };
diff --git a/src/lib/time/digxel.hpp b/src/lib/time/digxel.hpp
index 9189d2ed5..4fb3b645b 100644
--- a/src/lib/time/digxel.hpp
+++ b/src/lib/time/digxel.hpp
@@ -224,7 +224,7 @@ namespace time {
             , class FMT  = digxel::Formatter<NUM>
             >
   class Digxel
-    : public boost::totally_ordered<Digxel<NUM,FMT> >
+    : public boost::totally_ordered<Digxel<NUM,FMT>>
     {
       mutable
       FMT buffer_;
diff --git a/src/lib/time/timevalue.hpp b/src/lib/time/timevalue.hpp
index 9f9967bb0..69e93e30c 100644
--- a/src/lib/time/timevalue.hpp
+++ b/src/lib/time/timevalue.hpp
@@ -79,7 +79,7 @@ namespace time {
    */
   class TimeValue
     : boost::totally_ordered<TimeValue,
-      boost::totally_ordered<TimeValue, gavl_time_t> >
+      boost::totally_ordered<TimeValue, gavl_time_t>>
     {
     protected:
       /** the raw (internal) time value
diff --git a/src/lib/visitor-dispatcher.hpp b/src/lib/visitor-dispatcher.hpp
index d3aa22690..3b264caed 100644
--- a/src/lib/visitor-dispatcher.hpp
+++ b/src/lib/visitor-dispatcher.hpp
@@ -180,7 +180,7 @@ namespace visitor {
       
       
     public:
-      static Depend<Dispatcher<TAR,TOOL> > instance;
+      static Depend<Dispatcher<TAR,TOOL>> instance;
       
       inline ReturnType 
       forwardCall (TAR& target, TOOL& tool)
@@ -208,7 +208,7 @@ namespace visitor {
   
   /** storage for the dispatcher table(s) */
   template<class TAR, class TOOL>
-  Depend<Dispatcher<TAR,TOOL> > Dispatcher<TAR,TOOL>::instance;
+  Depend<Dispatcher<TAR,TOOL>> Dispatcher<TAR,TOOL>::instance;
   
   
   
diff --git a/src/lib/wrapper.hpp b/src/lib/wrapper.hpp
index 007b76936..f8f00441c 100644
--- a/src/lib/wrapper.hpp
+++ b/src/lib/wrapper.hpp
@@ -140,7 +140,7 @@ namespace wrapper {
    */
   template<typename TY>
   class ItemWrapper
-    : public BoolCheckable<ItemWrapper<TY> >
+    : public BoolCheckable<ItemWrapper<TY>>
     {
       
       typedef typename remove_const<TY>::type TY_unconst;
@@ -347,8 +347,8 @@ namespace wrapper {
     : public function<SIG>
     , boost::noncopyable
     {
-      typedef typename FunctionSignature<function<SIG> >::Ret Res;
-      typedef ItemWrapper<Res> ResWrapper;
+      using Res = typename FunctionSignature<function<SIG>>::Ret;
+      using ResWrapper = ItemWrapper<Res>;
       
       ResWrapper lastResult_;
       
diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp
index 3bbb7b228..8f37faf69 100644
--- a/src/proc/asset.hpp
+++ b/src/proc/asset.hpp
@@ -339,7 +339,7 @@ namespace asset {
   struct is_pAsset : boost::false_type {};
   
   template <class A>
-  struct is_pAsset<shared_ptr<A> >
+  struct is_pAsset<shared_ptr<A>>
     : boost::is_base_of<Asset, A>      {};
   
   
diff --git a/src/proc/control/argument-tuple-accept.hpp b/src/proc/control/argument-tuple-accept.hpp
index e3f8a93c7..d7777804a 100644
--- a/src/proc/control/argument-tuple-accept.hpp
+++ b/src/proc/control/argument-tuple-accept.hpp
@@ -596,8 +596,8 @@ namespace control {
     template<typename SIG>
     struct _Type
       {
-        using Args = typename FunctionSignature< function<SIG> >::Args;
-        using Ret  = typename FunctionSignature< function<SIG> >::Ret;
+        using Args = typename FunctionSignature< function<SIG>>::Args;
+        using Ret  = typename FunctionSignature< function<SIG>>::Ret;
         using Sig  = SIG;
         using ArgTuple = Tuple<Args>;
       };
diff --git a/src/proc/control/command-def.hpp b/src/proc/control/command-def.hpp
index 1a0941aae..9564e610e 100644
--- a/src/proc/control/command-def.hpp
+++ b/src/proc/control/command-def.hpp
@@ -98,8 +98,8 @@ namespace control {
   
   namespace stage { ///< helpers for building up a command definition
     
-    typedef shared_ptr<CommandImpl> ImplInstance;
-    typedef function<Command&(ImplInstance const&)> Activation;
+    using ImplInstance = shared_ptr<CommandImpl>;
+    using Activation   = function<Command&(ImplInstance const&)>;
     
     
     
@@ -112,7 +112,7 @@ namespace control {
       {
         Command& prototype_;
         
-        typedef typename FunctionSignature< function<SIG> >::Args CmdArgs;
+        typedef typename FunctionSignature< function<SIG>>::Args CmdArgs;
         
         CompletedDefinition (Command& definedCommand)
           : prototype_(definedCommand)
@@ -244,11 +244,11 @@ namespace control {
         
         
         template<typename SIG2>
-        typename BuildUndoDefType<UndoSignature<SIG2> >::Type
+        typename BuildUndoDefType<UndoSignature<SIG2>>::Type
         captureUndo (SIG2& how_to_capture_UndoState)
           {
             typedef typename UndoSignature<SIG2>::CaptureSig UndoCapSig;
-            typedef typename BuildUndoDefType<UndoSignature<SIG2> >::Type SpecificUndoDefinition;
+            typedef typename BuildUndoDefType<UndoSignature<SIG2>>::Type SpecificUndoDefinition;
             
             function<UndoCapSig> captureOperation (how_to_capture_UndoState);
             return SpecificUndoDefinition (callback_, operation_, captureOperation);
diff --git a/src/proc/control/command-op-closure.hpp b/src/proc/control/command-op-closure.hpp
index 0fd5e42a5..0acbd70a2 100644
--- a/src/proc/control/command-op-closure.hpp
+++ b/src/proc/control/command-op-closure.hpp
@@ -153,7 +153,7 @@ namespace control {
   template<typename SIG>
   class OpClosure
     {
-      using Args = typename FunctionSignature< function<SIG> >::Args;
+      using Args = typename FunctionSignature< function<SIG>>::Args;
       using Builder = BuildTupleAccessor<ParamAccessor, Args>;
       
       using ParamStorageTuple =typename Builder::Product;
diff --git a/src/proc/control/command-registry.hpp b/src/proc/control/command-registry.hpp
index 94165bc02..13ab398a1 100644
--- a/src/proc/control/command-registry.hpp
+++ b/src/proc/control/command-registry.hpp
@@ -120,7 +120,7 @@ namespace control {
     , noncopyable
     {
       // using a hashtable to implement the index
-      typedef unordered_map<Symbol, Command, hash<Symbol> > CmdIndex;
+      typedef unordered_map<Symbol, Command, hash<Symbol>> CmdIndex;
       typedef map< const Command*, Symbol, order_by_impl> ReverseIndex;
       
       TypedAllocationManager allocator_;
diff --git a/src/proc/control/command-signature.hpp b/src/proc/control/command-signature.hpp
index 452c020cb..9b08ed3b2 100644
--- a/src/proc/control/command-signature.hpp
+++ b/src/proc/control/command-signature.hpp
@@ -78,7 +78,7 @@ namespace control {
   template<typename SIG, typename MEM>
   class CommandSignature
     {
-      typedef typename FunctionSignature< function<SIG> >::Args Args;
+      typedef typename FunctionSignature< function<SIG>>::Args Args;
       
       typedef typename Args::List ArgList;
       typedef typename Append<ArgList, MEM>::List ExtendedArglist;
@@ -113,8 +113,8 @@ namespace control {
   class UndoSignature
     {
       // preparation:  dissect the function signature into arguments and result
-      typedef typename FunctionSignature< function<SIG> >::Args Args;
-      typedef typename FunctionSignature< function<SIG> >::Ret  Ret;
+      typedef typename FunctionSignature< function<SIG>>::Args Args;
+      typedef typename FunctionSignature< function<SIG>>::Ret  Ret;
       
       /** Case1: defining the Undo-Capture function */
       template<typename RET, typename ARG>
diff --git a/src/proc/engine/nodeoperation.hpp b/src/proc/engine/nodeoperation.hpp
index 26031d989..5ad0da05c 100644
--- a/src/proc/engine/nodeoperation.hpp
+++ b/src/proc/engine/nodeoperation.hpp
@@ -283,7 +283,7 @@ namespace config {
   template<class CONF>
   struct SelectBuffProvider                                          { typedef AllocBufferFromParent Type; };
   template<uint PROC_ign, uint INPLA_ign>
-  struct SelectBuffProvider< Config<CACHING, PROC_ign, INPLA_ign> >  { typedef AllocBufferFromCache  Type; };
+  struct SelectBuffProvider< Config<CACHING, PROC_ign, INPLA_ign>>   { typedef AllocBufferFromCache  Type; };
   
   
   template<class Config>
@@ -291,7 +291,7 @@ namespace config {
   
   
   template<uint INPLACE_ign>
-  struct Strategy< Config<CACHING,PROCESS,INPLACE_ign> >
+  struct Strategy< Config<CACHING,PROCESS,INPLACE_ign>>
     : QueryCache<
        AllocBufferTable<
         PullInput<
@@ -303,7 +303,7 @@ namespace config {
     { };
   
   template<uint INPLACE_ign>
-  struct Strategy< Config<PROCESS,INPLACE_ign> >
+  struct Strategy< Config<PROCESS,INPLACE_ign>>
     : AllocBufferTable<
        PullInput<
         AllocOutput<
diff --git a/src/proc/engine/nodewiring-config.hpp b/src/proc/engine/nodewiring-config.hpp
index 44f61dc3f..69b9f5fe3 100644
--- a/src/proc/engine/nodewiring-config.hpp
+++ b/src/proc/engine/nodewiring-config.hpp
@@ -153,7 +153,7 @@ namespace config {
           void
           visit (IxID code)
             {
-              PFunc pFactory (new FactoryHolder<Factory<CONF> > (ctor_param_));
+              PFunc pFactory (new FactoryHolder<Factory<CONF>> (ctor_param_));
               factories_[code] = pFactory;
             }
           
diff --git a/src/proc/mobject/placement-ref.hpp b/src/proc/mobject/placement-ref.hpp
index d0b3fd94c..235802bf9 100644
--- a/src/proc/mobject/placement-ref.hpp
+++ b/src/proc/mobject/placement-ref.hpp
@@ -98,7 +98,7 @@ namespace proc {
    */
   template<class MX =MObject>
   class PlacementRef
-    : public lib::BoolCheckable<PlacementRef<MX> >
+    : public lib::BoolCheckable<PlacementRef<MX>>
     {
       typedef Placement<MX>      PlacementMX;
       typedef Placement<MObject>::ID     _ID;
diff --git a/src/proc/mobject/session/fork.hpp b/src/proc/mobject/session/fork.hpp
index 31eec9444..da98b3258 100644
--- a/src/proc/mobject/session/fork.hpp
+++ b/src/proc/mobject/session/fork.hpp
@@ -90,7 +90,7 @@ namespace session {     //////////////////////////////////////////////////////TI
         
       public:
         /** Child tracks in a tree structure */
-//      vector<Placement<Track> > subTracks;  ///////////TODO: it should really work with PlacementRefs! this here is just a decoy!!!!!!!
+//      vector<Placement<Track>> subTracks;   ///////////TODO: it should really work with PlacementRefs! this here is just a decoy!!!!!!!
 /////////////////////////////////////////////////////////TICKET #513
         
         bool isSameID (string const&);
diff --git a/src/proc/mobject/session/placement-index-query-resolver.cpp b/src/proc/mobject/session/placement-index-query-resolver.cpp
index 4c3678a5c..1eb803b77 100644
--- a/src/proc/mobject/session/placement-index-query-resolver.cpp
+++ b/src/proc/mobject/session/placement-index-query-resolver.cpp
@@ -275,7 +275,7 @@ namespace session {
     QueryID
     whenQueryingFor()
       {
-        QueryID qID(Goal::DISCOVERY, getResultTypeID<Placement<MO> >());
+        QueryID qID(Goal::DISCOVERY, getResultTypeID<Placement<MO>>());
         return qID;
       }
     
@@ -326,15 +326,15 @@ namespace session {
   PlacementIndexQueryResolver::canHandleQuery(QID qID)  const
   {
     return qID.kind == Goal::DISCOVERY
-       &&( qID.type == getResultTypeID<Placement<MObject> >()
-         ||qID.type == getResultTypeID<Placement<Clip> >()
-         ||qID.type == getResultTypeID<Placement<Effect> >()
+       &&( qID.type == getResultTypeID<Placement<MObject>>()
+         ||qID.type == getResultTypeID<Placement<Clip>>()
+         ||qID.type == getResultTypeID<Placement<Effect>>()
                        /////////////////////////////////////////////////////////////////TICKET #414
          
-         ||qID.type == getResultTypeID<Placement<mobject::test::DummyMO    > >()
-         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO1 > >()
-         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO2 > >()
-         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO21> >()
+         ||qID.type == getResultTypeID<Placement<mobject::test::DummyMO    >>()
+         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO1 >>()
+         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO2 >>()
+         ||qID.type == getResultTypeID<Placement<mobject::test::TestSubMO21>>()
                        /////////////////////////////////////////////////////////////////TICKET #532
          );
   }
diff --git a/src/proc/mobject/session/placement-index.hpp b/src/proc/mobject/session/placement-index.hpp
index 1fdec078f..fd97380b5 100644
--- a/src/proc/mobject/session/placement-index.hpp
+++ b/src/proc/mobject/session/placement-index.hpp
@@ -157,7 +157,7 @@ namespace session {
   
   /// @note just ignoring the second (parent) type encoded into Placement
   template<typename MO, typename BMO>
-  struct BuildID<Placement<MO,BMO> >
+  struct BuildID<Placement<MO,BMO>>
     {
       typedef PlacementMO::Id<MO> Type;
       typedef MO                  Target;
diff --git a/src/proc/mobject/session/scope-query.hpp b/src/proc/mobject/session/scope-query.hpp
index ca9e0a2c8..4b0b36baa 100644
--- a/src/proc/mobject/session/scope-query.hpp
+++ b/src/proc/mobject/session/scope-query.hpp
@@ -72,9 +72,9 @@ namespace session {
    */
   template<class MO>
   class DiscoveryQuery
-    : public Query<Placement<MO> >
+    : public Query<Placement<MO>>
     {
-      typedef Query<Placement<MO> > _Query;
+      typedef Query<Placement<MO>> _Query;
       
       
     public:      
@@ -145,7 +145,7 @@ namespace session {
     : public DiscoveryQuery<MO>
     {
       typedef DiscoveryQuery<MO>   _Parent;
-      typedef Query<Placement<MO> > _Query;
+      typedef Query<Placement<MO>> _Query;
       
       
       PlacementMO::ID    startPoint_;
diff --git a/tests/basics/time/digxel-configurations-test.cpp b/tests/basics/time/digxel-configurations-test.cpp
index ee09b60a6..60a9de713 100644
--- a/tests/basics/time/digxel-configurations-test.cpp
+++ b/tests/basics/time/digxel-configurations-test.cpp
@@ -60,13 +60,13 @@ namespace test{
       virtual void
       run (Arg) 
         {
-          verifyConfiguration<Digxel<int>    > (123);
-          verifyConfiguration<Digxel<double> > (123.4567);
-          verifyConfiguration<SexaDigit      > (42);
-          verifyConfiguration<SexaDigit      > (-5);
-          verifyConfiguration<HexaDigit      > (0xc);
-          verifyConfiguration<HexaDigit      > (0x6f);
-          verifyConfiguration<CountVal       > (-1234567890);
+          verifyConfiguration<Digxel<int>   > (123);
+          verifyConfiguration<Digxel<double>> (123.4567);
+          verifyConfiguration<SexaDigit     > (42);
+          verifyConfiguration<SexaDigit     > (-5);
+          verifyConfiguration<HexaDigit     > (0xc);
+          verifyConfiguration<HexaDigit     > (0x6f);
+          verifyConfiguration<CountVal      > (-1234567890);
           
           verifySignum();
         }
diff --git a/tests/core/proc/asset/testasset.cpp b/tests/core/proc/asset/testasset.cpp
index 3bc9b0437..7213852f5 100644
--- a/tests/core/proc/asset/testasset.cpp
+++ b/tests/core/proc/asset/testasset.cpp
@@ -79,7 +79,7 @@ namespace test {
    *  within AssetManager by the Asset base class ctor
    */
   template<class A>
-  lib::P<TestAsset<A> >
+  lib::P<TestAsset<A>>
   TestAsset<A>::ptrFromThis ()
   {
     return static_pointer_cast<TestAsset<A>,Asset>
@@ -111,8 +111,8 @@ namespace test {
   template TestAsset<Asset>::TestAsset (PAsset& pRef);
   template TestAsset<Unknown>::TestAsset (PAsset& pRef);
   
-  template lib::P<TestAsset<Asset> >   TestAsset<Asset>::ptrFromThis ();
-  template lib::P<TestAsset<Unknown> > TestAsset<Unknown>::ptrFromThis ();
+  template lib::P<TestAsset<Asset>>   TestAsset<Asset>::ptrFromThis ();
+  template lib::P<TestAsset<Unknown>> TestAsset<Unknown>::ptrFromThis ();
   
   
   
diff --git a/tests/core/proc/asset/testasset.hpp b/tests/core/proc/asset/testasset.hpp
index 0b4c73f5d..413eb2f58 100644
--- a/tests/core/proc/asset/testasset.hpp
+++ b/tests/core/proc/asset/testasset.hpp
@@ -53,7 +53,7 @@ namespace test {
       static void deleter (TestAsset<A>* aa) { delete aa; }
       
     public:
-      typedef lib::P<TestAsset<A> > PA;
+      using PA = lib::P<TestAsset<A>>;
       
       static PA create ()             { return (new TestAsset<A>       )->ptrFromThis(); }
       static PA create (PAsset& pRef) { return (new TestAsset<A> (pRef))->ptrFromThis(); }
diff --git a/tests/core/proc/control/argument-tuple-accept-test.cpp b/tests/core/proc/control/argument-tuple-accept-test.cpp
index 132befc5d..bc511feb4 100644
--- a/tests/core/proc/control/argument-tuple-accept-test.cpp
+++ b/tests/core/proc/control/argument-tuple-accept-test.cpp
@@ -54,8 +54,8 @@ namespace test    {
     template<typename SIG>
     struct _Tup
       {
-        typedef typename FunctionSignature< function<SIG> >::Args Args;
-        typedef typename FunctionSignature< function<SIG> >::Ret  Ret;
+        typedef typename FunctionSignature< function<SIG>>::Args Args;
+        typedef typename FunctionSignature< function<SIG>>::Ret  Ret;
         typedef Tuple<Args> Ty;
       };
     
diff --git a/tests/core/proc/control/command-mutation-test.cpp b/tests/core/proc/control/command-mutation-test.cpp
index 3d1ae2672..85354b2a3 100644
--- a/tests/core/proc/control/command-mutation-test.cpp
+++ b/tests/core/proc/control/command-mutation-test.cpp
@@ -108,7 +108,7 @@ namespace test    {
           VERIFY_ERROR (UNBOUND_ARGUMENTS, functor(nullClosure) );
           
           // now create a real closure....
-          Tuple<Types<int> > param = std::make_tuple (23);
+          Tuple<Types<int>> param = std::make_tuple (23);
           SimpleClosure<void(int)> closed_over{param};
           
           CmdClosure& closure (closed_over);
diff --git a/tests/core/proc/control/command-registry-test.cpp b/tests/core/proc/control/command-registry-test.cpp
index a36da3d00..17bbc5b59 100644
--- a/tests/core/proc/control/command-registry-test.cpp
+++ b/tests/core/proc/control/command-registry-test.cpp
@@ -211,7 +211,7 @@ namespace test    {
           
           CHECK (!pImpl->canExec());
           typedef Types<int> ArgType;
-          TypedArguments<Tuple<ArgType> > arg (Tuple<ArgType>(98765));
+          TypedArguments<Tuple<ArgType>> arg{Tuple<ArgType>(98765)};
           pImpl->setArguments(arg);
           CHECK (pImpl->canExec());
           
diff --git a/tests/core/proc/control/handling-pattern-basics-test.cpp b/tests/core/proc/control/handling-pattern-basics-test.cpp
index 844599503..0bd3e686f 100644
--- a/tests/core/proc/control/handling-pattern-basics-test.cpp
+++ b/tests/core/proc/control/handling-pattern-basics-test.cpp
@@ -179,7 +179,7 @@ namespace test    {
           typedef Types<int> ArgType;
           const int ARGU (1 + rand() % 1000);
           Tuple<ArgType> tuple(ARGU);
-          TypedArguments<Tuple<ArgType> > arg(tuple);
+          TypedArguments<Tuple<ArgType>> arg(tuple);
           com->setArguments(arg);
           
           CHECK (com->canExec());
diff --git a/tests/core/proc/engine/testframe.cpp b/tests/core/proc/engine/testframe.cpp
index 9b404dbf5..8310c9492 100644
--- a/tests/core/proc/engine/testframe.cpp
+++ b/tests/core/proc/engine/testframe.cpp
@@ -90,9 +90,9 @@ namespace test   {
      */
     template<uint CHA, uint FRA>
     struct TestFrameTable
-      : vector<vector<TestFrame> >
+      : vector<vector<TestFrame>>
       {
-        typedef vector<vector<TestFrame> > VECT;
+        typedef vector<vector<TestFrame>> VECT;
         
         TestFrameTable()
           : VECT(CHA)
diff --git a/tests/core/proc/mobject/session/defs-registry-impl-test.cpp b/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
index dddebd38e..6bd74a51b 100644
--- a/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
+++ b/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
@@ -79,10 +79,10 @@ namespace test    {
     string Dummy<I>::name = _Fmt("Dummy<%2i>") % I;
     
     template<int I>
-    inline P<Dummy<I> >
+    inline P<Dummy<I>>
     fabricate()
     {
-      return P<Dummy<I> >(new Dummy<I>);
+      return P<Dummy<I>>(new Dummy<I>);
     }
     
   }//(End)Test helpers
@@ -104,14 +104,14 @@ namespace test    {
     {
       scoped_ptr<DefsRegistry> reg_;
       
-      typedef P<Dummy<13> > Obj;
-      typedef P<Dummy<23> > Pra;
+      typedef P<Dummy<13>> Obj;
+      typedef P<Dummy<23>> Pra;
       
-      typedef Query<Dummy<13> > Q13;
-      typedef Query<Dummy<23> > Q23;
+      typedef Query<Dummy<13>> Q13;
+      typedef Query<Dummy<23>> Q23;
       
-      typedef DefsRegistry::Iter<Dummy<13> > Iter13;
-      typedef DefsRegistry::Iter<Dummy<23> > Iter23;
+      typedef DefsRegistry::Iter<Dummy<13>> Iter13;
+      typedef DefsRegistry::Iter<Dummy<23>> Iter23;
       
       
       // some test objects...
diff --git a/tests/library/allocation-cluster-test.cpp b/tests/library/allocation-cluster-test.cpp
index cf1294d43..20bab9bbd 100644
--- a/tests/library/allocation-cluster-test.cpp
+++ b/tests/library/allocation-cluster-test.cpp
@@ -98,7 +98,7 @@ namespace test {
     void
     place_object (AllocationCluster& clu, uint id)
       {
-        clu.create<Dummy<i> > (id);
+        clu.create<Dummy<i>> (id);
       }
     
     typedef void (Invoker)(AllocationCluster&, uint);
@@ -170,10 +170,10 @@ namespace test {
           AllocationCluster clu;
           
           char c1(123), c2(56), c3(3), c4(4), c5(5);
-          Dummy<44>& ref1 = clu.create<Dummy<44> > ();
-          Dummy<37>& ref2 = clu.create<Dummy<37> > (c1);
-          Dummy<37>& ref3 = clu.create<Dummy<37> > (c2);
-          Dummy<1234>& rX = clu.create<Dummy<1234> > (c3,c4,c5);
+          Dummy<44>& ref1 = clu.create<Dummy<44>> ();
+          Dummy<37>& ref2 = clu.create<Dummy<37>> (c1);
+          Dummy<37>& ref3 = clu.create<Dummy<37>> (c2);
+          Dummy<1234>& rX = clu.create<Dummy<1234>> (c3,c4,c5);
           
           CHECK (&ref1);
           CHECK (&ref2);
@@ -189,9 +189,9 @@ namespace test {
           // all created object's dtors will be invoked.
           
           CHECK (4 == clu.size());
-          CHECK (1 == clu.count<Dummy<44> >());
-          CHECK (2 == clu.count<Dummy<37> >());
-          CHECK (1 == clu.count<Dummy<1234> >());
+          CHECK (1 == clu.count<Dummy<44>>());
+          CHECK (2 == clu.count<Dummy<37>>());
+          CHECK (1 == clu.count<Dummy<1234>>());
         }
       
       
@@ -221,7 +221,7 @@ namespace test {
                 {
                   char i1 = truncChar(i);
                   char i2 = truncChar(rand() % 5);
-                  clu.create<Dummy<1> > (i1,i2);
+                  clu.create<Dummy<1>> (i1,i2);
                 }
               catch (char id)
                 {
diff --git a/tests/library/custom-shared-ptr-test.cpp b/tests/library/custom-shared-ptr-test.cpp
index 0ffdc9c61..189210fab 100644
--- a/tests/library/custom-shared-ptr-test.cpp
+++ b/tests/library/custom-shared-ptr-test.cpp
@@ -141,7 +141,7 @@ namespace test{
           CHECK (0 == pX.use_count());
           CHECK (4 == pX2.use_count());
           
-          P<X, P<X> > pXX (pX2);  // a different type, but compatible pointers
+          P<X, P<X>> pXX (pX2);  // a different type, but compatible pointers
           pX2 = pX;
           CHECK (!pX2);
           CHECK (0 == pX2.use_count());
@@ -194,13 +194,13 @@ namespace test{
       void
       check_type_relations ()
         {
-          P<X> pX;                    // Base: shared_ptr<X>
-          P<XX> pX1;                  // Base: shared_ptr<XX>
-          P<XX,P<X> > pX2;            // Base: P<X>
-          P<XX,shared_ptr<X> > pX3;   // Base: shared_ptr<X>
-          P<XX,shared_ptr<long> > pLo;// Base: shared_ptr<long>       (rather nonsense, but well...)
-          P<X,string> pLoL;           // Base: std::string
-          P<string> pLoLoL;           // Base: shared_ptr<string>
+          P<X> pX;                   // Base: shared_ptr<X>
+          P<XX> pX1;                 // Base: shared_ptr<XX>
+          P<XX,P<X>> pX2;            // Base: P<X>
+          P<XX,shared_ptr<X>> pX3;   // Base: shared_ptr<X>
+          P<XX,shared_ptr<long>> pLo;// Base: shared_ptr<long>       (rather nonsense, but well...)
+          P<X,string> pLoL;          // Base: std::string
+          P<string> pLoLoL;          // Base: shared_ptr<string>
           
           CHECK (INSTANCEOF (shared_ptr<X>, &pX));
           
diff --git a/tests/library/del-stash-test.cpp b/tests/library/del-stash-test.cpp
index 5a157d1c8..e35140eb0 100644
--- a/tests/library/del-stash-test.cpp
+++ b/tests/library/del-stash-test.cpp
@@ -130,7 +130,7 @@ namespace test{
           
           killer.manage (p);
           killer.manage (r);
-          killer.manage<Probe<9> > (v);
+          killer.manage<Probe<9>> (v);
           
           CHECK (3 == killer.size());
           
diff --git a/tests/library/linked-elements-test.cpp b/tests/library/linked-elements-test.cpp
index dc843acce..102e97eec 100644
--- a/tests/library/linked-elements-test.cpp
+++ b/tests/library/linked-elements-test.cpp
@@ -416,15 +416,15 @@ namespace test{
             
             ListCustomAllocated elements(allocator);
             
-            elements.pushNew<Num<1> > (2);
-            elements.pushNew<Num<3> > (4,5);
-            elements.pushNew<Num<6> > (7,8,9);
+            elements.pushNew<Num<1>> (2);
+            elements.pushNew<Num<3>> (4,5);
+            elements.pushNew<Num<6>> (7,8,9);
             
             CHECK (sum(9) == Dummy::checksum());
             CHECK (3 == allocator.size());
-            CHECK (1 == allocator.count<Num<1> >());
-            CHECK (1 == allocator.count<Num<3> >());
-            CHECK (1 == allocator.count<Num<6> >());
+            CHECK (1 == allocator.count<Num<1>>());
+            CHECK (1 == allocator.count<Num<3>>());
+            CHECK (1 == allocator.count<Num<6>>());
             
             CHECK (3 == elements.size());
             CHECK (1+2 == elements[2].getVal());
diff --git a/tests/library/meta/config-flags-test.cpp b/tests/library/meta/config-flags-test.cpp
index 906b29f0b..9ed9b2bd1 100644
--- a/tests/library/meta/config-flags-test.cpp
+++ b/tests/library/meta/config-flags-test.cpp
@@ -102,7 +102,7 @@ namespace test {
     template<> struct Maybe<Conf3> : Indeed { enum{ CODE = 30 }; };
     
     template<uint Fl> 
-    struct Maybe<Config<TWO,Fl> >
+    struct Maybe<Config<TWO,Fl>>
     { 
       typedef Yes_t is_defined;
       
@@ -170,7 +170,7 @@ cout << "__________________________\n" \
           CHECK (1==sizeof(flags1));   // pure marker-type without content
           CHECK (1==sizeof(flags2));
           
-          typedef DefineConfigByFlags<Node<Flag<ONE>,NullType> >::Config SimpleConfig_defined_by_Typelist;
+          typedef DefineConfigByFlags<Node<Flag<ONE>,NullType>>::Config SimpleConfig_defined_by_Typelist;
           DISPLAY (SimpleConfig_defined_by_Typelist);
           
           typedef DefineConfigByFlags<AllFlags>::Config AnotherConfig_defined_by_Typelist;
diff --git a/tests/library/meta/function-closure-test.cpp b/tests/library/meta/function-closure-test.cpp
index 7ed7c05fd..56cc89685 100644
--- a/tests/library/meta/function-closure-test.cpp
+++ b/tests/library/meta/function-closure-test.cpp
@@ -142,8 +142,8 @@ namespace test {
       check_signatureTypeManip ()
         {
           typedef int someFunc(Num<5>,Num<9>);
-          typedef FunctionSignature<function<someFunc> >::Ret RetType;  // should be int
-          typedef FunctionSignature<function<someFunc> >::Args Args;
+          typedef FunctionSignature<function<someFunc>>::Ret RetType;  // should be int
+          typedef FunctionSignature<function<someFunc>>::Args Args;
           DISPLAY (Args);
           
           typedef Prepend<Num<1>, Args>::Seq NewArgs;               // manipulate the argument type(s)
@@ -162,10 +162,10 @@ namespace test {
         {
           cout << "\t:\n\t: ---Apply---\n";
           
-          Tuple<Types<> >            tup0 ;
-          Tuple<Types<int> >         tup1 (11);
-          Tuple<Types<int,int> >     tup2 (11,12);
-          Tuple<Types<int,int,int> > tup3 (11,12,13);
+          Tuple<Types<>>            tup0 ;
+          Tuple<Types<int>>         tup1 (11);
+          Tuple<Types<int,int>>     tup2 (11,12);
+          Tuple<Types<int,int,int>> tup3 (11,12,13);
           DUMPVAL (tup0);
           DUMPVAL (tup1);
           DUMPVAL (tup2);
@@ -192,10 +192,10 @@ namespace test {
       void
       check_applyFunc ()
         {
-          Tuple<Types<> >            tup0 ;
-          Tuple<Types<int> >         tup1 (11);
-          Tuple<Types<int,int> >     tup2 (11,12);
-          Tuple<Types<int,int,int> > tup3 (11,12,13);
+          Tuple<Types<>>             tup0 ;
+          Tuple<Types<int>>          tup1 (11);
+          Tuple<Types<int,int>>      tup2 (11,12);
+          Tuple<Types<int,int,int>>  tup3 (11,12,13);
           function<int()>            functor0 (fun0);
           function<int(int)>         functor1 (fun1);
           function<int(int,int)>     functor2 (fun2);
@@ -224,10 +224,10 @@ namespace test {
         {
           cout << "\t:\n\t: ---Bind----\n";
           
-          Tuple<Types<> >            tup0 ;
-          Tuple<Types<int> >         tup1 (11);
-          Tuple<Types<int,int> >     tup2 (11,12);
-          Tuple<Types<int,int,int> > tup3 (11,12,13);
+          Tuple<Types<>>            tup0 ;
+          Tuple<Types<int>>         tup1 (11);
+          Tuple<Types<int,int>>     tup2 (11,12);
+          Tuple<Types<int,int,int>> tup3 (11,12,13);
           
           typedef function<int()> BoundFun;
           
@@ -257,10 +257,10 @@ namespace test {
       void
       check_bindFunc ()
         {
-          Tuple<Types<> >            tup0 ;
-          Tuple<Types<int> >         tup1 (11);
-          Tuple<Types<int,int> >     tup2 (11,12);
-          Tuple<Types<int,int,int> > tup3 (11,12,13);
+          Tuple<Types<>>             tup0 ;
+          Tuple<Types<int>>          tup1 (11);
+          Tuple<Types<int,int>>      tup2 (11,12);
+          Tuple<Types<int,int,int>>  tup3 (11,12,13);
           function<int()>            unbound_functor0 (fun0);
           function<int(int)>         unbound_functor1 (fun1);
           function<int(int,int)>     unbound_functor2 (fun2);
@@ -294,10 +294,10 @@ namespace test {
       void
       build_closure ()
         {
-          Tuple<Types<> >            tup0 ;
-          Tuple<Types<int> >         tup1 (11);
-          Tuple<Types<int,int> >     tup2 (11,12);
-          Tuple<Types<int,int,int> > tup3 (11,12,13);
+          Tuple<Types<>>            tup0 ;
+          Tuple<Types<int>>         tup1 (11);
+          Tuple<Types<int,int>>     tup2 (11,12);
+          Tuple<Types<int,int,int>> tup3 (11,12,13);
           
           FunctionClosure<int()>            clo0 (fun0,tup0);
           FunctionClosure<int(int)>         clo1 (fun1,tup1);
diff --git a/tests/library/meta/function-composition-test.cpp b/tests/library/meta/function-composition-test.cpp
index 8e3df3aaa..71a8172a0 100644
--- a/tests/library/meta/function-composition-test.cpp
+++ b/tests/library/meta/function-composition-test.cpp
@@ -217,7 +217,7 @@ namespace test {
           
           // Version3: let the PApply-template do the work for us--- //
           
-          typedef Types<Num<1> > ArgTypes;                           // now package just the argument(s) to be applied into a tuple
+          typedef Types<Num<1>> ArgTypes;                            // now package just the argument(s) to be applied into a tuple
           Tuple<ArgTypes> args_to_bind (Num<1>(18));
           
           fun_23 = PApply<Sig123, ArgTypes>::bindFront (f , args_to_bind);
@@ -280,7 +280,7 @@ namespace test {
           // covering the general case of partial function closure:
           typedef Num<5> Sig54321(Num<5>, Num<4>, Num<3>, Num<2>, Num<1>);   // Signature of the 5-argument function
           typedef Num<5> Sig54   (Num<5>, Num<4>);                           // ...closing the last 3 arguments should yield this 2-argument function
-          typedef Types<Num<3>,Num<2>,Num<1> > Args2Close;                   // Tuple type to hold the 3 argument values used for the closure
+          typedef Types<Num<3>,Num<2>,Num<1>> Args2Close;                    // Tuple type to hold the 3 argument values used for the closure
           
           // Close the trailing 3 arguments of the 5-argument function...
           function<Sig54> fun_54 = PApply<Sig54321, Args2Close>::bindBack(fun15<5,4,3,2,1>,
@@ -343,7 +343,7 @@ namespace test {
           
           Sig15& f = fun15<1,2,3,4,5>;
           SigA5& f5 = fun11<5>;
-          Tuple<Types<char> > argT(55);
+          Tuple<Types<char>> argT(55);
           
           function<SigR1> f_bound_1 = BindToArgument<Sig15,char,0>::reduced (f, argT);
           function<SigR2> f_bound_2 = BindToArgument<Sig15,char,1>::reduced (f, argT);
diff --git a/tests/library/meta/generator-test.cpp b/tests/library/meta/generator-test.cpp
index c80a203ae..4ca10e8b9 100644
--- a/tests/library/meta/generator-test.cpp
+++ b/tests/library/meta/generator-test.cpp
@@ -131,7 +131,7 @@ namespace test {
           me_can_has_more_numberz.eat (b2);
           me_can_has_more_numberz.eat (b5);
           
-          TakeIt<Block<13> >& subInterface = me_can_has_more_numberz;
+          TakeIt<Block<13>>& subInterface = me_can_has_more_numberz;
           
           subInterface.eat (b13);
           me_can_has_more_numberz.eat();
diff --git a/tests/library/meta/tuple-helper-test.cpp b/tests/library/meta/tuple-helper-test.cpp
index 04380be5c..023341e15 100644
--- a/tests/library/meta/tuple-helper-test.cpp
+++ b/tests/library/meta/tuple-helper-test.cpp
@@ -55,11 +55,11 @@ namespace test {
     typedef Types< Num<1>
                  , Num<3>
                  , Num<5>
-                 >          Types1;
+                 >         Types1;
     typedef Types< Num<2>
                  , Num<4>
-                 >          Types2;
-    typedef Types< Num<7> > Types3;
+                 >         Types2;
+    typedef Types< Num<7>> Types3;
     
     
     
diff --git a/tests/library/meta/typelist-diagnostics.hpp b/tests/library/meta/typelist-diagnostics.hpp
index 8e46538bd..514cdd6bf 100644
--- a/tests/library/meta/typelist-diagnostics.hpp
+++ b/tests/library/meta/typelist-diagnostics.hpp
@@ -88,9 +88,9 @@ namespace meta {
   
   
   /** helper for generating test lists */      
-  template<class X> struct CountDown          { typedef NullType List; };
-  template<>        struct CountDown<Num<0> > { typedef Node<Num<0>, NullType> List; };
-  template<int I>   struct CountDown<Num<I> > { typedef Node<Num<I>, typename CountDown<Num<I-1> >::List> List; };
+  template<class X> struct CountDown         { typedef NullType List; };
+  template<>        struct CountDown<Num<0>> { typedef Node<Num<0>, NullType> List; };
+  template<int I>   struct CountDown<Num<I>> { typedef Node<Num<I>, typename CountDown<Num<I-1>>::List> List; };
   
   
   
diff --git a/tests/library/meta/typelist-manip-test.cpp b/tests/library/meta/typelist-manip-test.cpp
index 6a863e078..26a9d47fc 100644
--- a/tests/library/meta/typelist-manip-test.cpp
+++ b/tests/library/meta/typelist-manip-test.cpp
@@ -153,13 +153,13 @@ namespace test {
               typedef Append<NullType, NullType> Append1;
               DISPLAY (Append1);
               
-              typedef Append<Num<11>,Num<22> >   Append2;
+              typedef Append<Num<11>,Num<22>>    Append2;
               DISPLAY (Append2);
               
               typedef Append<Num<111>,NullType>  Append3;
               DISPLAY (Append3);
               
-              typedef Append<NullType,Num<222> > Append4;
+              typedef Append<NullType,Num<222>>  Append4;
               DISPLAY (Append4);
               
               typedef Append<List1,NullType>     Append5;
@@ -171,7 +171,7 @@ namespace test {
               typedef Append<Num<111>,List2>     Append7;
               DISPLAY (Append7);
               
-              typedef Append<List1,Num<222> >    Append8;
+              typedef Append<List1,Num<222>>     Append8;
               DISPLAY (Append8);
               
               typedef Append<List1,List2>        Append9;
@@ -182,7 +182,7 @@ namespace test {
           void
           check_splice ()
             {
-              typedef Types<Num<9>,Num<8> >::List OLi;
+              typedef Types<Num<9>,Num<8>>::List OLi;
               // will "paste" the list OLi "on top" of another Typelist...
               
               typedef Splice<NullType, NullType> Overl01;
@@ -225,7 +225,7 @@ namespace test {
               DISPLAY (Overl13);
               
               
-              typedef Types<Num<99> >::List OLi2;
+              typedef Types<Num<99>>::List OLi2;
               typedef Splice<List1, OLi2, 0>::Front Front1;
               typedef Splice<List1, OLi2, 1>::Front Front2;
               typedef Splice<List1, OLi2, 5>::Front Front3;
@@ -293,8 +293,8 @@ namespace test {
           
           
           
-          template<class X> struct AddConst2          { typedef X        Type; };
-          template<int I>   struct AddConst2<Num<I> > { typedef Num<I+2> Type; };
+          template<class X> struct AddConst2         { typedef X        Type; };
+          template<int I>   struct AddConst2<Num<I>> { typedef Num<I+2> Type; };
           
           void
           check_apply ()
@@ -304,8 +304,8 @@ namespace test {
             }
           
           
-          template<class X> struct IsEven          { enum {value = false };        };
-          template<int I>   struct IsEven<Num<I> > { enum {value = (0 == I % 2) }; };
+          template<class X> struct IsEven         { enum {value = false };        };
+          template<int I>   struct IsEven<Num<I>> { enum {value = (0 == I % 2) }; };
           
           void
           check_filter ()
@@ -318,13 +318,13 @@ namespace test {
           void
           check_prefix ()
             {
-              typedef PrefixAll<Num<11>,Num<22> > Prefix1;
+              typedef PrefixAll<Num<11>,Num<22>> Prefix1;
               DISPLAY (Prefix1);
               
-              typedef PrefixAll<Num<101>,List1>   Prefix2;
+              typedef PrefixAll<Num<101>,List1>  Prefix2;
               DISPLAY (Prefix2);
               
-              typedef PrefixAll<NullType,List1>   Prefix3;
+              typedef PrefixAll<NullType,List1>  Prefix3;
               DISPLAY (Prefix3);
               
               typedef Types<List1::List,Num<0>,List2::List>::List  List_of_Lists;
@@ -345,8 +345,8 @@ namespace test {
               typedef Distribute<Num<11>, List1> Dist1;
               DISPLAY (Dist1);
               
-              typedef Types<Num<11>,Num<22>,Num<33> >::List Prefixes;
-              typedef Distribute<Prefixes, Num<0> > Dist2;
+              typedef Types<Num<11>,Num<22>,Num<33>>::List Prefixes;
+              typedef Distribute<Prefixes, Num<0>> Dist2;
               DISPLAY (Dist2);
               
               typedef Distribute<Prefixes, List1> Dist3;
@@ -360,7 +360,7 @@ namespace test {
           void
           check_combine()
             {
-              typedef CountDown<Num<11> > Down;
+              typedef CountDown<Num<11>> Down;
               DISPLAY (Down);
               
               typedef Combine<List1::List, CountDown> Combi;
diff --git a/tests/library/multifact-singleton-test.cpp b/tests/library/multifact-singleton-test.cpp
index 08ce5e1eb..6153c7217 100644
--- a/tests/library/multifact-singleton-test.cpp
+++ b/tests/library/multifact-singleton-test.cpp
@@ -78,10 +78,10 @@ namespace test{
     TestFactory theFact;
     
     // Configure the products to be fabricated....
-    TestFactory::Singleton<Implementation<ONE> > holder1 (theFact,ONE);
-    TestFactory::Singleton<Implementation<TWO> > holder2 (theFact,TWO);
-    TestFactory::Singleton<Implementation<THR> > holder3 (theFact,THR);
-    TestFactory::Singleton<Implementation<FOU> > holder4 (theFact,FOU);
+    TestFactory::Singleton<Implementation<ONE>> holder1{theFact,ONE};
+    TestFactory::Singleton<Implementation<TWO>> holder2{theFact,TWO};
+    TestFactory::Singleton<Implementation<THR>> holder3{theFact,THR};
+    TestFactory::Singleton<Implementation<FOU>> holder4{theFact,FOU};
   }
   
   
@@ -124,7 +124,7 @@ namespace test{
           CHECK (isnil (anotherFact));
           VERIFY_ERROR (INVALID, anotherFact(ONE) );
           
-          TestFactory::Singleton<Implementation<ONE> > anotherSingletonHolder (anotherFact,ONE);
+          TestFactory::Singleton<Implementation<ONE>> anotherSingletonHolder (anotherFact,ONE);
           Interface & o3 = anotherFact(ONE);
           CHECK (isSameObject(o2,o3));
         } 
diff --git a/tests/library/opaque-unchecked-buffer-test.cpp b/tests/library/opaque-unchecked-buffer-test.cpp
index 6b6b74cd3..cdf8d7725 100644
--- a/tests/library/opaque-unchecked-buffer-test.cpp
+++ b/tests/library/opaque-unchecked-buffer-test.cpp
@@ -137,7 +137,7 @@ namespace test{
           _checksum = 0;
           _create_count = 0;
           {
-            typedef InPlaceBuffer<Base, sizeof(DD<42>), DD<0> > Buffer;
+            typedef InPlaceBuffer<Base, sizeof(DD<42>), DD<0>> Buffer;
             
             Buffer buff;
             CHECK (sizeof(buff) <= sizeof(DD<42>) + _ALIGN_);
@@ -145,10 +145,10 @@ namespace test{
             CHECK (0 == _checksum);
             buff->confess();          // one default object of type DD<0> has been created
             
-            buff.create<DD<5> > ();
+            buff.create<DD<5>>();
             buff->confess();
             
-            buff.create<DD<9> > ("I'm fine");
+            buff.create<DD<9>> ("I'm fine");
             buff->confess();
             
             VERIFY_ERROR( FATAL, buff.create<Killer> () );
diff --git a/tests/library/polymorphic-value-test.cpp b/tests/library/polymorphic-value-test.cpp
index 6da5cd81f..785838ffe 100644
--- a/tests/library/polymorphic-value-test.cpp
+++ b/tests/library/polymorphic-value-test.cpp
@@ -194,11 +194,11 @@ namespace test{
       createOpaqueValues ()
         {
           TestList list;
-          list.push_back (PolyVal::build<Imp<1> >  () );
-          list.push_back (PolyVal::build<Imp<11> > () );
-          list.push_back (PolyVal::build<Imp<111> >() );
-          list.push_back (PolyVal::build<Imp<23> > () );
-          list.push_back (PolyVal::build<Imp<5> >  () );
+          list.push_back (PolyVal::build<Imp<1>>  () );
+          list.push_back (PolyVal::build<Imp<11>> () );
+          list.push_back (PolyVal::build<Imp<111>>() );
+          list.push_back (PolyVal::build<Imp<23>> () );
+          list.push_back (PolyVal::build<Imp<5>>  () );
           return list;
         } //note: copy
       
diff --git a/tests/library/simple-allocator-test.cpp b/tests/library/simple-allocator-test.cpp
index 891a9020a..2982e44e3 100644
--- a/tests/library/simple-allocator-test.cpp
+++ b/tests/library/simple-allocator-test.cpp
@@ -106,10 +106,10 @@ namespace test{
           typedef DummyObj<23> * PD23;
           CHECK (sizeof(DummyObj<1>) != sizeof(DummyObj<23>));
           
-          PD1  pD11 = allocator.create<DummyObj<1> >();
-          PD1  pD12 = allocator.create<DummyObj<1> >();
-          PD23 pD21 = allocator.create<DummyObj<23> >();
-          PD23 pD22 = allocator.create<DummyObj<23> >();
+          PD1  pD11 = allocator.create<DummyObj<1>>();
+          PD1  pD12 = allocator.create<DummyObj<1>>();
+          PD23 pD21 = allocator.create<DummyObj<23>>();
+          PD23 pD22 = allocator.create<DummyObj<23>>();
           PS   pS11 = allocator.create<string> ("Lumiera");
           PS   pS12 = allocator.create<string> ("the paradox");
           
@@ -138,8 +138,8 @@ namespace test{
           CHECK (*pS11 == "Lumiera");
           CHECK (*pS12 == "the paradox");
           
-          PD23 pDxx = allocator.create<DummyObj<23> > (*pD21);
-          PS   pSxx = allocator.create<string>        (*pS12);
+          PD23 pDxx = allocator.create<DummyObj<23>> (*pD21);
+          PS   pSxx = allocator.create<string>       (*pS12);
           
           CHECK (*pS12 == *pSxx);
           CHECK (!isSameObject (*pS12, *pSxx));
@@ -153,8 +153,8 @@ namespace test{
           allocator.destroy (pDxx);
           allocator.destroy (pSxx);
           
-          CHECK (0 == allocator.numSlots<DummyObj<1> >());
-          CHECK (0 == allocator.numSlots<DummyObj<23> >());
+          CHECK (0 == allocator.numSlots<DummyObj<1>>());
+          CHECK (0 == allocator.numSlots<DummyObj<23>>());
           CHECK (0 == allocator.numSlots<string>());
           CHECK (0 == checksum_);
         }
diff --git a/tests/library/sub-id-test.cpp b/tests/library/sub-id-test.cpp
index 8b7ab938b..fb420c946 100644
--- a/tests/library/sub-id-test.cpp
+++ b/tests/library/sub-id-test.cpp
@@ -142,7 +142,7 @@ namespace test{
       
       template<class KEY>
       struct HashTable
-        : std::unordered_map<KEY, string, hash<KEY> >
+        : std::unordered_map<KEY, string, hash<KEY>>
         {
           void
           add (KEY key)
diff --git a/tests/library/symbol-hashtable-test.cpp b/tests/library/symbol-hashtable-test.cpp
index 71aefef4d..ec5e8b108 100644
--- a/tests/library/symbol-hashtable-test.cpp
+++ b/tests/library/symbol-hashtable-test.cpp
@@ -54,7 +54,7 @@ namespace test{
     
   }
   
-  typedef std::unordered_map< Symbol, string, hash<Symbol> > HTable;
+  typedef std::unordered_map< Symbol, string, hash<Symbol>> HTable;
   
   
   /*********************************************************//**
diff --git a/tests/library/typed-allocation-manager-test.cpp b/tests/library/typed-allocation-manager-test.cpp
index ef75edfd3..4d6616a8f 100644
--- a/tests/library/typed-allocation-manager-test.cpp
+++ b/tests/library/typed-allocation-manager-test.cpp
@@ -90,15 +90,15 @@ namespace test{
           
           TypedAllocationManager allocator;
           
-          typedef shared_ptr<DummyObj<1> >  PD1;
-          typedef shared_ptr<DummyObj<22> > PD22;
+          typedef shared_ptr<DummyObj<1>>  PD1;
+          typedef shared_ptr<DummyObj<22>> PD22;
           CHECK (sizeof(DummyObj<1>) != sizeof(DummyObj<22>));
           
             {
               PD1  pD11 = allocator.create<DummyObj<1> >();
               PD1  pD12 = allocator.create<DummyObj<1> >();
-              PD22 pD21 = allocator.create<DummyObj<22> >();
-              PD22 pD22 = allocator.create<DummyObj<22> >();
+              PD22 pD21 = allocator.create<DummyObj<22>>();
+              PD22 pD22 = allocator.create<DummyObj<22>>();
               CHECK (pD11);
               CHECK (pD12);
               CHECK (pD21);
@@ -121,13 +121,13 @@ namespace test{
               CHECK (isSameObject (*pD21, *pD2x));
               
               CHECK (2 == allocator.numSlots<DummyObj<1> >());
-              CHECK (2 == allocator.numSlots<DummyObj<22> >());
+              CHECK (2 == allocator.numSlots<DummyObj<22>>());
               
               CHECK (0 == allocator.numSlots<long>()); // query just some unrelated type...
             }
           
           CHECK (0 == allocator.numSlots<DummyObj<1> >());
-          CHECK (0 == allocator.numSlots<DummyObj<22> >());
+          CHECK (0 == allocator.numSlots<DummyObj<22>>());
           CHECK (0 == checksum_);
         }
     };