imgui 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5db61cd5cd40e3d068a5c8144fe6edcaa2f5a2be978aa621b479af946e83f1b3
+  data.tar.gz: fc7ed9985b2a2c5b3fcc4cb61e78b7d0d133de5ccc44be361216e8f96701f9d6
+SHA512:
+  metadata.gz: a5bb6a0cdb519cdf4c7090dea048b8b51be6b290411da1dd54c37c0fd36a300ac235c69709fe9bb2bdf715b48ca53a1d4761da7e09340ffb5335d65f9e66c76b
+  data.tar.gz: 99dc01926644a20bdc35894e60b7cc05001476d7f3f393bf56e71d558606465d761964bd8aa23c461e926cc459898d9de9de9fb6201c7ef7410e25c0e372900e

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,273 @@
+# imgui-ruby
+
+Ruby bindings for [Dear ImGui](https://github.com/ocornut/imgui) through
+[cimgui](https://github.com/cimgui/cimgui) and FFI. The binding targets Dear
+ImGui 1.91.9 from the docking branch and is generated from cimgui metadata.
+Version 1 freezes the idiomatic Ruby, DSL, backend, and ImPlot method
+signatures in [`api/v1.json`](api/v1.json).
+
+The API has three layers:
+
+```ruby
+ImGui::Native.igButton("OK", ImGui::Native::ImVec2.new) # generated C API
+ImGui.button("OK")                                      # idiomatic Ruby API
+ImGui.window("Debug") { ImGui.text("hello") }           # exception-safe DSL
+```
+
+## Installation
+
+Add the gem to your bundle:
+
+```bash
+bundle add imgui-ruby
+```
+
+The source gem needs CMake and a C++17 compiler. Platform gems for x86_64 and
+Arm64 Linux, Intel and Arm64 macOS, and x64 Windows contain a prebuilt
+`libcimgui_ruby` and do not compile during installation. The only required
+runtime dependency is `ffi`; `glfw-ruby`, `sdl3`, and `wgpu` are optional and
+needed only by their respective backends.
+
+To use a custom native build, set its full path before requiring the gem:
+
+```bash
+IMGUI_RUBY_LIB=/opt/imgui/libcimgui_ruby.so ruby app.rb
+```
+
+## Basic OpenGL/GLFW loop
+
+```ruby
+require "imgui"
+require "glfw"
+
+context = ImGui.create_context
+io = ImGui.io
+io.config_flags |= ImGui::ConfigFlags::DockingEnable
+io.fonts.add_font_jp("assets/NotoSansJP-Regular.ttf", size: 18)
+
+ImGui::Backends::Glfw.init_for_opengl(window.handle, install_callbacks: true)
+ImGui::Backends::OpenGL3.init("#version 330")
+
+until window.should_close?
+  GLFW.poll_events
+  ImGui::Backends::OpenGL3.new_frame
+  ImGui::Backends::Glfw.new_frame
+  ImGui.new_frame
+
+  ImGui.window("Stats") do
+    ImGui.text("fps: %.1f", io.framerate)
+    ImGui.separator
+    ImGui.button("Reset")
+  end
+
+  ImGui.render
+  ImGui::Backends::OpenGL3.render_draw_data(ImGui.draw_data)
+  window.swap_buffers
+end
+
+ImGui::Backends::OpenGL3.shutdown
+ImGui::Backends::Glfw.shutdown
+ImGui.destroy_context(context)
+```
+
+`ImGui.frame` performs the three `new_frame` calls, yields the UI block, then
+renders DrawData. `ImGui.easy_loop` additionally owns the window loop and swaps
+buffers when the window object supports it.
+
+## Values and output arguments
+
+Passing a Ruby value returns `[changed, value]`:
+
+```ruby
+changed, speed = ImGui.slider_float("Speed", speed, 0.0, 10.0)
+changed, tint = ImGui.color_edit3("Tint", tint)
+```
+
+`ImGui::Value` owns stable native memory and is updated in place:
+
+```ruby
+speed = ImGui::Value.float(1.0)
+open = ImGui::Value.bool(true)
+name = ImGui::Value.text("Player", capacity: 256)
+
+ImGui.slider_float("Speed", speed, 0.0, 10.0)
+ImGui.checkbox("Open", open)
+ImGui.input_text("Name", name)
+```
+
+The available types are `bool`, `int`, `float`, `vec2`, `vec3`, `vec4`, and
+`text`.
+
+## Block DSL
+
+Begin/End pairs have different native contracts. The DSL calls the matching
+End or Pop under the correct condition and uses `ensure`, so Ruby exceptions do
+not corrupt the ImGui stack.
+
+```ruby
+ImGui.window("Inspector") do
+  ImGui.menu_bar do
+    ImGui.menu("File") { ImGui.menu_item("Close") }
+  end
+
+  ImGui.tree_node("Renderer") do
+    ImGui.style_color(ImGui::Col::Text, [1, 0.4, 0.2, 1]) do
+      ImGui.text("draw calls: %d", draw_calls)
+    end
+  end
+end
+```
+
+Blockless calls return the native Begin result for manual control. Close them
+with the matching method, such as `end_window`, `end_table`, `tree_pop`, or the
+generic `close_scope`. A mismatched close raises `ImGui::StackError`.
+
+## Fonts and retained strings
+
+`io.fonts.add_font_jp` uses Dear ImGui's Japanese glyph range. Pass
+`merge: true` to merge an icon font. Dear ImGui retains `IniFilename` and
+`LogFilename` pointers, so assign them through `ImGui.ini_filename=` or the IO
+wrapper; imgui-ruby retains the backing memory for the context lifetime.
+
+```ruby
+ImGui.ini_filename = "settings/imgui.ini"
+ImGui.io.log_filename = nil
+```
+
+## Thread safety
+
+Contexts are owned by the thread that first uses or creates them. Layer 2 and
+the DSL raise `ImGui::ThreadError` when a context is used from another thread.
+`ImGui.unsafe_allow_threads!` disables this guard for applications that provide
+their own synchronization; `ImGui.enforce_thread_safety!` restores it.
+
+## Backends
+
+The native build can include GLFW, OpenGL3, and SDL3 wrappers. Select source
+build backends with a comma-separated environment variable:
+
+```bash
+IMGUI_RUBY_BACKENDS=glfw,opengl3 bundle exec rake native:build
+```
+
+Backend symbols are resolved on first use, so a core-only library remains
+usable for headless operation. Calling a backend omitted from the native
+library raises `ImGui::BackendUnavailableError`. GLFW and SDL3 calls use a
+validated runtime loader on every supported OS, so the native gem does not
+link either optional library. WebGPU uses an explicit function table and does
+not link against a particular wgpu-native release.
+
+### SDL3
+
+The SDL3 adapter supports OpenGL, Vulkan, D3D, Metal, SDL_Renderer, SDL_GPU,
+and renderer-independent initialization. Forward each polled event before the
+frame begins:
+
+```ruby
+require "sdl3"
+require "imgui"
+
+SDL3.init(SDL3::INIT_VIDEO | SDL3::INIT_GAMEPAD)
+window = SDL3::Window.new("ImGui", 1280, 720)
+context = ImGui.create_context
+
+ImGui::Backends::SDL3.init_for_other(window.ptr)
+ImGui::Backends::SDL3.set_gamepad_mode(:auto_first)
+
+# SDL3 event loop:
+# ImGui::Backends::SDL3.process_event(event.raw)
+ImGui::Backends::SDL3.new_frame
+ImGui.new_frame
+ImGui.window("SDL3") { ImGui.text("ready") }
+ImGui.render
+
+ImGui::Backends::SDL3.shutdown
+ImGui.destroy_context(context)
+window.destroy
+SDL3.quit
+```
+
+### WGPU and stagecraft-style renderers
+
+`WGPU.init` accepts objects exposing `#handle`/`#to_ptr` and discovers the
+wgpu-native function table from the device, or accepts `function_table:` or
+`library_path:` explicitly. Passing an encoder and target view creates an
+overlay render pass; passing an existing render pass records directly into it.
+
+```ruby
+ImGui::Backends::WGPU.init(
+  device: renderer.device,
+  queue: renderer.queue,
+  render_target_format: renderer.surface_format,
+  depth_format: nil,
+  frames_in_flight: 3
+)
+
+renderer.on_after_render do |encoder, target_view|
+  ImGui::Backends::WGPU.render_draw_data(ImGui.draw_data, encoder, target_view)
+end
+```
+
+## ImPlot
+
+ImPlot is opt-in at the Ruby level and shares the bundled native library:
+
+```ruby
+require "imgui/plot"
+
+plot_context = ImPlot.create_context
+ImPlot.plot("Frame time") do
+  ImPlot.setup_axes("frame", "ms")
+  ImPlot.plot_line("CPU", [4.1, 3.8, 5.0, 4.4])
+  ImPlot.plot_scatter("samples", [4.1, 3.8], xs: [1.0, 2.0])
+end
+ImPlot.destroy_context(plot_context)
+```
+
+Line, scatter, stairs, bars, and histogram helpers accept Ruby numeric arrays.
+
+## Development
+
+Native dependency sources are not stored in Git. Their revisions and SHA-256
+checksums are pinned in `generator/native-dependencies.yml`; the first native
+build or generation downloads a minimal snapshot into the ignored `tmp/vendor`
+cache. Install dependencies, fetch the cache, then run the suites:
+
+```bash
+bundle install
+bundle exec rake vendor:fetch
+bundle exec rake vendor:verify
+bundle exec rake
+bundle exec rake native:spec
+bundle exec rake native:audit
+```
+
+Regenerate all committed Native files and the snake_case Layer 2 surface with:
+
+```bash
+bundle exec rake generate
+```
+
+`vendor:fetch` uses a valid cache without network access and otherwise downloads
+the pinned revisions. `vendor:verify` performs an offline file and checksum
+audit, while `vendor:update` advances the configured upstream branches and
+updates their checksums.
+
+`native:spec` builds cimgui and executes two real headless frames.
+`native:audit` builds every supported backend and attaches all generated
+symbols. `native:integration` runs GLFW/OpenGL3, SDL3, and WGPU integration
+frames when the optional gems and system libraries are installed. To build the
+source gem use `bundle exec rake build`; `bundle exec rake gem:platform`
+builds a gem containing the native library for the current platform. Source gem
+packaging stages only the native files needed for an offline extension build;
+platform gems contain no native source snapshots.
+
+The weekly update workflow refreshes the dependency cache and lock data, regenerates the
+bindings, and opens a pull request only after the compatibility and native
+suites pass. Tagged releases build all platform gems and use RubyGems trusted
+publishing; repository maintainers must register `release.yml` and the
+`release` environment as a trusted publisher before the first release.
+
+## License
+
+imgui-ruby, Dear ImGui, and cimgui are available under the MIT License.

data/Rakefile

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rbconfig"
+
+desc "Generate FFI declarations from cimgui metadata"
+task generate: "vendor:fetch" do
+  ruby File.expand_path("generator/generate.rb", __dir__)
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+namespace :vendor do
+  desc "Fetch the pinned native dependencies when the cache is missing"
+  task :fetch do
+    ruby File.expand_path("generator/update_vendor.rb", __dir__)
+  end
+
+  desc "Verify the cached native dependency snapshots"
+  task :verify do
+    ruby File.expand_path("generator/update_vendor.rb", __dir__), "--verify"
+  end
+
+  desc "Update cached native dependencies from their configured branches"
+  task :update do
+    ruby File.expand_path("generator/update_vendor.rb", __dir__), "--latest"
+  end
+end
+
+namespace :native do
+  build_root = File.expand_path("tmp/native-build", __dir__)
+  install_root = File.expand_path("tmp/native-install", __dir__)
+
+  desc "Build the cached cimgui library"
+  task build: "vendor:fetch" do
+    require_relative "ext/build_cimgui"
+
+    ImGuiRuby::NativeBuilder.new(
+      source_dir: File.expand_path("ext", __dir__),
+      build_dir: build_root,
+      install_dir: install_root
+    ).build!
+  end
+
+  desc "Build cimgui and run a real headless ImGui frame"
+  task spec: :build do
+    library = Dir.glob(File.join(install_root, "*cimgui_ruby.{so,dylib,dll}")).first
+    raise "built cimgui library was not found" unless library
+
+    previous_library = ENV["IMGUI_RUBY_LIB"]
+    ENV["IMGUI_RUBY_LIB"] = library
+    ruby "-Ilib", "spec/native_smoke.rb"
+  ensure
+    ENV["IMGUI_RUBY_LIB"] = previous_library
+  end
+
+
+  desc "Build all supported backends and attach every generated native function"
+  task :audit do
+    previous_backends = ENV["IMGUI_RUBY_BACKENDS"]
+    ENV["IMGUI_RUBY_BACKENDS"] = "glfw,opengl3,sdl3,wgpu"
+    Rake::Task["native:build"].invoke
+    library = Dir.glob(File.join(install_root, "*cimgui_ruby.{so,dylib,dll}")).first
+    raise "built cimgui library was not found" unless library
+
+    previous_library = ENV["IMGUI_RUBY_LIB"]
+    ENV["IMGUI_RUBY_LIB"] = library
+    ruby "-Ilib", "spec/native_symbol_audit.rb"
+  ensure
+    ENV["IMGUI_RUBY_BACKENDS"] = previous_backends
+    ENV["IMGUI_RUBY_LIB"] = previous_library
+  end
+
+  desc "Run GLFW/OpenGL3, SDL3, and WGPU backend integration frames"
+  task :integration do
+    previous_backends = ENV["IMGUI_RUBY_BACKENDS"]
+    ENV["IMGUI_RUBY_BACKENDS"] = "glfw,opengl3,sdl3,wgpu"
+    Rake::Task["native:build"].invoke
+    library = Dir.glob(File.join(install_root, "*cimgui_ruby.{so,dylib,dll}")).first
+    raise "built cimgui library was not found" unless library
+
+    require "bundler"
+    Bundler.with_unbundled_env do
+      sh({ "IMGUI_RUBY_LIB" => library, "IMGUI_RUBY_REQUIRE_GLFW" => "1" },
+         RbConfig.ruby, "-Ilib", "spec/glfw_opengl_smoke.rb")
+      sh({ "IMGUI_RUBY_LIB" => library, "IMGUI_RUBY_REQUIRE_SDL3" => "1" },
+         RbConfig.ruby, "-Ilib", "spec/sdl3_smoke.rb")
+      sh({ "IMGUI_RUBY_LIB" => library },
+         RbConfig.ruby, "-Ilib", "spec/wgpu_smoke.rb")
+    end
+  ensure
+    ENV["IMGUI_RUBY_BACKENDS"] = previous_backends
+  end
+end

data/api/v1.json

@@ -0,0 +1,53 @@
+{
+  "schema_version": 1,
+  "surfaces": {
+    "ImGui": {
+      "method_count": 387,
+      "sha256": "2a530e9c72597da0b6095c9a71626fc379c354d596acd0b02946a1069419844c"
+    },
+    "ImPlot": {
+      "method_count": 21,
+      "sha256": "d17bd05b4d1f92b4a2c12af3ebacead53d4c8c3d73c969b7b1b170a259e1e702"
+    },
+    "ImGui::Backends::Glfw": {
+      "method_count": 8,
+      "sha256": "7fe06d1fe8a70fc5da9506aa35781aee9c93b27886bd1a980109c5e702b8e621"
+    },
+    "ImGui::Backends": {
+      "method_count": 3,
+      "sha256": "7da32543c540d627d33ebd0bf0826cebf3ef7ebadc55391c6c38d1ec98fca320"
+    },
+    "ImGui::Backends::OpenGL3": {
+      "method_count": 8,
+      "sha256": "e4c26cc73c9536480f28cac617206774aff663e571979ab0a1e2c87ab593a803"
+    },
+    "ImGui::Backends::SDL3": {
+      "method_count": 12,
+      "sha256": "b125914e0fb9a73aa36fded3c308c67395a564759d521b72a5e03a3f91bf644a"
+    },
+    "ImGui::Backends::WGPU": {
+      "method_count": 5,
+      "sha256": "b84c3315a395d4086fd34f6bd3af3a1d743c51423bac80c8da84dbf60167ab9d"
+    },
+    "ImGui::IO": {
+      "method_count": 40,
+      "sha256": "f7718b34d921f9358a6e982694f2b18998dab1885c465693e81bfe94c2f5fe4f"
+    },
+    "ImGui::Style": {
+      "method_count": 8,
+      "sha256": "45e66164917622943d3318bc0b65230eee280061d4a191a5860d9b897c7a8110"
+    },
+    "ImGui::Fonts": {
+      "method_count": 6,
+      "sha256": "8185515769a642357bb4b10165ce862a264a87f674cd453233cb8f4293aacfa1"
+    },
+    "ImGui::DrawData": {
+      "method_count": 10,
+      "sha256": "1bc1067e5e8fe91bd3b438e1391913164681b35af9cdd60059d5fabf360ec8f8"
+    },
+    "ImGui::Value": {
+      "method_count": 6,
+      "sha256": "edb310c84ff76eca385fd5634b960f9b95245a42498fecbbe0570202a38cc799"
+    }
+  }
+}

data/ext/CMakeLists.txt

@@ -0,0 +1,128 @@
+cmake_minimum_required(VERSION 3.15)
+project(cimgui_ruby LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(IMGUI_RUBY_WITH_GLFW "Compile the Dear ImGui GLFW backend" OFF)
+option(IMGUI_RUBY_WITH_OPENGL3 "Compile the Dear ImGui OpenGL3 backend" OFF)
+option(IMGUI_RUBY_WITH_SDL3 "Compile the Dear ImGui SDL3 backend" OFF)
+option(IMGUI_RUBY_WITH_IMPLOT "Compile the bundled ImPlot extension" ON)
+option(IMGUI_RUBY_WITH_WGPU "Compile the Dear ImGui WebGPU backend" OFF)
+
+get_filename_component(IMGUI_RUBY_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
+set(IMGUI_RUBY_VENDOR_DIR "" CACHE PATH "Directory containing native dependency sources")
+if(NOT IMGUI_RUBY_VENDOR_DIR)
+  if(EXISTS "${IMGUI_RUBY_ROOT}/vendor-src")
+    set(IMGUI_RUBY_VENDOR_DIR "${IMGUI_RUBY_ROOT}/vendor-src")
+  else()
+    set(IMGUI_RUBY_VENDOR_DIR "${IMGUI_RUBY_ROOT}/tmp/vendor")
+  endif()
+endif()
+
+set(CIMGUI_DIR "${IMGUI_RUBY_VENDOR_DIR}/cimgui")
+set(IMGUI_DIR "${CIMGUI_DIR}/imgui")
+set(CIMPLOT_DIR "${IMGUI_RUBY_VENDOR_DIR}/cimplot")
+set(SDL_DIR "${IMGUI_RUBY_VENDOR_DIR}/sdl")
+set(WEBGPU_HEADERS_DIR "${IMGUI_RUBY_VENDOR_DIR}")
+
+if(NOT EXISTS "${CIMGUI_DIR}/cimgui.cpp")
+  message(FATAL_ERROR "cimgui source is missing; run bundle exec rake vendor:fetch")
+endif()
+
+set(IMGUI_RUBY_SOURCES
+  "${CIMGUI_DIR}/cimgui.cpp"
+  "${IMGUI_DIR}/imgui.cpp"
+  "${IMGUI_DIR}/imgui_draw.cpp"
+  "${IMGUI_DIR}/imgui_tables.cpp"
+  "${IMGUI_DIR}/imgui_widgets.cpp"
+  "${IMGUI_DIR}/imgui_demo.cpp"
+)
+
+set(IMGUI_RUBY_BACKEND_DEFINITIONS)
+if(IMGUI_RUBY_WITH_IMPLOT)
+  if(NOT EXISTS "${CIMPLOT_DIR}/cimplot.cpp")
+    message(FATAL_ERROR "cimplot source is missing; run bundle exec rake vendor:fetch")
+  endif()
+  list(APPEND IMGUI_RUBY_SOURCES
+    "${CIMPLOT_DIR}/cimplot.cpp"
+    "${CIMPLOT_DIR}/implot/implot.cpp"
+    "${CIMPLOT_DIR}/implot/implot_demo.cpp"
+    "${CIMPLOT_DIR}/implot/implot_items.cpp"
+  )
+endif()
+
+if(IMGUI_RUBY_WITH_GLFW)
+  list(APPEND IMGUI_RUBY_SOURCES
+    "${CMAKE_CURRENT_LIST_DIR}/backend_function_bridge.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/glfw_vulkan_bridge.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/imgui_ruby_glfw.cpp"
+    "${CIMGUI_DIR}/cimgui_impl.cpp"
+  )
+  list(APPEND IMGUI_RUBY_BACKEND_DEFINITIONS CIMGUI_USE_GLFW)
+endif()
+
+if(IMGUI_RUBY_WITH_OPENGL3)
+  list(APPEND IMGUI_RUBY_SOURCES
+    "${CIMGUI_DIR}/cimgui_impl.cpp"
+    "${IMGUI_DIR}/backends/imgui_impl_opengl3.cpp"
+  )
+  list(APPEND IMGUI_RUBY_BACKEND_DEFINITIONS CIMGUI_USE_OPENGL3)
+endif()
+
+if(IMGUI_RUBY_WITH_SDL3)
+  if(NOT EXISTS "${SDL_DIR}/include/SDL3/SDL.h")
+    message(FATAL_ERROR "SDL headers are missing; run bundle exec rake vendor:fetch")
+  endif()
+  list(APPEND IMGUI_RUBY_SOURCES
+    "${CMAKE_CURRENT_LIST_DIR}/backend_function_bridge.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/imgui_ruby_sdl3.cpp"
+    "${CIMGUI_DIR}/cimgui_impl.cpp"
+  )
+  list(APPEND IMGUI_RUBY_BACKEND_DEFINITIONS CIMGUI_USE_SDL3)
+endif()
+
+if(IMGUI_RUBY_WITH_WGPU)
+  if(NOT EXISTS "${WEBGPU_HEADERS_DIR}/webgpu/webgpu.h")
+    message(FATAL_ERROR "WebGPU headers are missing; run bundle exec rake vendor:fetch")
+  endif()
+  list(APPEND IMGUI_RUBY_SOURCES
+    "${CMAKE_CURRENT_LIST_DIR}/imgui_ruby_wgpu.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/webgpu_function_bridge.cpp"
+    "${IMGUI_DIR}/backends/imgui_impl_wgpu.cpp"
+  )
+  list(APPEND IMGUI_RUBY_BACKEND_DEFINITIONS IMGUI_IMPL_WEBGPU_BACKEND_WGPU)
+endif()
+
+list(REMOVE_DUPLICATES IMGUI_RUBY_SOURCES)
+add_library(cimgui_ruby SHARED ${IMGUI_RUBY_SOURCES})
+set(IMGUI_RUBY_BUILD_CONFIG "${CMAKE_CURRENT_LIST_DIR}/imgui_ruby_build_config.h")
+if(MSVC)
+  target_compile_options(cimgui_ruby PRIVATE "/FI${IMGUI_RUBY_BUILD_CONFIG}")
+else()
+  target_compile_options(cimgui_ruby PRIVATE "-include${IMGUI_RUBY_BUILD_CONFIG}")
+endif()
+target_include_directories(cimgui_ruby PRIVATE
+  "${CIMGUI_DIR}"
+  "${IMGUI_DIR}"
+  "${IMGUI_DIR}/backends"
+  "${IMGUI_DIR}/examples/libs/glfw/include"
+  "${CIMPLOT_DIR}"
+  "${CIMPLOT_DIR}/implot"
+  "${SDL_DIR}/include"
+  "${WEBGPU_HEADERS_DIR}"
+)
+target_compile_definitions(cimgui_ruby PRIVATE
+  IMGUI_DISABLE_OBSOLETE_FUNCTIONS=1
+  ${IMGUI_RUBY_BACKEND_DEFINITIONS}
+)
+
+target_link_libraries(cimgui_ruby PRIVATE ${CMAKE_DL_LIBS})
+
+set_target_properties(cimgui_ruby PROPERTIES OUTPUT_NAME cimgui_ruby)
+install(TARGETS cimgui_ruby
+  RUNTIME DESTINATION .
+  LIBRARY DESTINATION .
+  ARCHIVE DESTINATION .
+)

data/ext/Rakefile

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rbconfig"
+
+require_relative "build_cimgui"
+
+host_os = RbConfig::CONFIG.fetch("host_os")
+platform_os = if host_os.include?("darwin")
+                "darwin"
+              elsif host_os.match?(/mswin|mingw/)
+                "windows"
+              else
+                "linux"
+              end
+host_cpu = RbConfig::CONFIG.fetch("host_cpu")
+platform_cpu = host_cpu == "arm64" ? "aarch64" : host_cpu
+platform = "#{platform_cpu}-#{platform_os}"
+extension_root = ENV.fetch("RUBYARCHDIR", File.expand_path("../lib", __dir__))
+install_dir = File.join(extension_root, "imgui", "vendor", platform)
+
+desc "Build the bundled cimgui shared library"
+task :compile do
+  ImGuiRuby::NativeBuilder.new(
+    source_dir: __dir__,
+    build_dir: File.join(__dir__, "build"),
+    install_dir: install_dir
+  ).build!
+end
+
+task default: :compile