diff --git a/doc/samples/meshviewer/scenesetup.cpp b/doc/samples/meshviewer/scenesetup.cpp
index 74e942dd..a86ff561 100644
--- a/doc/samples/meshviewer/scenesetup.cpp
+++ b/doc/samples/meshviewer/scenesetup.cpp
@@ -159,86 +159,76 @@ SceneSetupLuaObject::~SceneSetupLuaObject()
 //-----------------------------------------------------------------------------
 SceneSetupLuaObject* SceneSetupLuaObject::New(lua_State* l, int arg_nb)
 {
-    UNUSED(l);
     UNUSED(arg_nb);
-    LuaStack s(l);
-    LuaString n;
-    s >> n;
-    return new SceneSetupLuaObject(n());
+    auto s = LuaStack::Begin(l);
+    auto n = s.Get<String>();
+    return new SceneSetupLuaObject(n);
 }
 
 //-- Setup command ------------------------------------------------------------
 int SceneSetupLuaObject::AddLight(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaString t;
-    s >> o >> t;
-    o->m_setup->AddLight(FindValue<LightType>(t().C()));
-    return 0;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto t = s.Get<String>();
+    o->m_setup->AddLight(FindValue<LightType>(t.C()));
+    return s.End();
 }
 int SceneSetupLuaObject::SetupScene(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    s >> o;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
     o->m_setup->SetupScene();
-    return 0;
+    return s.End();
 }
 //-- main funcs ---------------------------------------------------------------
 int SceneSetupLuaObject::SetPosition(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaVec3 c;
-    s >> o >> c;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto c = s.Get<vec3>();
     o->m_setup->SetPosition(c);
-    return 0;
+    return s.End();
 }
 int SceneSetupLuaObject::SetLookAt(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaVec3 c;
-    s >> o >> c;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto c = s.Get<vec3>();
     o->m_setup->SetLookAt(c);
-    return 0;
+    return s.End();
 }
 int SceneSetupLuaObject::SetColor(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaColor c;
-    s >> o >> c;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto c = s.Get<vec4>();
     o->m_setup->SetColor(c);
-    return 0;
+    return s.End();
 }
 int SceneSetupLuaObject::Show(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaDisplay e;
-    s >> o >> e;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto e = s.GetEnum<SceneSetup::DisplayBase>();
     o->m_setup->Show(e);
-    return 0;
+    return s.End();
 }
 int SceneSetupLuaObject::Hide(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaDisplay e;
-    s >> o >> e;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto e = s.GetEnum<SceneSetup::DisplayBase>();
     o->m_setup->Hide(e);
-    return 0;
+    return s.End();
 }
 int SceneSetupLuaObject::Toggle(lua_State* l)
 {
-    LuaStack s(l);
-    LuaSSetupPtr o;
-    LuaDisplay e;
-    s >> o >> e;
+    auto s = LuaStack::Begin(l);
+    auto o = s.GetPtr<SceneSetupLuaObject>();
+    auto e = s.GetEnum<SceneSetup::DisplayBase>();
     o->m_setup->Toggle(e);
-    return 0;
+    return s.End();
 }
 
 //-----------------------------------------------------------------------------
@@ -264,7 +254,7 @@ const LuaObjectLibrary* SceneSetupLuaObject::GetLib()
         },
         //Variables
         { { nullptr, nullptr, nullptr } });
-            return &lib;
+    return &lib;
 }
 
 //-----------------------------------------------------------------------------
diff --git a/doc/samples/meshviewer/scenesetup.h b/doc/samples/meshviewer/scenesetup.h
index 39165715..23694a7b 100644
--- a/doc/samples/meshviewer/scenesetup.h
+++ b/doc/samples/meshviewer/scenesetup.h
@@ -103,12 +103,10 @@ public:
     bool                        m_show_gizmo;
     bool                        m_show_lights;
 };
-typedef Lolua::VarEnum<SceneSetup::DisplayBase> LuaDisplay;
 
 //-----------------------------------------------------------------------------
 class SceneSetupLuaObject : public LuaObject
 {
-    typedef Lolua::VarPtr<SceneSetupLuaObject> LuaSSetupPtr;
 public:
     //-------------------------------------------------------------------------
     SceneSetupLuaObject(String& name);
diff --git a/doc/tutorial/14_lol_lua.cpp b/doc/tutorial/14_lol_lua.cpp
index de5b5cd0..ce0348ab 100644
--- a/doc/tutorial/14_lol_lua.cpp
+++ b/doc/tutorial/14_lol_lua.cpp
@@ -23,7 +23,6 @@ using namespace lol;
 //-----------------------------------------------------------------------------
 class DemoObject : public LuaObject
 {
-    typedef Lolua::VarPtr<DemoObject> LuaDemoObjectPtr;
 public:
     DemoObject() : LuaObject() {}
     virtual ~DemoObject() {}
diff --git a/src/easymesh/easymeshlua.cpp b/src/easymesh/easymeshlua.cpp
index a68c6a7e..a36ab4d8 100644
--- a/src/easymesh/easymeshlua.cpp
+++ b/src/easymesh/easymeshlua.cpp
@@ -81,10 +81,9 @@ EasyMeshLuaObject* EasyMeshLuaObject::New(lua_State* l, int arg_nb)
 {
     UNUSED(l);
     UNUSED(arg_nb);
-    LuaStack s(l);
-    LuaString n("", true);
-    s >> n;
-    return new EasyMeshLuaObject(n());
+    LuaStack s = LuaStack::Begin(l);
+    String str = s.Get("", true);
+    return new EasyMeshLuaObject(str);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/src/easymesh/easymeshlua.h b/src/easymesh/easymeshlua.h
index 35e76140..5fb32ea8 100644
--- a/src/easymesh/easymeshlua.h
+++ b/src/easymesh/easymeshlua.h
@@ -18,7 +18,6 @@ namespace lol
 //-----------------------------------------------------------------------------
 class EasyMeshLuaObject : public LuaObject
 {
-    typedef Lolua::VarPtr<EasyMeshLuaObject> EzMeshPtr;
     EasyMesh m_instance;
 public:
     //-------------------------------------------------------------------------
@@ -33,604 +32,583 @@ public:
     //-------------------------------------------------------------------------
     static int AppendCylinder(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 nsides;
-        LuaFloat h, d1, d2;
-        LuaBool dualside(false, true), smooth(false, true), close(false, true);
-        s >> m >> nsides >> h >> d1 >> d2 >> dualside >> smooth >> close;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto nsides = s.Get<int32_t>();
+        auto h = s.Get<float>();
+        auto d1 = s.Get<float>();
+        auto d2 = s.Get<float>();
+        auto dualside = s.Get<bool>(false, true);
+        auto smooth = s.Get<bool>(false, true);
+        auto close = s.Get<bool>(false, true);
         m->m_instance.AppendCylinder(nsides, h, d1, d2, dualside, smooth, close);
-        return 0;
+        return s.End();
     }
     static int AppendSphere(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 ndivisions;
-        LuaFloat d;
-        s >> m >> ndivisions >> d;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto ndivisions = s.Get<int32_t>();
+        auto d = s.Get<float>();
         m->m_instance.AppendSphere(ndivisions, d);
-        return 0;
+        return s.End();
     }
     static int AppendCapsule(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 ndivisions;
-        LuaFloat h, d;
-        s >> m >> ndivisions >> h >> d;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto ndivisions = s.Get<int32_t>();
+        auto h = s.Get<float>();
+        auto d = s.Get<float>();
         m->m_instance.AppendCapsule(ndivisions, h, d);
-        return 0;
+        return s.End();
     }
     static int AppendTorus(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 ndivisions;
-        LuaFloat d1, d2;
-        s >> m >> ndivisions >> d1 >> d2;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto ndivisions = s.Get<int32_t>();
+        auto d1 = s.Get<float>();
+        auto d2 = s.Get<float>();
         m->m_instance.AppendTorus(ndivisions, d1, d2);
-        return 0;
+        return s.End();
     }
     static int AppendBox(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaVec3 size;
-        LuaFloat chamf(0.f, true);
-        LuaBool smooth(false, true);
-        s >> m >> size >> chamf >> smooth;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto size = s.Get<vec3>();
+        auto chamf = s.Get<float>(0.f, true);
+        auto smooth = s.Get<bool>(false, true);
         m->m_instance.AppendBox(size, chamf, smooth);
-        return 0;
+        return s.End();
     }
     static int AppendStar(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 nbranches;
-        LuaFloat d1, d2;
-        LuaBool fade(false, true), fade2(false, true);
-        s >> m >> nbranches >> d1 >> d2 >> fade >> fade2;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto nbranches = s.Get<int32_t>();
+        auto d1 = s.Get<float>();
+        auto d2 = s.Get<float>();
+        auto fade = s.Get<bool>(false, true);
+        auto fade2 = s.Get<bool>(false, true);
         m->m_instance.AppendStar(nbranches, d1, d2, fade, fade2);
-        return 0;
+        return s.End();
     }
     static int AppendExpandedStar(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 nbranches;
-        LuaFloat d1, d2, extrad(0.f, true);
-        s >> m >> nbranches >> d1 >> d2 >> extrad;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto nbranches = s.Get<int32_t>();
+        auto d1 = s.Get<float>();
+        auto d2 = s.Get<float>();
+        auto extrad = s.Get<float>(0.f, true);
         m->m_instance.AppendExpandedStar(nbranches, d1, d2, extrad);
-        return 0;
+        return s.End();
     }
     static int AppendDisc(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 nsides;
-        LuaFloat d;
-        LuaBool fade(false, true);
-        s >> m >> nsides >> d >> fade;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto nsides = s.Get<int32_t>();
+        auto d = s.Get<float>();
+        auto fade = s.Get<bool>(false, true);
         m->m_instance.AppendDisc(nsides, d, fade);
-        return 0;
+        return s.End();
     }
     static int AppendSimpleTriangle(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat d;
-        LuaBool fade(false, true);
-        s >> m >> d >> fade;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto d = s.Get<float>();
+        auto fade = s.Get<bool>(false, true);
         m->m_instance.AppendSimpleTriangle(d, fade);
-        return 0;
+        return s.End();
     }
     static int AppendSimpleQuad(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat size;
-        LuaBool fade(false, true);
-        s >> m >> size >> fade;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto size = s.Get<float>();
+        auto fade = s.Get<bool>(false, true);
         m->m_instance.AppendSimpleQuad(size, fade);
-        return 0;
+        return s.End();
     }
     static int AppendCog(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 nbsides;
-        LuaFloat h, sidemul(0.f, true);
-        LuaVec2 d0, d1, d2;
-        LuaBool offset(false, true);
-        s >> m >> nbsides >> h >> d0 >> d1 >> d2 >> sidemul >> offset;
-        m->m_instance.AppendCog(nbsides, h, d0().x, d0().y, d1().x, d1().y, d2().x, d2().y, sidemul, offset);
-        return 0;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto nbsides = s.Get<int32_t>();
+        auto h = s.Get<float>();
+        auto sidemul = s.Get<float>(0.f, true);
+        auto d0 = s.Get<vec2>();
+        auto d1 = s.Get<vec2>();
+        auto d2 = s.Get<vec2>();
+        auto offset = s.Get<bool>(false, true);
+        m->m_instance.AppendCog(nbsides, h, d0.x, d0.y, d1.x, d1.y, d2.x, d2.y, sidemul, offset);
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int TranslateX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat f;
-        s >> m >> f;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto f = s.Get<float>();
         m->m_instance.TranslateX(f);
-        return 0;
+        return s.End();
     }
     static int TranslateY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat f;
-        s >> m >> f;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto f = s.Get<float>();
         m->m_instance.TranslateY(f);
-        return 0;
+        return s.End();
     }
     static int TranslateZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat f;
-        s >> m >> f;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto f = s.Get<float>();
         m->m_instance.TranslateZ(f);
-        return 0;
+        return s.End();
     }
     static int Translate(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaVec3 v;
-        s >> m >> v;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto v = s.Get<vec3>();
         m->m_instance.Translate(v);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int RotateX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat a;
-        s >> m >> a;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto a = s.Get<float>();
         m->m_instance.RotateX(a);
-        return 0;
+        return s.End();
     }
     static int RotateY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat a;
-        s >> m >> a;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto a = s.Get<float>();
         m->m_instance.RotateY(a);
-        return 0;
+        return s.End();
     }
     static int RotateZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat a;
-        s >> m >> a;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto a = s.Get<float>();
         m->m_instance.RotateZ(a);
-        return 0;
+        return s.End();
     }
     static int Rotate(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat a;
-        LuaVec3 v;
-        s >> m >> a >> v;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto a = s.Get<float>();
+        auto v = s.Get<vec3>();
         m->m_instance.Rotate(a, v);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int ScaleX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x;
-        s >> m >> x;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
         m->m_instance.ScaleX(x);
-        return 0;
+        return s.End();
     }
     static int ScaleY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat y;
-        s >> m >> y;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto y = s.Get<float>();
         m->m_instance.ScaleY(y);
-        return 0;
+        return s.End();
     }
     static int ScaleZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat z;
-        s >> m >> z;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto z = s.Get<float>();
         m->m_instance.ScaleZ(z);
-        return 0;
+        return s.End();
     }
     static int Scale(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaVec3 v;
-        s >> m >> v;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto v = s.Get<vec3>();
         m->m_instance.Scale(v);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int RadialJitter(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat f;
-        s >> m >> f;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto f = s.Get<float>();
         m->m_instance.RadialJitter(f);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int TaperX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat y, z, xoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> y >> z >> xoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto y = s.Get<float>();
+        auto z = s.Get<float>();
+        auto xoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.TaperX(y, z, xoff, abs);
-        return 0;
+        return s.End();
     }
     static int TaperY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, z, yoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> x >> z >> yoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto z = s.Get<float>();
+        auto yoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.TaperY(x, z, yoff, abs);
-        return 0;
+        return s.End();
     }
     static int TaperZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, y, zoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> x >> y >> zoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto y = s.Get<float>();
+        auto zoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.TaperZ(x, y, zoff, abs);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int TwistX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.TwistX(t, toff);
-        return 0;
+        return s.End();
     }
     static int TwistY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.TwistY(t, toff);
-        return 0;
+        return s.End();
     }
     static int TwistZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.TwistZ(t, toff);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int ShearX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat y, z, xoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> y >> z >> xoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto y = s.Get<float>();
+        auto z = s.Get<float>();
+        auto xoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.ShearX(y, z, xoff, abs);
-        return 0;
+        return s.End();
     }
     static int ShearY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, z, yoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> x >> z >> yoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto z = s.Get<float>();
+        auto yoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.ShearY(x, z, yoff, abs);
-        return 0;
+        return s.End();
     }
     static int ShearZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, y, zoff(0.f, true);
-        LuaBool abs(true, true);
-        s >> m >> x >> y >> zoff >> abs;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto y = s.Get<float>();
+        auto zoff = s.Get<float>(0.f, true);
+        auto abs = s.Get<bool>(true, true);
         m->m_instance.ShearZ(x, y, zoff, abs);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int StretchX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat y, z, xoff(0.f, true);
-        s >> m >> y >> z >> xoff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto y = s.Get<float>();
+        auto z = s.Get<float>();
+        auto xoff = s.Get<float>(0.f, true);
         m->m_instance.StretchX(y, z, xoff);
-        return 0;
+        return s.End();
     }
     static int StretchY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, z, yoff(0.f, true);
-        s >> m >> x >> z >> yoff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto z = s.Get<float>();
+        auto yoff = s.Get<float>(0.f, true);
         m->m_instance.StretchY(x, z, yoff);
-        return 0;
+        return s.End();
     }
     static int StretchZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat x, y, zoff(0.f, true);
-        s >> m >> x >> y >> zoff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto x = s.Get<float>();
+        auto y = s.Get<float>();
+        auto zoff = s.Get<float>(0.f, true);
         m->m_instance.StretchZ(x, y, zoff);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int BendXY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendXY(t, toff);
-        return 0;
+        return s.End();
     }
     static int BendXZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendXZ(t, toff);
-        return 0;
+        return s.End();
     }
     static int BendYX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendYX(t, toff);
-        return 0;
+        return s.End();
     }
     static int BendYZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendYZ(t, toff);
-        return 0;
+        return s.End();
     }
     static int BendZX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendZX(t, toff);
-        return 0;
+        return s.End();
     }
     static int BendZY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat t, toff(0.f, true);
-        s >> m >> t >> toff;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto t = s.Get<float>();
+        auto toff = s.Get<float>(0.f, true);
         m->m_instance.BendZY(t, toff);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int MirrorX(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.MirrorX();
-        return 0;
+        return s.End();
     }
     static int MirrorY(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.MirrorY();
-        return 0;
+        return s.End();
     }
     static int MirrorZ(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.MirrorZ();
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int LoopStart(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 loopnb;
-        s >> m >> loopnb;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto loopnb = s.Get<int32_t>();
         m->m_instance.LoopStart(loopnb);
-        return 0;
+        return s.End();
     }
     static int LoopEnd(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.LoopEnd();
-        return 0;
+        return s.End();
     }
     static int OpenBrace(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.OpenBrace();
-        return 0;
+        return s.End();
     }
     static int CloseBrace(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.CloseBrace();
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int ToggleScaleWinding(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.ToggleScaleWinding();
-        return 0;
+        return s.End();
     }
     static int ToggleQuadWeighting(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.ToggleQuadWeighting();
-        return 0;
+        return s.End();
     }
     static int TogglePostBuildNormal(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.TogglePostBuildNormal();
-        return 0;
+        return s.End();
     }
     static int ToggleVerticeNoCleanup(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.ToggleVerticeNoCleanup();
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int VerticesMerge(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.VerticesMerge();
-        return 0;
+        return s.End();
     }
     static int VerticesSeparate(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.VerticesSeparate();
-        return 0;
+        return s.End();
     }
     static int VerticesCleanup(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        s >> m;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
         m->m_instance.VerticesCleanup();
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int Duplicate(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaVec3 ds(vec3(1.f));
-        s >> m >> ds;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto ds = s.Get<vec3>(vec3(1.f));
         m->m_instance.DupAndScale(ds, true);
-        return 0;
+        return s.End();
     }
     static int Smooth(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 pass, split_per_pass, smooth_per_pass;
-        s >> m >> pass >> split_per_pass >> smooth_per_pass;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto pass = s.Get<int32_t>();
+        auto split_per_pass = s.Get<int32_t>();
+        auto smooth_per_pass = s.Get<int32_t>();
         m->m_instance.SmoothMesh(pass, split_per_pass, smooth_per_pass);
-        return 0;
+        return s.End();
     }
     static int SplitTriangles(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaInt32 pass;
-        s >> m >> pass;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto pass = s.Get<int32_t>();
         m->m_instance.SplitTriangles(pass);
-        return 0;
+        return s.End();
     }
     static int Chamfer(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaFloat f;
-        s >> m >> f;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto f = s.Get<float>();
         m->m_instance.Chamfer(f);
-        return 0;
+        return s.End();
     }
     //-------------------------------------------------------------------------
     static int SetCurColor(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaColor c;
-        s >> m >> c;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto c = s.Get<vec4>();
         m->m_instance.SetCurColor(c);
-        return 0;
+        return s.End();
     }
     static int SetCurColorA(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaColor c;
-        s >> m >> c;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto c = s.Get<vec4>();
         m->m_instance.SetCurColorA(c);
-        return 0;
+        return s.End();
     }
     static int SetCurColorB(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaColor c;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto c = s.Get<vec4>();
         m->m_instance.SetCurColorB(c);
-        return 0;
+        return s.End();
     }
     static int SetVertColor(lua_State* l)
     {
-        LuaStack s(l);
-        EzMeshPtr m;
-        LuaColor c;
-        s >> m >> c;
+        auto s = LuaStack::Begin(l);
+        auto m = s.GetPtr<EasyMeshLuaObject>();
+        auto c = s.Get<vec4>();
         m->m_instance.SetVertColor(c);
-        return 0;
+        return s.End();
     }
     /*
     (csgu|csgunion)          { return token::T_CSGUNION; }
diff --git a/src/lolua/baselua.cpp b/src/lolua/baselua.cpp
index 8a1c035d..faffef0f 100644
--- a/src/lolua/baselua.cpp
+++ b/src/lolua/baselua.cpp
@@ -40,8 +40,9 @@ class LuaBaseData
         int status = luaL_dostring(l, s.C());
         if (status == 1)
         {
-            LuaString error; error.Get(l, -1);
-            msg::error("Lua error %s\n", error().C());
+            auto stack = LuaStack::Begin(l, -1);
+            auto error = stack.Get<String>();
+            msg::error("Lua error %s\n", error.C());
             lua_pop(l, 1);
         }
         return status;
@@ -53,8 +54,8 @@ class LuaBaseData
         if (lua_isnoneornil(l, 1))
             return LUA_ERRFILE;
 
-        LuaCharPtr var; var.Get(l, 1);
-        char const *filename = var;// lua_tostring(l, 1);
+        auto stack = LuaStack::Begin(l);
+        char const *filename = stack.Get<char const*>();
         int status = LUA_ERRFILE;
 
         File f;
@@ -76,8 +77,9 @@ class LuaBaseData
             msg::error("could not find Lua file %s\n", filename);
         else if (status == 1)
         {
-            LuaString error; error.Get(l, -1);
-            msg::error("Lua error %s\n", error().C());
+            stack.SetIndex(-1);
+            auto error = stack.Get<String>();
+            msg::error("Lua error %s\n", error.C());
             lua_pop(l, 1);
         }
 
diff --git a/src/lolua/baselua.h b/src/lolua/baselua.h
index 035a641b..c4316558 100644
--- a/src/lolua/baselua.h
+++ b/src/lolua/baselua.h
@@ -16,9 +16,6 @@
 
 #pragma once
 
-#define OLD_VAR_SYSTEM true
-#define NEW_VAR_SYSTEM true
-
 namespace lol
 {
 
@@ -134,20 +131,19 @@ public:
             { "New", New<TLuaClass> },
             { "Store", Store<TLuaClass> },
             { "__gc", Del<TLuaClass> },
+            { "__tostring", ToString<TLuaClass> },
+            { "__add", OpAdd<TLuaClass> },
+            { "__sub", OpSubstract<TLuaClass> },
+            { "__mul", OpMultiply<TLuaClass> },
+            { "__div", OpDivide<TLuaClass> },
+            { "__mod", OpModulo<TLuaClass> },
+            { "__unm", OpUnaryNeg<TLuaClass> },
+            { "__concat", OpConcat<TLuaClass> },
+            { "__eq", CmpEqual<TLuaClass> },
+            { "__lt", CmpLessThan<TLuaClass> },
+            { "__le", CmpLessEqual<TLuaClass> },
             { NULL, NULL }
         };
-        //TODO: Touky: Implement that
-        //__tostring : ToString
-        //__add : Addition(+)
-        //__sub : Subtraction(-)
-        //__mul : Multiplication(*)
-        //__div : Division(/ )
-        //__mod : Modulos(%)
-        //__unm : Unary - , used for negation on numbers
-        //__concat : Concatenation(..)
-        //__eq : Equality(== )
-        //__lt : Less than(<)
-        //__le : Less than or equal to(<= )
 
         //Create Static metatable
         luaL_newmetatable(l, GetStaticName<TLuaClass>());
@@ -235,6 +231,18 @@ protected:
     //-------------------------------------------------------------------------
     template <typename TLuaClass> static int Store(lua_State * l);
     template <typename TLuaClass> static int Del(lua_State * l);
+    //-------------------------------------------------------------------------
+    template <typename TLuaClass> static int ToString(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpAdd(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpSubstract(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpMultiply(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpDivide(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpModulo(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpUnaryNeg(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int OpConcat(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int CmpEqual(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int CmpLessThan(lua_State* l) { ASSERT(false); return 0; }
+    template <typename TLuaClass> static int CmpLessEqual(lua_State* l) { ASSERT(false); return 0; }
 };
 
 //-----------------------------------------------------------------------------
@@ -248,683 +256,47 @@ public:
     }
 };
 
-//-----------------------------------------------------------------------------
-#if OLD_VAR_SYSTEM
-
-//-----------------------------------------------------------------------------
-template<typename T>
-class VarPtr
-{
-protected:
-    T* m_value = nullptr;
-    bool m_optional = false;
-
-public:
-    VarPtr(bool optional = false)
-    {
-        m_optional = optional;
-    }
-    VarPtr(T* value, bool optional = false)
-        : VarPtr(optional)
-    {
-        m_value = value;
-    }
-    VarPtr(lua_State* l, int& index, bool optional = false)
-        : VarPtr(optional)
-    {
-        GetInc(l, index);
-    }
-    VarPtr(T* value, lua_State* l, int& index, bool optional = false)
-        : VarPtr(value, optional)
-    {
-        GetInc(l, index);
-    }
-
-    inline T* operator ()()       { return m_value; }
-    inline T* operator ->()       { return m_value; }
-    inline T* operator=(T* value) { m_value = value; }
-    inline T* GetValue()          { return m_value; }
-    inline bool IsValid(lua_State* l, int index)
-    {
-        return InnerIsValid(l, index);
-    }
-    inline bool IsOptional()
-    {
-        return m_optional;
-    }
-private:
-    inline void GetInc(lua_State* l, int& index)
-    {
-        bool is_nil = lua_isnil(l, index);
-        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
-        {
-            ASSERT(!is_nil);
-            InnerGet(l, index);
-        }
-    }
-public:
-    inline void Get(lua_State* l, int index)
-    {
-        int idx = index;
-        GetInc(l, idx);
-    }
-    inline int Return(lua_State* l)
-    {
-        InnerPush(l);
-        return 1;
-    }
-
-protected:
-    virtual bool InnerIsValid(lua_State* l, int index)
-    {
-        return !!lua_isuserdata(l, index);
-    }
-    virtual void InnerGet(lua_State* l, int& index)
-    {
-        T** obj = static_cast<T**>(luaL_checkudata(l, index++, ObjectHelper::GetMethodName<T>()));
-        m_value = obj ? *obj : nullptr;
-    }
-    void InnerPush(lua_State* l)
-    {
-        T** data = (T**)lua_newuserdata(l, sizeof(T*));
-        *data = m_value;
-    }
-};
-
-//-----------------------------------------------------------------------------
-/* TODO: FIX THAT TOUKY !!
-template<typename T>
-class VarPtrLight
-{
-public:
-    VarPtrLight(bool optional = false) : VarPtr(optional) { }
-    VarPtrLight(T* value, bool optional = false) : VarPtr(value, optional) { }
-    VarPtrLight(lua_State* l, int& index, bool optional = false) : VarPtr(l, index, optional) { }
-    VarPtrLight(T* value, lua_State* l, int& index, bool optional = false) : VarPtr(value, l, index, optional) { }
-protected:
-    virtual void InnerGet(lua_State* l, int& index)
-    {
-        T** obj = static_cast<T**>(luaL_testudata(l, index++, ObjectDef::GetMethodName<T>()));
-        m_value = obj ? *obj : nullptr;
-    }
-};
-*/
-
-//-----------------------------------------------------------------------------
-template<typename T>
-class Var
-{
-protected:
-    bool m_optional = false;
-    T m_value;
-
-public:
-    Var(bool optional = false)
-    {
-        m_optional = optional;
-        InnerInit();
-    }
-    Var(T value, bool optional = false)
-    {
-        m_optional = optional;
-        m_value = value;
-    }
-    Var(lua_State* l, int& index, bool optional = false)
-    {
-        m_optional = optional;
-        GetInc(l, index);
-    }
-    Var(T value, lua_State* l, int& index, bool optional = false)
-    {
-        m_optional = optional;
-        m_value = value;
-        GetInc(l, index);
-    }
-    inline operator T()     { return m_value; }
-    inline T& operator ()() { return m_value; }
-    inline T& GetValue()    { return m_value; }
-    inline bool IsValid(lua_State* l, int index)
-    {
-        return InnerIsValid(l, index);
-    }
-    inline bool IsOptional()
-    {
-        return m_optional;
-    }
-private:
-    void GetInc(lua_State* l, int& index)
-    {
-        bool is_nil = lua_isnil(l, index);
-        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
-        {
-            ASSERT(!is_nil);
-            InnerGet(l, index);
-        }
-    }
-public:
-    inline void Get(lua_State* l, int index)
-    {
-        int idx = index;
-        GetInc(l, idx);
-    }
-    inline int Return(lua_State* l)
-    {
-        return InnerPush(l);
-    }
-    inline Var<T>&  operator-(const T& value)  { m_value - value; return *this; }
-    inline Var<T>&  operator+(const T& value)  { m_value + value; return *this; }
-    inline Var<T>&  operator*(const T& value)  { m_value  * value; return *this; }
-    inline Var<T>&  operator/(const T& value)  { m_value / value; return *this; }
-    inline Var<T>&  operator=(const T& value)  { m_value = value; return *this; }
-    inline Var<T>& operator-=(const T& value)  { m_value -= value; return *this; }
-    inline Var<T>& operator+=(const T& value)  { m_value += value; return *this; }
-    inline Var<T>& operator*=(const T& value)  { m_value *= value; return *this; }
-    inline Var<T>& operator/=(const T& value)  { m_value /= value; return *this; }
-    inline Var<T>&  operator-(const Var<T>& o) { m_value - o.m_value; return *this; }
-    inline Var<T>&  operator+(const Var<T>& o) { m_value + o.m_value; return *this; }
-    inline Var<T>&  operator*(const Var<T>& o) { m_value  * o.m_value; return *this; }
-    inline Var<T>&  operator/(const Var<T>& o) { m_value / o.m_value; return *this; }
-    inline Var<T>&  operator=(const Var<T>& o) { m_value = o.m_value; return *this; }
-    inline Var<T>& operator-=(const Var<T>& o) { m_value -= o.m_value; return *this; }
-    inline Var<T>& operator+=(const Var<T>& o) { m_value += o.m_value; return *this; }
-    inline Var<T>& operator*=(const Var<T>& o) { m_value *= o.m_value; return *this; }
-    inline Var<T>& operator/=(const Var<T>& o) { m_value /= o.m_value; return *this; }
-    inline bool operator==(const T& value)     { return m_value == value; }
-    inline bool operator!=(const T& value)     { return m_value != value; }
-    inline bool operator==(const Var<T>& o)    { return m_value == o.m_value; }
-    inline bool operator!=(const Var<T>& o)    { return m_value != o.m_value; }
-
-protected:
-    void InnerInit()                          { m_value = T(0); }
-    bool InnerIsValid(lua_State* l, int index) { UNUSED(l); UNUSED(index); ASSERT(false); return false; }
-    void InnerGet(lua_State* l, int& index)    { UNUSED(l); UNUSED(index); ASSERT(false); }
-    int InnerPush(lua_State* l)                { UNUSED(l); ASSERT(false); return 0; }
-};
-
-//-----------------------------------------------------------------------------
-#ifndef BASE_TYPES
-template<> inline bool Var<bool>::InnerIsValid(lua_State* l, int index)
-{
-    return lua_isboolean(l, index);
-}
-template<> inline void Var<bool>::InnerGet(lua_State* l, int& index)
-{
-    m_value = !!lua_toboolean(l, index++);
-}
-template<> inline int Var<bool>::InnerPush(lua_State* l)
-{
-    lua_pushboolean(l, m_value);
-    return 1;
-}
-//-----------------------------------------------------------------------------
-template<> inline bool Var<char const*>::InnerIsValid(lua_State* l, int index)
-{
-    return !!lua_isstring(l, index);
-}
-template<> inline void Var<char const*>::InnerGet(lua_State* l, int& index)
-{
-    m_value = lua_tostring(l, index++);
-}
-template<> inline int Var<char const*>::InnerPush(lua_State* l)
-{
-    lua_pushstring(l, m_value);
-    return 1;
-}
-//-----------------------------------------------------------------------------
-template<> inline void Var<String>::InnerInit()
-{
-    m_value = String();
-}
-template<> inline bool Var<String>::InnerIsValid(lua_State* l, int index)
-{
-    Var<char const*> v;
-    return v.IsValid(l, index);
-}
-template<> inline void Var<String>::InnerGet(lua_State* l, int& index)
-{
-    Var<char const*> v(l, index);
-    m_value = v();
-}
-template<> inline int Var<String>::InnerPush(lua_State* l)
-{
-    Var<char const*> v;
-    v = m_value.C();
-    return v.Return(l);
-}
-//-----------------------------------------------------------------------------
-template<> inline bool Var<double>::InnerIsValid(lua_State* l, int index)
-{
-    return !!lua_isnumber(l, index);
-}
-template<> inline void Var<double>::InnerGet(lua_State* l, int& index)
-{
-    m_value = lua_tonumber(l, index++);
-}
-template<> inline int Var<double>::InnerPush(lua_State* l)
-{
-    lua_pushnumber(l, m_value);
-    return 1;
-}
-//-----------------------------------------------------------------------------
-template<> inline bool Var<float>::InnerIsValid(lua_State* l, int index)
-{
-    Var<double> v;
-    return v.IsValid(l, index);
-}
-template<> inline void Var<float>::InnerGet(lua_State* l, int& index)
-{
-    Var<double> v(l, index);
-    m_value = (float)v();
-}
-template<> inline int Var<float>::InnerPush(lua_State* l)
-{
-    Var<double> v = (double)m_value;
-    return v.Return(l);
-}
-
-#if 0
-//-----------------------------------------------------------------------------
-template<> inline bool Var<int64_t>::InnerIsValid(lua_State* l, int index)
-{
-    return !!lua_isnumber(l, index);
-}
-template<> inline void Var<int64_t>::InnerGet(lua_State* l, int& index)
-{
-    m_value = lua_tointeger(l, index++);
-}
-template<> inline int Var<int64_t>::InnerPush(lua_State* l)
-{
-    lua_pushinteger(l, m_value);
-    return 1;
-}
-#endif
-
-//-----------------------------------------------------------------------------
-template<> inline bool Var<int32_t>::InnerIsValid(lua_State* l, int index)
-{
-    Var<int64_t> v;
-    return v.IsValid(l, index);
-}
-template<> inline void Var<int32_t>::InnerGet(lua_State* l, int& index)
-{
-    Var<int64_t> v(l, index);
-    m_value = (int32_t)v();
-}
-template<> inline int Var<int32_t>::InnerPush(lua_State* l)
-{
-    Var<int64_t> v = (int64_t)m_value;
-    return v.Return(l);
-}
-
-//-----------------------------------------------------------------------------
-template<> inline bool Var<uint32_t>::InnerIsValid(lua_State* l, int index)
-{
-    return !!lua_isnumber(l, index);
-}
-template<> inline void Var<uint32_t>::InnerGet(lua_State* l, int& index)
-{
-    m_value = (uint32_t)(lua_Unsigned)lua_tointeger(l, index++);
-}
-template<> inline int Var<uint32_t>::InnerPush(lua_State* l)
-{
-    lua_pushinteger(l, (lua_Integer)m_value);
-    return 1;
-}
-
-#if 0
-//-----------------------------------------------------------------------------
-template<> inline bool Var<uint64_t>::InnerIsValid(lua_State* l, int index)
-{
-    Var<uint32_t> v;
-    return v.IsValid(l, index);
-}
-template<> inline void Var<uint64_t>::InnerGet(lua_State* l, int& index)
-{
-    Var<uint32_t> v(l, index);
-    m_value = (uint64_t)v();
-}
-template<> inline int Var<uint64_t>::InnerPush(lua_State* l)
-{
-    Var<uint32_t> v = (uint32_t)m_value;
-    return v.Return(l);
-}
-#endif
-
-//-----------------------------------------------------------------------------
-template<> inline bool Var<vec2>::InnerIsValid(lua_State* l, int index)
-{
-    Var<float> x;
-    return x.IsValid(l, index);
-}
-template<> inline void Var<vec2>::InnerGet(lua_State* l, int& index)
-{
-    Var<float> x(l, index);
-    Var<float> y(x(), l, index, true);
-    m_value = vec2(x, y);
-}
-template<> inline int Var<vec2>::InnerPush(lua_State* l)
-{
-    Var<float> x = m_value.x;
-    Var<float> y = m_value.y;
-    return (x.Return(l) + y.Return(l));
-}
-//-----------------------------------------------------------------------------
-template<> inline bool Var<vec3>::InnerIsValid(lua_State* l, int index)
-{
-    Var<float> x;
-    return x.IsValid(l, index);
-}
-template<> inline void Var<vec3>::InnerGet(lua_State* l, int& index)
-{
-    Var<float> x(l, index);
-    Var<float> y(x(), l, index, true);
-    Var<float> z(x(), l, index, true);
-    m_value = vec3(x, y, z);
-}
-template<> inline int Var<vec3>::InnerPush(lua_State* l)
-{
-    Var<float> x = m_value.x;
-    Var<float> y = m_value.y;
-    Var<float> z = m_value.z;
-    return (x.Return(l) + y.Return(l) + z.Return(l));
-}
-//-----------------------------------------------------------------------------
-template<> inline bool Var<vec4>::InnerIsValid(lua_State* l, int index)
-{
-    Var<float> x;
-    return x.IsValid(l, index);
-}
-template<> inline void Var<vec4>::InnerGet(lua_State* l, int& index)
-{
-    Var<float> x(l, index);
-    Var<float> y(x(), l, index, true);
-    Var<float> z(x(), l, index, true);
-    Var<float> w(x(), l, index, true);
-    m_value = vec4(x, y, z, w);
-}
-template<> inline int Var<vec4>::InnerPush(lua_State* l)
-{
-    Var<float> x = m_value.x;
-    Var<float> y = m_value.y;
-    Var<float> z = m_value.z;
-    Var<float> w = m_value.w;
-    return (x.Return(l) + y.Return(l) + z.Return(l) + w.Return(l));
-}
-#endif //BASE_TYPES
-
-//-----------------------------------------------------------------------------
-#ifndef CUSTOM_TYPES
-class VarColor
-{
-protected:
-    Var<vec4> m_value;
-
-public:
-    VarColor(bool optional = false)
-    {
-        m_value = Var<vec4>(optional);
-        InnerInit();
-    }
-    VarColor(vec4 value, bool optional = false)
-    {
-        m_value = Var<vec4>(value, optional);
-    }
-    VarColor(lua_State* l, int& index, bool optional = false)
-        : VarColor(optional)
-    {
-        GetInc(l, index);
-    }
-    VarColor(vec4 value, lua_State* l, int& index, bool optional = false)
-        : VarColor(value, optional)
-    {
-        GetInc(l, index);
-    }
-
-    inline operator vec4()     { return m_value; }
-    inline vec4& operator ()() { return m_value(); }
-    inline vec4& GetValue()    { return m_value.GetValue(); }
-    inline bool IsValid(lua_State* l, int index)
-    {
-        return InnerIsValid(l, index);
-    }
-    inline bool IsOptional()
-    {
-        return m_value.IsOptional();
-    }
-private:
-    void GetInc(lua_State* l, int& index)
-    {
-        bool is_nil = lua_isnil(l, index);
-        if (!m_value.IsOptional() || (!is_nil && InnerIsValid(l, index)))
-        {
-            ASSERT(!is_nil);
-            InnerGet(l, index);
-        }
-    }
-public:
-    inline void Get(lua_State* l, int index)
-    {
-        int idx = index;
-        GetInc(l, idx);
-    }
-    inline int Return(lua_State* l)
-    {
-        return InnerPush(l);
-    }
-    inline VarColor&  operator-(const vec4& value)  { m_value - value; return *this; }
-    inline VarColor&  operator+(const vec4& value)  { m_value + value; return *this; }
-    inline VarColor&  operator*(const vec4& value)  { m_value  * value; return *this; }
-    inline VarColor&  operator/(const vec4& value)  { m_value / value; return *this; }
-    inline VarColor&  operator=(const vec4& value)  { m_value = value; return *this; }
-    inline VarColor& operator-=(const vec4& value)  { m_value -= value; return *this; }
-    inline VarColor& operator+=(const vec4& value)  { m_value += value; return *this; }
-    inline VarColor& operator*=(const vec4& value)  { m_value *= value; return *this; }
-    inline VarColor& operator/=(const vec4& value)  { m_value /= value; return *this; }
-    inline VarColor&  operator-(const Var<vec4>& o) { m_value - o; return *this; }
-    inline VarColor&  operator+(const Var<vec4>& o) { m_value + o; return *this; }
-    inline VarColor&  operator*(const Var<vec4>& o) { m_value  * o; return *this; }
-    inline VarColor&  operator/(const Var<vec4>& o) { m_value / o; return *this; }
-    inline VarColor&  operator=(const Var<vec4>& o) { m_value = o; return *this; }
-    inline VarColor& operator-=(const Var<vec4>& o) { m_value -= o; return *this; }
-    inline VarColor& operator+=(const Var<vec4>& o) { m_value += o; return *this; }
-    inline VarColor& operator*=(const Var<vec4>& o) { m_value *= o; return *this; }
-    inline VarColor& operator/=(const Var<vec4>& o) { m_value /= o; return *this; }
-    inline bool operator==(const vec4& value)     { return m_value == value; }
-    inline bool operator!=(const vec4& value)     { return m_value != value; }
-    inline bool operator==(const Var<vec4>& o)    { return m_value == o; }
-    inline bool operator!=(const Var<vec4>& o)    { return m_value != o; }
-    inline VarColor&  operator-(const VarColor& v)  { m_value -  v.m_value; return *this; }
-    inline VarColor&  operator+(const VarColor& v)  { m_value +  v.m_value; return *this; }
-    inline VarColor&  operator*(const VarColor& v)  { m_value  * v.m_value; return *this; }
-    inline VarColor&  operator/(const VarColor& v)  { m_value /  v.m_value; return *this; }
-    inline VarColor&  operator=(const VarColor& v)  { m_value =  v.m_value; return *this; }
-    inline VarColor& operator-=(const VarColor& v)  { m_value -= v.m_value; return *this; }
-    inline VarColor& operator+=(const VarColor& v)  { m_value += v.m_value; return *this; }
-    inline VarColor& operator*=(const VarColor& v)  { m_value *= v.m_value; return *this; }
-    inline VarColor& operator/=(const VarColor& v)  { m_value /= v.m_value; return *this; }
-    inline bool operator==(const VarColor& v)     { return m_value == v.m_value; }
-    inline bool operator!=(const VarColor& v)     { return m_value != v.m_value; }
-
-protected:
-    void InnerInit()
-    {
-        m_value = vec4::zero;
-    }
-    bool InnerIsValid(lua_State* l, int index)
-    {
-        Var<String> s;
-        return m_value.IsValid(l, index) || s.IsValid(l, index);
-    }
-    void InnerGet(lua_State* l, int& index)
-    {
-        //Try vec4 first
-        if (m_value.IsValid(l, index))
-        {
-            m_value.Get(l, index);
-        }
-        else
-        {
-            Var<String> c(l, index);
-            *this = Color::C8BppHexString(c);
-        }
-    }
-    int InnerPush(lua_State* l)
-    {
-        Var<String> c = Color::HexString8Bpp(m_value);
-        return c.Return(l);
-    }
-};
-
-//-----------------------------------------------------------------------------
-template<typename E>
-class VarEnum
-{
-protected:
-    SafeEnum<E> m_value;
-    bool m_optional = false;
-
-public:
-    VarEnum(bool optional = false)
-    {
-        m_optional = optional;
-        InnerInit();
-    }
-    VarEnum(SafeEnum<E> value, bool optional = false)
-        : VarEnum(optional)
-    {
-        m_value = value;
-    }
-    VarEnum(lua_State* l, int& index, bool optional = false)
-        : VarEnum(optional)
-    {
-        GetInc(l, index);
-    }
-    VarEnum(SafeEnum<E> value, lua_State* l, int& index, bool optional = false)
-        : VarEnum(value, optional)
-    {
-        GetInc(l, index);
-    }
-
-    inline operator SafeEnum<E>()     { return m_value; }
-    inline SafeEnum<E>& operator ()() { return m_value; }
-    inline SafeEnum<E>& GetValue()    { return m_value; }
-    inline bool IsValid(lua_State* l, int index)
-    {
-        return InnerIsValid(l, index);
-    }
-    inline bool IsOptional()
-    {
-        return m_optional;
-    }
-private:
-    void GetInc(lua_State* l, int& index)
-    {
-        bool is_nil = lua_isnil(l, index);
-        if (!m_optional || (!is_nil && InnerIsValid(l, index)))
-        {
-            ASSERT(!is_nil);
-            InnerGet(l, index);
-        }
-    }
-public:
-    inline void Get(lua_State* l, int index)
-    {
-        int idx = index;
-        GetInc(l, idx);
-    }
-    inline int Return(lua_State* l)
-    {
-        return InnerPush(l);
-    }
-    inline VarEnum<E>&  operator-(const SafeEnum<E>& value)  { m_value - value; return *this; }
-    inline VarEnum<E>&  operator+(const SafeEnum<E>& value)  { m_value + value; return *this; }
-    inline VarEnum<E>&  operator*(const SafeEnum<E>& value)  { m_value  * value; return *this; }
-    inline VarEnum<E>&  operator/(const SafeEnum<E>& value)  { m_value / value; return *this; }
-    inline VarEnum<E>&  operator=(const SafeEnum<E>& value)  { m_value = value; return *this; }
-    inline VarEnum<E>& operator-=(const SafeEnum<E>& value)  { m_value -= value; return *this; }
-    inline VarEnum<E>& operator+=(const SafeEnum<E>& value)  { m_value += value; return *this; }
-    inline VarEnum<E>& operator*=(const SafeEnum<E>& value)  { m_value *= value; return *this; }
-    inline VarEnum<E>& operator/=(const SafeEnum<E>& value)  { m_value /= value; return *this; }
-    inline bool operator==(const SafeEnum<E>& value)     { return m_value == value; }
-    inline bool operator!=(const SafeEnum<E>& value)     { return m_value != value; }
-    inline VarEnum<E>&  operator-(const VarEnum<E>& v)  { m_value - v.m_value; return *this; }
-    inline VarEnum<E>&  operator+(const VarEnum<E>& v)  { m_value + v.m_value; return *this; }
-    inline VarEnum<E>&  operator*(const VarEnum<E>& v)  { m_value  * v.m_value; return *this; }
-    inline VarEnum<E>&  operator/(const VarEnum<E>& v)  { m_value / v.m_value; return *this; }
-    inline VarEnum<E>&  operator=(const VarEnum<E>& v)  { m_value = v.m_value; return *this; }
-    inline VarEnum<E>& operator-=(const VarEnum<E>& v)  { m_value -= v.m_value; return *this; }
-    inline VarEnum<E>& operator+=(const VarEnum<E>& v)  { m_value += v.m_value; return *this; }
-    inline VarEnum<E>& operator*=(const VarEnum<E>& v)  { m_value *= v.m_value; return *this; }
-    inline VarEnum<E>& operator/=(const VarEnum<E>& v)  { m_value /= v.m_value; return *this; }
-    inline bool operator==(const VarEnum<E>& v)     { return m_value == v.m_value; }
-    inline bool operator!=(const VarEnum<E>& v)     { return m_value != v.m_value; }
-
-protected:
-    void InnerInit()
-    {
-        m_value = SafeEnum<E>(0);
-    }
-    bool InnerIsValid(lua_State* l, int index)
-    {
-        Var<String> s;
-        return s.IsValid(l, index);
-    }
-    void InnerGet(lua_State* l, int& index)
-    {
-        Var<String> c(l, index);
-        *this = FindValue<SafeEnum<E> >(c);
-    }
-    int InnerPush(lua_State* l)
-    {
-        Var<String> s = this->GetValue().ToString();
-        return s.Return(l);
-    }
-};
-#endif //CUSTOM_TYPES
-
-#endif //OLD_VAR_SYSTEM
-
 //-----------------------------------------------------------------------------
 // Stack: Main class that encapsulates everything -----------------------------
 //-----------------------------------------------------------------------------
 class Stack
 {
-public:
-
-#if NEW_VAR_SYSTEM
-
     //-------------------------------------------------------------------------
+public:
     static Stack Begin(lua_State* state, int32_t start_index = 1)
     {
         return Stack(state, start_index);
     }
 
+    //-------------------------------------------------------------------------
+    void SetIndex(int32_t index)
+    {
+        m_index = index;
+    }
+
     //-------------------------------------------------------------------------
     int32_t End()
     {
         return m_result;
     }
 
-#if !OLD_VAR_SYSTEM
+    //-------------------------------------------------------------------------
 protected:
-#endif //!OLD_VAR_SYSTEM
-
-#endif //NEW_VAR_SYSTEM
-    
     Stack(lua_State* l, int32_t start_index = 1)
     {
         m_state = l;
         m_index = start_index;
     }
+
+public:
     virtual ~Stack() { }
 
+protected:
     int32_t GetArgs()
     {
         return lua_gettop(m_state);
     }
 
-#if NEW_VAR_SYSTEM
-
 public:
     //-------------------------------------------------------------------------
     //The encapsulating struct for pointers
@@ -945,6 +317,7 @@ public:
         }
         Ptr(const T*& value) { m_value = value; }
         inline operator T*() { return m_value; }
+        inline T* operator ->() { return m_value; }
         inline Ptr<T>& operator=(T const*& value) { m_value = value; return *this; }
     };
 
@@ -985,13 +358,6 @@ protected:
     template<typename T> T InnerGet(T value) { UNUSED(value); ASSERT(false, INNER_ERROR); return InnerDefault<T>(); }
     template<typename T> int InnerPush(T value) { UNUSED(value); ASSERT(false, INNER_ERROR); return 0; }
 
-#ifndef INNER_T_T
-    //template<typename T, template <typename> class C> C<T> InnerDefault() { return C<E>(); }
-    //template<typename E> bool InnerIsValid() { return InnerIsValid<String>(); }
-    //template<typename E> SafeEnum<E> InnerGet(SafeEnum<E> value) { return FindValue<SafeEnum<E> >(InnerGet<char const*>(value.ToString().C())); }
-    //template<typename E> int InnerPush(SafeEnum<E> value) { return InnerPush<char const*>(value.ToString.C()); }
-#endif //STACK_STRING
-
 #ifndef INNER_SAFE_ENUM
     template<typename E> SafeEnum<E> InnerDefaultSafeEnum() { return SafeEnum<E>(); }
     template<typename E> bool InnerIsValidSafeEnum() { return InnerIsValid<String>(); }
@@ -1016,35 +382,7 @@ protected:
     }
 #endif //STACK_STRING
 
-#endif //NEW_VAR_SYSTEM
-
-	//-------------------------------------------------------------------------
-#if OLD_VAR_SYSTEM
-public:
-    inline operator int32_t() { return m_result; }
-    //-------------------------------------------------------------------------
-
-    template<typename T>
-    Stack& operator>>(T& var)
-    {
-        var = T(var.GetValue(), m_state, m_index, var.IsOptional());
-        return *this;
-    }
-
-#if !NEW_VAR_SYSTEM
-
     //-------------------------------------------------------------------------
-    template<typename T>
-    Stack& operator<<(T& var)
-    {
-        m_result += var.Return(m_state);
-        return *this;
-    }
-
-#endif //NEW_VAR_SYSTEM
-
-#endif //OLD_VAR_SYSTEM
-
 private:
     lua_State*  m_state = nullptr;
     int32_t m_index = 1;
@@ -1052,22 +390,8 @@ private:
 };
 
 //-----------------------------------------------------------------------------
-#if NEW_VAR_SYSTEM
-
 #ifndef REGION_STACK_VAR
 
-//#if OLD_VAR_SYSTEM && NEW_VAR_SYSTEM
-//
-////-------------------------------------------------------------------------
-//template<typename T, typename V>
-//Stack& Stack::operator<<(Var<T>& var)
-//{
-//    m_result += var.Return(m_state);
-//    return *this;
-//}
-//
-//#endif //OLD_VAR_SYSTEM && NEW_VAR_SYSTEM
-
 #ifndef STACK_BOOL
 template<> inline bool Stack::InnerIsValid<bool>()       { return lua_isboolean(m_state, m_index); }
 template<> inline bool Stack::InnerGet<bool>(bool value) { UNUSED(value); return !!lua_toboolean(m_state, m_index++); }
@@ -1104,7 +428,6 @@ template<> inline int Stack::InnerPush<float>(float value)  { return InnerPush<d
 #endif //STACK_FLOAT
 
 //-----------------------------------------------------------------------------
-//DO NOT REMOVE: IT IS THE BASIS FOR INT 32
 #ifndef STACK_INT64
 template<> inline bool Stack::InnerIsValid<int64_t>()             { return !!lua_isnumber(m_state, m_index); }
 template<> inline int64_t Stack::InnerGet<int64_t>(int64_t value) { UNUSED(value); return lua_tointeger(m_state, m_index++); }
@@ -1153,36 +476,8 @@ template<> inline vec4 Stack::InnerGet<vec4>(vec4 value) { return vec4(InnerGet<
 template<> inline int Stack::InnerPush<vec4>(vec4 value) { return (InnerPush<float>(value.x) + InnerPush<float>(value.y) + InnerPush<float>(value.z) + InnerPush<float>(value.w)); }
 #endif STACK_VEC4
 
-//-----------------------------------------------------------------------------
-#ifndef STACK_SAFE_ENUM
-//template<typename E> inline SafeEnum<E> Stack::InnerDefault<SafeEnum, E>()              { return SafeEnum<E>(); }
-//template<typename E> inline bool Stack::InnerIsValid<SafeEnum<E> >()                     { return InnerIsValid<String>(); }
-//template<typename E> inline SafeEnum<E> Stack::InnerGet<SafeEnum<E> >(SafeEnum<E> value) { return FindValue<SafeEnum<E> >(InnerGet<char const*>(value.ToString().C())); }
-//template<typename E> inline int Stack::InnerPush<SafeEnum<E> >(SafeEnum<E> value)        { return InnerPush<char const*>(value.ToString.C()); }
-#endif //STACK_STRING
-
-//-----------------------------------------------------------------------------
-#ifndef STACK_PTR
-//template<typename P> inline Stack::Ptr<P> Stack::InnerDefault<Stack::Ptr<P> >() { return Stack::Ptr<P>(nullptr); }
-//template<typename P> inline bool Stack::InnerIsValid<Stack::Ptr<P> >() { return !!lua_isuserdata(m_state, m_index); }
-//template<typename P> inline Stack::Ptr<P> Stack::InnerGet<Stack::Ptr<P> >(Stack::Ptr<P> value)
-//{
-//    P** obj = static_cast<P**>(value.m_throw_error
-//                                    ? luaL_checkudata(m_state, m_index++, ObjectHelper::GetMethodName<P>())
-//                                    : luaL_testudata(m_state, m_index++, ObjectHelper::GetMethodName<P>()) );
-//    return Stack::Ptr<P>(obj ? *obj : value.m_value);
-//}
-//template<typename P> inline int Stack::InnerPush<Stack::Ptr<P> >(Stack::Ptr<P> value)
-//{
-//    P** data = (P**)lua_newuserdata(m_state, sizeof(P*));
-//    *data = value.m_value;
-//}
-#endif //STACK_STRING
-
 #endif //REGION_STACK_VAR
 
-#endif //NEW_VAR_SYSTEM
-
 //-----------------------------------------------------------------------------
 class Loader
 {
@@ -1194,7 +489,6 @@ public:
     bool ExecLuaFile(String const &lua);
     bool ExecLuaCode(String const &lua);
 
-#if NEW_VAR_SYSTEM
     //-------------------------------------------------------------------------
 #define DECLARE_LOADER_GET(T0, T1, GET_NAME) \
     template<typename T0> \
@@ -1213,27 +507,6 @@ public:
 
 #undef DECLARE_LOADER_GET
 
-#else //OLD_VAR_SYSTEM
-
-    template<typename T>
-    T GetVar(String const &name)
-    {
-        lua_getglobal(m_lua_state, name.C());
-        Var<T> var; var.Get(m_lua_state, -1);
-        lua_pop(m_lua_state, 1);
-        return var;
-    }
-    template<typename T>
-    T* GetPtr(String const &name)
-    {
-        lua_getglobal(m_lua_state, name.C());
-        VarPtr<T> var; var.Get(m_lua_state, -1);
-        lua_pop(m_lua_state, 1);
-        return var();
-    }
-
-#endif //OLD_VAR_SYSTEM
-
 protected:
     lua_State* GetLuaState();
     static void Store(lua_State* l, Loader* loader);
@@ -1249,12 +522,11 @@ private:
 //-----------------------------------------------------------------------------
 // ObjectHelper member implementations that require VarPtr
 
-#if NEW_VAR_SYSTEM
 template <typename TLuaClass>
 int ObjectHelper::Store(lua_State * l)
 {
     auto stack = LuaStack::Begin(l);
-    auto obj = stack.Get<Stack::Ptr<TLuaClass> >();
+    TLuaClass* obj = stack.GetPtr<TLuaClass>();
     ASSERT(obj);
     Loader::StoreObject(l, obj);
     return 0;
@@ -1264,37 +536,12 @@ template <typename TLuaClass>
 int ObjectHelper::Del(lua_State * l)
 {
     auto stack = LuaStack::Begin(l);
-    auto obj = stack.Get<Stack::Ptr<TLuaClass> >();
+    TLuaClass* obj = stack.GetPtr<TLuaClass>();
     ASSERT(obj);
     delete obj;
     return 0;
 }
 
-#else //OLD_VAR_SYSTEM
-
-template <typename TLuaClass>
-int ObjectHelper::Store(lua_State * l)
-{
-    VarPtr<TLuaClass> obj;
-    obj.Get(l, 1);
-    ASSERT(obj());
-    Loader::StoreObject(l, obj());
-    return 0;
-}
-
-template <typename TLuaClass>
-int ObjectHelper::Del(lua_State * l)
-{
-    VarPtr<TLuaClass> obj;
-    obj.Get(l, 1);
-    ASSERT(obj());
-    delete obj();
-    return 0;
-}
-
-#endif //OLD_VAR_SYSTEM
-
-
 } /* namespace Lolua */
 
 //TYPEDEFS
@@ -1305,22 +552,5 @@ typedef Lolua::Object::Library  LuaObjectLibrary;
 typedef Lolua::Loader           LuaLoader;
 typedef Lolua::Stack            LuaStack;
 template <typename P> using LuaPtr = Lolua::Stack::Ptr<P>;
-//template <typename P>
-//typedef Lolua::Stack::Ptr<P>    LuaPtr<P>;
-#if OLD_VAR_SYSTEM
-typedef Lolua::Var<bool>        LuaBool;
-typedef Lolua::Var<char const*> LuaCharPtr;
-typedef Lolua::Var<String>      LuaString;
-typedef Lolua::Var<double>      LuaDouble;
-typedef Lolua::Var<float>       LuaFloat;
-typedef Lolua::Var<int64_t>     LuaInt64;
-typedef Lolua::Var<int32_t>     LuaInt32;
-typedef Lolua::Var<uint32_t>    LuaUInt32;
-typedef Lolua::Var<uint64_t>    LuaUInt64;
-typedef Lolua::Var<vec2>        LuaVec2;
-typedef Lolua::Var<vec3>        LuaVec3;
-typedef Lolua::Var<vec4>        LuaVec4;
-typedef Lolua::VarColor         LuaColor;
-#endif //OLD_VAR_SYSTEM
 
 } /* namespace lol */