diff --git a/include/xgl.h b/include/xgl.h
index 6c03de6..2e40aed 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -81,6 +81,8 @@
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER, XGL_OBJECT)
+XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
@@ -151,26 +153,26 @@
     XGL_NUM_MEMORY_PRIORITY                                 = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
 } XGL_MEMORY_PRIORITY;
 
-typedef enum _XGL_MEMORY_STATE
+typedef enum _XGL_BUFFER_STATE
 {
-    XGL_MEMORY_STATE_DATA_TRANSFER                          = 0x00000000,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY              = 0x00000001,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY             = 0x00000002,
-    XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE             = 0x00000003,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY               = 0x00000004,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY              = 0x00000005,
-    XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE              = 0x00000006,
-    XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY                 = 0x00000007,
-    XGL_MEMORY_STATE_INDEX_DATA                             = 0x00000008,
-    XGL_MEMORY_STATE_INDIRECT_ARG                           = 0x00000009,
-    XGL_MEMORY_STATE_WRITE_TIMESTAMP                        = 0x0000000A,
-    XGL_MEMORY_STATE_QUEUE_ATOMIC                           = 0x0000000B,
+    XGL_BUFFER_STATE_DATA_TRANSFER                          = 0x00000000,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY              = 0x00000001,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_WRITE_ONLY             = 0x00000002,
+    XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_WRITE             = 0x00000003,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_READ_ONLY               = 0x00000004,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_WRITE_ONLY              = 0x00000005,
+    XGL_BUFFER_STATE_COMPUTE_SHADER_READ_WRITE              = 0x00000006,
+    XGL_BUFFER_STATE_MULTI_SHADER_READ_ONLY                 = 0x00000007,
+    XGL_BUFFER_STATE_INDEX_DATA                             = 0x00000008,
+    XGL_BUFFER_STATE_INDIRECT_ARG                           = 0x00000009,
+    XGL_BUFFER_STATE_WRITE_TIMESTAMP                        = 0x0000000A,
+    XGL_BUFFER_STATE_QUEUE_ATOMIC                           = 0x0000000B,
 
-    XGL_MEMORY_STATE_BEGIN_RANGE                            = XGL_MEMORY_STATE_DATA_TRANSFER,
-    XGL_MEMORY_STATE_END_RANGE                              = XGL_MEMORY_STATE_QUEUE_ATOMIC,
-    XGL_NUM_MEMORY_STATE                                    = (XGL_MEMORY_STATE_END_RANGE - XGL_MEMORY_STATE_BEGIN_RANGE + 1),
-    XGL_MAX_ENUM(_XGL_MEMORY_STATE)
-} XGL_MEMORY_STATE;
+    XGL_BUFFER_STATE_BEGIN_RANGE                            = XGL_BUFFER_STATE_DATA_TRANSFER,
+    XGL_BUFFER_STATE_END_RANGE                              = XGL_BUFFER_STATE_QUEUE_ATOMIC,
+    XGL_NUM_BUFFER_STATE                                    = (XGL_BUFFER_STATE_END_RANGE - XGL_BUFFER_STATE_BEGIN_RANGE + 1),
+    XGL_MAX_ENUM(_XGL_BUFFER_STATE)
+} XGL_BUFFER_STATE;
 
 typedef enum _XGL_IMAGE_STATE
 {
@@ -858,9 +860,9 @@
     XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO                    = 2,
     XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO                     = 4,
     XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO                = 5,
-    XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO              = 6,
+    XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO              = 6,
     XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO               = 7,
-    XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION              = 8,
+    XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION              = 8,
     XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO               = 9,
     XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO    = 10,
     XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO       = 11,
@@ -886,14 +888,16 @@
     XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO        = 31,
     XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO      = 32,
     XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO                    = 33,
-    XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 34,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 35,
-    XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 36,
-    XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 37,
+    XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO                   = 37,
+    XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO              = 38,
+    XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO              = 39,
+    XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO                = 40,
+    XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO       = 41,
+    XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO              = 42,
+    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 43,
 // IMG CHANGE BEGIN - support for vertex input description
-    XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 38,
+    XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO    = 90,
 // IMG CHANGE END
-    XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO                    = 39,
     XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
 } XGL_STRUCTURE_TYPE;
 
@@ -930,17 +934,48 @@
 // Memory allocation flags
 typedef enum _XGL_MEMORY_ALLOC_FLAGS
 {
-    XGL_MEMORY_ALLOC_VIRTUAL_BIT                            = 0x00000001,
-    XGL_MEMORY_ALLOC_SHAREABLE_BIT                          = 0x00000002,
+    XGL_MEMORY_ALLOC_SHAREABLE_BIT                          = 0x00000001,
 } XGL_MEMORY_ALLOC_FLAGS;
 
+// Buffer usage flags
+typedef enum _XGL_BUFFER_USAGE_FLAGS
+{
+    XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SBBO)
+    XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT                = 0x00000002,   // Shader write (e.g. image buffer, SSBO)
+    XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT               = 0x00000004,   // Shader atomic operations (e.g. image buffer, SSBO)
+    XGL_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000008,   // Uniform read (UBO)
+    XGL_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000010,   // Fixed function index fetch (index buffer)
+    XGL_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000020,   // Fixed function vertex fetch (VBO)
+    XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000040,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+} XGL_BUFFER_USAGE_FLAGS;
+
+// Buffer flags
+typedef enum _XGL_BUFFER_CREATE_FLAGS
+{
+    XGL_BUFFER_CREATE_SHAREABLE_BIT                         = 0x00000001,
+    XGL_BUFFER_CREATE_SPARSE_BIT                            = 0x00000002,
+} XGL_BUFFER_CREATE_FLAGS;
+
+typedef enum _XGL_BUFFER_VIEW_TYPE
+{
+    XGL_BUFFER_VIEW_RAW                                     = 0x00000000,   // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
+    XGL_BUFFER_VIEW_TYPED                                   = 0x00000001,   // Typed buffer, format and channels are used (TBO, image buffer)
+    XGL_BUFFER_VIEW_STRUCTURED                              = 0x00000002,   // Structured buffer, stride is used (VBO, DX-style structured buffer)
+
+    XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE                         = XGL_BUFFER_VIEW_RAW,
+    XGL_BUFFER_VIEW_TYPE_END_RANGE                           = XGL_BUFFER_VIEW_STRUCTURED,
+    XGL_NUM_BUFFER_VIEW_TYPE                                 = (XGL_BUFFER_VIEW_TYPE_END_RANGE - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
+    XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
+} XGL_BUFFER_VIEW_TYPE;
+
 // Image usage flags
 typedef enum _XGL_IMAGE_USAGE_FLAGS
 {
     XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
     XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
-    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000004,
-    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000008,
+    XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,
+    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000008,
+    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000010,
 } XGL_IMAGE_USAGE_FLAGS;
 
 // Image flags
@@ -949,6 +984,7 @@
     XGL_IMAGE_CREATE_INVARIANT_DATA_BIT                     = 0x00000001,
     XGL_IMAGE_CREATE_CLONEABLE_BIT                          = 0x00000002,
     XGL_IMAGE_CREATE_SHAREABLE_BIT                          = 0x00000004,
+    XGL_IMAGE_CREATE_SPARSE_BIT                             = 0x00000008,
 } XGL_IMAGE_CREATE_FLAGS;
 
 // Depth-stencil view creation flags
@@ -1063,6 +1099,14 @@
     XGL_EXTENT2D                            extent;
 } XGL_RECT;
 
+typedef struct _XGL_CHANNEL_MAPPING
+{
+    XGL_CHANNEL_SWIZZLE                     r;
+    XGL_CHANNEL_SWIZZLE                     g;
+    XGL_CHANNEL_SWIZZLE                     b;
+    XGL_CHANNEL_SWIZZLE                     a;
+} XGL_CHANNEL_MAPPING;
+
 typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
 {
     XGL_SIZE                                structSize;
@@ -1073,7 +1117,6 @@
     XGL_PHYSICAL_GPU_TYPE                   gpuType;
     XGL_CHAR                                gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
     XGL_UINT                                maxMemRefsPerSubmission;
-    XGL_GPU_SIZE                            virtualMemPageSize;
     XGL_GPU_SIZE                            maxInlineMemoryUpdateSize;
     XGL_UINT                                maxBoundDescriptorSets;
     XGL_UINT                                maxThreadGroupSize;
@@ -1162,7 +1205,6 @@
 {
     XGL_SIZE                                structSize;                 // Size of structure in bytes
     XGL_BOOL                                supportsMigration;
-    XGL_BOOL                                supportsVirtualMemoryRemapping;
     XGL_BOOL                                supportsPinning;
 } XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
 
@@ -1205,19 +1247,11 @@
     XGL_GPU_MEMORY                          originalMem;
 } XGL_PEER_MEMORY_OPEN_INFO;
 
-typedef struct _XGL_VIRTUAL_MEMORY_REMAP_RANGE
-{
-    XGL_GPU_MEMORY                          virtualMem;
-    XGL_GPU_SIZE                            virtualStartPage;
-    XGL_GPU_MEMORY                          realMem;
-    XGL_GPU_SIZE                            realStartPage;
-    XGL_GPU_SIZE                            pageCount;
-} XGL_VIRTUAL_MEMORY_REMAP_RANGE;
-
 typedef struct _XGL_MEMORY_REQUIREMENTS
 {
     XGL_GPU_SIZE                            size;                       // Specified in bytes
     XGL_GPU_SIZE                            alignment;                  // Specified in bytes
+    XGL_GPU_SIZE                            granularity;                // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
     XGL_UINT                                heapCount;
     XGL_UINT                                heaps[XGL_MAX_MEMORY_HEAPS];
 } XGL_MEMORY_REQUIREMENTS;
@@ -1228,17 +1262,13 @@
     XGL_FLAGS                               optimalTilingFeatures;     // XGL_FORMAT_FEATURE_FLAGS
 } XGL_FORMAT_PROPERTIES;
 
-typedef struct _XGL_MEMORY_VIEW_ATTACH_INFO
+typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
     XGL_VOID*                               pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          mem;
-    XGL_GPU_SIZE                            offset;
-    XGL_GPU_SIZE                            range;
-    XGL_GPU_SIZE                            stride;
-    XGL_FORMAT                              format;
-    XGL_MEMORY_STATE                        state;
-} XGL_MEMORY_VIEW_ATTACH_INFO;
+    XGL_BUFFER_VIEW                         view;
+    XGL_BUFFER_STATE                        state;
+} XGL_BUFFER_VIEW_ATTACH_INFO;
 
 typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
 {
@@ -1248,16 +1278,38 @@
     XGL_IMAGE_STATE                         state;
 } XGL_IMAGE_VIEW_ATTACH_INFO;
 
-typedef struct _XGL_MEMORY_STATE_TRANSITION
+typedef struct _XGL_BUFFER_STATE_TRANSITION
 {
-    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION
     XGL_VOID*                               pNext;                      // Pointer to next structure
-    XGL_GPU_MEMORY                          mem;
-    XGL_MEMORY_STATE                        oldState;
-    XGL_MEMORY_STATE                        newState;
+    XGL_BUFFER                              buffer;
+    XGL_BUFFER_STATE                        oldState;
+    XGL_BUFFER_STATE                        newState;
     XGL_GPU_SIZE                            offset;
     XGL_GPU_SIZE                            regionSize;
-} XGL_MEMORY_STATE_TRANSITION;
+} XGL_BUFFER_STATE_TRANSITION;
+
+typedef struct _XGL_BUFFER_CREATE_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO
+    const XGL_VOID*                         pNext;                      // Pointer to next structure.
+    XGL_GPU_SIZE                            size;                       // Specified in bytes
+    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
+    XGL_FLAGS                               flags;                      // XGL_BUFFER_CREATE_FLAGS
+} XGL_BUFFER_CREATE_INFO;
+
+typedef struct _XGL_BUFFER_VIEW_CREATE_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
+    const XGL_VOID*                         pNext;                      // Pointer to next structure.
+    XGL_BUFFER                              buffer;
+    XGL_BUFFER_VIEW_TYPE                    viewType;
+    XGL_GPU_SIZE                            stride;                     // Optionally specifies stride between elements
+    XGL_FORMAT                              format;                     // Optionally specifies format of elements
+    XGL_CHANNEL_MAPPING                     channels;                   // Optionally specifies format channel mapping
+    XGL_GPU_SIZE                            offset;                     // Specified in bytes
+    XGL_GPU_SIZE                            range;                      // View size specified in bytes
+} XGL_BUFFER_VIEW_CREATE_INFO;
 
 typedef struct _XGL_IMAGE_SUBRESOURCE
 {
@@ -1311,14 +1363,6 @@
     XGL_GPU_SIZE                            depthPitch;             // Specified in bytes
 } XGL_SUBRESOURCE_LAYOUT;
 
-typedef struct _XGL_CHANNEL_MAPPING
-{
-    XGL_CHANNEL_SWIZZLE                     r;
-    XGL_CHANNEL_SWIZZLE                     g;
-    XGL_CHANNEL_SWIZZLE                     b;
-    XGL_CHANNEL_SWIZZLE                     a;
-} XGL_CHANNEL_MAPPING;
-
 typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
 {
     XGL_STRUCTURE_TYPE                      sType;                  // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
@@ -1370,12 +1414,19 @@
     XGL_IMAGE_STATE                         stencilState;           // XGL_IMAGE_STATE
 } XGL_DEPTH_STENCIL_BIND_INFO;
 
-typedef struct _XGL_MEMORY_COPY
+typedef struct _XGL_BUFFER_COPY
 {
     XGL_GPU_SIZE                            srcOffset;              // Specified in bytes
     XGL_GPU_SIZE                            destOffset;             // Specified in bytes
     XGL_GPU_SIZE                            copySize;               // Specified in bytes
-} XGL_MEMORY_COPY;
+} XGL_BUFFER_COPY;
+
+typedef struct _XGL_IMAGE_MEMORY_BIND_INFO
+{
+    XGL_IMAGE_SUBRESOURCE                   subresource;
+    XGL_OFFSET3D                            offset;
+    XGL_EXTENT3D                            extent;
+} XGL_IMAGE_MEMORY_BIND_INFO;
 
 typedef struct _XGL_IMAGE_COPY
 {
@@ -1386,13 +1437,13 @@
     XGL_EXTENT3D                            extent;
 } XGL_IMAGE_COPY;
 
-typedef struct _XGL_MEMORY_IMAGE_COPY
+typedef struct _XGL_BUFFER_IMAGE_COPY
 {
-    XGL_GPU_SIZE                            memOffset;              // Specified in bytes
+    XGL_GPU_SIZE                            bufferOffset;           // Specified in bytes
     XGL_IMAGE_SUBRESOURCE                   imageSubresource;
     XGL_OFFSET3D                            imageOffset;
     XGL_EXTENT3D                            imageExtent;
-} XGL_MEMORY_IMAGE_COPY;
+} XGL_BUFFER_IMAGE_COPY;
 
 typedef struct _XGL_IMAGE_RESOLVE
 {
@@ -1437,11 +1488,11 @@
     const XGL_VOID*                             pBufferData;
 } XGL_LINK_CONST_BUFFER;
 
-typedef struct _XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO
+typedef struct _XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO
 {
     XGL_DESCRIPTOR_SET_SLOT_TYPE            slotObjectType;
     XGL_UINT                                shaderEntityIndex;
-} XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO;
+} XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO;
 
 typedef struct _XGL_PIPELINE_SHADER
 {
@@ -1450,7 +1501,7 @@
     XGL_DESCRIPTOR_SET_MAPPING              descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
     XGL_UINT                                linkConstBufferCount;
     const XGL_LINK_CONST_BUFFER*            pLinkConstBufferInfo;
-    XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO       dynamicMemoryViewMapping;
+    XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO       dynamicBufferViewMapping;
 } XGL_PIPELINE_SHADER;
 
 typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
@@ -1853,7 +1904,6 @@
 typedef XGL_RESULT (XGLAPI *xglMapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData);
 typedef XGL_RESULT (XGLAPI *xglUnmapMemoryType)(XGL_GPU_MEMORY mem);
 typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem);
-typedef XGL_RESULT (XGLAPI *xglRemapVirtualMemoryPagesType)(XGL_DEVICE device, XGL_UINT rangeCount, const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges, XGL_UINT preWaitSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores, XGL_UINT postSignalSemaphoreCount, const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
 typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
 typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
 typedef XGL_RESULT (XGLAPI *xglOpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
@@ -1861,7 +1911,9 @@
 typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
 typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
 typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
-typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
+typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
+typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
+typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
 typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
 typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence);
 typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout);
@@ -1875,6 +1927,8 @@
 typedef XGL_RESULT (XGLAPI *xglCreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
 typedef XGL_RESULT (XGLAPI *xglGetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData);
 typedef XGL_RESULT (XGLAPI *xglGetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
+typedef XGL_RESULT (XGLAPI *xglCreateBufferType)(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer);
+typedef XGL_RESULT (XGLAPI *xglCreateBufferViewType)(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView);
 typedef XGL_RESULT (XGLAPI *xglCreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
 typedef XGL_RESULT (XGLAPI *xglGetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
 typedef XGL_RESULT (XGLAPI *xglCreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
@@ -1892,7 +1946,7 @@
 typedef XGL_VOID (XGLAPI *xglEndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
 typedef XGL_VOID (XGLAPI *xglAttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
 typedef XGL_VOID (XGLAPI *xglAttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
-typedef XGL_VOID (XGLAPI *xglAttachMemoryViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
+typedef XGL_VOID (XGLAPI *xglAttachBufferViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
 typedef XGL_VOID (XGLAPI *xglAttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
 typedef XGL_VOID (XGLAPI *xglClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
 typedef XGL_RESULT (XGLAPI *xglCreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
@@ -1908,38 +1962,38 @@
 typedef XGL_VOID (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
 typedef XGL_VOID (XGLAPI *xglCmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
 typedef XGL_VOID (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
-typedef XGL_VOID (XGLAPI *xglCmdBindDynamicMemoryViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
-typedef XGL_VOID (XGLAPI *xglCmdBindVertexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT binding);
-typedef XGL_VOID (XGLAPI *xglCmdBindIndexDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
-typedef XGL_VOID (XGLAPI *xglCmdPrepareMemoryRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
+typedef XGL_VOID (XGLAPI *xglCmdBindDynamicBufferViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
+typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding);
+typedef XGL_VOID (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
+typedef XGL_VOID (XGLAPI *xglCmdPrepareBufferRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_BUFFER_STATE_TRANSITION* pStateTransitions);
 typedef XGL_VOID (XGLAPI *xglCmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
 typedef XGL_VOID (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
 typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
-typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
-typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
+typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
 typedef XGL_VOID (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z);
-typedef XGL_VOID (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY mem, XGL_GPU_SIZE offset);
-typedef XGL_VOID (XGLAPI *xglCmdCopyMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
+typedef XGL_VOID (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_COPY* pRegions);
 typedef XGL_VOID (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions);
-typedef XGL_VOID (XGLAPI *xglCmdCopyMemoryToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY srcMem, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
-typedef XGL_VOID (XGLAPI *xglCmdCopyImageToMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_GPU_MEMORY destMem, XGL_UINT regionCount, const XGL_MEMORY_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
+typedef XGL_VOID (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
 typedef XGL_VOID (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState);
-typedef XGL_VOID (XGLAPI *xglCmdUpdateMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
-typedef XGL_VOID (XGLAPI *xglCmdFillMemoryType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
+typedef XGL_VOID (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
+typedef XGL_VOID (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
 typedef XGL_VOID (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
 typedef XGL_VOID (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects);
 typedef XGL_VOID (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
 typedef XGL_VOID (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
-typedef XGL_VOID (XGLAPI *xglCmdMemoryAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
+typedef XGL_VOID (XGLAPI *xglCmdBufferAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
 typedef XGL_VOID (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags);
 typedef XGL_VOID (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot);
 typedef XGL_VOID (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount);
-typedef XGL_VOID (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_VOID (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
 typedef XGL_VOID (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData);
-typedef XGL_VOID (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY srcMem, XGL_GPU_SIZE srcOffset);
-typedef XGL_VOID (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset);
+typedef XGL_VOID (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
+typedef XGL_VOID (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
 typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer);
 typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass);
 
@@ -2055,15 +2109,6 @@
     XGL_SIZE                                    memSize,
     XGL_GPU_MEMORY*                             pMem);
 
-XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
-    XGL_DEVICE                                  device,
-    XGL_UINT                                    rangeCount,
-    const XGL_VIRTUAL_MEMORY_REMAP_RANGE*       pRanges,
-    XGL_UINT                                    preWaitSemaphoreCount,
-    const XGL_QUEUE_SEMAPHORE*                  pPreWaitSemaphores,
-    XGL_UINT                                    postSignalSemaphoreCount,
-    const XGL_QUEUE_SEMAPHORE*                  pPostSignalSemaphores);
-
 // Multi-device functions
 
 XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
@@ -2106,7 +2151,20 @@
 XGL_RESULT XGLAPI xglBindObjectMemory(
     XGL_OBJECT                                  object,
     XGL_GPU_MEMORY                              mem,
-    XGL_GPU_SIZE                                offset);
+    XGL_GPU_SIZE                                memOffset);
+
+XGL_RESULT XGLAPI xglBindObjectMemoryRange(
+    XGL_OBJECT                                  object,
+    XGL_GPU_SIZE                                rangeOffset,
+    XGL_GPU_SIZE                                rangeSize,
+    XGL_GPU_MEMORY                              mem,
+    XGL_GPU_SIZE                                memOffset);
+
+XGL_RESULT XGLAPI xglBindImageMemoryRange(
+    XGL_IMAGE                                   image,
+    const XGL_IMAGE_MEMORY_BIND_INFO*           bindInfo,
+    XGL_GPU_MEMORY                              mem,
+    XGL_GPU_SIZE                                memOffset);
 
 // Fence functions
 
@@ -2179,6 +2237,20 @@
     XGL_SIZE*                                   pDataSize,
     XGL_VOID*                                   pData);
 
+// Buffer functions
+
+XGL_RESULT XGLAPI xglCreateBuffer(
+    XGL_DEVICE                                  device,
+    const XGL_BUFFER_CREATE_INFO*               pCreateInfo,
+    XGL_BUFFER*                                 pBuffer);
+
+// Buffer view functions
+
+XGL_RESULT XGLAPI xglCreateBufferView(
+    XGL_DEVICE                                  device,
+    const XGL_BUFFER_VIEW_CREATE_INFO*          pCreateInfo,
+    XGL_BUFFER_VIEW*                            pView);
+
 // Image functions
 
 XGL_RESULT XGLAPI xglCreateImage(
@@ -2278,11 +2350,11 @@
     XGL_UINT                                    slotCount,
     const XGL_IMAGE_VIEW_ATTACH_INFO*           pImageViews);
 
-XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
+XGL_VOID XGLAPI xglAttachBufferViewDescriptors(
     XGL_DESCRIPTOR_SET                          descriptorSet,
     XGL_UINT                                    startSlot,
     XGL_UINT                                    slotCount,
-    const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemViews);
+    const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferViews);
 
 XGL_VOID XGLAPI xglAttachNestedDescriptors(
     XGL_DESCRIPTOR_SET                          descriptorSet,
@@ -2363,29 +2435,29 @@
     XGL_DESCRIPTOR_SET                          descriptorSet,
     XGL_UINT                                    slotOffset);
 
-XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
+XGL_VOID XGLAPI xglCmdBindDynamicBufferView(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
+    const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferView);
 
 // IMG CHANGE BEGIN - support for vertex input description
-XGL_VOID XGLAPI xglCmdBindVertexData(
+XGL_VOID XGLAPI xglCmdBindVertexBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT                                    binding);
 // IMG CHANGE END
 
-XGL_VOID XGLAPI xglCmdBindIndexData(
+XGL_VOID XGLAPI xglCmdBindIndexBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_INDEX_TYPE                              indexType);
 
-XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
+XGL_VOID XGLAPI xglCmdPrepareBufferRegions(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_UINT                                    transitionCount,
-    const XGL_MEMORY_STATE_TRANSITION*          pStateTransitions);
+    const XGL_BUFFER_STATE_TRANSITION*          pStateTransitions);
 
 XGL_VOID XGLAPI xglCmdPrepareImages(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2409,14 +2481,14 @@
 
 XGL_VOID XGLAPI xglCmdDrawIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT32                                  count,
     XGL_UINT32                                  stride);
 
 XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset,
     XGL_UINT32                                  count,
     XGL_UINT32                                  stride);
@@ -2429,15 +2501,15 @@
 
 XGL_VOID XGLAPI xglCmdDispatchIndirect(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              mem,
+    XGL_BUFFER                                  buffer,
     XGL_GPU_SIZE                                offset);
 
-XGL_VOID XGLAPI xglCmdCopyMemory(
+XGL_VOID XGLAPI xglCmdCopyBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              srcMem,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  srcBuffer,
+    XGL_BUFFER                                  destBuffer,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_COPY*                      pRegions);
+    const XGL_BUFFER_COPY*                      pRegions);
 
 XGL_VOID XGLAPI xglCmdCopyImage(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2446,19 +2518,19 @@
     XGL_UINT                                    regionCount,
     const XGL_IMAGE_COPY*                       pRegions);
 
-XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
+XGL_VOID XGLAPI xglCmdCopyBufferToImage(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              srcMem,
+    XGL_BUFFER                                  srcBuffer,
     XGL_IMAGE                                   destImage,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_IMAGE_COPY*                pRegions);
+    const XGL_BUFFER_IMAGE_COPY*                pRegions);
 
-XGL_VOID XGLAPI xglCmdCopyImageToMemory(
+XGL_VOID XGLAPI xglCmdCopyImageToBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_IMAGE                                   srcImage,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_UINT                                    regionCount,
-    const XGL_MEMORY_IMAGE_COPY*                pRegions);
+    const XGL_BUFFER_IMAGE_COPY*                pRegions);
 
 XGL_VOID XGLAPI xglCmdCloneImageData(
     XGL_CMD_BUFFER                              cmdBuffer,
@@ -2467,16 +2539,16 @@
     XGL_IMAGE                                   destImage,
     XGL_IMAGE_STATE                             destImageState);
 
-XGL_VOID XGLAPI xglCmdUpdateMemory(
+XGL_VOID XGLAPI xglCmdUpdateBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_GPU_SIZE                                dataSize,
     const XGL_UINT32*                           pData);
 
-XGL_VOID XGLAPI xglCmdFillMemory(
+XGL_VOID XGLAPI xglCmdFillBuffer(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_GPU_SIZE                                fillSize,
     XGL_UINT32                                  data);
@@ -2518,9 +2590,9 @@
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_EVENT                                   event);
 
-XGL_VOID XGLAPI xglCmdMemoryAtomic(
+XGL_VOID XGLAPI xglCmdBufferAtomic(
     XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset,
     XGL_UINT64                                  srcData,
     XGL_ATOMIC_OP                               atomicOp);
@@ -2545,7 +2617,7 @@
 XGL_VOID XGLAPI xglCmdWriteTimestamp(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_TIMESTAMP_TYPE                          timestampType,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset);
 
 XGL_VOID XGLAPI xglCmdInitAtomicCounters(
@@ -2560,7 +2632,7 @@
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_UINT                                    startCounter,
     XGL_UINT                                    counterCount,
-    XGL_GPU_MEMORY                              srcMem,
+    XGL_BUFFER                                  srcBuffer,
     XGL_GPU_SIZE                                srcOffset);
 
 XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
@@ -2568,7 +2640,7 @@
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_UINT                                    startCounter,
     XGL_UINT                                    counterCount,
-    XGL_GPU_MEMORY                              destMem,
+    XGL_BUFFER                                  destBuffer,
     XGL_GPU_SIZE                                destOffset);
 
 XGL_RESULT XGLAPI xglCreateFramebuffer(
@@ -2619,11 +2691,11 @@
     feedback is part of the pipeline, transform feedback binding would be available
     through a new API bind point:
 
-        xglCmdBindTransformFeedbackMemoryView(
+        xglCmdBindTransformFeedbackBufferView(
                 XGL_CMD_BUFFER                              cmdBuffer,
                 XGL_PIPELINE_BIND_POINT                     pipelineBindPoint, // = GRAPHICS
                 XGL_UINT                                    index,
-                const XGL_MEMORY_VIEW_ATTACH_INFO*          pMemView);
+                const XGL_BUFFER_VIEW_ATTACH_INFO*          pBufferView);
 
     2) "Bindless" + support for non-bindless hardware.
 
diff --git a/include/xglDbg.h b/include/xglDbg.h
index 69e39d6..3ea8448 100644
--- a/include/xglDbg.h
+++ b/include/xglDbg.h
@@ -87,6 +87,9 @@
     XGL_DBG_OBJECT_FRAMEBUFFER            = 0x1d,
     XGL_DBG_OBJECT_RENDER_PASS            = 0x1e,
 
+    XGL_DBG_OBJECT_BUFFER,
+    XGL_DBG_OBJECT_BUFFER_VIEW,
+
     XGL_DBG_OBJECT_TYPE_BEGIN_RANGE = XGL_DBG_OBJECT_UNKNOWN,
     XGL_DBG_OBJECT_TYPE_END_RANGE   = XGL_DBG_OBJECT_RENDER_PASS,
     XGL_NUM_DBG_OBJECT_TYPE         = (XGL_DBG_OBJECT_TYPE_END_RANGE - XGL_DBG_OBJECT_TYPE_BEGIN_RANGE + 1),
diff --git a/include/xglLayer.h b/include/xglLayer.h
index 6061d89..8c473ba 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -45,7 +45,6 @@
     xglMapMemoryType MapMemory;
     xglUnmapMemoryType UnmapMemory;
     xglPinSystemMemoryType PinSystemMemory;
-    xglRemapVirtualMemoryPagesType RemapVirtualMemoryPages;
     xglGetMultiGpuCompatibilityType GetMultiGpuCompatibility;
     xglOpenSharedMemoryType OpenSharedMemory;
     xglOpenSharedQueueSemaphoreType OpenSharedQueueSemaphore;
@@ -54,6 +53,8 @@
     xglDestroyObjectType DestroyObject;
     xglGetObjectInfoType GetObjectInfo;
     xglBindObjectMemoryType BindObjectMemory;
+    xglBindObjectMemoryRangeType BindObjectMemoryRange;
+    xglBindImageMemoryRangeType BindImageMemoryRange;
     xglCreateFenceType CreateFence;
     xglGetFenceStatusType GetFenceStatus;
     xglWaitForFencesType WaitForFences;
@@ -67,6 +68,8 @@
     xglCreateQueryPoolType CreateQueryPool;
     xglGetQueryPoolResultsType GetQueryPoolResults;
     xglGetFormatInfoType GetFormatInfo;
+    xglCreateBufferType CreateBuffer;
+    xglCreateBufferViewType CreateBufferView;
     xglCreateImageType CreateImage;
     xglGetImageSubresourceInfoType GetImageSubresourceInfo;
     xglCreateImageViewType CreateImageView;
@@ -84,7 +87,7 @@
     xglEndDescriptorSetUpdateType EndDescriptorSetUpdate;
     xglAttachSamplerDescriptorsType AttachSamplerDescriptors;
     xglAttachImageViewDescriptorsType AttachImageViewDescriptors;
-    xglAttachMemoryViewDescriptorsType AttachMemoryViewDescriptors;
+    xglAttachBufferViewDescriptorsType AttachBufferViewDescriptors;
     xglAttachNestedDescriptorsType AttachNestedDescriptors;
     xglClearDescriptorSetSlotsType ClearDescriptorSetSlots;
     xglCreateViewportStateType CreateViewportState;
@@ -100,10 +103,10 @@
     xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
     xglCmdBindStateObjectType CmdBindStateObject;
     xglCmdBindDescriptorSetType CmdBindDescriptorSet;
-    xglCmdBindDynamicMemoryViewType CmdBindDynamicMemoryView;
-    xglCmdBindVertexDataType CmdBindVertexData;
-    xglCmdBindIndexDataType CmdBindIndexData;
-    xglCmdPrepareMemoryRegionsType CmdPrepareMemoryRegions;
+    xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView;
+    xglCmdBindVertexBufferType CmdBindVertexBuffer;
+    xglCmdBindIndexBufferType CmdBindIndexBuffer;
+    xglCmdPrepareBufferRegionsType CmdPrepareBufferRegions;
     xglCmdPrepareImagesType CmdPrepareImages;
     xglCmdDrawType CmdDraw;
     xglCmdDrawIndexedType CmdDrawIndexed;
@@ -111,20 +114,20 @@
     xglCmdDrawIndexedIndirectType CmdDrawIndexedIndirect;
     xglCmdDispatchType CmdDispatch;
     xglCmdDispatchIndirectType CmdDispatchIndirect;
-    xglCmdCopyMemoryType CmdCopyMemory;
+    xglCmdCopyBufferType CmdCopyBuffer;
     xglCmdCopyImageType CmdCopyImage;
-    xglCmdCopyMemoryToImageType CmdCopyMemoryToImage;
-    xglCmdCopyImageToMemoryType CmdCopyImageToMemory;
+    xglCmdCopyBufferToImageType CmdCopyBufferToImage;
+    xglCmdCopyImageToBufferType CmdCopyImageToBuffer;
     xglCmdCloneImageDataType CmdCloneImageData;
-    xglCmdUpdateMemoryType CmdUpdateMemory;
-    xglCmdFillMemoryType CmdFillMemory;
+    xglCmdUpdateBufferType CmdUpdateBuffer;
+    xglCmdFillBufferType CmdFillBuffer;
     xglCmdClearColorImageType CmdClearColorImage;
     xglCmdClearColorImageRawType CmdClearColorImageRaw;
     xglCmdClearDepthStencilType CmdClearDepthStencil;
     xglCmdResolveImageType CmdResolveImage;
     xglCmdSetEventType CmdSetEvent;
     xglCmdResetEventType CmdResetEvent;
-    xglCmdMemoryAtomicType CmdMemoryAtomic;
+    xglCmdBufferAtomicType CmdBufferAtomic;
     xglCmdBeginQueryType CmdBeginQuery;
     xglCmdEndQueryType CmdEndQuery;
     xglCmdResetQueryPoolType CmdResetQueryPool;
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index a77764c..3fbc712 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -29,8 +29,6 @@
 
 namespace xgl_testing {
 
-typedef GpuMemory Buffer;
-
 XGL_SIZE get_format_size(XGL_FORMAT format);
 
 class Environment : public ::testing::Environment {
@@ -54,7 +52,7 @@
 
 class ImageChecker {
 public:
-    explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_MEMORY_IMAGE_COPY> &regions)
+    explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
         : info_(info), regions_(regions), pattern_(HASH) {}
     explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info, const std::vector<XGL_IMAGE_SUBRESOURCE_RANGE> &ranges);
     explicit ImageChecker(const XGL_IMAGE_CREATE_INFO &info);
@@ -67,7 +65,7 @@
     bool check(Buffer &buf) const { return walk(CHECK, buf); }
     bool check(Image &img) const { return walk(CHECK, img); }
 
-    const std::vector<XGL_MEMORY_IMAGE_COPY> &regions() const { return regions_; }
+    const std::vector<XGL_BUFFER_IMAGE_COPY> &regions() const { return regions_; }
 
     static void hash_salt_generate() { hash_salt_++; }
 
@@ -83,18 +81,18 @@
     };
 
     XGL_SIZE buffer_cpp() const;
-    XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_MEMORY_IMAGE_COPY &region) const;
+    XGL_SUBRESOURCE_LAYOUT buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const;
 
     bool walk(Action action, Buffer &buf) const;
     bool walk(Action action, Image &img) const;
-    bool walk_region(Action action, const XGL_MEMORY_IMAGE_COPY &region, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
+    bool walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region, const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const;
 
     std::vector<uint8_t> pattern_hash(const XGL_IMAGE_SUBRESOURCE &subres, const XGL_OFFSET3D &offset) const;
 
     static uint32_t hash_salt_;
 
     XGL_IMAGE_CREATE_INFO info_;
-    std::vector<XGL_MEMORY_IMAGE_COPY> regions_;
+    std::vector<XGL_BUFFER_IMAGE_COPY> regions_;
 
     Pattern pattern_;
     std::vector<uint8_t> pattern_solid_;
@@ -179,9 +177,9 @@
     // create a region for every mip level in array slice 0
     XGL_GPU_SIZE offset = 0;
     for (XGL_UINT lv = 0; lv < info_.mipLevels; lv++) {
-        XGL_MEMORY_IMAGE_COPY region = {};
+        XGL_BUFFER_IMAGE_COPY region = {};
 
-        region.memOffset = offset;
+        region.bufferOffset = offset;
         region.imageSubresource.mipLevel = lv;
         region.imageSubresource.arraySlice = 0;
         region.imageExtent = Image::extent(info_.extent, lv);
@@ -216,9 +214,9 @@
 
         for (XGL_UINT slice = 1; slice < info_.arraySize; slice++) {
             for (XGL_UINT i = 0; i < slice_region_count; i++) {
-                XGL_MEMORY_IMAGE_COPY region = regions_[i];
+                XGL_BUFFER_IMAGE_COPY region = regions_[i];
 
-                region.memOffset += slice_pitch * slice;
+                region.bufferOffset += slice_pitch * slice;
                 region.imageSubresource.arraySlice = slice;
                 regions_.push_back(region);
             }
@@ -234,8 +232,8 @@
          it != ranges.end(); it++) {
         for (XGL_UINT lv = 0; lv < it->mipLevels; lv++) {
             for (XGL_UINT slice = 0; slice < it->arraySize; slice++) {
-                XGL_MEMORY_IMAGE_COPY region = {};
-                region.memOffset = offset;
+                XGL_BUFFER_IMAGE_COPY region = {};
+                region.bufferOffset = offset;
                 region.imageSubresource = Image::subresource(*it, lv, slice);
                 region.imageExtent = Image::extent(info_.extent, lv);
 
@@ -261,10 +259,10 @@
     return get_format_size(info_.format);
 }
 
-XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_MEMORY_IMAGE_COPY &region) const
+XGL_SUBRESOURCE_LAYOUT ImageChecker::buffer_layout(const XGL_BUFFER_IMAGE_COPY &region) const
 {
     XGL_SUBRESOURCE_LAYOUT layout = {};
-    layout.offset = region.memOffset;
+    layout.offset = region.bufferOffset;
     layout.rowPitch = buffer_cpp() * region.imageExtent.width;
     layout.depthPitch = layout.rowPitch * region.imageExtent.height;
     layout.size = layout.depthPitch * region.imageExtent.depth;
@@ -276,7 +274,7 @@
 {
     XGL_GPU_SIZE size = 0;
 
-    for (std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it = regions_.begin();
+    for (std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it = regions_.begin();
          it != regions_.end(); it++) {
         const XGL_SUBRESOURCE_LAYOUT layout = buffer_layout(*it);
         if (size < layout.offset + layout.size)
@@ -286,7 +284,7 @@
     return size;
 }
 
-bool ImageChecker::walk_region(Action action, const XGL_MEMORY_IMAGE_COPY &region,
+bool ImageChecker::walk_region(Action action, const XGL_BUFFER_IMAGE_COPY &region,
                                const XGL_SUBRESOURCE_LAYOUT &layout, void *data) const
 {
     for (XGL_INT z = 0; z < region.imageExtent.depth; z++) {
@@ -329,7 +327,7 @@
     if (!data)
         return false;
 
-    std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it;
+    std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
     for (it = regions_.begin(); it != regions_.end(); it++) {
         if (!walk_region(action, *it, buffer_layout(*it), data))
             break;
@@ -346,7 +344,7 @@
     if (!data)
         return false;
 
-    std::vector<XGL_MEMORY_IMAGE_COPY>::const_iterator it;
+    std::vector<XGL_BUFFER_IMAGE_COPY>::const_iterator it;
     for (it = regions_.begin(); it != regions_.end(); it++) {
         if (!walk_region(action, *it, img.subresource_layout(it->imageSubresource), data))
             break;
@@ -487,24 +485,6 @@
         }
     }
 
-    void add_memory_ref(const xgl_testing::GpuMemory &obj, XGL_FLAGS flags)
-    {
-        std::vector<XGL_MEMORY_REF>::iterator it;
-        for (it = mem_refs_.begin(); it != mem_refs_.end(); it++) {
-            if (it->mem == obj.obj())
-                break;
-        }
-
-        if (it == mem_refs_.end()) {
-            XGL_MEMORY_REF ref = {};
-            ref.mem = obj.obj();
-            ref.flags = flags;
-            mem_refs_.push_back(ref);
-        } else {
-            it->flags &= flags;
-        }
-    }
-
     xgl_testing::Device &dev_;
     xgl_testing::Queue &queue_;
     xgl_testing::CmdBuffer cmd_;
@@ -512,9 +492,9 @@
     std::vector<XGL_MEMORY_REF> mem_refs_;
 };
 
-typedef XglCmdBlitTest XglCmdFillMemoryTest;
+typedef XglCmdBlitTest XglCmdFillBufferTest;
 
-TEST_F(XglCmdFillMemoryTest, Basic)
+TEST_F(XglCmdFillBufferTest, Basic)
 {
     xgl_testing::Buffer buf;
 
@@ -522,8 +502,8 @@
     add_memory_ref(buf, 0);
 
     cmd_.begin();
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 4, 0x11111111);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 4, 16, 0x22222222);
     cmd_.end();
 
     submit_and_done();
@@ -537,7 +517,7 @@
     buf.unmap();
 }
 
-TEST_F(XglCmdFillMemoryTest, Large)
+TEST_F(XglCmdFillBufferTest, Large)
 {
     const XGL_GPU_SIZE size = 32 * 1024 * 1024;
     xgl_testing::Buffer buf;
@@ -546,8 +526,8 @@
     add_memory_ref(buf, 0);
 
     cmd_.begin();
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, size / 2, 0x11111111);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), size / 2, size / 2, 0x22222222);
     cmd_.end();
 
     submit_and_done();
@@ -561,7 +541,7 @@
     buf.unmap();
 }
 
-TEST_F(XglCmdFillMemoryTest, Overlap)
+TEST_F(XglCmdFillBufferTest, Overlap)
 {
     xgl_testing::Buffer buf;
 
@@ -569,8 +549,8 @@
     add_memory_ref(buf, 0);
 
     cmd_.begin();
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
-    xglCmdFillMemory(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 0, 48, 0x11111111);
+    xglCmdFillBuffer(cmd_.obj(), buf.obj(), 32, 32, 0x22222222);
     cmd_.end();
 
     submit_and_done();
@@ -584,7 +564,7 @@
     buf.unmap();
 }
 
-TEST_F(XglCmdFillMemoryTest, MultiAlignments)
+TEST_F(XglCmdFillBufferTest, MultiAlignments)
 {
     xgl_testing::Buffer bufs[9];
     XGL_GPU_SIZE size = 4;
@@ -593,7 +573,7 @@
     for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
         bufs[i].init(dev_, size);
         add_memory_ref(bufs[i], 0);
-        xglCmdFillMemory(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
+        xglCmdFillBuffer(cmd_.obj(), bufs[i].obj(), 0, size, 0x11111111);
         size <<= 1;
     }
     cmd_.end();
@@ -613,9 +593,9 @@
     }
 }
 
-typedef XglCmdBlitTest XglCmdCopyMemoryTest;
+typedef XglCmdBlitTest XglCmdCopyBufferTest;
 
-TEST_F(XglCmdCopyMemoryTest, Basic)
+TEST_F(XglCmdCopyBufferTest, Basic)
 {
     xgl_testing::Buffer src, dst;
 
@@ -629,9 +609,9 @@
     add_memory_ref(dst, 0);
 
     cmd_.begin();
-    XGL_MEMORY_COPY region = {};
+    XGL_BUFFER_COPY region = {};
     region.copySize = 4;
-    xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
+    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
     cmd_.end();
 
     submit_and_done();
@@ -641,7 +621,7 @@
     dst.unmap();
 }
 
-TEST_F(XglCmdCopyMemoryTest, Large)
+TEST_F(XglCmdCopyBufferTest, Large)
 {
     const XGL_GPU_SIZE size = 32 * 1024 * 1024;
     xgl_testing::Buffer src, dst;
@@ -658,9 +638,9 @@
     add_memory_ref(dst, 0);
 
     cmd_.begin();
-    XGL_MEMORY_COPY region = {};
+    XGL_BUFFER_COPY region = {};
     region.copySize = size;
-    xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
+    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), 1, &region);
     cmd_.end();
 
     submit_and_done();
@@ -671,9 +651,9 @@
     dst.unmap();
 }
 
-TEST_F(XglCmdCopyMemoryTest, MultiAlignments)
+TEST_F(XglCmdCopyBufferTest, MultiAlignments)
 {
-    const XGL_MEMORY_COPY regions[] = {
+    const XGL_BUFFER_COPY regions[] = {
         /* well aligned */
         {  0,   0,  256 },
         {  0, 256,  128 },
@@ -702,14 +682,14 @@
     add_memory_ref(dst, 0);
 
     cmd_.begin();
-    xglCmdCopyMemory(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
+    xglCmdCopyBuffer(cmd_.obj(), src.obj(), dst.obj(), ARRAY_SIZE(regions), regions);
     cmd_.end();
 
     submit_and_done();
 
     data = static_cast<uint8_t *>(dst.map());
     for (int i = 0; i < ARRAY_SIZE(regions); i++) {
-        const XGL_MEMORY_COPY &r = regions[i];
+        const XGL_BUFFER_COPY &r = regions[i];
 
         for (int j = 0; j < r.copySize; j++) {
             EXPECT_EQ(r.srcOffset + j, data[r.destOffset + j]) <<
@@ -720,7 +700,7 @@
     dst.unmap();
 }
 
-TEST_F(XglCmdCopyMemoryTest, RAWHazard)
+TEST_F(XglCmdCopyBufferTest, RAWHazard)
 {
     xgl_testing::Buffer bufs[3];
 
@@ -735,21 +715,21 @@
 
     cmd_.begin();
 
-    xglCmdFillMemory(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
+    xglCmdFillBuffer(cmd_.obj(), bufs[0].obj(), 0, 4, 0x11111111);
     // is this necessary?
-    XGL_MEMORY_STATE_TRANSITION transition = bufs[0].state_transition(
-            XGL_MEMORY_STATE_DATA_TRANSFER, XGL_MEMORY_STATE_DATA_TRANSFER, 0, 4);
-    xglCmdPrepareMemoryRegions(cmd_.obj(), 1, &transition);
+    XGL_BUFFER_STATE_TRANSITION transition = bufs[0].state_transition(
+            XGL_BUFFER_STATE_DATA_TRANSFER, XGL_BUFFER_STATE_DATA_TRANSFER, 0, 4);
+    xglCmdPrepareBufferRegions(cmd_.obj(), 1, &transition);
 
-    XGL_MEMORY_COPY region = {};
+    XGL_BUFFER_COPY region = {};
     region.copySize = 4;
-    xglCmdCopyMemory(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, &region);
+    xglCmdCopyBuffer(cmd_.obj(), bufs[0].obj(), bufs[1].obj(), 1, &region);
     // is this necessary?
     transition = bufs[1].state_transition(
-            XGL_MEMORY_STATE_DATA_TRANSFER, XGL_MEMORY_STATE_DATA_TRANSFER, 0, 4);
-    xglCmdPrepareMemoryRegions(cmd_.obj(), 1, &transition);
+            XGL_BUFFER_STATE_DATA_TRANSFER, XGL_BUFFER_STATE_DATA_TRANSFER, 0, 4);
+    xglCmdPrepareBufferRegions(cmd_.obj(), 1, &transition);
 
-    xglCmdCopyMemory(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, &region);
+    xglCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, &region);
     cmd_.end();
 
     submit_and_done();
@@ -806,7 +786,7 @@
 
         // copy in and tile
         cmd_.begin();
-        xglCmdCopyMemoryToImage(cmd_.obj(), in_buf.obj(), img.obj(),
+        xglCmdCopyBufferToImage(cmd_.obj(), in_buf.obj(), img.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -830,7 +810,7 @@
 
         // copy out and linearize
         cmd_.begin();
-        xglCmdCopyImageToMemory(cmd_.obj(), img.obj(), out_buf.obj(),
+        xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), out_buf.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -844,7 +824,7 @@
     XGL_FORMAT first_optimal_format_;
 };
 
-class XglCmdCopyMemoryToImageTest : public XglCmdBlitImageTest {
+class XglCmdCopyBufferToImageTest : public XglCmdBlitImageTest {
 protected:
     virtual void SetUp()
     {
@@ -866,7 +846,7 @@
         add_memory_ref(img, 0);
 
         cmd_.begin();
-        xglCmdCopyMemoryToImage(cmd_.obj(), buf.obj(), img.obj(),
+        xglCmdCopyBufferToImage(cmd_.obj(), buf.obj(), img.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -875,7 +855,7 @@
         check_dst(img, checker);
     }
 
-    void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_MEMORY_IMAGE_COPY> &regions)
+    void test_copy_memory_to_image(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
     {
         xgl_testing::ImageChecker checker(img_info, regions);
         test_copy_memory_to_image(img_info, checker);
@@ -888,7 +868,7 @@
     }
 };
 
-TEST_F(XglCmdCopyMemoryToImageTest, Basic)
+TEST_F(XglCmdCopyBufferToImageTest, Basic)
 {
     for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
@@ -903,7 +883,7 @@
     }
 }
 
-class XglCmdCopyImageToMemoryTest : public XglCmdBlitImageTest {
+class XglCmdCopyImageToBufferTest : public XglCmdBlitImageTest {
 protected:
     virtual void SetUp()
     {
@@ -925,7 +905,7 @@
         add_memory_ref(buf, 0);
 
         cmd_.begin();
-        xglCmdCopyImageToMemory(cmd_.obj(), img.obj(), buf.obj(),
+        xglCmdCopyImageToBuffer(cmd_.obj(), img.obj(), buf.obj(),
                 checker.regions().size(), &checker.regions()[0]);
         cmd_.end();
 
@@ -934,7 +914,7 @@
         checker.check(buf);
     }
 
-    void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_MEMORY_IMAGE_COPY> &regions)
+    void test_copy_image_to_memory(const XGL_IMAGE_CREATE_INFO &img_info, const std::vector<XGL_BUFFER_IMAGE_COPY> &regions)
     {
         xgl_testing::ImageChecker checker(img_info, regions);
         test_copy_image_to_memory(img_info, checker);
@@ -947,7 +927,7 @@
     }
 };
 
-TEST_F(XglCmdCopyImageToMemoryTest, Basic)
+TEST_F(XglCmdCopyImageToBufferTest, Basic)
 {
     for (std::vector<xgl_testing::Device::Format>::const_iterator it = test_formats_.begin();
          it != test_formats_.end(); it++) {
@@ -974,19 +954,19 @@
     void test_copy_image(const XGL_IMAGE_CREATE_INFO &src_info, const XGL_IMAGE_CREATE_INFO &dst_info,
                          const std::vector<XGL_IMAGE_COPY> &copies)
     {
-        // convert XGL_IMAGE_COPY to two sets of XGL_MEMORY_IMAGE_COPY
-        std::vector<XGL_MEMORY_IMAGE_COPY> src_regions, dst_regions;
+        // convert XGL_IMAGE_COPY to two sets of XGL_BUFFER_IMAGE_COPY
+        std::vector<XGL_BUFFER_IMAGE_COPY> src_regions, dst_regions;
         XGL_GPU_SIZE src_offset = 0, dst_offset = 0;
         for (std::vector<XGL_IMAGE_COPY>::const_iterator it = copies.begin(); it != copies.end(); it++) {
-            XGL_MEMORY_IMAGE_COPY src_region = {}, dst_region = {};
+            XGL_BUFFER_IMAGE_COPY src_region = {}, dst_region = {};
 
-            src_region.memOffset = src_offset;
+            src_region.bufferOffset = src_offset;
             src_region.imageSubresource = it->srcSubresource;
             src_region.imageOffset = it->srcOffset;
             src_region.imageExtent = it->extent;
             src_regions.push_back(src_region);
 
-            dst_region.memOffset = src_offset;
+            dst_region.bufferOffset = src_offset;
             dst_region.imageSubresource = it->destSubresource;
             dst_region.imageOffset = it->destOffset;
             dst_region.imageExtent = it->extent;
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index bcab74c..3773263 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -470,14 +470,14 @@
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &constantBuffer);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &constantBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&constantBuffer);
+    descriptorSet.AttachBufferView(&constantBuffer);
     m_memoryRefManager.AddMemoryRef(&constantBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -749,7 +749,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -759,7 +759,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -825,7 +825,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -932,11 +932,11 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglIndexBufferObj indexBuffer(m_device);
     indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), XGL_INDEX_16, g_idxData);
-    indexBuffer.SetMemoryState(XGL_MEMORY_STATE_INDEX_DATA);
+    indexBuffer.SetBufferState(XGL_BUFFER_STATE_INDEX_DATA);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1030,7 +1030,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1040,7 +1040,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1124,7 +1124,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1134,7 +1134,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1228,7 +1228,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1238,7 +1238,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1322,7 +1322,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1332,7 +1332,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1417,7 +1417,7 @@
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
 
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
@@ -1425,7 +1425,7 @@
 
     // Create descriptor set and attach the constant buffer to it
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&MVPBuffer);
+    descriptorSet.AttachBufferView(&MVPBuffer);
 
     m_memoryRefManager.AddMemoryRef(&MVPBuffer);
 
@@ -1562,7 +1562,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1572,7 +1572,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1655,7 +1655,7 @@
     ASSERT_NO_FATAL_FAILURE(InitViewport());
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
@@ -1665,7 +1665,7 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&meshBuffer);
+    descriptorSet.AttachBufferView(&meshBuffer);
 
     XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = {
          sizeof(g_vbData[0]),              // strideInBytes;  Distance between vertices in bytes (0 = no advancement)
@@ -1756,14 +1756,14 @@
     XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this);
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
 
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &MVPBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&MVPBuffer);
+    descriptorSet.AttachBufferView(&MVPBuffer);
 
     m_memoryRefManager.AddMemoryRef(&meshBuffer);
     m_memoryRefManager.AddMemoryRef(&MVPBuffer);
@@ -2278,14 +2278,14 @@
                                          1.0, 1.0, 1.0, 1.0 };
 
     XglConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &colorBuffer);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &colorBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&colorBuffer);
+    descriptorSet.AttachBufferView(&colorBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
@@ -2372,26 +2372,26 @@
     const int whiteCount = sizeof(whiteVals) / sizeof(float);
 
     XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
-    ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+    ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
 
     XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
-    ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+    ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
 
     XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
-    ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+    ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
 
     XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
-    ps.BindShaderEntitySlotToMemory(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+    ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&redBuffer);
-    descriptorSet.AttachMemoryView(&greenBuffer);
-    descriptorSet.AttachMemoryView(&blueBuffer);
-    descriptorSet.AttachMemoryView(&whiteBuffer);
+    descriptorSet.AttachBufferView(&redBuffer);
+    descriptorSet.AttachBufferView(&greenBuffer);
+    descriptorSet.AttachBufferView(&blueBuffer);
+    descriptorSet.AttachBufferView(&whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
@@ -2473,26 +2473,26 @@
     const int whiteCount = sizeof(whiteVals) / sizeof(float);
 
     XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
-    ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+    ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
 
     XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
-    ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+    ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
 
     XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
-    ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+    ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
 
     XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
-    ps.BindShaderEntitySlotToMemory(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+    ps.BindShaderEntitySlotToBuffer(18, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&redBuffer);
-    descriptorSet.AttachMemoryView(&greenBuffer);
-    descriptorSet.AttachMemoryView(&blueBuffer);
-    descriptorSet.AttachMemoryView(&whiteBuffer);
+    descriptorSet.AttachBufferView(&redBuffer);
+    descriptorSet.AttachBufferView(&greenBuffer);
+    descriptorSet.AttachBufferView(&blueBuffer);
+    descriptorSet.AttachBufferView(&whiteBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
@@ -2567,7 +2567,7 @@
 
     XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
             sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
-    meshBuffer.SetMemoryState(XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY);
+    meshBuffer.SetBufferState(XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY);
 
 
     const int buf_size = sizeof(MVP) / sizeof(XGL_FLOAT);
@@ -2578,8 +2578,8 @@
     XglSamplerObj sampler(m_device);
     XglTextureObj texture(m_device);
 
-    // vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &meshBuffer.m_constantBufferView);
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mvpBuffer);
+    // vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_VERTEX_INPUT, (XGL_OBJECT) &meshBuffer.m_constantBufferView);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mvpBuffer);
     ps.BindShaderEntitySlotToImage(0, XGL_SLOT_SHADER_TEXTURE_RESOURCE, &texture);
     ps.BindShaderEntitySlotToSampler(0, &sampler);
 
@@ -2589,7 +2589,7 @@
 
     XglDescriptorSetObj descriptorSet(m_device);
 
-    descriptorSet.AttachMemoryView(&mvpBuffer);
+    descriptorSet.AttachBufferView(&mvpBuffer);
     descriptorSet.AttachImageView(&texture);
     descriptorSet.AttachSampler(&sampler);
 
@@ -2698,16 +2698,16 @@
     const int whiteCount = sizeof(whiteVals) / sizeof(float);
 
     XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
-    ps.BindShaderEntitySlotToMemory(10, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+    ps.BindShaderEntitySlotToBuffer(10, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
 
     XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
-    ps.BindShaderEntitySlotToMemory(15, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+    ps.BindShaderEntitySlotToBuffer(15, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
 
     XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
-    ps.BindShaderEntitySlotToMemory(13, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+    ps.BindShaderEntitySlotToBuffer(13, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
 
     XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
-    ps.BindShaderEntitySlotToMemory(17, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+    ps.BindShaderEntitySlotToBuffer(17, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
 
     XglSamplerObj sampler0(m_device);
     XglTextureObj texture0(m_device); // Light Red
@@ -2739,10 +2739,10 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&redBuffer);
-    descriptorSet.AttachMemoryView(&greenBuffer);
-    descriptorSet.AttachMemoryView(&blueBuffer);
-    descriptorSet.AttachMemoryView(&whiteBuffer);
+    descriptorSet.AttachBufferView(&redBuffer);
+    descriptorSet.AttachBufferView(&greenBuffer);
+    descriptorSet.AttachBufferView(&blueBuffer);
+    descriptorSet.AttachBufferView(&whiteBuffer);
     descriptorSet.AttachImageView(&texture0);
     descriptorSet.AttachSampler(&sampler0);
     descriptorSet.AttachImageView(&texture2);
@@ -2836,16 +2836,16 @@
     const int whiteCount = sizeof(whiteVals) / sizeof(float);
 
     XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
-    ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
+    ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &redBuffer);
 
     XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
-    ps.BindShaderEntitySlotToMemory(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
+    ps.BindShaderEntitySlotToBuffer(1, XGL_SLOT_SHADER_RESOURCE, &greenBuffer);
 
     XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
-    ps.BindShaderEntitySlotToMemory(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
+    ps.BindShaderEntitySlotToBuffer(2, XGL_SLOT_SHADER_RESOURCE, &blueBuffer);
 
     XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
-    ps.BindShaderEntitySlotToMemory(3, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
+    ps.BindShaderEntitySlotToBuffer(3, XGL_SLOT_SHADER_RESOURCE, &whiteBuffer);
 
     XglSamplerObj sampler0(m_device);
     XglTextureObj texture0(m_device); // Light Red
@@ -2874,10 +2874,10 @@
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&redBuffer);
-    descriptorSet.AttachMemoryView(&greenBuffer);
-    descriptorSet.AttachMemoryView(&blueBuffer);
-    descriptorSet.AttachMemoryView(&whiteBuffer);
+    descriptorSet.AttachBufferView(&redBuffer);
+    descriptorSet.AttachBufferView(&greenBuffer);
+    descriptorSet.AttachBufferView(&blueBuffer);
+    descriptorSet.AttachBufferView(&whiteBuffer);
     descriptorSet.AttachImageView(&texture0);
     descriptorSet.AttachSampler(&sampler0);
     descriptorSet.AttachImageView(&texture2);
@@ -3136,15 +3136,15 @@
     XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this);
 
     XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
-    vs.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
-    ps.BindShaderEntitySlotToMemory(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
+    vs.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
+    ps.BindShaderEntitySlotToBuffer(0, XGL_SLOT_SHADER_RESOURCE, &mixedBuffer);
 
     XglPipelineObj pipelineobj(m_device);
     pipelineobj.AddShader(&vs);
     pipelineobj.AddShader(&ps);
 
     XglDescriptorSetObj descriptorSet(m_device);
-    descriptorSet.AttachMemoryView(&mixedBuffer);
+    descriptorSet.AttachBufferView(&mixedBuffer);
 
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
     XglCommandBufferObj cmdBuffer(m_device);
diff --git a/tests/xglrenderframework.cpp b/tests/xglrenderframework.cpp
index b95b8e9..c144ac4 100644
--- a/tests/xglrenderframework.cpp
+++ b/tests/xglrenderframework.cpp
@@ -236,10 +236,10 @@
 
 }
 
-void XglDescriptorSetObj::AttachMemoryView(XglConstantBufferObj *constantBuffer)
+void XglDescriptorSetObj::AttachBufferView(XglConstantBufferObj *constantBuffer)
 {
-    m_memoryViews.push_back(&constantBuffer->m_constantBufferView);
-    m_memorySlots.push_back(m_nextSlot);
+    m_bufferViews.push_back(&constantBuffer->m_bufferViewInfo);
+    m_bufferSlots.push_back(m_nextSlot);
     m_nextSlot++;
 
 }
@@ -264,7 +264,7 @@
                                                            vector<XGL_DESCRIPTOR_SET_SLOT_TYPE>types,
                                                            vector<void *>objs )
 {
-    int nSlots = m_memorySlots.size() + m_imageSlots.size() + m_samplerSlots.size();
+    int nSlots = m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size();
     m_slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( nSlots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) );
     memset(m_slotInfo,0,nSlots*sizeof(XGL_DESCRIPTOR_SLOT_INFO));
 
@@ -275,12 +275,12 @@
 
     for (int i=0; i<slots.size(); i++)
     {
-        for (int j=0; j<m_memorySlots.size(); j++)
+        for (int j=0; j<m_bufferSlots.size(); j++)
         {
-            if ( m_memoryViews[j] == objs[i])
+            if ( m_bufferViews[j] == objs[i])
             {
-                m_slotInfo[m_memorySlots[j]].shaderEntityIndex = slots[i];
-                m_slotInfo[m_memorySlots[j]].slotObjectType = types[i];
+                m_slotInfo[m_bufferSlots[j]].shaderEntityIndex = slots[i];
+                m_slotInfo[m_bufferSlots[j]].slotObjectType = types[i];
             }
         }
         for (int j=0; j<m_imageSlots.size(); j++)
@@ -317,9 +317,9 @@
     begin();
     clear();
 
-    for (int i=0; i<m_memoryViews.size();i++)
+    for (int i=0; i<m_bufferViews.size();i++)
     {
-        attach(m_memorySlots[i], *m_memoryViews[i]);
+        attach(m_bufferSlots[i], *m_bufferViews[i]);
     }
     for (int i=0; i<m_samplers.size();i++)
     {
@@ -350,9 +350,9 @@
     begin();
     clear();
 
-    for (int i=0; i<m_memoryViews.size();i++)
+    for (int i=0; i<m_bufferViews.size();i++)
     {
-        attach(m_memorySlots[i], *m_memoryViews[i]);
+        attach(m_bufferSlots[i], *m_bufferViews[i]);
     }
     for (int i=0; i<m_samplers.size();i++)
     {
@@ -365,7 +365,7 @@
 
     end();
 
-    // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
+    // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
     xglCmdBindDescriptorSet(commandBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, obj(), 0 );
 }
 
@@ -548,7 +548,7 @@
     m_device = device;
     m_commandBuffer = 0;
 
-    memset(&m_constantBufferView,0,sizeof(m_constantBufferView));
+    memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
 }
 
 XglConstantBufferObj::XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data)
@@ -556,7 +556,7 @@
     m_device = device;
     m_commandBuffer = 0;
 
-    memset(&m_constantBufferView,0,sizeof(m_constantBufferView));
+    memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
     m_numVertices = constantCount;
     m_stride = constantSize;
 
@@ -567,27 +567,38 @@
     memcpy(pData, data, allocationSize);
     unmap();
 
-    // set up the memory view for the constant buffer
-    this->m_constantBufferView.stride = 16;
-    this->m_constantBufferView.range  = allocationSize;
-    this->m_constantBufferView.offset = 0;
-    this->m_constantBufferView.mem    = obj();
-    this->m_constantBufferView.format.channelFormat = XGL_CH_FMT_R32G32B32A32;
-    this->m_constantBufferView.format.numericFormat = XGL_NUM_FMT_FLOAT;
-    this->m_constantBufferView.state  = XGL_MEMORY_STATE_DATA_TRANSFER;
+    // set up the buffer view for the constant buffer
+    XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
+    view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    view_info.buffer = obj();
+    view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+    view_info.stride = 16;
+    view_info.format.channelFormat = XGL_CH_FMT_R32G32B32A32;
+    view_info.format.numericFormat = XGL_NUM_FMT_FLOAT;
+    view_info.channels.r = XGL_CHANNEL_SWIZZLE_R;
+    view_info.channels.g = XGL_CHANNEL_SWIZZLE_G;
+    view_info.channels.b = XGL_CHANNEL_SWIZZLE_B;
+    view_info.channels.a = XGL_CHANNEL_SWIZZLE_A;
+    view_info.offset = 0;
+    view_info.range  = allocationSize;
+    m_bufferView.init(*m_device, view_info);
+
+    this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    this->m_bufferViewInfo.view = m_bufferView.obj();
+    this->m_bufferViewInfo.state = XGL_BUFFER_STATE_DATA_TRANSFER;
 }
 
 void XglConstantBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, XGL_UINT binding)
 {
-    xglCmdBindVertexData(cmdBuffer, obj(), offset, binding);
+    xglCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
 }
 
 
-void XglConstantBufferObj::SetMemoryState(XGL_MEMORY_STATE newState)
+void XglConstantBufferObj::SetBufferState(XGL_BUFFER_STATE newState)
 {
     XGL_RESULT err = XGL_SUCCESS;
 
-    if (this->m_constantBufferView.state == newState)
+    if (this->m_bufferViewInfo.state == newState)
         return;
 
     if (!m_commandBuffer)
@@ -611,12 +622,12 @@
     err = m_commandBuffer->BeginCommandBuffer(&cmd_buf_info);
     ASSERT_XGL_SUCCESS(err);
 
-    XGL_MEMORY_STATE_TRANSITION transition =
-        state_transition(XGL_MEMORY_STATE_DATA_TRANSFER, newState, 0, m_numVertices * m_stride);
+    XGL_BUFFER_STATE_TRANSITION transition =
+        state_transition(XGL_BUFFER_STATE_DATA_TRANSFER, newState, 0, m_numVertices * m_stride);
 
     // write transition to the command buffer
-    m_commandBuffer->PrepareMemoryRegions(1, &transition);
-    this->m_constantBufferView.state = newState;
+    m_commandBuffer->PrepareBufferRegions(1, &transition);
+    this->m_bufferViewInfo.state = newState;
 
     // finish recording the command buffer
     err = m_commandBuffer->EndCommandBuffer();
@@ -626,7 +637,7 @@
     XGL_MEMORY_REF memRefs;
     // this command buffer only uses the vertex buffer memory
     memRefs.flags = 0;
-    memRefs.mem = obj();
+    memRefs.mem = memories()[0];
 
     // submit the command buffer to the universal queue
     XGL_CMD_BUFFER bufferArray[1];
@@ -673,19 +684,30 @@
     memcpy(pData, data, allocationSize);
     unmap();
 
-    // set up the memory view for the constant buffer
-    this->m_constantBufferView.stride = m_stride;
-    this->m_constantBufferView.range  = allocationSize;
-    this->m_constantBufferView.offset = 0;
-    this->m_constantBufferView.mem    = obj();
-    this->m_constantBufferView.format.channelFormat = viewFormat.channelFormat;
-    this->m_constantBufferView.format.numericFormat = viewFormat.numericFormat;
-    this->m_constantBufferView.state  = XGL_MEMORY_STATE_DATA_TRANSFER;
+    // set up the buffer view for the constant buffer
+    XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
+    view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    view_info.buffer = obj();
+    view_info.viewType = XGL_BUFFER_VIEW_TYPED;
+    view_info.stride = m_stride;
+    view_info.format.channelFormat = viewFormat.channelFormat;
+    view_info.format.numericFormat = viewFormat.numericFormat;
+    view_info.channels.r = XGL_CHANNEL_SWIZZLE_R;
+    view_info.channels.g = XGL_CHANNEL_SWIZZLE_G;
+    view_info.channels.b = XGL_CHANNEL_SWIZZLE_B;
+    view_info.channels.a = XGL_CHANNEL_SWIZZLE_A;
+    view_info.offset = 0;
+    view_info.range  = allocationSize;
+    m_bufferView.init(*m_device, view_info);
+
+    this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
+    this->m_bufferViewInfo.view = m_bufferView.obj();
+    this->m_bufferViewInfo.state = XGL_BUFFER_STATE_DATA_TRANSFER;
 }
 
 void XglIndexBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset)
 {
-    xglCmdBindIndexData(cmdBuffer, obj(), offset, m_indexType);
+    xglCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
 }
 
 XGL_INDEX_TYPE XglIndexBufferObj::GetIndexType()
@@ -703,8 +725,8 @@
     stageInfo->shader.descriptorSetMapping[0].descriptorCount = 0;
     stageInfo->shader.linkConstBufferCount = 0;
     stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
-    stageInfo->shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED;
-    stageInfo->shader.dynamicMemoryViewMapping.shaderEntityIndex = 0;
+    stageInfo->shader.dynamicBufferViewMapping.slotObjectType = XGL_SLOT_UNUSED;
+    stageInfo->shader.dynamicBufferViewMapping.shaderEntityIndex = 0;
 
     stageInfo->shader.descriptorSetMapping[0].descriptorCount = descriptorSet->GetTotalSlots();
     if (stageInfo->shader.descriptorSetMapping[0].descriptorCount)
@@ -713,15 +735,15 @@
         vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> allTypes;
         vector<void *> allObjs;
 
-        allSlots.reserve(m_memSlots.size() + m_imageSlots.size() + m_samplerSlots.size());
-        allTypes.reserve(m_memTypes.size() + m_imageTypes.size() + m_samplerTypes.size());
-        allObjs.reserve(m_memObjs.size() + m_imageObjs.size() + m_samplerObjs.size());
+        allSlots.reserve(m_bufferSlots.size() + m_imageSlots.size() + m_samplerSlots.size());
+        allTypes.reserve(m_bufferTypes.size() + m_imageTypes.size() + m_samplerTypes.size());
+        allObjs.reserve(m_bufferObjs.size() + m_imageObjs.size() + m_samplerObjs.size());
 
-        if (m_memSlots.size())
+        if (m_bufferSlots.size())
         {
-            allSlots.insert(allSlots.end(), m_memSlots.begin(), m_memSlots.end());
-            allTypes.insert(allTypes.end(), m_memTypes.begin(), m_memTypes.end());
-            allObjs.insert(allObjs.end(), m_memObjs.begin(), m_memObjs.end());
+            allSlots.insert(allSlots.end(), m_bufferSlots.begin(), m_bufferSlots.end());
+            allTypes.insert(allTypes.end(), m_bufferTypes.begin(), m_bufferTypes.end());
+            allObjs.insert(allObjs.end(), m_bufferObjs.begin(), m_bufferObjs.end());
         }
         if (m_imageSlots.size())
         {
@@ -742,11 +764,11 @@
     return stageInfo;
 }
 
-void XglShaderObj::BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer)
+void XglShaderObj::BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer)
 {
-    m_memSlots.push_back(slot);
-    m_memTypes.push_back(type);
-    m_memObjs.push_back(&constantBuffer->m_constantBufferView);
+    m_bufferSlots.push_back(slot);
+    m_bufferTypes.push_back(type);
+    m_bufferObjs.push_back(&constantBuffer->m_bufferViewInfo);
 
 }
 
@@ -943,7 +965,7 @@
 
     for (int i=0; i < m_vertexBufferCount; i++)
     {
-        m_vertexBufferObjs[i]->Bind(m_cmdBuffer, m_vertexBufferObjs[i]->m_constantBufferView.offset,  m_vertexBufferBindings[i]);
+        m_vertexBufferObjs[i]->Bind(m_cmdBuffer, 0,  m_vertexBufferBindings[i]);
     }
 }
 
@@ -952,7 +974,9 @@
 }
 
 void XglMemoryRefManager::AddMemoryRef(XglConstantBufferObj *constantBuffer) {
-    m_bufferObjs.push_back(constantBuffer->obj());
+    const std::vector<XGL_GPU_MEMORY> mems = constantBuffer->memories();
+    if (!mems.empty())
+        m_bufferObjs.push_back(mems[0]);
 }
 
 void XglMemoryRefManager::AddMemoryRef(XglTextureObj *texture) {
@@ -1017,9 +1041,9 @@
     return XGL_SUCCESS;
 }
 
-void XglCommandBufferObj::PrepareMemoryRegions(int transitionCount, XGL_MEMORY_STATE_TRANSITION *transitionPtr)
+void XglCommandBufferObj::PrepareBufferRegions(int transitionCount, XGL_BUFFER_STATE_TRANSITION *transitionPtr)
 {
-    xglCmdPrepareMemoryRegions(obj(), transitionCount, transitionPtr);
+    xglCmdPrepareBufferRegions(obj(), transitionCount, transitionPtr);
 }
 
 void XglCommandBufferObj::ClearAllBuffers(XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage)
@@ -1144,14 +1168,14 @@
 
 void XglCommandBufferObj::BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet)
 {
-    // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view)
+    // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
     xglCmdBindDescriptorSet(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, descriptorSet, 0 );
 }
 void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, XGL_UINT offset)
 {
-    xglCmdBindIndexData(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
+    xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
 }
 void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, XGL_UINT offset, XGL_UINT binding)
 {
-    xglCmdBindVertexData(obj(), vertexBuffer->obj(), offset, binding);
+    xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
 }
diff --git a/tests/xglrenderframework.h b/tests/xglrenderframework.h
index f17ff4c..421f79d 100644
--- a/tests/xglrenderframework.h
+++ b/tests/xglrenderframework.h
@@ -116,7 +116,7 @@
     XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj);
     XGL_RESULT BeginCommandBuffer();
     XGL_RESULT EndCommandBuffer();
-    void PrepareMemoryRegions(int transitionCount, XGL_MEMORY_STATE_TRANSITION *transitionPtr);
+    void PrepareBufferRegions(int transitionCount, XGL_BUFFER_STATE_TRANSITION *transitionPtr);
     void AddRenderTarget(XglImage *renderTarget);
     void AddDepthStencil();
     void ClearAllBuffers();
@@ -138,17 +138,19 @@
 
 };
 
-class XglConstantBufferObj : public xgl_testing::GpuMemory
+class XglConstantBufferObj : public xgl_testing::Buffer
 {
 public:
     XglConstantBufferObj(XglDevice *device);
     XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data);
-    void SetMemoryState(XGL_MEMORY_STATE newState);
+    void SetBufferState(XGL_BUFFER_STATE newState);
     void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, XGL_UINT binding);
-    XGL_MEMORY_VIEW_ATTACH_INFO     m_constantBufferView;
+
+    XGL_BUFFER_VIEW_ATTACH_INFO     m_bufferViewInfo;
 
 protected:
     XglDevice                      *m_device;
+    xgl_testing::BufferView         m_bufferView;
     int                             m_numVertices;
     int                             m_stride;
     XglCommandBufferObj             *m_commandBuffer;
@@ -258,7 +260,7 @@
 {
 public:
     XglDescriptorSetObj(XglDevice *device);
-    void AttachMemoryView(XglConstantBufferObj* constantBuffer);
+    void AttachBufferView(XglConstantBufferObj* constantBuffer);
     void AttachSampler( XglSamplerObj* sampler);
     void AttachImageView( XglTextureObj* texture);
     void BindCommandBuffer(XGL_CMD_BUFFER commandBuffer);
@@ -271,8 +273,8 @@
     XglDevice                           *m_device;
     XGL_DESCRIPTOR_SLOT_INFO            *m_slotInfo;
     int                                  m_nextSlot;
-    vector<int>                          m_memorySlots;
-    vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memoryViews;
+    vector<int>                          m_bufferSlots;
+    vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferViews;
     vector<int>                          m_samplerSlots;
     vector<XglSamplerObj*>               m_samplers;
     vector<int>                          m_imageSlots;
@@ -285,7 +287,7 @@
 public:
     XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework);
     XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(XglDescriptorSetObj *descriptorSet);
-    void BindShaderEntitySlotToMemory(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer);
+    void BindShaderEntitySlotToBuffer(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglConstantBufferObj *constantBuffer);
     void BindShaderEntitySlotToImage(int slot, XGL_DESCRIPTOR_SET_SLOT_TYPE type, XglTextureObj *texture);
     void BindShaderEntitySlotToSampler(int slot, XglSamplerObj *sampler);
 
@@ -293,9 +295,9 @@
     XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info;
     XGL_PIPELINE_SHADER_STAGE m_stage;
     XglDevice *m_device;
-    vector<int>    m_memSlots;
-    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_memTypes;
-    vector<XGL_MEMORY_VIEW_ATTACH_INFO*> m_memObjs;
+    vector<int>    m_bufferSlots;
+    vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_bufferTypes;
+    vector<XGL_BUFFER_VIEW_ATTACH_INFO*> m_bufferObjs;
     vector<int>    m_samplerSlots;
     vector<XGL_DESCRIPTOR_SET_SLOT_TYPE> m_samplerTypes;
     vector<XglSamplerObj*> m_samplerObjs;
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index 0417732..b738734 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -233,6 +233,12 @@
     EXPECT(!alloc_idx && xglBindObjectMemory(obj(), mem.obj(), mem_offset) == XGL_SUCCESS);
 }
 
+void Object::bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
+                         const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+{
+    EXPECT(!alloc_idx && xglBindObjectMemoryRange(obj(), offset, size, mem.obj(), mem_offset) == XGL_SUCCESS);
+}
+
 void Object::unbind_memory(uint32_t alloc_idx)
 {
     EXPECT(!alloc_idx && xglBindObjectMemory(obj(), XGL_NULL_HANDLE, 0) == XGL_SUCCESS);
@@ -255,6 +261,21 @@
     for (int i = 0; i < mem_reqs.size(); i++) {
         XGL_MEMORY_ALLOC_INFO info = GpuMemory::alloc_info(mem_reqs[i]);
 
+        // prefer CPU visible heaps
+        std::vector<uint32_t> non_visible_heaps;
+        info.heapCount = 0;
+        for (uint32_t j = 0; j < mem_reqs[i].heapCount; j++) {
+            const uint32_t heap = mem_reqs[i].heaps[j];
+            const XGL_MEMORY_HEAP_PROPERTIES &props = dev.heap_properties()[heap];
+
+            if (props.flags & XGL_MEMORY_HEAP_CPU_VISIBLE_BIT)
+                info.heaps[info.heapCount++] = heap;
+            else
+                non_visible_heaps.push_back(heap);
+        }
+        for (std::vector<uint32_t>::const_iterator it = non_visible_heaps.begin(); it != non_visible_heaps.end(); it++)
+            info.heaps[info.heapCount++] = *it;
+
         primary_mem_ = &internal_mems_[i];
 
         internal_mems_[i].init(dev, info);
@@ -496,24 +517,6 @@
     DERIVED_OBJECT_INIT(xglAllocMemory, dev.obj(), &info);
 }
 
-void GpuMemory::init(const Device &dev, XGL_GPU_SIZE size)
-{
-    XGL_MEMORY_ALLOC_INFO info = {};
-    info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-    info.allocationSize = size;
-    info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-
-    // find CPU visible heaps
-    for (XGL_UINT id = 0; id < dev.heap_properties().size(); id++) {
-        const XGL_MEMORY_HEAP_PROPERTIES &heap = dev.heap_properties()[id];
-        if (heap.flags & XGL_MEMORY_HEAP_CPU_VISIBLE_BIT)
-            info.heaps[info.heapCount++] = id;
-    }
-
-    EXPECT(info.heapCount);
-    init(dev, info);
-}
-
 void GpuMemory::init(const Device &dev, size_t size, const void *data)
 {
     DERIVED_OBJECT_INIT(xglPinSystemMemory, dev.obj(), data, size);
@@ -610,6 +613,24 @@
     return err;
 }
 
+void Buffer::init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+{
+    init_no_mem(dev, info);
+    alloc_memory(dev);
+}
+
+void Buffer::init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info)
+{
+    DERIVED_OBJECT_INIT(xglCreateBuffer, dev.obj(), &info);
+    create_info_ = info;
+}
+
+void BufferView::init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info)
+{
+    DERIVED_OBJECT_INIT(xglCreateBufferView, dev.obj(), &info);
+    alloc_memory(dev);
+}
+
 void Image::init(const Device &dev, const XGL_IMAGE_CREATE_INFO &info)
 {
     init_no_mem(dev, info);
@@ -645,6 +666,12 @@
     }
 }
 
+void Image::bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
+                        const GpuMemory &mem, XGL_GPU_SIZE mem_offset)
+{
+    EXPECT(!alloc_idx && xglBindImageMemoryRange(obj(), &info, mem.obj(), mem_offset) == XGL_SUCCESS);
+}
+
 XGL_SUBRESOURCE_LAYOUT Image::subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const
 {
     const XGL_SUBRESOURCE_INFO_TYPE type = XGL_INFO_TYPE_SUBRESOURCE_LAYOUT;
@@ -752,9 +779,9 @@
     xglAttachImageViewDescriptors(obj(), start_slot, img_views.size(), &img_views[0]);
 }
 
-void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_MEMORY_VIEW_ATTACH_INFO> &mem_views)
+void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views)
 {
-    xglAttachMemoryViewDescriptors(obj(), start_slot, mem_views.size(), &mem_views[0]);
+    xglAttachBufferViewDescriptors(obj(), start_slot, buf_views.size(), &buf_views[0]);
 }
 
 void DescriptorSet::attach(uint32_t start_slot, const std::vector<XGL_DESCRIPTOR_SET_ATTACH_INFO> &sets)
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index 0e9e28a..725cb9d 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -43,6 +43,8 @@
 class QueueSemaphore;
 class Event;
 class QueryPool;
+class Buffer;
+class BufferView;
 class Image;
 class ImageView;
 class ColorAttachmentView;
@@ -127,6 +129,10 @@
     void unbind_memory(uint32_t alloc_idx);
     void unbind_memory();
 
+    // xglBindObjectMemoryRange()
+    void bind_memory(uint32_t alloc_idx, XGL_GPU_SIZE offset, XGL_GPU_SIZE size,
+                     const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
+
     // Unless an object is initialized with init_no_mem(), memories are
     // automatically allocated and bound.  These methods can be used to get
     // the memories (for XGL_MEMORY_REFs), or to map/unmap the primary memory.
@@ -262,13 +268,10 @@
 
 class GpuMemory : public DerivedObject<XGL_GPU_MEMORY, BaseObject> {
 public:
-    explicit GpuMemory() {}
-    explicit GpuMemory(const Device &dev, XGL_GPU_SIZE size) { init(dev, size); }
     ~GpuMemory();
 
     // xglAllocMemory()
     void init(const Device &dev, const XGL_MEMORY_ALLOC_INFO &info);
-    void init(const Device &dev, XGL_GPU_SIZE size);
     // xglPinSystemMemory()
     void init(const Device &dev, size_t size, const void *data);
     // xglOpenSharedMemory()
@@ -290,19 +293,6 @@
     // xglUnmapMemory()
     void unmap() const;
 
-    XGL_MEMORY_STATE_TRANSITION state_transition(XGL_MEMORY_STATE old_state, XGL_MEMORY_STATE new_state,
-                                                 XGL_GPU_SIZE offset, XGL_GPU_SIZE size) const
-    {
-        XGL_MEMORY_STATE_TRANSITION transition = {};
-        transition.sType = XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION;
-        transition.mem = obj();
-        transition.oldState = old_state;
-        transition.newState = new_state;
-        transition.offset = offset;
-        transition.regionSize = size;
-        return transition;
-    }
-
     static XGL_MEMORY_ALLOC_INFO alloc_info(const XGL_MEMORY_REQUIREMENTS &reqs);
 };
 
@@ -353,6 +343,41 @@
     static XGL_QUERY_POOL_CREATE_INFO create_info(XGL_QUERY_TYPE type, uint32_t slot_count);
 };
 
+class Buffer : public DerivedObject<XGL_BUFFER, Object> {
+public:
+    explicit Buffer() {}
+    explicit Buffer(const Device &dev, const XGL_BUFFER_CREATE_INFO &info) { init(dev, info); }
+    explicit Buffer(const Device &dev, XGL_GPU_SIZE size) { init(dev, size); }
+
+    // xglCreateBuffer()
+    void init(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
+    void init(const Device &dev, XGL_GPU_SIZE size) { init(dev, create_info(size, 0)); }
+    void init_no_mem(const Device &dev, const XGL_BUFFER_CREATE_INFO &info);
+
+    static XGL_BUFFER_CREATE_INFO create_info(XGL_GPU_SIZE size, XGL_FLAGS usage);
+
+    XGL_BUFFER_STATE_TRANSITION state_transition(XGL_BUFFER_STATE old_state, XGL_BUFFER_STATE new_state,
+                                                 XGL_GPU_SIZE offset, XGL_GPU_SIZE size) const
+    {
+        XGL_BUFFER_STATE_TRANSITION transition = {};
+        transition.sType = XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION;
+        transition.buffer = obj();
+        transition.oldState = old_state;
+        transition.newState = new_state;
+        transition.offset = offset;
+        transition.regionSize = size;
+        return transition;
+    }
+private:
+    XGL_BUFFER_CREATE_INFO create_info_;
+};
+
+class BufferView : public DerivedObject<XGL_BUFFER_VIEW, Object> {
+public:
+    // xglCreateBufferView()
+    void init(const Device &dev, const XGL_BUFFER_VIEW_CREATE_INFO &info);
+};
+
 class Image : public DerivedObject<XGL_IMAGE, Object> {
 public:
     explicit Image() : format_features_(0) {}
@@ -364,6 +389,10 @@
     // xglOpenPeerImage()
     void init(const Device &dev, const XGL_PEER_IMAGE_OPEN_INFO &info, const XGL_IMAGE_CREATE_INFO &original_info);
 
+    // xglBindImageMemoryRange()
+    void bind_memory(uint32_t alloc_idx, const XGL_IMAGE_MEMORY_BIND_INFO &info,
+                     const GpuMemory &mem, XGL_GPU_SIZE mem_offset);
+
     // xglGetImageSubresourceInfo()
     XGL_SUBRESOURCE_LAYOUT subresource_layout(const XGL_IMAGE_SUBRESOURCE &subres) const;
 
@@ -483,11 +512,11 @@
         attach(start_slot, std::vector<XGL_IMAGE_VIEW_ATTACH_INFO>(1, view));
     }
 
-    // xglAttachMemoryViewDescriptors()
-    void attach(uint32_t start_slot, const std::vector<XGL_MEMORY_VIEW_ATTACH_INFO> &mem_views);
-    void attach(uint32_t start_slot, const XGL_MEMORY_VIEW_ATTACH_INFO &view)
+    // xglAttachBufferViewDescriptors()
+    void attach(uint32_t start_slot, const std::vector<XGL_BUFFER_VIEW_ATTACH_INFO> &buf_views);
+    void attach(uint32_t start_slot, const XGL_BUFFER_VIEW_ATTACH_INFO &view)
     {
-        attach(start_slot, std::vector<XGL_MEMORY_VIEW_ATTACH_INFO>(1, view));
+        attach(start_slot, std::vector<XGL_BUFFER_VIEW_ATTACH_INFO>(1, view));
     }
 
     // xglAttachNestedDescriptors()
@@ -593,6 +622,15 @@
     return info;
 }
 
+inline XGL_BUFFER_CREATE_INFO Buffer::create_info(XGL_GPU_SIZE size, XGL_FLAGS usage)
+{
+    XGL_BUFFER_CREATE_INFO info = {};
+    info.sType = XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    info.size = size;
+    info.usage = usage;
+    return info;
+}
+
 inline XGL_FENCE_CREATE_INFO Fence::create_info(XGL_FLAGS flags)
 {
     XGL_FENCE_CREATE_INFO info = {};
diff --git a/xgl.py b/xgl.py
index 2297f94..ef59f80 100644
--- a/xgl.py
+++ b/xgl.py
@@ -189,6 +189,8 @@
         "XGL_QUEUE",
         "XGL_GPU_MEMORY",
         "XGL_OBJECT",
+        "XGL_BUFFER",
+        "XGL_BUFFER_VIEW",
         "XGL_IMAGE",
         "XGL_IMAGE_VIEW",
         "XGL_COLOR_ATTACHMENT_VIEW",
@@ -210,7 +212,7 @@
         "XGL_EVENT",
         "XGL_QUERY_POOL",
         "XGL_FRAMEBUFFER",
-        "XGL_RENDER_PASS"
+        "XGL_RENDER_PASS",
     ],
     protos=[
         Proto("XGL_RESULT", "InitAndEnumerateGpus",
@@ -312,15 +314,6 @@
              Param("XGL_SIZE", "memSize"),
              Param("XGL_GPU_MEMORY*", "pMem")]),
 
-        Proto("XGL_RESULT", "RemapVirtualMemoryPages",
-            [Param("XGL_DEVICE", "device"),
-             Param("XGL_UINT", "rangeCount"),
-             Param("const XGL_VIRTUAL_MEMORY_REMAP_RANGE*", "pRanges"),
-             Param("XGL_UINT", "preWaitSemaphoreCount"),
-             Param("const XGL_QUEUE_SEMAPHORE*", "pPreWaitSemaphores"),
-             Param("XGL_UINT", "postSignalSemaphoreCount"),
-             Param("const XGL_QUEUE_SEMAPHORE*", "pPostSignalSemaphores")]),
-
         Proto("XGL_RESULT", "GetMultiGpuCompatibility",
             [Param("XGL_PHYSICAL_GPU", "gpu0"),
              Param("XGL_PHYSICAL_GPU", "gpu1"),
@@ -359,7 +352,20 @@
         Proto("XGL_RESULT", "BindObjectMemory",
             [Param("XGL_OBJECT", "object"),
              Param("XGL_GPU_MEMORY", "mem"),
-             Param("XGL_GPU_SIZE", "offset")]),
+             Param("XGL_GPU_SIZE", "memOffset")]),
+
+        Proto("XGL_RESULT", "BindObjectMemoryRange",
+            [Param("XGL_OBJECT", "object"),
+             Param("XGL_GPU_SIZE", "rangeOffset"),
+             Param("XGL_GPU_SIZE", "rangeSize"),
+             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_GPU_SIZE", "memOffset")]),
+
+        Proto("XGL_RESULT", "BindImageMemoryRange",
+            [Param("XGL_IMAGE", "image"),
+             Param("const XGL_IMAGE_MEMORY_BIND_INFO*", "bindInfo"),
+             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_GPU_SIZE", "memOffset")]),
 
         Proto("XGL_RESULT", "CreateFence",
             [Param("XGL_DEVICE", "device"),
@@ -422,6 +428,16 @@
              Param("XGL_SIZE*", "pDataSize"),
              Param("XGL_VOID*", "pData")]),
 
+        Proto("XGL_RESULT", "CreateBuffer",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_BUFFER_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_BUFFER*", "pBuffer")]),
+
+        Proto("XGL_RESULT", "CreateBufferView",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_BUFFER_VIEW_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_BUFFER_VIEW*", "pView")]),
+
         Proto("XGL_RESULT", "CreateImage",
             [Param("XGL_DEVICE", "device"),
              Param("const XGL_IMAGE_CREATE_INFO*", "pCreateInfo"),
@@ -509,11 +525,11 @@
              Param("XGL_UINT", "slotCount"),
              Param("const XGL_IMAGE_VIEW_ATTACH_INFO*", "pImageViews")]),
 
-        Proto("XGL_VOID", "AttachMemoryViewDescriptors",
+        Proto("XGL_VOID", "AttachBufferViewDescriptors",
             [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
              Param("XGL_UINT", "startSlot"),
              Param("XGL_UINT", "slotCount"),
-             Param("const XGL_MEMORY_VIEW_ATTACH_INFO*", "pMemViews")]),
+             Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferViews")]),
 
         Proto("XGL_VOID", "AttachNestedDescriptors",
             [Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
@@ -588,27 +604,27 @@
              Param("XGL_DESCRIPTOR_SET", "descriptorSet"),
              Param("XGL_UINT", "slotOffset")]),
 
-        Proto("XGL_VOID", "CmdBindDynamicMemoryView",
+        Proto("XGL_VOID", "CmdBindDynamicBufferView",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("const XGL_MEMORY_VIEW_ATTACH_INFO*", "pMemView")]),
+             Param("const XGL_BUFFER_VIEW_ATTACH_INFO*", "pBufferView")]),
 
-        Proto("XGL_VOID", "CmdBindVertexData",
+        Proto("XGL_VOID", "CmdBindVertexBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT", "binding")]),
 
-        Proto("XGL_VOID", "CmdBindIndexData",
+        Proto("XGL_VOID", "CmdBindIndexBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_INDEX_TYPE", "indexType")]),
 
-        Proto("XGL_VOID", "CmdPrepareMemoryRegions",
+        Proto("XGL_VOID", "CmdPrepareBufferRegions",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_UINT", "transitionCount"),
-             Param("const XGL_MEMORY_STATE_TRANSITION*", "pStateTransitions")]),
+             Param("const XGL_BUFFER_STATE_TRANSITION*", "pStateTransitions")]),
 
         Proto("XGL_VOID", "CmdPrepareImages",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -632,14 +648,14 @@
 
         Proto("XGL_VOID", "CmdDrawIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT32", "count"),
              Param("XGL_UINT32", "stride")]),
 
         Proto("XGL_VOID", "CmdDrawIndexedIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset"),
              Param("XGL_UINT32", "count"),
              Param("XGL_UINT32", "stride")]),
@@ -652,15 +668,15 @@
 
         Proto("XGL_VOID", "CmdDispatchIndirect",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "mem"),
+             Param("XGL_BUFFER", "buffer"),
              Param("XGL_GPU_SIZE", "offset")]),
 
-        Proto("XGL_VOID", "CmdCopyMemory",
+        Proto("XGL_VOID", "CmdCopyBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_COPY*", "pRegions")]),
 
         Proto("XGL_VOID", "CmdCopyImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -669,19 +685,19 @@
              Param("XGL_UINT", "regionCount"),
              Param("const XGL_IMAGE_COPY*", "pRegions")]),
 
-        Proto("XGL_VOID", "CmdCopyMemoryToImage",
+        Proto("XGL_VOID", "CmdCopyBufferToImage",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
              Param("XGL_IMAGE", "destImage"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_IMAGE_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
 
-        Proto("XGL_VOID", "CmdCopyImageToMemory",
+        Proto("XGL_VOID", "CmdCopyImageToBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_IMAGE", "srcImage"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_UINT", "regionCount"),
-             Param("const XGL_MEMORY_IMAGE_COPY*", "pRegions")]),
+             Param("const XGL_BUFFER_IMAGE_COPY*", "pRegions")]),
 
         Proto("XGL_VOID", "CmdCloneImageData",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
@@ -690,16 +706,16 @@
              Param("XGL_IMAGE", "destImage"),
              Param("XGL_IMAGE_STATE", "destImageState")]),
 
-        Proto("XGL_VOID", "CmdUpdateMemory",
+        Proto("XGL_VOID", "CmdUpdateBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_GPU_SIZE", "dataSize"),
              Param("const XGL_UINT32*", "pData")]),
 
-        Proto("XGL_VOID", "CmdFillMemory",
+        Proto("XGL_VOID", "CmdFillBuffer",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_GPU_SIZE", "fillSize"),
              Param("XGL_UINT32", "data")]),
@@ -741,9 +757,9 @@
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_EVENT", "event")]),
 
-        Proto("XGL_VOID", "CmdMemoryAtomic",
+        Proto("XGL_VOID", "CmdBufferAtomic",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset"),
              Param("XGL_UINT64", "srcData"),
              Param("XGL_ATOMIC_OP", "atomicOp")]),
@@ -768,7 +784,7 @@
         Proto("XGL_VOID", "CmdWriteTimestamp",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_TIMESTAMP_TYPE", "timestampType"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset")]),
 
         Proto("XGL_VOID", "CmdInitAtomicCounters",
@@ -783,7 +799,7 @@
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_UINT", "startCounter"),
              Param("XGL_UINT", "counterCount"),
-             Param("XGL_GPU_MEMORY", "srcMem"),
+             Param("XGL_BUFFER", "srcBuffer"),
              Param("XGL_GPU_SIZE", "srcOffset")]),
 
         Proto("XGL_VOID", "CmdSaveAtomicCounters",
@@ -791,7 +807,7 @@
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_UINT", "startCounter"),
              Param("XGL_UINT", "counterCount"),
-             Param("XGL_GPU_MEMORY", "destMem"),
+             Param("XGL_BUFFER", "destBuffer"),
              Param("XGL_GPU_SIZE", "destOffset")]),
 
         Proto("XGL_RESULT", "CreateFramebuffer",