diff --git a/src/binding/src/script_core.cpp b/src/binding/src/script_core.cpp
index 8225fee..5e6f4f6 100644
--- a/src/binding/src/script_core.cpp
+++ b/src/binding/src/script_core.cpp
@@ -17,6 +17,7 @@
 namespace sol {
 template <> struct is_automagical<pw::matrix4x4> : std::false_type {};
 template <> struct is_automagical<pw::vector3> : std::false_type {};
+template <> struct is_automagical<pw::vector2> : std::false_type {};
 template <> struct is_automagical<pw::vector4> : std::false_type {};
 template <> struct is_automagical<pw::quaternion> : std::false_type {};
 template <> struct is_automagical<pw::rectangle> : std::false_type {};
@@ -24,22 +25,22 @@ template <> struct is_automagical<pw::rectangle> : std::false_type {};
 
 namespace pw {
 
-
-rectangle from_lua_table(sol::table t)
+vector3 table_to_vector3(sol::table t)
 {
-    float v[4];
+    return vector3(t[0],t[1],t[2]);
+}
 
-    for (std::size_t i {1}; i <= t.size();i++){
-        v[i-1] = t[i];
+template <typename elementType>
+std::vector<elementType> convert_sequence(sol::table t)
+{
+    const std::size_t sz = t.size();
+    std::vector<elementType> res(sz);
+    for (std::size_t i = 1; i <= sz; i++) {
+        res[i - 1] = t[i];
     }
-    return rectangle(v);
+    return res;
 }
 
-vector3 vector3_from_lua_table(sol::table t)
-{
-
-    return vector3();
-}
 
 
 void register_core_function(sol::state& lua,sol::table& ns)
@@ -51,16 +52,25 @@ void register_core_function(sol::state& lua,sol::table& ns)
 
 
     ns.new_usertype<matrix4x4>("matrix4x4"
-                               , sol::constructors<matrix4x4()>()
+                               , sol::call_constructor,sol::constructors<matrix4x4()>()
                                , "row",&matrix4x4::row
                                , "column",&matrix4x4::column
                                , "set_identity",&matrix4x4::set_identity
                                , "inverse",&matrix4x4::inverse
-                               , "identity", &matrix4x4::identity
+                               , "identity",sol::readonly_property(matrix4x4::identity)
+                               //                               , "set",[](sol::this_state s,sol::table t) { for (int i = 0;i < t.size();i++) s.Ldata[i] = t[i-1]; })
+                               //                               , "get",[]() ->sol::table { return sol::table(); }
+
                                );
 
+    ns.new_usertype<vector2>("vector2"
+                            ,sol::call_constructor,sol::constructors<vector2(),vector2(Scalar,Scalar)>()
+                             ,"x", sol::property(sol::resolve<const vector2::value_type&() const>(&vector2::x), [](vector2& v,vector2::value_type val){ v.x() = val;})
+            ,"y", sol::property(sol::resolve<const vector2::value_type&() const>(&vector2::y), [](vector2& v,vector2::value_type val){ v.y() = val;})
+    );
+
     ns.new_usertype<vector3>("vector3"
-                            ,sol::constructors<vector3(),vector3(Scalar,Scalar,Scalar)>()
+                            ,sol::call_constructor,sol::constructors<vector3(),vector3(Scalar,Scalar,Scalar)>()
                             ,"x", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::x), [](vector3& v,vector3::value_type val){ v.x() = val;})
                             ,"y", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::y), [](vector3& v,vector3::value_type val){ v.y() = val;})
                             ,"z", sol::property(sol::resolve<const vector3::value_type&() const>(&vector3::z), [](vector3& v,vector3::value_type val){ v.z() = val;})
@@ -79,29 +89,29 @@ void register_core_function(sol::state& lua,sol::table& ns)
                             );
 
     ns.new_usertype<vector4>("vector4"
-                             ,sol::constructors<vector4(),vector4(vector4::value_type,vector4::value_type,vector4::value_type,vector4::value_type)>()
+                             ,sol::call_constructor,sol::constructors<vector4(),vector4(vector4::value_type,vector4::value_type,vector4::value_type,vector4::value_type)>()
                              ,"x", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::x), [](vector4& v,vector4::value_type val){ v.x() = val;})
-                             ,"y", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::y), [](vector4& v,vector4::value_type val){ v.y() = val;})
-                             ,"z", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::z), [](vector4& v,vector4::value_type val){ v.z() = val;})
-                             ,"w", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::w), [](vector4& v,vector4::value_type val){ v.w() = val;})
-                             ,"project",&vector4::project
-                             );
+            ,"y", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::y), [](vector4& v,vector4::value_type val){ v.y() = val;})
+    ,"z", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::z), [](vector4& v,vector4::value_type val){ v.z() = val;})
+    ,"w", sol::property(sol::resolve<const vector4::value_type&() const>(&vector4::w), [](vector4& v,vector4::value_type val){ v.w() = val;})
+    ,"project",&vector4::project
+            );
 
 
     ns.new_usertype<quaternion>("quaternion"
                                 ,sol::constructors<quaternion(), quaternion(quaternion::value_type,quaternion::value_type,quaternion::value_type,quaternion::value_type)>()
                                 ,"x", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::x), [](quaternion& v,quaternion::value_type val){ v.x() = val;})
-                                ,"y", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::y), [](quaternion& v,quaternion::value_type val){ v.y() = val;})
-                                ,"z", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::z), [](quaternion& v,quaternion::value_type val){ v.z() = val;})
-                                ,"w", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::w), [](quaternion& v,quaternion::value_type val){ v.w() = val;})
-                                ,"identity",sol::readonly_property(&quaternion::identity)
-                                ,"dot",&quaternion::dot
-                                ,"inverse",sol::readonly_property(&quaternion::inverse)
-                                ,"normalized",&quaternion::normalized
-                                ,"lerp",&quaternion::lerp
-                                ,"slerp",&quaternion::slerp
-                                ,"matrix",&quaternion::to_matrix
-                                );
+            ,"y", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::y), [](quaternion& v,quaternion::value_type val){ v.y() = val;})
+    ,"z", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::z), [](quaternion& v,quaternion::value_type val){ v.z() = val;})
+    ,"w", sol::property(sol::resolve<const quaternion::value_type&() const>(&quaternion::w), [](quaternion& v,quaternion::value_type val){ v.w() = val;})
+    ,"identity",sol::readonly_property(&quaternion::identity)
+            ,"dot",&quaternion::dot
+            ,"inverse",sol::readonly_property(&quaternion::inverse)
+            ,"normalized",&quaternion::normalized
+            ,"lerp",&quaternion::lerp
+            ,"slerp",&quaternion::slerp
+            ,"matrix",&quaternion::to_matrix
+            );
 
     ns.new_usertype<axisangle>
             ("axisangle",
@@ -114,18 +124,18 @@ void register_core_function(sol::state& lua,sol::table& ns)
 
 
     ns.new_usertype<size>("size"
-                          , sol::call_constructor,sol::constructors<size(),size(Scalar,Scalar)>()
+                          , sol::call_constructor, sol::constructors<size(),size(Scalar,Scalar)>()
                           , "width",&size::width
                           , "height",&size::height
                           , "cast_to_float",&size::cast<float>
                           );
 
     ns.new_usertype<sizef>("sizef"
-                          , sol::constructors<sizef(),sizef(Scalar,Scalar)>()
-                          , "width",&sizef::width
-                          , "height",&sizef::height
-                          , "cast_to_int",&sizef::cast<int>
-                          );
+                          , sol::call_constructor, sol::constructors<sizef(),sizef(Scalar,Scalar)>()
+                           , "width",&sizef::width
+                           , "height",&sizef::height
+                           , "cast_to_int",&sizef::cast<int>
+                           );
 
     ns.new_usertype<point>("point",
                            sol::constructors<point(),point(Scalar,Scalar)>(),
@@ -151,14 +161,16 @@ void register_core_function(sol::state& lua,sol::table& ns)
     ns.new_usertype<geometry>("geometry"
                               , sol::constructors<geometry(),geometry(geometry::primitive_topology_type,vector3_array,geometry::indices_t)>()
                               , "primitive_topology", sol::property(&geometry::primitive_topology,&geometry::set_primitive_topology)
-                              , "vertices", sol::property(&geometry::vertices,&geometry::set_vertices)
-                              , "indices", sol::property(&geometry::indices,&geometry::set_indices)
+                              , "vertices", sol::property(&geometry::ref_vertices,&geometry::ref_vertices)
+                              , "indices", sol::property(&geometry::ref_indices,&geometry::ref_indices)
+                              , "add_texture_coordinates",&geometry::add_texture_coordinates
+                              //                              , "texture_coordinates",&geometry::texture_coordinates
                               , "compute_normals", &geometry::compute_normals);
 
     ns.new_enum<false>("primitive_topology_type"
                         ,"point_list", geometry::primitive_topology_type::point_list
-                        ,"line_list",  geometry::primitive_topology_type::line_list
-                        ,"triangle_list", geometry::primitive_topology_type::triangle_list);
+                       ,"line_list",  geometry::primitive_topology_type::line_list
+                       ,"triangle_list", geometry::primitive_topology_type::triangle_list);
 
 
     ns.new_usertype<matrix_transform<real_t>>("matrixtransform"
@@ -166,11 +178,11 @@ void register_core_function(sol::state& lua,sol::table& ns)
                                               ,"look_at",&matrix_transform<real_t>::look_at
                                               ,"perspective_projection",&matrix_transform<real_t>::perspective_projection);
     // SOL3
-    //    geoom_type["type"] = lua.create_table_with(
-    //                  "points", geometry::topology_type::points
-    //                , "lines", geometry::topology_type::lines
-    //                , "line_strip", geometry::topology_type::line_strip
-    //                );
+//    geoom_type["type"] = lua.create_table_with(
+//                  "points", geometry::topology_type::points
+//                , "lines", geometry::topology_type::lines
+//                , "line_strip", geometry::topology_type::line_strip
+//                );
 
 
 
@@ -182,21 +194,21 @@ void register_core_function(sol::state& lua,sol::table& ns)
                                              ,"change_count",sol::property(&image::change_count,&image::set_change_count)
                                              );
 
-    image_type.create_named("pixel_layout"
-                            ,"rgb8", image::RGB8
-                            ,"rgb32", image::RGBA8
-                            ,"gray", image::LUM
-                            );
+    ns.create_named("pixel_layout"
+                    ,"rgb8", image::RGB8
+                    ,"rgb32", image::RGBA8
+                    ,"gray", image::LUM
+                    );
 
-//    image_type["layout"] = lua.create_table_with(
-//                                  "rgb8", image::RGB8
-//                                 ,"rgb32", image::RGBA8
-//                                 ,"gray", image::LUM);
+    //    image_type["layout"] = lua.create_table_with(
+    //                                  "rgb8", image::RGB8
+    //                                 ,"rgb32", image::RGBA8
+    //                                 ,"gray", image::LUM);
 
 
     ns.new_usertype<rectangle>("rectangle"
             ,sol::constructors<rectangle(),rectangle(const point_<float>&,const size_<float>&)>()
-            );
+                               );
 
     auto mathf_table = ns.create_named("mathf");
     mathf_table.set_function("ping_pong",ping_pong<real_t>);
diff --git a/src/binding/src/script_visual.cpp b/src/binding/src/script_visual.cpp
index bb09edd..395b0f6 100644
--- a/src/binding/src/script_visual.cpp
+++ b/src/binding/src/script_visual.cpp
@@ -13,7 +13,7 @@
 
 namespace pw {
 
-void register_visual_function(sol::state&,sol::table &ns)
+void register_visual_function(sol::state& lua,sol::table &ns)
 {
 
     ns.new_usertype<pipeline>("pipeline"
@@ -36,16 +36,21 @@ void register_visual_function(sol::state&,sol::table &ns)
                             ,"set_uniform_vec4",&shader::set_uniform<vector4&>
                             ,"set_uniform_texture",&shader::set_uniform<texture&>
 
-                            ).new_enum<false>("shader_type"
+                            );
+
+
+    ns["shader_type"] = ns.create_named("shader_type"
                                        ,"fragment",shader::code_type::fragment
-                                              ,"vertex",shader::code_type::vertex
-                                              ,"geometry",shader::code_type::geometry
-                                              ,"compute",shader::code_type::compute);
+                                        ,"vertex",shader::code_type::vertex
+                                        ,"geometry",shader::code_type::geometry
+                                        ,"compute",shader::code_type::compute);
+
+//    new_enum<false>(
 
 
-    ns.new_usertype<render_pass>("render_pass"
-                                ,"submit",&render_pass::submit
-                                 );
+//    ns.new_usertype<render_pass>("render_pass"
+//                                ,"submit",&render_pass::submit
+//                                 );
 
 
     ns.new_usertype<renderer>("renderer"
diff --git a/src/core/include/pw/core/geometry.hpp b/src/core/include/pw/core/geometry.hpp
index 66ced4c..4dd420e 100644
--- a/src/core/include/pw/core/geometry.hpp
+++ b/src/core/include/pw/core/geometry.hpp
@@ -65,12 +65,20 @@ public:
     void set_vertices(vector3_array v);
     const vector3_array& vertices() const { return _vertices; }
 
+    vector3_array& ref_vertices() { return _vertices;}
+
     void set_indices(indices_t v);
     const indices_t& indices() const;
 
+    indices_t& ref_indices() { return _indices; }
+
     void set_normals(vector3_array v);
     const vector3_array& normals() const;
 
+    void add_texture_coordinates(vector2_array v);
+    const std::vector<vector2_array>& texture_coordinates() const { return _texture_coords;}
+
+
     void transform(const matrix4x4& m);
 
     void compute_normals();
@@ -90,7 +98,7 @@ protected:
     vector3_array _tangents;   //!< tangent data
     vector3_array _bitangents; //!< bitangent
 
-    std::vector<vector3_array> _texture_coords; //! texture coordinates
+    std::vector<vector2_array> _texture_coords; //! texture coordinates
 
     uint64_t _change_count { 0 };
 };
diff --git a/src/core/src/geometry.cpp b/src/core/src/geometry.cpp
index 17d9007..45f6dc5 100644
--- a/src/core/src/geometry.cpp
+++ b/src/core/src/geometry.cpp
@@ -102,6 +102,13 @@ void geometry::set_normals(vector3_array v)
 
 const vector3_array &geometry::normals() const { return _normals; }
 
+
+void geometry::add_texture_coordinates(vector2_array v)
+{
+    _texture_coords.push_back(v);
+}
+
+
 //void geometry::set_vertices(const geometry::vertex3array_t &v)
 //{
 //    // first set vertices
diff --git a/src/scripts/demos/simple_003.lua b/src/scripts/demos/simple_003.lua
index 9176764..705b170 100644
--- a/src/scripts/demos/simple_003.lua
+++ b/src/scripts/demos/simple_003.lua
@@ -5,8 +5,8 @@
 -- we need everything
 pw.script:load_all()
 
-print(pw.path.get().executable_path)
-print(pw.path.get().resource_path)
+print("executable path:",pw.path.get().executable_path)
+print("resource path:",pw.path.get().resource_path)
 
 local img = pw.image.new()
 if not img:create(pw.size(64,64),pw.pixel_layout.rgb8) then
@@ -31,20 +31,27 @@ w.position = pw.point.new(100,100)
 -- create a new geometry
 local g = pw.geometry:new()
 
+
+-- create texture coordinates
+local tc = { pw.vector2(1.0,1.0),
+             pw.vector2(1.0,0.0),
+             pw.vector2(0.0,1.0),
+             pw.vector2(0.0,0.0) }
+
+g:add_texture_coordinates(tc)
+
+--print(g)
+
 g.primitive_topology = pw.primitive_topology_type.triangle_list -- meh
 
 z = -5.0
 s = 1
 
 -- geometry can only build with indexed facesets
-g.vertices:add(pw.vector3:new(-s, s, z)) -- 0
-g.vertices:add(pw.vector3:new(-s,-s, z)) -- 1
-g.vertices:add(pw.vector3:new( s,-s, z)) -- 2
-g.vertices:add(pw.vector3:new( s, s, z)) -- 3
-
--- 0 --- 3
--- |  \  |
--- 1 --- 2
+g.vertices:add(pw.vector3(-s, s, z)) -- 0
+g.vertices:add(pw.vector3(-s,-s, z)) -- 1
+g.vertices:add(pw.vector3( s,-s, z)) -- 2
+g.vertices:add(pw.vector3( s, s, z)) -- 3
 
 g.indices:add(0)
 g.indices:add(1)
@@ -55,9 +62,25 @@ g.indices:add(3)
 g.indices:add(0)
 
 
-local mm = pw.matrix4x4:new()
-local mv = pw.matrix4x4:new()
-local mp = pw.matrix4x4:new()
+print(#g.vertices,g.vertices,g.vertices[1].x,g.vertices[1].y,g.vertices[1].z)
+--print(g.vertices[1])
+
+local v3 = pw.vector3()
+
+print(g.indices,#g.indices)
+print(g.vertices,#g.vertices)
+
+--os.exit()
+
+-- 0 --- 3
+-- |  \  |
+-- 1 --- 2
+
+
+
+local mm = pw.matrix4x4.identity
+local mv = pw.matrix4x4()
+local mp = pw.matrix4x4()
 
 local s = pw.shader:new()
 
@@ -82,7 +105,7 @@ uniform sampler2D tex_color;
 out vec4 frag_color;
 
 void main() {
-    frag_color = texture(tex_color,vec2(1.0,1.0));
+    frag_color = color * texture(tex_color,vec2(1.0,1.0));
 }
 ]])
 
@@ -100,9 +123,9 @@ if not renderer:create(g) then
 end
 
 -- camera position
-local cam_pos = pw.vector3:new(0,0,0)
+local cam_pos = pw.vector3(0,0,0)
 
-local model_pos = pw.vector3:new(0,0,0)
+local model_pos = pw.vector3(0,0,0)
 
 
 local ctx = pw.context:new()
@@ -119,9 +142,6 @@ end
 -- setup a lua callback function as callback
 w.on_update = function(self)
 
-    -- set identity on model matrix
-    mm:set_identity()
-
     -- set view matrix with look_at - view matrix is moving the world - hence inverse!
     mv = pw.matrixtransform.look_at(cam_pos,cam_pos + pw.vector3.forward(),pw.vector3.up()):inverse()
 
@@ -135,21 +155,14 @@ w.on_update = function(self)
     local color_red  = pw.mathf.ping_pong(pw.time.now,1.0)
     local color_green = pw.mathf.ping_pong(pw.time.now + 1,1.0)
     local color_blue = 1.0 - pw.mathf.ping_pong(pw.time.now,1.0)
-    local cl = pw.vector4:new( color_red, color_green, color_blue, 1.0 )
+    local cl = pw.vector4( color_red, color_green, color_blue, 1.0 )
 
     img:generate_noise()
-
     tx:update(img)
 
-
---    print(img.change_count)
-
     -- bind the shader
     s:use()
 
-
-
-
     -- update the uniforms, currently the slow path
     s:set_uniform_mat4("model",mm)