diff --git a/engine/imgui/src/imgui.zig b/engine/imgui/src/imgui.zig
index df8f726..a8a0330 100644
--- a/engine/imgui/src/imgui.zig
+++ b/engine/imgui/src/imgui.zig
@@ -1,17 +1,25 @@
 const std = @import("std");
 pub const core = @import("core");
-pub const cimgui = @import("cimgui");
+pub const api = @import("cimgui");
 const rend = @import("rend");
+const Impl = @import("sgpu/backend_impl.zig").Impl;
 
 pub const Module: core.ModuleDescription = .{
     .name = "imgui",
     .enabledByDefault = false,
 };
 
+var gImgui: *Impl = undefined;
+
 pub fn start_module(comptime programSpec: anytype, args: anytype, allocator: std.mem.Allocator) !void {
     _ = allocator;
     _ = args;
     _ = programSpec;
+
+    // gImgui = try rend.createRendererObject(Impl);
+    // try gImgui.setup();
+    gImgui = try core.createObject(Impl, .{});
+    try gImgui.setup();
 }
 
 pub fn shutdown_module(allocator: std.mem.Allocator) void {
diff --git a/engine/imgui/src/sgpu/backend_impl.zig b/engine/imgui/src/sgpu/backend_impl.zig
index 6d62058..8380788 100644
--- a/engine/imgui/src/sgpu/backend_impl.zig
+++ b/engine/imgui/src/sgpu/backend_impl.zig
@@ -1,37 +1,73 @@
-pub const ImguiImpl = struct {
+pub const Impl = struct {
     allocator: std.mem.Allocator,
-    device: *gpu.GPUDevice,
+    device: *gpu.GPUDevice = undefined,
+
+    drawData: [*c]ig.DrawData = undefined,
+
+    pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());
+
+    pub const Settings = struct {
+        x: u32 = 0,
+    };
 
     // renderer plugin
-    pub fn create(device: *gpu.GPUDevice, allocator: std.mem.Allocator, settings: struct {}) !*@This() {
+    pub fn create(allocator: std.mem.Allocator) !*@This() {
         const self = try allocator.create(@This());
 
         self.* = .{
             .allocator = allocator,
-            .device = device,
         };
-        _ = settings;
 
         return self;
     }
 
+    pub fn setup(self: *@This()) !void {
+        core.graphics_log("imgui startup", .{});
+        self.device = rend.context().device;
+        try rend.registerRendererObject(@This(), self);
+
+        c.Imgui_SDL3_Init(@ptrCast(platform.getInstance().window), @ptrCast(self.device));
+        try platform.getInstance().addSDLProcessFunction(processSDLEvents);
+    }
+
+    pub fn processSDLEvents(event: *sdl3.Event) void {
+        c.Imgui_SDL3_ProcessEvent(@ptrCast(event));
+    }
+
+    pub fn onPreDraw(p: *anyopaque, cmd: *gpu.GPUCommandBuffer) void {
+        const self: *@This() = @ptrCast(@alignCast(p));
+        ig.render();
+        self.drawData = ig.getDrawData();
+
+        c.Imgui_SDL3_PrepareRender(@ptrCast(self.drawData), @ptrCast(cmd));
+    }
+
+    pub fn postRender(p: *anyopaque, cmd: *gpu.GPUCommandBuffer, renderPass: *gpu.GPURenderPass) void {
+        const self: *@This() = @ptrCast(@alignCast(p));
+
+        c.ImGui_SDLGPU3_RenderDrawData(
+            @ptrCast(self.drawData),
+            @ptrCast(cmd),
+            @ptrCast(renderPass),
+        );
+    }
+
     pub fn preTick(_: *@This(), _: f64) core.EngineDataEventError!void {
-        c.ImGui_ImplGlfw_NewFrame();
-        c.cImGui_vk_NewFrame();
+        core.engine_logs("imgui pretick");
+        c.Imgui_SDL3_NewFrame();
         c.igNewFrame();
     }
 
     // renderer plugin
-    pub fn destroy(p: *anyopaque) void {
-        const self: *@This() = @ptrCast(@alignCast(p));
-
+    pub fn destroy(self: *@This()) void {
         self.allocator.destroy(self);
     }
 };
 const c = @import("cimgui").c;
-const ig = @import("cimgui").cimgui;
+const ig = @import("cimgui");
 const sdl3 = @import("sdl3");
 const gpu = sdl3.gpu;
 const rend = @import("rend");
+const platform = @import("platform");
 const std = @import("std");
 const core = @import("core");
diff --git a/engine/modulelist.zig b/engine/modulelist.zig
index c09b12d..4bda2af 100644
--- a/engine/modulelist.zig
+++ b/engine/modulelist.zig
@@ -6,7 +6,7 @@ pub const list = [_][]const u8{
     "physics",
 
     "rend",
-    // "imgui",
+    "imgui",
     // to be implemented
     // "graphics",
     // "ui",
diff --git a/engine/platform/src/windowing.zig b/engine/platform/src/windowing.zig
index b56419c..aa66352 100644
--- a/engine/platform/src/windowing.zig
+++ b/engine/platform/src/windowing.zig
@@ -75,9 +75,12 @@ pub const PlatformInstance = struct {
 
     windowDestroyed: bool = false,
 
+    processFuncs: std.ArrayListUnmanaged(*const fn (*sdl3.Event) void) = .{},
+
     pub fn deinit(self: *@This()) void {
         self.allocator.free(self.windowName);
         self.allocator.free(self.iconPath);
+        self.processFuncs.deinit(self.allocator);
         // shutdown
     }
 
@@ -105,6 +108,10 @@ pub const PlatformInstance = struct {
         return self;
     }
 
+    pub fn addSDLProcessFunction(self: *@This(), processFunc: *const fn (*sdl3.Event) void) !void {
+        try self.processFuncs.append(self.allocator, processFunc);
+    }
+
     pub fn setupWindow(self: *@This()) core.EngineDataEventError!void {
         sdl3.init(.{ .video = true, .gamepad = true }) catch return error.BadInit;
         self.window = sdl3.c.SDL_CreateWindow(self.windowName, self.windowExtent.x, self.windowExtent.y, 0).?; // resizeable
@@ -130,7 +137,8 @@ pub const PlatformInstance = struct {
     pub fn processEvents(ptr: *anyopaque, frameNumber: u64) core.EngineDataEventError!void {
         _ = frameNumber;
 
-        _ = ptr;
+        const self: *@This() = @ptrCast(@alignCast(ptr));
+
         // const self: *@This() = @ptrCast(@alignCast(ptr));
         var t1 = tracy.ZoneN(@src(), "Pumping Events");
         defer t1.End();
@@ -142,6 +150,10 @@ pub const PlatformInstance = struct {
                 inputStack.routeEvent(converted);
             }
 
+            for (self.processFuncs.items) |func| {
+                func(@ptrCast(event));
+            }
+
             switch (event.type) {
                 sdl3.events.quit => {
                     core.exitNow();
diff --git a/engine/rend/src/rend.zig b/engine/rend/src/rend.zig
index c063806..a385351 100644
--- a/engine/rend/src/rend.zig
+++ b/engine/rend/src/rend.zig
@@ -27,6 +27,9 @@ pub const getMeshByName = renderer.getMeshByName;
 // camera API
 pub const setActiveCamera = renderer.setActiveCamera;
 
+pub const createRendererObject = renderer.createRendererObject;
+pub const registerRendererObject = renderer.registerRendererObject;
+
 var rendAllocator: std.mem.Allocator = undefined;
 pub fn getAllocator() std.mem.Allocator {
     return rendAllocator;
diff --git a/engine/rend/src/sgpu/renderer.zig b/engine/rend/src/sgpu/renderer.zig
index c26cac4..463955d 100644
--- a/engine/rend/src/sgpu/renderer.zig
+++ b/engine/rend/src/sgpu/renderer.zig
@@ -30,7 +30,10 @@ pub const Renderer = struct {
 
     uploads: std.ArrayListUnmanaged(struct { ptr: *anyopaque, func: *const fn (*anyopaque, *gpu.GPUCopyPass) void }) = .{},
     uploadCleanup: std.ArrayListUnmanaged(struct { ptr: *anyopaque, func: *const fn (*anyopaque) void }) = .{},
+
+    postRenders: std.ArrayListUnmanaged(struct { ptr: *anyopaque, func: *const fn (*anyopaque, *gpu.GPUCommandBuffer, *gpu.GPURenderPass) void }) = .{},
     destroys: std.ArrayListUnmanaged(struct { ptr: *anyopaque, func: *const fn (*anyopaque) void }) = .{},
+    preDraws: std.ArrayListUnmanaged(struct { ptr: *anyopaque, func: *const fn (*anyopaque, *gpu.GPUCommandBuffer) void }) = .{},
 
     depthTexture: *gpu.GPUTexture = undefined,
 
@@ -51,12 +54,34 @@ pub const Renderer = struct {
         return self;
     }
 
-    pub fn registerRendererObject(self: *@This(), T: type) !*T {
+    // pub fn createRendererObjectArgs(self: *@This(), T: type) !*T {
+
+    // registers a pre-existing render object, does not add to destroys
+    pub fn registerRendererObject(self: *@This(), T: type, object: *anyopaque) !void {
+        if (@hasDecl(T, "onUpload")) {
+            try self.uploads.append(self.allocator, .{ .ptr = object, .func = T.onUpload });
+        }
+
+        if (@hasDecl(T, "onUploadCleanup")) {
+            try self.uploadCleanup.append(self.allocator, .{ .ptr = object, .func = T.onUploadCleanup });
+        }
+
+        if (@hasDecl(T, "postRender")) {
+            try self.postRenders.append(self.allocator, .{ .ptr = object, .func = T.postRender });
+        }
+
+        if (@hasDecl(T, "onPreDraw")) {
+            try self.preDraws.append(self.allocator, .{ .ptr = object, .func = T.onPreDraw });
+        }
+    }
+
+    pub fn createRendererObject(self: *@This(), T: type) !*T {
         const object = try T.create(self.device, self.allocator, .{});
 
-        try self.uploads.append(self.allocator, .{ .ptr = object, .func = T.onUpload });
-        try self.uploadCleanup.append(self.allocator, .{ .ptr = object, .func = T.onUploadCleanup });
+        try self.registerRendererObject(T, object);
+
         try self.destroys.append(self.allocator, .{ .ptr = object, .func = T.destroy });
+
         return object;
     }
 
@@ -94,7 +119,7 @@ pub const Renderer = struct {
         try self.createMeshPipeline();
         try self.createDepthTexture();
 
-        self.meshPool = try self.registerRendererObject(MeshPool);
+        self.meshPool = try self.createRendererObject(MeshPool);
     }
 
     pub fn discoverFormats(self: *@This()) !void {
@@ -345,6 +370,10 @@ pub const Renderer = struct {
         self.frameUploads();
         try self.uploadUniforms(cmd);
 
+        for (self.preDraws.items) |interface| {
+            interface.func(interface.ptr, cmd);
+        }
+
         var swapchainTexture: *gpu.GPUTexture = undefined;
         if (cmd.waitAndAcquireGPUSwapchainTexture(self.window, &swapchainTexture, null, null)) {
             var targetInfo: gpu.GPUColorTargetInfo = std.mem.zeroes(gpu.GPUColorTargetInfo);
@@ -391,6 +420,10 @@ pub const Renderer = struct {
                 }
             }
 
+            for (self.postRenders.items) |interface| {
+                interface.func(interface.ptr, cmd, renderpass);
+            }
+
             // renderpass.drawGPUPrimitives(3, 1, 0, 0);
 
             renderpass.endGPURenderPass();
@@ -465,6 +498,14 @@ pub fn setActiveCamera(camera: ?*rend.CameraComponent) void {
     gRenderer.activeCamera = camera;
 }
 
+pub fn createRendererObject(comptime T: type) !*T {
+    return try gRenderer.createRendererObject(T);
+}
+
+pub fn registerRendererObject(comptime T: type, object: *anyopaque) !void {
+    return try gRenderer.registerRendererObject(T, object);
+}
+
 pub const getMesh = mesh_pool.getMesh;
 pub const getMeshByName = mesh_pool.getMeshByName;
 
diff --git a/lib/cimgui/build.zig b/lib/cimgui/build.zig
index d749673..3ce85a4 100644
--- a/lib/cimgui/build.zig
+++ b/lib/cimgui/build.zig
@@ -12,6 +12,11 @@ pub fn build(b: *std.Build) void {
         .root_source_file = b.path("src/cimgui.zig"),
     });
 
+    mod.addIncludePath(b.path("cimgui/imgui"));
+    mod.addIncludePath(b.path("cimgui/SDL/include"));
+    mod.addIncludePath(b.path("cimplot"));
+    mod.addIncludePath(b.path("cimplot/implot"));
+
     const cimgui = b.addStaticLibrary(.{
         .name = "cimgui",
         .target = target,
@@ -34,7 +39,7 @@ pub fn build(b: *std.Build) void {
         .root = b.path("cimgui/imgui"),
         .files = &[_][]const u8{
             "cimgui.cpp",
-            // "cimgui_compat.cpp", replace with cimgui_compat_sdlgpu
+            "cimgui_compat.cpp", // replace with cimgui_compat_sdlgpu
             "imgui.cpp",
             "imgui_demo.cpp",
             "imgui_draw.cpp",
diff --git a/lib/cimgui/cimgui/imgui/cimgui_compat.cpp b/lib/cimgui/cimgui/imgui/cimgui_compat.cpp
new file mode 100644
index 0000000..f67d02f
--- /dev/null
+++ b/lib/cimgui/cimgui/imgui/cimgui_compat.cpp
@@ -0,0 +1,55 @@
+#include "imgui.h"
+#include "imgui_impl_sdl3.h"
+#include "imgui_impl_sdlgpu3.h"
+#include <stdio.h>          // printf, fprintf
+#include <stdlib.h>         // abort
+
+extern "C" void Imgui_SDL3_Init(SDL_Window* window, SDL_GPUDevice* gpu_device)
+{
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO(); (void)io;
+    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+    io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;         // Enable Docking
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;       // Enable Multi-Viewport / Platform Windows
+
+    // Setup Dear ImGui style
+    ImGui::StyleColorsDark();
+    //ImGui::StyleColorsLight();
+
+    // When viewports are enabled we tweak WindowRounding/WindowBg so platform windows can look identical to regular ones.
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
+    {
+        style.WindowRounding = 0.0f;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0f;
+    }
+
+    // Setup Platform/Renderer backends
+    ImGui_ImplSDL3_InitForSDLGPU(window);
+    ImGui_ImplSDLGPU3_InitInfo init_info = {};
+    init_info.Device = gpu_device;
+    init_info.ColorTargetFormat = SDL_GetGPUSwapchainTextureFormat(gpu_device, window);
+    init_info.MSAASamples = SDL_GPU_SAMPLECOUNT_1;
+    ImGui_ImplSDLGPU3_Init(&init_info);}
+
+extern "C" void Imgui_SDL3_ProcessEvent(SDL_Event* Event)
+{
+    ImGui_ImplSDL3_ProcessEvent(Event);
+}
+
+extern "C" void Imgui_SDL3_NewFrame()
+{
+    ImGui_ImplSDLGPU3_NewFrame();
+    ImGui_ImplSDL3_NewFrame();
+}
+
+extern "C" void ImGui_SDLGPU3_RenderDrawData(ImDrawData* draw_data, SDL_GPUCommandBuffer* command_buffer, SDL_GPURenderPass* render_pass, SDL_GPUGraphicsPipeline* pipeline)
+{
+    ImGui_ImplSDLGPU3_RenderDrawData(draw_data, command_buffer, render_pass, nullptr);
+}
+
+extern "C" void Imgui_SDL3_PrepareRender(ImDrawData* draw_data, SDL_GPUCommandBuffer* command_buffer)
+{
+    Imgui_ImplSDLGPU3_PrepareDrawData(draw_data, command_buffer);
+}
diff --git a/lib/cimgui/cimgui/imgui/cimgui_compat.h b/lib/cimgui/cimgui/imgui/cimgui_compat.h
new file mode 100644
index 0000000..8f1917c
--- /dev/null
+++ b/lib/cimgui/cimgui/imgui/cimgui_compat.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <SDL3/SDL.h>
+
+#if __cplusplus
+extern "C"{
+#endif
+void Imgui_SDL3_Init(SDL_Window* window, SDL_GPUDevice* gpu_device);
+void Imgui_SDL3_ProcessEvent(SDL_Event* Event);
+void Imgui_SDL3_NewFrame();
+void ImGui_SDLGPU3_RenderDrawData(ImDrawData* draw_data, SDL_GPUCommandBuffer* command_buffer, SDL_GPURenderPass* render_pass);
+void Imgui_SDL3_PrepareRender(ImDrawData* draw_data, SDL_GPUCommandBuffer* command_buffer);
+
+#if __cplusplus
+}
+#endif
diff --git a/lib/cimgui/cimplot/cimplot.h b/lib/cimgui/cimplot/cimplot.h
index 56e4b80..450b2bf 100644
--- a/lib/cimgui/cimplot/cimplot.h
+++ b/lib/cimgui/cimplot/cimplot.h
@@ -28,11 +28,11 @@ typedef struct ImVector_ImS64 {int Size;int Capacity;ImS64* Data;} ImVector_ImS6
 
 typedef struct ImVector_ImS8 {int Size;int Capacity;ImS8* Data;} ImVector_ImS8;
 
-typedef struct ImVector_ImU16 {int Size;int Capacity;ImU16* Data;} ImVector_ImU16;
+// typedef struct ImVector_ImU16 {int Size;int Capacity;ImU16* Data;} ImVector_ImU16;
 
 typedef struct ImVector_ImU64 {int Size;int Capacity;ImU64* Data;} ImVector_ImU64;
 
-typedef struct ImVector_ImU8 {int Size;int Capacity;ImU8* Data;} ImVector_ImU8;
+// typedef struct ImVector_ImU8 {int Size;int Capacity;ImU8* Data;} ImVector_ImU8;
 
 struct ImPlotContext;
 typedef int ImAxis;
diff --git a/lib/cimgui/src/cimgui.zig b/lib/cimgui/src/cimgui.zig
index 1ff1859..479b384 100644
--- a/lib/cimgui/src/cimgui.zig
+++ b/lib/cimgui/src/cimgui.zig
@@ -81,10 +81,10 @@ pub const Wchar = c_ushort; // ImWchar;
 pub const Wchar16 = c_ushort; // ImWchar16;
 pub const Wchar32 = c_int; // ImWchar32;
 
-pub const InputTextCallback = *fn (data: *InputTextCallbackData) c_int; // ImGuiInputTextCallback
-pub const SizeCallback = *fn (data: *SizeCallbackData) void; // ImGuiInputTextCallback
-pub const MemAllocFunc = *fn (sz: usize, user_data: ?*anyopaque) ?*anyopaque; // ImGuiMemAllocFunc
-pub const MemFreeFunc = *fn (ptr: ?*anyopaque, user_data: ?*anyopaque) void; // ImMemAllocFunction
+pub const InputTextCallback = *const fn (data: *InputTextCallbackData) callconv(.C) c_int; // ImGuiInputTextCallback
+pub const SizeCallback = *const fn (data: *SizeCallbackData) callconv(.C) void; // ImGuiInputTextCallback
+pub const MemAllocFunc = *const fn (sz: usize, user_data: ?*anyopaque) callconv(.C) ?*anyopaque; // ImGuiMemAllocFunc
+pub const MemFreeFunc = *const fn (ptr: ?*anyopaque, user_data: ?*anyopaque) callconv(.C) void; // ImMemAllocFunction
 
 pub const Vec2 = extern struct { // ImVec2
     x: f32 = 0,
@@ -550,7 +550,7 @@ pub const Key = enum(c_int) {
     // KeysData_OFFSET = 0,
 };
 
-pub const NamedKeyCOUNT = Key.COUNT - 512;
+pub const NamedKeyCOUNT = @intFromEnum(Key.COUNT) - 512;
 
 pub const KeyPrivate = enum(c_int) {
     LegacyNative_BEGIN = 0,
@@ -1094,7 +1094,7 @@ pub const PlatformIO = extern struct { // struct ImGuiPlatformIO
     platform_swap_buffers: *const fn ([*c]Viewport, ?*anyopaque) callconv(.C) void,
     platform_get_window_dpi_scale: *const fn ([*c]Viewport) callconv(.C) f32,
     platform_on_changed_viewport: *const fn ([*c]Viewport) callconv(.C) void,
-    platform_create_vk_surface: *const fn ([*c]Viewport, U64, [*c]const void, [*c]U64) callconv(.C) c_int,
+    platform_create_vk_surface: *const fn ([*c]Viewport, U64, ?*const anyopaque, [*c]U64) callconv(.C) c_int,
     renderer_create_window: *const fn ([*c]Viewport) callconv(.C) void,
     renderer_destroy_window: *const fn ([*c]Viewport) callconv(.C) void,
     renderer_set_window_size: *const fn ([*c]Viewport, Vec2) callconv(.C) void,
@@ -1569,8 +1569,8 @@ pub const InputTextState = extern struct { // struct ImGuiInputTextState
 
 pub const PopupData = extern struct { // struct ImGuiPopupData
     popup_id: ID,
-    window: [*c]Window,
-    source_window: [*c]Window,
+    window: ?*Window,
+    source_window: ?*Window,
     parent_nav_layer: c_int,
     open_frame_count: c_int,
     open_parent_id: ID,
@@ -1631,7 +1631,7 @@ pub const StackSizes = extern struct { // struct ImGuiStackSizes
 };
 
 pub const WindowStackData = extern struct { // struct ImGuiWindowStackData
-    window: [*c]Window,
+    window: ?*Window,
     parent_last_item_data_backup: LastItemData,
     stack_sizes_on_begin: StackSizes,
 };
@@ -1716,7 +1716,7 @@ pub const ListClipperRangeVector = extern struct { // struct ImVector_ImGuiListC
 };
 
 pub const NavItemData = extern struct { // struct ImGuiNavItemData
-    window: [*c]Window,
+    window: ?*Window,
     id: ID,
     focus_scope_id: ID,
     rect_rel: Rect,
@@ -1742,7 +1742,7 @@ pub const OldColumnDataVector = extern struct { // struct ImVector_ImGuiOldColum
 pub const WindowPtrVector = extern struct { // struct ImVector_ImGuiWindowPtr
     size: c_int,
     capacity: c_int,
-    data: [*c]Window,
+    data: ?*Window,
 };
 
 pub const WindowDockStyle = extern struct { // struct ImGuiWindowDockStyle
@@ -1779,7 +1779,7 @@ pub const ViewportP = extern struct { // struct ImGuiViewportP
     last_alpha: f32,
     platform_monitor: c_short,
     platform_window_created: bool,
-    window: [*c]Window,
+    window: ?*Window,
     draw_lists_last_frame: [2]c_int,
     draw_lists: [2][*c]DrawList,
     draw_data_p: DrawData,
@@ -1809,12 +1809,12 @@ pub const WindowSettings = extern struct { // struct ImGuiWindowSettings
 pub const SettingsHandler = extern struct { // struct ImGuiSettingsHandler
     type_name: [*c]const u8,
     type_hash: ID,
-    clear_all_fn: *const fn ([*c]Context, [*c]SettingsHandler) void,
-    read_init_fn: *const fn ([*c]Context, [*c]SettingsHandler) void,
-    read_open_fn: *const fn ([*c]Context, [*c]SettingsHandler, [*c]const u8) ?*anyopaque,
-    read_line_fn: *const fn ([*c]Context, [*c]SettingsHandler, ?*anyopaque, [*c]const u8) void,
-    apply_all_fn: *const fn ([*c]Context, [*c]SettingsHandler) void,
-    write_all_fn: *const fn ([*c]Context, [*c]SettingsHandler, [*c]TextBuffer) void,
+    clear_all_fn: *const fn (?*Context, [*c]SettingsHandler) void,
+    read_init_fn: *const fn (?*Context, [*c]SettingsHandler) void,
+    read_open_fn: *const fn (?*Context, [*c]SettingsHandler, [*c]const u8) ?*anyopaque,
+    read_line_fn: *const fn (?*Context, [*c]SettingsHandler, ?*anyopaque, [*c]const u8) void,
+    apply_all_fn: *const fn (?*Context, [*c]SettingsHandler) void,
+    write_all_fn: *const fn (?*Context, [*c]SettingsHandler, [*c]TextBuffer) void,
     user_data: ?*anyopaque,
 };
 
@@ -1863,7 +1863,7 @@ pub const InputEventVector = extern struct { // struct ImVector_ImGuiInputEvent
 pub const WindowStackDataVector = extern struct { // struct ImVector_ImGuiWindowStackData
     size: c_int,
     capacity: c_int,
-    data: [*c]WindowStackData,
+    data: ?*WindowStackData,
 };
 
 pub const ColorModVector = extern struct { // struct ImVector_ImGuiColorMod
@@ -1875,7 +1875,7 @@ pub const ColorModVector = extern struct { // struct ImVector_ImGuiColorMod
 pub const StyleModVector = extern struct { // struct ImGuiStyleMod
     size: c_int,
     capacity: c_int,
-    data: [*c]StyleMod,
+    data: ?*StyleMod,
 };
 
 pub const IDVector = extern struct { // struct ImGuiID
@@ -1999,7 +1999,7 @@ pub const TableSettingsChunkStream = extern struct { // struct ImChunkStream_ImG
 pub const TabItem = extern struct { // struct ImGuiTabItem
     i_d: ID,
     flags: TabItemFlags,
-    window: [*c]Window,
+    window: ?*Window,
     last_frame_visible: c_int,
     last_frame_selected: c_int,
     offset: f32,
@@ -2060,7 +2060,7 @@ pub const TableTempData = extern struct { // struct ImGuiTableTempData
     host_backup_item_width: f32,
     host_backup_item_width_stack_size: c_int,
 };
-pub const ContextHookCallback = *const fn ([*c]Context, [*c]ContextHook) void;
+pub const ContextHookCallback = *const fn (?*Context, [*c]ContextHook) void;
 
 pub const TableSettings = extern struct { // struct ImGuiTableSettings
     id: ID,
@@ -2119,240 +2119,7 @@ pub const TextBuffer = extern struct { // struct ImGuiTextBuffer
 pub const TableColumnIdx = S8; // ImGuiTableColumnIdx
 pub const TableDrawChannelIdx = U8; // ImGuiTableDrawChannelIdx
 
-pub const Context = extern struct { // struct ImGuiContext
-    initialized: bool,
-    font_atlas_owned_by_context: bool,
-    io: Io,
-    platform_i_o: PlatformIO,
-    input_events_queue: InputEventVector,
-    input_events_trail: InputEventVector,
-    style: Style,
-    config_flags_curr_frame: ConfigFlags,
-    config_flags_last_frame: ConfigFlags,
-    font: [*c]Font,
-    font_size: f32,
-    font_base_size: f32,
-    draw_list_shared_data: DrawListSharedData,
-    time: f64,
-    frame_count: c_int,
-    frame_count_ended: c_int,
-    frame_count_platform_ended: c_int,
-    frame_count_rendered: c_int,
-    within_frame_scope: bool,
-    within_frame_scope_with_implicit_window: bool,
-    within_end_child: bool,
-    gc_compact_all: bool,
-    test_engine_hook_items: bool,
-    test_engine: ?*anyopaque,
-    windows: WindowPtrVector,
-    windows_focus_order: WindowPtrVector,
-    windows_temp_sort_buffer: WindowPtrVector,
-    current_window_stack: WindowStackDataVector,
-    windows_by_id: Storage,
-    windows_active_count: c_int,
-    windows_hover_padding: Vec2,
-    current_window: [*c]Window,
-    hovered_window: [*c]Window,
-    hovered_window_under_moving_window: [*c]Window,
-    hovered_dock_node: [*c]DockNode,
-    moving_window: [*c]Window,
-    wheeling_window: [*c]Window,
-    wheeling_window_ref_mouse_pos: Vec2,
-    wheeling_window_timer: f32,
-    debug_hook_id_info: ID,
-    hovered_id: ID,
-    hovered_id_previous_frame: ID,
-    hovered_id_allow_overlap: bool,
-    hovered_id_using_mouse_wheel: bool,
-    hovered_id_previous_frame_using_mouse_wheel: bool,
-    hovered_id_disabled: bool,
-    hovered_id_timer: f32,
-    hovered_id_not_active_timer: f32,
-    active_id: ID,
-    active_id_is_alive: ID,
-    active_id_timer: f32,
-    active_id_is_just_activated: bool,
-    active_id_allow_overlap: bool,
-    active_id_no_clear_on_focus_loss: bool,
-    active_id_has_been_pressed_before: bool,
-    active_id_has_been_edited_before: bool,
-    active_id_has_been_edited_this_frame: bool,
-    active_id_click_offset: Vec2,
-    active_id_window: [*c]Window,
-    active_id_source: InputSource,
-    active_id_mouse_button: c_int,
-    active_id_previous_frame: ID,
-    active_id_previous_frame_is_alive: bool,
-    active_id_previous_frame_has_been_edited_before: bool,
-    active_id_previous_frame_window: [*c]Window,
-    last_active_id: ID,
-    last_active_id_timer: f32,
-    active_id_using_mouse_wheel: bool,
-    active_id_using_nav_dir_mask: U32,
-    active_id_using_nav_input_mask: U32,
-    active_id_using_key_input_mask: BitArrayForNamedKeys,
-    current_item_flags: ItemFlags,
-    next_item_data: NextItemData,
-    last_item_data: LastItemData,
-    next_window_data: NextWindowData,
-    color_stack: ColorModVector,
-    style_var_stack: StyleModVector,
-    font_stack: FontPtrVector,
-    focus_scope_stack: IDVector,
-    item_flags_stack: ItemFlagsVector,
-    group_stack: GroupDataVector,
-    open_popup_stack: PopupDataVector,
-    begin_popup_stack: PopupDataVector,
-    begin_menu_count: c_int,
-    viewports: ViewportPPtrVector,
-    current_dpi_scale: f32,
-    current_viewport: [*c]ViewportP,
-    mouse_viewport: [*c]ViewportP,
-    mouse_last_hovered_viewport: [*c]ViewportP,
-    platform_last_focused_viewport_id: ID,
-    fallback_monitor: PlatformMonitor,
-    viewport_front_most_stamp_count: c_int,
-    nav_window: [*c]Window,
-    nav_id: ID,
-    nav_focus_scope_id: ID,
-    nav_activate_id: ID,
-    nav_activate_down_id: ID,
-    nav_activate_pressed_id: ID,
-    nav_activate_input_id: ID,
-    nav_activate_flags: ActivateFlags,
-    nav_just_moved_to_id: ID,
-    nav_just_moved_to_focus_scope_id: ID,
-    nav_just_moved_to_key_mods: ModFlags,
-    nav_next_activate_id: ID,
-    nav_next_activate_flags: ActivateFlags,
-    nav_input_source: InputSource,
-    nav_layer: NavLayer,
-    nav_id_is_alive: bool,
-    nav_mouse_pos_dirty: bool,
-    nav_disable_highlight: bool,
-    nav_disable_mouse_hover: bool,
-    nav_any_request: bool,
-    nav_init_request: bool,
-    nav_init_request_from_move: bool,
-    nav_init_result_id: ID,
-    nav_init_result_rect_rel: Rect,
-    nav_move_submitted: bool,
-    nav_move_scoring_items: bool,
-    nav_move_forward_to_next_frame: bool,
-    nav_move_flags: NavMoveFlags,
-    nav_move_scroll_flags: ScrollFlags,
-    nav_move_key_mods: ModFlags,
-    nav_move_dir: Dir,
-    nav_move_dir_for_debug: Dir,
-    nav_move_clip_dir: Dir,
-    nav_scoring_rect: Rect,
-    nav_scoring_no_clip_rect: Rect,
-    nav_scoring_debug_count: c_int,
-    nav_tabbing_dir: c_int,
-    nav_tabbing_counter: c_int,
-    nav_move_result_local: NavItemData,
-    nav_move_result_local_visible: NavItemData,
-    nav_move_result_other: NavItemData,
-    nav_tabbing_result_first: NavItemData,
-    nav_windowing_target: [*c]Window,
-    nav_windowing_target_anim: [*c]Window,
-    nav_windowing_list_window: [*c]Window,
-    nav_windowing_timer: f32,
-    nav_windowing_highlight_alpha: f32,
-    nav_windowing_toggle_layer: bool,
-    dim_bg_ratio: f32,
-    mouse_cursor: MouseCursor,
-    drag_drop_active: bool,
-    drag_drop_within_source: bool,
-    drag_drop_within_target: bool,
-    drag_drop_source_flags: DragDropFlags,
-    drag_drop_source_frame_count: c_int,
-    drag_drop_mouse_button: c_int,
-    drag_drop_payload: Payload,
-    drag_drop_target_rect: Rect,
-    drag_drop_target_id: ID,
-    drag_drop_accept_flags: DragDropFlags,
-    drag_drop_accept_id_curr_rect_surface: f32,
-    drag_drop_accept_id_curr: ID,
-    drag_drop_accept_id_prev: ID,
-    drag_drop_accept_frame_count: c_int,
-    drag_drop_hold_just_pressed_id: ID,
-    drag_drop_payload_buf_heap: u8Vector,
-    drag_drop_payload_buf_local: [16]u8,
-    clipper_temp_data_stacked: c_int,
-    clipper_temp_data: ListClipperDataVector,
-    current_table: [*c]Table,
-    tables_temp_data_stacked: c_int,
-    tables_temp_data: TableTempDataVector,
-    tables: Table,
-    tables_last_time_active: f32Vector,
-    draw_channels_temp_merge_buffer: DrawChannelVector,
-    current_tab_bar: [*c]TabBar,
-    tab_bars: TabBar,
-    current_tab_bar_stack: PtrOrIndexVector,
-    shrink_width_buffer: ShrinkWidthItemVector,
-    mouse_last_valid_pos: Vec2,
-    input_text_state: InputTextState,
-    input_text_password_font: Font,
-    temp_input_id: ID,
-    color_edit_options: ColorEditFlags,
-    color_edit_last_hue: f32,
-    color_edit_last_sat: f32,
-    color_edit_last_color: U32,
-    color_picker_ref: Vec4,
-    combo_preview_data: ComboPreviewData,
-    slider_grab_click_offset: f32,
-    slider_current_accum: f32,
-    slider_current_accum_dirty: bool,
-    drag_current_accum_dirty: bool,
-    drag_current_accum: f32,
-    drag_speed_default_ratio: f32,
-    scrollbar_click_delta_to_grab_center: f32,
-    disabled_alpha_backup: f32,
-    disabled_stack_size: c_short,
-    tooltip_override_count: c_short,
-    tooltip_slow_delay: f32,
-    clipboard_handler_data: u8Vector,
-    menus_id_submitted_this_frame: IDVector,
-    platform_ime_data: PlatformImeData,
-    platform_ime_data_prev: PlatformImeData,
-    platform_ime_viewport: ID,
-    platform_locale_decimal_point: u8,
-    dock_context: DockContext,
-    settings_loaded: bool,
-    settings_dirty_timer: f32,
-    settings_ini_data: TextBuffer,
-    settings_handlers: SettingsHandlerVector,
-    settings_windows: WindowSettings,
-    settings_tables: TableSettings,
-    hooks: ContextHookVector,
-    hook_id_next: ID,
-    log_enabled: bool,
-    log_type: LogType,
-    log_file: FileHandle,
-    log_buffer: TextBuffer,
-    log_next_prefix: [*c]const u8,
-    log_next_suffix: [*c]const u8,
-    log_line_pos_y: f32,
-    log_line_first_item: bool,
-    log_depth_ref: c_int,
-    log_depth_to_expand: c_int,
-    log_depth_to_expand_default: c_int,
-    debug_log_flags: DebugLogFlags,
-    debug_log_buf: TextBuffer,
-    debug_item_picker_active: bool,
-    debug_item_picker_break_id: ID,
-    debug_metrics_config: MetricsConfig,
-    debug_stack_tool: StackTool,
-    framerate_sec_per_frame: [120]f32,
-    framerate_sec_per_frame_idx: c_int,
-    framerate_sec_per_frame_count: c_int,
-    framerate_sec_per_frame_accum: f32,
-    want_capture_mouse_next_frame: c_int,
-    want_capture_keyboard_next_frame: c_int,
-    want_text_input_next_frame: c_int,
-    temp_buffer: u8Vector,
-};
+pub const Context = opaque {};
 
 pub const DrawChannelVector = extern struct { // struct ImVector_ImDrawChannel
     size: c_int,
@@ -2409,11 +2176,11 @@ pub const ListClipper = extern struct { // struct ImGuiListClipper
     temp_data: ?*anyopaque,
 };
 
-pub const Storage = struct { // struct ImGuiStorage
+pub const Storage = extern struct { // struct ImGuiStorage
     data: StoragePairVector,
 };
 
-pub const StoragePairVector = struct {
+pub const StoragePairVector = extern struct {
     size: c_int,
     capacity: c_int,
     data: ?*StoragePair,
@@ -2519,20 +2286,20 @@ pub const DrawListSplitter = extern struct { // struct ImDrawListSplitter
     _channels: DrawChannelVector,
 };
 
-pub inline fn createContext(shared_font_atlas: [*c]FontAtlas) [*c]Context { //igCreateContext
-    return c.igCreateContext(shared_font_atlas);
+pub inline fn createContext(shared_font_atlas: [*c]FontAtlas) ?*Context { //igCreateContext
+    return @ptrCast(c.igCreateContext(@ptrCast(shared_font_atlas)));
 }
-pub inline fn destroyContext(ctx: [*c]Context) void { //igDestroyContext
+pub inline fn destroyContext(ctx: ?*Context) void { //igDestroyContext
     c.igDestroyContext(ctx);
 }
 pub inline fn getCurrentContext() ?*Context { //igGetCurrentContext
     return @ptrCast(c.igGetCurrentContext());
 }
-pub inline fn setCurrentContext(ctx: [*c]Context) void { //igSetCurrentContext
+pub inline fn setCurrentContext(ctx: ?*Context) void { //igSetCurrentContext
     c.igSetCurrentContext(ctx);
 }
 pub inline fn getIO() ?*Io { //igGetIO
-    return @ptrCast(c.igGetIO());
+    return @ptrCast(c.igGetIO_Nil());
 }
 pub inline fn getStyle() ?*Style { //igGetStyle
     return @ptrCast(c.igGetStyle());
@@ -2547,7 +2314,7 @@ pub inline fn render() void { //igRender
     c.igRender();
 }
 pub inline fn getDrawData() [*c]DrawData { //igGetDrawData
-    return c.igGetDrawData();
+    return @ptrCast(c.igGetDrawData());
 }
 pub inline fn showDemoWindow(p_open: [*c]bool) void { //igShowDemoWindow
     c.igShowDemoWindow(p_open);
@@ -3789,76 +3556,76 @@ pub inline fn imBitArraySetBit(arr: [*c]U32, n: c_int) void { //igImBitArraySetB
 pub inline fn imBitArraySetBitRange(arr: [*c]U32, n: c_int, n2: c_int) void { //igImBitArraySetBitRange
     c.igImBitArraySetBitRange(arr, n, n2);
 }
-pub inline fn getCurrentWindowRead() [*c]Window { //igGetCurrentWindowRead
+pub inline fn getCurrentWindowRead() ?*Window { //igGetCurrentWindowRead
     return c.igGetCurrentWindowRead();
 }
-pub inline fn getCurrentWindow() [*c]Window { //igGetCurrentWindow
+pub inline fn getCurrentWindow() ?*Window { //igGetCurrentWindow
     return c.igGetCurrentWindow();
 }
-pub inline fn findWindowByID(id: ID) [*c]Window { //igFindWindowByID
+pub inline fn findWindowByID(id: ID) ?*Window { //igFindWindowByID
     return c.igFindWindowByID(id);
 }
-pub inline fn findWindowByName(name: [*c]const u8) [*c]Window { //igFindWindowByName
+pub inline fn findWindowByName(name: [*c]const u8) ?*Window { //igFindWindowByName
     return c.igFindWindowByName(name);
 }
-pub inline fn updateWindowParentAndRootLinks(window: [*c]Window, flags: WindowFlags, parent_window: [*c]Window) void { //igUpdateWindowParentAndRootLinks
+pub inline fn updateWindowParentAndRootLinks(window: ?*Window, flags: WindowFlags, parent_window: ?*Window) void { //igUpdateWindowParentAndRootLinks
     c.igUpdateWindowParentAndRootLinks(window, @bitCast(flags), parent_window);
 }
-pub inline fn calcWindowNextAutoFitSize(pout: [*c]Vec2, window: [*c]Window) void { //igCalcWindowNextAutoFitSize
+pub inline fn calcWindowNextAutoFitSize(pout: [*c]Vec2, window: ?*Window) void { //igCalcWindowNextAutoFitSize
     c.igCalcWindowNextAutoFitSize(pout, window);
 }
-pub inline fn isWindowChildOf(window: [*c]Window, potential_parent: [*c]Window, popup_hierarchy: bool, dock_hierarchy: bool) bool { //igIsWindowChildOf
+pub inline fn isWindowChildOf(window: ?*Window, potential_parent: ?*Window, popup_hierarchy: bool, dock_hierarchy: bool) bool { //igIsWindowChildOf
     return c.igIsWindowChildOf(window, potential_parent, popup_hierarchy, dock_hierarchy);
 }
-pub inline fn isWindowWithinBeginStackOf(window: [*c]Window, potential_parent: [*c]Window) bool { //igIsWindowWithinBeginStackOf
+pub inline fn isWindowWithinBeginStackOf(window: ?*Window, potential_parent: ?*Window) bool { //igIsWindowWithinBeginStackOf
     return c.igIsWindowWithinBeginStackOf(window, potential_parent);
 }
-pub inline fn isWindowAbove(potential_above: [*c]Window, potential_below: [*c]Window) bool { //igIsWindowAbove
+pub inline fn isWindowAbove(potential_above: ?*Window, potential_below: ?*Window) bool { //igIsWindowAbove
     return c.igIsWindowAbove(potential_above, potential_below);
 }
-pub inline fn isWindowNavFocusable(window: [*c]Window) bool { //igIsWindowNavFocusable
+pub inline fn isWindowNavFocusable(window: ?*Window) bool { //igIsWindowNavFocusable
     return c.igIsWindowNavFocusable(window);
 }
-pub inline fn setWindowPos_WindowPtr(window: [*c]Window, pos: Vec2, cond: Cond) void { //igSetWindowPos_WindowPtr
+pub inline fn setWindowPos_WindowPtr(window: ?*Window, pos: Vec2, cond: Cond) void { //igSetWindowPos_WindowPtr
     c.igSetWindowPos_WindowPtr(window, @bitCast(pos), @bitCast(cond));
 }
-pub inline fn setWindowSize_WindowPtr(window: [*c]Window, size: Vec2, cond: Cond) void { //igSetWindowSize_WindowPtr
+pub inline fn setWindowSize_WindowPtr(window: ?*Window, size: Vec2, cond: Cond) void { //igSetWindowSize_WindowPtr
     c.igSetWindowSize_WindowPtr(window, @bitCast(size), @bitCast(cond));
 }
-pub inline fn setWindowCollapsed_WindowPtr(window: [*c]Window, collapsed: bool, cond: Cond) void { //igSetWindowCollapsed_WindowPtr
+pub inline fn setWindowCollapsed_WindowPtr(window: ?*Window, collapsed: bool, cond: Cond) void { //igSetWindowCollapsed_WindowPtr
     c.igSetWindowCollapsed_WindowPtr(window, collapsed, @bitCast(cond));
 }
-pub inline fn setWindowHitTestHole(window: [*c]Window, pos: Vec2, size: Vec2) void { //igSetWindowHitTestHole
+pub inline fn setWindowHitTestHole(window: ?*Window, pos: Vec2, size: Vec2) void { //igSetWindowHitTestHole
     c.igSetWindowHitTestHole(window, @bitCast(pos), @bitCast(size));
 }
-pub inline fn windowRectAbsToRel(pout: [*c]Rect, window: [*c]Window, r: Rect) void { //igWindowRectAbsToRel
+pub inline fn windowRectAbsToRel(pout: [*c]Rect, window: ?*Window, r: Rect) void { //igWindowRectAbsToRel
     c.igWindowRectAbsToRel(pout, window, @bitCast(r));
 }
-pub inline fn windowRectRelToAbs(pout: [*c]Rect, window: [*c]Window, r: Rect) void { //igWindowRectRelToAbs
+pub inline fn windowRectRelToAbs(pout: [*c]Rect, window: ?*Window, r: Rect) void { //igWindowRectRelToAbs
     c.igWindowRectRelToAbs(pout, window, @bitCast(r));
 }
-pub inline fn focusWindow(window: [*c]Window) void { //igFocusWindow
+pub inline fn focusWindow(window: ?*Window) void { //igFocusWindow
     c.igFocusWindow(window);
 }
-pub inline fn focusTopMostWindowUnderOne(under_this_window: [*c]Window, ignore_window: [*c]Window) void { //igFocusTopMostWindowUnderOne
+pub inline fn focusTopMostWindowUnderOne(under_this_window: ?*Window, ignore_window: ?*Window) void { //igFocusTopMostWindowUnderOne
     c.igFocusTopMostWindowUnderOne(under_this_window, ignore_window);
 }
-pub inline fn bringWindowToFocusFront(window: [*c]Window) void { //igBringWindowToFocusFront
+pub inline fn bringWindowToFocusFront(window: ?*Window) void { //igBringWindowToFocusFront
     c.igBringWindowToFocusFront(window);
 }
-pub inline fn bringWindowToDisplayFront(window: [*c]Window) void { //igBringWindowToDisplayFront
+pub inline fn bringWindowToDisplayFront(window: ?*Window) void { //igBringWindowToDisplayFront
     c.igBringWindowToDisplayFront(window);
 }
-pub inline fn bringWindowToDisplayBack(window: [*c]Window) void { //igBringWindowToDisplayBack
+pub inline fn bringWindowToDisplayBack(window: ?*Window) void { //igBringWindowToDisplayBack
     c.igBringWindowToDisplayBack(window);
 }
-pub inline fn bringWindowToDisplayBehind(window: [*c]Window, above_window: [*c]Window) void { //igBringWindowToDisplayBehind
+pub inline fn bringWindowToDisplayBehind(window: ?*Window, above_window: ?*Window) void { //igBringWindowToDisplayBehind
     c.igBringWindowToDisplayBehind(window, above_window);
 }
-pub inline fn findWindowDisplayIndex(window: [*c]Window) c_int { //igFindWindowDisplayIndex
+pub inline fn findWindowDisplayIndex(window: ?*Window) c_int { //igFindWindowDisplayIndex
     return c.igFindWindowDisplayIndex(window);
 }
-pub inline fn findBottomMostVisibleWindowWithinBeginStack(window: [*c]Window) [*c]Window { //igFindBottomMostVisibleWindowWithinBeginStack
+pub inline fn findBottomMostVisibleWindowWithinBeginStack(window: ?*Window) ?*Window { //igFindBottomMostVisibleWindowWithinBeginStack
     return c.igFindBottomMostVisibleWindowWithinBeginStack(window);
 }
 pub inline fn setCurrentFont(font: [*c]Font) void { //igSetCurrentFont
@@ -3867,7 +3634,7 @@ pub inline fn setCurrentFont(font: [*c]Font) void { //igSetCurrentFont
 pub inline fn getDefaultFont() [*c]Font { //igGetDefaultFont
     return c.igGetDefaultFont();
 }
-pub inline fn getForegroundDrawList_WindowPtr(window: [*c]Window) [*c]DrawList { //igGetForegroundDrawList_WindowPtr
+pub inline fn getForegroundDrawList_WindowPtr(window: ?*Window) [*c]DrawList { //igGetForegroundDrawList_WindowPtr
     return c.igGetForegroundDrawList_WindowPtr(window);
 }
 pub inline fn initialize() void { //igInitialize
@@ -3882,10 +3649,10 @@ pub inline fn updateInputEvents(trickle_fast_inputs: bool) void { //igUpdateInpu
 pub inline fn updateHoveredWindowAndCaptureFlags() void { //igUpdateHoveredWindowAndCaptureFlags
     c.igUpdateHoveredWindowAndCaptureFlags();
 }
-pub inline fn startMouseMovingWindow(window: [*c]Window) void { //igStartMouseMovingWindow
+pub inline fn startMouseMovingWindow(window: ?*Window) void { //igStartMouseMovingWindow
     c.igStartMouseMovingWindow(window);
 }
-pub inline fn startMouseMovingWindowOrNode(window: [*c]Window, node: [*c]DockNode, undock_floating_node: bool) void { //igStartMouseMovingWindowOrNode
+pub inline fn startMouseMovingWindowOrNode(window: ?*Window, node: [*c]DockNode, undock_floating_node: bool) void { //igStartMouseMovingWindowOrNode
     c.igStartMouseMovingWindowOrNode(window, node, undock_floating_node);
 }
 pub inline fn updateMouseMovingWindowNewFrame() void { //igUpdateMouseMovingWindowNewFrame
@@ -3894,13 +3661,13 @@ pub inline fn updateMouseMovingWindowNewFrame() void { //igUpdateMouseMovingWind
 pub inline fn updateMouseMovingWindowEndFrame() void { //igUpdateMouseMovingWindowEndFrame
     c.igUpdateMouseMovingWindowEndFrame();
 }
-pub inline fn addContextHook(context: [*c]Context, hook: [*c]const ContextHook) ID { //igAddContextHook
+pub inline fn addContextHook(context: ?*Context, hook: [*c]const ContextHook) ID { //igAddContextHook
     return c.igAddContextHook(context, hook);
 }
-pub inline fn removeContextHook(context: [*c]Context, hook_to_remove: ID) void { //igRemoveContextHook
+pub inline fn removeContextHook(context: ?*Context, hook_to_remove: ID) void { //igRemoveContextHook
     c.igRemoveContextHook(context, hook_to_remove);
 }
-pub inline fn callContextHooks(context: [*c]Context, t: ContextHookType) void { //igCallContextHooks
+pub inline fn callContextHooks(context: ?*Context, t: ContextHookType) void { //igCallContextHooks
     c.igCallContextHooks(context, @intFromEnum(t));
 }
 pub inline fn translateWindowsInViewport(viewport: [*c]ViewportP, old_pos: Vec2, new_pos: Vec2) void { //igTranslateWindowsInViewport
@@ -3912,10 +3679,10 @@ pub inline fn scaleWindowsInViewport(viewport: [*c]ViewportP, scale: f32) void {
 pub inline fn destroyPlatformWindow(viewport: [*c]ViewportP) void { //igDestroyPlatformWindow
     c.igDestroyPlatformWindow(viewport);
 }
-pub inline fn setWindowViewport(window: [*c]Window, viewport: [*c]ViewportP) void { //igSetWindowViewport
+pub inline fn setWindowViewport(window: ?*Window, viewport: [*c]ViewportP) void { //igSetWindowViewport
     c.igSetWindowViewport(window, viewport);
 }
-pub inline fn setCurrentViewport(window: [*c]Window, viewport: [*c]ViewportP) void { //igSetCurrentViewport
+pub inline fn setCurrentViewport(window: ?*Window, viewport: [*c]ViewportP) void { //igSetCurrentViewport
     c.igSetCurrentViewport(window, viewport);
 }
 pub inline fn getViewportPlatformMonitor(viewport: [*c]Viewport) [*c]const PlatformMonitor { //igGetViewportPlatformMonitor
@@ -3927,19 +3694,19 @@ pub inline fn findHoveredViewportFromPlatformWindowStack(mouse_platform_pos: Vec
 pub inline fn markIniSettingsDirty_Nil() void { //igMarkIniSettingsDirty_Nil
     c.igMarkIniSettingsDirty_Nil();
 }
-pub inline fn markIniSettingsDirty_WindowPtr(window: [*c]Window) void { //igMarkIniSettingsDirty_WindowPtr
+pub inline fn markIniSettingsDirty_WindowPtr(window: ?*Window) void { //igMarkIniSettingsDirty_WindowPtr
     c.igMarkIniSettingsDirty_WindowPtr(window);
 }
 pub inline fn clearIniSettings() void { //igClearIniSettings
     c.igClearIniSettings();
 }
-pub inline fn createNewWindowSettings(name: [*c]const u8) [*c]WindowSettings { //igCreateNewWindowSettings
+pub inline fn createNewWindowSettings(name: [*c]const u8) ?*WindowSettings { //igCreateNewWindowSettings
     return c.igCreateNewWindowSettings(name);
 }
-pub inline fn findWindowSettings(id: ID) [*c]WindowSettings { //igFindWindowSettings
+pub inline fn findWindowSettings(id: ID) ?*WindowSettings { //igFindWindowSettings
     return c.igFindWindowSettings(id);
 }
-pub inline fn findOrCreateWindowSettings(name: [*c]const u8) [*c]WindowSettings { //igFindOrCreateWindowSettings
+pub inline fn findOrCreateWindowSettings(name: [*c]const u8) ?*WindowSettings { //igFindOrCreateWindowSettings
     return c.igFindOrCreateWindowSettings(name);
 }
 pub inline fn addSettingsHandler(handler: [*c]const SettingsHandler) void { //igAddSettingsHandler
@@ -3954,28 +3721,28 @@ pub inline fn findSettingsHandler(type_name: [*c]const u8) [*c]SettingsHandler {
 pub inline fn setNextWindowScroll(scroll: Vec2) void { //igSetNextWindowScroll
     c.igSetNextWindowScroll(@bitCast(scroll));
 }
-pub inline fn setScrollX_WindowPtr(window: [*c]Window, scroll_x: f32) void { //igSetScrollX_WindowPtr
+pub inline fn setScrollX_WindowPtr(window: ?*Window, scroll_x: f32) void { //igSetScrollX_WindowPtr
     c.igSetScrollX_WindowPtr(window, scroll_x);
 }
-pub inline fn setScrollY_WindowPtr(window: [*c]Window, scroll_y: f32) void { //igSetScrollY_WindowPtr
+pub inline fn setScrollY_WindowPtr(window: ?*Window, scroll_y: f32) void { //igSetScrollY_WindowPtr
     c.igSetScrollY_WindowPtr(window, scroll_y);
 }
-pub inline fn setScrollFromPosX_WindowPtr(window: [*c]Window, local_x: f32, center_x_ratio: f32) void { //igSetScrollFromPosX_WindowPtr
+pub inline fn setScrollFromPosX_WindowPtr(window: ?*Window, local_x: f32, center_x_ratio: f32) void { //igSetScrollFromPosX_WindowPtr
     c.igSetScrollFromPosX_WindowPtr(window, local_x, center_x_ratio);
 }
-pub inline fn setScrollFromPosY_WindowPtr(window: [*c]Window, local_y: f32, center_y_ratio: f32) void { //igSetScrollFromPosY_WindowPtr
+pub inline fn setScrollFromPosY_WindowPtr(window: ?*Window, local_y: f32, center_y_ratio: f32) void { //igSetScrollFromPosY_WindowPtr
     c.igSetScrollFromPosY_WindowPtr(window, local_y, center_y_ratio);
 }
 pub inline fn scrollToItem(flags: ScrollFlags) void { //igScrollToItem
     c.igScrollToItem(@bitCast(flags));
 }
-pub inline fn scrollToRect(window: [*c]Window, rect: Rect, flags: ScrollFlags) void { //igScrollToRect
+pub inline fn scrollToRect(window: ?*Window, rect: Rect, flags: ScrollFlags) void { //igScrollToRect
     c.igScrollToRect(window, @bitCast(rect), @bitCast(flags));
 }
-pub inline fn scrollToRectEx(pout: [*c]Vec2, window: [*c]Window, rect: Rect, flags: ScrollFlags) void { //igScrollToRectEx
+pub inline fn scrollToRectEx(pout: [*c]Vec2, window: ?*Window, rect: Rect, flags: ScrollFlags) void { //igScrollToRectEx
     c.igScrollToRectEx(pout, window, @bitCast(rect), @bitCast(flags));
 }
-pub inline fn scrollToBringRectIntoView(window: [*c]Window, rect: Rect) void { //igScrollToBringRectIntoView
+pub inline fn scrollToBringRectIntoView(window: ?*Window, rect: Rect) void { //igScrollToBringRectIntoView
     c.igScrollToBringRectIntoView(window, @bitCast(rect));
 }
 pub inline fn getItemID() ID { //igGetItemID
@@ -3993,10 +3760,10 @@ pub inline fn getActiveID() ID { //igGetActiveID
 pub inline fn getFocusID() ID { //igGetFocusID
     return c.igGetFocusID();
 }
-pub inline fn setActiveID(id: ID, window: [*c]Window) void { //igSetActiveID
+pub inline fn setActiveID(id: ID, window: ?*Window) void { //igSetActiveID
     c.igSetActiveID(id, window);
 }
-pub inline fn setFocusID(id: ID, window: [*c]Window) void { //igSetFocusID
+pub inline fn setFocusID(id: ID, window: ?*Window) void { //igSetFocusID
     c.igSetFocusID(id, window);
 }
 pub inline fn clearActiveID() void { //igClearActiveID
@@ -4083,7 +3850,7 @@ pub inline fn openPopupEx(id: ID, popup_flags: PopupFlags) void { //igOpenPopupE
 pub inline fn closePopupToLevel(remaining: c_int, restore_focus_to_window_under_popup: bool) void { //igClosePopupToLevel
     c.igClosePopupToLevel(remaining, restore_focus_to_window_under_popup);
 }
-pub inline fn closePopupsOverWindow(ref_window: [*c]Window, restore_focus_to_window_under_popup: bool) void { //igClosePopupsOverWindow
+pub inline fn closePopupsOverWindow(ref_window: ?*Window, restore_focus_to_window_under_popup: bool) void { //igClosePopupsOverWindow
     c.igClosePopupsOverWindow(ref_window, restore_focus_to_window_under_popup);
 }
 pub inline fn closePopupsExceptModals() void { //igClosePopupsExceptModals
@@ -4098,16 +3865,16 @@ pub inline fn beginPopupEx(id: ID, extra_flags: WindowFlags) bool { //igBeginPop
 pub inline fn beginTooltipEx(tooltip_flags: TooltipFlags, extra_window_flags: WindowFlags) void { //igBeginTooltipEx
     c.igBeginTooltipEx(@bitCast(tooltip_flags), @bitCast(extra_window_flags));
 }
-pub inline fn getPopupAllowedExtentRect(pout: [*c]Rect, window: [*c]Window) void { //igGetPopupAllowedExtentRect
+pub inline fn getPopupAllowedExtentRect(pout: [*c]Rect, window: ?*Window) void { //igGetPopupAllowedExtentRect
     c.igGetPopupAllowedExtentRect(pout, window);
 }
-pub inline fn getTopMostPopupModal() [*c]Window { //igGetTopMostPopupModal
+pub inline fn getTopMostPopupModal() ?*Window { //igGetTopMostPopupModal
     return c.igGetTopMostPopupModal();
 }
-pub inline fn getTopMostAndVisiblePopupModal() [*c]Window { //igGetTopMostAndVisiblePopupModal
+pub inline fn getTopMostAndVisiblePopupModal() ?*Window { //igGetTopMostAndVisiblePopupModal
     return c.igGetTopMostAndVisiblePopupModal();
 }
-pub inline fn findBestWindowPosForPopup(pout: [*c]Vec2, window: [*c]Window) void { //igFindBestWindowPosForPopup
+pub inline fn findBestWindowPosForPopup(pout: [*c]Vec2, window: ?*Window) void { //igFindBestWindowPosForPopup
     c.igFindBestWindowPosForPopup(pout, window);
 }
 pub inline fn findBestWindowPosForPopupEx(pout: [*c]Vec2, ref_pos: Vec2, size: Vec2, last_dir: [*c]Dir, r_outer: Rect, r_avoid: Rect, policy: PopupPositionPolicy) void { //igFindBestWindowPosForPopupEx
@@ -4131,7 +3898,7 @@ pub inline fn beginComboPreview() bool { //igBeginComboPreview
 pub inline fn endComboPreview() void { //igEndComboPreview
     c.igEndComboPreview();
 }
-pub inline fn navInitWindow(window: [*c]Window, force_reinit: bool) void { //igNavInitWindow
+pub inline fn navInitWindow(window: ?*Window, force_reinit: bool) void { //igNavInitWindow
     c.igNavInitWindow(window, force_reinit);
 }
 pub inline fn navInitRequestApplyResult() void { //igNavInitRequestApplyResult
@@ -4155,7 +3922,7 @@ pub inline fn navMoveRequestCancel() void { //igNavMoveRequestCancel
 pub inline fn navMoveRequestApplyResult() void { //igNavMoveRequestApplyResult
     c.igNavMoveRequestApplyResult();
 }
-pub inline fn navMoveRequestTryWrapping(window: [*c]Window, move_flags: NavMoveFlags) void { //igNavMoveRequestTryWrapping
+pub inline fn navMoveRequestTryWrapping(window: ?*Window, move_flags: NavMoveFlags) void { //igNavMoveRequestTryWrapping
     c.igNavMoveRequestTryWrapping(window, @bitCast(move_flags));
 }
 pub inline fn getNavInputName(n: NavInput) [*c]const u8 { //igGetNavInputName
@@ -4173,7 +3940,7 @@ pub inline fn calcTypematicRepeatAmount(t0: f32, t1: f32, repeat_delay: f32, rep
 pub inline fn activateItem(id: ID) void { //igActivateItem
     c.igActivateItem(id);
 }
-pub inline fn setNavWindow(window: [*c]Window) void { //igSetNavWindow
+pub inline fn setNavWindow(window: ?*Window) void { //igSetNavWindow
     c.igSetNavWindow(window);
 }
 pub inline fn setNavID(id: ID, nav_layer: NavLayer, focus_scope_id: ID, rect_rel: Rect) void { //igSetNavID
@@ -4236,40 +4003,40 @@ pub inline fn getMergedModFlags() ModFlags { //igGetMergedModFlags
 pub inline fn isKeyPressedMap(key: Key, repeat: bool) bool { //igIsKeyPressedMap
     return c.igIsKeyPressedMap(@intFromEnum(key), repeat);
 }
-pub inline fn dockContextInitialize(ctx: [*c]Context) void { //igDockContextInitialize
+pub inline fn dockContextInitialize(ctx: ?*Context) void { //igDockContextInitialize
     c.igDockContextInitialize(ctx);
 }
-pub inline fn dockContextShutdown(ctx: [*c]Context) void { //igDockContextShutdown
+pub inline fn dockContextShutdown(ctx: ?*Context) void { //igDockContextShutdown
     c.igDockContextShutdown(ctx);
 }
-pub inline fn dockContextClearNodes(ctx: [*c]Context, root_id: ID, clear_settings_refs: bool) void { //igDockContextClearNodes
+pub inline fn dockContextClearNodes(ctx: ?*Context, root_id: ID, clear_settings_refs: bool) void { //igDockContextClearNodes
     c.igDockContextClearNodes(ctx, root_id, clear_settings_refs);
 }
-pub inline fn dockContextRebuildNodes(ctx: [*c]Context) void { //igDockContextRebuildNodes
+pub inline fn dockContextRebuildNodes(ctx: ?*Context) void { //igDockContextRebuildNodes
     c.igDockContextRebuildNodes(ctx);
 }
-pub inline fn dockContextNewFrameUpdateUndocking(ctx: [*c]Context) void { //igDockContextNewFrameUpdateUndocking
+pub inline fn dockContextNewFrameUpdateUndocking(ctx: ?*Context) void { //igDockContextNewFrameUpdateUndocking
     c.igDockContextNewFrameUpdateUndocking(ctx);
 }
-pub inline fn dockContextNewFrameUpdateDocking(ctx: [*c]Context) void { //igDockContextNewFrameUpdateDocking
+pub inline fn dockContextNewFrameUpdateDocking(ctx: ?*Context) void { //igDockContextNewFrameUpdateDocking
     c.igDockContextNewFrameUpdateDocking(ctx);
 }
-pub inline fn dockContextEndFrame(ctx: [*c]Context) void { //igDockContextEndFrame
+pub inline fn dockContextEndFrame(ctx: ?*Context) void { //igDockContextEndFrame
     c.igDockContextEndFrame(ctx);
 }
-pub inline fn dockContextGenNodeID(ctx: [*c]Context) ID { //igDockContextGenNodeID
+pub inline fn dockContextGenNodeID(ctx: ?*Context) ID { //igDockContextGenNodeID
     return c.igDockContextGenNodeID(ctx);
 }
-pub inline fn dockContextQueueDock(ctx: [*c]Context, target: [*c]Window, target_node: [*c]DockNode, payload: [*c]Window, split_dir: Dir, split_ratio: f32, split_outer: bool) void { //igDockContextQueueDock
+pub inline fn dockContextQueueDock(ctx: ?*Context, target: ?*Window, target_node: [*c]DockNode, payload: ?*Window, split_dir: Dir, split_ratio: f32, split_outer: bool) void { //igDockContextQueueDock
     c.igDockContextQueueDock(ctx, target, target_node, payload, @intFromEnum(split_dir), split_ratio, split_outer);
 }
-pub inline fn dockContextQueueUndockWindow(ctx: [*c]Context, window: [*c]Window) void { //igDockContextQueueUndockWindow
+pub inline fn dockContextQueueUndockWindow(ctx: ?*Context, window: ?*Window) void { //igDockContextQueueUndockWindow
     c.igDockContextQueueUndockWindow(ctx, window);
 }
-pub inline fn dockContextQueueUndockNode(ctx: [*c]Context, node: [*c]DockNode) void { //igDockContextQueueUndockNode
+pub inline fn dockContextQueueUndockNode(ctx: ?*Context, node: [*c]DockNode) void { //igDockContextQueueUndockNode
     c.igDockContextQueueUndockNode(ctx, node);
 }
-pub inline fn dockContextCalcDropPosForDocking(target: [*c]Window, target_node: [*c]DockNode, payload: [*c]Window, split_dir: Dir, split_outer: bool, out_pos: [*c]Vec2) bool { //igDockContextCalcDropPosForDocking
+pub inline fn dockContextCalcDropPosForDocking(target: ?*Window, target_node: [*c]DockNode, payload: ?*Window, split_dir: Dir, split_outer: bool, out_pos: [*c]Vec2) bool { //igDockContextCalcDropPosForDocking
     return c.igDockContextCalcDropPosForDocking(target, target_node, payload, @intFromEnum(split_dir), split_outer, out_pos);
 }
 pub inline fn dockNodeBeginAmendTabBar(node: [*c]DockNode) bool { //igDockNodeBeginAmendTabBar
@@ -4293,19 +4060,19 @@ pub inline fn dockNodeGetWindowMenuButtonId(node: [*c]const DockNode) ID { //igD
 pub inline fn getWindowDockNode() [*c]DockNode { //igGetWindowDockNode
     return c.igGetWindowDockNode();
 }
-pub inline fn getWindowAlwaysWantOwnTabBar(window: [*c]Window) bool { //igGetWindowAlwaysWantOwnTabBar
+pub inline fn getWindowAlwaysWantOwnTabBar(window: ?*Window) bool { //igGetWindowAlwaysWantOwnTabBar
     return c.igGetWindowAlwaysWantOwnTabBar(window);
 }
-pub inline fn beginDocked(window: [*c]Window, p_open: [*c]bool) void { //igBeginDocked
+pub inline fn beginDocked(window: ?*Window, p_open: [*c]bool) void { //igBeginDocked
     c.igBeginDocked(window, p_open);
 }
-pub inline fn beginDockableDragDropSource(window: [*c]Window) void { //igBeginDockableDragDropSource
+pub inline fn beginDockableDragDropSource(window: ?*Window) void { //igBeginDockableDragDropSource
     c.igBeginDockableDragDropSource(window);
 }
-pub inline fn beginDockableDragDropTarget(window: [*c]Window) void { //igBeginDockableDragDropTarget
+pub inline fn beginDockableDragDropTarget(window: ?*Window) void { //igBeginDockableDragDropTarget
     c.igBeginDockableDragDropTarget(window);
 }
-pub inline fn setWindowDock(window: [*c]Window, dock_id: ID, cond: Cond) void { //igSetWindowDock
+pub inline fn setWindowDock(window: ?*Window, dock_id: ID, cond: Cond) void { //igSetWindowDock
     c.igSetWindowDock(window, dock_id, @bitCast(cond));
 }
 pub inline fn dockBuilderDockWindow(window_name: [*c]const u8, node_id: ID) void { //igDockBuilderDockWindow
@@ -4362,7 +4129,7 @@ pub inline fn clearDragDrop() void { //igClearDragDrop
 pub inline fn isDragDropPayloadBeingAccepted() bool { //igIsDragDropPayloadBeingAccepted
     return c.igIsDragDropPayloadBeingAccepted();
 }
-pub inline fn setWindowClipRectBeforeSetChannel(window: [*c]Window, clip_rect: Rect) void { //igSetWindowClipRectBeforeSetChannel
+pub inline fn setWindowClipRectBeforeSetChannel(window: ?*Window, clip_rect: Rect) void { //igSetWindowClipRectBeforeSetChannel
     c.igSetWindowClipRectBeforeSetChannel(window, @bitCast(clip_rect));
 }
 pub inline fn beginColumns(str_id: [*c]const u8, count: c_int, flags: OldColumnFlags) void { //igBeginColumns
@@ -4410,70 +4177,70 @@ pub inline fn tablePushBackgroundChannel() void { //igTablePushBackgroundChannel
 pub inline fn tablePopBackgroundChannel() void { //igTablePopBackgroundChannel
     c.igTablePopBackgroundChannel();
 }
-pub inline fn getCurrentTable() [*c]Table { //igGetCurrentTable
+pub inline fn getCurrentTable() ?*Table { //igGetCurrentTable
     return c.igGetCurrentTable();
 }
-pub inline fn tableFindByID(id: ID) [*c]Table { //igTableFindByID
+pub inline fn tableFindByID(id: ID) ?*Table { //igTableFindByID
     return c.igTableFindByID(id);
 }
 pub inline fn beginTableEx(name: [*c]const u8, id: ID, columns_count: c_int, flags: TableFlags, outer_size: Vec2, inner_width: f32) bool { //igBeginTableEx
     return c.igBeginTableEx(name, id, columns_count, @bitCast(flags), @bitCast(outer_size), inner_width);
 }
-pub inline fn tableBeginInitMemory(table: [*c]Table, columns_count: c_int) void { //igTableBeginInitMemory
+pub inline fn tableBeginInitMemory(table: ?*Table, columns_count: c_int) void { //igTableBeginInitMemory
     c.igTableBeginInitMemory(table, columns_count);
 }
-pub inline fn tableBeginApplyRequests(table: [*c]Table) void { //igTableBeginApplyRequests
+pub inline fn tableBeginApplyRequests(table: ?*Table) void { //igTableBeginApplyRequests
     c.igTableBeginApplyRequests(table);
 }
-pub inline fn tableSetupDrawChannels(table: [*c]Table) void { //igTableSetupDrawChannels
+pub inline fn tableSetupDrawChannels(table: ?*Table) void { //igTableSetupDrawChannels
     c.igTableSetupDrawChannels(table);
 }
-pub inline fn tableUpdateLayout(table: [*c]Table) void { //igTableUpdateLayout
+pub inline fn tableUpdateLayout(table: ?*Table) void { //igTableUpdateLayout
     c.igTableUpdateLayout(table);
 }
-pub inline fn tableUpdateBorders(table: [*c]Table) void { //igTableUpdateBorders
+pub inline fn tableUpdateBorders(table: ?*Table) void { //igTableUpdateBorders
     c.igTableUpdateBorders(table);
 }
-pub inline fn tableUpdateColumnsWeightFromWidth(table: [*c]Table) void { //igTableUpdateColumnsWeightFromWidth
+pub inline fn tableUpdateColumnsWeightFromWidth(table: ?*Table) void { //igTableUpdateColumnsWeightFromWidth
     c.igTableUpdateColumnsWeightFromWidth(table);
 }
-pub inline fn tableDrawBorders(table: [*c]Table) void { //igTableDrawBorders
+pub inline fn tableDrawBorders(table: ?*Table) void { //igTableDrawBorders
     c.igTableDrawBorders(table);
 }
-pub inline fn tableDrawContextMenu(table: [*c]Table) void { //igTableDrawContextMenu
+pub inline fn tableDrawContextMenu(table: ?*Table) void { //igTableDrawContextMenu
     c.igTableDrawContextMenu(table);
 }
-pub inline fn tableMergeDrawChannels(table: [*c]Table) void { //igTableMergeDrawChannels
+pub inline fn tableMergeDrawChannels(table: ?*Table) void { //igTableMergeDrawChannels
     c.igTableMergeDrawChannels(table);
 }
-pub inline fn tableGetInstanceData(table: [*c]Table, instance_no: c_int) [*c]TableInstanceData { //igTableGetInstanceData
+pub inline fn tableGetInstanceData(table: ?*Table, instance_no: c_int) ?*TableInstanceData { //igTableGetInstanceData
     return c.igTableGetInstanceData(table, instance_no);
 }
-pub inline fn tableSortSpecsSanitize(table: [*c]Table) void { //igTableSortSpecsSanitize
+pub inline fn tableSortSpecsSanitize(table: ?*Table) void { //igTableSortSpecsSanitize
     c.igTableSortSpecsSanitize(table);
 }
-pub inline fn tableSortSpecsBuild(table: [*c]Table) void { //igTableSortSpecsBuild
+pub inline fn tableSortSpecsBuild(table: ?*Table) void { //igTableSortSpecsBuild
     c.igTableSortSpecsBuild(table);
 }
-pub inline fn tableGetColumnNextSortDirection(column: [*c]TableColumn) SortDirection { //igTableGetColumnNextSortDirection
+pub inline fn tableGetColumnNextSortDirection(column: ?*TableColumn) SortDirection { //igTableGetColumnNextSortDirection
     return c.igTableGetColumnNextSortDirection(column);
 }
-pub inline fn tableFixColumnSortDirection(table: [*c]Table, column: [*c]TableColumn) void { //igTableFixColumnSortDirection
+pub inline fn tableFixColumnSortDirection(table: ?*Table, column: ?*TableColumn) void { //igTableFixColumnSortDirection
     c.igTableFixColumnSortDirection(table, column);
 }
-pub inline fn tableGetColumnWidthAuto(table: [*c]Table, column: [*c]TableColumn) f32 { //igTableGetColumnWidthAuto
+pub inline fn tableGetColumnWidthAuto(table: ?*Table, column: ?*TableColumn) f32 { //igTableGetColumnWidthAuto
     return c.igTableGetColumnWidthAuto(table, column);
 }
-pub inline fn tableBeginRow(table: [*c]Table) void { //igTableBeginRow
+pub inline fn tableBeginRow(table: ?*Table) void { //igTableBeginRow
     c.igTableBeginRow(table);
 }
-pub inline fn tableEndRow(table: [*c]Table) void { //igTableEndRow
+pub inline fn tableEndRow(table: ?*Table) void { //igTableEndRow
     c.igTableEndRow(table);
 }
-pub inline fn tableBeginCell(table: [*c]Table, column_n: c_int) void { //igTableBeginCell
+pub inline fn tableBeginCell(table: ?*Table, column_n: c_int) void { //igTableBeginCell
     c.igTableBeginCell(table, column_n);
 }
-pub inline fn tableEndCell(table: [*c]Table) void { //igTableEndCell
+pub inline fn tableEndCell(table: ?*Table) void { //igTableEndCell
     c.igTableEndCell(table);
 }
 pub inline fn tableGetCellBgRect(pout: [*c]Rect, table: [*c]const Table, column_n: c_int) void { //igTableGetCellBgRect
@@ -4488,43 +4255,43 @@ pub inline fn tableGetColumnResizeID(table: [*c]const Table, column_n: c_int, in
 pub inline fn tableGetMaxColumnWidth(table: [*c]const Table, column_n: c_int) f32 { //igTableGetMaxColumnWidth
     return c.igTableGetMaxColumnWidth(table, column_n);
 }
-pub inline fn tableSetColumnWidthAutoSingle(table: [*c]Table, column_n: c_int) void { //igTableSetColumnWidthAutoSingle
+pub inline fn tableSetColumnWidthAutoSingle(table: ?*Table, column_n: c_int) void { //igTableSetColumnWidthAutoSingle
     c.igTableSetColumnWidthAutoSingle(table, column_n);
 }
-pub inline fn tableSetColumnWidthAutoAll(table: [*c]Table) void { //igTableSetColumnWidthAutoAll
+pub inline fn tableSetColumnWidthAutoAll(table: ?*Table) void { //igTableSetColumnWidthAutoAll
     c.igTableSetColumnWidthAutoAll(table);
 }
-pub inline fn tableRemove(table: [*c]Table) void { //igTableRemove
+pub inline fn tableRemove(table: ?*Table) void { //igTableRemove
     c.igTableRemove(table);
 }
-pub inline fn tableGcCompactTransientBuffers_TablePtr(table: [*c]Table) void { //igTableGcCompactTransientBuffers_TablePtr
+pub inline fn tableGcCompactTransientBuffers_TablePtr(table: ?*Table) void { //igTableGcCompactTransientBuffers_TablePtr
     c.igTableGcCompactTransientBuffers_TablePtr(table);
 }
-pub inline fn tableGcCompactTransientBuffers_TableTempDataPtr(table: [*c]TableTempData) void { //igTableGcCompactTransientBuffers_TableTempDataPtr
+pub inline fn tableGcCompactTransientBuffers_TableTempDataPtr(table: ?*TableTempData) void { //igTableGcCompactTransientBuffers_TableTempDataPtr
     c.igTableGcCompactTransientBuffers_TableTempDataPtr(table);
 }
 pub inline fn tableGcCompactSettings() void { //igTableGcCompactSettings
     c.igTableGcCompactSettings();
 }
-pub inline fn tableLoadSettings(table: [*c]Table) void { //igTableLoadSettings
+pub inline fn tableLoadSettings(table: ?*Table) void { //igTableLoadSettings
     c.igTableLoadSettings(table);
 }
-pub inline fn tableSaveSettings(table: [*c]Table) void { //igTableSaveSettings
+pub inline fn tableSaveSettings(table: ?*Table) void { //igTableSaveSettings
     c.igTableSaveSettings(table);
 }
-pub inline fn tableResetSettings(table: [*c]Table) void { //igTableResetSettings
+pub inline fn tableResetSettings(table: ?*Table) void { //igTableResetSettings
     c.igTableResetSettings(table);
 }
-pub inline fn tableGetBoundSettings(table: [*c]Table) [*c]TableSettings { //igTableGetBoundSettings
+pub inline fn tableGetBoundSettings(table: ?*Table) ?*TableSettings { //igTableGetBoundSettings
     return c.igTableGetBoundSettings(table);
 }
 pub inline fn tableSettingsAddSettingsHandler() void { //igTableSettingsAddSettingsHandler
     c.igTableSettingsAddSettingsHandler();
 }
-pub inline fn tableSettingsCreate(id: ID, columns_count: c_int) [*c]TableSettings { //igTableSettingsCreate
+pub inline fn tableSettingsCreate(id: ID, columns_count: c_int) ?*TableSettings { //igTableSettingsCreate
     return c.igTableSettingsCreate(id, columns_count);
 }
-pub inline fn tableSettingsFindByID(id: ID) [*c]TableSettings { //igTableSettingsFindByID
+pub inline fn tableSettingsFindByID(id: ID) ?*TableSettings { //igTableSettingsFindByID
     return c.igTableSettingsFindByID(id);
 }
 pub inline fn beginTabBarEx(tab_bar: [*c]TabBar, bb: Rect, flags: TabBarFlags, dock_node: [*c]DockNode) bool { //igBeginTabBarEx
@@ -4536,7 +4303,7 @@ pub inline fn tabBarFindTabByID(tab_bar: [*c]TabBar, tab_id: ID) [*c]TabItem { /
 pub inline fn tabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar: [*c]TabBar) [*c]TabItem { //igTabBarFindMostRecentlySelectedTabForActiveWindow
     return c.igTabBarFindMostRecentlySelectedTabForActiveWindow(tab_bar);
 }
-pub inline fn tabBarAddTab(tab_bar: [*c]TabBar, tab_flags: TabItemFlags, window: [*c]Window) void { //igTabBarAddTab
+pub inline fn tabBarAddTab(tab_bar: [*c]TabBar, tab_flags: TabItemFlags, window: ?*Window) void { //igTabBarAddTab
     c.igTabBarAddTab(tab_bar, @bitCast(tab_flags), window);
 }
 pub inline fn tabBarRemoveTab(tab_bar: [*c]TabBar, tab_id: ID) void { //igTabBarRemoveTab
@@ -4554,7 +4321,7 @@ pub inline fn tabBarQueueReorderFromMousePos(tab_bar: [*c]TabBar, tab: [*c]const
 pub inline fn tabBarProcessReorder(tab_bar: [*c]TabBar) bool { //igTabBarProcessReorder
     return c.igTabBarProcessReorder(tab_bar);
 }
-pub inline fn tabItemEx(tab_bar: [*c]TabBar, label: [*c]const u8, p_open: [*c]bool, flags: TabItemFlags, docked_window: [*c]Window) bool { //igTabItemEx
+pub inline fn tabItemEx(tab_bar: [*c]TabBar, label: [*c]const u8, p_open: [*c]bool, flags: TabItemFlags, docked_window: ?*Window) bool { //igTabItemEx
     return c.igTabItemEx(tab_bar, label, p_open, @bitCast(flags), docked_window);
 }
 pub inline fn tabItemCalcSize(pout: [*c]Vec2, label: [*c]const u8, has_close_button: bool) void { //igTabItemCalcSize
@@ -4638,16 +4405,16 @@ pub inline fn scrollbarEx(bb: Rect, id: ID, axis: Axis, p_scroll_v: [*c]S64, ava
 pub inline fn imageButtonEx(id: ID, texture_id: TextureID, size: Vec2, uv0: Vec2, uv1: Vec2, padding: Vec2, bg_col: Vec4, tint_col: Vec4) bool { //igImageButtonEx
     return c.igImageButtonEx(id, texture_id, @bitCast(size), @bitCast(uv0), @bitCast(uv1), @bitCast(padding), @bitCast(bg_col), @bitCast(tint_col));
 }
-pub inline fn getWindowScrollbarRect(pout: [*c]Rect, window: [*c]Window, axis: Axis) void { //igGetWindowScrollbarRect
+pub inline fn getWindowScrollbarRect(pout: [*c]Rect, window: ?*Window, axis: Axis) void { //igGetWindowScrollbarRect
     c.igGetWindowScrollbarRect(pout, window, @intFromEnum(axis));
 }
-pub inline fn getWindowScrollbarID(window: [*c]Window, axis: Axis) ID { //igGetWindowScrollbarID
+pub inline fn getWindowScrollbarID(window: ?*Window, axis: Axis) ID { //igGetWindowScrollbarID
     return c.igGetWindowScrollbarID(window, @intFromEnum(axis));
 }
-pub inline fn getWindowResizeCornerID(window: [*c]Window, n: c_int) ID { //igGetWindowResizeCornerID
+pub inline fn getWindowResizeCornerID(window: ?*Window, n: c_int) ID { //igGetWindowResizeCornerID
     return c.igGetWindowResizeCornerID(window, n);
 }
-pub inline fn getWindowResizeBorderID(window: [*c]Window, dir: Dir) ID { //igGetWindowResizeBorderID
+pub inline fn getWindowResizeBorderID(window: ?*Window, dir: Dir) ID { //igGetWindowResizeBorderID
     return c.igGetWindowResizeBorderID(window, @intFromEnum(dir));
 }
 pub inline fn separatorEx(flags: SeparatorFlags) void { //igSeparatorEx
@@ -4731,10 +4498,10 @@ pub inline fn shadeVertsLinearUV(draw_list: [*c]DrawList, vert_start_idx: c_int,
 pub inline fn gcCompactTransientMiscBuffers() void { //igGcCompactTransientMiscBuffers
     c.igGcCompactTransientMiscBuffers();
 }
-pub inline fn gcCompactTransientWindowBuffers(window: [*c]Window) void { //igGcCompactTransientWindowBuffers
+pub inline fn gcCompactTransientWindowBuffers(window: ?*Window) void { //igGcCompactTransientWindowBuffers
     c.igGcCompactTransientWindowBuffers(window);
 }
-pub inline fn gcAwakeTransientWindowBuffers(window: [*c]Window) void { //igGcAwakeTransientWindowBuffers
+pub inline fn gcAwakeTransientWindowBuffers(window: ?*Window) void { //igGcAwakeTransientWindowBuffers
     c.igGcAwakeTransientWindowBuffers(window);
 }
 pub inline fn errorCheckEndFrameRecover(log_callback: ErrorLogCallback, user_data: ?*anyopaque) void { //igErrorCheckEndFrameRecover
@@ -4761,7 +4528,7 @@ pub inline fn debugNodeColumns(cols: [*c]OldColumns) void { //igDebugNodeColumns
 pub inline fn debugNodeDockNode(node: [*c]DockNode, label: [*c]const u8) void { //igDebugNodeDockNode
     c.igDebugNodeDockNode(node, label);
 }
-pub inline fn debugNodeDrawList(window: [*c]Window, viewport: [*c]ViewportP, draw_list: [*c]const DrawList, label: [*c]const u8) void { //igDebugNodeDrawList
+pub inline fn debugNodeDrawList(window: ?*Window, viewport: [*c]ViewportP, draw_list: [*c]const DrawList, label: [*c]const u8) void { //igDebugNodeDrawList
     c.igDebugNodeDrawList(window, viewport, draw_list, label);
 }
 pub inline fn debugNodeDrawCmdShowMeshAndBoundingBox(out_draw_list: [*c]DrawList, draw_list: [*c]const DrawList, draw_cmd: [*c]const DrawCmd, show_mesh: bool, show_aabb: bool) void { //igDebugNodeDrawCmdShowMeshAndBoundingBox
@@ -4779,7 +4546,7 @@ pub inline fn debugNodeStorage(storage: [*c]Storage, label: [*c]const u8) void {
 pub inline fn debugNodeTabBar(tab_bar: [*c]TabBar, label: [*c]const u8) void { //igDebugNodeTabBar
     c.igDebugNodeTabBar(tab_bar, label);
 }
-pub inline fn debugNodeTable(table: [*c]Table) void { //igDebugNodeTable
+pub inline fn debugNodeTable(table: ?*Table) void { //igDebugNodeTable
     c.igDebugNodeTable(table);
 }
 pub inline fn debugNodeTableSettings(settings: [*c]TableSettings) void { //igDebugNodeTableSettings
@@ -4788,16 +4555,16 @@ pub inline fn debugNodeTableSettings(settings: [*c]TableSettings) void { //igDeb
 pub inline fn debugNodeInputTextState(state: [*c]InputTextState) void { //igDebugNodeInputTextState
     c.igDebugNodeInputTextState(state);
 }
-pub inline fn debugNodeWindow(window: [*c]Window, label: [*c]const u8) void { //igDebugNodeWindow
+pub inline fn debugNodeWindow(window: ?*Window, label: [*c]const u8) void { //igDebugNodeWindow
     c.igDebugNodeWindow(window, label);
 }
-pub inline fn debugNodeWindowSettings(settings: [*c]WindowSettings) void { //igDebugNodeWindowSettings
+pub inline fn debugNodeWindowSettings(settings: ?*WindowSettings) void { //igDebugNodeWindowSettings
     c.igDebugNodeWindowSettings(settings);
 }
-pub inline fn debugNodeWindowsList(windows: [*c]WindowPtrVector, label: [*c]const u8) void { //igDebugNodeWindowsList
+pub inline fn debugNodeWindowsList(windows: ?*WindowPtrVector, label: [*c]const u8) void { //igDebugNodeWindowsList
     c.igDebugNodeWindowsList(windows, label);
 }
-pub inline fn debugNodeWindowsListByBeginStackParent(windows: [*c]Window, windows_size: c_int, parent_in_begin_stack: [*c]Window) void { //igDebugNodeWindowsListByBeginStackParent
+pub inline fn debugNodeWindowsListByBeginStackParent(windows: ?*Window, windows_size: c_int, parent_in_begin_stack: ?*Window) void { //igDebugNodeWindowsListByBeginStackParent
     c.igDebugNodeWindowsListByBeginStackParent(windows, windows_size, parent_in_begin_stack);
 }
 pub inline fn debugNodeViewport(viewport: [*c]ViewportP) void { //igDebugNodeViewport
@@ -4914,10 +4681,9 @@ pub inline fn textFmt(comptime fmt: []const u8, args: anytype) !void {
 
 pub const c = @cImport({
     @cDefine("CIMGUI_DEFINE_ENUMS_AND_STRUCTS", {});
-    @cDefine("CIMGUI_USE_GLFW", "1"); // if this needs a reference to glfw3, cleanest thing to do is to copy the glfw3 header here. I suspect it won't need it though.
     @cInclude("cimgui.h");
     @cInclude("cimgui_compat.h");
-    @cInclude("cimgui_impl.h");
+    // @cInclude("cimgui_impl.h");
     @cInclude("cimplot.h");
 });
 
diff --git a/projects/sampleGame/main.zig b/projects/sampleGame/main.zig
index e9f46a7..673d976 100644
--- a/projects/sampleGame/main.zig
+++ b/projects/sampleGame/main.zig
@@ -118,6 +118,10 @@ pub fn tick(self: *@This(), dt: f64) void {
         scene.getPosRot().position = scene.getPosRot().position.add(vector.fmul(self.cameraSpeed * fdt));
         // core.engine_log(" camera position >> {any}", .{scene.getPosRot().position});
     }
+
+    var show: bool = true;
+
+    ig.showDemoWindow(&show);
 }
 
 pub fn deinit(self: *@This()) void {
@@ -138,5 +142,6 @@ const std = @import("std");
 const backlog = @import("Backlog");
 const assets = backlog.assets;
 const core = backlog.core;
+const ig = backlog.imgui.api;
 const rend = backlog.rend;
 const script = core.script;