diff --git a/src/action.cpp b/src/action.cpp
index 552f3c7..8ba56bf 100644
--- a/src/action.cpp
+++ b/src/action.cpp
@@ -20,11 +20,11 @@ void ActionManager::undo()
         return;
 
     I.m_redos.emplace(I.m_actions.top()->get_redo());
-    I.m_redos.top()->was_saved = !ui::Canvas::I->m_unsaved;
+    I.m_redos.top()->was_saved = !Canvas::I->m_unsaved;
 
     I.m_actions.top()->undo();
     I.m_memory -= I.m_actions.top()->memory();
-    ui::Canvas::I->m_unsaved = !I.m_actions.top()->was_saved;
+    Canvas::I->m_unsaved = !I.m_actions.top()->was_saved;
     I.m_actions.pop();
     //LOG("History: %.2f KB", I.m_memory / 1024.f);
     App::I.update_memory_usage(I.m_memory);
@@ -37,11 +37,11 @@ void ActionManager::redo()
         return;
 
     I.m_actions.emplace(I.m_redos.top()->get_redo());
-    I.m_actions.top()->was_saved = !ui::Canvas::I->m_unsaved;
+    I.m_actions.top()->was_saved = !Canvas::I->m_unsaved;
     I.m_memory += I.m_actions.top()->memory();
 
     I.m_redos.top()->undo();
-    ui::Canvas::I->m_unsaved = !I.m_redos.top()->was_saved;
+    Canvas::I->m_unsaved = !I.m_redos.top()->was_saved;
     I.m_redos.pop();
     //LOG("History: %.2f KB", I.m_memory / 1024.f);
     App::I.update_memory_usage(I.m_memory);
diff --git a/src/app.cpp b/src/app.cpp
index 31cb200..a344355 100644
--- a/src/app.cpp
+++ b/src/app.cpp
@@ -21,8 +21,6 @@ void async_unlock();
 void destroy_window();
 #endif
 
-using namespace ui;
-
 App App::I; // singleton
 
 void App::create()
@@ -65,7 +63,7 @@ void App::open_document(std::string path)
 bool App::request_close()
 {
     static bool dialog_already_opened = false;
-    if (!ui::Canvas::I->m_unsaved)
+    if (!Canvas::I->m_unsaved)
         return true;
     if (!dialog_already_opened)
     {
@@ -82,7 +80,7 @@ bool App::request_close()
 #ifdef __OSX__
             [osx_view close];
 #endif
-            ui::Canvas::I->m_unsaved = false;
+            Canvas::I->m_unsaved = false;
         };
         m->btn_cancel->m_text->set_text("No");
         m->btn_cancel->on_click = [this,m](Node*) {
@@ -517,9 +515,9 @@ void App::update(float dt)
 
 //     glEnable(GL_BLEND);
 //     sampler.bind(0);
-//     ui::ShaderManager::use(kShader::Texture);
-//     ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-//     ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-1.f, 1.f, -1.f, 1.f));
+//     ShaderManager::use(kShader::Texture);
+//     ShaderManager::u_int(kShaderUniform::Tex, 0);
+//     ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-1.f, 1.f, -1.f, 1.f));
 //     glActiveTexture(GL_TEXTURE0);
 //     uirtt.bindTexture();
 //     m_face_plane.draw_fill();
diff --git a/src/app.h b/src/app.h
index bcededf..7cc4624 100644
--- a/src/app.h
+++ b/src/app.h
@@ -51,8 +51,8 @@ public:
     Sampler sampler;
     Sampler sampler_stencil;
     Sampler sampler_linear;
-    ui::Plane m_face_plane;
-    //ui::Sphere sphere;
+    Plane m_face_plane;
+    //Sphere sphere;
     LayoutManager layout;
     NodeMessageBox* msgbox;
     NodeSettings* settings;
diff --git a/src/app_cloud.cpp b/src/app_cloud.cpp
index 7a778cf..ed158e6 100644
--- a/src/app_cloud.cpp
+++ b/src/app_cloud.cpp
@@ -4,13 +4,11 @@
 #include "node_progress_bar.h"
 #include "node_dialog_cloud.h"
 
-using namespace ui;
-
 void App::cloud_upload()
 {
     if (!canvas)
         return;
-    if (ui::Canvas::I->m_newdoc)
+    if (Canvas::I->m_newdoc)
     {
         auto msgbox = new NodeMessageBox();
         msgbox->m_manager = &layout;
@@ -23,7 +21,7 @@ void App::cloud_upload()
     else
     {
         auto upload_thread = [this] {
-            if (ui::Canvas::I->m_unsaved)
+            if (Canvas::I->m_unsaved)
             {
                 Canvas::I->project_save_thread(doc_path);
             }
diff --git a/src/app_commands.cpp b/src/app_commands.cpp
index 4b36728..6635324 100644
--- a/src/app_commands.cpp
+++ b/src/app_commands.cpp
@@ -9,7 +9,7 @@ void App::cmd_convert(std::string pano_path, std::string out_path)
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glBlendEquation(GL_FUNC_ADD);
 
-    ui::Canvas* canvas = new ui::Canvas;
+    Canvas* canvas = new Canvas;
     canvas->create(CANVAS_RES, CANVAS_RES);
     canvas->project_open_thread(pano_path);
     canvas->export_equirectangular_thread(out_path);
diff --git a/src/app_dialogs.cpp b/src/app_dialogs.cpp
index f8ad99f..7e2016e 100644
--- a/src/app_dialogs.cpp
+++ b/src/app_dialogs.cpp
@@ -154,7 +154,7 @@ void App::dialog_newdoc()
 
     if (canvas)
     {
-        if (ui::Canvas::I->m_unsaved)
+        if (Canvas::I->m_unsaved)
         {
             auto m = layout[main_id]->add_child<NodeMessageBox>();
             m->m_title->set_text("Unsaved document");
@@ -162,7 +162,7 @@ void App::dialog_newdoc()
             m->btn_ok->m_text->set_text("Yes");
             m->btn_cancel->m_text->set_text("No");
             m->btn_ok->on_click = [this, m, show_dialog](Node*) {
-                ui::Canvas::I->project_save([this, m, show_dialog](bool success){
+                Canvas::I->project_save([this, m, show_dialog](bool success){
                     if (success)
                         show_dialog();
                     else
@@ -218,7 +218,7 @@ void App::dialog_open()
 
     if (canvas)
     {
-        if (ui::Canvas::I->m_unsaved)
+        if (Canvas::I->m_unsaved)
         {
             auto m = layout[main_id]->add_child<NodeMessageBox>();
             m->m_title->set_text("Unsaved document");
@@ -226,7 +226,7 @@ void App::dialog_open()
             m->btn_ok->m_text->set_text("Yes");
             m->btn_cancel->m_text->set_text("No");
             m->btn_ok->on_click = [this,m,show_dialog](Node*){
-                ui::Canvas::I->project_save([this,m,show_dialog](bool success){
+                Canvas::I->project_save([this,m,show_dialog](bool success){
                     if (success)
                         show_dialog();
                     else
@@ -278,7 +278,7 @@ void App::dialog_browse()
 
     if (canvas)
     {
-        if (ui::Canvas::I->m_unsaved)
+        if (Canvas::I->m_unsaved)
         {
             auto m = layout[main_id]->add_child<NodeMessageBox>();
             m->m_title->set_text("Unsaved document");
@@ -286,7 +286,7 @@ void App::dialog_browse()
             m->btn_ok->m_text->set_text("Yes");
             m->btn_cancel->m_text->set_text("No");
             m->btn_ok->on_click = [this, m, show_dialog](Node*) {
-                ui::Canvas::I->project_save([this, m, show_dialog](bool success){
+                Canvas::I->project_save([this, m, show_dialog](bool success){
                     if (success)
                         show_dialog();
                     else
diff --git a/src/app_events.cpp b/src/app_events.cpp
index 33fdac5..d7b5472 100644
--- a/src/app_events.cpp
+++ b/src/app_events.cpp
@@ -10,8 +10,6 @@ std::string win32_open_dir();
 #endif
 
 
-using namespace ui;
-
 void App::tick(float dt)
 {
     layout[main_id]->tick(dt);
diff --git a/src/app_layout.cpp b/src/app_layout.cpp
index b631f29..90a4869 100644
--- a/src/app_layout.cpp
+++ b/src/app_layout.cpp
@@ -6,8 +6,6 @@
 #include "node_progress_bar.h"
 #include "node_dialog_picker.h"
 
-using namespace ui;
-
 static glm::vec4 color_button_normal{ .1, .1, .1, 1 };
 static glm::vec4 color_button_hlight{ 1, .0, .0, 1 };
 
@@ -139,26 +137,26 @@ void App::init_sidebar()
 
 //     if (canvas)
 //     {
-//         ui::Canvas::I->m_current_brush.m_tip_color = color->m_color;
+//         Canvas::I->m_current_brush.m_tip_color = color->m_color;
 //         stroke->m_canvas->draw_stroke();
 //     }
 
     brushes->on_brush_changed = [this](Node* target, int index) {
-        ui::Canvas::I->m_current_brush.m_tex_id = brushes->get_texture_id(index);
-        ui::Canvas::I->m_current_brush.id = brushes->get_brush_id(index);
+        Canvas::I->m_current_brush.m_tex_id = brushes->get_texture_id(index);
+        Canvas::I->m_current_brush.id = brushes->get_brush_id(index);
         stroke->m_preview->draw_stroke();
     };
     presets->on_brush_changed = [this](Node* target, int index) {
         auto b = presets->get_brush(index);
         // don't change some params
-        b.m_tip_size = ui::Canvas::I->m_current_brush.m_tip_size;
-        b.m_tip_color = ui::Canvas::I->m_current_brush.m_tip_color;
-        ui::Canvas::I->m_current_brush = b;
+        b.m_tip_size = Canvas::I->m_current_brush.m_tip_size;
+        b.m_tip_color = Canvas::I->m_current_brush.m_tip_color;
+        Canvas::I->m_current_brush = b;
         stroke->m_preview->draw_stroke();
     };
 
     color->on_color_changed = [this](Node* target, glm::vec4 color) {
-        ui::Canvas::I->m_current_brush.m_tip_color = color;
+        Canvas::I->m_current_brush.m_tip_color = color;
     };
 // 
 //     stroke->on_stroke_change = [this](Node*target) {
@@ -224,7 +222,7 @@ void App::init_sidebar()
             panels->fix_scroll();
             button->set_color(panels->get_child_index(color.get()) == -1 ? color_button_normal : color_button_hlight);
 //             auto pick = layout[main_id]->add_child<NodeColorPicker>();
-//             pick->m_color_cur->m_color = ui::Canvas::I->m_current_brush.m_tip_color;
+//             pick->m_color_cur->m_color = Canvas::I->m_current_brush.m_tip_color;
         };
     }
     if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-layer"))
@@ -318,7 +316,7 @@ void App::init_toolbar_draw()
     {
         button->on_click = [this, button](Node*) {
             select_button(layout[main_id], button);
-            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]);
+            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
             m->m_action = CanvasModeTransform::ActionType::Copy;
             Canvas::set_mode(Canvas::kCanvasMode::Transform);
         };
@@ -327,7 +325,7 @@ void App::init_toolbar_draw()
     {
         button->on_click = [this, button](Node*) {
             select_button(layout[main_id], button);
-            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]);
+            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
             m->m_action = CanvasModeTransform::ActionType::Cut;
             Canvas::set_mode(Canvas::kCanvasMode::Transform);
         };
@@ -356,7 +354,7 @@ void App::init_toolbar_draw()
     if (auto* button = layout[main_id]->find<NodeButtonCustom>("btn-bucket"))
     {
         button->on_click = [this](Node*) {
-            canvas->m_canvas->clear(ui::Canvas::I->m_current_brush.m_tip_color);
+            canvas->m_canvas->clear(Canvas::I->m_current_brush.m_tip_color);
         };
     }
 }
@@ -397,7 +395,7 @@ void App::init_menu_file()
                         }
                         else
                         {
-                            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)ui::Canvas::kCanvasMode::Transform][0]);
+                            auto m = static_cast<CanvasModeTransform*>(canvas->m_canvas->modes[(int)Canvas::kCanvasMode::Transform][0]);
                             m->m_action = CanvasModeTransform::ActionType::Import;
                             m->m_source_image = std::move(img);
                             Canvas::set_mode(Canvas::kCanvasMode::Transform);
@@ -423,11 +421,11 @@ void App::init_menu_file()
                 };
             if (auto b = popup->find<NodeButtonCustom>("file-save"))
                 b->on_click = [this](Node*) {
-                    if (ui::Canvas::I->m_newdoc)
+                    if (Canvas::I->m_newdoc)
                     {
                         dialog_save();
                     }
-                    else if(ui::Canvas::I->m_unsaved)
+                    else if(Canvas::I->m_unsaved)
                     {
                         canvas->m_canvas->project_save();
                     }
@@ -442,7 +440,7 @@ void App::init_menu_file()
                 };
             if (auto b = popup->find<NodeButtonCustom>("file-save-ver"))
                 b->on_click = [this](Node*) {
-                    ui::Canvas::I->m_newdoc ? dialog_save() : dialog_save_ver();
+                    Canvas::I->m_newdoc ? dialog_save() : dialog_save_ver();
                     popup->mouse_release();
                     popup->destroy();
                 };
@@ -632,7 +630,7 @@ void App::init_menu_layer()
             popup->m_flood_events = true;
             popup->m_capture_children = false;
             popup->find<NodeButtonCustom>("clear-grids")->on_click = [this](Node*) {
-                CanvasModeGrid* mode = (CanvasModeGrid*)ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid][0];
+                CanvasModeGrid* mode = (CanvasModeGrid*)Canvas::modes[(int)Canvas::kCanvasMode::Grid][0];
                 mode->clear();
                 popup->mouse_release();
                 popup->destroy();
@@ -746,7 +744,7 @@ void App::initLayout()
         b.m_tip_flow = .5f;
         b.m_tip_spacing = .1f;
         b.m_tip_opacity = 1.f;
-        ui::Canvas::I->m_current_brush = b;
+        Canvas::I->m_current_brush = b;
 
         brush_update();
         
@@ -782,7 +780,7 @@ void App::initLayout()
             auto frame_text = layout[main_id]->find<NodeText>("timeline-frame");
             slider->on_value_changed = [this, frame_text](Node*, float value)
             {
-                auto& c = *ui::Canvas::I;
+                auto& c = *Canvas::I;
 
                 for (int i = 0; i < c.m_layers.size(); i++)
                 {
diff --git a/src/app_shaders.cpp b/src/app_shaders.cpp
index 7171cc2..b843016 100644
--- a/src/app_shaders.cpp
+++ b/src/app_shaders.cpp
@@ -2,8 +2,6 @@
 #include "app.h"
 #include "shader.h"
 
-using namespace ui;
-
 void App::initShaders()
 {
     static const char* shader_v =
diff --git a/src/app_vr.cpp b/src/app_vr.cpp
index 080b441..c4a7330 100644
--- a/src/app_vr.cpp
+++ b/src/app_vr.cpp
@@ -3,8 +3,6 @@
 
 void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat4& pose)
 {
-    using namespace ui;
-
     //glm::mat4 ortho_proj = glm::ortho(0.f, box.z, 0.f, box.w, -1000.f, 1000.f);
     //glm::mat4 proj = glm::perspective(glm::radians(m_canvas->m_cam_fov), box.z / box.w, 0.01f, 1000.f);
     //glm::mat4 camera = glm::eulerAngleXY(m_canvas->m_cam_rot.y, m_canvas->m_cam_rot.x) *
@@ -34,8 +32,8 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             canvas->m_canvas->m_plane_transform[plane_index] *
             glm::translate(glm::vec3(0, 0, -1));
 
-        ui::ShaderManager::use(kShader::Checkerboard);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+        ShaderManager::use(kShader::Checkerboard);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
         m_face_plane.draw_fill();
     }
 
@@ -58,17 +56,17 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
                 canvas->m_canvas->m_plane_transform[plane_index] *
                 glm::translate(glm::vec3(0, 0, -1));
             
-            if (canvas->m_canvas->m_state == ui::Canvas::kCanvasMode::Erase && canvas->m_canvas->m_show_tmp && canvas->m_canvas->m_current_layer_idx == layer_index)
+            if (canvas->m_canvas->m_state == Canvas::kCanvasMode::Erase && canvas->m_canvas->m_show_tmp && canvas->m_canvas->m_current_layer_idx == layer_index)
             {
                 sampler.bind(0);
-                ui::ShaderManager::use(kShader::CompErase);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-                //ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
-                //ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
-                //ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::CompErase);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+                //ShaderManager::u_int(kShaderUniform::TexMask, 2);
+                ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
+                //ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
+                //ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 glActiveTexture(GL_TEXTURE0);
                 canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
                 glActiveTexture(GL_TEXTURE1);
@@ -86,17 +84,17 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             {
                 sampler.bind(0);
                 auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
-                ui::ShaderManager::use(kShader::CompDraw);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-                ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-                ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_canvas->m_size);
-                //ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
-                ui::ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked);
-                ui::ShaderManager::u_int(kShaderUniform::Mask, canvas->m_canvas->m_smask_active);
-                ui::ShaderManager::u_int(kShaderUniform::BlendMode, canvas->m_canvas->m_current_stroke->m_brush.m_blend_mode);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::CompDraw);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+                ShaderManager::u_int(kShaderUniform::TexMask, 2);
+                ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_canvas->m_size);
+                //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
+                ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_stroke->m_brush.m_tip_opacity);
+                ShaderManager::u_int(kShaderUniform::Lock, canvas->m_canvas->m_layers[layer_index].m_alpha_locked);
+                ShaderManager::u_int(kShaderUniform::Mask, canvas->m_canvas->m_smask_active);
+                ShaderManager::u_int(kShaderUniform::BlendMode, canvas->m_canvas->m_current_stroke->m_brush.m_blend_mode);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 glActiveTexture(GL_TEXTURE0);
                 canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
                 glActiveTexture(GL_TEXTURE1);
@@ -118,12 +116,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             {
                 sampler.bind(0);
                 sampler_linear.bind(1);
-                ui::ShaderManager::use(kShader::TextureAlphaSep);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexA, 1);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
-                ui::ShaderManager::u_int(kShaderUniform::Highlight, canvas->m_canvas->m_layers[layer_index].m_hightlight);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::TextureAlphaSep);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexA, 1);
+                ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_layers[layer_index].m_opacity);
+                ShaderManager::u_int(kShaderUniform::Highlight, canvas->m_canvas->m_layers[layer_index].m_hightlight);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 
                 glActiveTexture(GL_TEXTURE0);
                 canvas->m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
@@ -150,9 +148,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             glm::transpose(canvas->m_canvas->m_cam_rot) *
             glm::translate(glm::vec3(0, 0, -1)) *
             glm::scale(aspect * tan_fov);
-        ui::ShaderManager::use(kShader::Color);
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
         m_face_plane.draw_stroke();
     }
 
@@ -164,12 +162,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             pos.x = pos.x - canvas->m_canvas->m_current_brush.m_tip_size * 500;
         auto cur = (glm::vec2(pos.x / width, 1.f - pos.y / height) - 0.5f) * 2.f;
 
-        ui::ShaderManager::use(ui::kShader::StrokePreview);
-        ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
+        ShaderManager::use(kShader::StrokePreview);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
         auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
+        ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
+        ShaderManager::u_mat4(kShaderUniform::MVP,
             proj * camera *
             glm::scale(glm::vec3(100)) *
             glm::transpose(canvas->m_canvas->m_cam_rot) *
@@ -195,9 +193,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             glm::translate(glm::vec3(0, 0, -1)) *
             glm::scale(aspect * tan_fov);
         sampler_linear.bind(0);
-        ui::ShaderManager::use(kShader::Texture);
-        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+        ShaderManager::use(kShader::Texture);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
         glActiveTexture(GL_TEXTURE0);
         uirtt.bindTexture();
         m_face_plane.draw_fill();
@@ -211,12 +209,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
             glm::scale(glm::vec3(100)) *
             glm::transpose(canvas->m_canvas->m_cam_rot) *
             glm::translate(glm::vec3(cur * glm::vec2(aspect * tan_fov), -1));
-        ui::ShaderManager::use(kShader::Color);
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.01)));
         m_face_plane.draw_fill();
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
+        ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, 1 });
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.005)));
         m_face_plane.draw_fill();
     }
 
@@ -224,9 +222,9 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
 /*
     {
         auto mvp = proj * camera * glm::translate(glm::normalize(vr_controller_pos));
-        ui::ShaderManager::use(kShader::Color);
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025)));
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp * glm::scale(glm::vec3(.025)));
         sphere.draw_fill();
     }
 */
@@ -234,12 +232,12 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
     // draw the motion controller brush
     {
         auto pos = glm::translate(glm::normalize(vr_controller_pos));
-        ui::ShaderManager::use(ui::kShader::StrokePreview);
-        ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
+        ShaderManager::use(kShader::StrokePreview);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_canvas->m_current_brush.m_tip_flow);
         auto tip_color = glm::vec4(glm::vec3(canvas->m_canvas->m_current_brush.m_tip_color), 1);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
+        ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
+        ShaderManager::u_mat4(kShaderUniform::MVP,
             proj * camera * pos * 
             glm::inverse(glm::lookAt({ 0, 0, 0 }, vr_controller_pos, { 0, 1, 0 })) *
             //glm::scale(glm::vec3(0.1)) *
@@ -267,8 +265,8 @@ void App::vr_draw(const glm::mat4& proj, const glm::mat4& camera, const glm::mat
     }
     
     // keep drawing the grids
-    if (m_canvas->m_state != ui::Canvas::kCanvasMode::Grid)
-        for (auto& mode : ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid])
+    if (m_canvas->m_state != Canvas::kCanvasMode::Grid)
+        for (auto& mode : Canvas::modes[(int)Canvas::kCanvasMode::Grid])
             mode->on_Draw(ortho_proj, proj, camera);
 */
 
diff --git a/src/brush.cpp b/src/brush.cpp
index b8626fd..336a613 100644
--- a/src/brush.cpp
+++ b/src/brush.cpp
@@ -2,7 +2,7 @@
 #include "log.h"
 #include "brush.h"
 
-void ui::BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj)
+void BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::mat4& proj)
 {
     std::vector<instance_t> attributes;
     attributes.reserve(samples.size());
@@ -65,7 +65,7 @@ void ui::BrushMesh::draw(const std::vector<StrokeSample>& samples, const glm::ma
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 #endif // USE_VBO
 }
-bool ui::BrushMesh::create()
+bool BrushMesh::create()
 {
     static GLushort idx[6]{ 0, 1, 2, 0, 2, 3 };
     static vertex_t vertices[4]{
@@ -126,7 +126,7 @@ bool ui::BrushMesh::create()
 
     return true;
 }
-ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec3& pos, float pressure, float curve_angle)
+StrokeSample Stroke::randomize_sample(const glm::vec3& pos, float pressure, float curve_angle)
 {
     auto rnd_nor = [&] { return float((double)prng() / (double)prng.max()); };              // normalized [0, +1]
     //auto rnd_neg = [&] { return float((double)prng() / (double)prng.max() * 2.0 - 1.0); };  // normalized [-1, +1]
@@ -150,7 +150,7 @@ ui::StrokeSample ui::Stroke::randomize_sample(const glm::vec3& pos, float pressu
     s.col = convert_hsv2rgb(m_hsv_jitter.average());
     return s;
 }
-std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
+std::vector<StrokeSample> Stroke::compute_samples()
 {
     if (m_keypoints.empty()) return {};
     int nsamples = (int)glm::floor((m_keypoints.back().dist - m_dist) / m_step);
@@ -188,19 +188,19 @@ std::vector<ui::StrokeSample> ui::Stroke::compute_samples()
     }
     return samples;
 }
-bool ui::Stroke::has_sample()
+bool Stroke::has_sample()
 {
     return m_keypoints.empty() ? false :                // no keypoints
         (m_keypoints.back().dist > (m_dist + m_step));  // check if next kp is closer than spacing
 }
-void ui::Stroke::reset(bool clear_keypoints /*= false*/)
+void Stroke::reset(bool clear_keypoints /*= false*/)
 {
     m_last_kp = 0;
     m_dist = 0.f;
     if (clear_keypoints)
         m_keypoints.clear();
 }
-void ui::Stroke::add_point(glm::vec3 pos, float pressure)
+void Stroke::add_point(glm::vec3 pos, float pressure)
 {
 #ifdef __IOS__
     m_curve = glm::min(m_curve + 0.1f, 1.f);
@@ -229,7 +229,7 @@ void ui::Stroke::add_point(glm::vec3 pos, float pressure)
     kp.dist = dist;
     m_keypoints.push_back(kp);
 }
-void ui::Stroke::start(const ui::Brush& brush)
+void Stroke::start(const Brush& brush)
 {
     m_hold_points.clear();
     m_curve = 0.f;
diff --git a/src/brush.h b/src/brush.h
index df73885..71d00f6 100644
--- a/src/brush.h
+++ b/src/brush.h
@@ -2,8 +2,6 @@
 #include "rtt.h"
 #include "shader.h"
 
-NS_START
-
 class Brush
 {
 public:
@@ -89,7 +87,7 @@ public:
     float m_dist = 0;
     float m_step = 0;
     Camera m_camera;
-    ui::Brush m_brush;
+    Brush m_brush;
     cbuffer<float, 3> m_curve_angles;
     cbuffer<float, 10> m_pressure_buff;
     cbuffer<glm::vec3, 3> m_hsv_jitter;
@@ -99,12 +97,10 @@ public:
     std::vector<StrokeSample> m_samples;
     int m_last_kp;
     std::minstd_rand prng;
-    void start(const ui::Brush& brush);
+    void start(const Brush& brush);
     void add_point(glm::vec3 pos, float pressure);
     void reset(bool clear_keypoints = false);
     bool has_sample();
     std::vector<StrokeSample> compute_samples();
     StrokeSample randomize_sample(const glm::vec3& pos, float pressure, float curve_angle);
 };
-
-NS_END
diff --git a/src/canvas.cpp b/src/canvas.cpp
index 6f0b06d..6911ef5 100644
--- a/src/canvas.cpp
+++ b/src/canvas.cpp
@@ -11,8 +11,8 @@
 #endif
 
 
-ui::Canvas* ui::Canvas::I;
-std::vector<CanvasMode*> ui::Canvas::modes[] = {
+Canvas* Canvas::I;
+std::vector<CanvasMode*> Canvas::modes[] = {
     { new CanvasModePen, new CanvasModeBasicCamera },
     { new CanvasModePen, new CanvasModeBasicCamera },
     { new CanvasModeLine, new CanvasModeBasicCamera },
@@ -23,7 +23,7 @@ std::vector<CanvasMode*> ui::Canvas::modes[] = {
     { new CanvasModeMaskFree, new CanvasModeBasicCamera },
     { new CanvasModeMaskLine, new CanvasModeBasicCamera },
 };
-glm::vec3 ui::Canvas::m_plane_origin[6] = {
+glm::vec3 Canvas::m_plane_origin[6] = {
     { 0, 0,-1}, // front
     { 1, 0, 0}, // right
     { 0, 0, 1}, // back
@@ -31,7 +31,7 @@ glm::vec3 ui::Canvas::m_plane_origin[6] = {
     { 0, 1, 0}, // top
     { 0,-1, 0}, // bottom
 };
-glm::vec3 ui::Canvas::m_plane_normal[6] = {
+glm::vec3 Canvas::m_plane_normal[6] = {
     { 0, 0, 1}, // front
     {-1, 0, 0}, // right
     { 0, 0,-1}, // back
@@ -39,7 +39,7 @@ glm::vec3 ui::Canvas::m_plane_normal[6] = {
     { 0,-1, 0}, // top
     { 0, 1, 0}, // bottom
 };
-glm::vec3 ui::Canvas::m_plane_tangent[6] = {
+glm::vec3 Canvas::m_plane_tangent[6] = {
     {0, 1, 0}, // front
     {0, 1, 0}, // right
     {0, 1, 0}, // back
@@ -48,7 +48,7 @@ glm::vec3 ui::Canvas::m_plane_tangent[6] = {
     {0, 0, 1}, // bottom
 };
 // only rotation
-glm::mat4 ui::Canvas::m_plane_transform[6] = {
+glm::mat4 Canvas::m_plane_transform[6] = {
     glm::lookAt(glm::vec3(), { 0, 0,-1}, {0, 1, 0}), // front
     glm::lookAt(glm::vec3(), {-1, 0, 0}, {0, 1, 0}), // right
     glm::lookAt(glm::vec3(), { 0, 0, 1}, {0, 1, 0}), // back
@@ -57,12 +57,12 @@ glm::mat4 ui::Canvas::m_plane_transform[6] = {
     glm::lookAt(glm::vec3(), { 0,-1, 0}, {0, 0, 1}), // bottom
 };
 
-void ui::Canvas::pick_start()
+void Canvas::pick_start()
 {
     for (int i = 0; i < 6; i++)
         m_pick_ready[i] = false;
 }
-void ui::Canvas::pick_update(int plane)
+void Canvas::pick_update(int plane)
 {
     // check if already updated
     if (m_pick_ready[plane])
@@ -83,7 +83,7 @@ void ui::Canvas::pick_update(int plane)
     m_tmp[i].bindFramebuffer();
     m_tmp[i].clear({ 1, 1, 1, 1 });
 
-    ShaderManager::use(ui::kShader::TextureAlpha);
+    ShaderManager::use(kShader::TextureAlpha);
     ShaderManager::u_int(kShaderUniform::Highlight, false);
     ShaderManager::u_int(kShaderUniform::Tex, 0);
     ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
@@ -112,7 +112,7 @@ void ui::Canvas::pick_update(int plane)
     
     m_pick_ready[plane] = true;
 }
-glm::vec4 ui::Canvas::pick_get(glm::vec2 canvas_loc)
+glm::vec4 Canvas::pick_get(glm::vec2 canvas_loc)
 {
     glm::vec3 ray_origin;
     glm::vec3 ray_dir;
@@ -128,23 +128,23 @@ glm::vec4 ui::Canvas::pick_get(glm::vec2 canvas_loc)
     }
     return {0,0,0,1};
 }
-void ui::Canvas::pick_end()
+void Canvas::pick_end()
 {
     for (int i = 0; i < 6; i++)
         m_pick_data[i].release();
 }
-void ui::Canvas::clear(const glm::vec4& c/*={0,0,0,1}*/)
+void Canvas::clear(const glm::vec4& c/*={0,0,0,1}*/)
 {
     snap_history({ 0, 1, 2, 3, 4, 5 });
     m_layers[m_current_layer_idx].clear(c);
     m_unsaved = true;
 }
-void ui::Canvas::clear_all()
+void Canvas::clear_all()
 {
     for (auto& l : m_layers)
         l.clear({0, 0, 0, 0});
 }
-void ui::Canvas::snap_history(const std::vector<int>& planes)
+void Canvas::snap_history(const std::vector<int>& planes)
 {
     auto action = new ActionStroke;
     action->was_saved = !m_unsaved;
@@ -174,7 +174,7 @@ void ui::Canvas::snap_history(const std::vector<int>& planes)
     action->clear_layer = true;
     ActionManager::add(action);
 }
-ui::ActionStroke* ui::Canvas::create_action(int layer)
+ActionStroke* Canvas::create_action(int layer)
 {
     auto action = new ActionStroke;
     for (int i = 0; i < 6; i++)
@@ -203,7 +203,7 @@ ui::ActionStroke* ui::Canvas::create_action(int layer)
     action->clear_layer = true;
     return action;
 }
-void ui::Canvas::stroke_end()
+void Canvas::stroke_end()
 {
     if (!m_current_stroke)
         return;
@@ -218,14 +218,14 @@ void ui::Canvas::stroke_end()
         m_show_tmp = false;
     }
 }
-void ui::Canvas::stroke_cancel()
+void Canvas::stroke_cancel()
 {
     if (!m_current_stroke)
         return;
     m_current_stroke = nullptr;
     m_show_tmp = false;
 }
-void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
+void Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz)
 {
     m_mixer.bindFramebuffer();
 
@@ -252,12 +252,12 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
             m_plane_transform[plane_index] *
             glm::translate(glm::vec3(0, 0, -1));
 
-        ui::ShaderManager::use(kShader::TextureAlphaSep);
-        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_int(kShaderUniform::TexA, 1);
-        ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
-        ui::ShaderManager::u_int(kShaderUniform::Highlight, false);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+        ShaderManager::use(kShader::TextureAlphaSep);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_int(kShaderUniform::TexA, 1);
+        ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
+        ShaderManager::u_int(kShaderUniform::Highlight, false);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
             
             
         glEnable(GL_BLEND);
@@ -286,19 +286,19 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
         m_sampler.bind(1);
         m_sampler.bind(2);
         auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
-        ui::ShaderManager::use(kShader::CompDraw);
-        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-        //ui::ShaderManager::u_int(kShaderUniform::TexA, 0);
-        ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-        ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-        //ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
-        //ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3);
-        ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
-        ui::ShaderManager::u_int(kShaderUniform::Lock, m_layers[layer_index].m_alpha_locked);
-        ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
-        ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-        ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+        ShaderManager::use(kShader::CompDraw);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        //ShaderManager::u_int(kShaderUniform::TexA, 0);
+        ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+        ShaderManager::u_int(kShaderUniform::TexMask, 2);
+        //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
+        //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
+        ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
+        ShaderManager::u_int(kShaderUniform::Lock, m_layers[layer_index].m_alpha_locked);
+        ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
+        ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+        ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
         glActiveTexture(GL_TEXTURE0);
         m_layers[layer_index].m_rtt[plane_index].bindTexture();
         glActiveTexture(GL_TEXTURE1);
@@ -320,7 +320,7 @@ void ui::Canvas::stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz
     m_mixer.unbindFramebuffer();
     glDisable(GL_SCISSOR_TEST);
 }
-void ui::Canvas::stroke_draw()
+void Canvas::stroke_draw()
 {
     if (!(m_current_stroke && m_current_stroke->has_sample()))
     {
@@ -409,7 +409,7 @@ void ui::Canvas::stroke_draw()
         m_mixer.bindTexture();
 
         glDisable(GL_BLEND);
-        ShaderManager::use(ui::kShader::Stroke);
+        ShaderManager::use(kShader::Stroke);
         ShaderManager::u_int(kShaderUniform::Tex, 0); // brush
 #ifndef __IOS__
         ShaderManager::u_int(kShaderUniform::TexBG, 1); // bg
@@ -523,7 +523,7 @@ void ui::Canvas::stroke_draw()
                 glm::max(zw(m_dirty_box[i]), (glm::vec2)(tex_pos + tex_sz))
                 );
                 
-            ShaderManager::use(ui::kShader::Stroke);
+            ShaderManager::use(kShader::Stroke);
             ShaderManager::u_mat4(kShaderUniform::MVP, ortho_proj);
             ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(s.col, m_brush.m_tip_color.a));
             ShaderManager::u_float(kShaderUniform::Alpha, s.flow);
@@ -592,7 +592,7 @@ void ui::Canvas::stroke_draw()
         m_commit_delayed = false;
     }
 }
-bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
+bool Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
     glm::vec3& hit_pos, glm::vec2& fb_pos, glm::vec3& hit_normal, int& out_plane_id)
 {
     point_unproject(loc, { 0, 0, zw(m_box) }, m_mv, m_proj, ray_origin, ray_dir);
@@ -620,7 +620,7 @@ bool ui::Canvas::point_trace(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ra
     return false;
 }
 /*
-bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2& hit_fb_pos, int plane_id)
+bool Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2& hit_fb_pos, int plane_id)
 {
     auto ln = (loc / zw(m_box)) * 2.f - 1.f;
     auto p = m_plane_unproject[plane_id] * glm::vec4(ln, 1, 1);
@@ -632,7 +632,7 @@ bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& hit_pos, glm::vec2&
     return false;
 }
 */
-bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
+bool Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::vec3& ray_dir,
     glm::vec3& hit_pos, glm::vec3& hit_normal, glm::vec2& hit_fb_pos, int plane_id)
 {
 /*
@@ -661,7 +661,7 @@ bool ui::Canvas::point_trace_plane(glm::vec2 loc, glm::vec3& ray_origin, glm::ve
     }
     return false;
 }
-void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
+void Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
     glm::vec3& out_origin, glm::vec3& out_dir)
 {
     auto clip_space = glm::vec2(loc.x, vp.w - loc.y - 1.f) / zw(vp) * 2.f - 1.f;
@@ -671,7 +671,7 @@ void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera,
     out_origin = xyz(wp0 / wp0.w);
     out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin);
 };
-void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3& out_dir)
+void Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3& out_dir)
 {
     auto clip_space = glm::vec2(loc.x, m_vp.w - loc.y - 1.f) / zw(m_vp) * 2.f - 1.f;
     auto inv = glm::inverse(m_proj * m_mv);
@@ -680,7 +680,7 @@ void ui::Canvas::point_unproject(glm::vec2 loc, glm::vec3& out_origin, glm::vec3
     out_origin = xyz(wp0 / wp0.w);
     out_dir = glm::normalize(xyz(wp1 / wp1.w) - out_origin);
 }
-glm::vec3 ui::Canvas::point_trace(glm::vec2 loc)
+glm::vec3 Canvas::point_trace(glm::vec2 loc)
 {
     glm::vec3 ray_origin;
     glm::vec3 ray_dir;
@@ -692,7 +692,7 @@ glm::vec3 ui::Canvas::point_trace(glm::vec2 loc)
         return hit_pos;
     return glm::vec3(0);
 }
-void ui::Canvas::stroke_commit()
+void Canvas::stroke_commit()
 {
     if (!m_dirty || m_layers.empty())
         return;
@@ -759,12 +759,12 @@ void ui::Canvas::stroke_commit()
         m_sampler_stencil.bind(3);
         if (m_state == kCanvasMode::Erase)
         {
-            ui::ShaderManager::use(kShader::CompErase);
-            ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-            ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-            //ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-            ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-            ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
+            ShaderManager::use(kShader::CompErase);
+            ShaderManager::u_int(kShaderUniform::Tex, 0);
+            ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+            //ShaderManager::u_int(kShaderUniform::TexMask, 2);
+            ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+            ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
             ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
 
             glActiveTexture(GL_TEXTURE0);
@@ -784,16 +784,16 @@ void ui::Canvas::stroke_commit()
         {
             auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
 
-            ui::ShaderManager::use(kShader::CompDraw);
-            ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-            ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-            ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-            //ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
-            ui::ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
-            ui::ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
-            ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-            ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
-            ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+            ShaderManager::use(kShader::CompDraw);
+            ShaderManager::u_int(kShaderUniform::Tex, 0);
+            ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+            ShaderManager::u_int(kShaderUniform::TexMask, 2);
+            //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
+            ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
+            ShaderManager::u_int(kShaderUniform::Mask, m_smask_active);
+            ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+            ShaderManager::u_int(kShaderUniform::BlendMode, m_current_stroke->m_brush.m_blend_mode);
+            ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
 
             glActiveTexture(GL_TEXTURE0);
             m_tex2[i].bind();
@@ -814,7 +814,7 @@ void ui::Canvas::stroke_commit()
         }
 //        else
 //        {
-//            ShaderManager::use(ui::kShader::StrokeLayer);
+//            ShaderManager::use(kShader::StrokeLayer);
 //            ShaderManager::u_int(kShaderUniform::TexBG, 1);
 //            ShaderManager::u_int(kShaderUniform::Lock, m_layers[m_current_layer_idx].m_alpha_locked);
 //            ShaderManager::u_float(kShaderUniform::Alpha, m_current_stroke->m_brush.m_tip_opacity);
@@ -843,11 +843,11 @@ void ui::Canvas::stroke_commit()
     action->m_stroke = std::move(m_current_stroke);
     ActionManager::add(action);
 }
-void ui::Canvas::stroke_update(glm::vec3 point, float pressure)
+void Canvas::stroke_update(glm::vec3 point, float pressure)
 {
     m_current_stroke->add_point(point, pressure);
 }
-void ui::Canvas::stroke_start(glm::vec3 point, float pressure, const ui::Brush& brush)
+void Canvas::stroke_start(glm::vec3 point, float pressure, const Brush& brush)
 {
     // need to commit this now before starting a new stroke
     if (m_current_stroke && m_commit_delayed)
@@ -888,7 +888,7 @@ void ui::Canvas::stroke_start(glm::vec3 point, float pressure, const ui::Brush&
     }
     m_show_tmp = true;
 }
-void ui::Canvas::layer_add(std::string name)
+void Canvas::layer_add(std::string name)
 {
     int idx = (int)m_layers.size();
     m_layers.emplace_back();
@@ -896,7 +896,7 @@ void ui::Canvas::layer_add(std::string name)
     m_order.push_back(idx);
     m_current_layer_idx = idx;
 }
-void ui::Canvas::layer_remove(int idx) // m_order index
+void Canvas::layer_remove(int idx) // m_order index
 {
     int n = m_order[idx];
     for (auto& i : m_order)
@@ -906,11 +906,11 @@ void ui::Canvas::layer_remove(int idx) // m_order index
     m_order.erase(m_order.begin() + idx);
     m_current_layer_idx = m_order[std::min<int>((int)m_layers.size() - 1, idx)];
 }
-void ui::Canvas::layer_order(int idx, int pos) // m_order index
+void Canvas::layer_order(int idx, int pos) // m_order index
 {
     std::swap(m_order[idx], m_order[pos]);
 }
-void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
+void Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
 {
     m_dirty = false;
 
@@ -962,15 +962,15 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
         m_sampler.bind(0);
         m_sampler_bg.bind(1);
         {
-            ui::ShaderManager::use(kShader::CompDraw);
-            ui::ShaderManager::u_int(kShaderUniform::Tex, 0); // dest
-            ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source
-            //ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, m_size);
-            ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-            ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
-            ui::ShaderManager::u_int(kShaderUniform::Lock, false);
-            ui::ShaderManager::u_int(kShaderUniform::BlendMode, 0); // TODO: defaulted to normal, change to layer blend mode when implemented
-            ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+            ShaderManager::use(kShader::CompDraw);
+            ShaderManager::u_int(kShaderUniform::Tex, 0); // dest
+            ShaderManager::u_int(kShaderUniform::TexStroke, 1); // source
+            //ShaderManager::u_vec2(kShaderUniform::Resolution, m_size);
+            ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+            ShaderManager::u_float(kShaderUniform::Alpha, m_layers[source_idx].m_opacity);
+            ShaderManager::u_int(kShaderUniform::Lock, false);
+            ShaderManager::u_int(kShaderUniform::BlendMode, 0); // TODO: defaulted to normal, change to layer blend mode when implemented
+            ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
 
             glActiveTexture(GL_TEXTURE0);
             m_tex2[i].bind();
@@ -999,7 +999,7 @@ void ui::Canvas::layer_merge(int source_idx, int dest_idx) // m_layer index
     ActionManager::add(action);
 */
 }
-void ui::Canvas::resize(int width, int height)
+void Canvas::resize(int width, int height)
 {
     m_width = width;
     m_height = height;
@@ -1020,7 +1020,7 @@ void ui::Canvas::resize(int width, int height)
     m_smask.create(width, height, "mask");
     m_unsaved = true;
 }
-bool ui::Canvas::create(int width, int height)
+bool Canvas::create(int width, int height)
 {
     m_width = width;
     m_height = height;
@@ -1059,7 +1059,7 @@ bool ui::Canvas::create(int width, int height)
     return true;
 }
 
-void ui::Canvas::snapshot_save()
+void Canvas::snapshot_save()
 {
     LOG("SAVE SNAPSHOT");
     m_layers_snapshot.clear();
@@ -1068,7 +1068,7 @@ void ui::Canvas::snapshot_save()
         m_layers_snapshot[i] = m_layers[i].snapshot();
 }
 
-void ui::Canvas::snapshot_restore()
+void Canvas::snapshot_restore()
 {
     LOG("RESTORE SNAPSHOT");
     for (int i = 0; i < m_layers.size(); i++)
@@ -1076,7 +1076,7 @@ void ui::Canvas::snapshot_restore()
     m_layers_snapshot.clear();
 }
 
-void ui::Canvas::clear_context()
+void Canvas::clear_context()
 {
     LOG("Canvas CLEAR CONTEXT");
     for (auto& layer : m_layers)
@@ -1089,13 +1089,13 @@ void ui::Canvas::clear_context()
     }
 };
 
-void ui::Canvas::import_equirectangular(std::string file_path)
+void Canvas::import_equirectangular(std::string file_path)
 {
-    std::thread t(&ui::Canvas::import_equirectangular_thread, this, file_path);
+    std::thread t(&Canvas::import_equirectangular_thread, this, file_path);
     t.detach();
 }
 
-void ui::Canvas::import_equirectangular_thread(std::string file_path)
+void Canvas::import_equirectangular_thread(std::string file_path)
 {
     App::I.async_start();
     
@@ -1115,14 +1115,14 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
         static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 };
         tex.create(img.width, img.width, iformats[img.comp - 1], formats[img.comp - 1]);
         int stride = img.width * img.width * img.comp;
-        ui::Plane plane;
+        Plane plane;
         plane.create<1>(2, 2);
         draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
             tex.update(img.m_data.get() + indices[i] * stride);
             m_sampler.bind(0);
             glActiveTexture(GL_TEXTURE0);
             tex.bind();
-            ShaderManager::use(ui::kShader::Texture);
+            ShaderManager::use(kShader::Texture);
             ShaderManager::u_int(kShaderUniform::Tex, 0);
             ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(-1, -1, 1)));
             plane.draw_fill();
@@ -1134,14 +1134,14 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
     {
         Texture2D tex;
         tex.load_file(file_path);
-        ui::Sphere sphere;
+        Sphere sphere;
         glDisable(GL_DEPTH_TEST);
         sphere.create<64, 64>(2.f);
         draw_objects([&](const glm::mat4& camera, const glm::mat4& proj, int i) {
             m_sampler.bind(0);
             glActiveTexture(GL_TEXTURE0);
             tex.bind();
-            ShaderManager::use(ui::kShader::Texture);
+            ShaderManager::use(kShader::Texture);
             ShaderManager::u_int(kShaderUniform::Tex, 0);
             ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera *
                 glm::eulerAngleY(glm::radians(180.f)) * glm::scale(glm::vec3(1, -1, 1)));
@@ -1160,7 +1160,7 @@ void ui::Canvas::import_equirectangular_thread(std::string file_path)
     App::I.async_end();
 }
 
-void ui::Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete)
+void Canvas::export_equirectangular(std::string file_path, std::function<void()> on_complete)
 {
     if (App::I.check_license())
     {
@@ -1173,7 +1173,7 @@ void ui::Canvas::export_equirectangular(std::string file_path, std::function<voi
     }
 }
 
-void ui::Canvas::export_equirectangular_thread(std::string file_path)
+void Canvas::export_equirectangular_thread(std::string file_path)
 {
     gl_state gl;
 
@@ -1226,7 +1226,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
 
     for (int i = 0; i < 6; i++)
     {
-        ShaderManager::use(ui::kShader::TextureAlpha);
+        ShaderManager::use(kShader::TextureAlpha);
         ShaderManager::u_int(kShaderUniform::Highlight, false);
         ShaderManager::u_int(kShaderUniform::Tex, 0);
         ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
@@ -1279,9 +1279,9 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
     glViewport(0, 0, m_latlong.getWidth(), m_latlong.getHeight());
     glActiveTexture(GL_TEXTURE0);
     m_latlong.bindFramebuffer();
-    ui::ShaderManager::use(kShader::Equirect);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::use(kShader::Equirect);
+    ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
     glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
     m_sampler_mask.bind(0);
     m_plane.draw_fill();
@@ -1360,7 +1360,7 @@ void ui::Canvas::export_equirectangular_thread(std::string file_path)
     App::I.async_end();
 }
 
-void ui::Canvas::inject_xmp(std::string jpg_path)
+void Canvas::inject_xmp(std::string jpg_path)
 {
     static const char xmp[] = 
 "http://ns.adobe.com/xap/1.0/\0" R"(<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
@@ -1408,7 +1408,7 @@ void ui::Canvas::inject_xmp(std::string jpg_path)
 
 }
 
-void ui::Canvas::export_anim()
+void Canvas::export_anim()
 {
     if (!App::I.check_license())
         return;
@@ -1450,8 +1450,8 @@ void ui::Canvas::export_anim()
             if (seq == 0)
             {
                 m_tmp[i].clear({ 1, 1, 1, 1 });
-                ui::ShaderManager::use(kShader::Checkerboard);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+                ShaderManager::use(kShader::Checkerboard);
+                ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
                 m_plane.draw_fill();
                 glEnable(GL_BLEND);
             }
@@ -1462,7 +1462,7 @@ void ui::Canvas::export_anim()
             }
 
             glActiveTexture(GL_TEXTURE0);
-            ShaderManager::use(ui::kShader::TextureAlpha);
+            ShaderManager::use(kShader::TextureAlpha);
             ShaderManager::u_float(kShaderUniform::Alpha, 1);
             ShaderManager::u_int(kShaderUniform::Highlight, false);
             ShaderManager::u_int(kShaderUniform::Tex, 0);
@@ -1487,9 +1487,9 @@ void ui::Canvas::export_anim()
         glActiveTexture(GL_TEXTURE0);
         m_latlong.bindFramebuffer();
         m_latlong.clear({ 1, 1, 1, 0 });
-        ui::ShaderManager::use(kShader::Equirect);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
-        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::use(kShader::Equirect);
+        ShaderManager::u_mat4(kShaderUniform::MVP, glm::ortho(-.5f, .5f, -.5f, .5f, -1.f, 1.f));
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
         glBindTexture(GL_TEXTURE_CUBE_MAP, cube_id);
         glDisable(GL_BLEND);
         m_sampler_mask.bind(0);
@@ -1521,7 +1521,7 @@ void ui::Canvas::export_anim()
     glActiveTexture(GL_TEXTURE0);
 }
 
-void ui::Canvas::export_cubes()
+void Canvas::export_cubes()
 {
     if (!App::I.check_license())
         return;
@@ -1603,7 +1603,7 @@ void ui::Canvas::export_cubes()
 #endif
 }
 
-void ui::Canvas::project_save(std::function<void(bool)> on_complete)
+void Canvas::project_save(std::function<void(bool)> on_complete)
 {
     if (App::I.check_license())
     {
@@ -1616,7 +1616,7 @@ void ui::Canvas::project_save(std::function<void(bool)> on_complete)
     }
 }
 
-void ui::Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete)
+void Canvas::project_save(std::string file_path, std::function<void(bool)> on_complete)
 {
     if (App::I.check_license())
     {
@@ -1629,7 +1629,7 @@ void ui::Canvas::project_save(std::string file_path, std::function<void(bool)> o
     }
 }
 
-bool ui::Canvas::project_save_thread(std::string file_path)
+bool Canvas::project_save_thread(std::string file_path)
 {
     gl_state gl;
 
@@ -1794,7 +1794,7 @@ bool ui::Canvas::project_save_thread(std::string file_path)
     return success;
 }
 
-void ui::Canvas::project_open(std::string file_path, std::function<void(bool)> on_complete)
+void Canvas::project_open(std::string file_path, std::function<void(bool)> on_complete)
 {
     std::thread t([=] {
         bool result = project_open_thread(file_path);
@@ -1804,7 +1804,7 @@ void ui::Canvas::project_open(std::string file_path, std::function<void(bool)> o
     t.detach();
 }
 
-bool ui::Canvas::project_open_thread(std::string file_path)
+bool Canvas::project_open_thread(std::string file_path)
 {
     FILE* fp = fopen(file_path.c_str(), "rb");
     if (!fp)
@@ -1958,7 +1958,7 @@ bool ui::Canvas::project_open_thread(std::string file_path)
     return true;
 }
 
-ui::Image ui::Canvas::thumbnail_generate(int w, int h)
+Image Canvas::thumbnail_generate(int w, int h)
 {
     
     // save viewport and clear color states
@@ -1975,7 +1975,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
     fb.create(w, h);
     fb.bindFramebuffer();
     fb.clear({ 1, 1, 1, 1 });
-    ui::Plane m_face_plane;
+    Plane m_face_plane;
     m_face_plane.create<1>(2, 2);
 
     // recalculate because of different aspect ratio than the m_proj matrix
@@ -1986,17 +1986,17 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
     {
         auto plane_mvp = proj * m_mv * m_plane_transform[plane_index] * glm::translate(glm::vec3(0, 0, -1));
 
-        ui::ShaderManager::use(kShader::Checkerboard);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+        ShaderManager::use(kShader::Checkerboard);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
         m_face_plane.draw_fill();
 
-        ui::ShaderManager::use(kShader::TextureAlpha);
-        ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_int(kShaderUniform::Highlight, false);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+        ShaderManager::use(kShader::TextureAlpha);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_int(kShaderUniform::Highlight, false);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
         for (auto layer_index : m_order)
         {
-            ui::ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
+            ShaderManager::u_float(kShaderUniform::Alpha, m_layers[layer_index].m_opacity);
             m_layers[layer_index].m_rtt[plane_index].bindTexture();
             m_face_plane.draw_fill();
             m_layers[layer_index].m_rtt[plane_index].unbindTexture();
@@ -2006,7 +2006,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
     fb.unbindFramebuffer();
 
     // read the rendered image
-    ui::Image image;
+    Image image;
     image.create(w, h);
     fb.readTextureData((uint8_t*)image.data());
 
@@ -2021,7 +2021,7 @@ ui::Image ui::Canvas::thumbnail_generate(int w, int h)
     return image;
 }
 
-ui::Image ui::Canvas::thumbnail_read(std::string file_path)
+Image Canvas::thumbnail_read(std::string file_path)
 {
 //     static char name[128];
 //     sprintf(name, "%s/latlong.ppi", data_path.c_str());
@@ -2048,7 +2048,7 @@ ui::Image ui::Canvas::thumbnail_read(std::string file_path)
     return thumb;
 }
 
-void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer)
+void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer, Layer& layer)
 {
     // save viewport and clear color states
     GLint vp[4];
@@ -2079,12 +2079,12 @@ void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const
     glActiveTexture(GL_TEXTURE0);
 }
 
-void ui::Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer)
+void Canvas::draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)> observer)
 {
     draw_objects(observer, m_layers[m_current_layer_idx]);
 }
 
-void ui::Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
+void Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
 {
     for (auto& p : vertices)
     {
@@ -2096,7 +2096,7 @@ void ui::Canvas::project2Dpoints(std::vector<vertex_t>& vertices)
     }
 }
 
-glm::vec3 ui::Canvas::project2Dpoint(glm::vec2 pt)
+glm::vec3 Canvas::project2Dpoint(glm::vec2 pt)
 {
     glm::vec3 ro, rd, hit_o, hit_d;
     glm::vec2 hit_fb;
@@ -2110,7 +2110,7 @@ glm::vec3 ui::Canvas::project2Dpoint(glm::vec2 pt)
 
 // return the 2d shape of the faces based on the current camera
 // this can be used for screen space shapes clipping
-std::vector<glm::vec2> ui::Canvas::face_to_shape2D(int plane_index)
+std::vector<glm::vec2> Canvas::face_to_shape2D(int plane_index)
 {
     static std::array<glm::vec4, 4> corners{
         glm::vec4(-1.f, +1.f, -1.f, 1.f), // A top-left
@@ -2143,12 +2143,12 @@ std::vector<glm::vec2> ui::Canvas::face_to_shape2D(int plane_index)
     return points;
 }
 
-void ui::Canvas::push_camera()
+void Canvas::push_camera()
 {
     m_camera_stack.push(get_camera());
 }
 
-void ui::Canvas::pop_camera()
+void Canvas::pop_camera()
 {
     if (!m_camera_stack.empty())
     {
@@ -2157,7 +2157,7 @@ void ui::Canvas::pop_camera()
     }
 }
 
-ui::Canvas::CameraData ui::Canvas::get_camera()
+CameraData Canvas::get_camera()
 {
     CameraData c;
     c.m_box = m_box;
@@ -2170,7 +2170,7 @@ ui::Canvas::CameraData ui::Canvas::get_camera()
     return c;
 }
 
-void ui::Canvas::set_camera(const ui::Canvas::CameraData& c)
+void Canvas::set_camera(const CameraData& c)
 {
     m_box = c.m_box;
     m_mv = c.m_mv;
@@ -2181,11 +2181,11 @@ void ui::Canvas::set_camera(const ui::Canvas::CameraData& c)
     m_vp = c.m_vp;
 }
 
-void ui::Canvas::reset_camera()
+void Canvas::reset_camera()
 {
 }
 
-std::vector<vertex_t> ui::Canvas::triangulate_simple(const std::vector<vertex_t>& vertices)
+std::vector<vertex_t> Canvas::triangulate_simple(const std::vector<vertex_t>& vertices)
 {
     std::vector<vertex_t> ret;
     std::vector<p2t::Point> points(vertices.size());
@@ -2212,7 +2212,7 @@ std::vector<vertex_t> ui::Canvas::triangulate_simple(const std::vector<vertex_t>
     return ret;
 }
 
-std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<glm::vec2>& points)
+std::vector<vertex_t> Canvas::triangulate(const std::vector<glm::vec2>& points)
 {
     std::vector<vertex_t> tmp;
     for (auto pt : points)
@@ -2220,7 +2220,7 @@ std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<glm::vec2>& poin
     return triangulate(tmp);
 }
 
-std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<vertex_t>& points)
+std::vector<vertex_t> Canvas::triangulate(const std::vector<vertex_t>& points)
 {
     struct Segment
     {
@@ -2355,13 +2355,13 @@ std::vector<vertex_t> ui::Canvas::triangulate(const std::vector<vertex_t>& point
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-void ui::Layer::destroy()
+void Layer::destroy()
 {
     for (int i = 0; i < 6; i++)
         m_rtt[i].destroy();
 }
 
-void ui::Layer::restore(const Snapshot& snap)
+void Layer::restore(const Snapshot& snap)
 {
     //clear({ 0, 0, 0, 0 });
     for (int i = 0; i < 6; i++)
@@ -2389,7 +2389,7 @@ void ui::Layer::restore(const Snapshot& snap)
     }
 }
 
-ui::Layer::Snapshot ui::Layer::snapshot()
+Layer::Snapshot Layer::snapshot()
 {
     Snapshot snap;
     static int counter = 0;
@@ -2416,7 +2416,7 @@ ui::Layer::Snapshot ui::Layer::snapshot()
     return snap;
 }
 
-void ui::Layer::clear(const glm::vec4& c)
+void Layer::clear(const glm::vec4& c)
 {
     // push clear color state
     GLfloat cc[4];
@@ -2447,7 +2447,7 @@ void ui::Layer::clear(const glm::vec4& c)
     glClearColor(cc[0], cc[1], cc[2], cc[3]);
 }
 
-bool ui::Layer::create(int width, int height, std::string name)
+bool Layer::create(int width, int height, std::string name)
 {
     m_name = name;
     w = width;
@@ -2464,7 +2464,7 @@ bool ui::Layer::create(int width, int height, std::string name)
     return true;
 }
 
-void ui::Layer::resize(int width, int height)
+void Layer::resize(int width, int height)
 {
     glm::vec2 ratio = glm::vec2(width, height) / glm::vec2(w, h);
     w = width;
diff --git a/src/canvas.h b/src/canvas.h
index 84b07df..cb12c43 100644
--- a/src/canvas.h
+++ b/src/canvas.h
@@ -8,8 +8,6 @@
 #include "canvas_modes.h"
 #include <stack>
 
-NS_START
-
 #define CANVAS_RES 512
 
 class Layer
@@ -101,17 +99,6 @@ struct PPIHeader
     }
 };
 
-struct CameraData
-{
-    glm::mat4 m_mv{ 1 };
-    glm::mat4 m_proj{ 1 };
-    glm::vec4 m_box{ 0 };
-    glm::vec4 m_vp{ 0 };
-    glm::vec2 m_pan{ 0 };
-    glm::mat4 m_plane_unproject[6] = SIXPLETTE(glm::mat4(1));
-    glm::vec3 m_plane_dir[6] = SIXPLETTE(glm::vec3(0));
-};
-
 class Canvas
 {
 public:
@@ -153,7 +140,7 @@ public:
     RTT m_tmp[6];
     RTT m_mixer;
     float m_mixer_scale = 1;
-    ui::StrokeSample m_mixer_sample;
+    StrokeSample m_mixer_sample;
     bool m_mixer_idle = true;
     Texture2D m_brush_mix;
     Texture2D m_tex[6];
@@ -206,7 +193,7 @@ public:
     void layer_add(std::string name);
     void layer_order(int idx, int pos);
     void layer_merge(int source_idx, int dest_idx);
-    void stroke_start(glm::vec3 point, float pressure, const ui::Brush& brush);
+    void stroke_start(glm::vec3 point, float pressure, const Brush& brush);
     void stroke_update(glm::vec3 point, float pressure);
     void stroke_draw_mix(const glm::vec2& bb_min, const glm::vec2& bb_sz);
     void stroke_draw();
@@ -236,8 +223,8 @@ public:
     void project_open(std::string file_path, std::function<void(bool)> on_complete = nullptr);
     bool project_open_thread(std::string file_path);
     void inject_xmp(std::string jpg_path);
-    ui::Image thumbnail_generate(int w, int h);
-    ui::Image thumbnail_read(std::string file_path);
+    Image thumbnail_generate(int w, int h);
+    Image thumbnail_read(std::string file_path);
     void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>);
     void draw_objects(std::function<void(const glm::mat4& camera, const glm::mat4& proj, int i)>, Layer& layer);
     void point_unproject(glm::vec2 loc, glm::vec4 vp, glm::mat4 camera, glm::mat4 proj,
@@ -315,5 +302,3 @@ public:
     {
     }
 };
-
-NS_END
diff --git a/src/canvas_modes.cpp b/src/canvas_modes.cpp
index 3021b31..3427268 100644
--- a/src/canvas_modes.cpp
+++ b/src/canvas_modes.cpp
@@ -9,7 +9,7 @@
 #include "util.h"
 
 NodeCanvas* CanvasMode::node;
-ui::Canvas* CanvasMode::canvas; 
+Canvas* CanvasMode::canvas; 
 
 void CanvasModeBasicCamera::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
 {
@@ -191,10 +191,10 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
         auto pos = m_resizing ? m_size_pos_start : m_cur_pos;
         if (App::I.keys[(int)kKey::KeyAlt] && !m_resizing)
             pos.x = pos.x - canvas->m_current_brush.m_tip_size * 500.f;
-        ui::ShaderManager::use(ui::kShader::StrokePreview);
-        ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, canvas->m_current_brush.m_tip_flow);
-        float tip_scale_fix = 1.f / glm::tan(glm::radians(ui::Canvas::I->m_cam_fov * 0.5f));
+        ShaderManager::use(kShader::StrokePreview);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_float(kShaderUniform::Alpha, canvas->m_current_brush.m_tip_flow);
+        float tip_scale_fix = 1.f / glm::tan(glm::radians(Canvas::I->m_cam_fov * 0.5f));
         float tip_scale = canvas->m_current_brush.m_tip_size * 800.f * tip_scale_fix;
         float tip_angle = canvas->m_current_brush.m_tip_angle * (float)(M_PI * 2.0);
         glm::vec2 tip_offset = glm::vec2(0);
@@ -210,8 +210,8 @@ void CanvasModePen::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const
                 tip_color = glm::vec4(s.col, s.flow);
             }
         }
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, tip_color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
+        ShaderManager::u_vec4(kShaderUniform::Col, tip_color);
+        ShaderManager::u_mat4(kShaderUniform::MVP,
             glm::scale(glm::vec3(1, -1, 1)) *
             ortho *
             glm::translate(glm::vec3(pos + tip_offset, 0)) *
@@ -237,7 +237,7 @@ void CanvasModePen::leave()
 
 void CanvasModePen::enter()
 {
-    m_cur_pos = ui::Canvas::I->m_cur_pos;
+    m_cur_pos = Canvas::I->m_cur_pos;
     if (m_valid_brush)
     {
         canvas->m_current_brush = m_brush;
@@ -291,9 +291,9 @@ void CanvasModeLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
 {
     if (m_dragging)
     {
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, ortho);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, canvas->m_current_brush.m_tip_color);
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_mat4(kShaderUniform::MVP, ortho);
+        ShaderManager::u_vec4(kShaderUniform::Col, canvas->m_current_brush.m_tip_color);
         static glm::vec4 AB[2];
         AB[0] = { m_drag_start, 0, 1 };
         AB[1] = { m_drag_pos, 0, 1 };
@@ -402,9 +402,9 @@ void CanvasModeGrid::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
     {
         auto origin = l.o;
         auto dir = l.d;
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1});
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+        ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
         static glm::vec4 AB[2];
         AB[0] = {origin - dir * 10.f, 1};
         AB[1] = {origin + dir * 10.f, 1 };
@@ -421,9 +421,9 @@ void CanvasModeGrid::init()
 void CanvasModeGrid::commit()
 {
     auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj){
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 0, 0, 1});
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+        ShaderManager::u_vec4(kShaderUniform::Col, {1, 0, 0, 1});
         static glm::vec4 AB[2];
         AB[0] = {origin - dir * 10.f, 1};
         AB[1] = {origin + dir * 10.f, 1 };
@@ -497,9 +497,9 @@ void CanvasModeMaskFree::on_MouseEvent(MouseEvent* me, glm::vec2& loc)
                 //m_points2d = poly_intersect(poly_remove_duplicate(m_points2d), canvas->face_to_shape2D(0));
                 auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
                     //glEnable(GL_BLEND);
-                    ui::ShaderManager::use(ui::kShader::Color);
-                    ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-                    ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
+                    ShaderManager::use(kShader::Color);
+                    ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                    ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
                     m_shape.draw_fill();
                 };
                 // use m_shape to render the mask polygon
@@ -579,17 +579,17 @@ void CanvasModeMaskFree::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     {
         if (m_dragging)
         {
-            ui::ShaderManager::use(ui::kShader::Color);
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
-            ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
+            ShaderManager::use(kShader::Color);
+            ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
+            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
             //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
             m_shape.draw_stroke();
         }
         else
         {
-            ui::ShaderManager::use(ui::kShader::Color);
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-            ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
+            ShaderManager::use(kShader::Color);
+            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
             m_shape.draw_stroke();
         }
     }
@@ -621,9 +621,9 @@ void CanvasModeMaskLine::leave()
         {
             auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
                 //glEnable(GL_BLEND);
-                ui::ShaderManager::use(ui::kShader::Color);
-                ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-                ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
+                ShaderManager::use(kShader::Color);
+                ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+                ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
                 m_shape.draw_fill();
             };
             canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask);
@@ -715,17 +715,17 @@ void CanvasModeMaskLine::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     {
         if (m_active_tool)
         {
-            ui::ShaderManager::use(ui::kShader::Color);
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
-            ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
+            ShaderManager::use(kShader::Color);
+            ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(1,-1,1)) * ortho);
+            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
             //m_dragging ? m_shape.draw_stroke() : m_shape.draw_fill();
             m_shape.draw_stroke();
         }
         else
         {
-            ui::ShaderManager::use(ui::kShader::Color);
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-            ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
+            ShaderManager::use(kShader::Color);
+            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
             m_shape.draw_stroke();
         }
     }
@@ -743,9 +743,9 @@ void CanvasModeFill::leave()
     if (m_points.size() > 2)
     {
         auto drawer = [this](const glm::mat4& camera, const glm::mat4& proj) {
-            ui::ShaderManager::use(ui::kShader::Color);
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-            ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, {1, 1, 1, 1});
+            ShaderManager::use(kShader::Color);
+            ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+            ShaderManager::u_vec4(kShaderUniform::Col, {1, 1, 1, 1});
             m_shape.draw_fill();
         };
         canvas->draw_objects(std::bind(drawer, std::placeholders::_1, std::placeholders::_2), canvas->m_smask);
@@ -835,9 +835,9 @@ void CanvasModeFill::on_Draw(const glm::mat4& ortho, const glm::mat4& proj, cons
 {
     if (!m_points.empty())
     {
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, .25 });
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, .25 });
         m_dragging ? m_shape.draw_fill() : m_shape.draw_stroke();
     }
 }
@@ -906,7 +906,7 @@ void CanvasModeTransform::enter()
         return;
     }
 
-    auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)ui::Canvas::kCanvasMode::MaskFree][0]);
+    auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)Canvas::kCanvasMode::MaskFree][0]);
     canvas->m_smask_active = false;
     auto points = m->m_points2d;
 
@@ -1013,17 +1013,17 @@ void CanvasModeTransform::enter()
         glActiveTexture(GL_TEXTURE0);
 
         glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 0 });
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 0 });
 
-        auto action = new ui::ActionStroke;
+        auto action = new ActionStroke;
         action->was_saved = !canvas->m_unsaved;
 
         for (int i = 0; i < 6; i++)
         {
             auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]);
             auto mvp = proj * plane_camera * m_xform * m_xform_local;
-            ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, mvp);
+            ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
 
             layer.m_rtt[i].bindFramebuffer();
 
@@ -1102,28 +1102,28 @@ void CanvasModeTransform::leave()
     glActiveTexture(GL_TEXTURE0);
 
     glm::mat4 proj = glm::perspective(glm::radians(90.f), 1.f, .01f, 1000.f);
-    ui::ShaderManager::use(ui::kShader::CompDraw);
-    ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
-    ui::ShaderManager::u_int(ui::kShaderUniform::TexStroke, 1);
-    ui::ShaderManager::u_int(ui::kShaderUniform::TexMask, 2);
-    ui::ShaderManager::u_float(ui::kShaderUniform::Alpha, 1);
-    ui::ShaderManager::u_int(ui::kShaderUniform::Lock, false);
-    ui::ShaderManager::u_int(ui::kShaderUniform::Mask, false);
-    ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, true);
-    ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, canvas->m_size);
-    ui::ShaderManager::u_int(ui::kShaderUniform::BlendMode, 0);
+    ShaderManager::use(kShader::CompDraw);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+    ShaderManager::u_int(kShaderUniform::TexMask, 2);
+    ShaderManager::u_float(kShaderUniform::Alpha, 1);
+    ShaderManager::u_int(kShaderUniform::Lock, false);
+    ShaderManager::u_int(kShaderUniform::Mask, false);
+    ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, true);
+    ShaderManager::u_vec2(kShaderUniform::Resolution, canvas->m_size);
+    ShaderManager::u_int(kShaderUniform::BlendMode, 0);
 
     canvas->m_sampler_bg.bind(1);
     canvas->m_sampler_bg.bind(0);
 
-    auto action = new ui::ActionStroke;
+    auto action = new ActionStroke;
     action->was_saved = !canvas->m_unsaved;
 
     for (int i = 0; i < 6; i++)
     {
         auto plane_camera = glm::lookAt(glm::vec3(0), canvas->m_plane_origin[i], canvas->m_plane_tangent[i]);
         auto mvp = proj * plane_camera * m_xform * m_xform_local;
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, mvp);
+        ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
         
         layer.m_rtt[i].bindFramebuffer();
 
@@ -1188,7 +1188,7 @@ void CanvasModeTransform::leave()
     //action->m_stroke = std::move(m_current_stroke);
     ActionManager::add(action);
 
-    //auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)ui::Canvas::kCanvasMode::MaskFree][0]);
+    //auto m = static_cast<CanvasModeMaskFree*>(canvas->modes[(int)Canvas::kCanvasMode::MaskFree][0]);
     //m->clear();
 }
 
@@ -1200,14 +1200,14 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
     glEnable(GL_BLEND);
     for (int i = 0; i < 6; i++)
     {
-        ui::ShaderManager::use(ui::kShader::Color);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 1, 1, .1 });
+        ShaderManager::use(kShader::Color);
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 1, 1, .1 });
         m_shape[i].draw_fill();
 
-        ui::ShaderManager::use(ui::kShader::Texture);
-        ui::ShaderManager::u_int(ui::kShaderUniform::Tex, 0);
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
+        ShaderManager::use(kShader::Texture);
+        ShaderManager::u_int(kShaderUniform::Tex, 0);
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera * m_xform * m_xform_local);
         glActiveTexture(GL_TEXTURE0);
         m_tex[i].bind();
         canvas->m_sampler.bind(0);
@@ -1215,7 +1215,7 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
         m_tex[i].unbind();
     }
 
-    ui::ShaderManager::use(ui::kShader::Color);
+    ShaderManager::use(kShader::Color);
     auto m2d = canvas->m_proj * canvas->m_mv * m_xform * m_xform_local;
     for (int i = 0; i < corners.size(); i++)
     {
@@ -1225,15 +1225,15 @@ void CanvasModeTransform::on_Draw(const glm::mat4& ortho, const glm::mat4& proj,
             continue;
         auto c2d = (xy(c3d) * 0.5f + 0.5f) * zw(canvas->m_box);
 
-        ui::ShaderManager::u_mat4(ui::kShaderUniform::MVP,
+        ShaderManager::u_mat4(kShaderUniform::MVP,
             ortho * glm::translate(glm::vec3(c2d, 0)) * glm::scale(glm::vec3(20.f) * App::I.zoom));
 
         // draw inside
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f });
+        ShaderManager::u_vec4(kShaderUniform::Col, { 1, 1, 1, i == corner_hl ? 1.f : .1f });
         m_circle.draw_fill();
 
         // draw black border
-        ui::ShaderManager::u_vec4(ui::kShaderUniform::Col, { 0, 0, 0, 1 });
+        ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
         m_circle.draw_stroke();
     }
 
diff --git a/src/canvas_modes.h b/src/canvas_modes.h
index c9ebd9b..834a305 100644
--- a/src/canvas_modes.h
+++ b/src/canvas_modes.h
@@ -3,18 +3,26 @@
 #include "shape.h"
 #include "brush.h"
 #include "texture.h"
-#include "canvas.h"
 #include <poly2tri.h>
 
-// NS_START
-// class Canvas;
-// NS_END
+class Canvas;
+
+struct CameraData
+{
+    glm::mat4 m_mv{ 1 };
+    glm::mat4 m_proj{ 1 };
+    glm::vec4 m_box{ 0 };
+    glm::vec4 m_vp{ 0 };
+    glm::vec2 m_pan{ 0 };
+    glm::mat4 m_plane_unproject[6] = SIXPLETTE(glm::mat4(1));
+    glm::vec3 m_plane_dir[6] = SIXPLETTE(glm::vec3(0));
+};
 
 class CanvasMode
 {
 public:
     static class NodeCanvas* node;
-    static ui::Canvas* canvas;
+    static Canvas* canvas;
     virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) {}
     virtual void on_KeyEvent(KeyEvent* ke) {}
     virtual void on_GestureEvent(GestureEvent* ge) {}
@@ -53,7 +61,7 @@ class CanvasModePen : public CanvasMode
     float m_zoom_canvas = 1.f;
     float m_zoom_start;
     bool m_valid_brush = false;
-    ui::Brush m_brush;
+    Brush m_brush;
     // resizing the tip
     bool m_resizing = false;
 public:
@@ -67,7 +75,7 @@ public:
 
 class CanvasModeLine : public CanvasMode
 {
-    ui::LineSegment m_line;
+    LineSegment m_line;
     bool m_dragging = false;
     glm::vec2 m_drag_start;
     glm::vec2 m_drag_pos;
@@ -79,7 +87,7 @@ public:
 
 class CanvasModeGrid : public CanvasMode
 {
-    ui::LineSegment m_line;
+    LineSegment m_line;
     glm::vec3 origin;
     glm::vec3 dir;
     int m_plane_id;
@@ -105,7 +113,7 @@ public:
 
 class CanvasModeFill : public CanvasMode
 {
-    ui::DynamicShape m_shape;
+    DynamicShape m_shape;
     bool m_dragging = false;
     std::vector<vertex_t> m_points;
     std::map<int, int> m_dirty_planes;
@@ -119,11 +127,11 @@ public:
 class CanvasModeMaskFree : public CanvasMode
 {
     friend class CanvasModeTransform;
-    ui::DynamicShape m_shape;
+    DynamicShape m_shape;
     bool m_dragging = false;
     std::vector<vertex_t> m_points;
     std::vector<glm::vec2> m_points2d;
-    struct ui::CameraData m_selection_cam;
+    CameraData m_selection_cam;
 public:
     virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override;
     virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
@@ -134,7 +142,7 @@ public:
 
 class CanvasModeMaskLine : public CanvasMode
 {
-    ui::DynamicShape m_shape;
+    DynamicShape m_shape;
     bool m_dragging = false;
     std::vector<vertex_t> m_points;
     std::vector<glm::vec2> m_points2d;
@@ -150,9 +158,9 @@ public:
 
 class CanvasModeTransform : public CanvasMode
 {
-    ui::DynamicShape m_shape[6]{};
-    ui::Sphere m_sphere{};
-    ui::Circle m_circle{};
+    DynamicShape m_shape[6]{};
+    Sphere m_sphere{};
+    Circle m_circle{};
     Texture2D m_tex[6]{};
     glm::vec3 m_origin{0, 0, 1 };
     std::vector<glm::vec3> corners{};
@@ -178,7 +186,7 @@ class CanvasModeTransform : public CanvasMode
 public:
     enum class ActionType : uint8_t { Copy, Cut, Import };
     ActionType m_action;
-    ui::Image m_source_image;
+    Image m_source_image;
     CanvasModeTransform() = default;
     virtual void on_Draw(const glm::mat4& ortho, const glm::mat4& proj, const glm::mat4& camera) override;
     virtual void on_MouseEvent(MouseEvent* me, glm::vec2& loc) override;
diff --git a/src/image.cpp b/src/image.cpp
index b62531c..7a06d2e 100644
--- a/src/image.cpp
+++ b/src/image.cpp
@@ -5,8 +5,6 @@
 
 #include <stb/stb_image.h>
 
-using namespace ui;
-
 bool Image::load(std::string filename)
 {
     stbi_set_flip_vertically_on_load(false);
@@ -47,7 +45,7 @@ void Image::flip()
     std::swap(m_data, flipped);
 }
 
-ui::Image ui::Image::resize(int w, int h)
+Image Image::resize(int w, int h)
 {
     Image ret;
     ret.create(w, h);
diff --git a/src/image.h b/src/image.h
index 982d4e8..9c36757 100644
--- a/src/image.h
+++ b/src/image.h
@@ -1,7 +1,5 @@
 #pragma once
 
-namespace ui {
-
 class Image
 {
 public:
@@ -35,5 +33,3 @@ public:
     void create() { m_data = std::make_unique<uint8_t[]>(size()); }
     Image resize(int w, int h);
 };
-
-}
diff --git a/src/log.h b/src/log.h
index b46e315..143b747 100644
--- a/src/log.h
+++ b/src/log.h
@@ -17,7 +17,7 @@ public:
     bool m_running = false;
     bool m_error = false;
     std::thread m_thread;
-    ui::BlockingQueue<std::string> m_mq;
+    BlockingQueue<std::string> m_mq;
     CURL *curl = nullptr;
     CURLcode res;
     std::string readBuffer;
diff --git a/src/main.cpp b/src/main.cpp
index 522fd68..d238889 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -384,10 +384,10 @@ static void SetupExceptionHandler()
     BT_AddLogFile(wpath);
 
     BT_SetPreErrHandler([](INT_PTR){
-        if (ui::Canvas::I)
+        if (Canvas::I)
         {
             auto path = App::I.data_path + "/recovery.ppi";
-            ui::Canvas::I->project_save_thread(path);
+            Canvas::I->project_save_thread(path);
             static char abspath[MAX_PATH];
             GetFullPathNameA(path.c_str(), MAX_PATH, abspath, NULL);
             static char message[4096];
@@ -727,7 +727,7 @@ int main(int argc, char** argv)
                 if (a == Controller::Action::Press)
                 {
                     async_lock();
-                    ui::Canvas::I->stroke_start(vive->controllers[0].pos * 800.f, vive->controllers[0].axis[1].x, ui::Canvas::I->m_current_brush);
+                    Canvas::I->stroke_start(vive->controllers[0].pos * 800.f, vive->controllers[0].axis[1].x, Canvas::I->m_current_brush);
                     async_unlock();
                     controller_last_point = vive->controllers[0].pos * 800.f;
                     controller_points.clear();
@@ -737,7 +737,7 @@ int main(int argc, char** argv)
                 {
                     trigger_down = false;
                     async_lock();
-                    ui::Canvas::I->stroke_end();
+                    Canvas::I->stroke_end();
                     async_unlock();
                 }
             }
@@ -763,7 +763,7 @@ int main(int argc, char** argv)
                 if (glm::distance(p, controller_last_point) > 1)
                 {
                     async_lock();
-                    ui::Canvas::I->stroke_update(p, vive->controllers[0].axis[1].x);
+                    Canvas::I->stroke_update(p, vive->controllers[0].axis[1].x);
                     async_unlock();
                     controller_last_point = p;
                     App::I.redraw = true;
diff --git a/src/node_border.cpp b/src/node_border.cpp
index 659b509..80059fe 100644
--- a/src/node_border.cpp
+++ b/src/node_border.cpp
@@ -3,7 +3,7 @@
 #include "node_border.h"
 #include "shader.h"
 
-ui::Plane NodeBorder::m_plane;
+Plane NodeBorder::m_plane;
 
 NodeBorder::NodeBorder()
 {
@@ -60,14 +60,13 @@ void NodeBorder::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* a
 }
 void NodeBorder::draw()
 {
-    using namespace ui;
-    ui::ShaderManager::use(kShader::Color);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::use(kShader::Color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
 
     if (m_color.a > 0.f)
     {
         m_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
+        ShaderManager::u_vec4(kShaderUniform::Col, m_color);
         m_plane.draw_fill();
         glDisable(GL_BLEND);
     }
@@ -75,7 +74,7 @@ void NodeBorder::draw()
     if (m_thinkness > 0 && m_border_color.a > 0.f)
     {
         glLineWidth(m_thinkness);
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, m_border_color);
+        ShaderManager::u_vec4(kShaderUniform::Col, m_border_color);
         m_border_color.a < 1.f ? glEnable(GL_BLEND) : glDisable(GL_BLEND);
         m_plane.draw_stroke();
         glDisable(GL_BLEND);
diff --git a/src/node_border.h b/src/node_border.h
index 9a9440f..e7f5e05 100644
--- a/src/node_border.h
+++ b/src/node_border.h
@@ -5,7 +5,7 @@
 class NodeBorder : public Node
 {
 public:
-    static ui::Plane m_plane;
+    static Plane m_plane;
     glm::vec4 m_color{ 0, 0, 0, 1 };
     glm::vec4 m_border_color{ 1, 1, 1, 1 };
     float m_thinkness{ 0 };
diff --git a/src/node_canvas.cpp b/src/node_canvas.cpp
index 1fca42e..9480763 100644
--- a/src/node_canvas.cpp
+++ b/src/node_canvas.cpp
@@ -12,7 +12,7 @@ Node* NodeCanvas::clone_instantiate() const
 void NodeCanvas::init()
 {
     m_mouse_ignore = false;
-    m_canvas = std::make_unique<ui::Canvas>();
+    m_canvas = std::make_unique<Canvas>();
     m_canvas->create(CANVAS_RES, CANVAS_RES);
     m_canvas->m_unsaved = false;
     m_canvas->m_node = this;
@@ -26,8 +26,8 @@ void NodeCanvas::init()
     m_line.create();
     CanvasMode::node = this;
     CanvasMode::canvas = m_canvas.get();
-    for (int i = 0; i < (int)ui::Canvas::kCanvasMode::COUNT; i++)
-        for (auto m : ui::Canvas::modes[i])
+    for (int i = 0; i < (int)Canvas::kCanvasMode::COUNT; i++)
+        for (auto m : Canvas::modes[i])
             m->init();
 
     m_grid.create(1, 1, m_grid_divs);
@@ -45,8 +45,8 @@ void NodeCanvas::restore_context()
     m_canvas->snapshot_restore();
     CanvasMode::node = this;
     CanvasMode::canvas = m_canvas.get();
-    for (int i = 0; i < (int)ui::Canvas::kCanvasMode::COUNT; i++)
-        for (auto m : ui::Canvas::modes[i])
+    for (int i = 0; i < (int)Canvas::kCanvasMode::COUNT; i++)
+        for (auto m : Canvas::modes[i])
             m->init();
 }
 
@@ -60,7 +60,6 @@ void NodeCanvas::clear_context()
 
 void NodeCanvas::draw()
 {
-    using namespace ui;
     GLint vp[4];
     GLfloat cc[4];
     glGetIntegerv(GL_VIEWPORT, vp);
@@ -109,8 +108,8 @@ void NodeCanvas::draw()
             m_canvas->m_plane_transform[plane_index] * 
             glm::translate(glm::vec3(0, 0, -1));
 
-        ui::ShaderManager::use(kShader::Checkerboard);
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+        ShaderManager::use(kShader::Checkerboard);
+        ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
         m_face_plane.draw_fill();
     }
 
@@ -144,18 +143,18 @@ void NodeCanvas::draw()
                 m_canvas->m_plane_transform[plane_index] * 
                 glm::translate(glm::vec3(0, 0, -1));
             
-            if (m_canvas->m_current_stroke && m_canvas->m_state == ui::Canvas::kCanvasMode::Erase && m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
+            if (m_canvas->m_current_stroke && m_canvas->m_state == Canvas::kCanvasMode::Erase && m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
             {
                 m_sampler.bind(0);
-                ui::ShaderManager::use(kShader::CompErase);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-                //ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
-                ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-                //ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
-                //ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::CompErase);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+                //ShaderManager::u_int(kShaderUniform::TexMask, 2);
+                ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
+                ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+                //ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
+                //ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 glActiveTexture(GL_TEXTURE0);
                 m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
                 glActiveTexture(GL_TEXTURE1);
@@ -173,18 +172,18 @@ void NodeCanvas::draw()
             {
                 m_sampler.bind(0);
                 auto& paper = TextureManager::get(const_hash("data/paper.jpg"));
-                ui::ShaderManager::use(kShader::CompDraw);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexStroke, 1);
-                ui::ShaderManager::u_int(kShaderUniform::TexMask, 2);
-                //ui::ShaderManager::u_vec2(ui::kShaderUniform::Resolution, zw(m_canvas->m_box) / zoom);
-                //ui::ShaderManager::u_int(kShaderUniform::TexStencil, 3);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
-                ui::ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
-                ui::ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
-                ui::ShaderManager::u_int(ui::kShaderUniform::UseFragCoordUV2, false);
-                ui::ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_current_stroke->m_brush.m_blend_mode);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::CompDraw);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexStroke, 1);
+                ShaderManager::u_int(kShaderUniform::TexMask, 2);
+                //ShaderManager::u_vec2(kShaderUniform::Resolution, zw(m_canvas->m_box) / zoom);
+                //ShaderManager::u_int(kShaderUniform::TexStencil, 3);
+                ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_current_stroke->m_brush.m_tip_opacity);
+                ShaderManager::u_int(kShaderUniform::Lock, m_canvas->m_layers[layer_index].m_alpha_locked);
+                ShaderManager::u_int(kShaderUniform::Mask, m_canvas->m_smask_active);
+                ShaderManager::u_int(kShaderUniform::UseFragCoordUV2, false);
+                ShaderManager::u_int(kShaderUniform::BlendMode, m_canvas->m_current_stroke->m_brush.m_blend_mode);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 glActiveTexture(GL_TEXTURE0);
                 m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
                 glActiveTexture(GL_TEXTURE1);
@@ -206,12 +205,12 @@ void NodeCanvas::draw()
             {
                 m_sampler.bind(0);
                 m_sampler_linear.bind(1);
-                ui::ShaderManager::use(kShader::TextureAlphaSep);
-                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-                ui::ShaderManager::u_int(kShaderUniform::TexA, 1);
-                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
-                ui::ShaderManager::u_int(kShaderUniform::Highlight, m_canvas->m_layers[layer_index].m_hightlight);
-                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+                ShaderManager::use(kShader::TextureAlphaSep);
+                ShaderManager::u_int(kShaderUniform::Tex, 0);
+                ShaderManager::u_int(kShaderUniform::TexA, 1);
+                ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
+                ShaderManager::u_int(kShaderUniform::Highlight, m_canvas->m_layers[layer_index].m_hightlight);
+                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
                 
                 glActiveTexture(GL_TEXTURE0);
                 m_canvas->m_layers[layer_index].m_rtt[plane_index].bindTexture();
@@ -229,11 +228,11 @@ void NodeCanvas::draw()
 //            if (m_canvas->m_show_tmp && m_canvas->m_current_layer_idx == layer_index)
 //            {
 //                glDisable(GL_BLEND);
-//                ui::ShaderManager::use(kShader::TextureAlpha);
-//                ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-//                ui::ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
-//                ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
-//                ui::ShaderManager::u_float(kShaderUniform::Alpha, 1);
+//                ShaderManager::use(kShader::TextureAlpha);
+//                ShaderManager::u_int(kShaderUniform::Tex, 0);
+//                ShaderManager::u_float(kShaderUniform::Alpha, m_canvas->m_layers[layer_index].m_opacity);
+//                ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp_z);
+//                ShaderManager::u_float(kShaderUniform::Alpha, 1);
 //                m_canvas->m_tmp[plane_index].bindTexture();
 //                m_face_plane.draw_fill();
 //                m_canvas->m_tmp[plane_index].unbindTexture();
@@ -253,11 +252,11 @@ void NodeCanvas::draw()
                 m_canvas->m_plane_transform[plane_index] *
                 glm::translate(glm::vec3(0, 0, -1));
 
-            ui::ShaderManager::use(kShader::TextureAlpha);
-            ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-            ui::ShaderManager::u_float(kShaderUniform::Alpha, 0.5f);
-            ui::ShaderManager::u_int(kShaderUniform::Highlight, 0);
-            ui::ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
+            ShaderManager::use(kShader::TextureAlpha);
+            ShaderManager::u_int(kShaderUniform::Tex, 0);
+            ShaderManager::u_float(kShaderUniform::Alpha, 0.5f);
+            ShaderManager::u_int(kShaderUniform::Highlight, 0);
+            ShaderManager::u_mat4(kShaderUniform::MVP, plane_mvp);
             glActiveTexture(GL_TEXTURE0);
             m_canvas->m_smask.m_rtt[plane_index].bindTexture();
             m_face_plane.draw_fill();
@@ -276,8 +275,8 @@ void NodeCanvas::draw()
     }
     
     // keep drawing the grids
-    if (m_canvas->m_state != ui::Canvas::kCanvasMode::Grid)
-        for (auto& mode : ui::Canvas::modes[(int)ui::Canvas::kCanvasMode::Grid])
+    if (m_canvas->m_state != Canvas::kCanvasMode::Grid)
+        for (auto& mode : Canvas::modes[(int)Canvas::kCanvasMode::Grid])
             mode->on_Draw(ortho_proj, proj, camera);
 
 
@@ -287,7 +286,7 @@ void NodeCanvas::draw()
         glClear(GL_DEPTH_BUFFER_BIT);
 
         // DRAW GRIDS
-        ui::ShaderManager::use(kShader::Color);
+        ShaderManager::use(kShader::Color);
 
         // ground grid
         int grid_divs = glm::floor(App::I.grid->m_groud_scale->get_value() * 100);
@@ -298,10 +297,10 @@ void NodeCanvas::draw()
         }
         float grid_scale = m_grid_divs * 0.01f;
 
-        ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
+        ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
             glm::vec3(App::I.grid->m_groud_value->get_value()),
             App::I.grid->m_groud_opacity->get_value()));
-        ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
+        ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
             * glm::translate(glm::vec3(0, glm::pow(App::I.grid->m_groud_height->get_value() - 0.5f, 3), 0))
             * glm::eulerAngleX(glm::radians(90.f))
             * glm::scale(glm::vec3(grid_scale, grid_scale, 1))
@@ -315,10 +314,10 @@ void NodeCanvas::draw()
 
     // box grid
     // ceiling
-//     ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
+//     ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(
 //         glm::vec3(App::I.grid->m_groud_value->get_value()),
 //         App::I.grid->m_box_opacity->get_value()));
-//     ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
+//     ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera
 //         * glm::translate(glm::vec3(0, (App::I.grid->m_groud_height->get_value() + App::I.grid->m_box_height->get_value() - 0.5f) * 2.f, 0))
 //         * glm::eulerAngleX(glm::radians(90.f))
 //         * glm::scale(glm::vec3(grid_scale, grid_scale, 1))
@@ -326,16 +325,16 @@ void NodeCanvas::draw()
 //     m_grid.draw_stroke();
 
 
-    //ui::ShaderManager::use(kShader::Equirect);
-    //ui::ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(.5, .5, 1)));
-    //ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+    //ShaderManager::use(kShader::Equirect);
+    //ShaderManager::u_mat4(kShaderUniform::MVP, glm::scale(glm::vec3(.5, .5, 1)));
+    //ShaderManager::u_int(kShaderUniform::Tex, 0);
     //glBindTexture(GL_TEXTURE_CUBE_MAP, m_canvas->cube_id);
     //m_face_plane.draw_fill();
     //glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
 
-//         ui::ShaderManager::use(kShader::Color);
-//         ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
-//         ui::ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 0, 1 });
+//         ShaderManager::use(kShader::Color);
+//         ShaderManager::u_mat4(kShaderUniform::MVP, proj * camera);
+//         ShaderManager::u_vec4(kShaderUniform::Col, { 1, 0, 0, 1 });
 //         static glm::vec4 AB[4]{ {-.75, 0, -1, 1},{ -.75, 0, 1, 1 } };
 //         m_line.update_vertices(AB);
 //         m_line.draw_stroke();
@@ -379,9 +378,9 @@ kEventResult NodeCanvas::handle_event(Event* e)
     case kEventType::MouseMove:
         if (stylus_eraser != me->m_eraser)
         {
-            ui::Canvas::set_mode(me->m_eraser ?
-                ui::Canvas::kCanvasMode::Erase :
-                ui::Canvas::kCanvasMode::Draw);
+            Canvas::set_mode(me->m_eraser ?
+                Canvas::kCanvasMode::Erase :
+                Canvas::kCanvasMode::Draw);
             stylus_eraser = me->m_eraser;
         }
     case kEventType::MouseScroll:
@@ -396,7 +395,7 @@ kEventResult NodeCanvas::handle_event(Event* e)
         break;
     case kEventType::KeyDown:
         if (ke->m_key == kKey::KeyE)
-            ui::Canvas::set_mode(ui::Canvas::kCanvasMode::Erase);
+            Canvas::set_mode(Canvas::kCanvasMode::Erase);
         if (ke->m_key == kKey::AndroidBack)
             if (!ActionManager::empty())
                 ActionManager::undo();
@@ -404,29 +403,29 @@ kEventResult NodeCanvas::handle_event(Event* e)
         break;
     case kEventType::KeyUp:
         if (ke->m_key == kKey::KeyE)
-            ui::Canvas::set_mode(ui::Canvas::kCanvasMode::Draw);
+            Canvas::set_mode(Canvas::kCanvasMode::Draw);
         if (ke->m_key == kKey::KeyTab)
             App::I.toggle_ui();
         if (ke->m_key == kKey::KeyZ && App::I.keys[(int)kKey::KeyCtrl])
             App::I.keys[(int)kKey::KeyShift] ? ActionManager::redo() : ActionManager::undo();
         if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && !App::I.keys[(int)kKey::KeyShift])
         {
-            if (ui::Canvas::I->m_newdoc)
+            if (Canvas::I->m_newdoc)
             {
                 App::I.dialog_save();
             }
-            else if (ui::Canvas::I->m_unsaved)
+            else if (Canvas::I->m_unsaved)
             {
-                ui::Canvas::I->project_save();
+                Canvas::I->project_save();
             }
         }
         if (ke->m_key == kKey::KeyS && App::I.keys[(int)kKey::KeyCtrl] && App::I.keys[(int)kKey::KeyShift])
         {
-            if (ui::Canvas::I->m_newdoc)
+            if (Canvas::I->m_newdoc)
             {
                 App::I.dialog_save();
             }
-            else if (ui::Canvas::I->m_unsaved)
+            else if (Canvas::I->m_unsaved)
             {
                 App::I.dialog_save_ver();
             }
diff --git a/src/node_canvas.h b/src/node_canvas.h
index 1f57b9c..8dc8cf9 100644
--- a/src/node_canvas.h
+++ b/src/node_canvas.h
@@ -5,13 +5,13 @@
 class NodeCanvas : public Node
 {
 public:
-    std::unique_ptr<ui::Canvas> m_canvas;
+    std::unique_ptr<Canvas> m_canvas;
     Sampler m_sampler;
     Sampler m_sampler_linear;
     Sampler m_sampler_stencil;
-    ui::Plane m_face_plane;
-    ui::LineSegment m_line;
-    ui::Plane m_grid;
+    Plane m_face_plane;
+    LineSegment m_line;
+    Plane m_grid;
     int m_grid_divs = 30;
     virtual Node* clone_instantiate() const override;
     virtual void init() override;
diff --git a/src/node_color_quad.cpp b/src/node_color_quad.cpp
index a7457f0..2f65563 100644
--- a/src/node_color_quad.cpp
+++ b/src/node_color_quad.cpp
@@ -91,9 +91,8 @@ void NodeColorQuad::draw()
     auto pos = glm::clamp(m_value * sz, { 0, 0 }, sz);
     m_picker->SetPosition(pos - m_picker->GetSize() * .5f);
 
-    using namespace ui;
-    ui::ShaderManager::use(kShader::ColorQuad);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
-    ui::ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
+    ShaderManager::use(kShader::ColorQuad);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, glm::vec4(convert_rgb2hsv(glm::vec3(m_color)), 1));
     m_plane.draw_fill();
 }
diff --git a/src/node_colorwheel.cpp b/src/node_colorwheel.cpp
index 80ea4f8..52e35f0 100644
--- a/src/node_colorwheel.cpp
+++ b/src/node_colorwheel.cpp
@@ -28,9 +28,9 @@ void NodeColorWheel::init_controls()
 
 void NodeColorWheel::loaded()
 {
-    m_circle.create<64>(.5, .4, ui::Circle::kUVMapping::Tube);
+    m_circle.create<64>(.5, .4, Circle::kUVMapping::Tube);
     m_cur_hue.create<16>(.05, 0.04);
-    m_cur_quad.create<16>(.04, 0.03, ui::Circle::kUVMapping::Tube);
+    m_cur_quad.create<16>(.04, 0.03, Circle::kUVMapping::Tube);
 
     float quad_scale = glm::sin(glm::radians(45.f)) * 0.8f;
     m_quad.create<1>(quad_scale, quad_scale);
@@ -61,8 +61,6 @@ void NodeColorWheel::loaded()
 
 void NodeColorWheel::draw()
 {
-    using namespace ui;
-    
     glDisable(GL_BLEND);
     ShaderManager::use(kShader::ColorHue);
     ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp * glm::eulerAngleZ(glm::radians(-90.f)));
diff --git a/src/node_colorwheel.h b/src/node_colorwheel.h
index e9294ab..2a4657c 100644
--- a/src/node_colorwheel.h
+++ b/src/node_colorwheel.h
@@ -8,10 +8,10 @@
 class NodeColorWheel : public Node
 {
 public:
-    ui::Circle m_circle;
-    ui::Plane m_cur_hue;
-    ui::Circle m_cur_quad;
-    ui::Plane m_quad;
+    Circle m_circle;
+    Plane m_cur_hue;
+    Circle m_cur_quad;
+    Plane m_quad;
     NodeBorder* m_color_cur;
     glm::vec3 m_hsv;
     GLuint m_tri_vbo;
diff --git a/src/node_dialog_browse.cpp b/src/node_dialog_browse.cpp
index c79de91..5cf3896 100644
--- a/src/node_dialog_browse.cpp
+++ b/src/node_dialog_browse.cpp
@@ -135,7 +135,7 @@ void NodeDialogBrowse::init_list()
     {
         auto f_name = std::get<0>(f);
         auto f_path = std::get<1>(f);
-        ui::Image thumb = ui::Canvas::I->thumbnail_read(f_path);
+        Image thumb = Canvas::I->thumbnail_read(f_path);
         if (thumb.width == 0 || thumb.height == 0)
             continue;
 
diff --git a/src/node_dialog_cloud.cpp b/src/node_dialog_cloud.cpp
index fa6c85f..8621223 100644
--- a/src/node_dialog_cloud.cpp
+++ b/src/node_dialog_cloud.cpp
@@ -142,7 +142,7 @@ void NodeDialogCloud::load_thumbs_thread()
             std::string rgb;
             rgb.resize(Base64::DecodedLength(info[3]));
             Base64::Decode(info[3], &rgb);
-            ui::Image thumb;
+            Image thumb;
             thumb.create(width, height);
             thumb.copy_from((uint8_t*)rgb.data());
 
diff --git a/src/node_dialog_layer_rename.cpp b/src/node_dialog_layer_rename.cpp
index 7a4b511..bec72da 100644
--- a/src/node_dialog_layer_rename.cpp
+++ b/src/node_dialog_layer_rename.cpp
@@ -36,7 +36,7 @@ void NodeDialogLayerRename::init_controls()
 
 void NodeDialogLayerRename::loaded()
 {
-//    ui::Image thumb = ui::Canvas::I->thumbnail_read(data_path);
+//    Image thumb = Canvas::I->thumbnail_read(data_path);
 //    auto image_tex = find<NodeImageTexture>("thumb-tex");
 //    image_tex->tex.create(thumb);
 }
diff --git a/src/node_dialog_open.cpp b/src/node_dialog_open.cpp
index 944f4ad..f8e8024 100644
--- a/src/node_dialog_open.cpp
+++ b/src/node_dialog_open.cpp
@@ -81,7 +81,7 @@ void NodeDialogOpen::init_controls()
         node->on_selected = [&](NodeDialogOpenItem* target) {
             if (target == current)
                 return;
-            ui::Image thumb = ui::Canvas::I->thumbnail_read(target->m_path);
+            Image thumb = Canvas::I->thumbnail_read(target->m_path);
             auto image_tex = find<NodeImageTexture>("thumb-tex");
             image_tex->tex.destroy();
             image_tex->tex.create(thumb);
diff --git a/src/node_dialog_picker.cpp b/src/node_dialog_picker.cpp
index 27899e5..21cf5c4 100644
--- a/src/node_dialog_picker.cpp
+++ b/src/node_dialog_picker.cpp
@@ -25,7 +25,7 @@ void NodeColorPicker::init()
 void NodeColorPicker::draw()
 {
     NodeBorder::draw();
-//    glm::vec3 rgb = glm::vec3(ui::Canvas::I->m_current_brush.m_tip_color);
+//    glm::vec3 rgb = glm::vec3(Canvas::I->m_current_brush.m_tip_color);
 //    glm::vec3 hsv = convert_rgb2hsv(rgb);
 //    m_slider_h->m_value.x = hsv.x;
 //    m_slider_s->m_value.x = hsv.y;
diff --git a/src/node_dialog_resize.cpp b/src/node_dialog_resize.cpp
index 2a9bf5a..7e177f1 100644
--- a/src/node_dialog_resize.cpp
+++ b/src/node_dialog_resize.cpp
@@ -32,7 +32,7 @@ void NodeDialogResize::init_controls()
     btn_cancel = find<NodeButton>("btn-cancel");
     combo = find<NodeComboBox>("resolution");
     text = find<NodeText>("current-res");
-    resolution = ui::Canvas::I->m_width;
+    resolution = Canvas::I->m_width;
     static char txt[128];
     sprintf(txt, "Current: %s", App::I.res_to_string(resolution).c_str());
     text->set_text(txt);
@@ -43,7 +43,7 @@ void NodeDialogResize::init_controls()
 
 void NodeDialogResize::loaded()
 {
-//    ui::Image thumb = ui::Canvas::I->thumbnail_read(data_path);
+//    Image thumb = Canvas::I->thumbnail_read(data_path);
 //    auto image_tex = find<NodeImageTexture>("thumb-tex");
 //    image_tex->tex.create(thumb);
 }
diff --git a/src/node_image.cpp b/src/node_image.cpp
index f103a96..18e803f 100644
--- a/src/node_image.cpp
+++ b/src/node_image.cpp
@@ -3,7 +3,7 @@
 #include "node_image.h"
 #include "shader.h"
 
-ui::Plane NodeImage::m_plane;
+Plane NodeImage::m_plane;
 Sampler NodeImage::m_sampler;
 Sampler NodeImage::m_sampler_mips;
 
@@ -84,23 +84,22 @@ void NodeImage::parse_attributes(kAttribute ka, const tinyxml2::XMLAttribute* at
 
 void NodeImage::draw()
 {
-    using namespace ui;
     TextureManager::get(m_tex_id).bind();
     auto& sampler = m_use_mipmaps ? m_sampler_mips : m_sampler;
     sampler.bind(0);
     glEnable(GL_BLEND);
     if (m_use_atlas)
     {
-        ui::ShaderManager::use(kShader::Atlas);
-        ui::ShaderManager::u_vec2(kShaderUniform::Tof, m_off);
-        ui::ShaderManager::u_vec2(kShaderUniform::Tsz, m_sz);
+        ShaderManager::use(kShader::Atlas);
+        ShaderManager::u_vec2(kShaderUniform::Tof, m_off);
+        ShaderManager::u_vec2(kShaderUniform::Tsz, m_sz);
     }
     else
     {
-        ui::ShaderManager::use(kShader::Texture);
+        ShaderManager::use(kShader::Texture);
     }
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
     m_plane.draw_fill();
     sampler.unbind();
     TextureManager::get(m_tex_id).unbind();
diff --git a/src/node_image.h b/src/node_image.h
index 91ef9fc..1280607 100644
--- a/src/node_image.h
+++ b/src/node_image.h
@@ -6,7 +6,7 @@
 class NodeImage : public Node
 {
 public:
-    static ui::Plane m_plane;
+    static Plane m_plane;
     static Sampler m_sampler;
     static Sampler m_sampler_mips;
     bool m_use_atlas = false;
diff --git a/src/node_image_texture.cpp b/src/node_image_texture.cpp
index d440d0e..43e82dd 100644
--- a/src/node_image_texture.cpp
+++ b/src/node_image_texture.cpp
@@ -18,14 +18,13 @@ void NodeImageTexture::clone_copy(Node* dest) const
 
 void NodeImageTexture::draw()
 {
-    using namespace ui;
     tex.bind();
     auto& sampler = tex.has_mips ? NodeImage::m_sampler_mips : NodeImage::m_sampler;
     sampler.bind(0);
     glEnable(GL_BLEND);
-    ui::ShaderManager::use(kShader::Texture);
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::use(kShader::Texture);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
     NodeImage::m_plane.draw_fill();
     sampler.unbind();
     tex.unbind();
diff --git a/src/node_panel_brush.cpp b/src/node_panel_brush.cpp
index f700f39..02fcfa0 100644
--- a/src/node_panel_brush.cpp
+++ b/src/node_panel_brush.cpp
@@ -205,7 +205,7 @@ void NodePanelBrushPreset::handle_click(Node* target)
         on_brush_changed(this, m_current->m_brushID);
 }
 
-ui::Brush NodePanelBrushPreset::get_brush(int index) const
+Brush NodePanelBrushPreset::get_brush(int index) const
 {
     auto b = m_brushes[index]->m_brush;
     TextureManager::load(m_brushes[index]->high_path.c_str(), true);
diff --git a/src/node_panel_brush.h b/src/node_panel_brush.h
index 8e54950..dc4e44f 100644
--- a/src/node_panel_brush.h
+++ b/src/node_panel_brush.h
@@ -43,7 +43,7 @@ class NodeBrushPresetItem : public NodeButtonCustom
 {
 public:
     int m_brushID;
-    ui::Brush m_brush;
+    Brush m_brush;
     std::string high_path;
     uint16_t high_id;
     bool m_selected = false;
@@ -65,7 +65,7 @@ public:
     virtual void init() override;
     void handle_click(Node* target);
     uint16_t get_texture_id(int index) const;
-    ui::Brush get_brush(int index) const;
+    Brush get_brush(int index) const;
     int get_brush_id(int index) const;
 };
 
diff --git a/src/node_panel_color.cpp b/src/node_panel_color.cpp
index e958182..08ab0ae 100644
--- a/src/node_panel_color.cpp
+++ b/src/node_panel_color.cpp
@@ -55,5 +55,5 @@ void NodePanelColor::set_color(glm::vec3 rgb)
 
 void NodePanelColor::added(Node* parent)
 {
-    set_color(ui::Canvas::I->m_current_brush.m_tip_color);
+    set_color(Canvas::I->m_current_brush.m_tip_color);
 }
diff --git a/src/node_panel_grid.cpp b/src/node_panel_grid.cpp
index be0d3e9..6c02855 100644
--- a/src/node_panel_grid.cpp
+++ b/src/node_panel_grid.cpp
@@ -49,7 +49,7 @@ void NodePanelGrid::init_controls()
 
     m_hm_load->on_click = [this](Node*) {
         App::I.pick_image([this](std::string path) {
-            ui::Image img;
+            Image img;
             if (img.load_file(path))
             {
                 m_hm_image = img.resize(128, 128);
diff --git a/src/node_panel_grid.h b/src/node_panel_grid.h
index da0aeb2..e64e9e5 100644
--- a/src/node_panel_grid.h
+++ b/src/node_panel_grid.h
@@ -25,8 +25,8 @@ public:
     NodeButton* m_hm_load;
     NodeSliderH* m_hm_offset;
     NodeSliderH* m_hm_height;
-    ui::HeightmapPlane m_hm_plane;
-    ui::Image m_hm_image;
+    HeightmapPlane m_hm_plane;
+    Image m_hm_image;
 
     virtual Node* clone_instantiate() const override;
     virtual void clone_finalize(Node* dest) const override;
diff --git a/src/node_panel_stroke.cpp b/src/node_panel_stroke.cpp
index ddb4265..7313623 100644
--- a/src/node_panel_stroke.cpp
+++ b/src/node_panel_stroke.cpp
@@ -22,7 +22,7 @@ void NodePanelStroke::init()
 
 void NodePanelStroke::update_controls()
 {
-    const auto& b = ui::Canvas::I->m_current_brush;
+    const auto& b = Canvas::I->m_current_brush;
     m_tip_size->m_value.x = glm::pow(b.m_tip_size, 1.f/3.f);
     m_tip_spacing->m_value.x = glm::pow(b.m_tip_spacing, 1.f/2.f) / 4.f;
     m_tip_flow->m_value.x = glm::pow(b.m_tip_flow, 1.f/2.f);
@@ -50,44 +50,44 @@ void NodePanelStroke::init_controls()
     m_preview = find<NodeStrokePreview>("canvas");
     m_blend_mode = find<NodeComboBox>("blend-mode");
     m_blend_mode->on_select = [](Node*, int index) {
-        ui::Canvas::I->m_current_brush.m_blend_mode = index;
+        Canvas::I->m_current_brush.m_blend_mode = index;
     };
 
-    init_slider(m_tip_size, "tip-size", &ui::Brush::m_tip_size);
-    init_slider(m_tip_spacing, "tip-spacing", &ui::Brush::m_tip_spacing);
-    init_slider(m_tip_flow, "tip-flow", &ui::Brush::m_tip_flow);
-    init_slider(m_tip_opacity, "tip-opacity", &ui::Brush::m_tip_opacity);
-    init_slider(m_tip_angle, "tip-angle", &ui::Brush::m_tip_angle);
-    init_slider(m_tip_mix, "tip-mix", &ui::Brush::m_tip_mix);
-    init_slider(m_tip_stencil, "tip-stencil", &ui::Brush::m_tip_stencil);
-    init_slider(m_tip_wet, "tip-wet", &ui::Brush::m_tip_wet);
-    init_slider(m_tip_noise, "tip-noise", &ui::Brush::m_tip_noise);
-    init_slider(m_tip_hue, "tip-hue", &ui::Brush::m_tip_hue);
-    init_slider(m_tip_sat, "tip-sat", &ui::Brush::m_tip_sat);
-    init_slider(m_tip_val, "tip-val", &ui::Brush::m_tip_val);
-    init_slider(m_jitter_scale, "jitter-scale", &ui::Brush::m_jitter_scale);
-    init_slider(m_jitter_angle, "jitter-angle", &ui::Brush::m_jitter_angle);
-    init_slider(m_jitter_spread, "jitter-spread", &ui::Brush::m_jitter_spread);
-    init_slider(m_jitter_flow, "jitter-flow", &ui::Brush::m_jitter_flow);
-    init_slider(m_jitter_hue, "jitter-hue", &ui::Brush::m_jitter_hue);
-    init_slider(m_jitter_sat, "jitter-sat", &ui::Brush::m_jitter_sat);
-    init_slider(m_jitter_val, "jitter-val", &ui::Brush::m_jitter_val);
+    init_slider(m_tip_size, "tip-size", &Brush::m_tip_size);
+    init_slider(m_tip_spacing, "tip-spacing", &Brush::m_tip_spacing);
+    init_slider(m_tip_flow, "tip-flow", &Brush::m_tip_flow);
+    init_slider(m_tip_opacity, "tip-opacity", &Brush::m_tip_opacity);
+    init_slider(m_tip_angle, "tip-angle", &Brush::m_tip_angle);
+    init_slider(m_tip_mix, "tip-mix", &Brush::m_tip_mix);
+    init_slider(m_tip_stencil, "tip-stencil", &Brush::m_tip_stencil);
+    init_slider(m_tip_wet, "tip-wet", &Brush::m_tip_wet);
+    init_slider(m_tip_noise, "tip-noise", &Brush::m_tip_noise);
+    init_slider(m_tip_hue, "tip-hue", &Brush::m_tip_hue);
+    init_slider(m_tip_sat, "tip-sat", &Brush::m_tip_sat);
+    init_slider(m_tip_val, "tip-val", &Brush::m_tip_val);
+    init_slider(m_jitter_scale, "jitter-scale", &Brush::m_jitter_scale);
+    init_slider(m_jitter_angle, "jitter-angle", &Brush::m_jitter_angle);
+    init_slider(m_jitter_spread, "jitter-spread", &Brush::m_jitter_spread);
+    init_slider(m_jitter_flow, "jitter-flow", &Brush::m_jitter_flow);
+    init_slider(m_jitter_hue, "jitter-hue", &Brush::m_jitter_hue);
+    init_slider(m_jitter_sat, "jitter-sat", &Brush::m_jitter_sat);
+    init_slider(m_jitter_val, "jitter-val", &Brush::m_jitter_val);
     m_curves[m_tip_size] = [](float v){ return glm::pow(v, 3.f); };
     m_curves[m_tip_spacing] = [](float v){ return glm::pow(v * 4.f, 2.f); };
     m_curves[m_tip_flow] = [](float v){ return glm::pow(v, 2.f); };
 
-    init_checkbox(m_tip_angle_follow, "tip-angle-follow", &ui::Brush::m_tip_angle_follow);
-    init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &ui::Brush::m_tip_flow_pressure);
-    init_checkbox(m_tip_size_pressure, "tip-size-pressure", &ui::Brush::m_tip_size_pressure);
-    init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &ui::Brush::m_tip_hue_pressure);
-    init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &ui::Brush::m_tip_sat_pressure);
-    init_checkbox(m_tip_val_pressure, "tip-val-pressure", &ui::Brush::m_tip_val_pressure);
+    init_checkbox(m_tip_angle_follow, "tip-angle-follow", &Brush::m_tip_angle_follow);
+    init_checkbox(m_tip_flow_pressure, "tip-flow-pressure", &Brush::m_tip_flow_pressure);
+    init_checkbox(m_tip_size_pressure, "tip-size-pressure", &Brush::m_tip_size_pressure);
+    init_checkbox(m_tip_hue_pressure, "tip-hue-pressure", &Brush::m_tip_hue_pressure);
+    init_checkbox(m_tip_sat_pressure, "tip-sat-pressure", &Brush::m_tip_sat_pressure);
+    init_checkbox(m_tip_val_pressure, "tip-val-pressure", &Brush::m_tip_val_pressure);
 
-    m_preview->m_brush = ui::Canvas::I->m_current_brush;
+    m_preview->m_brush = Canvas::I->m_current_brush;
     m_preview->draw_stroke();
 }
 
-void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float ui::Brush::* prop)
+void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float Brush::* prop)
 {
     target = find<NodeSliderH>(id);
     target->on_value_changed = std::bind(&NodePanelStroke::handle_slide,
@@ -95,28 +95,28 @@ void NodePanelStroke::init_slider(NodeSliderH*& target, const char* id, float ui
     //m_canvas->m_brush.*prop = target->m_value.x;
 }
 
-void NodePanelStroke::handle_slide(float ui::Brush::* prop, Node* target, float value)
+void NodePanelStroke::handle_slide(float Brush::* prop, Node* target, float value)
 {
     auto curve = m_curves.find((NodeSliderH*)target);
-    ui::Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value;
-    m_preview->m_brush = ui::Canvas::I->m_current_brush;
+    Canvas::I->m_current_brush.*prop = curve != m_curves.end() ? curve->second(value) : value;
+    m_preview->m_brush = Canvas::I->m_current_brush;
     m_preview->draw_stroke();
     if (on_stroke_change)
         on_stroke_change(this);
 }
 
-void NodePanelStroke::init_checkbox(NodeCheckBox*& target, const char* id, bool ui::Brush::* prop)
+void NodePanelStroke::init_checkbox(NodeCheckBox*& target, const char* id, bool Brush::* prop)
 {
     target = find<NodeCheckBox>(id);
     target->on_value_changed = std::bind(&NodePanelStroke::handle_checkbox,
         this, prop, std::placeholders::_1, std::placeholders::_2);
-    ui::Canvas::I->m_current_brush.*prop = target->checked;
+    Canvas::I->m_current_brush.*prop = target->checked;
 }
 
-void NodePanelStroke::handle_checkbox(bool ui::Brush::* prop, Node *target, bool value)
+void NodePanelStroke::handle_checkbox(bool Brush::* prop, Node *target, bool value)
 {
-    ui::Canvas::I->m_current_brush.*prop = value;
-    m_preview->m_brush = ui::Canvas::I->m_current_brush;
+    Canvas::I->m_current_brush.*prop = value;
+    m_preview->m_brush = Canvas::I->m_current_brush;
     m_preview->draw_stroke();
     if (on_stroke_change)
         on_stroke_change(this);
diff --git a/src/node_panel_stroke.h b/src/node_panel_stroke.h
index e6cbcec..daeab11 100644
--- a/src/node_panel_stroke.h
+++ b/src/node_panel_stroke.h
@@ -45,9 +45,9 @@ public:
     void init_controls();
     void update_controls();
     
-    void init_slider(NodeSliderH*& slider, const char* id, float ui::Brush::* prop);
-    void handle_slide(float ui::Brush::* prop, Node* target, float value);
+    void init_slider(NodeSliderH*& slider, const char* id, float Brush::* prop);
+    void handle_slide(float Brush::* prop, Node* target, float value);
 
-    void init_checkbox(NodeCheckBox*& slider, const char* id, bool ui::Brush::* prop);
-    void handle_checkbox(bool ui::Brush::* prop, Node* target, bool value);
+    void init_checkbox(NodeCheckBox*& slider, const char* id, bool Brush::* prop);
+    void handle_checkbox(bool Brush::* prop, Node* target, bool value);
 };
diff --git a/src/node_slider.cpp b/src/node_slider.cpp
index bd9a7a8..16aad8e 100644
--- a/src/node_slider.cpp
+++ b/src/node_slider.cpp
@@ -27,16 +27,15 @@ void NodeSliderH::draw()
 {
     NodeBorder::draw();
 
-    using namespace ui;
     auto sz = GetSize();
     glm::vec2 cur_size = sz * (1.f - m_mask) + m_mask * glm::vec2(10);
     glm::mat4 scale = glm::scale(glm::vec3(cur_size, 1.f));
     glm::mat4 pos = glm::translate(glm::vec3(m_value * m_mask * sz + m_pos + sz * .5f * (1.f - m_mask), 0));
     auto mvp = m_proj * pos * scale;
 
-    ui::ShaderManager::use(kShader::Color);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
-    ui::ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
+    ShaderManager::use(kShader::Color);
+    ShaderManager::u_mat4(kShaderUniform::MVP, mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, { 0, 0, 0, 1 });
     m_plane.draw_fill();
 }
 
@@ -149,11 +148,10 @@ glm::vec4 NodeSliderHue::get_hue()
 
 void NodeSliderHue::draw()
 {
-    using namespace ui;
-    ui::ShaderManager::use(kShader::ColorHue);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
-    //ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
-    ui::ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
+    ShaderManager::use(kShader::ColorHue);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    //ShaderManager::u_vec4(kShaderUniform::Col, m_color);
+    ShaderManager::u_int(kShaderUniform::Direction, 1); // set vertical
     m_plane.draw_fill();
     NodeBorder::m_color = glm::vec4(0);
     NodeSliderH::draw();
diff --git a/src/node_stroke_preview.cpp b/src/node_stroke_preview.cpp
index 450936d..9381176 100644
--- a/src/node_stroke_preview.cpp
+++ b/src/node_stroke_preview.cpp
@@ -34,7 +34,7 @@ void NodeStrokePreview::init_controls()
     m_sampler_brush.create();
     m_sampler_brush.set_filter(GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
 //     TextureManager::load("data/thumbs/Round-Hard.png");
-//     ui::Canvas::I->m_current_brush.m_tex_id = const_hash("data/thumbs/Round-Hard.png");
+//     Canvas::I->m_current_brush.m_tex_id = const_hash("data/thumbs/Round-Hard.png");
 }
 
 void NodeStrokePreview::restore_context()
@@ -56,7 +56,6 @@ void NodeStrokePreview::draw_stroke()
 {
     m_rtt.bindFramebuffer();
     {
-        using namespace ui;
         GLint vp[4];
         GLfloat cc[4];
         glGetIntegerv(GL_VIEWPORT, vp);
@@ -69,8 +68,8 @@ void NodeStrokePreview::draw_stroke()
         glm::mat4 proj = glm::ortho<float>(0, (float)m_rtt.getWidth(), 0, (float)m_rtt.getHeight(), -1, 1);
 
         auto b = m_brush;
-        m_stroke.m_camera.fov = ui::Canvas::I->m_cam_fov;
-        m_stroke.m_camera.rot = ui::Canvas::I->m_cam_rot;
+        m_stroke.m_camera.fov = Canvas::I->m_cam_fov;
+        m_stroke.m_camera.rot = Canvas::I->m_cam_rot;
         m_stroke.reset();
         m_stroke.start(b);
         if (!m_stroke.m_keypoints.empty())
@@ -127,10 +126,9 @@ void NodeStrokePreview::draw_stroke()
 
 void NodeStrokePreview::draw()
 {
-    using namespace ui;
-    ui::ShaderManager::use(kShader::Texture);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::use(kShader::Texture);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
     m_rtt.bindTexture();
     m_sampler.bind(0);
     m_plane.draw_fill();
diff --git a/src/node_stroke_preview.h b/src/node_stroke_preview.h
index 4feba46..d4a207c 100644
--- a/src/node_stroke_preview.h
+++ b/src/node_stroke_preview.h
@@ -9,10 +9,10 @@ class NodeStrokePreview : public NodeBorder
     RTT m_rtt;
     Sampler m_sampler;
     Sampler m_sampler_brush;
-    ui::BrushMesh m_mesh;
+    BrushMesh m_mesh;
 public:
-    ui::Brush m_brush;
-    ui::Stroke m_stroke;
+    Brush m_brush;
+    Stroke m_stroke;
     std::vector<glm::vec2> m_bez_points;
     virtual Node* clone_instantiate() const override;
     virtual void clone_copy(Node* dest) const override;
diff --git a/src/node_text.cpp b/src/node_text.cpp
index e0f626a..a0e0cee 100644
--- a/src/node_text.cpp
+++ b/src/node_text.cpp
@@ -102,13 +102,12 @@ void NodeText::set_text_format(const char* fmt, ...)
 
 void NodeText::draw()
 {
-    using namespace ui;
     glm::mat4 pos = glm::translate(glm::vec3(glm::floor(m_pos), 0));
     m_mvp = m_proj * pos;
-    ui::ShaderManager::use(kShader::Font);
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
-    ui::ShaderManager::u_vec4(kShaderUniform::Col, m_color);
+    ShaderManager::use(kShader::Font);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_mat4(kShaderUniform::MVP, m_mvp);
+    ShaderManager::u_vec4(kShaderUniform::Col, m_color);
     glEnable(GL_BLEND);
     m_text_mesh.draw();
     glDisable(GL_BLEND);
diff --git a/src/node_viewport.cpp b/src/node_viewport.cpp
index ee1e5f7..5a270e2 100644
--- a/src/node_viewport.cpp
+++ b/src/node_viewport.cpp
@@ -5,7 +5,6 @@
 
 void NodeViewport::draw()
 {
-    using namespace ui;
     glm::mat4 cam = glm::lookAt(glm::vec3(sinf(angle) * 10, 0, -10), glm::vec3(0, 0, 0), glm::vec3(0, -1, 0));
     glm::mat4 proj = glm::perspective<float>(glm::radians(45.f), m_clip.z / m_clip.w, .1f, 100);
 
@@ -22,9 +21,9 @@ void NodeViewport::draw()
     TextureManager::get(m_tex_id).bind();
     m_sampler->bind(0);
     glEnable(GL_BLEND);
-    ui::ShaderManager::use(kShader::Texture);
-    ui::ShaderManager::u_int(kShaderUniform::Tex, 0);
-    ui::ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam);
+    ShaderManager::use(kShader::Texture);
+    ShaderManager::u_int(kShaderUniform::Tex, 0);
+    ShaderManager::u_mat4(kShaderUniform::MVP, proj * cam);
     m_faces->draw_fill();
     m_sampler->unbind();
     TextureManager::get(m_tex_id).unbind();
@@ -39,7 +38,7 @@ Node* NodeViewport::clone_instantiate() const
 }
 void NodeViewport::create()
 {
-    m_faces = std::make_unique<ui::Plane>();
+    m_faces = std::make_unique<Plane>();
     m_faces->create<1>(10, 10);
     m_sampler = std::make_unique<Sampler>();
     m_sampler->create();
diff --git a/src/node_viewport.h b/src/node_viewport.h
index 49badb5..4e4b3fb 100644
--- a/src/node_viewport.h
+++ b/src/node_viewport.h
@@ -7,7 +7,7 @@
 class NodeViewport : public Node
 {
 public:
-    std::unique_ptr<ui::Plane> m_faces;
+    std::unique_ptr<Plane> m_faces;
     std::unique_ptr<Sampler> m_sampler;
     uint16_t m_tex_id;
     glm::vec2 drag_start;
diff --git a/src/pch.h b/src/pch.h
index ea5fc3a..90f826d 100644
--- a/src/pch.h
+++ b/src/pch.h
@@ -72,8 +72,6 @@
 
 #endif
 
-#define NS_START namespace ui {
-#define NS_END }
 #define SIXPLETTE(I) {I, I, I, I, I, I}
 
 #ifdef __cplusplus
diff --git a/src/shader.cpp b/src/shader.cpp
index 954f150..be1ef02 100644
--- a/src/shader.cpp
+++ b/src/shader.cpp
@@ -2,8 +2,6 @@
 #include "log.h"
 #include "shader.h"
 
-using namespace ui;
-
 std::map<kShader, Shader> ShaderManager::m_shaders;
 Shader* ShaderManager::m_current;
 
@@ -146,7 +144,7 @@ void Shader::u_float(kShaderUniform id, float f)
         LOG("UNIFORM float %d NOT FOUND in shader %d", (int)id, (int)name)
     else glUniform1f(m_umap[id], f);
 }
-GLint ui::Shader::GetAttribLocation(const char* name)
+GLint Shader::GetAttribLocation(const char* name)
 {
     return glGetAttribLocation(prog, name);
 }
@@ -188,13 +186,13 @@ void ShaderManager::u_int(kShaderUniform id, int i)
     m_current->u_int(id, i);
 }
 
-Shader* ui::ShaderManager::get(kShader id)
+Shader* ShaderManager::get(kShader id)
 {
     auto it = m_shaders.find(id);
     return (it == m_shaders.end()) ? nullptr : &it->second;
 }
 
-void ui::ShaderManager::u_float(kShaderUniform id, float f)
+void ShaderManager::u_float(kShaderUniform id, float f)
 {
     m_current->u_float(id, f);
 }
diff --git a/src/shader.h b/src/shader.h
index 9cb2a6d..59367c9 100644
--- a/src/shader.h
+++ b/src/shader.h
@@ -1,8 +1,6 @@
 #pragma once
 #include "util.h"
 
-namespace ui {
-
 enum class kShaderUniform : uint16_t
 {
     MVP = const_hash("mvp"),
@@ -88,5 +86,3 @@ public:
     static void u_float(kShaderUniform id, float f);
     static void invalidate();
 };
-
-}
diff --git a/src/shape.cpp b/src/shape.cpp
index 8a08f03..76d0657 100644
--- a/src/shape.cpp
+++ b/src/shape.cpp
@@ -2,16 +2,14 @@
 #include "log.h"
 #include "shape.h"
 
-using namespace ui;
-
-bool ui::Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
+bool Shape::create_buffers(GLushort * idx, GLvoid * vertices, int isize, int vsize)
 {
     index_type = GL_UNSIGNED_SHORT;
     create_buffers_imp(idx, vertices, isize, vsize);
     return false;
 }
 
-bool ui::Shape::create_buffers(GLuint* idx, GLvoid * vertices, int isize, int vsize)
+bool Shape::create_buffers(GLuint* idx, GLvoid * vertices, int isize, int vsize)
 {
     index_type = GL_UNSIGNED_INT;
     create_buffers_imp(idx, vertices, isize, vsize);
@@ -239,7 +237,7 @@ void Plane::create_impl(float w, float h, int div, GLushort *idx, vertex_t *vert
     }
 }
 
-bool ui::HeightmapPlane::create(float w, float h, const Image& img, float scale)
+bool HeightmapPlane::create(float w, float h, const Image& img, float scale)
 {
     int div = img.width - 1; // TODO: handle height also
     int idx_size = (div * div * 6) + (div * (div + 1) * 4);
@@ -313,7 +311,7 @@ bool ui::HeightmapPlane::create(float w, float h, const Image& img, float scale)
     return create_buffers(idx.get(), vertices.get(), sizeof(GLuint) * idx_size, sizeof(vertex_t) * vertices_size);
 }
 
-void ui::Plane::update_vertices(const glm::vec4* data, const glm::vec2* uvs, const glm::vec2* uvs2)
+void Plane::update_vertices(const glm::vec4* data, const glm::vec2* uvs, const glm::vec2* uvs2)
 {
     static vertex_t vertices[4];
     
@@ -605,7 +603,7 @@ void Sphere::create_impl(int rings, int sectors, float radius,
         *i++ = (r+1) * sectors + s;
     }
 }
-void ui::LineSegment::update_vertices(const glm::vec4 data[2])
+void LineSegment::update_vertices(const glm::vec4 data[2])
 {
     static vertex_t vertices[2];
     vertices[0] = { data[0], { 0, 0 } }; // A
@@ -614,7 +612,7 @@ void ui::LineSegment::update_vertices(const glm::vec4 data[2])
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
-void ui::DynamicShape::update_vertices(vertex_t* vertices, int vcount)
+void DynamicShape::update_vertices(vertex_t* vertices, int vcount)
 {
     count[0] = vcount;
     count[1] = vcount;
diff --git a/src/shape.h b/src/shape.h
index 486085e..30ff600 100644
--- a/src/shape.h
+++ b/src/shape.h
@@ -9,8 +9,6 @@ enum class kShapeType : uint16_t
     Slice9 = const_hash("slice9"),
 };
 
-namespace ui {
-
 class Shape
 {
 protected:
@@ -221,5 +219,3 @@ public:
         return create_buffers(idx.get(), vertices.get(), rings * sectors * 6 * sizeof(GLushort), rings * sectors * sizeof(vertex_t));
     }
 };
-
-}
diff --git a/src/texture.cpp b/src/texture.cpp
index 39b93ff..d771d21 100644
--- a/src/texture.cpp
+++ b/src/texture.cpp
@@ -53,7 +53,7 @@ bool Texture2D::create(int width, int height, GLint internal_format, GLint forma
     unbind();
     return true;
 }
-bool Texture2D::create(const ui::Image& img)
+bool Texture2D::create(const Image& img)
 {
     static GLint formats[] = { GL_RED, GL_RG, GL_RGB, GL_RGBA };
     static GLint iformats[] = { GL_R8, GL_RG8, GL_RGB8, GL_RGBA8 };
@@ -80,7 +80,7 @@ void Texture2D::assign(GLuint tex, int w/* = -1*/, int h/* = -1*/, GLuint intern
 bool Texture2D::load(std::string filename)
 {
     LOG("load texture %s", filename.c_str());
-    ui::Image img;
+    Image img;
     if (!img.load(filename))
         return false;
     return create(img);
@@ -89,7 +89,7 @@ bool Texture2D::load(std::string filename)
 bool Texture2D::load_file(std::string filename)
 {
     LOG("load texture %s", filename.c_str());
-    ui::Image img;
+    Image img;
     if (!img.load_file(filename))
         return false;
     return create(img);
diff --git a/src/texture.h b/src/texture.h
index 6b30bcf..95004e0 100644
--- a/src/texture.h
+++ b/src/texture.h
@@ -11,7 +11,7 @@ class Texture2D
 public:
     bool has_mips = false;
     bool create(int width, int height, GLint internal_format = GL_RGBA8, GLint format = GL_RGBA, const uint8_t* data = nullptr);
-    bool create(const ui::Image& img);
+    bool create(const Image& img);
     void assign(GLuint tex, int w = -1, int h = -1, GLuint internal_format = GL_RGBA8, GLuint format = GL_RGBA);
     bool load(std::string filename);
     bool load_file(std::string filename);
diff --git a/src/util.h b/src/util.h
index bf57980..0e63ba9 100644
--- a/src/util.h
+++ b/src/util.h
@@ -115,7 +115,6 @@ template<typename T, int N> struct cbuffer
     }
 };
 
-NS_START
 template<typename T, int Max = 0>
 class BlockingQueue
 {
@@ -216,5 +215,3 @@ struct gl_state
         glBindTexture(GL_TEXTURE_CUBE_MAP, cube);
     }
 };
-
-NS_END