diff --git a/BUILD.md b/BUILD.md
index 216135a..143cf9c 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -145,11 +145,13 @@
 cd GL-Next  # cd to the root of the xgl git repository
 mkdir _out64
 cd _out64
-cmake -G "Visual Studio 12 Win64" ..
+cmake -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=Debug ..
 ```
 
 At this point, you can use Windows Explorer to launch Visual Studio by double-clicking on the "XGL.sln" file in the _out64 folder.  Once Visual Studio comes up, you can select "Debug" or "Release" from a drop-down list.  You can start a build with either the menu (Build->Build Solution), or a keyboard shortcut (Ctrl+Shift+B).  As part of the build process, Python scripts will create additional Visual Studio files and projects, along with additional source files.  All of these auto-generated files are under the "_out64" folder.
 
+XGL programs must be able to find and use the XGL.dll libary. Make sure it is either installed in the C:\Windows\System32 folder, or the PATH enviroment variable includes the folder that it is located in.
+
 To run XGL programs you must have an appropriate icd (installable client driver) that is either installed in the C:\Windows\System32 folder, or pointed to by the
 environment variable LIBXGL_DRIVERS_PATH.  This environment variable cannot be set with Cygwin, but must be set via Windows, and may require a system restart in order for it to take effect.  Here is how to set this environment variable on a Windows 7 system:
 
diff --git a/glave-generate.py b/glave-generate.py
index bac6435..d146e0c 100755
--- a/glave-generate.py
+++ b/glave-generate.py
@@ -2294,12 +2294,10 @@
         ri_body.append('int xglReplay::init(glv_replay::Display & disp)')
         ri_body.append('{')
         ri_body.append('    int err;')
-        ri_body.append('#if defined _WIN64')
-        ri_body.append('    HMODULE handle = LoadLibrary("xgl64.dll" );')
-        ri_body.append('#elif defined _WIN32')
-        ri_body.append('    HMODULE handle = LoadLibrary("xgl32.dll" );')
-        ri_body.append('#elif defined PLATFORM_LINUX')
+        ri_body.append('#if defined PLATFORM_LINUX')
         ri_body.append('    void * handle = dlopen("libXGL.so", RTLD_LAZY);')
+        ri_body.append('#else')
+        ri_body.append('    HMODULE handle = LoadLibrary("xgl.dll" );')
         ri_body.append('#endif\n')
         ri_body.append('    if (handle == NULL) {')
         ri_body.append('        glv_LogError("Failed to open xgl library.\\n");')
@@ -3078,18 +3076,32 @@
 
     def _gen_replay_wsi_associate_connection(self):
         wac_body = []
+        wac_body.append('#ifdef WIN32')
+        wac_body.append('            //TBD')
+        wac_body.append('            replayResult = XGL_SUCCESS;')
+        wac_body.append('#else')
         wac_body.append('            //associate with the replayers Wsi connection rather than tracers')
         wac_body.append('            replayResult = m_xglFuncs.real_xglWsiX11AssociateConnection(remap(pPacket->gpu), &(m_display->m_WsiConnection));')
+        wac_body.append('#endif')
         return "\n".join(wac_body)
 
     def _gen_replay_wsi_get_msc(self):
         wgm_body = []
+        wgm_body.append('#ifdef WIN32')
+        wgm_body.append('            //TBD')
+        wgm_body.append('            replayResult = XGL_SUCCESS;')
+        wgm_body.append('#else')
         wgm_body.append('            xcb_window_t window = m_display->m_XcbWindow;')
         wgm_body.append('            replayResult = m_xglFuncs.real_xglWsiX11GetMSC(remap(pPacket->device), window, pPacket->crtc, pPacket->pMsc);')
+        wgm_body.append('#endif')
         return "\n".join(wgm_body)
 
     def _gen_replay_wsi_create_presentable_image(self):
         cpi_body = []
+        cpi_body.append('#ifdef WIN32')
+        cpi_body.append('            //TBD')
+        cpi_body.append('            replayResult = XGL_SUCCESS;')
+        cpi_body.append('#else')
         cpi_body.append('            XGL_IMAGE img;')
         cpi_body.append('            XGL_GPU_MEMORY mem;')
         cpi_body.append('            m_display->imageHeight.push_back(pPacket->pCreateInfo->extent.height);')
@@ -3104,10 +3116,15 @@
         cpi_body.append('                m_display->imageHandles.push_back(img);')
         cpi_body.append('                m_display->imageMemory.push_back(mem);')
         cpi_body.append('            }')
+        cpi_body.append('#endif')
         return "\n".join(cpi_body)
 
     def _gen_replay_wsi_queue_present(self):
         wqp_body = []
+        wqp_body.append('#ifdef WIN32')
+        wqp_body.append('            //TBD')
+        wqp_body.append('            replayResult = XGL_SUCCESS;')
+        wqp_body.append('#else')
         wqp_body.append('            XGL_WSI_X11_PRESENT_INFO pInfo;')
         wqp_body.append('            std::vector<int>::iterator it;')
         wqp_body.append('            memcpy(&pInfo, pPacket->pPresentInfo, sizeof(XGL_WSI_X11_PRESENT_INFO));')
@@ -3130,6 +3147,7 @@
         wqp_body.append('                    }')
         wqp_body.append('                }')
         wqp_body.append('            }')
+        wqp_body.append('#endif')
         wqp_body.append('            m_display->m_frameNumber++;')
         return "\n".join(wqp_body)
 
@@ -3462,7 +3480,11 @@
         header_txt = []
         header_txt.append('#pragma once\n')
         header_txt.append('#include "xgl.h"')
+        header_txt.append('#if defined(PLATFORM_LINUX)')
         header_txt.append('#include "xglWsiX11Ext.h"\n')
+        header_txt.append('#else')
+        header_txt.append('#include "xglWsiWinExt.h"')
+        header_txt.append('#endif')
         header_txt.append('void AttachHooks_xglwsix11ext();')
         header_txt.append('void DetachHooks_xglwsix11ext();')
         return "\n".join(header_txt)
@@ -3498,7 +3520,11 @@
     def generate_header(self):
         header_txt = []
         header_txt.append('#pragma once\n')
+        header_txt.append('#if defined(PLATFORM_LINUX)')
         header_txt.append('#include "xglWsiX11Ext.h"')
+        header_txt.append('#else')
+        header_txt.append('#include "xglWsiWinExt.h"')
+        header_txt.append('#endif')
         header_txt.append('#include "glv_trace_packet_utils.h"\n')
         return "\n".join(header_txt)
 
@@ -3566,13 +3592,19 @@
         header_txt.append('#include <map>')
         header_txt.append('#include <vector>')
         header_txt.append('#include <string>')
+        header_txt.append('#if defined(PLATFORM_LINUX)')
         header_txt.append('#include <xcb/xcb.h>\n')
+        header_txt.append('#endif')
         header_txt.append('#include "glvreplay_window.h"')
         header_txt.append('#include "glvreplay_factory.h"')
         header_txt.append('#include "glv_trace_packet_identifiers.h"\n')
         header_txt.append('#include "xgl.h"')
         header_txt.append('#include "xglDbg.h"')
+        header_txt.append('#if defined(PLATFORM_LINUX)')
         header_txt.append('#include "xglWsiX11Ext.h"')
+        header_txt.append('#else')
+        header_txt.append('#include "xglWsiWinExt.h"')
+        header_txt.append('#endif')
         return "\n".join(header_txt)
 
     def generate_body(self):
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index cfada53..d572a19 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -24,14 +24,24 @@
  */
 
 #include "nulldrv.h"
+#include <stdio.h>
 
+#if 0
+#define NULLDRV_LOG_FUNC \
+    do { \
+        fflush(stdout); \
+        fflush(stderr); \
+        printf("null driver: %s\n", __FUNCTION__); \
+        fflush(stdout); \
+    } while (0)
+#else
+    #define NULLDRV_LOG_FUNC do { } while (0)
+#endif
+
+// The null driver supports all WSI extenstions ... for now ...
 static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
-#ifdef ENABLE_WSI_X11
 	[NULLDRV_EXT_WSI_X11] = "XGL_WSI_X11",
-#endif
-#ifdef ENABLE_WSI_WINDOWS
-	[NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS",
-#endif
+	[NULLDRV_EXT_WSI_WINDOWS] = "XGL_WSI_WINDOWS"
 };
 
 static struct nulldrv_base *nulldrv_base(XGL_BASE_OBJECT base)
@@ -781,6 +791,30 @@
     return XGL_SUCCESS;
 }
 
+static struct nulldrv_buf *nulldrv_buf(XGL_BUFFER buf)
+{
+    return (struct nulldrv_buf *) buf;
+}
+
+static XGL_RESULT nulldrv_buf_view_create(struct nulldrv_dev *dev,
+                                 const XGL_BUFFER_VIEW_CREATE_INFO *info,
+                                 struct nulldrv_buf_view **view_ret)
+{
+    struct nulldrv_buf *buf = nulldrv_buf(info->buffer);
+    struct nulldrv_buf_view *view;
+
+    view = (struct nulldrv_buf_view *) nulldrv_base_create(dev, sizeof(*view),
+            XGL_DBG_OBJECT_BUFFER_VIEW);
+    if (!view)
+        return XGL_ERROR_OUT_OF_MEMORY;
+
+    view->buf = buf;
+
+    *view_ret = view;
+
+    return XGL_SUCCESS;
+}
+
 
 //*********************************************
 // Driver entry points
@@ -791,6 +825,7 @@
     const XGL_BUFFER_CREATE_INFO*               pCreateInfo,
     XGL_BUFFER*                                 pBuffer)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_buf_create(dev, pCreateInfo, (struct nulldrv_buf **) pBuffer);
@@ -801,6 +836,7 @@
     const XGL_CMD_BUFFER_CREATE_INFO*           pCreateInfo,
     XGL_CMD_BUFFER*                             pCmdBuffer)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_cmd_create(dev, pCreateInfo,
@@ -811,18 +847,21 @@
     XGL_CMD_BUFFER                              cmdBuffer,
     const XGL_CMD_BUFFER_BEGIN_INFO            *info)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglEndCommandBuffer(
     XGL_CMD_BUFFER                              cmdBuffer)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglResetCommandBuffer(
     XGL_CMD_BUFFER                              cmdBuffer)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -833,6 +872,7 @@
     uint32_t                                    counterCount,
     const uint32_t*                             pData)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdLoadAtomicCounters(
@@ -843,6 +883,7 @@
     XGL_BUFFER                                  srcBuffer,
     XGL_GPU_SIZE                                srcOffset)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdSaveAtomicCounters(
@@ -853,17 +894,20 @@
     XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDbgMarkerBegin(
     XGL_CMD_BUFFER                              cmdBuffer,
     const char*                                 pMarker)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDbgMarkerEnd(
     XGL_CMD_BUFFER                              cmdBuffer)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdCopyBuffer(
@@ -873,6 +917,7 @@
     uint32_t                                    regionCount,
     const XGL_BUFFER_COPY*                      pRegions)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdCopyImage(
@@ -882,6 +927,7 @@
     uint32_t                                    regionCount,
     const XGL_IMAGE_COPY*                       pRegions)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdCopyBufferToImage(
@@ -891,6 +937,7 @@
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdCopyImageToBuffer(
@@ -900,6 +947,7 @@
     uint32_t                                    regionCount,
     const XGL_BUFFER_IMAGE_COPY*                pRegions)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdCloneImageData(
@@ -909,6 +957,7 @@
     XGL_IMAGE                                   destImage,
     XGL_IMAGE_LAYOUT                            destImageLayout)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdUpdateBuffer(
@@ -918,6 +967,7 @@
     XGL_GPU_SIZE                                dataSize,
     const uint32_t*                             pData)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdFillBuffer(
@@ -927,6 +977,7 @@
     XGL_GPU_SIZE                                fillSize,
     uint32_t                                    data)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdClearColorImage(
@@ -936,6 +987,7 @@
     uint32_t                                    rangeCount,
     const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdClearColorImageRaw(
@@ -945,6 +997,7 @@
     uint32_t                                    rangeCount,
     const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdClearDepthStencil(
@@ -955,6 +1008,7 @@
     uint32_t                                    rangeCount,
     const XGL_IMAGE_SUBRESOURCE_RANGE*          pRanges)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdResolveImage(
@@ -964,6 +1018,7 @@
     uint32_t                                    rectCount,
     const XGL_IMAGE_RESOLVE*                    pRects)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBeginQuery(
@@ -972,6 +1027,7 @@
     uint32_t                                    slot,
     XGL_FLAGS                                   flags)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdEndQuery(
@@ -979,6 +1035,7 @@
     XGL_QUERY_POOL                              queryPool,
     uint32_t                                    slot)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdResetQueryPool(
@@ -987,6 +1044,7 @@
     uint32_t                                    startQuery,
     uint32_t                                    queryCount)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdSetEvent(
@@ -994,12 +1052,14 @@
     XGL_EVENT                                   event_,
     XGL_SET_EVENT                               pipeEvent)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdResetEvent(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_EVENT                                   event_)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdWriteTimestamp(
@@ -1008,6 +1068,7 @@
     XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindPipeline(
@@ -1015,6 +1076,7 @@
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_PIPELINE                                pipeline)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
@@ -1022,6 +1084,7 @@
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_PIPELINE_DELTA                          delta)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
@@ -1029,6 +1092,7 @@
     XGL_STATE_BIND_POINT                        stateBindPoint,
     XGL_DYNAMIC_STATE_OBJECT                    state)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindDescriptorSet(
@@ -1037,6 +1101,7 @@
     XGL_DESCRIPTOR_SET                          descriptorSet,
     const uint32_t*                             pUserData)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindVertexBuffer(
@@ -1045,6 +1110,7 @@
     XGL_GPU_SIZE                                offset,
     uint32_t                                    binding)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdBindIndexBuffer(
@@ -1053,6 +1119,7 @@
     XGL_GPU_SIZE                                offset,
     XGL_INDEX_TYPE                              indexType)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDraw(
@@ -1062,6 +1129,7 @@
     uint32_t                                    firstInstance,
     uint32_t                                    instanceCount)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDrawIndexed(
@@ -1072,6 +1140,7 @@
     uint32_t                                    firstInstance,
     uint32_t                                    instanceCount)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDrawIndirect(
@@ -1081,6 +1150,7 @@
     uint32_t                                    count,
     uint32_t                                    stride)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDrawIndexedIndirect(
@@ -1090,6 +1160,7 @@
     uint32_t                                    count,
     uint32_t                                    stride)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDispatch(
@@ -1098,6 +1169,7 @@
     uint32_t                                    y,
     uint32_t                                    z)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdDispatchIndirect(
@@ -1105,18 +1177,21 @@
     XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdWaitEvents(
     XGL_CMD_BUFFER                              cmdBuffer,
     const XGL_EVENT_WAIT_INFO*                  pWaitInfo)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdPipelineBarrier(
     XGL_CMD_BUFFER                              cmdBuffer,
     const XGL_PIPELINE_BARRIER*                 pBarrier)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateDevice(
@@ -1124,6 +1199,7 @@
     const XGL_DEVICE_CREATE_INFO*               pCreateInfo,
     XGL_DEVICE*                                 pDevice)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_gpu *gpu = nulldrv_gpu(gpu_);
     return nulldrv_dev_create(gpu, pCreateInfo, (struct nulldrv_dev**)pDevice);
 }
@@ -1131,6 +1207,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglDestroyDevice(
     XGL_DEVICE                                  device)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1140,6 +1217,7 @@
     uint32_t                                    queueIndex,
     XGL_QUEUE*                                  pQueue)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
     *pQueue = dev->queues[0];
     return XGL_SUCCESS;
@@ -1148,6 +1226,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglDeviceWaitIdle(
     XGL_DEVICE                                  device)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1155,6 +1234,7 @@
     XGL_DEVICE                                  device,
     XGL_VALIDATION_LEVEL                        validationLevel)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1163,6 +1243,7 @@
     int32_t                                     msgCode,
     XGL_DBG_MSG_FILTER                          filter)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1172,6 +1253,7 @@
     size_t                                      dataSize,
     const void*                                 pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1180,24 +1262,28 @@
     const XGL_EVENT_CREATE_INFO*                pCreateInfo,
     XGL_EVENT*                                  pEvent)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglGetEventStatus(
     XGL_EVENT                                   event_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglSetEvent(
     XGL_EVENT                                   event_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglResetEvent(
     XGL_EVENT                                   event_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1206,6 +1292,7 @@
     const XGL_FENCE_CREATE_INFO*                pCreateInfo,
     XGL_FENCE*                                  pFence)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_fence_create(dev, pCreateInfo,
@@ -1215,6 +1302,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglGetFenceStatus(
     XGL_FENCE                                   fence_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1225,6 +1313,7 @@
     bool32_t                                    waitAll,
     uint64_t                                    timeout)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1235,6 +1324,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1244,6 +1334,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1251,6 +1342,7 @@
     XGL_PHYSICAL_GPU                            gpu_,
     const char*                                 pExtName)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1259,6 +1351,7 @@
     XGL_PHYSICAL_GPU                            gpu1_,
     XGL_GPU_COMPATIBILITY_INFO*                 pInfo)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1268,6 +1361,7 @@
     XGL_IMAGE*                                  pImage,
     XGL_GPU_MEMORY*                             pMem)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1276,6 +1370,7 @@
     const XGL_IMAGE_CREATE_INFO*                pCreateInfo,
     XGL_IMAGE*                                  pImage)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_img_create(dev, pCreateInfo, false,
@@ -1289,6 +1384,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     const struct nulldrv_img *img = nulldrv_img(image);
     XGL_RESULT ret = XGL_SUCCESS;
 
@@ -1319,6 +1415,7 @@
     XGL_IMAGE                                   image,
     const float                                 color[4])
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1326,6 +1423,7 @@
     XGL_IMAGE                                   image,
     float                                       depth)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1334,6 +1432,7 @@
     const XGL_MEMORY_ALLOC_INFO*                pAllocInfo,
     XGL_GPU_MEMORY*                             pMem)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_mem_alloc(dev, pAllocInfo, (struct nulldrv_mem **) pMem);
@@ -1342,6 +1441,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglFreeMemory(
     XGL_GPU_MEMORY                              mem_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1349,6 +1449,7 @@
     XGL_GPU_MEMORY                              mem_,
     XGL_MEMORY_PRIORITY                         priority)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1357,6 +1458,7 @@
     XGL_FLAGS                                   flags,
     void**                                      ppData)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_mem *mem = nulldrv_mem(mem_);
     void *ptr = nulldrv_mem_map(mem, flags);
 
@@ -1368,6 +1470,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglUnmapMemory(
     XGL_GPU_MEMORY                              mem_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1377,6 +1480,7 @@
     size_t                                      memSize,
     XGL_GPU_MEMORY*                             pMem)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1385,6 +1489,7 @@
     const XGL_MEMORY_OPEN_INFO*                 pOpenInfo,
     XGL_GPU_MEMORY*                             pMem)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1393,6 +1498,7 @@
     const XGL_PEER_MEMORY_OPEN_INFO*            pOpenInfo,
     XGL_GPU_MEMORY*                             pMem)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1401,6 +1507,7 @@
     const XGL_ALLOC_CALLBACKS*                  pAllocCb,
     XGL_INSTANCE*                               pInstance)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_instance *inst;
 
     inst = (struct nulldrv_instance *) nulldrv_base_create(NULL, sizeof(*inst),
@@ -1418,6 +1525,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
     XGL_INSTANCE                                pInstance)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1427,6 +1535,7 @@
     uint32_t*                                   pGpuCount,
     XGL_PHYSICAL_GPU*                           pGpus)
 {
+    NULLDRV_LOG_FUNC;
     XGL_RESULT ret;
     struct nulldrv_gpu *gpu;
     *pGpuCount = 1;
@@ -1444,6 +1553,7 @@
     char* const*                                pOutLayers,
     void*                                       pReserved)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1451,12 +1561,14 @@
     XGL_DBG_MSG_CALLBACK_FUNCTION               pfnMsgCallback,
     void*                                       pUserData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
     XGL_DBG_MSG_CALLBACK_FUNCTION               pfnMsgCallback)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1465,12 +1577,14 @@
     size_t                                      dataSize,
     const void*                                 pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
     XGL_OBJECT                                  object)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1480,6 +1594,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_base *base = nulldrv_base(object);
 
     return base->get_info(base, infoType, pDataSize, pData);
@@ -1491,6 +1606,7 @@
     XGL_GPU_MEMORY                              mem_,
     XGL_GPU_SIZE                                memOffset)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1502,6 +1618,7 @@
     XGL_GPU_MEMORY                              mem,
     XGL_GPU_SIZE                                memOffset)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1512,6 +1629,7 @@
     XGL_GPU_MEMORY                              mem,
     XGL_GPU_SIZE                                memOffset)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1520,6 +1638,7 @@
     size_t                                      tagSize,
     const void*                                 pTag)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1528,6 +1647,7 @@
     const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
     XGL_PIPELINE*                               pPipeline)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return graphics_pipeline_create(dev, pCreateInfo,
@@ -1539,6 +1659,7 @@
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
     XGL_PIPELINE*                               pPipeline)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1547,6 +1668,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1556,6 +1678,7 @@
     const void*                                 pData,
     XGL_PIPELINE*                               pPipeline)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1565,6 +1688,7 @@
     XGL_PIPELINE                                p2,
     XGL_PIPELINE_DELTA*                         delta)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1573,6 +1697,7 @@
     const XGL_QUERY_POOL_CREATE_INFO*           pCreateInfo,
     XGL_QUERY_POOL*                             pQueryPool)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1583,6 +1708,7 @@
     size_t*                                     pDataSize,
     void*                                       pData)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1591,12 +1717,14 @@
     uint32_t                                    memRefCount,
     const XGL_MEMORY_REF*                       pMemRefs)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglQueueWaitIdle(
     XGL_QUEUE                                   queue_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1608,6 +1736,7 @@
     const XGL_MEMORY_REF*                       pMemRefs,
     XGL_FENCE                                   fence_)
 {
+    NULLDRV_LOG_FUNC;
    return XGL_SUCCESS;
 }
 
@@ -1616,6 +1745,7 @@
     const XGL_QUEUE_SEMAPHORE_OPEN_INFO*        pOpenInfo,
     XGL_QUEUE_SEMAPHORE*                        pSemaphore)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1624,6 +1754,7 @@
     const XGL_QUEUE_SEMAPHORE_CREATE_INFO*      pCreateInfo,
     XGL_QUEUE_SEMAPHORE*                        pSemaphore)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1631,6 +1762,7 @@
     XGL_QUEUE                                   queue,
     XGL_QUEUE_SEMAPHORE                         semaphore)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1638,6 +1770,7 @@
     XGL_QUEUE                                   queue,
     XGL_QUEUE_SEMAPHORE                         semaphore)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1646,6 +1779,7 @@
     const XGL_SAMPLER_CREATE_INFO*              pCreateInfo,
     XGL_SAMPLER*                                pSampler)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_sampler_create(dev, pCreateInfo,
@@ -1657,6 +1791,7 @@
         const XGL_SHADER_CREATE_INFO*               pCreateInfo,
         XGL_SHADER*                                 pShader)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return shader_create(dev, pCreateInfo, (struct nulldrv_shader **) pShader);
@@ -1667,6 +1802,7 @@
     const XGL_DYNAMIC_VP_STATE_CREATE_INFO*       pCreateInfo,
     XGL_DYNAMIC_VP_STATE_OBJECT*                  pState)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_viewport_state_create(dev, pCreateInfo,
@@ -1678,6 +1814,7 @@
     const XGL_DYNAMIC_RS_STATE_CREATE_INFO*         pCreateInfo,
     XGL_DYNAMIC_RS_STATE_OBJECT*                    pState)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_raster_state_create(dev, pCreateInfo,
@@ -1689,6 +1826,7 @@
     const XGL_DYNAMIC_CB_STATE_CREATE_INFO*    pCreateInfo,
     XGL_DYNAMIC_CB_STATE_OBJECT*               pState)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_blend_state_create(dev, pCreateInfo,
@@ -1700,6 +1838,7 @@
     const XGL_DYNAMIC_DS_STATE_CREATE_INFO*  pCreateInfo,
     XGL_DYNAMIC_DS_STATE_OBJECT*             pState)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_ds_state_create(dev, pCreateInfo,
@@ -1711,7 +1850,11 @@
     const XGL_BUFFER_VIEW_CREATE_INFO*          pCreateInfo,
     XGL_BUFFER_VIEW*                            pView)
 {
-    return XGL_SUCCESS;
+    NULLDRV_LOG_FUNC;
+    struct nulldrv_dev *dev = nulldrv_dev(device);
+
+    return nulldrv_buf_view_create(dev, pCreateInfo,
+            (struct nulldrv_buf_view **) pView);
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateImageView(
@@ -1719,6 +1862,7 @@
     const XGL_IMAGE_VIEW_CREATE_INFO*           pCreateInfo,
     XGL_IMAGE_VIEW*                             pView)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_img_view_create(dev, pCreateInfo,
@@ -1730,6 +1874,7 @@
     const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
     XGL_COLOR_ATTACHMENT_VIEW*                  pView)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_rt_view_create(dev, pCreateInfo,
@@ -1741,6 +1886,7 @@
     const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO*   pCreateInfo,
     XGL_DEPTH_STENCIL_VIEW*                     pView)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_ds_view_create(dev, pCreateInfo,
@@ -1756,6 +1902,7 @@
     const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList,
     XGL_DESCRIPTOR_SET_LAYOUT*                   pSetLayout)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
     struct nulldrv_desc_layout *prior_layout = nulldrv_desc_layout(priorSetLayout);
 
@@ -1768,6 +1915,7 @@
     XGL_DEVICE                                   device,
     XGL_DESCRIPTOR_UPDATE_MODE                   updateMode)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1775,6 +1923,7 @@
     XGL_DEVICE                                   device,
     XGL_CMD_BUFFER                               cmd_)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1785,6 +1934,7 @@
     const XGL_DESCRIPTOR_REGION_CREATE_INFO*     pCreateInfo,
     XGL_DESCRIPTOR_REGION*                       pDescriptorRegion)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_desc_region_create(dev, regionUsage, maxSets, pCreateInfo,
@@ -1794,6 +1944,7 @@
 ICD_EXPORT XGL_RESULT XGLAPI xglClearDescriptorRegion(
     XGL_DESCRIPTOR_REGION                        descriptorRegion)
 {
+    NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
 }
 
@@ -1805,6 +1956,7 @@
     XGL_DESCRIPTOR_SET*                          pDescriptorSets,
     uint32_t*                                    pCount)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_desc_region *region = nulldrv_desc_region(descriptorRegion);
     struct nulldrv_dev *dev = region->dev;
     XGL_RESULT ret = XGL_SUCCESS;
@@ -1831,12 +1983,14 @@
     uint32_t                                     count,
     const XGL_DESCRIPTOR_SET*                    pDescriptorSets)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglUpdateDescriptors(
     XGL_DESCRIPTOR_SET                           descriptorSet,
     const void*                                  pUpdateChain)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateFramebuffer(
@@ -1844,6 +1998,7 @@
     const XGL_FRAMEBUFFER_CREATE_INFO*          info,
     XGL_FRAMEBUFFER*                            fb_ret)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_fb_create(dev, info, (struct nulldrv_framebuffer **) fb_ret);
@@ -1855,6 +2010,7 @@
     const XGL_RENDER_PASS_CREATE_INFO*          info,
     XGL_RENDER_PASS*                            rp_ret)
 {
+    NULLDRV_LOG_FUNC;
     struct nulldrv_dev *dev = nulldrv_dev(device);
 
     return nulldrv_render_pass_create(dev, info, (struct nulldrv_render_pass **) rp_ret);
@@ -1864,10 +2020,12 @@
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_RENDER_PASS                             renderPass)
 {
+    NULLDRV_LOG_FUNC;
 }
 
 ICD_EXPORT void XGLAPI xglCmdEndRenderPass(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_RENDER_PASS                             renderPass)
 {
+    NULLDRV_LOG_FUNC;
 }
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
index 20fdd72..b32cbb7 100644
--- a/icd/nulldrv/nulldrv.h
+++ b/icd/nulldrv/nulldrv.h
@@ -210,4 +210,15 @@
     struct nulldrv_obj obj;
 };
 
+struct nulldrv_buf_view {
+    struct nulldrv_obj obj;
+
+    struct nulldrv_buf *buf;
+
+    /* SURFACE_STATE */
+    uint32_t cmd[8];
+    uint32_t fs_cmd[8];
+    uint32_t cmd_len;
+};
+
 #endif /* NULLDRV_H */
diff --git a/include/xglWsiWinExt.h b/include/xglWsiWinExt.h
index 73b52fb..84d3eb1 100644
--- a/include/xglWsiWinExt.h
+++ b/include/xglWsiWinExt.h
@@ -3,7 +3,16 @@
 #ifndef __XGLWSIWINEXT_H__
 #define __XGLWSIWINEXT_H__
 
+// This should be moved out of this WSI header file and
+// into a platform-specific file.
+#define snprintf _snprintf
 
-// TODO: create the contents of this file
+// This is just to get windows to build.
+// Need to replace with the declarations for Windows wsi.
+typedef void XGL_WSI_X11_CONNECTION_INFO;
+typedef unsigned int xcb_window_t;
+typedef unsigned int xcb_randr_crtc_t;
+typedef void XGL_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO;
+typedef void XGL_WSI_X11_PRESENT_INFO;
 
 #endif // __XGLWSIWINEXT_H__
diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index 41fd989..41d60fe 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -19,8 +19,9 @@
 if (WIN32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DXGL_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS")
 
-    add_library(XGL SHARED loader.c dirent_on_windows.c dispatch.c table_ops.h)
-    add_library(XGLstatic STATIC loader.c dirent_on_windows.c dispatch.c table_ops.h)
+    add_library(XGL SHARED loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h XGL.def)
+    set_target_properties(XGL PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/loader/XGL.def")
+    add_library(XGLstatic STATIC loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h)
     set_target_properties(XGLstatic PROPERTIES OUTPUT_NAME XGL)
     target_link_libraries(XGL)
 endif()
diff --git a/loader/XGL.def b/loader/XGL.def
new file mode 100644
index 0000000..6c560ba
--- /dev/null
+++ b/loader/XGL.def
@@ -0,0 +1,150 @@
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; XGL
+;
+; Copyright (C) 2015 LunarG, Inc.
+;
+; 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.
+;;;;  End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The following is required on Windows, for exporting symbols from the DLL
+
+LIBRARY XGL
+EXPORTS
+   xglCreateInstance
+   xglDestroyInstance
+   xglEnumerateGpus
+   xglGetGpuInfo
+   xglGetProcAddr
+   xglCreateDevice
+   xglDestroyDevice
+   xglGetExtensionSupport
+   xglEnumerateLayers
+   xglGetDeviceQueue
+   xglQueueSubmit
+   xglQueueSetGlobalMemReferences
+   xglQueueWaitIdle
+   xglDeviceWaitIdle
+   xglAllocMemory
+   xglFreeMemory
+   xglSetMemoryPriority
+   xglMapMemory
+   xglUnmapMemory
+   xglPinSystemMemory
+   xglGetMultiGpuCompatibility
+   xglOpenSharedMemory
+   xglOpenSharedQueueSemaphore
+   xglOpenPeerMemory
+   xglOpenPeerImage
+   xglDestroyObject
+   xglGetObjectInfo
+   xglBindObjectMemory
+   xglBindObjectMemoryRange
+   xglBindImageMemoryRange
+   xglCreateFence
+   xglGetFenceStatus
+   xglWaitForFences
+   xglCreateQueueSemaphore
+   xglSignalQueueSemaphore
+   xglWaitQueueSemaphore
+   xglCreateEvent
+   xglGetEventStatus
+   xglSetEvent
+   xglResetEvent
+   xglCreateQueryPool
+   xglGetQueryPoolResults
+   xglGetFormatInfo
+   xglCreateBuffer
+   xglCreateBufferView
+   xglCreateImage
+   xglSetFastClearColor
+   xglSetFastClearDepth
+   xglGetImageSubresourceInfo
+   xglCreateImageView
+   xglCreateColorAttachmentView
+   xglCreateDepthStencilView
+   xglCreateShader
+   xglCreateGraphicsPipeline
+   xglCreateComputePipeline
+   xglStorePipeline
+   xglLoadPipeline
+   xglCreatePipelineDelta
+   xglCreateSampler
+   xglCreateDescriptorSetLayout
+   xglBeginDescriptorRegionUpdate
+   xglEndDescriptorRegionUpdate
+   xglCreateDescriptorRegion
+   xglClearDescriptorRegion
+   xglAllocDescriptorSets
+   xglClearDescriptorSets
+   xglUpdateDescriptors
+   xglCreateDynamicViewportState
+   xglCreateDynamicRasterState
+   xglCreateDynamicColorBlendState
+   xglCreateDynamicDepthStencilState
+   xglCreateCommandBuffer
+   xglBeginCommandBuffer
+   xglEndCommandBuffer
+   xglResetCommandBuffer
+   xglCmdBindPipeline
+   xglCmdBindPipelineDelta
+   xglCmdBindDynamicStateObject
+   xglCmdBindDescriptorSet
+   xglCmdBindVertexBuffer
+   xglCmdBindIndexBuffer
+   xglCmdDraw
+   xglCmdDrawIndexed
+   xglCmdDrawIndirect
+   xglCmdDrawIndexedIndirect
+   xglCmdDispatch
+   xglCmdDispatchIndirect
+   xglCmdCopyBuffer
+   xglCmdCopyImage
+   xglCmdCopyBufferToImage
+   xglCmdCopyImageToBuffer
+   xglCmdCloneImageData
+   xglCmdUpdateBuffer
+   xglCmdFillBuffer
+   xglCmdClearColorImage
+   xglCmdClearColorImageRaw
+   xglCmdClearDepthStencil
+   xglCmdResolveImage
+   xglCmdSetEvent
+   xglCmdResetEvent
+   xglCmdWaitEvents
+   xglCmdPipelineBarrier
+   xglCmdBeginQuery
+   xglCmdEndQuery
+   xglCmdResetQueryPool
+   xglCmdWriteTimestamp
+   xglCmdInitAtomicCounters
+   xglCmdLoadAtomicCounters
+   xglCmdSaveAtomicCounters
+   xglCreateFramebuffer
+   xglCreateRenderPass
+   xglCmdBeginRenderPass
+   xglCmdEndRenderPass
+   xglDbgSetValidationLevel
+   xglDbgRegisterMsgCallback
+   xglDbgUnregisterMsgCallback
+   xglDbgSetMessageFilter
+   xglDbgSetObjectTag
+   xglDbgSetGlobalOption
+   xglDbgSetDeviceOption
+   xglCmdDbgMarkerBegin
+   xglCmdDbgMarkerEnd
diff --git a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
index f9c8001..59427aa 100644
--- a/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvdebug_xgl/CMakeLists.txt
@@ -6,6 +6,7 @@
 project(glvdebug_xgl)
 
 include("${SRC_DIR}/build_options.cmake")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/../../..)
 
 find_package(Qt5 COMPONENTS Widgets Gui Core QUIET)
 
diff --git a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
index 770a068..f7577f4 100644
--- a/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvreplay_xgl/CMakeLists.txt
@@ -1,11 +1,9 @@
 cmake_minimum_required(VERSION 2.8)
 
-# this project is currently only available on Linux
-if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-
 project(glvreplay_xgl)
 
 include("${SRC_DIR}/build_options.cmake")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/../../..)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/../../../include ${SRC_DIR}/../../../layers ${SRC_DIR}/glv_extensions/glvreplay_xgl)
 
@@ -23,7 +21,7 @@
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 set(OS_REPLAYER_LIBS
-    ${CMAKE_CURRENT_BINARY_DIR}/../../../../../loader/libXGL.dll
+    ${CMAKE_CURRENT_BINARY_DIR}/../../../../../loader/${CMAKE_BUILD_TYPE}/XGL.lib
 )
 endif()
 
@@ -69,5 +67,3 @@
 )
 
 build_options_finalize()
-
-endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
diff --git a/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt
index e677727..7d17fae 100644
--- a/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvtrace_gl_fps/CMakeLists.txt
@@ -6,6 +6,7 @@
 project(glvtrace_gl_fps)
 
 include("${SRC_DIR}/build_options.cmake")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/../../..)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
diff --git a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
index 4ec55bd..fdcbf94 100644
--- a/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
+++ b/tools/glave/src/glv_extensions/glvtrace_xgl/CMakeLists.txt
@@ -6,6 +6,7 @@
 project(glvtrace_xgl)
 
 include("${SRC_DIR}/build_options.cmake")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/../../..)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${SRC_DIR}/../../../include)