diff --git a/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp b/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
index b9cc69f..09943bf 100644
--- a/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
+++ b/common/end2end/GfxstreamEnd2EndVkSnapshotPipelineTests.cpp
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <android-base/expected.h>
+
 #include <string>
 
 #include "GfxstreamEnd2EndTestUtils.h"
@@ -46,12 +48,21 @@
     vkhpp::UniqueImageView imageView;
 };
 
+struct BufferInfo {
+    vkhpp::UniqueBuffer buffer;
+    vkhpp::UniqueDeviceMemory memory;
+};
+
 class GfxstreamEnd2EndVkSnapshotPipelineTest : public GfxstreamEnd2EndTest {
    protected:
     vkhpp::UniqueRenderPass createRenderPass(vkhpp::Device device);
     std::unique_ptr<ImageInfo> createColorAttachment(vkhpp::PhysicalDevice physicalDevice,
                                                      vkhpp::Device device);
     std::unique_ptr<PipelineInfo> createPipeline(vkhpp::Device device);
+    VkExpected<BufferInfo> createAndPopulateBuffer(vkhpp::PhysicalDevice physicalDevice,
+                                                   vkhpp::Device device,
+                                                   vkhpp::BufferUsageFlags usage, const void* data,
+                                                   uint64_t dataSize);
     static const uint32_t kFbWidth = 32;
     static const uint32_t kFbHeight = 32;
 };
@@ -65,12 +76,56 @@
         std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count());
 }
 
-// A blue triangle
-const float kVertexData[] = {
-    -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
-    0.0f,  0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
+// Full screen blue rectangle
+const float kFullscreenBlueRectangleVertexData[] = {
+    // clang-format off
+    /*pos=*/ -1.0f, -1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    /*pos=*/  1.0f, -1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    /*pos=*/  1.0f,  1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    /*pos=*/  1.0f,  1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    /*pos=*/ -1.0f,  1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    /*pos=*/ -1.0f, -1.0f, 0.0f, 1.0f, /*color=*/ 0.0f,  0.0f,  1.0f, 1.0f,
+    // clang-format on
 };
 
+VkExpected<BufferInfo> GfxstreamEnd2EndVkSnapshotPipelineTest::createAndPopulateBuffer(
+    vkhpp::PhysicalDevice physicalDevice, vkhpp::Device device, vkhpp::BufferUsageFlags usage,
+    const void* data, uint64_t dataSize) {
+    const vkhpp::BufferCreateInfo vertexBufferCreateInfo = {
+        .size = dataSize,
+        .usage = usage,
+        .sharingMode = vkhpp::SharingMode::eExclusive,
+    };
+    auto vertexBuffer = VK_EXPECT_RV(device.createBufferUnique(vertexBufferCreateInfo));
+
+    vkhpp::MemoryRequirements vertexBufferMemoryRequirements{};
+    device.getBufferMemoryRequirements(*vertexBuffer, &vertexBufferMemoryRequirements);
+
+    const auto vertexBufferMemoryType = utils::getMemoryType(
+        physicalDevice, vertexBufferMemoryRequirements,
+        vkhpp::MemoryPropertyFlagBits::eHostVisible | vkhpp::MemoryPropertyFlagBits::eHostCoherent);
+    if (vertexBufferMemoryType == -1) {
+        return android::base::unexpected(vkhpp::Result::eErrorOutOfHostMemory);
+    }
+    // Vertex memory
+    const vkhpp::MemoryAllocateInfo vertexBufferMemoryAllocateInfo = {
+        .allocationSize = vertexBufferMemoryRequirements.size,
+        .memoryTypeIndex = vertexBufferMemoryType,
+    };
+    auto vertexBufferMemory =
+        VK_EXPECT_RV(device.allocateMemoryUnique(vertexBufferMemoryAllocateInfo));
+    device.bindBufferMemory(*vertexBuffer, *vertexBufferMemory, 0);
+    void* mapped;
+    device.mapMemory(*vertexBufferMemory, 0, VK_WHOLE_SIZE, vkhpp::MemoryMapFlags{}, &mapped);
+    memcpy(mapped, data, dataSize);
+    device.unmapMemory(*vertexBufferMemory);
+
+    BufferInfo res;
+    res.buffer = std::move(vertexBuffer);
+    res.memory = std::move(vertexBufferMemory);
+    return res;
+}
+
 vkhpp::UniqueRenderPass GfxstreamEnd2EndVkSnapshotPipelineTest::createRenderPass(
     vkhpp::Device device) {
     vkhpp::AttachmentDescription colorAttachmentDescription = {
@@ -103,11 +158,26 @@
     std::unique_ptr<PipelineInfo> res(new PipelineInfo);
     res->renderPass = createRenderPass(device);
 
-    vkhpp::DescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {};
+    vkhpp::DescriptorSetLayoutBinding bindings[1] = {
+        {
+            .binding = 0,
+            .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 1,
+            .stageFlags = vkhpp::ShaderStageFlagBits::eFragment,
+        },
+    };
+    vkhpp::DescriptorSetLayoutCreateInfo descriptorSetLayoutInfo = {
+        .bindingCount = 1,
+        .pBindings = bindings,
+    };
     res->descriptorSetLayout =
         device.createDescriptorSetLayoutUnique(descriptorSetLayoutInfo).value;
-    res->pipelineLayout =
-        device.createPipelineLayoutUnique(vkhpp::PipelineLayoutCreateInfo{}).value;
+    res->pipelineLayout = device
+                              .createPipelineLayoutUnique(vkhpp::PipelineLayoutCreateInfo{
+                                  .setLayoutCount = 1,
+                                  .pSetLayouts = &res->descriptorSetLayout.get(),
+                              })
+                              .value;
 
     vkhpp::ShaderModuleCreateInfo vertexShaderModuleCreateInfo = {
         .codeSize = sizeof(kSimpleShaderVert),
@@ -361,11 +431,7 @@
 
 TEST_P(GfxstreamEnd2EndVkSnapshotPipelineWithMultiSamplingTest, CanSubmitQueue) {
     TypicalVkTestEnvironment testEnvironment = VK_ASSERT(SetUpTypicalVkTestEnvironment());
-    auto& instance = testEnvironment.instance;
-    auto& physicalDevice = testEnvironment.physicalDevice;
-    auto& device = testEnvironment.device;
-    auto& queue = testEnvironment.queue;
-    auto queueFamilyIndex = testEnvironment.queueFamilyIndex;
+    auto& [instance, physicalDevice, device, queue, queueFamilyIndex] = testEnvironment;
 
     auto pipelineInfo = createPipeline(device.get());
 
@@ -489,6 +555,10 @@
     waitResult = device->waitForFences(*fence, VK_TRUE, 3000000000L);
     ASSERT_THAT(waitResult, IsVkSuccess());
 
+    if (GetParam().samples != 1) {
+        return;
+    }
+
     std::vector<uint32_t> dst(kFbWidth * kFbHeight);
     utils::readImageData(*colorAttachmentInfo->image, kFbWidth, kFbHeight,
                          vkhpp::ImageLayout::eColorAttachmentOptimal, dst.data(),
@@ -498,6 +568,395 @@
     }
 }
 
+TEST_P(GfxstreamEnd2EndVkSnapshotPipelineTest, CanSnapshotDescriptors) {
+    TypicalVkTestEnvironment testEnvironment = VK_ASSERT(SetUpTypicalVkTestEnvironment());
+    auto& [instance, physicalDevice, device, queue, queueFamilyIndex] = testEnvironment;
+
+    auto pipelineInfo = createPipeline(device.get());
+    auto vertexBufferInfo = createAndPopulateBuffer(
+        physicalDevice, device.get(), vkhpp::BufferUsageFlagBits::eVertexBuffer,
+        kFullscreenBlueRectangleVertexData, sizeof(kFullscreenBlueRectangleVertexData));
+
+    auto colorAttachmentInfo = createColorAttachment(physicalDevice, device.get());
+    ASSERT_THAT(colorAttachmentInfo->image, IsValidHandle());
+    ASSERT_THAT(colorAttachmentInfo->memory, IsValidHandle());
+    ASSERT_THAT(colorAttachmentInfo->imageView, IsValidHandle());
+
+    // Descriptor
+    std::vector<vkhpp::DescriptorPoolSize> sizes = {
+        {
+            .type = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 10,
+        },
+    };
+    vkhpp::DescriptorPoolCreateInfo descriptorPoolCreateInfo = {
+        .maxSets = 10,
+        .poolSizeCount = static_cast<uint32_t>(sizes.size()),
+        .pPoolSizes = sizes.data(),
+    };
+    auto descriptorPool = device->createDescriptorPoolUnique(descriptorPoolCreateInfo).value;
+    ASSERT_THAT(descriptorPool, IsValidHandle());
+
+    const std::vector<vkhpp::DescriptorSetLayout> descriptorSetLayouts(
+        1, *pipelineInfo->descriptorSetLayout);
+
+    vkhpp::DescriptorSetAllocateInfo descriptorSetAllocateInfo = {
+        .descriptorPool = *descriptorPool,
+        .descriptorSetCount = 1,
+        .pSetLayouts = descriptorSetLayouts.data(),
+    };
+    auto descriptorSets = device->allocateDescriptorSetsUnique(descriptorSetAllocateInfo);
+    EXPECT_THAT(descriptorSets.result, Eq(vkhpp::Result::eSuccess));
+    auto descriptorSet = *descriptorSets.value[0];
+
+    // A uniform for red color
+    float kColor1[] = {1.0f, 0.0f, 0.0f, 0.0f};
+    auto uniformBufferInfo = createAndPopulateBuffer(physicalDevice, device.get(),
+                                                     vkhpp::BufferUsageFlagBits::eUniformBuffer,
+                                                     kColor1, sizeof(kColor1));
+
+    std::vector<vkhpp::WriteDescriptorSet> writeDescriptorSets;
+    std::vector<vkhpp::DescriptorBufferInfo> bufferInfos;
+    bufferInfos.emplace_back(vkhpp::DescriptorBufferInfo{
+        .buffer = *uniformBufferInfo->buffer,
+        .offset = 0,
+        .range = VK_WHOLE_SIZE,
+    });
+    writeDescriptorSets.emplace_back(vkhpp::WriteDescriptorSet{
+        .dstSet = descriptorSet,
+        .dstBinding = 0,
+        .descriptorCount = 1,
+        .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+        .pBufferInfo = bufferInfos.data(),
+    });
+    device->updateDescriptorSets(writeDescriptorSets, nullptr);
+
+    const std::vector<vkhpp::ImageView> attachments(1, *colorAttachmentInfo->imageView);
+    vkhpp::FramebufferCreateInfo framebufferCreateInfo = {
+        .renderPass = *pipelineInfo->renderPass,
+        .attachmentCount = 1,
+        .pAttachments = attachments.data(),
+        .width = kFbWidth,
+        .height = kFbHeight,
+        .layers = 1,
+    };
+    auto framebuffer = device->createFramebufferUnique(framebufferCreateInfo).value;
+    ASSERT_THAT(framebuffer, IsValidHandle());
+
+    auto fence = device->createFenceUnique(vkhpp::FenceCreateInfo()).value;
+    ASSERT_THAT(fence, IsValidHandle());
+
+    const vkhpp::CommandPoolCreateInfo commandPoolCreateInfo = {
+        .flags = vkhpp::CommandPoolCreateFlagBits::eResetCommandBuffer,
+        .queueFamilyIndex = queueFamilyIndex,
+    };
+
+    auto commandPool = device->createCommandPoolUnique(commandPoolCreateInfo).value;
+    ASSERT_THAT(commandPool, IsValidHandle());
+
+    const vkhpp::CommandBufferAllocateInfo commandBufferAllocateInfo = {
+        .level = vkhpp::CommandBufferLevel::ePrimary,
+        .commandPool = *commandPool,
+        .commandBufferCount = 1,
+    };
+
+    auto commandBuffers = device->allocateCommandBuffersUnique(commandBufferAllocateInfo).value;
+    ASSERT_THAT(commandBuffers, Not(IsEmpty()));
+    auto commandBuffer = std::move(commandBuffers[0]);
+    ASSERT_THAT(commandBuffer, IsValidHandle());
+
+    vkhpp::ClearColorValue clearColor(std::array<float, 4>{0.0f, 0.0f, 0.0f, 1.0f});
+    vkhpp::ClearValue clearValue{
+        .color = clearColor,
+    };
+    vkhpp::RenderPassBeginInfo renderPassBeginInfo{
+        .renderPass = *pipelineInfo->renderPass,
+        .framebuffer = *framebuffer,
+        .renderArea = vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)),
+        .clearValueCount = 1,
+        .pClearValues = &clearValue,
+    };
+
+    // Descriptor updates are cached on the guest, for testing purpose we need to submit a queue to
+    // commit descriptor updates.
+
+    const vkhpp::CommandBufferBeginInfo commandBufferBeginInfo = {
+        .flags = vkhpp::CommandBufferUsageFlagBits::eOneTimeSubmit,
+    };
+
+    commandBuffer->begin(commandBufferBeginInfo);
+    const vkhpp::ImageMemoryBarrier colorAttachmentBarrier{
+        .oldLayout = vkhpp::ImageLayout::eUndefined,
+        .newLayout = vkhpp::ImageLayout::eColorAttachmentOptimal,
+        .dstAccessMask = vkhpp::AccessFlagBits::eColorAttachmentRead |
+                         vkhpp::AccessFlagBits::eColorAttachmentWrite,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = *colorAttachmentInfo->image,
+        .subresourceRange =
+            {
+                .aspectMask = vkhpp::ImageAspectFlagBits::eColor,
+                .levelCount = 1,
+                .layerCount = 1,
+            },
+    };
+
+    commandBuffer->pipelineBarrier(
+        vkhpp::PipelineStageFlagBits::eTopOfPipe | vkhpp::PipelineStageFlagBits::eTransfer,
+        vkhpp::PipelineStageFlagBits::eColorAttachmentOutput, vkhpp::DependencyFlags(), nullptr,
+        nullptr, colorAttachmentBarrier);
+
+    commandBuffer->beginRenderPass(renderPassBeginInfo, vkhpp::SubpassContents::eInline);
+    commandBuffer->bindPipeline(vkhpp::PipelineBindPoint::eGraphics, *pipelineInfo->pipeline);
+    commandBuffer->bindDescriptorSets(vkhpp::PipelineBindPoint::eGraphics,
+                                      *pipelineInfo->pipelineLayout, 0, descriptorSet, nullptr);
+    commandBuffer->bindVertexBuffers(0, {*vertexBufferInfo->buffer}, {0});
+    commandBuffer->setViewport(0, vkhpp::Viewport(0.0f, 0.0f, static_cast<float>(kFbWidth),
+                                                  static_cast<float>(kFbHeight), 0.0f, 1.0f));
+    commandBuffer->setScissor(
+        0, vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)));
+    commandBuffer->draw(6, 1, 0, 0);
+    commandBuffer->endRenderPass();
+    commandBuffer->end();
+
+    std::vector<vkhpp::CommandBuffer> commandBufferHandles;
+    commandBufferHandles.push_back(*commandBuffer);
+
+    const vkhpp::SubmitInfo submitInfo = {
+        .commandBufferCount = static_cast<uint32_t>(commandBufferHandles.size()),
+        .pCommandBuffers = commandBufferHandles.data(),
+    };
+    queue.submit(submitInfo, *fence);
+    auto waitResult = device->waitForFences(*fence, VK_TRUE, 3000000000L);
+    ASSERT_THAT(waitResult, IsVkSuccess());
+    commandBuffer->reset();
+
+    // Clear the rendering
+    commandBuffer->begin(commandBufferBeginInfo);
+    commandBuffer->beginRenderPass(renderPassBeginInfo, vkhpp::SubpassContents::eInline);
+    commandBuffer->bindPipeline(vkhpp::PipelineBindPoint::eGraphics, *pipelineInfo->pipeline);
+    vkhpp::ClearAttachment clearAttachment{
+        .aspectMask = vkhpp::ImageAspectFlagBits::eColor,
+        .colorAttachment = 0,
+        .clearValue = clearValue,
+    };
+    vkhpp::ClearRect clearRect{
+        .rect = vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)),
+        .baseArrayLayer = 0,
+        .layerCount = 1,
+    };
+    commandBuffer->clearAttachments(1, &clearAttachment, 1, &clearRect);
+    commandBuffer->endRenderPass();
+    commandBuffer->end();
+
+    device->resetFences(1, &fence.get());
+    queue.submit(submitInfo, *fence);
+    waitResult = device->waitForFences(*fence, VK_TRUE, 3000000000L);
+    ASSERT_THAT(waitResult, IsVkSuccess());
+    commandBuffer->reset();
+
+    SnapshotSaveAndLoad();
+
+    // Redraw after snapshot, verify descriptors keep their value
+    // Command buffer snapshot is not implemented yet, so we need to re-make the command buffer.
+    commandBuffer->begin(commandBufferBeginInfo);
+    commandBuffer->beginRenderPass(renderPassBeginInfo, vkhpp::SubpassContents::eInline);
+    commandBuffer->bindPipeline(vkhpp::PipelineBindPoint::eGraphics, *pipelineInfo->pipeline);
+    commandBuffer->bindDescriptorSets(vkhpp::PipelineBindPoint::eGraphics,
+                                      *pipelineInfo->pipelineLayout, 0, descriptorSet, nullptr);
+    commandBuffer->bindVertexBuffers(0, {*vertexBufferInfo->buffer}, {0});
+    commandBuffer->setViewport(0, vkhpp::Viewport(0.0f, 0.0f, static_cast<float>(kFbWidth),
+                                                  static_cast<float>(kFbHeight), 0.0f, 1.0f));
+    commandBuffer->setScissor(
+        0, vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)));
+    commandBuffer->draw(6, 1, 0, 0);
+    commandBuffer->endRenderPass();
+    commandBuffer->end();
+
+    device->resetFences(1, &fence.get());
+    queue.submit(submitInfo, *fence);
+    waitResult = device->waitForFences(*fence, VK_TRUE, 3000000000L);
+    ASSERT_THAT(waitResult, IsVkSuccess());
+
+    std::vector<uint32_t> dst(kFbWidth * kFbHeight);
+    utils::readImageData(*colorAttachmentInfo->image, kFbWidth, kFbHeight,
+                         vkhpp::ImageLayout::eColorAttachmentOptimal, dst.data(),
+                         dst.size() * sizeof(uint32_t), testEnvironment);
+    for (int i = 0; i < dst.size(); i++) {
+        // The shader adds a blue color (from vertex buffer) with a red color (from uniform) and get
+        // purple.
+        ASSERT_THAT(dst[i], Eq(0xffff00ff));
+    }
+}
+
+TEST_P(GfxstreamEnd2EndVkSnapshotPipelineTest, DeleteBufferAfterWriteDescriptor) {
+    TypicalVkTestEnvironment testEnvironment = VK_ASSERT(SetUpTypicalVkTestEnvironment());
+    auto& [instance, physicalDevice, device, queue, queueFamilyIndex] = testEnvironment;
+
+    auto pipelineInfo = createPipeline(device.get());
+    auto vertexBufferInfo = createAndPopulateBuffer(
+        physicalDevice, device.get(), vkhpp::BufferUsageFlagBits::eVertexBuffer,
+        kFullscreenBlueRectangleVertexData, sizeof(kFullscreenBlueRectangleVertexData));
+
+    auto colorAttachmentInfo = createColorAttachment(physicalDevice, device.get());
+    ASSERT_THAT(colorAttachmentInfo->image, IsValidHandle());
+    ASSERT_THAT(colorAttachmentInfo->memory, IsValidHandle());
+    ASSERT_THAT(colorAttachmentInfo->imageView, IsValidHandle());
+
+    // Descriptor
+    std::vector<vkhpp::DescriptorPoolSize> sizes = {
+        {
+            .type = vkhpp::DescriptorType::eUniformBuffer,
+            .descriptorCount = 10,
+        },
+    };
+    vkhpp::DescriptorPoolCreateInfo descriptorPoolCreateInfo = {
+        .maxSets = 10,
+        .poolSizeCount = static_cast<uint32_t>(sizes.size()),
+        .pPoolSizes = sizes.data(),
+    };
+    auto descriptorPool = device->createDescriptorPoolUnique(descriptorPoolCreateInfo).value;
+    ASSERT_THAT(descriptorPool, IsValidHandle());
+
+    const std::vector<vkhpp::DescriptorSetLayout> descriptorSetLayouts(
+        1, *pipelineInfo->descriptorSetLayout);
+
+    vkhpp::DescriptorSetAllocateInfo descriptorSetAllocateInfo = {
+        .descriptorPool = *descriptorPool,
+        .descriptorSetCount = 1,
+        .pSetLayouts = descriptorSetLayouts.data(),
+    };
+    auto descriptorSets = device->allocateDescriptorSetsUnique(descriptorSetAllocateInfo);
+    EXPECT_THAT(descriptorSets.result, Eq(vkhpp::Result::eSuccess));
+    auto descriptorSet = *descriptorSets.value[0];
+
+    // A uniform for red color
+    float kColor1[] = {1.0f, 0.0f, 0.0f, 0.0f};
+    auto uniformBufferInfo = createAndPopulateBuffer(physicalDevice, device.get(),
+                                                     vkhpp::BufferUsageFlagBits::eUniformBuffer,
+                                                     kColor1, sizeof(kColor1));
+
+    std::vector<vkhpp::WriteDescriptorSet> writeDescriptorSets;
+    std::vector<vkhpp::DescriptorBufferInfo> bufferInfos;
+    bufferInfos.emplace_back(vkhpp::DescriptorBufferInfo{
+        .buffer = *uniformBufferInfo->buffer,
+        .offset = 0,
+        .range = VK_WHOLE_SIZE,
+    });
+    writeDescriptorSets.emplace_back(vkhpp::WriteDescriptorSet{
+        .dstSet = descriptorSet,
+        .dstBinding = 0,
+        .descriptorCount = 1,
+        .descriptorType = vkhpp::DescriptorType::eUniformBuffer,
+        .pBufferInfo = bufferInfos.data(),
+    });
+    device->updateDescriptorSets(writeDescriptorSets, nullptr);
+
+    const std::vector<vkhpp::ImageView> attachments(1, *colorAttachmentInfo->imageView);
+    vkhpp::FramebufferCreateInfo framebufferCreateInfo = {
+        .renderPass = *pipelineInfo->renderPass,
+        .attachmentCount = 1,
+        .pAttachments = attachments.data(),
+        .width = kFbWidth,
+        .height = kFbHeight,
+        .layers = 1,
+    };
+    auto framebuffer = device->createFramebufferUnique(framebufferCreateInfo).value;
+    ASSERT_THAT(framebuffer, IsValidHandle());
+
+    auto fence = device->createFenceUnique(vkhpp::FenceCreateInfo()).value;
+    ASSERT_THAT(fence, IsValidHandle());
+
+    const vkhpp::CommandPoolCreateInfo commandPoolCreateInfo = {
+        .flags = vkhpp::CommandPoolCreateFlagBits::eResetCommandBuffer,
+        .queueFamilyIndex = queueFamilyIndex,
+    };
+
+    auto commandPool = device->createCommandPoolUnique(commandPoolCreateInfo).value;
+    ASSERT_THAT(commandPool, IsValidHandle());
+
+    const vkhpp::CommandBufferAllocateInfo commandBufferAllocateInfo = {
+        .level = vkhpp::CommandBufferLevel::ePrimary,
+        .commandPool = *commandPool,
+        .commandBufferCount = 1,
+    };
+
+    auto commandBuffers = device->allocateCommandBuffersUnique(commandBufferAllocateInfo).value;
+    ASSERT_THAT(commandBuffers, Not(IsEmpty()));
+    auto commandBuffer = std::move(commandBuffers[0]);
+    ASSERT_THAT(commandBuffer, IsValidHandle());
+
+    vkhpp::ClearColorValue clearColor(std::array<float, 4>{0.0f, 0.0f, 0.0f, 1.0f});
+    vkhpp::ClearValue clearValue{
+        .color = clearColor,
+    };
+    vkhpp::RenderPassBeginInfo renderPassBeginInfo{
+        .renderPass = *pipelineInfo->renderPass,
+        .framebuffer = *framebuffer,
+        .renderArea = vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)),
+        .clearValueCount = 1,
+        .pClearValues = &clearValue,
+    };
+
+    // Descriptor updates are cached on the guest, for testing purpose we need to submit a queue to
+    // commit descriptor updates.
+
+    const vkhpp::CommandBufferBeginInfo commandBufferBeginInfo = {
+        .flags = vkhpp::CommandBufferUsageFlagBits::eOneTimeSubmit,
+    };
+
+    commandBuffer->begin(commandBufferBeginInfo);
+    const vkhpp::ImageMemoryBarrier colorAttachmentBarrier{
+        .oldLayout = vkhpp::ImageLayout::eUndefined,
+        .newLayout = vkhpp::ImageLayout::eColorAttachmentOptimal,
+        .dstAccessMask = vkhpp::AccessFlagBits::eColorAttachmentRead |
+                         vkhpp::AccessFlagBits::eColorAttachmentWrite,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = *colorAttachmentInfo->image,
+        .subresourceRange =
+            {
+                .aspectMask = vkhpp::ImageAspectFlagBits::eColor,
+                .levelCount = 1,
+                .layerCount = 1,
+            },
+    };
+
+    commandBuffer->pipelineBarrier(
+        vkhpp::PipelineStageFlagBits::eTopOfPipe | vkhpp::PipelineStageFlagBits::eTransfer,
+        vkhpp::PipelineStageFlagBits::eColorAttachmentOutput, vkhpp::DependencyFlags(), nullptr,
+        nullptr, colorAttachmentBarrier);
+
+    commandBuffer->beginRenderPass(renderPassBeginInfo, vkhpp::SubpassContents::eInline);
+    commandBuffer->bindPipeline(vkhpp::PipelineBindPoint::eGraphics, *pipelineInfo->pipeline);
+    commandBuffer->bindDescriptorSets(vkhpp::PipelineBindPoint::eGraphics,
+                                      *pipelineInfo->pipelineLayout, 0, descriptorSet, nullptr);
+    commandBuffer->bindVertexBuffers(0, {*vertexBufferInfo->buffer}, {0});
+    commandBuffer->setViewport(0, vkhpp::Viewport(0.0f, 0.0f, static_cast<float>(kFbWidth),
+                                                  static_cast<float>(kFbHeight), 0.0f, 1.0f));
+    commandBuffer->setScissor(
+        0, vkhpp::Rect2D(vkhpp::Offset2D(0, 0), vkhpp::Extent2D(kFbWidth, kFbHeight)));
+    commandBuffer->draw(6, 1, 0, 0);
+    commandBuffer->endRenderPass();
+    commandBuffer->end();
+
+    std::vector<vkhpp::CommandBuffer> commandBufferHandles;
+    commandBufferHandles.push_back(*commandBuffer);
+
+    const vkhpp::SubmitInfo submitInfo = {
+        .commandBufferCount = static_cast<uint32_t>(commandBufferHandles.size()),
+        .pCommandBuffers = commandBufferHandles.data(),
+    };
+    queue.submit(submitInfo, *fence);
+    auto waitResult = device->waitForFences(*fence, VK_TRUE, 3000000000L);
+    ASSERT_THAT(waitResult, IsVkSuccess());
+    commandBuffer->reset();
+
+    vertexBufferInfo->buffer.reset();
+    // Descriptor snapshot should not crash after underlying buffer is deleted.
+    SnapshotSaveAndLoad();
+}
+
 INSTANTIATE_TEST_CASE_P(GfxstreamEnd2EndTests, GfxstreamEnd2EndVkSnapshotPipelineTest,
                         ::testing::ValuesIn({
                             TestParams{
diff --git a/common/end2end/simple_shader.frag b/common/end2end/simple_shader.frag
index b8b6f56..a3e42b1 100644
--- a/common/end2end/simple_shader.frag
+++ b/common/end2end/simple_shader.frag
@@ -14,11 +14,15 @@
 
 #version 450
 
+layout (binding = 0) uniform UniformBuffer {
+  vec4 color1;
+};
+
 layout (location = 0) in vec4 color;
 
 layout (location = 0) out vec4 outColor;
 
 void main()
 {
-  outColor = color;
+  outColor = color + color1;
 }
\ No newline at end of file
diff --git a/common/end2end/simple_shader_frag.h b/common/end2end/simple_shader_frag.h
index cbb84f0..974d127 100644
--- a/common/end2end/simple_shader_frag.h
+++ b/common/end2end/simple_shader_frag.h
@@ -20,17 +20,26 @@
 #include <stdint.h>
 
 const uint32_t kSimpleShaderFrag[] = {
-    0x07230203, 0x00010000, 0x000d000b, 0x0000000d, 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
+    0x07230203, 0x00010000, 0x000d000b, 0x00000016, 0x00000000, 0x00020011, 0x00000001, 0x0006000b,
     0x00000001, 0x4c534c47, 0x6474732e, 0x3035342e, 0x00000000, 0x0003000e, 0x00000000, 0x00000001,
     0x0007000f, 0x00000004, 0x00000004, 0x6e69616d, 0x00000000, 0x00000009, 0x0000000b, 0x00030010,
     0x00000004, 0x00000007, 0x00030003, 0x00000002, 0x000001c2, 0x000a0004, 0x475f4c47, 0x4c474f4f,
     0x70635f45, 0x74735f70, 0x5f656c79, 0x656e696c, 0x7269645f, 0x69746365, 0x00006576, 0x00080004,
     0x475f4c47, 0x4c474f4f, 0x6e695f45, 0x64756c63, 0x69645f65, 0x74636572, 0x00657669, 0x00040005,
     0x00000004, 0x6e69616d, 0x00000000, 0x00050005, 0x00000009, 0x4374756f, 0x726f6c6f, 0x00000000,
-    0x00040005, 0x0000000b, 0x6f6c6f63, 0x00000072, 0x00040047, 0x00000009, 0x0000001e, 0x00000000,
-    0x00040047, 0x0000000b, 0x0000001e, 0x00000000, 0x00020013, 0x00000002, 0x00030021, 0x00000003,
-    0x00000002, 0x00030016, 0x00000006, 0x00000020, 0x00040017, 0x00000007, 0x00000006, 0x00000004,
-    0x00040020, 0x00000008, 0x00000003, 0x00000007, 0x0004003b, 0x00000008, 0x00000009, 0x00000003,
-    0x00040020, 0x0000000a, 0x00000001, 0x00000007, 0x0004003b, 0x0000000a, 0x0000000b, 0x00000001,
-    0x00050036, 0x00000002, 0x00000004, 0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003d,
-    0x00000007, 0x0000000c, 0x0000000b, 0x0003003e, 0x00000009, 0x0000000c, 0x000100fd, 0x00010038};
\ No newline at end of file
+    0x00040005, 0x0000000b, 0x6f6c6f63, 0x00000072, 0x00060005, 0x0000000d, 0x66696e55, 0x426d726f,
+    0x65666675, 0x00000072, 0x00050006, 0x0000000d, 0x00000000, 0x6f6c6f63, 0x00003172, 0x00030005,
+    0x0000000f, 0x00000000, 0x00040047, 0x00000009, 0x0000001e, 0x00000000, 0x00040047, 0x0000000b,
+    0x0000001e, 0x00000000, 0x00050048, 0x0000000d, 0x00000000, 0x00000023, 0x00000000, 0x00030047,
+    0x0000000d, 0x00000002, 0x00040047, 0x0000000f, 0x00000022, 0x00000000, 0x00040047, 0x0000000f,
+    0x00000021, 0x00000000, 0x00020013, 0x00000002, 0x00030021, 0x00000003, 0x00000002, 0x00030016,
+    0x00000006, 0x00000020, 0x00040017, 0x00000007, 0x00000006, 0x00000004, 0x00040020, 0x00000008,
+    0x00000003, 0x00000007, 0x0004003b, 0x00000008, 0x00000009, 0x00000003, 0x00040020, 0x0000000a,
+    0x00000001, 0x00000007, 0x0004003b, 0x0000000a, 0x0000000b, 0x00000001, 0x0003001e, 0x0000000d,
+    0x00000007, 0x00040020, 0x0000000e, 0x00000002, 0x0000000d, 0x0004003b, 0x0000000e, 0x0000000f,
+    0x00000002, 0x00040015, 0x00000010, 0x00000020, 0x00000001, 0x0004002b, 0x00000010, 0x00000011,
+    0x00000000, 0x00040020, 0x00000012, 0x00000002, 0x00000007, 0x00050036, 0x00000002, 0x00000004,
+    0x00000000, 0x00000003, 0x000200f8, 0x00000005, 0x0004003d, 0x00000007, 0x0000000c, 0x0000000b,
+    0x00050041, 0x00000012, 0x00000013, 0x0000000f, 0x00000011, 0x0004003d, 0x00000007, 0x00000014,
+    0x00000013, 0x00050081, 0x00000007, 0x00000015, 0x0000000c, 0x00000014, 0x0003003e, 0x00000009,
+    0x00000015, 0x000100fd, 0x00010038};
\ No newline at end of file
diff --git a/host/vulkan/VkDecoderGlobalState.cpp b/host/vulkan/VkDecoderGlobalState.cpp
index bf18f23..785b1f4 100644
--- a/host/vulkan/VkDecoderGlobalState.cpp
+++ b/host/vulkan/VkDecoderGlobalState.cpp
@@ -528,6 +528,141 @@
             releaseSnapshotStateBlock(&stateBlock);
         }
 
+        // snapshot descriptors
+        std::vector<VkDescriptorPool> sortedBoxedDescriptorPools;
+        for (const auto& descriptorPoolIte : mDescriptorPoolInfo) {
+            auto boxed =
+                unboxed_to_boxed_non_dispatchable_VkDescriptorPool(descriptorPoolIte.first);
+            sortedBoxedDescriptorPools.push_back(boxed);
+        }
+        std::sort(sortedBoxedDescriptorPools.begin(), sortedBoxedDescriptorPools.end());
+        for (const auto& boxedDescriptorPool : sortedBoxedDescriptorPools) {
+            auto unboxedDescriptorPool = unbox_VkDescriptorPool(boxedDescriptorPool);
+            const DescriptorPoolInfo& poolInfo = mDescriptorPoolInfo[unboxedDescriptorPool];
+
+            for (uint64_t poolId : poolInfo.poolIds) {
+                DispatchableHandleInfo<uint64_t>* setHandleInfo = sBoxedHandleManager.get(poolId);
+                bool allocated = setHandleInfo->underlying != 0;
+                stream->putByte(allocated);
+                if (!allocated) {
+                    continue;
+                }
+
+                const DescriptorSetInfo& descriptorSetInfo =
+                    mDescriptorSetInfo[(VkDescriptorSet)setHandleInfo->underlying];
+                VkDescriptorSetLayout boxedLayout =
+                    unboxed_to_boxed_non_dispatchable_VkDescriptorSetLayout(
+                        descriptorSetInfo.unboxedLayout);
+                stream->putBe64((uint64_t)boxedLayout);
+                // Count all valid descriptors.
+                //
+                // There is a use case where user can create an image, write it to a descriptor,
+                // read/write the image by committing a command, then delete the image without
+                // unbinding the descriptor. For example:
+                //
+                // T1: create "vkimage1" (original)
+                // T2: update binding1 of vkdescriptorset1 with vkimage1
+                // T3: draw
+                // T4: delete "vkimage1" (original)
+                // T5: create "vkimage1" (recycled)
+                // T6: snapshot load
+                //
+                // At the point of the snapshot, the original vk image has been invalidated,
+                // thus we cannot call vkUpdateDescriptorSets for it, and need to remove it
+                // from the snapshot.
+                //
+                // The current implementation bases on smart pointers. A descriptor set info
+                // holds weak pointers to their underlying resources (image, image view, buffer).
+                // On snapshot load, we check if any of the smart pointers are invalidated.
+                //
+                // An alternative approach has been discussed by, instead of using smart
+                // pointers, checking valid handles on snapshot save. This approach has the
+                // advantage that it reduces number of smart pointer allocations. After discussion
+                // we concluded that there is at least one corner case that will break the
+                // alternative approach. That is when the user deletes a bound vkimage and creates
+                // a new vkimage. The driver is free to reuse released handles, thus we might
+                // end up having a new vkimage with the same handle as the old one (see T5 in the
+                // example), and think the binding is still valid. And if we bind the new image
+                // regardless, we might hit a Vulkan validation error because the new image might
+                // have the "usage" flag that is unsuitable to bind to descriptors.
+                std::vector<std::pair<int, int>> validWriteIndices;
+                for (int bindingIdx = 0; bindingIdx < descriptorSetInfo.allWrites.size();
+                     bindingIdx++) {
+                    for (int bindingElemIdx = 0;
+                         bindingElemIdx < descriptorSetInfo.allWrites[bindingIdx].size();
+                         bindingElemIdx++) {
+                        const auto& entry = descriptorSetInfo.allWrites[bindingIdx][bindingElemIdx];
+                        if (entry.writeType == DescriptorSetInfo::DescriptorWriteType::Empty) {
+                            continue;
+                        }
+                        int dependencyObjCount =
+                            descriptorDependencyObjectCount(entry.descriptorType);
+                        if (entry.alives.size() < dependencyObjCount) {
+                            continue;
+                        }
+                        bool isValid = true;
+                        for (const auto& alive : entry.alives) {
+                            isValid &= !alive.expired();
+                            if (!isValid) {
+                                break;
+                            }
+                        }
+                        if (!isValid) {
+                            continue;
+                        }
+                        validWriteIndices.push_back(std::make_pair(bindingIdx, bindingElemIdx));
+                    }
+                }
+                stream->putBe64(validWriteIndices.size());
+                // Save all valid descriptors
+                for (const auto& idx : validWriteIndices) {
+                    const auto& entry = descriptorSetInfo.allWrites[idx.first][idx.second];
+                    stream->putBe32(idx.first);
+                    stream->putBe32(idx.second);
+                    stream->putBe32(entry.writeType);
+                    // entry.descriptorType might be redundant.
+                    stream->putBe32(entry.descriptorType);
+                    switch (entry.writeType) {
+                        case DescriptorSetInfo::DescriptorWriteType::ImageInfo: {
+                            VkDescriptorImageInfo imageInfo = entry.imageInfo;
+                            // Get the unboxed version
+                            imageInfo.imageView =
+                                descriptorTypeContainsImage(entry.descriptorType)
+                                    ? unboxed_to_boxed_non_dispatchable_VkImageView(
+                                          imageInfo.imageView)
+                                    : VK_NULL_HANDLE;
+                            imageInfo.sampler =
+                                descriptorTypeContainsSampler(entry.descriptorType)
+                                    ? unboxed_to_boxed_non_dispatchable_VkSampler(imageInfo.sampler)
+                                    : VK_NULL_HANDLE;
+                            stream->write(&imageInfo, sizeof(imageInfo));
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::BufferInfo: {
+                            VkDescriptorBufferInfo bufferInfo = entry.bufferInfo;
+                            // Get the unboxed version
+                            bufferInfo.buffer =
+                                unboxed_to_boxed_non_dispatchable_VkBuffer(bufferInfo.buffer);
+                            stream->write(&bufferInfo, sizeof(bufferInfo));
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::BufferView: {
+                            // Get the unboxed version
+                            VkBufferView bufferView =
+                                unboxed_to_boxed_non_dispatchable_VkBufferView(entry.bufferView);
+                            stream->write(&bufferView, sizeof(bufferView));
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::InlineUniformBlock:
+                        case DescriptorSetInfo::DescriptorWriteType::AccelerationStructure:
+                            // TODO
+                            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                                << "Encountered pending inline uniform block or acceleration "
+                                   "structure "
+                                   "desc write, abort (NYI)";
+                        default:
+                            break;
+                    }
+                }
+            }
+        }
         mSnapshotState = SnapshotState::Normal;
     }
 
@@ -539,6 +674,7 @@
         // destroy all current internal data structures
         clear();
         mSnapshotState = SnapshotState::Loading;
+        android::base::BumpPool bumpPool;
         // this part will replay in the decoder
         snapshot()->load(stream, gfxLogger, healthMonitor);
         // load mapped memory
@@ -609,6 +745,105 @@
             releaseSnapshotStateBlock(&stateBlock);
         }
 
+        // snapshot descriptors
+        std::vector<VkDescriptorPool> sortedBoxedDescriptorPools;
+        for (const auto& descriptorPoolIte : mDescriptorPoolInfo) {
+            auto boxed =
+                unboxed_to_boxed_non_dispatchable_VkDescriptorPool(descriptorPoolIte.first);
+            sortedBoxedDescriptorPools.push_back(boxed);
+        }
+        sort(sortedBoxedDescriptorPools.begin(), sortedBoxedDescriptorPools.end());
+        for (const auto& boxedDescriptorPool : sortedBoxedDescriptorPools) {
+            auto unboxedDescriptorPool = unbox_VkDescriptorPool(boxedDescriptorPool);
+            const DescriptorPoolInfo& poolInfo = mDescriptorPoolInfo[unboxedDescriptorPool];
+
+            std::vector<VkDescriptorSetLayout> layouts;
+            std::vector<uint64_t> poolIds;
+            std::vector<VkWriteDescriptorSet> writeDescriptorSets;
+            std::vector<uint32_t> writeStartingIndices;
+
+            // Temporary structures for the pointers in VkWriteDescriptorSet.
+            // Use unique_ptr so that the pointers don't change when vector resizes.
+            std::vector<std::unique_ptr<VkDescriptorImageInfo>> tmpImageInfos;
+            std::vector<std::unique_ptr<VkDescriptorBufferInfo>> tmpBufferInfos;
+            std::vector<std::unique_ptr<VkBufferView>> tmpBufferViews;
+
+            for (uint64_t poolId : poolInfo.poolIds) {
+                bool allocated = stream->getByte();
+                if (!allocated) {
+                    continue;
+                }
+                poolIds.push_back(poolId);
+                writeStartingIndices.push_back(writeDescriptorSets.size());
+                VkDescriptorSetLayout boxedLayout = (VkDescriptorSetLayout)stream->getBe64();
+                layouts.push_back(unbox_VkDescriptorSetLayout(boxedLayout));
+                uint64_t validWriteCount = stream->getBe64();
+                for (int write = 0; write < validWriteCount; write++) {
+                    uint32_t binding = stream->getBe32();
+                    uint32_t arrayElement = stream->getBe32();
+                    DescriptorSetInfo::DescriptorWriteType writeType =
+                        static_cast<DescriptorSetInfo::DescriptorWriteType>(stream->getBe32());
+                    VkDescriptorType descriptorType =
+                        static_cast<VkDescriptorType>(stream->getBe32());
+                    VkWriteDescriptorSet writeDescriptorSet = {
+                        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                        .dstSet = (VkDescriptorSet)poolId,
+                        .dstBinding = binding,
+                        .dstArrayElement = arrayElement,
+                        .descriptorCount = 1,
+                        .descriptorType = descriptorType,
+                    };
+                    switch (writeType) {
+                        case DescriptorSetInfo::DescriptorWriteType::ImageInfo: {
+                            tmpImageInfos.push_back(std::make_unique<VkDescriptorImageInfo>());
+                            writeDescriptorSet.pImageInfo = tmpImageInfos.back().get();
+                            VkDescriptorImageInfo& imageInfo = *tmpImageInfos.back();
+                            stream->read(&imageInfo, sizeof(imageInfo));
+                            imageInfo.imageView = descriptorTypeContainsImage(descriptorType)
+                                                      ? unbox_VkImageView(imageInfo.imageView)
+                                                      : 0;
+                            imageInfo.sampler = descriptorTypeContainsSampler(descriptorType)
+                                                    ? unbox_VkSampler(imageInfo.sampler)
+                                                    : 0;
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::BufferInfo: {
+                            tmpBufferInfos.push_back(std::make_unique<VkDescriptorBufferInfo>());
+                            writeDescriptorSet.pBufferInfo = tmpBufferInfos.back().get();
+                            VkDescriptorBufferInfo& bufferInfo = *tmpBufferInfos.back();
+                            stream->read(&bufferInfo, sizeof(bufferInfo));
+                            bufferInfo.buffer = unbox_VkBuffer(bufferInfo.buffer);
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::BufferView: {
+                            tmpBufferViews.push_back(std::make_unique<VkBufferView>());
+                            writeDescriptorSet.pTexelBufferView = tmpBufferViews.back().get();
+                            VkBufferView& bufferView = *tmpBufferViews.back();
+                            stream->read(&bufferView, sizeof(bufferView));
+                            bufferView = unbox_VkBufferView(bufferView);
+                        } break;
+                        case DescriptorSetInfo::DescriptorWriteType::InlineUniformBlock:
+                        case DescriptorSetInfo::DescriptorWriteType::AccelerationStructure:
+                            // TODO
+                            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                                << "Encountered pending inline uniform block or acceleration "
+                                   "structure "
+                                   "desc write, abort (NYI)";
+                        default:
+                            break;
+                    }
+                    writeDescriptorSets.push_back(writeDescriptorSet);
+                }
+            }
+            std::vector<uint32_t> whichPool(poolIds.size(), 0);
+            std::vector<uint32_t> pendingAlloc(poolIds.size(), true);
+
+            const auto& device = poolInfo.device;
+            const auto& deviceInfo = android::base::find(mDeviceInfo, device);
+            VulkanDispatch* dvk = dispatch_VkDevice(deviceInfo->boxed);
+            on_vkQueueCommitDescriptorSetUpdatesGOOGLE(
+                &bumpPool, dvk, device, 1, &unboxedDescriptorPool, poolIds.size(), layouts.data(),
+                poolIds.data(), whichPool.data(), pendingAlloc.data(), writeStartingIndices.data(),
+                writeDescriptorSets.size(), writeDescriptorSets.data());
+        }
         mSnapshotState = SnapshotState::Normal;
     }
 
@@ -1668,6 +1903,13 @@
                                const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
         auto device = unbox_VkDevice(boxed_device);
         auto vk = dispatch_VkDevice(boxed_device);
+        VkBufferCreateInfo localCreateInfo;
+        if (snapshotsEnabled()) {
+            localCreateInfo = *pCreateInfo;
+            localCreateInfo.usage |=
+                VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+            pCreateInfo = &localCreateInfo;
+        }
 
         VkResult result = vk->vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 
@@ -2663,7 +2905,20 @@
         auto& setInfo = mDescriptorSetInfo[descriptorSet];
 
         setInfo.pool = pool;
+        setInfo.unboxedLayout = setLayout;
         setInfo.bindings = setLayoutInfo->bindings;
+        for (size_t i = 0; i < setInfo.bindings.size(); i++) {
+            VkDescriptorSetLayoutBinding dslBinding = setInfo.bindings[i];
+            int bindingIdx = dslBinding.binding;
+            if (setInfo.allWrites.size() <= bindingIdx) {
+                setInfo.allWrites.resize(bindingIdx + 1);
+            }
+            setInfo.allWrites[bindingIdx].resize(dslBinding.descriptorCount);
+            for (auto& write : setInfo.allWrites[bindingIdx]) {
+                write.descriptorType = dslBinding.descriptorType;
+                write.dstArrayElement = 0;
+            }
+        }
 
         poolInfo->allocedSetsToBoxed[descriptorSet] = (VkDescriptorSet)boxedDescriptorSet;
         applyDescriptorSetAllocationLocked(*poolInfo, setInfo.bindings);
@@ -2759,6 +3014,117 @@
                                        const VkWriteDescriptorSet* pDescriptorWrites,
                                        uint32_t descriptorCopyCount,
                                        const VkCopyDescriptorSet* pDescriptorCopies) {
+        if (snapshotsEnabled()) {
+            for (uint32_t writeIdx = 0; writeIdx < descriptorWriteCount; writeIdx++) {
+                const VkWriteDescriptorSet& descriptorWrite = pDescriptorWrites[writeIdx];
+                auto ite = mDescriptorSetInfo.find(descriptorWrite.dstSet);
+                if (ite == mDescriptorSetInfo.end()) {
+                    continue;
+                }
+                DescriptorSetInfo& descriptorSetInfo = ite->second;
+                auto& table = descriptorSetInfo.allWrites;
+                VkDescriptorType descType = descriptorWrite.descriptorType;
+                uint32_t dstBinding = descriptorWrite.dstBinding;
+                uint32_t dstArrayElement = descriptorWrite.dstArrayElement;
+                uint32_t descriptorCount = descriptorWrite.descriptorCount;
+
+                uint32_t arrOffset = dstArrayElement;
+
+                if (isDescriptorTypeImageInfo(descType)) {
+                    for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+                         ++writeElemIdx, ++arrOffset) {
+                        // Descriptor writes wrap to the next binding. See
+                        // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html
+                        if (arrOffset >= table[dstBinding].size()) {
+                            ++dstBinding;
+                            arrOffset = 0;
+                        }
+                        auto& entry = table[dstBinding][arrOffset];
+                        entry.imageInfo = descriptorWrite.pImageInfo[writeElemIdx];
+                        entry.writeType = DescriptorSetInfo::DescriptorWriteType::ImageInfo;
+                        entry.descriptorType = descType;
+                        entry.alives.clear();
+                        if (descriptorTypeContainsImage(descType)) {
+                            auto* imageViewInfo =
+                                android::base::find(mImageViewInfo, entry.imageInfo.imageView);
+                            entry.alives.push_back(imageViewInfo->alive);
+                        }
+                        if (descriptorTypeContainsSampler(descType)) {
+                            auto* samplerInfo =
+                                android::base::find(mSamplerInfo, entry.imageInfo.sampler);
+                            entry.alives.push_back(samplerInfo->alive);
+                        }
+                    }
+                } else if (isDescriptorTypeBufferInfo(descType)) {
+                    for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+                         ++writeElemIdx, ++arrOffset) {
+                        if (arrOffset >= table[dstBinding].size()) {
+                            ++dstBinding;
+                            arrOffset = 0;
+                        }
+                        auto& entry = table[dstBinding][arrOffset];
+                        entry.bufferInfo = descriptorWrite.pBufferInfo[writeElemIdx];
+                        entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferInfo;
+                        entry.descriptorType = descType;
+                        entry.alives.clear();
+                        auto* bufferInfo =
+                            android::base::find(mBufferInfo, entry.bufferInfo.buffer);
+                        entry.alives.push_back(bufferInfo->alive);
+                    }
+                } else if (isDescriptorTypeBufferView(descType)) {
+                    for (uint32_t writeElemIdx = 0; writeElemIdx < descriptorCount;
+                         ++writeElemIdx, ++arrOffset) {
+                        if (arrOffset >= table[dstBinding].size()) {
+                            ++dstBinding;
+                            arrOffset = 0;
+                        }
+                        auto& entry = table[dstBinding][arrOffset];
+                        entry.bufferView = descriptorWrite.pTexelBufferView[writeElemIdx];
+                        entry.writeType = DescriptorSetInfo::DescriptorWriteType::BufferView;
+                        entry.descriptorType = descType;
+                        // TODO: check alive
+                        ERR("%s: Snapshot for texel buffer view is incomplete.\n", __func__);
+                    }
+                } else if (isDescriptorTypeInlineUniformBlock(descType)) {
+                    const VkWriteDescriptorSetInlineUniformBlock* descInlineUniformBlock =
+                        static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
+                            descriptorWrite.pNext);
+                    while (descInlineUniformBlock &&
+                           descInlineUniformBlock->sType !=
+                               VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK) {
+                        descInlineUniformBlock =
+                            static_cast<const VkWriteDescriptorSetInlineUniformBlock*>(
+                                descInlineUniformBlock->pNext);
+                    }
+                    if (!descInlineUniformBlock) {
+                        GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                            << __func__ << ": did not find inline uniform block";
+                        return;
+                    }
+                    auto& entry = table[dstBinding][0];
+                    entry.inlineUniformBlock = *descInlineUniformBlock;
+                    entry.inlineUniformBlockBuffer.assign(
+                        static_cast<const uint8_t*>(descInlineUniformBlock->pData),
+                        static_cast<const uint8_t*>(descInlineUniformBlock->pData) +
+                            descInlineUniformBlock->dataSize);
+                    entry.writeType = DescriptorSetInfo::DescriptorWriteType::InlineUniformBlock;
+                    entry.descriptorType = descType;
+                    entry.dstArrayElement = dstArrayElement;
+                } else if (isDescriptorTypeAccelerationStructure(descType)) {
+                    // TODO
+                    // Look for pNext inline uniform block or acceleration structure.
+                    // Append new DescriptorWrite entry that holds the buffer
+                    ERR("%s: Ignoring Snapshot for emulated write for descriptor type 0x%x\n",
+                        __func__, descType);
+                }
+            }
+            // TODO: bookkeep pDescriptorCopies
+            // Our primary use case vkQueueCommitDescriptorSetUpdatesGOOGLE does not use
+            // pDescriptorCopies. Thus skip its implementation for now.
+            if (descriptorCopyCount) {
+                ERR("%s: Snapshot does not support descriptor copy yet\n");
+            }
+        }
         bool needEmulateWriteDescriptor = false;
         // c++ seems to allow for 0-size array allocation
         std::unique_ptr<bool[]> descriptorWritesNeedDeepCopy(new bool[descriptorWriteCount]);
@@ -5733,8 +6099,7 @@
                 return (VkDescriptorSet)(setHandleInfo->underlying);
             }
         } else {
-            // Snapshot doesn't really replay the commands to allocate those descriptors.
-            if (pendingAlloc || snapshotsEnabled()) {
+            if (pendingAlloc) {
                 VkDescriptorSet allocedSet;
                 VkDescriptorSetAllocateInfo dsAi = {
                     VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, 0, pool, 1, &setLayout,
@@ -5774,7 +6139,21 @@
             GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
                 << "queue " << queue << "(boxed: " << boxed_queue << ") with no device registered";
         }
+        on_vkQueueCommitDescriptorSetUpdatesGOOGLE(
+            pool, vk, device, descriptorPoolCount, pDescriptorPools, descriptorSetCount,
+            pDescriptorSetLayouts, pDescriptorSetPoolIds, pDescriptorSetWhichPool,
+            pDescriptorSetPendingAllocation, pDescriptorWriteStartingIndices,
+            pendingDescriptorWriteCount, pPendingDescriptorWrites);
+    }
 
+    void on_vkQueueCommitDescriptorSetUpdatesGOOGLE(
+        android::base::BumpPool* pool, VulkanDispatch* vk, VkDevice device,
+        uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
+        uint32_t descriptorSetCount, const VkDescriptorSetLayout* pDescriptorSetLayouts,
+        const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
+        const uint32_t* pDescriptorSetPendingAllocation,
+        const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
+        const VkWriteDescriptorSet* pPendingDescriptorWrites) {
         std::vector<VkDescriptorSet> setsToUpdate(descriptorSetCount, nullptr);
 
         bool didAlloc = false;
@@ -5805,7 +6184,6 @@
                 } else {
                     writeEndIndex = pDescriptorWriteStartingIndices[i + 1];
                 }
-
                 for (uint32_t j = writeStartIndex; j < writeEndIndex; ++j) {
                     writeDescriptorSetsForHostDriver[j].dstSet = setsToUpdate[i];
                 }
@@ -6897,6 +7275,18 @@
                (descType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
     }
 
+    bool descriptorTypeContainsImage(VkDescriptorType descType) {
+        return (descType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) ||
+               (descType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) ||
+               (descType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) ||
+               (descType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
+    }
+
+    bool descriptorTypeContainsSampler(VkDescriptorType descType) {
+        return (descType == VK_DESCRIPTOR_TYPE_SAMPLER) ||
+               (descType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+    }
+
     bool isDescriptorTypeBufferInfo(VkDescriptorType descType) {
         return (descType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
                (descType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
@@ -6909,6 +7299,34 @@
                (descType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER);
     }
 
+    bool isDescriptorTypeInlineUniformBlock(VkDescriptorType descType) {
+        return descType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
+    }
+
+    bool isDescriptorTypeAccelerationStructure(VkDescriptorType descType) {
+        return descType == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
+    }
+
+    int descriptorDependencyObjectCount(VkDescriptorType descType) {
+        switch (descType) {
+            case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+                return 2;
+            case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+            case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+            case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+            case VK_DESCRIPTOR_TYPE_SAMPLER:
+            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+            case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+            case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+                return 1;
+            default:
+                return 0;
+        }
+    }
+
     struct DescriptorUpdateTemplateInfo {
         VkDescriptorUpdateTemplateCreateInfo createInfo;
         std::vector<VkDescriptorUpdateTemplateEntry> linearizedTemplateEntries;
diff --git a/host/vulkan/VkDecoderInternalStructs.h b/host/vulkan/VkDecoderInternalStructs.h
index b81c50c..eab6656 100644
--- a/host/vulkan/VkDecoderInternalStructs.h
+++ b/host/vulkan/VkDecoderInternalStructs.h
@@ -231,6 +231,7 @@
     VkDeviceMemory memory = 0;
     VkDeviceSize memoryOffset = 0;
     VkDeviceSize size;
+    std::shared_ptr<bool> alive{new bool(true)};
 };
 
 struct ImageInfo {
@@ -251,6 +252,7 @@
 
     // Color buffer, provided via vkAllocateMemory().
     std::optional<HandleType> boundColorBuffer;
+    std::shared_ptr<bool> alive{new bool(true)};
 };
 
 struct SamplerInfo {
@@ -271,6 +273,7 @@
     SamplerInfo(const SamplerInfo& other) { *this = other; }
     SamplerInfo(SamplerInfo&& other) = delete;
     SamplerInfo& operator=(SamplerInfo&& other) = delete;
+    std::shared_ptr<bool> alive{new bool(true)};
 };
 
 struct FenceInfo {
@@ -331,7 +334,36 @@
 };
 
 struct DescriptorSetInfo {
+    enum DescriptorWriteType {
+        Empty = 0,
+        ImageInfo = 1,
+        BufferInfo = 2,
+        BufferView = 3,
+        InlineUniformBlock = 4,
+        AccelerationStructure = 5,
+    };
+
+    struct DescriptorWrite {
+        VkDescriptorType descriptorType;
+        DescriptorWriteType writeType = DescriptorWriteType::Empty;
+        uint32_t dstArrayElement;  // Only used for inlineUniformBlock and accelerationStructure.
+
+        union {
+            VkDescriptorImageInfo imageInfo;
+            VkDescriptorBufferInfo bufferInfo;
+            VkBufferView bufferView;
+            VkWriteDescriptorSetInlineUniformBlockEXT inlineUniformBlock;
+            VkWriteDescriptorSetAccelerationStructureKHR accelerationStructure;
+        };
+
+        std::vector<uint8_t> inlineUniformBlockBuffer;
+        // Weak pointer(s) to detect if all objects on dependency chain are alive.
+        std::vector<std::weak_ptr<bool>> alives;
+    };
+
     VkDescriptorPool pool;
+    VkDescriptorSetLayout unboxedLayout = 0;
+    std::vector<std::vector<DescriptorWrite>> allWrites;
     std::vector<VkDescriptorSetLayoutBinding> bindings;
 };
 
diff --git a/host/vulkan/VkDecoderSnapshotUtils.cpp b/host/vulkan/VkDecoderSnapshotUtils.cpp
index 921d075..8cdad81 100644
--- a/host/vulkan/VkDecoderSnapshotUtils.cpp
+++ b/host/vulkan/VkDecoderSnapshotUtils.cpp
@@ -584,7 +584,7 @@
     VkBufferCreateInfo bufferCreateInfo = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .size = static_cast<VkDeviceSize>(bufferInfo->size),
-        .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+        .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
     };
     VkBuffer stagingBuffer;