rrtrace 0.1.0

data/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "rrtrace"
+version = "0.1.0"
+edition = "2024"
+
+[profile.release]
+overflow-checks = true
+
+[dependencies]
+bytemuck = { version = "1.24.0", features = ["derive"] }
+crossbeam-queue = "0.3.12"
+glam = "0.30.9"
+pollster = "0.4.0"
+rayon-core = "1.13.0"
+smallvec = "1.15.1"
+wgpu = "28.0.0"
+winit = "0.30.12"
+
+[target.'cfg(unix)'.dependencies]
+libc = "0.2.178"
+
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.61.2", features = ["Win32_System_Memory", "Win32_Foundation", "Win32_System_Diagnostics_Debug"] }

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 White-Green
+
+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,39 @@
+# Rrtrace
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rrtrace`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rrtrace.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "standard/rake"
+
+require "rake/extensiontask"
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load("rrtrace.gemspec")
+
+Rake::ExtensionTask.new("rrtrace", GEMSPEC) do |ext|
+  ext.lib_dir = "lib/rrtrace"
+end
+
+task default: %i[clobber compile standard]

data/ext/rrtrace/extconf.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "fileutils"
+
+require_relative "rust_build_helper"
+
+# Makes all symbols private by default to avoid unintended conflict
+# with other gems. To explicitly export symbols you can use RUBY_FUNC_EXPORTED
+# selectively, or entirely remove this flag.
+append_cflags("-fvisibility=hidden")
+
+root_dir = File.expand_path("../../", __dir__)
+RustBuildHelper.build(root_dir)
+
+create_makefile("rrtrace/rrtrace")

data/ext/rrtrace/process_manager_posix.h

@@ -0,0 +1,25 @@
+#ifndef PROCESS_MANAGER_POSIX_H
+#define PROCESS_MANAGER_POSIX_H
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <spawn.h>
+
+typedef pid_t process_id;
+
+extern char **environ;
+
+static inline process_id spawn_process(const char *cmd, char * const* restrict argv) {
+    pid_t pid;
+    int status = posix_spawn(&pid, cmd, NULL, NULL, argv, environ);
+    if (status == 0) return pid;
+    else return 0;
+}
+
+static inline int is_process_running(process_id pid) {
+    int status;
+    waitpid(pid, &status, WNOHANG);
+    return !WIFEXITED(status);
+}
+
+#endif /* PROCESS_MANAGER_POSIX_H */

data/ext/rrtrace/process_manager_windows.h

@@ -0,0 +1,40 @@
+#ifndef PROCESS_MANAGER_WIN_H
+#define PROCESS_MANAGER_WIN_H
+
+#include <windows.h>
+#include <string.h>
+
+typedef HANDLE process_id;
+
+static inline process_id spawn_process(const char *cmd, char * const* argv) {
+    STARTUPINFOA si;
+    PROCESS_INFORMATION pi;
+    ZeroMemory(&si, sizeof(si));
+    si.cb = sizeof(si);
+    ZeroMemory(&pi, sizeof(pi));
+
+    char cmdline[4096] = {0};
+    for (int i = 0; argv[i] != NULL; i++) {
+        if (i > 0) strncat(cmdline, " ", sizeof(cmdline) - strlen(cmdline) - 1);
+        strncat(cmdline, "\"", sizeof(cmdline) - strlen(cmdline) - 1);
+        strncat(cmdline, argv[i], sizeof(cmdline) - strlen(cmdline) - 1);
+        strncat(cmdline, "\"", sizeof(cmdline) - strlen(cmdline) - 1);
+    }
+
+    if (!CreateProcessA(NULL, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
+        return 0;
+    }
+    CloseHandle(pi.hThread);
+    return pi.hProcess;
+}
+
+static inline int is_process_running(process_id pid) {
+    if (pid == NULL) return 0;
+    DWORD exitCode;
+    if (GetExitCodeProcess(pid, &exitCode)) {
+        return exitCode == STILL_ACTIVE;
+    }
+    return 0;
+}
+
+#endif /* PROCESS_MANAGER_WIN_H */

data/ext/rrtrace/rrtrace.c

@@ -0,0 +1,192 @@
+#include "rrtrace.h"
+#include "rrtrace_event_ringbuffer.h"
+
+#ifdef _WIN32
+#include "process_manager_windows.h"
+#include "shared_memory_windows.h"
+#else
+#include "process_manager_posix.h"
+#include "shared_memory_posix.h"
+#endif
+
+// #define RRTRACE_WRITE_DEBUG_LOG
+
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+#include<stdio.h>
+#endif
+
+typedef struct {
+  uint32_t thread_id;
+} ThreadData;
+
+typedef struct {
+  RRTraceEventRingBuffer *event_ringbuffer;
+  process_id visualizer_process_id;
+  rb_internal_thread_specific_key_t thread_data_key;
+  atomic_uint_fast32_t next_thread_id;
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  FILE *log;
+#endif
+} TraceContext;
+
+static inline void push_event(TraceContext *context, RRTraceEvent event) {
+  if (context->event_ringbuffer == NULL) return;
+  while (!rrtrace_event_ringbuffer_push(context->event_ringbuffer, event)) {
+    if (!is_process_running(context->visualizer_process_id)) {
+      context->event_ringbuffer = NULL;
+      break;
+    }
+  }
+}
+
+static uint32_t get_thread_id(TraceContext *context, VALUE thread) {
+  ThreadData *data = rb_internal_thread_specific_get(thread, context->thread_data_key);
+  if (data == NULL) {
+    data = malloc(sizeof(ThreadData));
+    data->thread_id = atomic_fetch_add_explicit(&context->next_thread_id, 1, memory_order_relaxed);
+    rb_internal_thread_specific_set(thread, context->thread_data_key, data);
+  }
+  return data->thread_id;
+}
+
+static void tracepoint_call_handler(VALUE tpval, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  struct rb_trace_arg_struct *tracearg = rb_tracearg_from_tracepoint(tpval);
+  uint64_t method_id = RB_SYM2ID(rb_tracearg_method_id(tracearg));
+  push_event(context, event_call(method_id));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  const char *method_name = rb_id2name(method_id);
+  fprintf(context->log, "CALL: %s\n", method_name);
+  fflush(context->log);
+#endif
+}
+
+static void tracepoint_return_handler(VALUE tpval, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  struct rb_trace_arg_struct *tracearg = rb_tracearg_from_tracepoint(tpval);
+  uint64_t method_id = RB_SYM2ID(rb_tracearg_method_id(tracearg));
+  push_event(context, event_return(method_id));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  const char *method_name = rb_id2name(method_id);
+  fprintf(context->log, "RETURN: %s\n", method_name);
+  fflush(context->log);
+#endif
+}
+
+static void tracepoint_gc_start_handler(VALUE tpval, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_gc_start());
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "GC START\n");
+  fflush(context->log);
+#endif
+}
+
+static void tracepoint_gc_end_handler(VALUE tpval, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_gc_end());
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "GC END\n");
+  fflush(context->log);
+#endif
+}
+
+static void thread_start_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_thread_start(get_thread_id(context, event_data->thread)));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "THREAD START\n");
+  fflush(context->log);
+#endif
+}
+
+static void thread_ready_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_thread_ready(get_thread_id(context, event_data->thread)));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "THREAD READY\n");
+  fflush(context->log);
+#endif
+}
+
+static void thread_suspended_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_thread_suspended(get_thread_id(context, event_data->thread)));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "THREAD SUSPENDED\n");
+  fflush(context->log);
+#endif
+}
+
+static void thread_resume_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_thread_resume(get_thread_id(context, event_data->thread)));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "THREAD RESUME\n");
+  fflush(context->log);
+#endif
+}
+
+static void thread_exit_handler(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *data) {
+  TraceContext *context = (TraceContext *)data;
+  push_event(context, event_thread_exit(get_thread_id(context, event_data->thread)));
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "THREAD EXIT\n");
+  fflush(context->log);
+#endif
+}
+
+RUBY_FUNC_EXPORTED void
+Init_rrtrace(void)
+{
+  TraceContext *context = malloc(sizeof(TraceContext));
+  context->thread_data_key = rb_internal_thread_specific_key_create();
+  atomic_init(&context->next_thread_id, 1);
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  context->log = fopen("rrtrace.log", "w");
+#endif
+
+  char shm_name[64];
+  generate_shared_memory_name(shm_name, sizeof(shm_name));
+  RRTraceEventRingBuffer *ringbuffer = open_shared_memory(shm_name, sizeof(RRTraceEventRingBuffer));
+  if (ringbuffer == NULL) {
+    rb_raise(rb_eRuntimeError, "Failed to create shared memory for rrtrace");
+    return;
+  }
+  rrtrace_event_ringbuffer_init(ringbuffer);
+  context->event_ringbuffer = ringbuffer;
+
+  VALUE mMyGem = rb_const_get(rb_cObject, rb_intern("Rrtrace"));
+  VALUE visualizer = rb_funcall(mMyGem, rb_intern("visualizer_path"), 0);
+  char *visualizer_path = rb_string_value_cstr(&visualizer);
+#ifdef RRTRACE_WRITE_DEBUG_LOG
+  fprintf(context->log, "Visualizer: %s\n", visualizer_path);
+  fprintf(context->log, "Shared Memory: %s\n", shm_name);
+#endif
+  process_id pid = spawn_process(visualizer_path, (char * const[]){visualizer_path, shm_name, NULL});
+  if (pid == 0) {
+    rb_raise(rb_eRuntimeError, "Failed to spawn visualizer process");
+    return;
+  }
+  context->visualizer_process_id = pid;
+
+  ThreadData *main_thread_data = malloc(sizeof(ThreadData));
+  main_thread_data->thread_id = 0;
+  VALUE thread = rb_thread_current();
+  rb_internal_thread_specific_set(thread, context->thread_data_key, main_thread_data);
+
+  VALUE trace_call = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, tracepoint_call_handler, context);
+  VALUE trace_return = rb_tracepoint_new(RUBY_Qnil, RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN, tracepoint_return_handler, context);
+  VALUE trace_gc_start = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_ENTER, tracepoint_gc_start_handler, context);
+  VALUE trace_gc_end = rb_tracepoint_new(RUBY_Qnil, RUBY_INTERNAL_EVENT_GC_EXIT, tracepoint_gc_end_handler, context);
+  rb_internal_thread_add_event_hook(thread_start_handler, RUBY_INTERNAL_THREAD_EVENT_STARTED, context);
+  rb_internal_thread_add_event_hook(thread_ready_handler, RUBY_INTERNAL_THREAD_EVENT_READY, context);
+  rb_internal_thread_add_event_hook(thread_suspended_handler, RUBY_INTERNAL_THREAD_EVENT_SUSPENDED, context);
+  rb_internal_thread_add_event_hook(thread_resume_handler, RUBY_INTERNAL_THREAD_EVENT_RESUMED, context);
+  rb_internal_thread_add_event_hook(thread_exit_handler, RUBY_INTERNAL_THREAD_EVENT_EXITED, context);
+
+  rb_tracepoint_enable(trace_call);
+  rb_tracepoint_enable(trace_return);
+  rb_tracepoint_enable(trace_gc_start);
+  rb_tracepoint_enable(trace_gc_end);
+}

data/ext/rrtrace/rrtrace.h

@@ -0,0 +1,8 @@
+#ifndef RRTRACE_H
+#define RRTRACE_H
+
+#include "ruby.h"
+#include "ruby/debug.h"
+#include "ruby/thread.h"
+
+#endif /* RRTRACE_H */

data/ext/rrtrace/rrtrace_event.h

@@ -0,0 +1,111 @@
+#ifndef RRTRACE_EVENT_H
+#define RRTRACE_EVENT_H
+
+#include <time.h>
+#include <stdatomic.h>
+#include <stdint.h>
+
+#define EVENT_TYPE_CALL             0x0000000000000000ull
+#define EVENT_TYPE_RETURN           0x1000000000000000ull
+#define EVENT_TYPE_GC_START         0x2000000000000000ull
+#define EVENT_TYPE_GC_END           0x3000000000000000ull
+#define EVENT_TYPE_THREAD_START     0x4000000000000000ull
+#define EVENT_TYPE_THREAD_READY     0x5000000000000000ull
+#define EVENT_TYPE_THREAD_SUSPENDED 0x6000000000000000ull
+#define EVENT_TYPE_THREAD_RESUME    0x7000000000000000ull
+#define EVENT_TYPE_THREAD_EXIT      0x8000000000000000ull
+
+#define EVENT_TYPE_MASK             0xF000000000000000ull
+
+typedef struct {
+    uint64_t timestamp_and_event_type;
+    uint64_t data;
+} RRTraceEvent;
+
+static inline uint64_t now(void) {
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    uint64_t timestamp = (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
+
+    static atomic_uint_fast64_t base_timestamp = 0;
+    uint64_t expected = 0;
+    if (atomic_compare_exchange_strong_explicit(&base_timestamp, &expected, timestamp, memory_order_relaxed, memory_order_relaxed)) {
+        return 0;
+    } else {
+        return timestamp - expected;
+    }
+}
+
+static inline RRTraceEvent event_call(uint64_t method_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_CALL;
+    event.data = method_id;
+    return event;
+}
+
+static inline RRTraceEvent event_return(uint64_t method_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_RETURN;
+    event.data = method_id;
+    return event;
+}
+
+static inline RRTraceEvent event_gc_start(void) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_GC_START;
+    return event;
+}
+
+static inline RRTraceEvent event_gc_end(void) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_GC_END;
+    return event;
+}
+
+static inline RRTraceEvent event_thread_start(uint32_t thread_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_THREAD_START;
+    event.data = thread_id;
+    return event;
+}
+
+static inline RRTraceEvent event_thread_ready(uint32_t thread_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_THREAD_READY;
+    event.data = thread_id;
+    return event;
+}
+
+static inline RRTraceEvent event_thread_suspended(uint32_t thread_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_THREAD_SUSPENDED;
+    event.data = thread_id;
+    return event;
+}
+
+static inline RRTraceEvent event_thread_resume(uint32_t thread_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_THREAD_RESUME;
+    event.data = thread_id;
+    return event;
+}
+
+static inline RRTraceEvent event_thread_exit(uint32_t thread_id) {
+    RRTraceEvent event;
+    event.timestamp_and_event_type = now() | EVENT_TYPE_THREAD_EXIT;
+    event.data = thread_id;
+    return event;
+}
+
+#undef EVENT_TYPE_CALL
+#undef EVENT_TYPE_RETURN
+#undef EVENT_TYPE_GC_START
+#undef EVENT_TYPE_GC_END
+#undef EVENT_TYPE_THREAD_START
+#undef EVENT_TYPE_THREAD_READY
+#undef EVENT_TYPE_THREAD_SUSPENDED
+#undef EVENT_TYPE_THREAD_RESUME
+#undef EVENT_TYPE_THREAD_EXIT
+#undef EVENT_TYPE_MASK
+
+#endif /* RRTRACE_EVENT_H */

data/ext/rrtrace/rrtrace_event_ringbuffer.h

@@ -0,0 +1,45 @@
+#ifndef RRTRACE_EVENT_RINGBUFFER_H
+#define RRTRACE_EVENT_RINGBUFFER_H
+
+#include "rrtrace_event.h"
+
+#define SIZE 65536
+#define MASK (SIZE - 1)
+
+typedef struct {
+    RRTraceEvent buffer[SIZE];
+    alignas(64) struct {
+        atomic_uint_fast64_t write_index;
+        uint64_t read_index_cache;
+    } writer;
+    alignas(64) struct {
+        atomic_uint_fast64_t read_index;
+        uint64_t write_index_cache;
+    } reader;
+} RRTraceEventRingBuffer;
+
+static inline void rrtrace_event_ringbuffer_init(RRTraceEventRingBuffer *rb) {
+    atomic_store_explicit(&rb->writer.write_index, 0, memory_order_relaxed);
+    rb->writer.read_index_cache = 0;
+    atomic_store_explicit(&rb->reader.read_index, 0, memory_order_relaxed);
+    rb->reader.write_index_cache = 0;
+}
+
+static inline int rrtrace_event_ringbuffer_push(RRTraceEventRingBuffer *rb, RRTraceEvent event) {
+    if (rb == NULL) return 1;
+    uint64_t write_index = atomic_load_explicit(&rb->writer.write_index, memory_order_relaxed);
+    uint64_t read_index_cache = rb->writer.read_index_cache;
+    if (write_index - read_index_cache >= SIZE) {
+        read_index_cache = atomic_load_explicit(&rb->reader.read_index, memory_order_acquire);
+        rb->writer.read_index_cache = read_index_cache;
+        if (write_index - read_index_cache >= SIZE) return 0;
+    }
+    rb->buffer[write_index & MASK] = event;
+    atomic_store_explicit(&rb->writer.write_index, write_index + 1, memory_order_release);
+    return 1;
+}
+
+#undef MASK
+#undef SIZE
+
+#endif /* RRTRACE_EVENT_RINGBUFFER_H */

data/ext/rrtrace/rust_build_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+
+module RustBuildHelper
+  def self.build(root_dir)
+    puts "--- Building Rust visualizer ---"
+    cargo_toml = File.join(root_dir, "Cargo.toml")
+
+    unless File.exist?(cargo_toml)
+      puts "Cargo.toml not found at #{cargo_toml}. Skipping rust build (maybe pre-compiled gem?)"
+      return
+    end
+
+    unless system("cargo --version")
+      puts "Cargo not found. Please install Rust to build this gem from source."
+      exit 1
+    end
+
+    # Build rust binary
+    # We use --release for performance of the visualizer
+    sh_cmd = "cargo build --release --locked"
+    puts "Running: #{sh_cmd} in #{root_dir}"
+    unless system(sh_cmd, chdir: root_dir)
+      puts "Failed to build Rust visualizer."
+      exit 1
+    end
+
+    # Copy to libexec
+    exe = "rrtrace#{RbConfig::CONFIG["EXEEXT"]}"
+    src_exe = File.join(root_dir, "target", "release", exe)
+    dest_dir = File.join(root_dir, "libexec")
+    FileUtils.mkdir_p(dest_dir)
+    dest_exe = File.join(dest_dir, exe)
+
+    puts "Copying #{src_exe} to #{dest_exe}"
+    FileUtils.cp(src_exe, dest_exe)
+    FileUtils.chmod(0755, dest_exe) unless Gem.win_platform?
+  end
+end

data/ext/rrtrace/shared_memory_posix.h

@@ -0,0 +1,26 @@
+#ifndef SHARED_MEMORY_POSIX_H
+#define SHARED_MEMORY_POSIX_H
+
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+
+static inline void generate_shared_memory_name(char *buffer, size_t size) {
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    snprintf(buffer, size, "/rrtrace_shm_%d_%d", getpid(), (int)ts.tv_nsec);
+}
+
+static inline void* open_shared_memory(const char *name, int size) {
+    int fd = shm_open(name, O_CREAT | O_RDWR, 0666);
+    if (fd == -1) return NULL;
+    if (ftruncate(fd, size) == -1) return NULL;
+    void *ptr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (ptr == MAP_FAILED) return NULL;
+    return ptr;
+}
+
+#endif /* SHARED_MEMORY_POSIX_H */

data/ext/rrtrace/shared_memory_windows.h

@@ -0,0 +1,34 @@
+#ifndef SHARED_MEMORY_WIN_H
+#define SHARED_MEMORY_WIN_H
+
+#include <windows.h>
+#include <stdio.h>
+
+static inline void generate_shared_memory_name(char *buffer, size_t size) {
+    snprintf(buffer, size, "Local\\rrtrace_shm_%lu_%lu", GetCurrentProcessId(), GetTickCount());
+}
+
+static inline void* open_shared_memory(const char *name, int size) {
+    HANDLE hMapFile = CreateFileMappingA(
+        INVALID_HANDLE_VALUE,
+        NULL,
+        PAGE_READWRITE,
+        0,
+        size,
+        name);
+
+    if (hMapFile == NULL) {
+        return NULL;
+    }
+
+    void *ptr = MapViewOfFile(
+        hMapFile,
+        FILE_MAP_ALL_ACCESS,
+        0,
+        0,
+        size);
+
+    return ptr;
+}
+
+#endif /* SHARED_MEMORY_WIN_H */

data/lib/rrtrace/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rrtrace
+  VERSION = "0.1.0"
+end

data/lib/rrtrace.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "rrtrace/version"
+
+module Rrtrace
+  def self.visualizer_path
+    exe = "rrtrace#{RbConfig::CONFIG["EXEEXT"]}"
+    File.expand_path("../libexec/#{exe}", __dir__)
+  end
+end
+
+require "rrtrace/rrtrace"

data/mise.toml

@@ -0,0 +1,8 @@
+[tools]
+ruby = "4.0.0"
+
+[tasks.setup]
+run = "bundle install"
+
+[tasks.build]
+run = "bundle exec rake build"