diff --git a/NodeKittenX.podspec b/NodeKittenX.podspec
index e5d14b9..6dbe2bf 100644
--- a/NodeKittenX.podspec
+++ b/NodeKittenX.podspec
@@ -25,7 +25,7 @@ s.source_files = "blocks/leif/NodeKittenX/*.{h}","blocks/leif/NodeKittenX/Platfo
 
 s.subspec "freetypegl" do |freetypegl|
     freetypegl.source_files = "deps/leif/freetype-gl/*.{h,c,cpp}"
-    #freetypegl.ios.vendored_libraries = "libs/ios/libFreetype2/libFreetype2.a"
+
     freetypegl.subspec "freetype" do |freetype|
             freetype.osx.source_files = "deps/miguel/freetype/src/base/*.{h,c}"
             freetype.ios.source_files = "deps/miguel/freetype/src/base/ftadvanc.c",
@@ -87,10 +87,8 @@ s.subspec "freetypegl" do |freetypegl|
                                     "deps/miguel/freetype/src/type42/type42.{h,c}",
                                     "deps/miguel/freetype/src/winfonts/winfnt.{h,c}"
             freetype.compiler_flags = '-DFT2_BUILD_LIBRARY=1 -DDARWIN_NO_CARBON -DFT_CONFIG_OPTION_SYSTEM_ZLIB=1'
-            freetype.xcconfig = { "HEADER_SEARCH_PATHS" => "/Users/leif/ClionProjects/NodeKittenX/deps/miguel/freetype/include" }
-            #freetype.xcconfig = { "HEADER_SEARCH_PATHS" => "
+            freetype.xcconfig = { "HEADER_SEARCH_PATHS" => "$(PODS_ROOT)/deps/miguel/freetype/include" }
         end
-    freetypegl.xcconfig = { "HEADER_SEARCH_PATHS" => "/Users/leif/ClionProjects/NodeKittenX/libs/ios/libFreetype2/include" }
 end
 
 s.subspec "picojpeg" do |picojpeg|
@@ -98,7 +96,14 @@ picojpeg.source_files = "deps/leif/picojpeg/*.{h,c,cpp}"
 end
 
 s.subspec "kiwi" do |kiwi|
-  kiwi.source_files = "deps/leif/kiwi/kiwi/*.{h}"
+  kiwi.source_files = "deps/leif/kiwi/kiwi/*.{h, hpp}"
+end
+
+s.subspec "underscore" do |underscore|
+underscore.source_files = "deps/leif/underscore/_.hpp",
+                          "deps/leif/underscore/underscore/underscore.h",
+                          "deps/leif/underscore/underscorehpp/*.hpp"
+underscore.xcconfig = { "HEADER_SEARCH_PATHS" => "$(PODS_ROOT)/deps/leif/underscore" }
 end
 
 s.subspec "png" do |png|
diff --git a/blocks/leif/NodeKittenX/Examples/LayoutExample.cpp b/blocks/leif/NodeKittenX/Examples/LayoutExample.cpp
index 3410a0f..dc6c610 100644
--- a/blocks/leif/NodeKittenX/Examples/LayoutExample.cpp
+++ b/blocks/leif/NodeKittenX/Examples/LayoutExample.cpp
@@ -6,18 +6,35 @@
 //
 //
 
-
 #include "LayoutExample.h"
 
 void LayoutExample::moveToView() {
-    auto container = ContainerView::viewWithSize(size.get().xy);
-    container
-            ->addRow(V2{.5, .5})
-            ->addColumn(V2{.5, .5});
-    container->addRow(V2{.5, .5})->setBackgroundColor(Color{.3, .3, .3});
-    addChild(container);
+  setLayoutMethod(Layout::Method::Vertical);
+  
+  addChild(View::view())->setBackgroundColor(Color("red"));
+  addChild(View::view())->setBackgroundColor(Color("orange"));
+  addChild(View::view())->setBackgroundColor(Color("yellow"));
+  addChild(View::view())->setBackgroundColor(Color("green"));
+  addChild(View::view())->setBackgroundColor(Color("blue"));
+  auto row = addChild(View::view())->setBackgroundColor(Color("violet"));
+  
+  row->setLayoutMethod(Layout::Method::Horizontal);
+  row->addChild(View::view())->setBackgroundColor(Color("red"));
+  row->addChild(View::view())->setBackgroundColor(Color("orange"));
+  row->addChild(View::view())->setBackgroundColor(Color("yellow"));
+  row->addChild(View::view())->setBackgroundColor(Color("green"));
+  row->addChild(View::view())->setBackgroundColor(Color("blue"));
+  auto col = row->addChild(View::view())->setBackgroundColor(Color("violet"));
+  
+  col->setLayoutMethod(Layout::Method::Vertical);
+  col->addChild(View::view())->setBackgroundColor(Color("red"));
+  col->addChild(View::view())->setBackgroundColor(Color("orange"));
+  col->addChild(View::view())->setBackgroundColor(Color("yellow"));
+  col->addChild(View::view())->setBackgroundColor(Color("green"));
+  col->addChild(View::view())->setBackgroundColor(Color("blue"));
+  col->addChild(View::view())->setBackgroundColor(Color("violet"));
 }
 
 void LayoutExample::handleUXEvent(shared_ptr<UXEvent> event){
-
+  
 }
\ No newline at end of file
diff --git a/blocks/leif/NodeKittenX/Generic/Layout.h b/blocks/leif/NodeKittenX/Generic/Layout.h
index dfeb0e6..5ff783c 100644
--- a/blocks/leif/NodeKittenX/Generic/Layout.h
+++ b/blocks/leif/NodeKittenX/Generic/Layout.h
@@ -5,145 +5,205 @@
 #include "kiwi.h"
 
 // non-raw literal operator
-constexpr double operator"" _percent( long double val) { return val / 100 ; }
-
-//namespace underscore {
-//    template<class Container, class Function>
-//    void each(Container container, Function fn)
-//    {
-//      auto first = cbegin(container);
-//      auto last = cend(container);
-//
-//      while (first!=last) {
-//        fn (*first);
-//        ++first;
-//      }
-//    }
-//}
-
-typedef enum : U1t {
-  LayoutManual,
-  LayoutContainer,
-  LayoutRow,
-  LayoutColumn,
-  LayoutCollection
-} LayoutMethod;
-
-enum class ConstraintType {size, margin};
-
-class LayoutUnit : public Reactive::Observable<F1t> {
-  using Reactive::Observable<F1t>::Observable;
-};
-
-class LayoutUnitPixel : public LayoutUnit {
-};
-
-class LayoutUnitPercent : public LayoutUnit {
-public:
-  class DoubleIsPercent{}; // a tag
-  explicit LayoutUnitPercent(DoubleIsPercent, double pct) : LayoutUnit(pct/100.0) {}
-};
-
-static LayoutUnitPercent operator "" _pct( long double pct )
-{
-  return LayoutUnitPercent{LayoutUnitPercent::DoubleIsPercent{}, static_cast<double>(pct)};
-}
-
-class Constraint {
-  ConstraintType _type;
-  std::vector<LayoutUnit> constraints;
-
-public:
-  const ConstraintType type() const {return _type;}
-  void setType(ConstraintType type) {_type = type;}
-
-  F1t solve(){
-
-  }
-
-
-};
-
-
-
-class Solver {
-  std::vector<Constraint> constraints;
-  kiwi::Solver kSolver;
-  kiwi::Variable x {"x"};
-  kiwi::Variable y {"y"};
-
-public:
-
-  Solver(){
-
-    // x = 20
-    kSolver.addConstraint(x == 20);
-
-    // x + 2 == y + 10
-    kSolver.addConstraint(x + 2 == y + 20);
-    // these all have strength 'required
-
-    kSolver.updateVariables();
-
-    nkLog("x + %f + y + %f", x.value(), y.value());
-
-// x == 20
-// y == 12
-
+constexpr double operator"" _pct( long double val) { return val / 100.0f ; }
+
+namespace Layout {
+  
+  enum class Method {
+    None,
+    Horizontal,
+    Vertical,
+    Container,
+    Row,
+    Column,
+    Collection
   };
-  ~Solver(){};
-
-  F1t solve(){
-
-  }
-};
-
-template<typename T>
-class Layout : public T {
-
-  bool horizontalMajor {false};
-
-  T* _selectedElement;
-  T* _element;
-
-  V4 anchor;
-
-  V2 Offset;
-  LayoutMethod _layoutMethod {LayoutContainer};
-
-  Constraint _constraint;
-
-public:
-  using T::T;
-
-  void layout(){
-//    _::each(this->children(), [](auto& child){
-//        nkLog(child->);
-//    });
+  
+  enum class Unit {
+    none,
+    Pixels,
+    Percent,
+    ConstrainPixels,
+    ConstrainPct
   };
-
-  const T* selectedElement() const {return _selectedElement;}
-  void setSelectedElement(T* selectedElement) {_selectedElement = selectedElement;}
-
-  const LayoutMethod layoutMethod() const {return _layoutMethod;}
-  void setLayoutMethod(LayoutMethod layoutMethod) {_layoutMethod = layoutMethod;}
-
-  // LAYOUT
-  virtual V2 sizeForViewAtIndex(IndexPath indexPath){
-
-  }
-  virtual V2 positionForViewAtIndexPath(IndexPath indexPath, T* view){
-
-  }
-  virtual V2 spacingForViewAtIndexPath(IndexPath indexPath, T* view){
-
-  }
-
-  // SCROLLING
-  virtual V2 targetPositionForEstimatedPosition(V2 position){
-
+  
+  enum class ConstraintType {size, margin};
+  
+  class LayoutUnit : public Reactive::Observable<F1t> {
+    using Reactive::Observable<F1t>::Observable;
+  };
+  
+  class LayoutUnitPixel : public LayoutUnit {
+  };
+  
+  class LayoutUnitPercent : public LayoutUnit {
+  public:
+    class DoubleIsPercent{}; // a tag
+    explicit LayoutUnitPercent(DoubleIsPercent, double pct) : LayoutUnit(pct/100.0) {}
+  };
+  
+  static LayoutUnitPercent operator "" _pct( long double pct )
+  {
+    return LayoutUnitPercent{LayoutUnitPercent::DoubleIsPercent{}, static_cast<double>(pct)};
   }
-
-};
+  
+  class Constraint {
+    ConstraintType _type;
+    std::vector<LayoutUnit> constraints;
+    
+  public:
+    const ConstraintType type() const {return _type;}
+    void setType(ConstraintType type) {_type = type;}
+    
+    F1t solve(){
+      
+    }
+    
+    
+  };
+  
+  
+  
+  class Solver {
+    std::vector<Constraint> constraints;
+    kiwi::Solver kSolver;
+    kiwi::Variable x {"x"};
+    kiwi::Variable y {"y"};
+    
+  public:
+    
+    Solver(){
+      
+      // x = 20
+      kSolver.addConstraint(x == 20);
+      
+      // x + 2 == y + 10
+      kSolver.addConstraint(x + 2 == y + 20);
+      // these all have strength 'required
+      
+      kSolver.updateVariables();
+      
+      nkLog("x + %f + y + %f", x.value(), y.value());
+      
+      // x == 20
+      // y == 12
+      
+    };
+    ~Solver(){};
+    
+    F1t solve(){
+      
+    }
+  };
+  
+  template<typename T>
+  class Delegate {
+    
+  };
+  
+  template<typename T>
+  class Manager {
+    std::vector<T*> _selectedElements;
+    
+    Delegate<T>* _delegate;
+    
+    bool _descending {true};
+    V2 _anchorPoint {0,0};
+    V2 _offset {0,0};
+    V4 _spacing {0,0,0,0};
+    
+    Method _method {Method::None};
+    Unit _unit {Unit::Percent};
+    Constraint _constraint;
+    
+  public:
+    const Method layoutMethod() const {return _method;}
+    Manager<T>* setLayoutMethod(Method layoutMethod) {_method = layoutMethod; return this;}
+    
+    const V2 anchorPoint() const {return _anchorPoint;}
+    Manager<T>* setAnchorPoint(V2 anchorPoint) {_anchorPoint = anchorPoint; return this;}
+    
+    const V2 spacing() const {return _spacing;}
+    Manager<T>* setSpacing(V2 spacing) {_spacing = spacing; return this;}
+    
+    // LAYOUT
+    virtual V2 sizeForViewAtIndex(IndexPath indexPath){
+      return {0,0};
+    }
+          
+    virtual V2 positionForViewAtIndexPath(IndexPath indexPath, T* view){
+      return {0,0};
+    }
+    virtual V2 spacingForViewAtIndexPath(IndexPath indexPath, T* view){
+      return {0,0};
+    }
+    
+    virtual int numberOfSections(){
+      return 1;
+    }
+    
+    virtual int numberOfChildrenInSection(const unsigned int section){
+      return 0;
+    }
+    
+    // SCROLLING
+    virtual V2 targetPositionForEstimatedPosition(V2 position){
+      return {0,0};
+    }
+    
+    void staticLayout(T* element, bool vertical, bool descending){
+      auto invert = descending ? -1.0f : 1.0f;
+      
+      auto spacing = V2{_spacing.left + _spacing.right, _spacing.top + _spacing.bottom};
+      
+      auto origin = element->size.get().xy * (_anchorPoint - (V2{.5,.5} * invert));
+      
+      V2 csize;
+      
+      if (vertical) {
+        csize = (element->size.get().xy * V2{1.0f, 1.0f / element->children().size()}) - spacing;
+        origin += (csize * .5) * invert;
+        if (descending) origin.y -= _spacing.top;
+        else origin.y += _spacing.bottom;
+        origin.x -= _spacing.right;
+      }
+      else {
+        csize = (element->size.get().xy * V2{1.0f / element->children().size(), 1.0f}) - spacing;
+        origin += (csize * .5) * invert;
+        if (descending) origin.x -= _spacing.right;
+        else origin.x += _spacing.left;
+        origin.y += _spacing.bottom;
+      }
+      
+      auto step = (csize + spacing) * invert;
+      
+      if (vertical) step.x = 0;
+      else step.y = 0;
+
+      for (auto& child : element->children()){
+        child->position.set(origin);
+        child->size.set(csize);
+        origin += step;
+      }
+    }
+    
+    virtual void layout(T* element) {
+      switch (_method){
+        case Method::None: default:
+          for (auto& child : element->children()){
+            child->afterTransform();
+          }
+        case Method::Vertical:
+          staticLayout(element, true, true);
+          break;
+        case Method::Horizontal:
+          staticLayout(element, false, false);
+          break;
+      }
+    };
+    
+  };
+  
+}
 
 #endif
\ No newline at end of file
diff --git a/blocks/leif/NodeKittenX/Generic/Nodal.h b/blocks/leif/NodeKittenX/Generic/Nodal.h
index 6b2ebc9..8afe852 100644
--- a/blocks/leif/NodeKittenX/Generic/Nodal.h
+++ b/blocks/leif/NodeKittenX/Generic/Nodal.h
@@ -19,20 +19,23 @@ class Nodal {
     return _children[0];
   }
   
-  T* addChild(std::shared_ptr<T>& child) {
+  template<class C>
+  C* addChild(std::shared_ptr<C>& child) {
     addChild(std::move(child));
     return child.get();
   }
   
-  T* addChild(std::shared_ptr<T>&& child) {
+  template<class C>
+  C* addChild(std::shared_ptr<C>&& child) {
     child->_siblingPosition = (int)_children.size();
     _children.push_back(child);
     child->setParent(static_cast<T*>(this));
     afterChildrenChanged();
-    return child.get();
+    return static_cast<C*>(child.get());
   }
   
-  T* insertChild(std::shared_ptr<T>& child, int atIndex){
+  template<class C>
+  C* insertChild(std::shared_ptr<C>& child, int atIndex){
     if (!_children.size()) {
       addChild(child);
     }
@@ -54,7 +57,7 @@ class Nodal {
     return nullptr;
   }
   
-  T* nextSibling() {
+  T* nextSibling() const {
     if (_parent){
       auto next = _parent->childAtSiblingPosition(_siblingPosition+1);
       if (next) return next;
@@ -64,7 +67,7 @@ class Nodal {
     return this;
   };
   
-  T* previousSibling() {
+  T* previousSibling() const {
     if (_parent){
       if (_siblingPosition-1 > 0){
         auto next = _parent->childAtSiblingPosition(_siblingPosition-1);
@@ -79,7 +82,8 @@ class Nodal {
   virtual void afterChildrenChanged(){
   }
   
-  virtual void setParent(T *parent){
+  
+  virtual T* setParent(T *parent){
     if (_parent) {
       beforeParentChanged();
       _parent->removeChild(static_cast<T*>(this));
@@ -89,6 +93,7 @@ class Nodal {
     else {
       _parent = parent;
     }
+    return static_cast<T*>(this);
   }
   
   virtual void beforeParentChanged(){};
diff --git a/blocks/leif/NodeKittenX/Generic/Reactive.h b/blocks/leif/NodeKittenX/Generic/Reactive.h
index dc6b476..3d1d8f8 100644
--- a/blocks/leif/NodeKittenX/Generic/Reactive.h
+++ b/blocks/leif/NodeKittenX/Generic/Reactive.h
@@ -5,167 +5,155 @@
 #include "GLState.h"
 
 namespace Reactive {
-
+  
   using std::function;
-
+  
   template<typename T>
   class Pullable {
-    static std::unordered_map<const void *, function<T()>> functions;
   protected:
     mutable bool _dirty;
     mutable T _cache;
+    std::function<T()> pull;
   public:
     Pullable() : _dirty{true} { }
-
+    
     Pullable(const T &initial) : _cache(initial), _dirty{false} { }
-
+    
     virtual ~Pullable() {
-      functions.erase(this);
     }
-
+    
     void setPullFunction(std::function<T(void)> &&func) {
-      functions[this] = func;
+      pull = func;
     }
-
-    T pull() const {
-      return functions[this]();
-    }
-
+    
     T get() const {
       if (!_dirty) return _cache;
       Pullable::set(pull());
       return _cache;
     };
-
+    
     T ref() const {
       return _cache;
     }
-
+    
     virtual void set(const T &value) const {
       _cache = value;
       _dirty = false;
     };
-
+    
     void setDirty(bool dirty = true) {
       _dirty = dirty;
     };
   };
-
-  template<typename T>
-  std::unordered_map<const void *, std::function<T()>> Pullable<T>::functions;
-
+  
+  
   template<typename T>
   class Variable : public Pullable<T> {
-    static std::unordered_map<const void *, std::vector < function<void(void)>>>
-    afterFuncs;
+    std::vector<function<void(void)>> afterFuncs;
   public:
     void afterSet(function<void(void)> &&callback) {
-      afterFuncs[this].push_back(callback);
+      afterFuncs.push_back(callback);
     }
-
+    
     void set(const T &value) const override {
       Pullable<T>::set(value);
-      for (auto &callback : afterFuncs[this]) {
+      for (auto &callback : afterFuncs) {
         callback();
       }
     }
-
+    
     virtual ~Variable() {
-      afterFuncs.erase(this);
-    }
-  };
-
-  template<typename T>
-  std::unordered_map<const void *, std::vector < function<void(void)>>>
-    Variable<T>::afterFuncs;
-
-  template<typename T>
-  class ObserverHandle;
-
-  template<typename T>
-  class Observable : public Pullable<T> {
-    using Pullable<T>::Pullable;
-    std::vector<ObserverHandle<T> *> observers;
-  public:
-    void set(const T &value) const override;
-
-    void addObserver(ObserverHandle<T> *observer) {
-      observers.push_back(observer);
-    }
-
-    void removeObserver(ObserverHandle<T> *observer) {
-      _::erase(observers, observer);
     }
-  };
-
-  template<typename T>
-  class PropertyObserver {
-    std::vector <std::unique_ptr<ObserverHandle<T>>> observers;
-  public:
-    void addObserver(const Observable<T> &property, function<void(T)> &&observeCallback) {
-      observers.emplace_back(property, observeCallback);
-    }
-  };
-
-  template<typename T>
-  class ObserverHandle {
-    Observable<T> &_property;
-    function<void(T)> _observeCallback;
-  public:
-    ObserverHandle(const Observable<T> &property, function<void(T)> observeCallback) :
+    };
+    
+    
+    template<typename T>
+    class ObserverHandle;
+    
+    template<typename T>
+    class Observable : public Pullable<T> {
+      using Pullable<T>::Pullable;
+      std::vector<ObserverHandle<T> *> observers;
+    public:
+      void set(const T &value) const override;
+      
+      void addObserver(ObserverHandle<T> *observer) {
+        observers.push_back(observer);
+      }
+      
+      void removeObserver(ObserverHandle<T> *observer) {
+        _::erase(observers, observer);
+      }
+    };
+    
+    template<typename T>
+    class PropertyObserver {
+      std::vector <std::unique_ptr<ObserverHandle<T>>> observers;
+    public:
+      void addObserver(const Observable<T> &property, function<void(T)> &&observeCallback) {
+        observers.emplace_back(property, observeCallback);
+      }
+    };
+    
+    template<typename T>
+    class ObserverHandle {
+      Observable<T> &_property;
+      function<void(T)> _observeCallback;
+    public:
+      ObserverHandle(const Observable<T> &property, function<void(T)> observeCallback) :
       _property(property),
       _observeCallback(observeCallback) {
-      _property->addObserver(this);
-    }
-
-    ~ObserverHandle() {
-      _property->removeObserver(this);
-    }
-
-    void observe(T changedValue) {
-      _observeCallback(changedValue);
-    }
-  };
-
-  template<typename T>
-  void Observable<T>::set(const T &value) const {
-    Pullable<T>::set(value);
-    for (auto &p : observers) {
-      p->observe(Pullable<T>::get());
-    }
-  }
-
-  template<typename T>
-  class Vector : public Variable<T> {
-  public:
-    void setX(F1t elem) {
-      T ex = Pullable<T>::_cache;
-      ex.v[0] = elem;
-      Pullable<T>::set(ex);
-    };
-
-    void setY(F1t elem) {
-      T ex = Pullable<T>::_cache;
-      ex.v[1] = elem;
-      Pullable<T>::set(ex);
+        _property->addObserver(this);
+      }
+      
+      ~ObserverHandle() {
+        _property->removeObserver(this);
+      }
+      
+      void observe(T changedValue) {
+        _observeCallback(changedValue);
+      }
     };
-
-    void setZ(F1t elem) {
-      T ex = Pullable<T>::_cache;
-      ex.v[2] = elem;
-      Pullable<T>::set(ex);
+    
+    template<typename T>
+    void Observable<T>::set(const T &value) const {
+      Pullable<T>::set(value);
+      for (auto &p : observers) {
+        p->observe(Pullable<T>::get());
+      }
+    }
+    
+    template<typename T>
+    class Vector : public Variable<T> {
+    public:
+      void setX(F1t elem) {
+        T ex = Pullable<T>::_cache;
+        ex.v[0] = elem;
+        Pullable<T>::set(ex);
+      };
+      
+      void setY(F1t elem) {
+        T ex = Pullable<T>::_cache;
+        ex.v[1] = elem;
+        Pullable<T>::set(ex);
+      };
+      
+      void setZ(F1t elem) {
+        T ex = Pullable<T>::_cache;
+        ex.v[2] = elem;
+        Pullable<T>::set(ex);
+      };
     };
-  };
-
-  template<>
-  void Vector<F1t>::setY(float position) = delete;
-
-  template<>
-  void Vector<F1t>::setZ(float position) = delete;
-
-  template<>
-  void Vector<V2>::setZ(float position) = delete;
-
-}
-
+    
+    template<>
+    void Vector<F1t>::setY(float position) = delete;
+    
+    template<>
+    void Vector<F1t>::setZ(float position) = delete;
+    
+    template<>
+    void Vector<V2>::setZ(float position) = delete;
+    
+    }
+    
 #endif
\ No newline at end of file
diff --git a/blocks/leif/NodeKittenX/Node/Mesh.cpp b/blocks/leif/NodeKittenX/Node/Mesh.cpp
index 12640a7..a08a94e 100644
--- a/blocks/leif/NodeKittenX/Node/Mesh.cpp
+++ b/blocks/leif/NodeKittenX/Node/Mesh.cpp
@@ -554,23 +554,17 @@ void Mesh::customDraw(){
 void Mesh::setupViewMatrix() const {
   if (!GLState::activeShader()) return;
   
-  if (forceOrthographic()) {
-    GLState::activeShader()->uniformNamed(NKS_M16_MVP).bindM16(M16Multiply(scene()->orthographicMatrix(),
-                                                                        M16Multiply(M16MakeLookAt(V3(0, 0, 1), V3(0), V3(0, 1, 0)),
-                                                                                    M16ScaleWithV3(globalTransform.get(), size.get()))));
+  if(GLState::activeShader()->hasUniformNamed(NKS_M16_MV) ){
+    GLState::activeShader()->uniformNamed(NKS_M16_MV).bindM16(modelViewMatrix.get());
   }
-  else {
-    if(GLState::activeShader()->hasUniformNamed(NKS_M16_MV) ){
-      GLState::activeShader()->uniformNamed(NKS_M16_MV).bindM16(modelViewMatrix.get());
-    }
-    
-    if(GLState::activeShader()->hasUniformNamed(NKS_M9_NORMAL) ){
-      GLState::activeShader()->uniformNamed(NKS_M9_NORMAL).bindM9(M16GetInverseNormalMatrix(modelViewMatrix.get()));
-    }
-    
-    GLState::activeShader()->uniformNamed(NKS_M16_MVP).bindM16(modelViewProjectionMatrix.get());
+  
+  if(GLState::activeShader()->hasUniformNamed(NKS_M9_NORMAL) ){
+    GLState::activeShader()->uniformNamed(NKS_M9_NORMAL).bindM9(M16GetInverseNormalMatrix(modelViewMatrix.get()));
   }
   
+  GLState::activeShader()->uniformNamed(NKS_M16_MVP).bindM16(modelViewProjectionMatrix.get());
+  
+  
   nkGetGLError();
 }
 
diff --git a/blocks/leif/NodeKittenX/Node/Node.cpp b/blocks/leif/NodeKittenX/Node/Node.cpp
index c9fbf78..74d7103 100644
--- a/blocks/leif/NodeKittenX/Node/Node.cpp
+++ b/blocks/leif/NodeKittenX/Node/Node.cpp
@@ -40,14 +40,16 @@ Node::Node(Color color, V3t size_)
   globalTransform.afterSet([this]{
     modelViewMatrix.setDirty();
   });
-  modelViewMatrix.setPullFunction([this]{
-    return M16Multiply(scene()->camera->viewMatrix.get(),M16ScaleWithV3(globalTransform.get(), size.get()));
-  });
   modelViewMatrix.afterSet([this]{
     modelViewProjectionMatrix.setDirty();
   });
+  modelViewMatrix.setPullFunction([this]{
+    M16t v = forceOrthographic() ? M16MakeLookAt({0,0,1}, {0,0,0}, {0,1,0}) : scene()->camera->viewMatrix.get();
+    return M16Multiply(v,M16ScaleWithV3(globalTransform.get(), size.get()));
+  });
   modelViewProjectionMatrix.setPullFunction([this]{
-    return M16Multiply(scene()->camera->projectionMatrix.get(), modelViewMatrix.get());
+    M16t p = forceOrthographic() ? scene()->orthographicMatrix() : scene()->camera->projectionMatrix.get();
+    return M16Multiply(p, modelViewMatrix.get());
   });
 }
 
diff --git a/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaDeviceTools.mm b/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaDeviceTools.mm
index 17d3356..8958907 100644
--- a/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaDeviceTools.mm
+++ b/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaDeviceTools.mm
@@ -10,6 +10,8 @@
 
 #include "CocoaDeviceTools.h"
 
+using namespace std;
+
 string NSToCppString(NSString *s){
     
     return string([s cStringUsingEncoding:NSUTF8StringEncoding]);
diff --git a/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaViews.mm b/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaViews.mm
index 5707980..482ed50 100644
--- a/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaViews.mm
+++ b/blocks/leif/NodeKittenX/Platform/Cocoa/CocoaViews.mm
@@ -12,6 +12,8 @@
 #include "SceneController.h"
 #include "Node.h"
 
+using namespace std;
+
 bool isIpad(){
 #if TARGET_OS_IPHONE
     if ( UI_USER_INTERFACE_IDIOM() == UIUserInterfaceIdiomPad )
diff --git a/blocks/leif/NodeKittenX/Shader/ShaderProgram.cpp b/blocks/leif/NodeKittenX/Shader/ShaderProgram.cpp
index c52323a..ed4896a 100644
--- a/blocks/leif/NodeKittenX/Shader/ShaderProgram.cpp
+++ b/blocks/leif/NodeKittenX/Shader/ShaderProgram.cpp
@@ -50,8 +50,8 @@ namespace Shader {
   shared_ptr<Program> Program::fill = nullptr;
   shared_ptr<Program> Program::textureFill = nullptr;
 
-  map<string, shared_ptr<Program>> programCache;
-  map<UB4t, Node *> nodeMap;
+  map<string, shared_ptr<Program>> Program::programCache;
+  map<UB4t, Node *> Program::nodeMap;
 
   static GLubyte GLUBYTE_MAX = UCHAR_MAX;
 
diff --git a/blocks/leif/NodeKittenX/Shader/ShaderTools.h b/blocks/leif/NodeKittenX/Shader/ShaderTools.h
index 03dd0da..a1327f0 100644
--- a/blocks/leif/NodeKittenX/Shader/ShaderTools.h
+++ b/blocks/leif/NodeKittenX/Shader/ShaderTools.h
@@ -292,7 +292,7 @@ namespace Shader {
 
 #pragma mark - NKSHADER VARIABLE
 
-  class Shader;
+  class Program;
 
   class ShaderVariable {
 
@@ -306,7 +306,7 @@ namespace Shader {
     GLuint arraySize{0};
     GLuint glLocation{0};
 
-    Shader *program{nullptr};
+    Program *program{nullptr};
 
     ShaderVariable() { }
 
diff --git a/blocks/leif/NodeKittenX/Texture/FrameBuffer.h b/blocks/leif/NodeKittenX/Texture/FrameBuffer.h
index fc74c7f..a7d8c5e 100644
--- a/blocks/leif/NodeKittenX/Texture/FrameBuffer.h
+++ b/blocks/leif/NodeKittenX/Texture/FrameBuffer.h
@@ -16,61 +16,65 @@ class Texture;
 
 class FrameBuffer
 {
-
+  
+  bool _dirty;
+  
 public:
-    
-    static std::vector<FrameBuffer*> stack;
-    
-    // INIT
-    FrameBuffer(){} // DEFAULT FOR APPLE
-    FrameBuffer(GLuint width, GLuint height, bool allocate = true);
-    FrameBuffer(V2 size) : FrameBuffer(size.width, size.height){};
-    ~FrameBuffer();
-    
-    // IVARS
-    
-    GLuint glName {0};
-
-    std::shared_ptr<Texture> renderTexture;
-    std::shared_ptr<Texture> renderTexture2;
-    std::shared_ptr<Texture> depthTexture;
-
-    // METHODS
-    
-    
-    void bind();
-    
-    void addSecondRenderTexture();
-    void bindPing();
-    void bindPong();
-    
-    void clear(Color = CLEAR);
-
-    void unbind();
-    void unload();
-    
-    GLuint bindTexture(int glname);
-    
-    GLuint renderBuffer {0};
-    GLuint depthBuffer {0};
-    I1t width {0};
-    I1t height {0};
-    
-    bool dirty {true};
-
+  
+  static std::vector<FrameBuffer*> stack;
+  
+  // INIT
+  FrameBuffer(){} // DEFAULT FOR APPLE
+  FrameBuffer(GLuint width, GLuint height, bool allocate = true);
+  FrameBuffer(V2 size) : FrameBuffer(size.width, size.height){};
+  ~FrameBuffer();
+  
+  // IVARS
+  
+  GLuint glName {0};
+  
+  std::shared_ptr<Texture> renderTexture;
+  std::shared_ptr<Texture> renderTexture2;
+  std::shared_ptr<Texture> depthTexture;
+  
+  // METHODS
+  
+  
+  void bind();
+  
+  void addSecondRenderTexture();
+  void bindPing();
+  void bindPong();
+  
+  void clear(Color = CLEAR);
+  
+  void unbind();
+  void unload();
+  
+  GLuint bindTexture(int glname);
+  
+  GLuint renderBuffer {0};
+  GLuint depthBuffer {0};
+  I1t width {0};
+  I1t height {0};
+  
+  const bool dirty() const {return _dirty;}
+  void setDirty(bool dirty = true) {_dirty = dirty;}
+  
+  
 #pragma mark - DEBUG
-    
-    static unsigned int createdObjects;
-    static unsigned int destroyedObjects;
-    static unsigned int liveObjects(){return createdObjects - destroyedObjects;};
-    
+  
+  static unsigned int createdObjects;
+  static unsigned int destroyedObjects;
+  static unsigned int liveObjects(){return createdObjects - destroyedObjects;};
+  
 protected:
-
-    
-    void destroyFbo(int glname);
-    void deleteFboAttachment(GLenum attachment);
-
-    
+  
+  
+  void destroyFbo(int glname);
+  void deleteFboAttachment(GLenum attachment);
+  
+  
 };
 
 #endif
diff --git a/blocks/leif/NodeKittenX/Types/VectorTypes.h b/blocks/leif/NodeKittenX/Types/VectorTypes.h
index 2a7d498..ea7c0af 100644
--- a/blocks/leif/NodeKittenX/Types/VectorTypes.h
+++ b/blocks/leif/NodeKittenX/Types/VectorTypes.h
@@ -514,6 +514,7 @@ union _V4t
   
   struct { F1t r, g, b, a; };
   struct { F1t s, t, p, q; };
+  struct { F1t top, right, bottom, left;};
   struct { F1t m00, m01, m10, m11;};
   
   _V4t(const F1t r,const F1t g,const F1t b,const F1t a){
diff --git a/blocks/leif/NodeKittenX/View/ContainerView.h b/blocks/leif/NodeKittenX/View/ContainerView.h
index ce1602f..0cebf95 100644
--- a/blocks/leif/NodeKittenX/View/ContainerView.h
+++ b/blocks/leif/NodeKittenX/View/ContainerView.h
@@ -23,16 +23,16 @@ class ContainerView : public ScrollView {
   }
   
   ContainerView* addRow(V2 vunits){
-    return addLayout(vunits, LayoutRow);
+    return addLayout(vunits, Layout::Method::Row);
   }
 
   ContainerView* addColumn(V2 vunits){
-    return addLayout(vunits, LayoutColumn);
+    return addLayout(vunits, Layout::Method::Column);
   }
 
-  ContainerView* addLayout(V2 vunits, LayoutMethod l){
+  ContainerView* addLayout(V2 vunits, Layout::Method l){
     auto child = std::make_shared<ContainerView>(vunits);
-    child->setLayoutMethod(l);
+    child->layoutManager()->setLayoutMethod(l);
     return static_cast<ContainerView*>(addChild(child));
   }
   
diff --git a/blocks/leif/NodeKittenX/View/Label.cpp b/blocks/leif/NodeKittenX/View/Label.cpp
index d9825b8..daf9345 100644
--- a/blocks/leif/NodeKittenX/View/Label.cpp
+++ b/blocks/leif/NodeKittenX/View/Label.cpp
@@ -8,206 +8,214 @@
 
 #include "Label.h"
 #include "ShaderProgram.h"
+#include "Scene.h"
+#include "Camera.h"
 
 using namespace std;
 using namespace Shader;
 
-shared_ptr<Label> Label::labelWithFontNamed(string fontName, double fontSize, Color color, V3t size){
-    return make_shared<Label>(fontName, fontSize, color, size);
+shared_ptr<Label> Label::labelWithFontNamed(string fontName, double fontSize, Color color){
+  return make_shared<Label>(fontName, fontSize, color);
 }
 
-Label::Label(string fontName, double fontSize, Color color, V3t size) :
-Mesh(nullptr, color, size)
+Label::Label(string fontName, double fontSize, Color color) :
+Mesh(nullptr, color, V3{0})
 {
-    _fontSize = fontSize;
-    t_scale = (_fontSize * Platform::Screen::scale()) / _loadedSize;
-    _fontName = fontName;
-    _drawMode = GL_TRIANGLES;
-    setCullFace(GLCullFaceBack);
-    
-    auto exist = Texture::fontCache[fontName];
-    if (!exist){
-        Texture::fontCache[fontName] = make_shared<FontAtlas>(fontName, _loadedSize, 2048, 2048);
-    }
-    setTexture(Texture::fontCache[fontName]);
+  _fontSize = fontSize;
+  t_scale = (_fontSize * Platform::Screen::scale()) / _loadedSize;
+  _fontName = fontName;
+  _drawMode = GL_TRIANGLES;
+  setCullFace(GLCullFaceBack);
+  
+  auto exist = Texture::fontCache[fontName];
+  if (!exist){
+    Texture::fontCache[fontName] = make_shared<FontAtlas>(fontName, _loadedSize, 2048, 2048);
+  }
+  setTexture(Texture::fontCache[fontName]);
+  
+  modelViewMatrix.setPullFunction([this]{
+    M16t v = forceOrthographic() ? M16MakeLookAt({0,0,1}, {0,0,0}, {0,1,0}) : scene()->camera->viewMatrix.get();
+    return M16Multiply(v, globalTransform.get());
+  });
 }
 
 void Label::setTexture(shared_ptr<Texture> fontAtlas){
-    _fontAtlas = static_pointer_cast<FontAtlas>(fontAtlas);
-    Mesh::setTexture(_fontAtlas);
+  _fontAtlas = static_pointer_cast<FontAtlas>(fontAtlas);
+  Mesh::setTexture(_fontAtlas);
 }
 
 void Label::chooseShader() {
-    if (!shader) {
-        auto modules = vector<ShaderModule> {ShaderModule::colorModule(NKS_COLOR_MODE_UNIFORM, 0),ShaderModule::freetypeModule()};
-        shader = Program::shaderNamed("freeTypeShader", modules, 0);
-//       _shader = Shader::shaderNamed("uColorLightShader",NKS_COLOR_MODE_UNIFORM,0,1);
-    }
+  if (!shader) {
+    auto modules = vector<ShaderModule> {ShaderModule::colorModule(NKS_COLOR_MODE_UNIFORM, 0),ShaderModule::freetypeModule()};
+    shader = Program::shaderNamed("freeTypeShader", modules, 0);
+    //       _shader = Shader::shaderNamed("uColorLightShader",NKS_COLOR_MODE_UNIFORM,0,1);
+  }
 }
 
 V2t Label::sizeForText() {
+  
+  V2t pen;
+  V4t bbox;
+  
+  for(size_t i=0; i<_text.length(); ++i)
+  {
+    texture_glyph_t *glyph = texture_font_get_glyph( _fontAtlas->font, _text[i] );
     
-    V2t pen;
-    V4t bbox;
-    
-    for(size_t i=0; i<_text.length(); ++i)
+    if( glyph != NULL )
     {
-        texture_glyph_t *glyph = texture_font_get_glyph( _fontAtlas->font, _text[i] );
-        
-        if( glyph != NULL )
-        {
-            float kerning = 0.0f;
-            
-            if( i > 0)
-            {
-                kerning = texture_glyph_get_kerning( glyph, _text[i-1] );
-            }
-            
-            pen.x += kerning;
-            
-            float x0  = ( pen.x + glyph->offset_x );
-            float y0  = ( pen.y + glyph->offset_y );
-            float x1  = x0 + (glyph->width);
-            float y1  = y0 - (glyph->height);
-            
-            pen.x += glyph->advance_x;
-            
-            if  (x0 < bbox.x)                bbox.x = x0;
-            if  (y1 < bbox.y)                bbox.y = y1;
-            if ((x1 - bbox.x) > bbox.width)  bbox.width  = x1-bbox.x;
-            if ((y0 - bbox.y) > bbox.height) bbox.height = y0-bbox.y;
-        }
+      float kerning = 0.0f;
+      
+      if( i > 0)
+      {
+        kerning = texture_glyph_get_kerning( glyph, _text[i-1] );
+      }
+      
+      pen.x += kerning;
+      
+      float x0  = ( pen.x + glyph->offset_x );
+      float y0  = ( pen.y + glyph->offset_y );
+      float x1  = x0 + (glyph->width);
+      float y1  = y0 - (glyph->height);
+      
+      pen.x += glyph->advance_x;
+      
+      if  (x0 < bbox.x)                bbox.x = x0;
+      if  (y1 < bbox.y)                bbox.y = y1;
+      if ((x1 - bbox.x) > bbox.width)  bbox.width  = x1-bbox.x;
+      if ((y0 - bbox.y) > bbox.height) bbox.height = y0-bbox.y;
     }
-    
-    return bbox.size;
+  }
+  
+  return bbox.size;
 }
 
 void Label::genVertices() {
-    
-    auto tsize = sizeForText();
-
-    //nkLog("fontSize: %1.2f - text scale : %1.5f", _fontSize, t_scale);
-    
-    if (!_vertexBuffer) {
-        _vertexBuffer = make_shared<VertexBuffer>();
-    }
-    
-    _vertexBuffer->clear();
-    
-    bool clear_sub_pixel = false;
-    
-    V2t pen = {0,0};
-    
-    switch (_textAlignment) {
-        case NKTextAlignmentLeft:
-        default:
-            break;
-            
-        case NKTextAlignmentCenter:
-            pen.x = -tsize.width * .5;
-            break;
-            
-        case NKTextAlignmentRight:
-            pen.x = size.get().width - tsize.width;
-            break;
-    }
-    
-    for(size_t i=0; i<_text.length(); ++i)
+  
+  auto tsize = sizeForText();
+  
+  //nkLog("fontSize: %1.2f - text scale : %1.5f", _fontSize, t_scale);
+  
+  if (!_vertexBuffer) {
+    _vertexBuffer = make_shared<VertexBuffer>();
+  }
+  
+  _vertexBuffer->clear();
+  
+  bool clear_sub_pixel = false;
+  
+  V2t pen = {0,0};
+  
+  switch (_textAlignment) {
+    case NKTextAlignmentLeft:
+    default:
+      pen.x = size.get().width * -0.5f;
+      break;
+      
+    case NKTextAlignmentCenter:
+      pen.x = tsize.width * -0.5f;
+      break;
+      
+    case NKTextAlignmentRight:
+      pen.x = (size.get().width * 0.5f) - tsize.width;
+      break;
+  }
+  
+  for(size_t i=0; i<_text.length(); ++i)
+  {
+    texture_glyph_t *glyph = texture_font_get_glyph(_fontAtlas->font, _text[i] );
+    if( glyph != NULL )
     {
-        texture_glyph_t *glyph = texture_font_get_glyph(_fontAtlas->font, _text[i] );
-        if( glyph != NULL )
-        {
-            float kerning = 0.0f;
-            if( i > 0)
-            {
-                kerning = texture_glyph_get_kerning( glyph, _text[i-1] );
-            }
-            pen.x += kerning;
-            float x0  = ( pen.x + glyph->offset_x ) * t_scale;
-            float y0  = ( pen.y + glyph->offset_y ) * t_scale;
-            float x1  = x0 + (glyph->width * t_scale);
-            float y1  = y0 - (glyph->height * t_scale);
-            float s0 = glyph->s0;
-            float t0 = glyph->t0;
-            float s1 = glyph->s1;
-            float t1 = glyph->t1;
-            
-            if (clear_sub_pixel){
-                x0 = int (x0);
-                x1 = int (x1);
-                y0 = int (y0);
-                y1 = int (y1);
-            }
-            
-            U1t start = (U1t)_vertexBuffer->_vertices.size();
-            
-            _vertexBuffer->_vertices.push_back({ x0,y0,0});
-            _vertexBuffer->_vertices.push_back({ x0,y1,0});
-            _vertexBuffer->_vertices.push_back({ x1,y1,0});
-            _vertexBuffer->_vertices.push_back({ x1,y0,0});
-            
-            _vertexBuffer->_texCoords.push_back({s0,t0,0});
-            _vertexBuffer->_texCoords.push_back({s0,t1,0});
-            _vertexBuffer->_texCoords.push_back({s1,t1,0});
-            _vertexBuffer->_texCoords.push_back({s1,t0,0});
-            
-            _vertexBuffer->_normals.push_back({ 0,0,1});
-            _vertexBuffer->_normals.push_back({ 0,0,1});
-            _vertexBuffer->_normals.push_back({ 0,0,1});
-            _vertexBuffer->_normals.push_back({ 0,0,1});
-            
-            _vertexBuffer->_colors.push_back(glColor());
-            _vertexBuffer->_colors.push_back(glColor());
-            _vertexBuffer->_colors.push_back(glColor());
-            _vertexBuffer->_colors.push_back(glColor());
-            
-            vector<U1t> indices;
-
-            _vertexBuffer->_indices.push_back(start+0);
-            _vertexBuffer->_indices.push_back(start+1);
-            _vertexBuffer->_indices.push_back(start+2);
-            _vertexBuffer->_indices.push_back(start+0);
-            _vertexBuffer->_indices.push_back(start+2);
-            _vertexBuffer->_indices.push_back(start+3);
-            
-            pen.x += glyph->advance_x;
-        }
-    }
-    
-    if (_vertexBuffer->size() > 0){
-        _vertexBuffer->setupVAOInterlaceAndBufferVBO();
+      float kerning = 0.0f;
+      if( i > 0)
+      {
+        kerning = texture_glyph_get_kerning( glyph, _text[i-1] );
+      }
+      pen.x += kerning;
+      float x0  = ( pen.x + glyph->offset_x ) * t_scale;
+      float y0  = ( pen.y + glyph->offset_y ) * t_scale;
+      float x1  = x0 + (glyph->width * t_scale);
+      float y1  = y0 - (glyph->height * t_scale);
+      float s0 = glyph->s0;
+      float t0 = glyph->t0;
+      float s1 = glyph->s1;
+      float t1 = glyph->t1;
+      
+      if (clear_sub_pixel){
+        x0 = int (x0);
+        x1 = int (x1);
+        y0 = int (y0);
+        y1 = int (y1);
+      }
+      
+      U1t start = (U1t)_vertexBuffer->_vertices.size();
+      
+      _vertexBuffer->_vertices.push_back({ x0,y0,0});
+      _vertexBuffer->_vertices.push_back({ x0,y1,0});
+      _vertexBuffer->_vertices.push_back({ x1,y1,0});
+      _vertexBuffer->_vertices.push_back({ x1,y0,0});
+      
+      _vertexBuffer->_texCoords.push_back({s0,t0,0});
+      _vertexBuffer->_texCoords.push_back({s0,t1,0});
+      _vertexBuffer->_texCoords.push_back({s1,t1,0});
+      _vertexBuffer->_texCoords.push_back({s1,t0,0});
+      
+      _vertexBuffer->_normals.push_back({ 0,0,1});
+      _vertexBuffer->_normals.push_back({ 0,0,1});
+      _vertexBuffer->_normals.push_back({ 0,0,1});
+      _vertexBuffer->_normals.push_back({ 0,0,1});
+      
+      _vertexBuffer->_colors.push_back(glColor());
+      _vertexBuffer->_colors.push_back(glColor());
+      _vertexBuffer->_colors.push_back(glColor());
+      _vertexBuffer->_colors.push_back(glColor());
+      
+      vector<U1t> indices;
+      
+      _vertexBuffer->_indices.push_back(start+0);
+      _vertexBuffer->_indices.push_back(start+1);
+      _vertexBuffer->_indices.push_back(start+2);
+      _vertexBuffer->_indices.push_back(start+0);
+      _vertexBuffer->_indices.push_back(start+2);
+      _vertexBuffer->_indices.push_back(start+3);
+      
+      pen.x += glyph->advance_x;
     }
+  }
+  
+  if (_vertexBuffer->size() > 0){
+    _vertexBuffer->setupVAOInterlaceAndBufferVBO();
+  }
 }
 
 // --------------------------------------------------------------- add_text ---
 void Label::setText(string text)
 {
-    if (String::wstring2string(_text) == text) return;
-    auto wtext = String::string2wstring(text);
-    _text = wtext;
-    genVertices();
+  if (String::wstring2string(_text) == text) return;
+  auto wtext = String::string2wstring(text);
+  _text = wtext;
+  genVertices();
 }
 
 void Label::setText(wstring text)
 {
-    if (_text == text) return;
-    _text = text;
-    genVertices();
-    
+  if (_text == text) return;
+  _text = text;
+  genVertices();
+  
 }
 
 void Label::setFontSize(double size){
-    if (_fontSize == size) return;
-    _fontSize = size;
-    t_scale = (_fontSize * Platform::Screen::scale()) / _loadedSize;
+  if (_fontSize == size) return;
+  _fontSize = size;
+  t_scale = (_fontSize * Platform::Screen::scale()) / _loadedSize;
 }
 
 void Label::setTextAlignment(NKTextAlignment alignment){
-    if (_textAlignment == alignment) return;
-    _textAlignment = alignment;
-    genVertices();
+  if (_textAlignment == alignment) return;
+  _textAlignment = alignment;
+  genVertices();
 }
 
 void Label::genTexture() {
-    setTexture(make_shared<FontAtlas>(_fontName, _loadedSize, 2048, 2048));
+  setTexture(make_shared<FontAtlas>(_fontName, _loadedSize, 2048, 2048));
 }
\ No newline at end of file
diff --git a/blocks/leif/NodeKittenX/View/Label.h b/blocks/leif/NodeKittenX/View/Label.h
index 07ee393..449ab99 100644
--- a/blocks/leif/NodeKittenX/View/Label.h
+++ b/blocks/leif/NodeKittenX/View/Label.h
@@ -32,9 +32,9 @@ class Label : public Mesh
     std::string _fontName;
 public:
     
-    static std::shared_ptr<Label> labelWithFontNamed(std::string fontName, double fontSize = 12, Color color = WHITE, V3t size = V3{1});
+    static std::shared_ptr<Label> labelWithFontNamed(std::string fontName = "Roboto.ttf", double fontSize = 12, Color color = WHITE);
     
-    Label(std::string fontName, double fontSize = 12, Color color = Color(1.0), V3t size = V3(1.0));
+    Label(std::string fontName, double fontSize = 12, Color color = Color(1.0));
     
     void setText(std::string text);
     void setText(std::wstring text);
diff --git a/blocks/leif/NodeKittenX/View/Scene.cpp b/blocks/leif/NodeKittenX/View/Scene.cpp
index 21a81f6..f6da5cf 100644
--- a/blocks/leif/NodeKittenX/View/Scene.cpp
+++ b/blocks/leif/NodeKittenX/View/Scene.cpp
@@ -25,6 +25,7 @@ using namespace Shader;
 #if NK_LOG_METRICS
 unsigned int Scene::draws {0};
 unsigned int Scene::fps {0};
+unsigned int Scene::mspf {0};
 #endif
 
 //Scene* Scene::activeScene = nullptr;
@@ -93,26 +94,16 @@ Scene::Scene(S2t size) : View(size){
   
 }
 
-void Scene::afterTransform(){
-  View::afterTransform();
-  auto theSize = size.get();
-  camera->setAspectRatio(theSize.width / theSize.height);
-#if NK_LOG_METRICS
-  if (metrics){
-    metrics->size.set(V2(theSize.x*0.125f, theSize.y));
-    metrics->position.set(V2(theSize.x*0.4375f, 0));
-  }
-#endif
-}
-
 void Scene::logMetrics() {
 #if NK_LOG_METRICS
-  printf("fps %d : frametime: %1.3f nodes: %lu : textures: %lu : bBodies %lu : lights %lu", fps, (frameTime / frames), allChildren().size(), (unsigned long)666, (unsigned long)666, (unsigned long)lights.size());
+  nkLog("fps %d : frametime: %1.3f nodes: %lu : textures: %lu : bBodies %lu : lights %lu", fps, (frameTime / frames), allChildren().size(), (unsigned long)666, (unsigned long)666, (unsigned long)lights.size());
 #endif
 }
 
 void Scene::updateWithTimeSinceLast(F1t dt){
   
+  currentFrameTime = Time::getCurrentTime();
+  
   if (!loaded){
     loaded = true;
     moveToView();
@@ -140,79 +131,40 @@ void Scene::updateWithTimeSinceLast(F1t dt){
     _updateBlock(dt);
   }
   
-#if NK_LOG_METRICS
-  currentFrameTime = Time::getCurrentTime();
+  #if NK_LOG_METRICS
   
-  if (!metrics) {
-    auto wh = V2(size.get().x*.125, size.get().y*.5);
+  if (!overlay){
+    overlay = View::view();
+    overlay->setLayoutMethod(Layout::Method::Horizontal);
+    
+    overlay->addChild(View::view());
+    overlay->addChild(View::view());
+    overlay->addChild(View::view());
+    
+    metrics = View::view();
+    overlay->addChild(metrics);
     
-    metrics = CollectionView::viewWithSize(wh);
+    metrics->setLayoutMethod(Layout::Method::Vertical);
     metrics->setScene(this);
     metrics->setBackgroundColor({1.0,0.5});
     metrics->setForceOrthographic();
     metrics->setIgnoresLights();
-    auto fontSize = 16.0;
-    
-    auto label = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    label->setColor(BLACK);
-    label->setTextAlignment(NKTextAlignmentRight);
-    label->setForceOrthographic();
-    metrics->addChild(label);
-    
-    auto fbo = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    fbo->setColor(BLACK);
-    fbo->setTextAlignment(NKTextAlignmentRight);
-    fbo->setForceOrthographic();
-    metrics->addChild(fbo);
-    
-    auto events = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    events->setColor(BLACK);
-    events->setTextAlignment(NKTextAlignmentRight);
-    events->setForceOrthographic();
-    metrics->addChild(events);
     
-    auto actions = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    actions->setColor(BLACK);
-    actions->setTextAlignment(NKTextAlignmentRight);
-    actions->setForceOrthographic();
-    metrics->addChild(actions);
-    
-    auto dlabel = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    dlabel->setColor(BLACK);
-    dlabel->setTextAlignment(NKTextAlignmentRight);
-    dlabel->setForceOrthographic();
-    metrics->addChild(dlabel);
-    
-    auto fLabel = Label::labelWithFontNamed("Vera.ttf", fontSize);
-    fLabel->setColor(BLACK);
-    fLabel->setTextAlignment(NKTextAlignmentRight);
-    fLabel->setForceOrthographic();
-    metrics->addChild(fLabel);
-    
-    label->position.set(wh*V2t{.49,.4});
-    fbo->position.set(wh*V2t{.49,.3});
-    events->position.set(wh*V2t{.49,.2});
-    actions->position.set(wh*V2t{.49,.1});
-    dlabel->position.set(wh*V2t{.49,0});
-    fLabel->position.set(wh*V2t{.49,-.1});
-    
-    metrics->transform.afterSet([this, fLabel, dlabel, label, events, fbo, actions]{
-      auto wh = V2(size.get().x*.125, size.get().y*.25);
-      label->position.set(wh*V2t{.49,.4});
-      fbo->position.set(wh*V2t{.49,.3});
-      events->position.set(wh*V2t{.49,.2});
-      actions->position.set(wh*V2t{.49,.1});
-      dlabel->position.set(wh*V2t{.49,0});
-      fLabel->position.set(wh*V2t{.49,-.1});
-    });
+    for (int i = 0; i < 7; i++){
+      auto label = Label::labelWithFontNamed("Roboto.ttf", 24.0, BLACK);
+      label->setTextAlignment(NKTextAlignmentRight);
+      label->setForceOrthographic();
+      metrics->addChild(label);
+    }
     
-    metrics->setUpdateBlock([this, fLabel, dlabel, label, events, fbo, actions](float dt){
-      fLabel->setText(nksf("%d fps", fps));
-      dlabel->setText(nksf("%d draws", draws));
-      label->setText(nksf("%d nodes", Node::liveObjects()));
-      events->setText(nksf("%d events", UXEvent::liveObjects()));
-      fbo->setText(nksf("%d fbos", FrameBuffer::liveObjects()));
-      actions->setText(nksf("%d actions", Action::liveObjects()));
+    metrics->setUpdateBlock([this](float dt){
+      static_pointer_cast<Label>(metrics->children()[0])->setText(nksf("%d fps", fps));
+      static_pointer_cast<Label>(metrics->children()[1])->setText(nksf("%d ms", mspf));
+      static_pointer_cast<Label>(metrics->children()[2])->setText(nksf("%d draws", draws));
+      static_pointer_cast<Label>(metrics->children()[3])->setText(nksf("%d nodes", Node::liveObjects()));
+      static_pointer_cast<Label>(metrics->children()[4])->setText(nksf("%d events", UXEvent::liveObjects()));
+      static_pointer_cast<Label>(metrics->children()[5])->setText(nksf("%d fbos", FrameBuffer::liveObjects()));
+      static_pointer_cast<Label>(metrics->children()[6])->setText(nksf("%d actions", Action::liveObjects()));
     });
   }
   
@@ -220,11 +172,14 @@ void Scene::updateWithTimeSinceLast(F1t dt){
   
   timer += dt;
   if (timer > 1.0f) {
+    mspf = ((frameTime * 1000) / frames);
     fps = (int)frames;
     frames = 0;
     timer -= 1.0f;
+    frameTime = 0;
   }
   draws = 0;
+  
 #endif
 }
 
@@ -288,6 +243,8 @@ void Scene::draw() {
   Node::draw();
 #endif
   
+  
+  
 #if NK_LOG_METRICS
   if (metrics){
     metrics->draw();
@@ -303,10 +260,10 @@ void Scene::customDraw() {
       axes = Mesh::nodeWithPrimitive(NKPrimitiveAxes, nullptr, Color(1.0, 0,0,1.0), V3(100));
       axes->shader = Program::shaderNamed("vertexColor",NKS_COLOR_MODE_VERTEX,0,0,0);
     }
-    if (!_::contains(children(), axes)) {
-      nkLog("add axes to scene");
-      addChild(axes);
-    }
+//    if (!_::contains(children(), axes)) {
+//      nkLog("add axes to scene");
+//      addChild(axes);
+//    }
   }
   if (drawCamera) {
     //camera->draw();
@@ -415,57 +372,6 @@ void Scene::clear() {
   }
 }
 
-void Scene::alertDidSelectOption(int option) {
-  if (option == 0) {
-    alertDidCancel();
-  }
-  // OVERRIDE IN SUBCLASS FOR OTHER OPTIONS
-}
-
-void Scene::alertDidCancel() {
-  dismissAlertAnimated(true);
-}
-
-void Scene::presentAlert(NKAlertSprite* alert, bool animated) {
-#warning ALERT SPRITE
-  //    _alertSprite = alert;
-  //    alert.delegate = self;
-  //    [self addChild:alert];
-  //
-  //    if (animated) {
-  //
-  //        [_alertSprite setPosition2d:V2(0, -self.size.height)];
-  //        [_alertSprite runAction:[Action move2dTo:V2(0, 0) duration:.3]];
-  //    }
-}
-
-
-void Scene::dismissAlertAnimated(bool animated){
-#warning ALERT SPRITE
-  //    if (animated) {
-  //        [_alertSprite runAction:[Action move2dTo:V2(0, -self.size.height) duration:.3] completion:^{
-  //         [self removeChild:_alertSprite];
-  //         _alertSprite = nil;
-  //         }];
-  //    }
-  //    else {
-  //        [self removeChild:_alertSprite];
-  //        _alertSprite = nil;
-  //    }
-}
-
-void Scene::pushMultiplyMatrix(M16t matrix) {
-  stack.pushMultiply(matrix);
-}
-
-void Scene::pushScale(V3t scale) {
-  stack.pushScale(scale);
-}
-
-void Scene::pushStyle(){
-  
-}
-
 void Scene::bindLights() {
   GLState::activeShader()->uniformNamed(NKS_I1_NUM_LIGHTS).bindI1((int)lights.size());
   nkGetGLError();
@@ -476,35 +382,7 @@ void Scene::bindLights() {
     }
   }
 }
-//void Scene::keyDown(U1t key) {
-//
-//    printf("key down %d \n", key);
-//
-//    V3t p = _position;
-//
-//    switch (key) {
-//
-//        case 123:
-//            setPosition(V3(p.x-1, p.y, p.z));
-//            break;
-//        case 124:
-//
-//            setPosition(V3(p.x+1, p.y, p.z));
-//            break;
-//
-//        case 126: //up arrow
-//
-//            setPosition(V3(p.x, p.y, p.z+1)));
-//            break;
-//
-//        case 125: // down arrow
-//            setPosition(V3(p.x, p.y, p.z-1));
-//            break;
-//
-//        default:
-//            break;
-//    }
-//}
+
 
 void Scene::dispatchUXEvent(UXEvent& event) {
   //NSLog(@"dispatch event for location %f %f",location.x, location.y);
diff --git a/blocks/leif/NodeKittenX/View/Scene.h b/blocks/leif/NodeKittenX/View/Scene.h
index 99d7b63..6db47ce 100644
--- a/blocks/leif/NodeKittenX/View/Scene.h
+++ b/blocks/leif/NodeKittenX/View/Scene.h
@@ -51,7 +51,7 @@ typedef std::function<void(void)> HitCallback;
 class SceneController;
 class Camera;
 namespace Shader {
-  class Shader;
+  class Program;
 }
 class VertexBuffer;
 class NKAlertSprite;
@@ -80,6 +80,7 @@ class Scene : public View
 #if NK_LOG_METRICS
   static unsigned int draws;
   static unsigned int fps;
+  static unsigned int mspf;
 #endif
   
   bool loaded {false};
@@ -105,10 +106,12 @@ class Scene : public View
   //@property (nonatomic) void *view;
   
   Color borderColor;
-
+  
   std::shared_ptr<Camera> camera;
   std::shared_ptr<Mesh> axes;
-  std::shared_ptr<CollectionView> metrics;
+  
+  std::shared_ptr<View> overlay;
+  std::shared_ptr<View> metrics;
   
   M16Stack stack;
   // NKAlertSprite *alertSprite;
@@ -117,7 +120,7 @@ class Scene : public View
   bool drawLights {false};
   bool drawCamera {false};
   bool drawAxes {false};
-
+  
   std::vector<Light*> lights;
   
   // HIT DETECTION
@@ -129,7 +132,7 @@ class Scene : public View
   bool useColorDetection {false};
   std::shared_ptr<Shader::Program> hitDetectShader;
   std::unique_ptr<FrameBuffer> hitDetectBuffer;
-
+  
   std::queue<HitCallback> hitQueue;
   
   // PHYSICS HIT DETECTION
@@ -164,7 +167,7 @@ class Scene : public View
   // GEOMETRY
   M16t orthographicMatrix() {
     auto sz = size.get();
-    return M16MakeOrtho(-sz.width*.5f, sz.width*.5f, -sz.height*.5f, sz.height*.5f, -10000, 10000);
+    return M16MakeOrtho(-sz.width*.5f, sz.width*.5f, -sz.height*.5f, sz.height*.5f, 65535, -65535);
   }
   
   // EVENTS
@@ -175,12 +178,26 @@ class Scene : public View
   
   // NODE OVERRIDES
   
-  void afterTransform() override;
+  
+  void afterTransform() override {
+    View::afterTransform();
+    for (auto& child : children()){
+      child->afterTransform();
+    }
+    auto theSize = size.get();
+    camera->setAspectRatio(theSize.width / theSize.height);
+#if NK_LOG_METRICS
+    if (overlay){
+      overlay->size.set(size.get());
+    }
+#endif
+  }
+  
   void afterResize() override {
     afterTransform();
   }
   
-  void pushStyle() override;
+  void pushStyle() override {};
   void updateWithTimeSinceLast(F1t dt) override;
   
   void bindLights();
diff --git a/blocks/leif/NodeKittenX/View/View.cpp b/blocks/leif/NodeKittenX/View/View.cpp
index 72ee828..a2637f2 100644
--- a/blocks/leif/NodeKittenX/View/View.cpp
+++ b/blocks/leif/NodeKittenX/View/View.cpp
@@ -9,23 +9,32 @@
 #include "View.h"
 #include "ShaderProgram.h"
 #include "Mesh.h"
-
-void View::layoutSubviews() {
-}
+#include "Scene.h"
 
 #pragma mark - DRAW
 
+View::View(V2t size) : Node(V3t{size.x, size.y, 1}){
+  _anchorPoint = V2(.5);
+  
+  modelViewMatrix.setPullFunction([this]{
+    return M16Multiply(M16MakeLookAt({0,0,1}, {0,0,0}, {0,1,0}),M16ScaleWithV3(globalTransform.get(), this->size.get()));
+  });
+  modelViewProjectionMatrix.setPullFunction([this]{
+    return M16Multiply(scene()->orthographicMatrix(), modelViewMatrix.get());
+  });
+}
+
 void View::draw() {
   if (hidden()) return;
   
   if (_shouldRasterize){
-    if (framebuffer && !framebuffer->dirty) {
+    if (_framebuffer && !_framebuffer->dirty()) {
       drawFBO();
       return;
     }
   }
   
-  if (framebuffer) {
+  if (_framebuffer) {
     pushFramebuffer();
   }
   else {
@@ -38,17 +47,16 @@ void View::draw() {
   nkGetGLError();
   restoreGLStates();
   nkGetGLError();
-  layoutSubviews();
   drawChildren();
   
-  if (framebuffer) {
+  if (_framebuffer) {
     popFramebuffer();
     drawFBO();
   }
 }
 
 void View::drawFBO() const {
-  Mesh::fillRect(scene(), getGlobalFrame(), WHITE, framebuffer->renderTexture);
+  Mesh::fillRect(scene(), getGlobalFrame(), WHITE, _framebuffer->renderTexture);
 }
 
 R4t View::getGlobalFrame() const {
diff --git a/blocks/leif/NodeKittenX/View/View.h b/blocks/leif/NodeKittenX/View/View.h
index ace1edd..1bf096a 100644
--- a/blocks/leif/NodeKittenX/View/View.h
+++ b/blocks/leif/NodeKittenX/View/View.h
@@ -12,11 +12,14 @@
 #include "Texture.h"
 #include "Node.h"
 
-class View : public Layout<Node> {
+class View :
+public Node {
   
   bool _shouldRasterize {false};
   V2t _anchorPoint;
   Color _backgroundColor;
+  std::unique_ptr<Layout::Manager<View>> _layoutManager;
+  std::unique_ptr<FrameBuffer> _framebuffer;
 
 public:
   // Convenience Constructors
@@ -25,38 +28,61 @@ class View : public Layout<Node> {
     return ret;
   }
   
-  View(V2t size) : Layout(V3t{size.x, size.y, 1}){
-    _anchorPoint = V2(.5);
+  static std::shared_ptr<View> view(){
+    std::shared_ptr<View> ret (new View(V2{1,1}));
+    return ret;
   }
+  
+  View(V2t size);
   ~View(){};
   
   // Public Properties
-  std::unique_ptr<FrameBuffer> framebuffer;
+  const std::unique_ptr<Layout::Manager<View>>& layoutManager() const {return _layoutManager;}
+  
+  Layout::Manager<View>* setLayoutMethod(Layout::Method layoutMethod) {
+    if (!_layoutManager){
+      _layoutManager.reset(new Layout::Manager<View>());
+    }
+    return _layoutManager->setLayoutMethod(layoutMethod);
+  }
+  
+  const std::unique_ptr<FrameBuffer>& framebuffer() const {return _framebuffer;}
+  void setFramebuffer(std::unique_ptr<FrameBuffer> framebuffer) {_framebuffer = std::move(framebuffer);}
   
 #pragma mark - Layout
   
-  void afterTransform() override{
-    Node::afterTransform();
-    if (framebuffer) {
-      framebuffer.reset();
-      framebuffer = std::make_unique<FrameBuffer>(size.get().xy);
+  void afterTransform() override {
+    globalTransform.setDirty();
+    modelViewMatrix.setDirty();
+    modelViewProjectionMatrix.setDirty();
+    
+    if (_framebuffer) {
+      _framebuffer.reset(new FrameBuffer(size.get().xy));
+    }
+    if (_layoutManager){
+      Node* rec = this;
+      while (rec->parent()){
+        printf("- ");
+        rec = rec->parent();
+      }
+      printf("layout %p \n", this);
+      _layoutManager->layout(this);
     }
   }
   
   void afterChildrenChanged() override{
-    if (framebuffer) {
-      framebuffer->dirty = true;
+    if (_framebuffer) {
+      _framebuffer->setDirty();
     }
   }
   
   void draw() override;
   void drawFBO() const;
-  virtual void layoutSubviews();
   
   bool containsPoint(P2t location) const;
   
 #pragma mark - SETTERS / GETTERS
-
+  
   View* setBackgroundColor(Color backgroundColor){
     _backgroundColor = backgroundColor;
     return this;
@@ -64,14 +90,14 @@ class View : public Layout<Node> {
   Color backgroundColor(){
     return _backgroundColor;
   }
-
+  
   View* setShouldRasterize(bool rasterize){
     _shouldRasterize = rasterize;
     
-    if (_shouldRasterize && !framebuffer){
-      framebuffer = std::make_unique<FrameBuffer>(size.get().xy);
+    if (_shouldRasterize && !_framebuffer){
+      _framebuffer.reset(new FrameBuffer(size.get().xy));
     }
-
+    
     return this;
   }
   
@@ -84,20 +110,20 @@ class View : public Layout<Node> {
 #pragma mark - FRAMEBUFFER
   
   void pushFramebuffer() {
-    framebuffer->bind();
+    _framebuffer->bind();
     if (_backgroundColor.visible()){
-      framebuffer->clear(_backgroundColor);
+      _framebuffer->clear(_backgroundColor);
     }
     else {
-      framebuffer->clear();
+      _framebuffer->clear();
     }
   }
   
   void popFramebuffer() {
-      if (_shouldRasterize) {
-        framebuffer->dirty = false;
-      }
-      framebuffer->unbind();
+    if (_shouldRasterize) {
+      _framebuffer->setDirty(false);
+    }
+    _framebuffer->unbind();
   }
   
 #pragma mark - ANCHOR METHODS
@@ -114,7 +140,7 @@ class View : public Layout<Node> {
   V2t anchorPoint(){
     return _anchorPoint;
   }
-
+  
 };
 
 #endif /* defined(__Pods__SceneController__) */
\ No newline at end of file