diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0a9b0c96ce..7d9d2e2f28 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -48,9 +48,23 @@ endif()
 set(VSG_WARNING_FLAGS ${VSG_WARNING_FLAGS} CACHE STRING "Compiler flags to use." FORCE)
 add_compile_options(${VSG_WARNING_FLAGS})
 
-find_package(glfw3)
 find_package(Vulkan)
 
+if (ANDROID)
+    # TODO
+elseif (WIN32)
+    # just use native windowing
+elseif (APPLE)
+    find_package(glfw3)
+else()
+    find_package(glfw3)
+
+    find_package(PkgConfig)
+    pkg_check_modules(xcb REQUIRED IMPORTED_TARGET xcb)
+    option(USE_GLFW "Use GLFW for Windowing" OFF)
+endif()
+
+
 
 # create doxygen build target
 find_package(Doxygen QUIET)
diff --git a/include/vsg/core/ConstVisitor.h b/include/vsg/core/ConstVisitor.h
index a994479a7e..c68cd8343a 100644
--- a/include/vsg/core/ConstVisitor.h
+++ b/include/vsg/core/ConstVisitor.h
@@ -34,12 +34,16 @@ namespace vsg
 
     // forward declare ui events classes
     class UIEvent;
+    class WindowEvent;
+    class ExposeWindowEvent;
+    class DeleteWindowEvent;
     class KeyEvent;
     class KeyPressEvent;
     class KeyReleaseEvent;
     class PointerEvent;
     class ButtonPressEvent;
     class ButtonReleaseEvent;
+    class MoveEvent;
 
     class VSG_DECLSPEC ConstVisitor : public Object
     {
@@ -120,12 +124,16 @@ namespace vsg
 
         // ui events
         virtual void apply(const UIEvent&);
+        virtual void apply(const WindowEvent&);
+        virtual void apply(const ExposeWindowEvent&);
+        virtual void apply(const DeleteWindowEvent&);
         virtual void apply(const KeyEvent&);
         virtual void apply(const KeyPressEvent&);
         virtual void apply(const KeyReleaseEvent&);
         virtual void apply(const PointerEvent&);
         virtual void apply(const ButtonPressEvent&);
         virtual void apply(const ButtonReleaseEvent&);
+        virtual void apply(const MoveEvent&);
     };
 
     // provide Value<>::accept() implementation
diff --git a/include/vsg/core/Visitor.h b/include/vsg/core/Visitor.h
index 95cf197aee..8eaf122bee 100644
--- a/include/vsg/core/Visitor.h
+++ b/include/vsg/core/Visitor.h
@@ -34,12 +34,16 @@ namespace vsg
 
     // forward declare ui events classes
     class UIEvent;
+    class WindowEvent;
+    class ExposeWindowEvent;
+    class DeleteWindowEvent;
     class KeyEvent;
     class KeyPressEvent;
     class KeyReleaseEvent;
     class PointerEvent;
     class ButtonPressEvent;
     class ButtonReleaseEvent;
+    class MoveEvent;
 
     class VSG_DECLSPEC Visitor : public Object
     {
@@ -120,12 +124,16 @@ namespace vsg
 
         // ui events
         virtual void apply(UIEvent&);
+        virtual void apply(WindowEvent&);
+        virtual void apply(ExposeWindowEvent&);
+        virtual void apply(DeleteWindowEvent&);
         virtual void apply(KeyEvent&);
         virtual void apply(KeyPressEvent&);
         virtual void apply(KeyReleaseEvent&);
         virtual void apply(PointerEvent&);
         virtual void apply(ButtonPressEvent&);
         virtual void apply(ButtonReleaseEvent&);
+        virtual void apply(MoveEvent&);
     };
 
     // provide Value<>::accept() implementation
diff --git a/include/vsg/ui/KeyEvent.h b/include/vsg/ui/KeyEvent.h
index 97514080ab..1edf4cfb3f 100644
--- a/include/vsg/ui/KeyEvent.h
+++ b/include/vsg/ui/KeyEvent.h
@@ -13,7 +13,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 </editor-fold> */
 
 #include <vsg/core/observer_ptr.h>
-#include <vsg/ui/UIEvent.h>
+#include <vsg/ui/WindowEvent.h>
 #include <vsg/viewer/Window.h>
 
 namespace vsg
@@ -264,18 +264,16 @@ namespace vsg
         MODKEY_Meta = 128
     };
 
-    class KeyEvent : public Inherit<UIEvent, KeyEvent>
+    class KeyEvent : public Inherit<WindowEvent, KeyEvent>
     {
     public:
         KeyEvent(Window* in_window, time_point in_time, KeySymbol in_keyBase, KeySymbol in_keyModified, KeyModifier in_modifier, uint32_t in_repeatCount=0):
-            Inherit(in_time),
-            window(in_window),
+            Inherit(in_window, in_time),
             keyBase(in_keyBase),
             keyModified(in_keyModified),
             keyModifier(in_modifier),
             repeatCount(in_repeatCount) {}
 
-        observer_ptr<Window> window;
         KeySymbol keyBase;
         KeySymbol keyModified;
         KeyModifier keyModifier;
diff --git a/include/vsg/ui/PointerEvent.h b/include/vsg/ui/PointerEvent.h
index bbd8f9e1a5..a6da8fa2c4 100644
--- a/include/vsg/ui/PointerEvent.h
+++ b/include/vsg/ui/PointerEvent.h
@@ -13,7 +13,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 </editor-fold> */
 
 #include <vsg/core/observer_ptr.h>
-#include <vsg/ui/UIEvent.h>
+#include <vsg/ui/WindowEvent.h>
 #include <vsg/viewer/Window.h>
 
 namespace vsg
@@ -30,33 +30,44 @@ namespace vsg
 
     // VSG_type_name(vsg::PointerEvent);
 
-    class PointerEvent : public Inherit<UIEvent, PointerEvent>
+    class PointerEvent : public Inherit<WindowEvent, PointerEvent>
     {
     public:
         PointerEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask):
-            Inherit(in_time),
-            window(in_window),
+            Inherit(in_window, in_time),
             x(in_x),
             y(in_y),
-            buttonMask(in_buttonMask) {}
+            mask(in_buttonMask) {}
 
-        observer_ptr<Window> window;
         uint32_t x;
         uint32_t y;
-        ButtonMask buttonMask;
+        ButtonMask mask;
     };
 
     class ButtonPressEvent : public Inherit<PointerEvent, ButtonPressEvent>
     {
     public:
-        ButtonPressEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask):
-            Inherit(in_window, in_time, in_x, in_y, in_buttonMask) {}
+        ButtonPressEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask, uint32_t in_button):
+            Inherit(in_window, in_time, in_x, in_y, in_buttonMask),
+            button(in_button) {}
+
+        uint32_t button;
     };
 
     class ButtonReleaseEvent : public Inherit<PointerEvent, ButtonReleaseEvent>
     {
     public:
-        ButtonReleaseEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask):
+        ButtonReleaseEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask, uint32_t in_button):
+            Inherit(in_window, in_time, in_x, in_y, in_buttonMask),
+            button(in_button) {}
+
+        uint32_t button;
+    };
+
+    class MoveEvent : public Inherit<PointerEvent, MoveEvent>
+    {
+    public:
+        MoveEvent(Window* in_window, time_point in_time, uint32_t in_x, uint32_t in_y, ButtonMask in_buttonMask):
             Inherit(in_window, in_time, in_x, in_y, in_buttonMask) {}
     };
 
diff --git a/include/vsg/ui/UIEvent.h b/include/vsg/ui/UIEvent.h
index d58312e0cf..f8fd1d375f 100644
--- a/include/vsg/ui/UIEvent.h
+++ b/include/vsg/ui/UIEvent.h
@@ -15,6 +15,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/core/Inherit.h>
 
 #include <chrono>
+#include <list>
 
 namespace vsg
 {
@@ -31,5 +32,5 @@ namespace vsg
         time_point time;
     };
 
-
+    using Events = std::list<ref_ptr<UIEvent>>;
 }
diff --git a/include/vsg/ui/WindowEvent.h b/include/vsg/ui/WindowEvent.h
new file mode 100644
index 0000000000..cfea5cb32f
--- /dev/null
+++ b/include/vsg/ui/WindowEvent.h
@@ -0,0 +1,56 @@
+#pragma once
+
+/* <editor-fold desc="MIT License">
+
+Copyright(c) 2018 Robert Osfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+</editor-fold> */
+
+#include <vsg/core/observer_ptr.h>
+#include <vsg/ui/UIEvent.h>
+#include <vsg/viewer/Window.h>
+
+namespace vsg
+{
+
+    class WindowEvent : public Inherit<UIEvent, WindowEvent>
+    {
+    public:
+        WindowEvent(Window* in_window, time_point in_time):
+            Inherit(in_time),
+            window(in_window) {}
+
+        observer_ptr<Window> window;
+    };
+
+    class ExposeWindowEvent : public Inherit<WindowEvent, ExposeWindowEvent>
+    {
+    public:
+        ExposeWindowEvent(Window* in_window, time_point in_time, int32_t in_x, int32_t in_y, uint32_t in_width, uint32_t in_height):
+            Inherit(in_window, in_time),
+            x(in_x),
+            y(in_y),
+            width(in_width),
+            height(in_height) {}
+
+        int x = 0;
+        int y = 0;
+        int width  = 0;
+        int height = 0;
+    };
+
+    class DeleteWindowEvent : public Inherit<WindowEvent, DeleteWindowEvent>
+    {
+    public:
+        DeleteWindowEvent(Window* in_window, time_point in_time):
+            Inherit(in_window, in_time) {}
+    };
+
+
+}
diff --git a/include/vsg/viewer/Window.h b/include/vsg/viewer/Window.h
index 055d8718ad..f78b0e0fd8 100644
--- a/include/vsg/viewer/Window.h
+++ b/include/vsg/viewer/Window.h
@@ -14,6 +14,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 #include <any>
 
+#include <vsg/ui/UIEvent.h>
+
 #include <vsg/vk/CommandBuffer.h>
 #include <vsg/vk/CommandPool.h>
 #include <vsg/vk/DeviceMemory.h>
@@ -21,6 +23,7 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <vsg/vk/Semaphore.h>
 #include <vsg/vk/State.h>
 
+
 namespace vsg
 {
 
@@ -32,13 +35,15 @@ namespace vsg
 
         struct Traits
         {
-            uint32_t x = 0;
-            uint32_t y = 0;
+            uint32_t x = 100;
+            uint32_t y = 100;
             uint32_t width = 800;
             uint32_t height = 600;
             uint32_t screenNum = 0;
 
-            std::string title = "vsg window";
+            std::string windowClass = "vsg::Window";
+            std::string windowTitle = "vsg window";
+
             bool decoration = true;
 
             Window* shareWindow = nullptr;
@@ -51,7 +56,7 @@ namespace vsg
 
         virtual bool valid() const { return false; }
 
-        virtual bool pollEvents() { return false; }
+        virtual bool pollEvents(Events& /*events*/) { return false; }
 
         virtual bool resized() const { return false; }
         virtual void resize() {}
diff --git a/src/vsg/CMakeLists.txt b/src/vsg/CMakeLists.txt
index 0a4f7f2d5b..a2da75c25e 100644
--- a/src/vsg/CMakeLists.txt
+++ b/src/vsg/CMakeLists.txt
@@ -79,10 +79,24 @@ set(SOURCES
 )
 
 # add platform specific Window implementation
-if(WIN32)
+# set up library dependancies
+set(LIBRARIES PUBLIC Vulkan::Vulkan)
+
+if (ANDROID)
+    # TODO
+elseif (WIN32)
     set(SOURCES ${SOURCES} viewer/Win32_Window.cpp)
-else()
+elseif (APPLE)
     set(SOURCES ${SOURCES} viewer/GLFW_Window.cpp)
+    set(LIBRARIES ${LIBRARIES} PRIVATE glfw)
+else()
+    if (USE_GLFW)
+        set(SOURCES ${SOURCES} viewer/GLFW_Window.cpp)
+        set(LIBRARIES ${LIBRARIES} PRIVATE glfw)
+    else()
+        set(SOURCES ${SOURCES} viewer/Xcb_Window.cpp)
+        set(LIBRARIES ${LIBRARIES} PRIVATE PkgConfig::xcb)
+    endif()
 endif()
 
 
@@ -142,14 +156,6 @@ set_property(TARGET vsg PROPERTY CXX_STANDARD 17)
 
 target_include_directories(vsg PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include> $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include>)
 
-# set up library dependancies
-set(LIBRARIES PUBLIC Vulkan::Vulkan)
-
-if(WIN32)
-    set(LIBRARIES ${LIBRARIES})
-else()
-    set(LIBRARIES ${LIBRARIES} PRIVATE glfw)
-endif()
 
 target_link_libraries(vsg ${LIBRARIES})
 
diff --git a/src/vsg/core/ConstVisitor.cpp b/src/vsg/core/ConstVisitor.cpp
index 31bcd3307b..2dcf37b9b2 100644
--- a/src/vsg/core/ConstVisitor.cpp
+++ b/src/vsg/core/ConstVisitor.cpp
@@ -305,10 +305,22 @@ void ConstVisitor::apply(const UIEvent& event)
 {
     apply(static_cast<const Object&>(event));
 }
-void ConstVisitor::apply(const KeyEvent& event)
+void ConstVisitor::apply(const WindowEvent& event)
 {
     apply(static_cast<const UIEvent&>(event));
 }
+void ConstVisitor::apply(const ExposeWindowEvent& event)
+{
+    apply(static_cast<const WindowEvent&>(event));
+}
+void ConstVisitor::apply(const DeleteWindowEvent& event)
+{
+    apply(static_cast<const WindowEvent&>(event));
+}
+void ConstVisitor::apply(const KeyEvent& event)
+{
+    apply(static_cast<const WindowEvent&>(event));
+}
 void ConstVisitor::apply(const KeyPressEvent& event)
 {
     apply(static_cast<const KeyEvent&>(event));
@@ -319,7 +331,7 @@ void ConstVisitor::apply(const KeyReleaseEvent& event)
 }
 void ConstVisitor::apply(const PointerEvent& event)
 {
-    apply(static_cast<const UIEvent&>(event));
+    apply(static_cast<const WindowEvent&>(event));
 }
 void ConstVisitor::apply(const ButtonPressEvent& event)
 {
@@ -329,3 +341,7 @@ void ConstVisitor::apply(const ButtonReleaseEvent& event)
 {
     apply(static_cast<const PointerEvent&>(event));
 }
+void ConstVisitor::apply(const MoveEvent& event)
+{
+    apply(static_cast<const PointerEvent&>(event));
+}
diff --git a/src/vsg/core/Visitor.cpp b/src/vsg/core/Visitor.cpp
index 302cde840a..b7dbe0723c 100644
--- a/src/vsg/core/Visitor.cpp
+++ b/src/vsg/core/Visitor.cpp
@@ -305,10 +305,22 @@ void Visitor::apply(UIEvent& event)
 {
     apply(static_cast<Object&>(event));
 }
-void Visitor::apply(KeyEvent& event)
+void Visitor::apply(WindowEvent& event)
 {
     apply(static_cast<UIEvent&>(event));
 }
+void Visitor::apply(ExposeWindowEvent& event)
+{
+    apply(static_cast<WindowEvent&>(event));
+}
+void Visitor::apply(DeleteWindowEvent& event)
+{
+    apply(static_cast<WindowEvent&>(event));
+}
+void Visitor::apply(KeyEvent& event)
+{
+    apply(static_cast<WindowEvent&>(event));
+}
 void Visitor::apply(KeyPressEvent& event)
 {
     apply(static_cast<KeyEvent&>(event));
@@ -319,7 +331,7 @@ void Visitor::apply(KeyReleaseEvent& event)
 }
 void Visitor::apply(PointerEvent& event)
 {
-    apply(static_cast<UIEvent&>(event));
+    apply(static_cast<WindowEvent&>(event));
 }
 void Visitor::apply(ButtonPressEvent& event)
 {
@@ -329,4 +341,8 @@ void Visitor::apply(ButtonReleaseEvent& event)
 {
     apply(static_cast<PointerEvent&>(event));
 }
+void Visitor::apply(MoveEvent& event)
+{
+    apply(static_cast<PointerEvent&>(event));
+}
 
diff --git a/src/vsg/viewer/GLFW_Window.cpp b/src/vsg/viewer/GLFW_Window.cpp
index bb3c147f8a..1d20aad733 100644
--- a/src/vsg/viewer/GLFW_Window.cpp
+++ b/src/vsg/viewer/GLFW_Window.cpp
@@ -18,6 +18,16 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 using namespace glfw;
 
+namespace vsg
+{
+    // Provide the Window::create(...) implementation that automatically maps to a GLFW_Window
+    Window::Result Window::create(const Window::Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
+    {
+        ref_ptr<vsg::Window> window = glfw::GLFW_Window::create(traits.width, traits.height, debugLayer, apiDumpLayer, traits.shareWindow, allocator);
+        return Result(window);
+    }
+}
+
 vsg::Names glfw::getInstanceExtensions()
 {
     uint32_t glfw_count;
@@ -163,7 +173,7 @@ GLFW_Window::~GLFW_Window()
     }
 }
 
-bool GLFW_Window::pollEvents()
+bool GLFW_Window::pollEvents(vsg::Events& /*events*/)
 {
     glfwPollEvents();
     return false;
diff --git a/src/vsg/viewer/GLFW_Window.h b/src/vsg/viewer/GLFW_Window.h
index 3010b1fac4..26e34b35f1 100644
--- a/src/vsg/viewer/GLFW_Window.h
+++ b/src/vsg/viewer/GLFW_Window.h
@@ -34,13 +34,13 @@ class GLFW_Window : public vsg::Window
 
     static Result create(uint32_t width, uint32_t height, bool debugLayer=false, bool apiDumpLayer=false, vsg::Window* shareWindow=nullptr, vsg::AllocationCallbacks* allocator=nullptr);
 
-    virtual bool valid() const { return _window && !glfwWindowShouldClose(_window); }
+    bool valid() const override { return _window && !glfwWindowShouldClose(_window); }
 
-    virtual bool pollEvents();
+    bool pollEvents(vsg::Events& events) override;
 
-    virtual bool resized() const;
+    bool resized() const override;
 
-    virtual void resize();
+    void resize() override;
 
     operator GLFWwindow* () { return _window; }
     operator const GLFWwindow* () const { return _window; }
diff --git a/src/vsg/viewer/Viewer.cpp b/src/vsg/viewer/Viewer.cpp
index 37109cd700..775023daa2 100644
--- a/src/vsg/viewer/Viewer.cpp
+++ b/src/vsg/viewer/Viewer.cpp
@@ -73,13 +73,79 @@ bool Viewer::done() const
     return false;
 }
 
+#include <vsg/ui/KeyEvent.h>
+#include <vsg/ui/PointerEvent.h>
+
 bool Viewer::pollEvents()
 {
     bool result = false;
+    Events events;
     for (auto& window : _windows)
     {
-        if (window->pollEvents()) result = true;
+        if (window->pollEvents(events)) result = true;
     }
+
+    if (result)
+    {
+        struct PrintEvents : public vsg::Visitor
+        {
+            vsg::clock::time_point start_point;
+            bool& close;
+
+            PrintEvents(vsg::clock::time_point in_start_point, bool& in_close) : start_point(in_start_point), close(in_close) {}
+
+            void apply(vsg::UIEvent& event)
+            {
+                std::cout<<"event : "<<event.className()<<", "<<std::chrono::duration<double>(event.time - start_point).count()<<std::endl;
+            }
+
+            void apply(vsg::ExposeWindowEvent& event)
+            {
+                std::cout<<"Expose window : "<<event.className()<<", "<<std::chrono::duration<double>(event.time - start_point).count()<<" "<<event.x<<", "<<event.y<<", "<<event.width<<", "<<event.height<<std::endl;
+            }
+
+            void apply(vsg::DeleteWindowEvent& event)
+            {
+                std::cout<<"Delete window : "<<event.className()<<", "<<std::chrono::duration<double>(event.time - start_point).count()<<std::endl;
+                close = true;
+            }
+
+            void apply(vsg::KeyReleaseEvent& keyRelease)
+            {
+                std::cout<<"KeyReleaeEvent : "<<keyRelease.className()<<", "<<std::chrono::duration<double>(keyRelease.time - start_point).count()<<", "<<keyRelease.keyBase<<std::endl;
+            }
+
+            void apply(vsg::KeyPressEvent& keyPress)
+            {
+                std::cout<<"KeyPressEvent : "<<keyPress.className()<<", "<<std::chrono::duration<double>(keyPress.time - start_point).count()<<", "<<keyPress.keyBase<<", "<<keyPress.keyModified<<std::endl;
+            }
+
+            void apply(vsg::ButtonPressEvent& buttonPress)
+            {
+                std::cout<<"ButtonPress : "<<buttonPress.className()<<", "<<std::chrono::duration<double>(buttonPress.time - start_point).count()<<", "<<buttonPress.x<<", "<<buttonPress.y<<", "<<buttonPress.mask<<", "<<buttonPress.button<<std::endl;
+            }
+
+            void apply(vsg::ButtonReleaseEvent& buttonRelease)
+            {
+                std::cout<<"ButtonRelease : "<<buttonRelease.className()<<", "<<std::chrono::duration<double>(buttonRelease.time - start_point).count()<<", "<<buttonRelease.x<<", "<<buttonRelease.y<<", "<<buttonRelease.mask<<", "<<buttonRelease.button<<std::endl;
+            }
+
+            void apply(vsg::MoveEvent& move)
+            {
+                std::cout<<"MoveEvent : "<<move.className()<<", "<<std::chrono::duration<double>(move.time - start_point).count()<<", "<<move.x<<", "<<move.y<<", "<<move.mask<<std::endl;
+            }
+        };
+
+        clock::time_point start_point = clock::now();
+
+        bool close = false;
+        PrintEvents print(start_point, close);
+        for(auto& vsg_event : events)
+        {
+            vsg_event->accept(print);
+        }
+    }
+
     return result;
 }
 
diff --git a/src/vsg/viewer/Win32_Window.cpp b/src/vsg/viewer/Win32_Window.cpp
index e0930e7c89..a4448aca71 100644
--- a/src/vsg/viewer/Win32_Window.cpp
+++ b/src/vsg/viewer/Win32_Window.cpp
@@ -20,14 +20,21 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 using namespace vsg;
 using namespace vsgWin32;
 
-namespace vsgWin32
+namespace vsg
 {
-    const std::string kWindowClassName = "vsg_Win32_Window_Class";
+    // Provide the Window::create(...) implementation that automatically maps to a GLFW_Window
+    Window::Result Window::create(const Window::Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
+    {
+        ref_ptr<vsg::Window> window = vsgWin32::Win32_Window::create(traits, debugLayer, apiDumpLayer, allocator);
+    }
+}
 
+namespace vsgWin32
+{
     vsg::Names vsgWin32::getInstanceExtensions()
     {
         // check the extensions are avaliable first
-        Names requiredExtensions = {"VK_KHR_surface", "VK_KHR_win32_surface"};
+        Names requiredExtensions = {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
 
         if (!vsg::isExtensionListSupported(requiredExtensions))
         {
@@ -95,7 +102,7 @@ Win32_Window::Result Win32_Window::create(const Traits& traits, bool debugLayer,
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = 0;
     wc.lpszMenuName = 0;
-    wc.lpszClassName = kWindowClassName.c_str();
+    wc.lpszClassName = traits.windowClass.c_str();
     wc.hIconSm = 0;
 
     if (::RegisterClassEx(&wc) == 0)
@@ -142,7 +149,7 @@ Win32_Window::Result Win32_Window::create(const Traits& traits, bool debugLayer,
     if (!::AdjustWindowRectEx(&windowRect, windowStyle, FALSE, extendedStyle)) return Result("Error: vsg::Win32_Window::create(...) failed to create Window, AdjustWindowRectEx failed.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
 
     // create the window
-    hwnd = ::CreateWindowEx(extendedStyle, kWindowClassName.c_str(), traits.title.c_str(), windowStyle,
+    hwnd = ::CreateWindowEx(extendedStyle, traits.windowClass.c_str(), traits.windowTitle.c_str(), windowStyle,
                             windowRect.left, windowRect.top, windowRect.right - windowRect.left, windowRect.bottom - windowRect.top,
                             NULL, NULL, ::GetModuleHandle(NULL), NULL);
 
@@ -237,11 +244,11 @@ Win32_Window::~Win32_Window()
         _window = nullptr;
 
         // when should we unregister??
-        ::UnregisterClass(kWindowClassName.c_str(), ::GetModuleHandle(NULL));
+        ::UnregisterClass(traits.windowClass.c_str(), ::GetModuleHandle(NULL));
     }
 }
 
-bool Win32_Window::pollEvents()
+bool Win32_Window::pollEvents(vsg::Events& events)
 {
     MSG msg;
 
diff --git a/src/vsg/viewer/Win32_Window.h b/src/vsg/viewer/Win32_Window.h
index da6506a79f..2a3e0c8515 100644
--- a/src/vsg/viewer/Win32_Window.h
+++ b/src/vsg/viewer/Win32_Window.h
@@ -35,13 +35,13 @@ namespace vsgWin32
 
         static Result create(const Traits& traits, bool debugLayer = false, bool apiDumpLayer = false, vsg::AllocationCallbacks* allocator = nullptr);
 
-        virtual bool valid() const { return _window && !_shouldClose; }
+        bool valid() const override { return _window && !_shouldClose; }
 
-        virtual bool pollEvents();
+        bool pollEvents(vsg::Events& events) override;
 
-        virtual bool resized() const;
+        bool resized() const override;
 
-        virtual void resize();
+        void resize() override;
 
         operator HWND () { return _window; }
         operator const HWND () const { return _window; }
diff --git a/src/vsg/viewer/Window.cpp b/src/vsg/viewer/Window.cpp
index 252e4dbd33..0627f1880d 100644
--- a/src/vsg/viewer/Window.cpp
+++ b/src/vsg/viewer/Window.cpp
@@ -16,12 +16,6 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #include <chrono>
 #include <iostream>
 
-#ifdef _WIN32
-#    include "Win32_Window.h"
-#else
-#    include "GLFW_Window.h"
-#endif
-
 namespace vsg
 {
 
@@ -173,14 +167,4 @@ namespace vsg
         return create(traits, debugLayer, apiDumpLayer, allocator);
     }
 
-    Window::Result Window::create(const Window::Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
-    {
-#ifdef _WIN32
-        ref_ptr<vsg::Window> window = vsgWin32::Win32_Window::create(traits, debugLayer, apiDumpLayer, allocator);
-#else
-        ref_ptr<vsg::Window> window = glfw::GLFW_Window::create(traits.width, traits.height, debugLayer, apiDumpLayer, traits.shareWindow, allocator);
-#endif
-        return Result(window);
-    }
-
 } // namespace vsg
diff --git a/src/vsg/viewer/Xcb_Window.cpp b/src/vsg/viewer/Xcb_Window.cpp
new file mode 100644
index 0000000000..3e55cd64a5
--- /dev/null
+++ b/src/vsg/viewer/Xcb_Window.cpp
@@ -0,0 +1,495 @@
+/* <editor-fold desc="MIT License">
+
+Copyright(c) 2018 Robert Osfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+</editor-fold> */
+
+#include "Xcb_Window.h"
+
+#include <vsg/vk/Extensions.h>
+#include <vsg/ui/PointerEvent.h>
+
+#include <xcb/xproto.h>
+
+#include <vulkan/vulkan_xcb.h>
+
+#include <thread>
+#include <chrono>
+#include <iostream>
+
+namespace vsg
+{
+    // Provide the Window::create(...) implementation that automatically maps to a Xcb_Window
+    Window::Result Window::create(const Window::Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
+    {
+        return xcb::Xcb_Window::create(traits, debugLayer, apiDumpLayer, allocator);
+    }
+}
+
+using namespace vsg;
+using namespace xcb;
+
+KeyboardMap::KeyboardMap()
+{
+    _modifierMask=0xff;
+}
+
+void KeyboardMap::add(uint16_t keycode, uint16_t modifier, KeySymbol key)
+{
+    //std::cout<<"Added ["<<keycode<<", "<<modifier<<"] "<<(int)key<<std::endl;
+    _keycodeMap[KeycodeModifier(keycode, modifier)] = key;
+}
+
+void KeyboardMap::add(uint16_t keycode, std::initializer_list<std::pair<uint16_t, KeySymbol> > combinations)
+{
+    for(auto [modifier, key] : combinations)
+    {
+        add(keycode, modifier, key);
+    }
+}
+
+Xcb_Surface::Xcb_Surface(vsg::Instance* instance, xcb_connection_t* connection, xcb_window_t window, vsg::AllocationCallbacks* allocator) :
+    vsg::Surface(VK_NULL_HANDLE, instance, allocator)
+{
+    VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{};
+    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
+    surfaceCreateInfo.connection = connection;
+    surfaceCreateInfo.window = window;
+
+    /*VkResult result =*/ vkCreateXcbSurfaceKHR(*instance, &surfaceCreateInfo, nullptr, &_surface);
+}
+
+// reference
+// https://harrylovescode.gitbooks.io/vulkan-api/content/chap04/chap04-linux.html
+
+vsg::Window::Result Xcb_Window::create(const Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
+{
+    try
+    {
+        ref_ptr<Window> window(new Xcb_Window(traits, debugLayer, apiDumpLayer, allocator));
+        return Result(window);
+    }
+    catch(vsg::Window::Result result)
+    {
+        return result;
+    }
+}
+
+
+Xcb_Window::Xcb_Window(const Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator)
+{
+    std::cout<<"Xcb_Window() "<<traits.x<<", "<<traits.y<<", "<<traits.width<<", "<<traits.height<<std::endl;
+
+    const char* displayName = 0;
+    int screenNum = traits.screenNum;
+
+    bool fullscreen = false;//true;
+    uint32_t override_redirect = 0; // fullscreen ? 1 : 0;
+
+    // open connection
+    _connection = xcb_connect(displayName, &screenNum);
+    if (xcb_connection_has_error(_connection))
+    {
+        // close connection
+        xcb_disconnect(_connection);
+        //return Result("Failed to created Window, unable able to establish xcb connection.", VK_ERROR_INVALID_EXTERNAL_HANDLE);  TODO need to throw?
+        return;
+    }
+
+    std::cout<<"    created connection "<<_connection<<" screenNum="<<screenNum<<" "<<std::endl;
+
+    // TODO, should record Traits within Window? Should pass back selected screeenNum?
+
+    // get the screeen
+    const xcb_setup_t* setup = xcb_get_setup(_connection);
+
+    _keyboard = new KeyboardMap;
+
+    {
+        std::cout<<"   *** stting up : min_keycode="<<(int)(setup->min_keycode)<<", max_keycode="<<(int)(setup->max_keycode)<<std::endl;
+
+        xcb_keycode_t min_keycode = setup->min_keycode;
+        xcb_keycode_t max_keycode = setup->max_keycode;
+
+#if 0
+        for(int keycode = min_keycode; keycode <= max_keycode; ++keycode)
+        {
+            std::cout<<"       keycode = "<<(int)keycode<<std::endl;
+        }
+#endif
+        xcb_get_keyboard_mapping_cookie_t keyboard_mapping_cookie = xcb_get_keyboard_mapping(_connection, min_keycode, (max_keycode-min_keycode)+1);
+        xcb_get_keyboard_mapping_reply_t * keyboard_mapping_reply = xcb_get_keyboard_mapping_reply(_connection, keyboard_mapping_cookie, nullptr);
+
+
+        std::cout<<"     keysyms_per_keycode = "<<int(keyboard_mapping_reply->keysyms_per_keycode)<<std::endl;
+        std::cout<<"     sequence = "<<keyboard_mapping_reply->sequence<<std::endl;
+        std::cout<<"     length = "<<keyboard_mapping_reply->length<<std::endl;
+
+        const xcb_keysym_t * keysyms = xcb_get_keyboard_mapping_keysyms (keyboard_mapping_reply);
+        int length = xcb_get_keyboard_mapping_keysyms_length (keyboard_mapping_reply);
+
+        std::cout<<"     xcb_get_keyboard_mapping_keysyms_length() = "<<length<<std::endl;
+        int keysyms_per_keycode = keyboard_mapping_reply->keysyms_per_keycode;
+        for(int i=0; i<length; i+=keysyms_per_keycode)
+        {
+            const xcb_keysym_t * keysym = &keysyms[i];
+            xcb_keycode_t keycode = min_keycode +i/keysyms_per_keycode;
+            std::cout<<"     keycode = "<<int(keycode)<<std::endl;
+            for(int m=0; m<keysyms_per_keycode; ++m)
+            {
+                std::cout<<"          keysym["<<m<<"] "<<int(keysym[m])<<" "<<std::hex<<int(keysym[m])<<std::dec;
+                if (keysym[m]>=32 && keysym[m]<256) std::cout<<" ["<<uint8_t(keysym[m])<<"]";
+                std::cout<<std::endl;
+                if (keysym[m]!=0) _keyboard->add(keycode, m, static_cast<KeySymbol>(keysym[m]));
+            }
+        }
+
+        free(keyboard_mapping_reply);
+    }
+
+
+
+    // select the appropriate screen for the window
+    xcb_screen_iterator_t screen_iterator = xcb_setup_roots_iterator(setup);
+    for (;screenNum>0; --screenNum) xcb_screen_next(&screen_iterator);
+    _screen = screen_iterator.data;
+    std::cout<<"    selected screen "<<_screen<<std::endl;
+
+    // generate the widnow id
+    _window = xcb_generate_id(_connection);
+
+    std::cout<<"    _window "<<_window<<std::endl;
+
+    std::cout<<"    screen.width_in_pixels = "<<_screen->width_in_pixels<<std::endl;
+    std::cout<<"    screen.height_in_pixels = "<<_screen->height_in_pixels<<std::endl;
+    std::cout<<"    width_in_millimeters = "<<_screen->width_in_millimeters<<std::endl;
+    std::cout<<"    height_in_millimeters = "<<_screen->height_in_millimeters<<std::endl;
+
+    uint8_t depth = XCB_COPY_FROM_PARENT;
+    xcb_window_t parent = _screen->root;
+    uint16_t border_width = 0;
+    uint16_t window_class = XCB_WINDOW_CLASS_INPUT_OUTPUT;
+    xcb_visualid_t visual = XCB_COPY_FROM_PARENT;
+    uint32_t value_mask = XCB_CW_BACK_PIXEL | XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
+    uint32_t value_list[] =
+    {
+        _screen->black_pixel,
+        override_redirect,
+        XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_PROPERTY_CHANGE
+    };
+
+    // ceate window
+    if (fullscreen)
+    {
+        xcb_create_window(_connection, depth, _window, parent,
+            0, 0, _screen->width_in_pixels, _screen->height_in_pixels,
+            border_width,
+            window_class,
+            visual,
+            value_mask,
+            value_list);
+    }
+    else
+    {
+        xcb_create_window(_connection, depth, _window, parent,
+            traits.x, traits.y, traits.width, traits.height,
+            border_width,
+            window_class,
+            visual,
+            value_mask,
+            value_list);
+    }
+
+    // set class of window to enable window manager configuration with rules for positioning
+    xcb_change_property(_connection, XCB_PROP_MODE_REPLACE, _window, XCB_ATOM_WM_CLASS, XCB_ATOM_STRING,  8, traits.windowClass.size(), traits.windowClass.data());
+
+    // set title of window
+    xcb_change_property(_connection, XCB_PROP_MODE_REPLACE, _window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING,  8, traits.windowTitle.size(), traits.windowTitle.data());
+
+    // make requests for the atoms
+    AtomRequest protocols(_connection, "WM_PROTOCOLS");
+    AtomRequest deleteWindow(_connection, "WM_DELETE_WINDOW");
+
+    // get the atoms request replies
+    _wmProtocols = protocols;
+    _wmDeleteWindow = deleteWindow;
+    xcb_change_property(_connection, XCB_PROP_MODE_REPLACE, _window, _wmProtocols, 4, 32, 1, &_wmDeleteWindow);
+
+    if (fullscreen)
+    {
+        AtomRequest wmState(_connection, "_NET_WM_STATE");
+        AtomRequest wmFullScreen(_connection, "_NET_WM_STATE_FULLSCREEN");
+        std::vector<xcb_atom_t> stateAtoms{ wmFullScreen };
+
+        xcb_change_property(_connection, XCB_PROP_MODE_REPLACE, _window, wmState, XCB_ATOM_ATOM, 32, stateAtoms.size(), stateAtoms.data());
+
+        std::cout<<"Set up full screen"<<std::endl;
+    }
+
+
+    // set whethert the window should have a border or not, and if so what resize/move/close functions to enable
+    AtomRequest motifHintAtom(_connection, "_MOTIF_WM_HINTS");
+    MotifHints hints = fullscreen ? MotifHints::borderless() : MotifHints::window();
+    xcb_change_property(_connection, XCB_PROP_MODE_REPLACE, _window, motifHintAtom, motifHintAtom, 32, 5, &hints);
+
+
+    std::cout<<"Create window : "<<traits.windowTitle<<std::endl;
+
+    // work out the X server timestamp by checking for the property notify events that result for the above xcb_change_property calls.
+    _first_xcb_timestamp = 0;
+    _first_xcb_time_point = vsg::clock::now();
+    {
+        xcb_generic_event_t *event = nullptr;
+        while (_first_xcb_timestamp==0 && (event = xcb_wait_for_event(_connection)))
+        {
+            uint8_t response_type = event->response_type & ~0x80;
+            if (response_type==XCB_PROPERTY_NOTIFY)
+            {
+                auto propety_notify = reinterpret_cast<const xcb_property_notify_event_t*>(event);
+                _first_xcb_timestamp = propety_notify->time;
+                _first_xcb_time_point = vsg::clock::now();
+            }
+            free(event);
+        }
+    }
+    xcb_map_window(_connection, _window);
+
+#if 0
+    // reconfigure the window position and size.
+    const uint32_t values[] = { 100, 200, 300, 400 };
+    xcb_configure_window (_connection, _window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values);
+    xcb_flush(_connection);
+#endif
+
+
+    //xcb_flush(_connection);
+
+    if (traits.shareWindow)
+    {
+        throw Result("Error: vsg::Xcb_Window::create(...) Sharing of Windows not Not supported yet.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+    }
+    else
+    {
+        Names instanceExtensions = {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME};
+
+        vsg::Names requestedLayers;
+        if (debugLayer)
+        {
+            instanceExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+            requestedLayers.push_back("VK_LAYER_LUNARG_standard_validation");
+            if (apiDumpLayer) requestedLayers.push_back("VK_LAYER_LUNARG_api_dump");
+        }
+
+        vsg::Names validatedNames = vsg::validateInstancelayerNames(requestedLayers);
+
+        vsg::Names deviceExtensions;
+        deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+
+        vsg::ref_ptr<vsg::Instance> instance = vsg::Instance::create(instanceExtensions, validatedNames, allocator);
+        if (!instance) throw Result("Error: vsg::Xcb_Window::create(...) failed to create Window, unable to create Vulkan instance.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+
+        std::cout<<"Instance created"<<std::endl;
+
+        // use GLFW to create surface
+        vsg::ref_ptr<vsg::Surface> surface(new Xcb_Surface(instance, _connection, _window, allocator));
+        if (!surface) throw Result("Error: vsg::Xcb_Window::create(...) failed to create Window, unable to create GLFWSurface.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+
+        std::cout<<"Surface created"<<std::endl;
+
+        // set up device
+        vsg::ref_ptr<vsg::PhysicalDevice> physicalDevice = vsg::PhysicalDevice::create(instance, VK_QUEUE_GRAPHICS_BIT, surface);
+        if (!physicalDevice) throw Result("Error: vsg::Xcb_Window::create(...) failed to create Window, no Vulkan PhysicalDevice supported.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+
+        std::cout<<"Physical Device created"<<std::endl;
+
+        vsg::ref_ptr<vsg::Device> device = vsg::Device::create(physicalDevice, validatedNames, deviceExtensions, allocator);
+        if (!device) throw Result("Error: vsg::Xcb_Window::create(...) failed to create Window, unable to create Vulkan logical Device.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+
+        std::cout<<"Device created"<<std::endl;
+
+        // set up renderpass with the imageFormat that the swap chain will use
+        vsg::SwapChainSupportDetails supportDetails = vsg::querySwapChainSupport(*physicalDevice, *surface);
+        VkSurfaceFormatKHR imageFormat = vsg::selectSwapSurfaceFormat(supportDetails);
+        VkFormat depthFormat = VK_FORMAT_D24_UNORM_S8_UINT; //VK_FORMAT_D32_SFLOAT; // VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_SFLOAT_S8_UINT
+        vsg::ref_ptr<vsg::RenderPass> renderPass = vsg::RenderPass::create(device, imageFormat.format, depthFormat, allocator);
+        if (!renderPass) throw Result("Error: vsg::Xcb_Window::create(...) failed to create Window, unable to create Vulkan RenderPass.", VK_ERROR_INVALID_EXTERNAL_HANDLE);
+
+        _instance = instance;
+        _surface = surface;
+        _physicalDevice = physicalDevice;
+        _device = device;
+        _renderPass = renderPass;
+        _debugLayersEnabled = debugLayer;
+
+        std::cout<<"Renderpass created"<<std::endl;
+    }
+
+    xcb_flush(_connection);
+
+    // sleep to give the window manage time to do any repositing and resizing
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    // build the swap chain, reuse the reize() for this
+    resize();
+}
+
+
+Xcb_Window::~Xcb_Window()
+{
+    if (_connection!=nullptr)
+    {
+        if (_window!=0) xcb_destroy_window(_connection, _window);
+
+        xcb_flush(_connection);
+        xcb_disconnect(_connection);
+
+        std::cout<<"Disconnect"<<std::endl;
+    }
+    std::cout<<"Destruction Xcb_Widnow"<<std::endl;
+}
+
+bool Xcb_Window::valid() const
+{
+    return _window!=9 && !_closeEventRecieved;
+}
+
+bool Xcb_Window::pollEvents(Events& events)
+{
+    unsigned numEventsBefore = events.size();
+    xcb_generic_event_t *event;
+    int i=0;
+    while ((event = xcb_poll_for_event(_connection)) )
+    {
+        ++i;
+        uint8_t response_type = event->response_type & ~0x80;
+        switch(response_type)
+        {
+#if 0
+            case(XCB_CONFIGURE_NOTIFY):
+            {
+                auto configure = reinterpret_cast<const xcb_configure_notify_event_t*>(event);
+
+                //vsg::clock::time_point event_time = vsg::clock::now();
+                //events.emplace_back(new vsg::ExposeWindowEvent(this, event_time, expose->x, expose->y, expose->width, expose->height));
+
+                std::cout<<"XCB_CONFIGURE_NOTIFY    x = "<<configure->x<<", y = "<<configure->y<<", "<<configure->width<<", "<<configure->height<<std::endl;
+
+                _windowResized = (configure->width != _extent2D.width || configure->height != _extent2D.height);
+                break;
+            }
+#endif
+            case(XCB_EXPOSE):
+            {
+                auto expose = reinterpret_cast<const xcb_expose_event_t*>(event);
+
+                vsg::clock::time_point event_time = vsg::clock::now();
+                events.emplace_back(new vsg::ExposeWindowEvent(this, event_time, expose->x, expose->y, expose->width, expose->height));
+
+                _windowResized = (expose->width != _extent2D.width || expose->height != _extent2D.height);
+
+                break;
+            }
+            case XCB_CLIENT_MESSAGE:
+            {
+                auto client_message = reinterpret_cast<const xcb_client_message_event_t*>(event);
+
+                if (client_message->data.data32[0]==_wmDeleteWindow)
+                {
+                    vsg::clock::time_point event_time = vsg::clock::now();
+                    events.emplace_back(new vsg::DeleteWindowEvent(this, event_time));
+
+                    _closeEventRecieved = true;
+                }
+                break;
+            }
+            case XCB_KEY_PRESS:
+            {
+                auto key_press = reinterpret_cast<const xcb_key_press_event_t*>(event);
+
+                vsg::clock::time_point event_time = _first_xcb_time_point + std::chrono::milliseconds(key_press->time-_first_xcb_timestamp);
+                vsg::KeySymbol keySymbol = _keyboard->getKeySymbol(key_press->detail, 0);
+                vsg::KeySymbol keySymbolModified = _keyboard->getKeySymbol(key_press->detail, key_press->state);
+                events.emplace_back(new vsg::KeyPressEvent(this, event_time, keySymbol, keySymbolModified, KeyModifier(key_press->state), 0));
+
+                break;
+            }
+            case XCB_KEY_RELEASE:
+            {
+                auto key_release = reinterpret_cast<const xcb_key_release_event_t*>(event);
+
+                vsg::clock::time_point event_time = _first_xcb_time_point + std::chrono::milliseconds(key_release->time-_first_xcb_timestamp);
+                vsg::KeySymbol keySymbol = _keyboard->getKeySymbol(key_release->detail, 0);
+                vsg::KeySymbol keySymbolModified = _keyboard->getKeySymbol(key_release->detail, key_release->state);
+                events.emplace_back(new vsg::KeyReleaseEvent(this, event_time, keySymbol, keySymbolModified, KeyModifier(key_release->state), 0));
+
+                break;
+            }
+            case(XCB_BUTTON_PRESS):
+            {
+                auto button_press = reinterpret_cast<const xcb_button_press_event_t*>(event);
+
+                vsg::clock::time_point event_time = _first_xcb_time_point + std::chrono::milliseconds(button_press->time-_first_xcb_timestamp);
+                events.emplace_back(new vsg::ButtonPressEvent(this, event_time, button_press->event_x, button_press->event_y, vsg::ButtonMask(button_press->state), button_press->detail));
+
+                break;
+            }
+            case(XCB_BUTTON_RELEASE):
+            {
+                auto button_release = reinterpret_cast<const xcb_button_release_event_t*>(event);
+
+                vsg::clock::time_point event_time = _first_xcb_time_point + std::chrono::milliseconds(button_release->time-_first_xcb_timestamp);
+                events.emplace_back(new vsg::ButtonPressEvent(this, event_time, button_release->event_x, button_release->event_y, vsg::ButtonMask(button_release->state), button_release->detail));
+
+                break;
+            }
+            case(XCB_MOTION_NOTIFY):
+            {
+                auto motion_notify = reinterpret_cast<const xcb_motion_notify_event_t*>(event);
+
+                vsg::clock::time_point event_time = _first_xcb_time_point + std::chrono::milliseconds(motion_notify->time-_first_xcb_timestamp);
+                events.emplace_back(new vsg::MoveEvent(this, event_time, motion_notify->event_x, motion_notify->event_y, vsg::ButtonMask(motion_notify->state)));
+
+                break;
+            }
+            default:
+            {
+                std::cout<<"event not handled, response_type = "<<(int)response_type<<std::endl;
+                break;
+            }
+        }
+        free(event);
+    }
+    unsigned numEventsAfter = events.size();
+    return numEventsBefore!=numEventsAfter;
+}
+
+bool Xcb_Window::resized() const
+{
+#if 0
+    return _windowResized;
+#else
+    xcb_get_geometry_reply_t* geometry_reply = xcb_get_geometry_reply(_connection, xcb_get_geometry(_connection, _window), nullptr);
+    if (geometry_reply)
+    {
+        return (geometry_reply->width != _extent2D.width || geometry_reply->height != _extent2D.height);
+    }
+
+    return false;
+#endif
+}
+
+void Xcb_Window::resize()
+{
+    xcb_get_geometry_reply_t* geometry_reply = xcb_get_geometry_reply(_connection, xcb_get_geometry(_connection, _window), nullptr);
+    if (geometry_reply)
+    {
+        buildSwapchain(geometry_reply->width, geometry_reply->height);
+    }
+    _windowResized = false;
+}
diff --git a/src/vsg/viewer/Xcb_Window.h b/src/vsg/viewer/Xcb_Window.h
new file mode 100644
index 0000000000..ace4f5cafc
--- /dev/null
+++ b/src/vsg/viewer/Xcb_Window.h
@@ -0,0 +1,247 @@
+/* <editor-fold desc="MIT License">
+
+Copyright(c) 2018 Robert Osfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+</editor-fold> */
+
+#pragma once
+
+#include <vsg/viewer/Window.h>
+#include <vsg/ui/KeyEvent.h>
+
+#include <xcb/xcb.h>
+
+#include <iostream>
+
+namespace xcb
+{
+
+    class KeyboardMap : public vsg::Object
+    {
+    public:
+        KeyboardMap();
+
+        using KeycodeModifier = std::pair<uint16_t, uint16_t>;
+        using KeycodeMap = std::map<KeycodeModifier, vsg::KeySymbol>;
+
+        void add(uint16_t keycode, uint16_t modifier, vsg::KeySymbol key);
+
+        void add(uint16_t keycode, std::initializer_list<std::pair<uint16_t, vsg::KeySymbol> > combinations);
+
+        vsg::KeySymbol getKeySymbol(uint16_t keycode, uint16_t modifier)
+        {
+            auto itr = _keycodeMap.find(KeycodeModifier(keycode, 0));
+            if (itr==_keycodeMap.end()) return vsg::KEY_Undefined;
+
+            vsg::KeySymbol baseKeySymbol = itr->second;
+            if (modifier==0) return baseKeySymbol;
+
+            bool shift = (modifier & vsg::MODKEY_Shift)!=0;
+            uint16_t index = 0;
+
+            if (baseKeySymbol>=vsg::KEY_KP_Space && baseKeySymbol<=vsg::KEY_KP_Divide)
+            {
+                // numeric keypad values
+                bool numLock = ((modifier & vsg::MODKEY_NumLock)!=0);
+                index = (numLock && !shift) ? 1 : 0;
+            }
+            else
+            {
+                bool capsLock = (modifier & vsg::MODKEY_CapsLock)!=0;
+                index = (capsLock ? !shift : shift) ? 1 : 0;
+            }
+            if (index==0) return baseKeySymbol;
+
+            if (itr = _keycodeMap.find(KeycodeModifier(keycode, index)); itr!=_keycodeMap.end()) return itr->second;
+            return vsg::KEY_Undefined;
+        }
+
+    protected:
+        KeycodeMap _keycodeMap;
+        uint16_t   _modifierMask;
+    };
+
+
+    // window decoation
+    struct MotifHints
+    {
+        enum Flags : uint32_t
+        {
+            FLAGS_FUNCTIONS   = 1<<0,
+            FLAGS_DECORATIONS = 1<<1,
+            FLAGS_INPUT_MODE  = 1<<2,
+            FLAGS_STATUS      = 1<<3,
+        };
+
+        enum Functions : uint32_t
+        {
+            FUNC_ALL = 1<<0,
+            FUNC_RESIZE = 1<<1,
+            FUNC_MOVE = 1<<2,
+            FUNC_MINIMUMSIZE = 1<<3,
+            FUNC_MAXIMUMSIZE = 1<<4,
+            FUNC_CLOSE = 1<<5
+        };
+
+        enum Decorations : uint32_t
+        {
+            DECOR_ALL = 1<<0,
+            DECOR_BORDER = 1<<1,
+            DECOR_RESIZE = 1<<2,
+            DECOR_TITLE = 1<<3,
+            DECOR_MENU = 1<<4,
+            DECOR_MINIMUMSIZE = 1<<5,
+            DECOR_MAXIMUMSIZE = 1<<6
+        };
+
+        static MotifHints borderless()
+        {
+            MotifHints hints;
+            hints.flags = FLAGS_DECORATIONS;
+            return hints;
+        }
+
+        static MotifHints window(bool resize=true, bool move=true, bool close=true)
+        {
+            MotifHints hints;
+            hints.flags = FLAGS_DECORATIONS | FLAGS_FUNCTIONS;
+            hints.functions = 0;
+            if (resize) hints.functions |= FUNC_RESIZE;
+            if (move) hints.functions |= FUNC_MOVE;
+            if (close) hints.functions |= FUNC_CLOSE;
+            hints.decorations = DECOR_ALL;
+            return hints;
+        }
+
+
+        uint32_t flags{};
+        uint32_t functions{};
+        uint32_t decorations{};
+        int32_t  input_mode{};
+        uint32_t status{};
+    };
+
+    class AtomRequest
+    {
+    public:
+        AtomRequest(xcb_connection_t* connection, const char* atom_name):
+            _connection(connection)
+        {
+            _cookie = xcb_intern_atom(connection, false, strlen(atom_name), atom_name);
+        }
+
+        operator xcb_atom_t ()
+        {
+            if (_connection)
+            {
+                xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(_connection, _cookie, nullptr);
+                if (reply)
+                {
+                    _atom = reply->atom;
+                    free(reply);
+                }
+                _connection = nullptr;
+            }
+            return _atom;
+        }
+
+        xcb_connection_t* _connection{};
+        xcb_intern_atom_cookie_t _cookie{};
+        xcb_atom_t _atom{};
+    };
+
+    bool getWindowGeometry(xcb_connection_t* connection, xcb_drawable_t window, int32_t& x, int32_t& y, uint32_t& width, uint32_t& height)
+    {
+        xcb_get_geometry_cookie_t geometry_cookie = xcb_get_geometry(connection, window);
+        xcb_query_tree_cookie_t tree_cookie = xcb_query_tree(connection, window);
+
+        xcb_get_geometry_reply_t* geometry_reply = xcb_get_geometry_reply(connection, geometry_cookie, nullptr);
+        xcb_query_tree_reply_t* tree_reply = xcb_query_tree_reply(connection, tree_cookie, nullptr);
+
+        if (geometry_reply)
+        {
+            x = geometry_reply->x;
+            y = geometry_reply->y;
+            width  = geometry_reply->width;
+            height = geometry_reply->height;
+
+            if (tree_reply)
+            {
+                xcb_translate_coordinates_cookie_t trans_cookie = xcb_translate_coordinates(connection, window, tree_reply->parent, x, y);
+                xcb_translate_coordinates_reply_t* trans_reply = xcb_translate_coordinates_reply(connection, trans_cookie, nullptr);
+                if (trans_reply)
+                {
+                    std::cout<<"trans->dst_x = "<<trans_reply->dst_x<<", trans->dst_y = "<<trans_reply->dst_y<<std::endl;
+                    free(trans_reply);
+                }
+
+                trans_cookie = xcb_translate_coordinates(connection, window, geometry_reply->root, x, y);
+                trans_reply = xcb_translate_coordinates_reply(connection, trans_cookie, nullptr);
+                if (trans_reply)
+                {
+                    std::cout<<"2nd trans->dst_x = "<<trans_reply->dst_x<<", trans->dst_y = "<<trans_reply->dst_y<<std::endl;
+                    free(trans_reply);
+                }
+
+                free(tree_reply);
+            }
+
+            free(geometry_reply);
+            return true;
+        }
+        return false;
+    }
+
+    class Xcb_Surface : public vsg::Surface
+    {
+    public:
+        Xcb_Surface(vsg::Instance* instance, xcb_connection_t* connection, xcb_window_t window, vsg::AllocationCallbacks* allocator = nullptr);
+    };
+
+    class Xcb_Window : public vsg::Window
+    {
+    public:
+
+        Xcb_Window() = delete;
+        Xcb_Window(const Xcb_Window&) = delete;
+        Xcb_Window& operator = (const Xcb_Window&) = delete;
+
+        static Result create(const Traits& traits, bool debugLayer=false, bool apiDumpLayer=false, vsg::AllocationCallbacks* allocator=nullptr);
+
+        bool valid() const override;
+
+        bool pollEvents(vsg::Events& events) override;
+
+        bool resized() const override;
+
+        void resize() override;
+
+    protected:
+        Xcb_Window(const Traits& traits, bool debugLayer, bool apiDumpLayer, vsg::AllocationCallbacks* allocator);
+
+        ~Xcb_Window();
+
+        xcb_connection_t* _connection = nullptr;
+        xcb_screen_t* _screen = nullptr;
+        xcb_window_t _window{};
+        xcb_atom_t _wmProtocols{};
+        xcb_atom_t _wmDeleteWindow{};
+
+        bool _closeEventRecieved = false;
+        bool _windowResized = false;
+
+        xcb_timestamp_t _first_xcb_timestamp = 0;
+        vsg::clock::time_point _first_xcb_time_point;
+
+        vsg::ref_ptr<KeyboardMap> _keyboard;
+    };
+
+
+}
+
diff --git a/src/vsg/vsgConfig.cmake b/src/vsg/vsgConfig.cmake
index 4211d59203..9eb1150619 100644
--- a/src/vsg/vsgConfig.cmake
+++ b/src/vsg/vsgConfig.cmake
@@ -2,8 +2,15 @@ include(CMakeFindDependencyMacro)
 
 find_dependency(Vulkan)
 
-if(NOT WIN32)
+if (ANDROID)
+    # TODO
+elseif (WIN32)
+    # just use native windowing
+elseif (APPLE)
     find_dependency(glfw3)
+else()
+    find_package(PkgConfig)
+    pkg_check_modules(xcb REQUIRED IMPORTED_TARGET xcb)
 endif()
 
 include("${CMAKE_CURRENT_LIST_DIR}/vsgTargets.cmake")