diff --git a/icd/intel/cmd.h b/icd/intel/cmd.h
index 209e7f8..be8bf13 100644
--- a/icd/intel/cmd.h
+++ b/icd/intel/cmd.h
@@ -35,7 +35,6 @@
 
 struct intel_pipeline;
 struct intel_pipeline_shader;
-struct intel_pipeline_delta;
 struct intel_viewport_state;
 struct intel_raster_state;
 struct intel_msaa_state;
@@ -50,7 +49,7 @@
 
 /*
  * We know what workarounds are needed for intel_pipeline.  These are mostly
- * for intel_pipeline_delta.
+ * for pipeline derivatives.
  */
 enum intel_cmd_wa_flags {
     /*
@@ -146,8 +145,6 @@
     struct {
         const struct intel_pipeline *graphics;
         const struct intel_pipeline *compute;
-        const struct intel_pipeline_delta *graphics_delta;
-        const struct intel_pipeline_delta *compute_delta;
 
         uint32_t vs_offset;
         uint32_t tcs_offset;
diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c
index 00851e5..84e24ce 100644
--- a/icd/intel/cmd_pipeline.c
+++ b/icd/intel/cmd_pipeline.c
@@ -3025,18 +3025,6 @@
     cmd->bind.pipeline.compute = pipeline;
 }
 
-static void cmd_bind_graphics_delta(struct intel_cmd *cmd,
-                                    const struct intel_pipeline_delta *delta)
-{
-    cmd->bind.pipeline.graphics_delta = delta;
-}
-
-static void cmd_bind_compute_delta(struct intel_cmd *cmd,
-                                   const struct intel_pipeline_delta *delta)
-{
-    cmd->bind.pipeline.compute_delta = delta;
-}
-
 static void cmd_bind_graphics_dset(struct intel_cmd *cmd,
                                    const struct intel_desc_set *dset,
                                    const uint32_t *dynamic_offsets)
@@ -3333,26 +3321,6 @@
     }
 }
 
-ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE_DELTA                          delta)
-{
-    struct intel_cmd *cmd = intel_cmd(cmdBuffer);
-
-    switch (pipelineBindPoint) {
-    case XGL_PIPELINE_BIND_POINT_COMPUTE:
-        cmd_bind_compute_delta(cmd, delta);
-        break;
-    case XGL_PIPELINE_BIND_POINT_GRAPHICS:
-        cmd_bind_graphics_delta(cmd, delta);
-        break;
-    default:
-        cmd_fail(cmd, XGL_ERROR_INVALID_VALUE);
-        break;
-    }
-}
-
 ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_STATE_BIND_POINT                        stateBindPoint,
diff --git a/icd/intel/pipeline.c b/icd/intel/pipeline.c
index 2b6c078..be21b42 100644
--- a/icd/intel/pipeline.c
+++ b/icd/intel/pipeline.c
@@ -1363,6 +1363,20 @@
             (struct intel_pipeline **) pPipeline);
 }
 
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+    XGL_DEVICE                                  device,
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline)
+{
+    struct intel_dev *dev = intel_dev(device);
+
+    /* TODO: Use basePipeline to optimize creation of derivative */
+
+    return graphics_pipeline_create(dev, pCreateInfo,
+            (struct intel_pipeline **) pPipeline);
+}
+
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
     XGL_DEVICE                                  device,
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
@@ -1388,11 +1402,12 @@
     return XGL_ERROR_UNAVAILABLE;
 }
 
-ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
+ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(
     XGL_DEVICE                                  device,
-    XGL_PIPELINE                                p1,
-    XGL_PIPELINE                                p2,
-    XGL_PIPELINE_DELTA*                         delta)
+    size_t                                      dataSize,
+    const void*                                 pData,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline)
 {
     return XGL_ERROR_UNAVAILABLE;
 }
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 33cff85..3efeba1 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1075,14 +1075,6 @@
     NULLDRV_LOG_FUNC;
 }
 
-ICD_EXPORT void XGLAPI xglCmdBindPipelineDelta(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE_DELTA                          delta)
-{
-    NULLDRV_LOG_FUNC;
-}
-
 ICD_EXPORT void XGLAPI xglCmdBindDynamicStateObject(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_STATE_BIND_POINT                        stateBindPoint,
@@ -1652,6 +1644,19 @@
             (struct nulldrv_pipeline **) pPipeline);
 }
 
+ICD_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+    XGL_DEVICE                                  device,
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline)
+{
+    NULLDRV_LOG_FUNC;
+    struct nulldrv_dev *dev = nulldrv_dev(device);
+
+    return graphics_pipeline_create(dev, pCreateInfo,
+            (struct nulldrv_pipeline **) pPipeline);
+}
+
 ICD_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(
     XGL_DEVICE                                  device,
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
@@ -1672,7 +1677,7 @@
 
 ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipeline(
     XGL_DEVICE                                  device,
-    size_t                                    dataSize,
+    size_t                                    	dataSize,
     const void*                                 pData,
     XGL_PIPELINE*                               pPipeline)
 {
@@ -1680,11 +1685,12 @@
     return XGL_SUCCESS;
 }
 
-ICD_EXPORT XGL_RESULT XGLAPI xglCreatePipelineDelta(
+ICD_EXPORT XGL_RESULT XGLAPI xglLoadPipelineDerivative(
     XGL_DEVICE                                  device,
-    XGL_PIPELINE                                p1,
-    XGL_PIPELINE                                p2,
-    XGL_PIPELINE_DELTA*                         delta)
+    size_t                                    	dataSize,
+    const void*                                 pData,
+    XGL_PIPELINE				basePipeline,
+    XGL_PIPELINE*                               pPipeline)
 {
     NULLDRV_LOG_FUNC;
     return XGL_SUCCESS;
diff --git a/include/xgl.h b/include/xgl.h
index dd12fc3..b1c7c88 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -33,7 +33,7 @@
 #include "xglPlatform.h"
 
 // XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 59, 0)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 60, 0)
 
 #ifdef __cplusplus
 extern "C"
@@ -69,7 +69,6 @@
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT)
-XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
 XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET_LAYOUT, XGL_OBJECT)
@@ -1220,6 +1219,7 @@
 typedef enum _XGL_PIPELINE_CREATE_FLAGS
 {
     XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT            = 0x00000001,
+    XGL_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT               = 0x00000002,
     XGL_MAX_ENUM(_XGL_PIPELINE_CREATE_FLAGS)
 } XGL_PIPELINE_CREATE_FLAGS;
 
@@ -2299,10 +2299,11 @@
 typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
 typedef XGL_RESULT (XGLAPI *xglCreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
 typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
+typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineDerivativeType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglCreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglStorePipelineType)(XGL_PIPELINE pipeline, size_t* pDataSize, void* pData);
 typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE* pPipeline);
-typedef XGL_RESULT (XGLAPI *xglCreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
+typedef XGL_RESULT (XGLAPI *xglLoadPipelineDerivativeType)(XGL_DEVICE device, size_t dataSize, const void* pData, XGL_PIPELINE basePipeline, XGL_PIPELINE* pPipeline);
 typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
 typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetLayoutType)(XGL_DEVICE device, XGL_FLAGS stageFlags, const uint32_t* pSetBindPoints, XGL_DESCRIPTOR_SET_LAYOUT priorSetLayout, const XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO* pSetLayoutInfoList, XGL_DESCRIPTOR_SET_LAYOUT* pSetLayout);
 typedef XGL_RESULT (XGLAPI *xglBeginDescriptorRegionUpdateType)(XGL_DEVICE device, XGL_DESCRIPTOR_UPDATE_MODE updateMode);
@@ -2321,7 +2322,6 @@
 typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
 typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
 typedef void       (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
-typedef void       (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
 typedef void       (XGLAPI *xglCmdBindDynamicStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state);
 typedef void       (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_DESCRIPTOR_SET descriptorSet, const uint32_t* pUserData);
 typedef void       (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
@@ -2666,6 +2666,12 @@
     const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
     XGL_PIPELINE*                               pPipeline);
 
+XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+    XGL_DEVICE                                  device,
+    const XGL_GRAPHICS_PIPELINE_CREATE_INFO*    pCreateInfo,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline);
+
 XGL_RESULT XGLAPI xglCreateComputePipeline(
     XGL_DEVICE                                  device,
     const XGL_COMPUTE_PIPELINE_CREATE_INFO*     pCreateInfo,
@@ -2682,11 +2688,12 @@
     const void*                                 pData,
     XGL_PIPELINE*                               pPipeline);
 
-XGL_RESULT XGLAPI xglCreatePipelineDelta(
+XGL_RESULT XGLAPI xglLoadPipelineDerivative(
     XGL_DEVICE                                  device,
-    XGL_PIPELINE                                p1,
-    XGL_PIPELINE                                p2,
-    XGL_PIPELINE_DELTA*                         delta);
+    size_t                                      dataSize,
+    const void*                                 pData,
+    XGL_PIPELINE                                basePipeline,
+    XGL_PIPELINE*                               pPipeline);
 
 // Sampler functions
 
@@ -2786,11 +2793,6 @@
     XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
     XGL_PIPELINE                                pipeline);
 
-void XGLAPI xglCmdBindPipelineDelta(
-    XGL_CMD_BUFFER                              cmdBuffer,
-    XGL_PIPELINE_BIND_POINT                     pipelineBindPoint,
-    XGL_PIPELINE_DELTA                          delta);
-
 void XGLAPI xglCmdBindDynamicStateObject(
     XGL_CMD_BUFFER                              cmdBuffer,
     XGL_STATE_BIND_POINT                        stateBindPoint,
diff --git a/include/xglLayer.h b/include/xglLayer.h
index 81da19e..cc9f0e9 100644
--- a/include/xglLayer.h
+++ b/include/xglLayer.h
@@ -81,10 +81,11 @@
     xglCreateDepthStencilViewType CreateDepthStencilView;
     xglCreateShaderType CreateShader;
     xglCreateGraphicsPipelineType CreateGraphicsPipeline;
+    xglCreateGraphicsPipelineDerivativeType CreateGraphicsPipelineDerivative;
     xglCreateComputePipelineType CreateComputePipeline;
     xglStorePipelineType StorePipeline;
     xglLoadPipelineType LoadPipeline;
-    xglCreatePipelineDeltaType CreatePipelineDelta;
+    xglLoadPipelineDerivativeType LoadPipelineDerivative;
     xglCreateSamplerType CreateSampler;
     xglCreateDescriptorSetLayoutType CreateDescriptorSetLayout;
     xglBeginDescriptorRegionUpdateType BeginDescriptorRegionUpdate;
@@ -103,7 +104,6 @@
     xglEndCommandBufferType EndCommandBuffer;
     xglResetCommandBufferType ResetCommandBuffer;
     xglCmdBindPipelineType CmdBindPipeline;
-    xglCmdBindPipelineDeltaType CmdBindPipelineDelta;
     xglCmdBindDynamicStateObjectType CmdBindDynamicStateObject;
     xglCmdBindDescriptorSetType CmdBindDescriptorSet;
     xglCmdBindVertexBufferType CmdBindVertexBuffer;
diff --git a/layers/draw_state.c b/layers/draw_state.c
index c764412..5148be8 100644
--- a/layers/draw_state.c
+++ b/layers/draw_state.c
@@ -1666,13 +1666,8 @@
     return result;
 }
 
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+static void track_pipeline(const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
-    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
-    // Create LL HEAD for this Pipeline
-    char str[1024];
-    sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
-    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
     loader_platform_thread_lock_mutex(&globalLock);
     PIPELINE_NODE *pTrav = g_pPipelineHead;
     if (pTrav) {
@@ -1695,6 +1690,35 @@
     pTrav->pipeline = *pPipeline;
     initPipeline(pTrav, pCreateInfo);
     loader_platform_thread_unlock_mutex(&globalLock);
+}
+
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipeline(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    // Create LL HEAD for this Pipeline
+    char str[1024];
+    sprintf(str, "Created Gfx Pipeline %p", (void*)*pPipeline);
+    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
+
+    track_pipeline(pCreateInfo, pPipeline);
+
+    return result;
+}
+
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+        XGL_DEVICE device,
+        const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        XGL_PIPELINE basePipeline,
+        XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    // Create LL HEAD for this Pipeline
+    char str[1024];
+    sprintf(str, "Created Gfx Pipeline %p (derived from pipeline %p)", (void*)*pPipeline, basePipeline);
+    layerCbMsg(XGL_DBG_MSG_UNKNOWN, XGL_VALIDATION_LEVEL_0, pPipeline, 0, DRAWSTATE_NONE, "DS", str);
+
+    track_pipeline(pCreateInfo, pPipeline);
+
     return result;
 }
 
@@ -2107,22 +2131,6 @@
     nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-XGL_LAYER_EXPORT void XGLAPI xglCmdBindPipelineDelta(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta)
-{
-    GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
-    if (pCB) {
-        // TODO : Handle storing Pipeline Deltas to cmd buffer here
-        updateCBTracking(cmdBuffer);
-        addCmd(pCB, CMD_BINDPIPELINEDELTA);
-    }
-    else {
-        char str[1024];
-        sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
-        layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
-    }
-    nextTable.CmdBindPipelineDelta(cmdBuffer, pipelineBindPoint, delta);
-}
-
 XGL_LAYER_EXPORT void XGLAPI xglCmdBindDynamicStateObject(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT state)
 {
     setLastBoundDynamicState(cmdBuffer, state, stateBindPoint);
@@ -2837,6 +2845,8 @@
         return (void*) xglCreateImageView;
     if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
         return (void*) xglCreateGraphicsPipeline;
+    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
+        return (void*) xglCreateGraphicsPipelineDerivative;
     if (!strcmp(funcName, "xglCreateSampler"))
         return (void*) xglCreateSampler;
     if (!strcmp(funcName, "xglCreateDescriptorSetLayout"))
@@ -2873,8 +2883,6 @@
         return (void*) xglResetCommandBuffer;
     if (!strcmp(funcName, "xglCmdBindPipeline"))
         return (void*) xglCmdBindPipeline;
-    if (!strcmp(funcName, "xglCmdBindPipelineDelta"))
-        return (void*) xglCmdBindPipelineDelta;
     if (!strcmp(funcName, "xglCmdBindDynamicStateObject"))
         return (void*) xglCmdBindDynamicStateObject;
     if (!strcmp(funcName, "xglCmdBindDescriptorSet"))
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 72fae40..2d840dc 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1217,6 +1217,21 @@
     return result;
 }
 
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateGraphicsPipelineDerivative(
+        XGL_DEVICE device,
+        const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
+        XGL_PIPELINE basePipeline,
+        XGL_PIPELINE* pPipeline)
+{
+    XGL_RESULT result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    if (result == XGL_SUCCESS) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        insertGlobalObjectNode(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO), "graphics_pipeline");
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+    return result;
+}
+
 XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglCreateComputePipeline(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline)
 {
     XGL_RESULT result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
@@ -1828,6 +1843,8 @@
         return (void*) xglCreateShader;
     if (!strcmp(funcName, "xglCreateGraphicsPipeline"))
         return (void*) xglCreateGraphicsPipeline;
+    if (!strcmp(funcName, "xglCreateGraphicsPipelineDerivative"))
+        return (void*) xglCreateGraphicsPipelineDerivative;
     if (!strcmp(funcName, "xglCreateComputePipeline"))
         return (void*) xglCreateComputePipeline;
     if (!strcmp(funcName, "xglCreateSampler"))
diff --git a/tests/xgltestbinding.cpp b/tests/xgltestbinding.cpp
index 8394566..76c471b 100644
--- a/tests/xgltestbinding.cpp
+++ b/tests/xgltestbinding.cpp
@@ -774,6 +774,15 @@
     alloc_memory(dev);
 }
 
+void Pipeline::init(
+        const Device &dev,
+        const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info,
+        const XGL_PIPELINE basePipeline)
+{
+    DERIVED_OBJECT_INIT(xglCreateGraphicsPipelineDerivative, dev.obj(), &info, basePipeline);
+    alloc_memory(dev);
+}
+
 void Pipeline::init(const Device &dev, const XGL_COMPUTE_PIPELINE_CREATE_INFO &info)
 {
     DERIVED_OBJECT_INIT(xglCreateComputePipeline, dev.obj(), &info);
@@ -786,6 +795,16 @@
     alloc_memory(dev);
 }
 
+void Pipeline::init(
+        const Device&dev,
+        size_t size,
+        const void *data,
+        const XGL_PIPELINE basePipeline)
+{
+    DERIVED_OBJECT_INIT(xglLoadPipelineDerivative, dev.obj(), size, data, basePipeline);
+    alloc_memory(dev);
+}
+
 size_t Pipeline::store(size_t size, void *data)
 {
     if (!EXPECT(xglStorePipeline(obj(), &size, data) == XGL_SUCCESS))
@@ -794,12 +813,6 @@
     return size;
 }
 
-void PipelineDelta::init(const Device &dev, const Pipeline &p1, const Pipeline &p2)
-{
-    DERIVED_OBJECT_INIT(xglCreatePipelineDelta, dev.obj(), p1.obj(), p2.obj());
-    alloc_memory(dev);
-}
-
 void Sampler::init(const Device &dev, const XGL_SAMPLER_CREATE_INFO &info)
 {
     DERIVED_OBJECT_INIT(xglCreateSampler, dev.obj(), &info);
diff --git a/tests/xgltestbinding.h b/tests/xgltestbinding.h
index 86f27f0..0bb7706 100644
--- a/tests/xgltestbinding.h
+++ b/tests/xgltestbinding.h
@@ -478,21 +478,19 @@
 public:
     // xglCreateGraphicsPipeline()
     void init(const Device &dev, const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info);
+    // xglCreateGraphicsPipelineDerivative()
+    void init(const Device &dev, const XGL_GRAPHICS_PIPELINE_CREATE_INFO &info, const XGL_PIPELINE basePipeline);
     // xglCreateComputePipeline()
     void init(const Device &dev, const XGL_COMPUTE_PIPELINE_CREATE_INFO &info);
     // xglLoadPipeline()
     void init(const Device&dev, size_t size, const void *data);
+    // xglLoadPipelineDerivative()
+    void init(const Device&dev, size_t size, const void *data, XGL_PIPELINE basePipeline);
 
     // xglStorePipeline()
     size_t store(size_t size, void *data);
 };
 
-class PipelineDelta : public DerivedObject<XGL_PIPELINE_DELTA, Object> {
-public:
-    // xglCreatePipelineDelta()
-    void init(const Device &dev, const Pipeline &p1, const Pipeline &p2);
-};
-
 class Sampler : public DerivedObject<XGL_SAMPLER, Object> {
 public:
     // xglCreateSampler()
diff --git a/tools/glave/scripts/vk_generate.py b/tools/glave/scripts/vk_generate.py
index c0de231..04e7948 100755
--- a/tools/glave/scripts/vk_generate.py
+++ b/tools/glave/scripts/vk_generate.py
@@ -1055,6 +1055,62 @@
                                                                                          '    glv_LogError("CreateGraphicsPipeline must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
                                                                                          '    pPacket->header = NULL;\n',
                                                                                          '}']},
+                             'CreateGraphicsPipelineDerivative' : {'param': 'pCreateInfo', 'txt': ['if (pPacket->pCreateInfo->sType == XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO) {\n',
+                                                                                         '    // need to make a non-const pointer to the pointer so that we can properly change the original pointer to the interpretted one\n',
+                                                                                         '    void** ppNextVoidPtr = (void**)&pPacket->pCreateInfo->pNext;\n',
+                                                                                         '    *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pPacket->pCreateInfo->pNext);\n',
+                                                                                         '    XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;\n',
+                                                                                         '    while ((NULL != pNext) && (XGL_NULL_HANDLE != pNext))\n', '{\n',
+                                                                                         '        switch(pNext->sType)\n', '    {\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO:\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO:\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO:\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO:\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO:\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO:\n',
+                                                                                         '            {\n',
+                                                                                         '                void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
+                                                                                         '                *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+                                                                                         '                break;\n',
+                                                                                         '            }\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO:\n',
+                                                                                         '            {\n',
+                                                                                         '                void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
+                                                                                         '                XGL_PIPELINE_CB_STATE_CREATE_INFO *pCb = (XGL_PIPELINE_CB_STATE_CREATE_INFO *) pNext;\n',
+                                                                                         '                *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+                                                                                         '                pCb->pAttachments = (XGL_PIPELINE_CB_ATTACHMENT_STATE*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pCb->pAttachments);\n',
+                                                                                         '                break;\n',
+                                                                                         '            }\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:\n',
+                                                                                         '            {\n',
+                                                                                         '                void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
+                                                                                         '                *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+                                                                                         '                interpret_pipeline_shader(pHeader, &pNext->shader);\n',
+                                                                                         '                break;\n',
+                                                                                         '            }\n',
+                                                                                         '            case XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO:\n',
+                                                                                         '            {\n',
+                                                                                         '                void** ppNextVoidPtr = (void**)&pNext->pNext;\n',
+                                                                                         '                XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *pVi = (XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO *) pNext;\n',
+                                                                                         '                *ppNextVoidPtr = (void*)glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pNext->pNext);\n',
+                                                                                         '                pVi->pVertexBindingDescriptions = (XGL_VERTEX_INPUT_BINDING_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexBindingDescriptions);\n',
+                                                                                         '                pVi->pVertexAttributeDescriptions = (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION*) glv_trace_packet_interpret_buffer_pointer(pHeader, (intptr_t)pVi->pVertexAttributeDescriptions);\n',
+                                                                                         '                break;\n',
+                                                                                         '            }\n',
+                                                                                         '            default:\n',
+                                                                                         '            {\n',
+                                                                                         '               glv_LogError("Encountered an unexpected type in pipeline state list.\\n");\n',
+                                                                                         '               pPacket->header = NULL;\n',
+                                                                                         '               pNext->pNext = NULL;\n',
+                                                                                         '            }\n',
+                                                                                         '        }\n',
+                                                                                         '        pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;\n',
+                                                                                         '    }\n',
+                                                                                         '} else {\n',
+                                                                                         '    // This is unexpected.\n',
+                                                                                         '    glv_LogError("CreateGraphicsPipelineDerivative must have CreateInfo stype of XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO.\\n");\n',
+                                                                                         '    pPacket->header = NULL;\n',
+                                                                                         '}']},
                              'CreateComputePipeline' : {'param': 'pCreateInfo', 'txt': ['interpret_pipeline_shader(pHeader, (XGL_PIPELINE_SHADER*)(&pPacket->pCreateInfo->cs));']}}
         if_body = []
         if_body.append('typedef struct struct_xglApiVersion {')
@@ -1529,6 +1585,37 @@
         cgp_body.append('            returnValue = manually_handle_xglCreateGraphicsPipeline(pPacket);')
         return "\n".join(cgp_body)
 
+    def _gen_replay_create_graphics_pipeline_derivative(self):
+        cgp_body = []
+        cgp_body.append('            XGL_GRAPHICS_PIPELINE_CREATE_INFO createInfo;')
+        cgp_body.append('            struct shaderPair saveShader[10];')
+        cgp_body.append('            unsigned int idx = 0;')
+        cgp_body.append('            memcpy(&createInfo, pPacket->pCreateInfo, sizeof(XGL_GRAPHICS_PIPELINE_CREATE_INFO));')
+        cgp_body.append('            createInfo.lastSetLayout = remap(createInfo.lastSetLayout);')
+        cgp_body.append('            // Cast to shader type, as those are of primariy interest and all structs in LL have same header w/ sType & pNext')
+        cgp_body.append('            XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacket->pCreateInfo->pNext;')
+        cgp_body.append('            XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)createInfo.pNext;')
+        cgp_body.append('            while (XGL_NULL_HANDLE != pPacketNext)')
+        cgp_body.append('            {')
+        cgp_body.append('                if (XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO == pNext->sType)')
+        cgp_body.append('                {')
+        cgp_body.append('                    saveShader[idx].val = pNext->shader.shader;')
+        cgp_body.append('                    saveShader[idx++].addr = &(pNext->shader.shader);')
+        cgp_body.append('                    pNext->shader.shader = remap(pPacketNext->shader.shader);')
+        cgp_body.append('                }')
+        cgp_body.append('                pPacketNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pPacketNext->pNext;')
+        cgp_body.append('                pNext = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*)pNext->pNext;')
+        cgp_body.append('            }')
+        cgp_body.append('            XGL_PIPELINE pipeline;')
+        cgp_body.append('            replayResult = m_xglFuncs.real_xglCreateGraphicsPipelineDerivative(remap(pPacket->device), &createInfo, remap(pPacket->basePipeline), &pipeline);')
+        cgp_body.append('            if (replayResult == XGL_SUCCESS)')
+        cgp_body.append('            {')
+        cgp_body.append('                add_to_map(pPacket->pPipeline, &pipeline);')
+        cgp_body.append('            }')
+        cgp_body.append('            for (unsigned int i = 0; i < idx; i++)')
+        cgp_body.append('                *(saveShader[i].addr) = saveShader[i].val;')
+        return "\n".join(cgp_body)
+
     def _gen_replay_cmd_wait_events(self):
         cwe_body = []
         cwe_body.append('            returnValue = manually_handle_xglCmdWaitEvents(pPacket);')
@@ -1665,6 +1752,7 @@
                             'CreateBuffer': self._gen_replay_create_buffer,
                             'GetImageSubresourceInfo': self._gen_replay_get_image_subresource_info,
                             'CreateGraphicsPipeline': self._gen_replay_create_graphics_pipeline,
+                            'CreateGraphicsPipelineDerivative': self._gen_replay_create_graphics_pipeline_derivative,
                             'CreateFramebuffer': self._gen_replay_create_framebuffer,
                             'CreateRenderPass': self._gen_replay_create_renderpass,
                             'BeginCommandBuffer': self._gen_replay_begin_command_buffer,
@@ -1702,7 +1790,7 @@
         # Functions that create views are unique from other create functions
         create_view_list = ['CreateBufferView', 'CreateImageView', 'CreateColorAttachmentView', 'CreateDepthStencilView', 'CreateComputePipeline']
         # Functions to treat as "Create' that don't have 'Create' in the name
-        special_create_list = ['LoadPipeline', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
+        special_create_list = ['LoadPipeline', 'LoadPipelineDerivative', 'AllocMemory', 'GetDeviceQueue', 'PinSystemMemory', 'AllocDescriptorSets']
         # A couple funcs use do while loops
         do_while_dict = {'GetFenceStatus': 'replayResult != pPacket->result  && pPacket->result == XGL_SUCCESS', 'GetEventStatus': '(pPacket->result == XGL_EVENT_SET || pPacket->result == XGL_EVENT_RESET) && replayResult != pPacket->result'}
         rbody = []
diff --git a/xgl.py b/xgl.py
index 1da38e6..04d80f7 100644
--- a/xgl.py
+++ b/xgl.py
@@ -198,7 +198,6 @@
         "XGL_DEPTH_STENCIL_VIEW",
         "XGL_SHADER",
         "XGL_PIPELINE",
-        "XGL_PIPELINE_DELTA",
         "XGL_SAMPLER",
         "XGL_DESCRIPTOR_SET",
         "XGL_DESCRIPTOR_SET_LAYOUT",
@@ -484,6 +483,12 @@
              Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
              Param("XGL_PIPELINE*", "pPipeline")]),
 
+        Proto("XGL_RESULT", "CreateGraphicsPipelineDerivative",
+            [Param("XGL_DEVICE", "device"),
+             Param("const XGL_GRAPHICS_PIPELINE_CREATE_INFO*", "pCreateInfo"),
+             Param("XGL_PIPELINE", "basePipeline"),
+             Param("XGL_PIPELINE*", "pPipeline")]),
+
         Proto("XGL_RESULT", "CreateComputePipeline",
             [Param("XGL_DEVICE", "device"),
              Param("const XGL_COMPUTE_PIPELINE_CREATE_INFO*", "pCreateInfo"),
@@ -500,11 +505,12 @@
              Param("const void*", "pData"),
              Param("XGL_PIPELINE*", "pPipeline")]),
 
-        Proto("XGL_RESULT", "CreatePipelineDelta",
+        Proto("XGL_RESULT", "LoadPipelineDerivative",
             [Param("XGL_DEVICE", "device"),
-             Param("XGL_PIPELINE", "p1"),
-             Param("XGL_PIPELINE", "p2"),
-             Param("XGL_PIPELINE_DELTA*", "delta")]),
+             Param("size_t", "dataSize"),
+             Param("const void*", "pData"),
+             Param("XGL_PIPELINE", "basePipeline"),
+             Param("XGL_PIPELINE*", "pPipeline")]),
 
         Proto("XGL_RESULT", "CreateSampler",
             [Param("XGL_DEVICE", "device"),
@@ -594,11 +600,6 @@
              Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
              Param("XGL_PIPELINE", "pipeline")]),
 
-        Proto("void", "CmdBindPipelineDelta",
-            [Param("XGL_CMD_BUFFER", "cmdBuffer"),
-             Param("XGL_PIPELINE_BIND_POINT", "pipelineBindPoint"),
-             Param("XGL_PIPELINE_DELTA", "delta")]),
-
         Proto("void", "CmdBindDynamicStateObject",
             [Param("XGL_CMD_BUFFER", "cmdBuffer"),
              Param("XGL_STATE_BIND_POINT", "stateBindPoint"),
@@ -928,7 +929,6 @@
     "XGL_DEPTH_STENCIL_VIEW",
     "XGL_SHADER",
     "XGL_PIPELINE",
-    "XGL_PIPELINE_DELTA",
     "XGL_SAMPLER",
     "XGL_DESCRIPTOR_SET",
     "XGL_DESCRIPTOR_SET_LAYOUT",