addressing more comments.

Author: gpx1000

en/Building_a_Simple_Engine/GUI/02_imgui_setup.adoc

@@ -111,6 +111,11 @@ Next, we set up the Vulkan pipeline objects that define how UI geometry is proce
 
 The pipeline infrastructure creates a specialized graphics pipeline optimized for UI rendering, which differs significantly from typical 3D rendering pipelines. UI rendering typically requires alpha blending for transparency effects, operates in 2D screen space rather than 3D world space, and uses simpler shading models focused on texture sampling rather than complex lighting calculations.
 
+[NOTE]
+====
+Frames-in-flight safety: If your renderer uses more than one frame in flight and you do not stall the GPU between frames, you must duplicate the dynamic ImGui buffers (vertex/index) per frame-in-flight. Using a single shared vertex/index buffer risks the CPU overwriting data still in use by the GPU from a previous frame. The simple single-buffer members shown above are for conceptual clarity; in production, store vectors of buffers/memories sized to the max frames in flight and update/bind the buffers for the current frame index.
+====
+
 The descriptor system manages the connection between our CPU-side resources and the GPU shaders. For UI rendering, this primarily involves binding the font atlas texture to the fragment shader, though more complex UI systems might include additional textures for icons, backgrounds, or other visual elements.
 
 === ImGuiVulkanUtil Architecture: Device Context and System Integration
@@ -773,7 +778,7 @@ void drawFrame() {
     // Render scene using dynamic rendering
     // ...
 
-    // Render ImGui
+    // Render ImGui (in multi-frame renderers, pass the current frame index to bind per-frame buffers)
     imGui.drawFrame(commandBuffer);
 
     // ... submit command buffer ...

en/Building_a_Simple_Engine/GUI/04_ui_elements.adoc

@@ -111,6 +111,69 @@ When integrating ImGui with Vulkan, consider these performance aspects:
 4. *Pipeline State*: Use a dedicated pipeline for ImGui to minimize state changes
 5. *Render Pass Integration*: Consider whether to use a separate render pass or subpass for the GUI
 
+==== Frames-in-Flight: Duplicate Dynamic Buffers Per Frame
+
+If your renderer uses multiple frames in flight (e.g., double/triple buffering) without a device wait-idle between frames, ImGui's dynamic vertex and index buffers must not be shared across frames. Otherwise, the CPU can overwrite data that the GPU from a previous frame is still reading.
+
+- Allocate one vertex buffer and one index buffer per frame-in-flight.
+- Update/bind the buffers for the current frame index only.
+- Size each buffer to the frame's ImDrawData TotalVtxCount/TotalIdxCount, growing as needed.
+
+Example sketch:
+
+[source,cpp]
+----
+class ImGuiSystem {
+  // ...
+  std::vector<vk::raii::Buffer> vertexBuffers;
+  std::vector<vk::raii::DeviceMemory> vertexMemories;
+  std::vector<vk::raii::Buffer> indexBuffers;
+  std::vector<vk::raii::DeviceMemory> indexMemories;
+  std::vector<uint32_t> vertexCounts;
+  std::vector<uint32_t> indexCounts;
+
+  bool Initialize(Renderer* renderer, uint32_t w, uint32_t h) {
+    // ... create pipelines, font, descriptors ...
+    const uint32_t frames = renderer->GetMaxFramesInFlight();
+    vertexBuffers.resize(frames);
+    vertexMemories.resize(frames);
+    indexBuffers.resize(frames);
+    indexMemories.resize(frames);
+    vertexCounts.assign(frames, 0);
+    indexCounts.assign(frames, 0);
+    return true;
+  }
+
+  void Render(vk::raii::CommandBuffer& cmd, uint32_t frameIndex) {
+    ImGui::Render();
+    updateBuffers(frameIndex);
+    // bind per-frame buffers
+    std::array vb = {*vertexBuffers[frameIndex]};
+    std::array<vk::DeviceSize,1> offs{};
+    cmd.bindVertexBuffers(0, vb, offs);
+    cmd.bindIndexBuffer(*indexBuffers[frameIndex], 0, vk::IndexType::eUint16);
+    // draw lists...
+  }
+
+  void updateBuffers(uint32_t frameIndex) {
+    ImDrawData* dd = ImGui::GetDrawData();
+    if (!dd || dd->CmdListsCount == 0) return;
+    vk::DeviceSize vbytes = dd->TotalVtxCount * sizeof(ImDrawVert);
+    vk::DeviceSize ibytes = dd->TotalIdxCount * sizeof(ImDrawIdx);
+    // grow-per-frame if needed, then map/copy for this frame only
+    // ...
+  }
+};
+----
+
+When integrating with your main renderer, pass the current frame index to the ImGui render call:
+
+[source,cpp]
+----
+// inside your frame loop after scene rendering
+imguiSystem->Render(commandBuffers[currentFrame], currentFrame);
+----
+
 === Organizing Your GUI Code
 
 For maintainable GUI code, consider these organizational patterns: