io-buffer-atomic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aaf99978c44e1771b3e54d16c21ca881a9a1959a672f09992fcf2ea89c3057f0
+  data.tar.gz: 3225f264e8b69a7b94157896dadc1d2e14257fcb40cb9240d10f50712f8434dd
+SHA512:
+  metadata.gz: 6cc7de2b83ceefefda9a2cab4b2f1b68d5c2b1ce0e74dbdcb4b1db523ab3d8fe4a19bee66e2f123d2b893d9282743a9fd61023002f1cf0c40f5cc620697a3af0
+  data.tar.gz: 9409c51c60fa6904342db119e934de234e5a46d4b1ef6a70728acf9643aca021551b1a5acff796e22b0c38a195b51bfb1b87c9ea8772bca706d9c3f5d7ff7bb9

data/agents.md

@@ -0,0 +1,421 @@
+# Agent
+
+## Context
+
+This section provides links to documentation from installed packages. It is automatically generated and may be updated by running `bake agent:context:install`.
+
+**Important:** Before performing any code, documentation, or analysis tasks, always read and apply the full content of any relevant documentation referenced in the following sections. These context files contain authoritative standards and best practices for documentation, code style, and project-specific workflows. **Do not proceed with any actions until you have read and incorporated the guidance from relevant context files.**
+
+**Setup Instructions:** If the referenced files are not present or if dependencies have been updated, run `bake agent:context:install` to install the latest context files.
+
+### agent-context
+
+Install and manage context files from Ruby gems.
+
+#### [Getting Started](.context/agent-context/getting-started.md)
+
+This guide explains how to use `agent-context`, a tool for discovering and installing contextual information from Ruby gems to help AI agents.
+
+### async
+
+A concurrency framework for Ruby.
+
+#### [Getting Started](.context/async/getting-started.md)
+
+This guide shows how to add async to your project and run code asynchronously.
+
+#### [Scheduler](.context/async/scheduler.md)
+
+This guide gives an overview of how the scheduler is implemented.
+
+#### [Tasks](.context/async/tasks.md)
+
+This guide explains how asynchronous tasks work and how to use them.
+
+#### [Best Practices](.context/async/best-practices.md)
+
+This guide gives an overview of best practices for using Async.
+
+#### [Debugging](.context/async/debugging.md)
+
+This guide explains how to debug issues with programs that use Async.
+
+#### [Thread safety](.context/async/thread-safety.md)
+
+This guide explains thread safety in Ruby, focusing on fibers and threads, common pitfalls, and best practices to avoid problems like data corruption, race conditions, and deadlocks.
+
+### async-container-supervisor
+
+A supervisor for managing multiple container processes.
+
+#### [Getting Started](.context/async-container-supervisor/getting-started.md)
+
+This guide explains how to get started with `async-container-supervisor` to supervise and monitor worker processes in your Ruby applications.
+
+#### [Memory Monitor](.context/async-container-supervisor/memory-monitor.md)
+
+This guide explains how to use the <code class="language-ruby">Async::Container::Supervisor::MemoryMonitor</code> to detect and restart workers that exceed memory limits or develop memory leaks.
+
+#### [Process Monitor](.context/async-container-supervisor/process-monitor.md)
+
+This guide explains how to use the <code class="language-ruby">Async::Container::Supervisor::ProcessMonitor</code> to log CPU and memory metrics for your worker processes.
+
+### async-http
+
+A HTTP client and server library.
+
+#### [Getting Started](.context/async-http/getting-started.md)
+
+This guide explains how to get started with `Async::HTTP`.
+
+#### [Testing](.context/async-http/testing.md)
+
+This guide explains how to use `Async::HTTP` clients and servers in your tests.
+
+### async-http-cache
+
+Standard-compliant cache for async-http.
+
+#### [Getting Started](.context/async-http-cache/getting-started.md)
+
+This guide explains how to get started with `async-http-cache`, a cache middleware for `Async::HTTP` clients and servers.
+
+### async-service
+
+A service layer for Async.
+
+#### [Getting Started](.context/async-service/getting-started.md)
+
+This guide explains how to get started with `async-service` to create and run services in Ruby.
+
+#### [Container Policies](.context/async-service/policies.md)
+
+This guide explains how to configure container policies for your services and understand the default failure handling behavior.
+
+#### [Service Architecture](.context/async-service/service-architecture.md)
+
+This guide explains the key architectural components of `async-service` and how they work together to provide a clean separation of concerns.
+
+#### [Best Practices](.context/async-service/best-practices.md)
+
+This guide outlines recommended patterns and practices for building robust, maintainable services with `async-service`.
+
+#### [Deployment](.context/async-service/deployment.md)
+
+This guide explains how to deploy `async-service` applications using systemd and Kubernetes. We'll use a simple example service to demonstrate deployment configurations.
+
+### bake
+
+A replacement for rake with a simpler syntax.
+
+#### [Getting Started](.context/bake/getting-started.md)
+
+This guide gives a general overview of `bake` and how to use it.
+
+#### [Command Line Interface](.context/bake/command-line-interface.md)
+
+The `bake` command is broken up into two main functions: `list` and `call`.
+
+#### [Project Integration](.context/bake/project-integration.md)
+
+This guide explains how to add `bake` to a Ruby project.
+
+#### [Gem Integration](.context/bake/gem-integration.md)
+
+This guide explains how to add `bake` to a Ruby gem and export standardised tasks for use by other gems and projects.
+
+#### [Input and Output](.context/bake/input-and-output.md)
+
+`bake` has built in tasks for reading input and writing output in different formats. While this can be useful for general processing, there are some limitations, notably that rich object representations like `json` and `yaml` often don't support stream processing.
+
+### bake-gem
+
+Release management for Ruby gems.
+
+#### [Getting Started](.context/bake-gem/getting-started.md)
+
+This guide explains how to use `bake-gem` to release gems safely and efficiently.
+
+### bake-releases
+
+Releases document management.
+
+#### [Getting Started](.context/bake-releases/getting-started.md)
+
+This guide explains how to use `bake-releases` to manage release documentation for your Ruby gem.
+
+### covered
+
+A modern approach to code coverage.
+
+#### [Getting Started](.context/covered/getting-started.md)
+
+This guide explains how to get started with `covered` and integrate it with your test suite.
+
+#### [Configuration](.context/covered/configuration.md)
+
+This guide will help you to configure covered for your project's specific requirements.
+
+### decode
+
+Code analysis for documentation generation.
+
+#### [Getting Started](.context/decode/getting-started.md)
+
+This guide explains how to use `decode` for source code analysis.
+
+#### [Documentation Coverage](.context/decode/documentation-coverage.md)
+
+This guide explains how to test and monitor documentation coverage in your Ruby projects using the Decode gem's built-in bake tasks.
+
+#### [Ruby Documentation](.context/decode/ruby-documentation.md)
+
+This guide covers documentation practices and pragmas supported by the Decode gem for documenting Ruby code. These pragmas provide structured documentation that can be parsed and used to generate API documentation and achieve complete documentation coverage.
+
+### falcon
+
+A fast, asynchronous, rack-compatible web server.
+
+#### [Getting Started](.context/falcon/getting-started.md)
+
+This guide gives an overview of how to use Falcon for running Ruby web applications.
+
+#### [Rails Integration](.context/falcon/rails-integration.md)
+
+This guide explains how to host Rails applications with Falcon.
+
+#### [Deployment](.context/falcon/deployment.md)
+
+This guide explains how to deploy applications using the Falcon web server. It covers the recommended deployment methods, configuration options, and examples for different environments, including systemd and kubernetes.
+
+#### [Performance Tuning](.context/falcon/performance-tuning.md)
+
+This guide explains the performance characteristics of Falcon.
+
+#### [WebSockets](.context/falcon/websockets.md)
+
+This guide explains how to use WebSockets with Falcon.
+
+#### [Interim Responses](.context/falcon/interim-responses.md)
+
+This guide explains how to use interim responses in Falcon to send early hints to the client.
+
+#### [How It Works](.context/falcon/how-it-works.md)
+
+This guide gives an overview of how Falcon handles an incoming web request.
+
+### io-endpoint
+
+Provides a separation of concerns interface for IO endpoints.
+
+#### [Getting Started](.context/io-endpoint/getting-started.md)
+
+This guide explains how to get started with `io-endpoint`, a library that provides a separation of concerns interface for network I/O endpoints.
+
+#### [Named Endpoints](.context/io-endpoint/named-endpoints.md)
+
+This guide explains how to use `IO::Endpoint::NamedEndpoints` to manage multiple endpoints by name, enabling scenarios like running the same application on different protocols or ports.
+
+### io-event
+
+An event loop.
+
+#### [Getting Started](.context/io-event/getting-started.md)
+
+This guide explains how to use `io-event` for non-blocking IO.
+
+### markly
+
+CommonMark parser and renderer. Written in C, wrapped in Ruby.
+
+#### [Getting Started](.context/markly/getting-started.md)
+
+This guide explains now to install and use Markly.
+
+#### [Abstract Syntax Tree](.context/markly/abstract-syntax-tree.md)
+
+This guide explains how to use Markly's abstract syntax tree (AST) to parse and manipulate Markdown documents.
+
+#### [Headings](.context/markly/headings.md)
+
+This guide explains how to work with headings in Markly, including extracting them for navigation and handling duplicate heading text.
+
+### memory
+
+Memory profiling routines for Ruby 2.3+
+
+#### [Getting Started](.context/memory/getting-started.md)
+
+This guide explains how to get started with `memory`, a Ruby gem for profiling memory allocations in your applications.
+
+### metrics
+
+Application metrics and instrumentation.
+
+#### [Getting Started](.context/metrics/getting-started.md)
+
+This guide explains how to use `metrics` for capturing run-time metrics.
+
+#### [Capture](.context/metrics/capture.md)
+
+This guide explains how to use `metrics` for exporting metric definitions from your application.
+
+#### [Testing](.context/metrics/testing.md)
+
+This guide explains how to write assertions in your test suite to validate `metrics` are being emitted correctly.
+
+### process-metrics
+
+Provide detailed OS-specific process metrics.
+
+#### [Getting Started](.context/process-metrics/getting-started.md)
+
+This guide explains how to use the `process-metrics` gem to collect and analyze process metrics including processor and memory utilization.
+
+### protocol-http
+
+Provides abstractions to handle HTTP protocols.
+
+#### [Getting Started](.context/protocol-http/getting-started.md)
+
+This guide explains how to use `protocol-http` for building abstract HTTP interfaces.
+
+#### [Message Body](.context/protocol-http/message-body.md)
+
+This guide explains how to work with HTTP request and response message bodies using `Protocol::HTTP::Body` classes.
+
+#### [Headers](.context/protocol-http/headers.md)
+
+This guide explains how to work with HTTP headers using `protocol-http`.
+
+#### [Middleware](.context/protocol-http/middleware.md)
+
+This guide explains how to build and use HTTP middleware with `Protocol::HTTP::Middleware`.
+
+#### [Streaming](.context/protocol-http/streaming.md)
+
+This guide gives an overview of how to implement streaming requests and responses.
+
+#### [Design Overview](.context/protocol-http/design-overview.md)
+
+This guide explains the high level design of `protocol-http` in the context of wider design patterns that can be used to implement HTTP clients and servers.
+
+### protocol-http1
+
+A low level implementation of the HTTP/1 protocol.
+
+#### [Getting Started](.context/protocol-http1/getting-started.md)
+
+This guide explains how to get started with `protocol-http1`, a low-level implementation of the HTTP/1 protocol for building HTTP clients and servers.
+
+### protocol-http2
+
+A low level implementation of the HTTP/2 protocol.
+
+#### [Getting Started](.context/protocol-http2/getting-started.md)
+
+This guide explains how to use the `protocol-http2` gem to implement a basic HTTP/2 client.
+
+### protocol-rack
+
+An implementation of the Rack protocol/specification.
+
+#### [Getting Started](.context/protocol-rack/getting-started.md)
+
+This guide explains how to get started with `protocol-rack` and integrate Rack applications with `Protocol::HTTP` servers.
+
+#### [Request and Response Handling](.context/protocol-rack/request-response.md)
+
+This guide explains how to work with requests and responses when bridging between Rack and `Protocol::HTTP`, covering advanced use cases and edge cases.
+
+### samovar
+
+Samovar is a flexible option parser excellent support for sub-commands and help documentation.
+
+#### [Getting Started](.context/samovar/getting-started.md)
+
+This guide explains how to use `samovar` to build command-line tools and applications.
+
+### sus
+
+A fast and scalable test runner.
+
+#### [Getting Started](.context/sus/getting-started.md)
+
+This guide explains how to use the `sus` gem to write tests for your Ruby projects.
+
+#### [Mocking](.context/sus/mocking.md)
+
+This guide explains how to use mocking in sus to isolate dependencies and verify interactions in your tests.
+
+#### [Shared Test Behaviors and Fixtures](.context/sus/shared-contexts.md)
+
+This guide explains how to use shared test contexts and fixtures in sus to reduce duplication and ensure consistent test behavior across your test suite.
+
+### traces
+
+Application instrumentation and tracing.
+
+#### [Getting Started](.context/traces/getting-started.md)
+
+This guide explains how to use `traces` for tracing code execution.
+
+#### [Context Propagation](.context/traces/context-propagation.md)
+
+This guide explains how to propagate trace context between different execution contexts within your application using `Traces.current_context` and `Traces.with_context`.
+
+#### [Testing](.context/traces/testing.md)
+
+This guide explains how to test traces in your code.
+
+#### [Capture](.context/traces/capture.md)
+
+This guide explains how to use `traces` for exporting traces from your application. This can be used to document all possible traces.
+
+### utopia
+
+Utopia is a framework for building dynamic content-driven websites.
+
+#### [Getting Started](.context/utopia/getting-started.md)
+
+This guide explains how to set up a `utopia` website for local development and deployment.
+
+#### [Middleware](.context/utopia/middleware.md)
+
+This guide gives an overview of the different Rack middleware used by Utopia.
+
+#### [Server Setup](.context/utopia/server-setup.md)
+
+This guide explains how to deploy a `utopia` web application.
+
+#### [Integrating with JavaScript](.context/utopia/integrating-with-javascript.md)
+
+This guide explains how to integrate JavaScript into your Utopia application.
+
+#### [What is XNode?](.context/utopia/what-is-xnode.md)
+
+This guide explains the `xnode` view layer and how it can be used to build efficient websites.
+
+#### [Updating Utopia](.context/utopia/updating-utopia.md)
+
+This guide explains how to update existing `utopia` websites.
+
+### utopia-project
+
+A project documentation tool based on Utopia.
+
+#### [Getting Started](.context/utopia-project/getting-started.md)
+
+This guide explains how to use `utopia-project` to add documentation to your project.
+
+#### [Documentation Guides](.context/utopia-project/documentation-guidelines.md)
+
+This guide explains how to create and maintain documentation for your project using `utopia-project`.
+
+#### [Mermaid Diagrams](.context/utopia-project/mermaid-diagrams.md)
+
+This guide explains how to use Mermaid diagrams in your documentation to visualize complex relationships, flows, and architectures.
+
+#### [GitHub Pages Integration](.context/utopia-project/github-pages-integration.md)
+
+This guide shows you how to use `utopia-project` with GitHub Pages to deploy documentation.

data/ext/extconf.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+return if RUBY_DESCRIPTION =~ /jruby/
+
+require "mkmf"
+
+gem_name = File.basename(__dir__)
+extension_name = "IO_Buffer_Atomic"
+
+append_cflags(["-Wall", "-Wno-unknown-pragmas", "-std=c11"])
+
+if ENV.key?("RUBY_DEBUG")
+	$stderr.puts "Enabling debug mode..."
+	
+	append_cflags(["-DRUBY_DEBUG", "-O0"])
+end
+
+$srcs = ["io/buffer/atomic.c"]
+$VPATH << "$(srcdir)/io/buffer"
+
+have_header("ruby/io/buffer.h")
+have_header("ruby/atomic.h")
+
+# Check for atomic operations support
+# Ruby's atomic.h handles platform detection, but we also need stdatomic.h for typed operations
+if have_header("stdatomic.h")
+	have_func("atomic_fetch_add", "stdatomic.h")
+elsif have_func("__atomic_add_fetch", "stdint.h")
+	# GCC built-in atomics are available
+elsif have_func("_InterlockedExchangeAdd", "intrin.h")
+	# MSVC intrinsics are available
+else
+	$stderr.puts "Warning: Atomic operations may not be available."
+end
+
+if ENV.key?("RUBY_SANITIZE")
+	$stderr.puts "Enabling sanitizers..."
+	
+	# Add address and undefined behaviour sanitizers:
+	append_cflags(["-fsanitize=address", "-fsanitize=undefined", "-fno-omit-frame-pointer"])
+	$LDFLAGS << " -fsanitize=address -fsanitize=undefined"
+end
+
+create_header
+
+# Generate the makefile to compile the native binary into `lib`:
+create_makefile(extension_name)

data/ext/io/buffer/atomic.c

@@ -0,0 +1,506 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include <ruby.h>
+#include <ruby/io/buffer.h>
+#include <ruby/atomic.h>
+#include <stdint.h>
+#include <string.h>
+
+// We need stdatomic.h for typed atomic operations on different widths
+#ifdef HAVE_STDATOMIC_H
+	#include <stdatomic.h>
+	#define HAVE_TYPED_ATOMICS 1
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+	// Use GCC built-in atomic operations
+	#define USE_GCC_ATOMICS 1
+	#define HAVE_TYPED_ATOMICS 1
+#elif defined(_MSC_VER)
+	// Use MSVC intrinsics
+	#include <intrin.h>
+	#define USE_MSVC_ATOMICS 1
+	#define HAVE_TYPED_ATOMICS 1
+#else
+	#error "Atomic operations not available on this platform"
+#endif
+
+// Helper to get buffer pointer and validate
+static void* get_buffer_pointer(VALUE buffer, size_t offset, size_t size) {
+	void *base;
+	size_t buffer_size;
+	
+	rb_io_buffer_get_bytes_for_writing(buffer, &base, &buffer_size);
+	
+	if (offset + size > buffer_size) {
+		rb_raise(rb_eRangeError, "Offset + size exceeds buffer size");
+	}
+	
+	return (char*)base + offset;
+}
+
+// Convert Ruby symbol to ID
+static ID get_type_id(VALUE type_sym) {
+	return RB_SYM2ID(type_sym);
+}
+
+#ifdef HAVE_TYPED_ATOMICS
+
+#ifdef HAVE_STDATOMIC_H
+// Using stdatomic.h - proper typed atomic operations
+
+// Static IDs for type checking (initialized in Init function)
+static ID RB_IO_BUFFER_DATA_TYPE_U8;
+static ID RB_IO_BUFFER_DATA_TYPE_S8;
+static ID RB_IO_BUFFER_DATA_TYPE_u16;
+static ID RB_IO_BUFFER_DATA_TYPE_U16;
+static ID RB_IO_BUFFER_DATA_TYPE_s16;
+static ID RB_IO_BUFFER_DATA_TYPE_S16;
+static ID RB_IO_BUFFER_DATA_TYPE_u32;
+static ID RB_IO_BUFFER_DATA_TYPE_U32;
+static ID RB_IO_BUFFER_DATA_TYPE_s32;
+static ID RB_IO_BUFFER_DATA_TYPE_S32;
+static ID RB_IO_BUFFER_DATA_TYPE_u64;
+static ID RB_IO_BUFFER_DATA_TYPE_U64;
+static ID RB_IO_BUFFER_DATA_TYPE_s64;
+static ID RB_IO_BUFFER_DATA_TYPE_S64;
+
+// Macro for atomic fetch_add operations (returns new value)
+#define ATOMIC_FETCH_ADD_IMPL(name, ctype, atomic_type, size, num2val, val2num) \
+	static VALUE atomic_fetch_add_##name(VALUE self, size_t offset, long value) { \
+		void *pointer = get_buffer_pointer(self, offset, size); \
+		ctype result = atomic_fetch_add((atomic_type*)pointer, (ctype)value) + (ctype)value; \
+		return val2num(result); \
+	}
+
+// Macro for atomic bitwise operations (returns new value)
+#define ATOMIC_BITWISE_IMPL(name, ctype, atomic_type, size, num2val, val2num, op) \
+	static VALUE atomic_##op##_##name(VALUE self, size_t offset, long value) { \
+		void *pointer = get_buffer_pointer(self, offset, size); \
+		atomic_fetch_##op((atomic_type*)pointer, (ctype)value); \
+		ctype result = atomic_load((atomic_type*)pointer); \
+		return val2num(result); \
+	}
+
+// Macro for atomic load (works on raw bytes in host endian)
+#define ATOMIC_LOAD_IMPL(name, ctype, atomic_type, size, num2val, val2num) \
+	static VALUE atomic_load_##name(VALUE self, size_t offset) { \
+		void *pointer = get_buffer_pointer(self, offset, size); \
+		ctype result = atomic_load((atomic_type*)pointer); \
+		return val2num(result); \
+	}
+
+// Macro for atomic store (works on raw bytes in host endian)
+#define ATOMIC_STORE_IMPL(name, ctype, atomic_type, size, num2val, val2num) \
+	static VALUE atomic_store_##name(VALUE self, size_t offset, VALUE value) { \
+		void *pointer = get_buffer_pointer(self, offset, size); \
+		ctype converted_value = (ctype)num2val(value); \
+		atomic_store((atomic_type*)pointer, converted_value); \
+		return self; \
+	}
+
+// Macro for atomic compare and swap
+#define ATOMIC_CAS_IMPL(name, ctype, atomic_type, size, num2val, val2num) \
+	static int atomic_cas_##name(VALUE self, size_t offset, VALUE expected_value, VALUE desired_value) { \
+		void *pointer = get_buffer_pointer(self, offset, size); \
+		ctype expected = (ctype)num2val(expected_value); \
+		ctype desired = (ctype)num2val(desired_value); \
+		/* atomic_compare_exchange_strong already checks if current == expected */ \
+		return atomic_compare_exchange_strong((atomic_type*)pointer, &expected, desired); \
+	}
+
+// Generate implementations for each type
+ATOMIC_FETCH_ADD_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM)
+ATOMIC_FETCH_ADD_IMPL(i8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM)
+ATOMIC_FETCH_ADD_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM)
+ATOMIC_FETCH_ADD_IMPL(i16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM)
+ATOMIC_FETCH_ADD_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM)
+ATOMIC_FETCH_ADD_IMPL(i32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM)
+ATOMIC_FETCH_ADD_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM)
+ATOMIC_FETCH_ADD_IMPL(i64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM)
+
+ATOMIC_BITWISE_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM, and)
+ATOMIC_BITWISE_IMPL(i8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM, and)
+ATOMIC_BITWISE_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM, and)
+ATOMIC_BITWISE_IMPL(i16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM, and)
+ATOMIC_BITWISE_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM, and)
+ATOMIC_BITWISE_IMPL(i32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM, and)
+ATOMIC_BITWISE_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM, and)
+ATOMIC_BITWISE_IMPL(i64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM, and)
+
+ATOMIC_BITWISE_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM, or)
+ATOMIC_BITWISE_IMPL(i8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM, or)
+ATOMIC_BITWISE_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM, or)
+ATOMIC_BITWISE_IMPL(i16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM, or)
+ATOMIC_BITWISE_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM, or)
+ATOMIC_BITWISE_IMPL(i32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM, or)
+ATOMIC_BITWISE_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM, or)
+ATOMIC_BITWISE_IMPL(i64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM, or)
+
+ATOMIC_BITWISE_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM, xor)
+ATOMIC_BITWISE_IMPL(i8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM, xor)
+ATOMIC_BITWISE_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM, xor)
+ATOMIC_BITWISE_IMPL(i16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM, xor)
+ATOMIC_BITWISE_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM, xor)
+ATOMIC_BITWISE_IMPL(i32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM, xor)
+ATOMIC_BITWISE_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM, xor)
+ATOMIC_BITWISE_IMPL(i64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM, xor)
+
+// Atomic load/store work on raw bytes in host endian (both :u32 and :U32 map to same implementation)
+ATOMIC_LOAD_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM)
+ATOMIC_LOAD_IMPL(s8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM)
+ATOMIC_LOAD_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM)
+ATOMIC_LOAD_IMPL(s16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM)
+ATOMIC_LOAD_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM)
+ATOMIC_LOAD_IMPL(s32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM)
+ATOMIC_LOAD_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM)
+ATOMIC_LOAD_IMPL(s64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM)
+
+ATOMIC_STORE_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM)
+ATOMIC_STORE_IMPL(s8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM)
+ATOMIC_STORE_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM)
+ATOMIC_STORE_IMPL(s16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM)
+ATOMIC_STORE_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM)
+ATOMIC_STORE_IMPL(s32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM)
+ATOMIC_STORE_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM)
+ATOMIC_STORE_IMPL(s64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM)
+
+ATOMIC_CAS_IMPL(u8, uint8_t, atomic_uint_least8_t, 1, NUM2UINT, UINT2NUM)
+ATOMIC_CAS_IMPL(i8, int8_t, atomic_int_least8_t, 1, NUM2INT, INT2NUM)
+ATOMIC_CAS_IMPL(u16, uint16_t, atomic_uint_least16_t, 2, NUM2UINT, UINT2NUM)
+ATOMIC_CAS_IMPL(i16, int16_t, atomic_int_least16_t, 2, NUM2INT, INT2NUM)
+ATOMIC_CAS_IMPL(u32, uint32_t, atomic_uint_least32_t, 4, NUM2UINT, UINT2NUM)
+ATOMIC_CAS_IMPL(i32, int32_t, atomic_int_least32_t, 4, NUM2INT, INT2NUM)
+ATOMIC_CAS_IMPL(u64, uint64_t, atomic_uint_least64_t, 8, NUM2ULL, ULL2NUM)
+ATOMIC_CAS_IMPL(i64, int64_t, atomic_int_least64_t, 8, NUM2LL, LL2NUM)
+
+// Generic implementations using macros (similar to Ruby's IO_BUFFER_SET_VALUE pattern)
+static VALUE atomic_increment_impl(VALUE self, ID type_identifier, size_t offset, long value) {
+#define ATOMIC_FETCH_ADD_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_fetch_add_##impl_name(self, offset, value); \
+	}
+	
+	ATOMIC_FETCH_ADD_CASE(U8, u8)
+	ATOMIC_FETCH_ADD_CASE(S8, i8)
+	ATOMIC_FETCH_ADD_CASE(u16, u16)
+	ATOMIC_FETCH_ADD_CASE(U16, u16)
+	ATOMIC_FETCH_ADD_CASE(s16, i16)
+	ATOMIC_FETCH_ADD_CASE(S16, i16)
+	ATOMIC_FETCH_ADD_CASE(u32, u32)
+	ATOMIC_FETCH_ADD_CASE(U32, u32)
+	ATOMIC_FETCH_ADD_CASE(s32, i32)
+	ATOMIC_FETCH_ADD_CASE(S32, i32)
+	ATOMIC_FETCH_ADD_CASE(u64, u64)
+	ATOMIC_FETCH_ADD_CASE(U64, u64)
+	ATOMIC_FETCH_ADD_CASE(s64, i64)
+	ATOMIC_FETCH_ADD_CASE(S64, i64)
+#undef ATOMIC_FETCH_ADD_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_and_impl(VALUE self, ID type_identifier, size_t offset, long value) {
+#define ATOMIC_AND_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_and_##impl_name(self, offset, value); \
+	}
+	
+	ATOMIC_AND_CASE(U8, u8)
+	ATOMIC_AND_CASE(S8, i8)
+	ATOMIC_AND_CASE(u16, u16)
+	ATOMIC_AND_CASE(U16, u16)
+	ATOMIC_AND_CASE(s16, i16)
+	ATOMIC_AND_CASE(S16, i16)
+	ATOMIC_AND_CASE(u32, u32)
+	ATOMIC_AND_CASE(U32, u32)
+	ATOMIC_AND_CASE(s32, i32)
+	ATOMIC_AND_CASE(S32, i32)
+	ATOMIC_AND_CASE(u64, u64)
+	ATOMIC_AND_CASE(U64, u64)
+	ATOMIC_AND_CASE(s64, i64)
+	ATOMIC_AND_CASE(S64, i64)
+#undef ATOMIC_AND_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_or_impl(VALUE self, ID type_identifier, size_t offset, long value) {
+#define ATOMIC_OR_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_or_##impl_name(self, offset, value); \
+	}
+	
+	ATOMIC_OR_CASE(U8, u8)
+	ATOMIC_OR_CASE(S8, i8)
+	ATOMIC_OR_CASE(u16, u16)
+	ATOMIC_OR_CASE(U16, u16)
+	ATOMIC_OR_CASE(s16, i16)
+	ATOMIC_OR_CASE(S16, i16)
+	ATOMIC_OR_CASE(u32, u32)
+	ATOMIC_OR_CASE(U32, u32)
+	ATOMIC_OR_CASE(s32, i32)
+	ATOMIC_OR_CASE(S32, i32)
+	ATOMIC_OR_CASE(u64, u64)
+	ATOMIC_OR_CASE(U64, u64)
+	ATOMIC_OR_CASE(s64, i64)
+	ATOMIC_OR_CASE(S64, i64)
+#undef ATOMIC_OR_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_xor_impl(VALUE self, ID type_identifier, size_t offset, long value) {
+#define ATOMIC_XOR_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_xor_##impl_name(self, offset, value); \
+	}
+	
+	ATOMIC_XOR_CASE(U8, u8)
+	ATOMIC_XOR_CASE(S8, i8)
+	ATOMIC_XOR_CASE(u16, u16)
+	ATOMIC_XOR_CASE(U16, u16)
+	ATOMIC_XOR_CASE(s16, i16)
+	ATOMIC_XOR_CASE(S16, i16)
+	ATOMIC_XOR_CASE(u32, u32)
+	ATOMIC_XOR_CASE(U32, u32)
+	ATOMIC_XOR_CASE(s32, i32)
+	ATOMIC_XOR_CASE(S32, i32)
+	ATOMIC_XOR_CASE(u64, u64)
+	ATOMIC_XOR_CASE(U64, u64)
+	ATOMIC_XOR_CASE(s64, i64)
+	ATOMIC_XOR_CASE(S64, i64)
+#undef ATOMIC_XOR_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_load_impl(VALUE self, ID type_identifier, size_t offset) {
+#define ATOMIC_LOAD_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_load_##impl_name(self, offset); \
+	}
+	
+	// Support both uppercase and lowercase (they map to same implementation - atomic ops work on raw bytes)
+	ATOMIC_LOAD_CASE(U8, u8)
+	ATOMIC_LOAD_CASE(S8, s8)
+	ATOMIC_LOAD_CASE(u16, u16)
+	ATOMIC_LOAD_CASE(s16, s16)
+	ATOMIC_LOAD_CASE(U16, u16)
+	ATOMIC_LOAD_CASE(S16, s16)
+	ATOMIC_LOAD_CASE(u32, u32)
+	ATOMIC_LOAD_CASE(s32, s32)
+	ATOMIC_LOAD_CASE(U32, u32)
+	ATOMIC_LOAD_CASE(S32, s32)
+	ATOMIC_LOAD_CASE(u64, u64)
+	ATOMIC_LOAD_CASE(s64, s64)
+	ATOMIC_LOAD_CASE(U64, u64)
+	ATOMIC_LOAD_CASE(S64, s64)
+#undef ATOMIC_LOAD_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_store_impl(VALUE self, ID type_identifier, size_t offset, VALUE value) {
+#define ATOMIC_STORE_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_store_##impl_name(self, offset, value); \
+	}
+	
+	// Support both uppercase and lowercase (they map to same implementation - atomic ops work on raw bytes)
+	ATOMIC_STORE_CASE(U8, u8)
+	ATOMIC_STORE_CASE(S8, s8)
+	ATOMIC_STORE_CASE(u16, u16)
+	ATOMIC_STORE_CASE(s16, s16)
+	ATOMIC_STORE_CASE(U16, u16)
+	ATOMIC_STORE_CASE(S16, s16)
+	ATOMIC_STORE_CASE(u32, u32)
+	ATOMIC_STORE_CASE(s32, s32)
+	ATOMIC_STORE_CASE(U32, u32)
+	ATOMIC_STORE_CASE(S32, s32)
+	ATOMIC_STORE_CASE(u64, u64)
+	ATOMIC_STORE_CASE(s64, s64)
+	ATOMIC_STORE_CASE(U64, u64)
+	ATOMIC_STORE_CASE(S64, s64)
+#undef ATOMIC_STORE_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qnil;
+}
+
+static VALUE atomic_compare_and_swap_impl(VALUE self, ID type_identifier, size_t offset, VALUE expected_value, VALUE desired_value) {
+#define ATOMIC_CAS_CASE(name, impl_name) \
+	if (type_identifier == RB_IO_BUFFER_DATA_TYPE_##name) { \
+		return atomic_cas_##impl_name(self, offset, expected_value, desired_value) ? Qtrue : Qfalse; \
+	}
+	
+	ATOMIC_CAS_CASE(U8, u8)
+	ATOMIC_CAS_CASE(S8, i8)
+	ATOMIC_CAS_CASE(u16, u16)
+	ATOMIC_CAS_CASE(U16, u16)
+	ATOMIC_CAS_CASE(s16, i16)
+	ATOMIC_CAS_CASE(S16, i16)
+	ATOMIC_CAS_CASE(u32, u32)
+	ATOMIC_CAS_CASE(U32, u32)
+	ATOMIC_CAS_CASE(s32, i32)
+	ATOMIC_CAS_CASE(S32, i32)
+	ATOMIC_CAS_CASE(u64, u64)
+	ATOMIC_CAS_CASE(U64, u64)
+	ATOMIC_CAS_CASE(s64, i64)
+	ATOMIC_CAS_CASE(S64, i64)
+#undef ATOMIC_CAS_CASE
+	
+	rb_raise(rb_eArgError, "Unsupported type for atomic operations: %"PRIsVALUE, rb_id2str(type_identifier));
+	return Qfalse;
+}
+
+#endif // HAVE_STDATOMIC_H
+
+#else
+#error "Typed atomic operations not available"
+#endif // HAVE_TYPED_ATOMICS
+
+// Ruby method wrappers
+static VALUE atomic_increment(int argc, VALUE *argv, VALUE self) {
+	VALUE type_symbol, offset_value, value_value;
+	
+	rb_scan_args(argc, argv, "21", &type_symbol, &offset_value, &value_value);
+	
+	if (value_value == Qnil) {
+		value_value = INT2NUM(1);
+	}
+	
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_increment_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_decrement(int argc, VALUE *argv, VALUE self) {
+	VALUE type_symbol, offset_value, value_value;
+	
+	rb_scan_args(argc, argv, "21", &type_symbol, &offset_value, &value_value);
+	
+	if (value_value == Qnil) {
+		value_value = INT2NUM(1);
+	}
+	
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_increment_impl(self, type_identifier, offset, -value);
+}
+
+static VALUE atomic_add(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_increment_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_subtract(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_increment_impl(self, type_identifier, offset, -value);
+}
+
+static VALUE atomic_and(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_and_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_or(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_or_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_xor(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	long value = NUM2LONG(value_value);
+	
+	return atomic_xor_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_load_method(VALUE self, VALUE type_symbol, VALUE offset_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	
+	return atomic_load_impl(self, type_identifier, offset);
+}
+
+static VALUE atomic_store_method(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	
+	return atomic_store_impl(self, type_identifier, offset, value);
+}
+
+static VALUE atomic_compare_and_swap(VALUE self, VALUE type_symbol, VALUE offset_value, VALUE expected_value, VALUE desired_value) {
+	ID type_identifier = get_type_id(type_symbol);
+	size_t offset = NUM2SIZET(offset_value);
+	
+	return atomic_compare_and_swap_impl(self, type_identifier, offset, expected_value, desired_value);
+}
+
+// Helper macro to define method only if it doesn't exist
+// Uses rb_method_boundp to check if method is already defined (feature detection)
+#define DEFINE_METHOD_IF_NOT_EXISTS(klass, name, func, argc) \
+	do { \
+		ID method_identifier = rb_intern(name); \
+		if (!rb_method_boundp(klass, method_identifier, 0)) { \
+			rb_define_method(klass, name, func, argc); \
+		} \
+	} while (0)
+
+void Init_IO_Buffer_Atomic(void) {
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+	rb_ext_ractor_safe(true);
+#endif
+	
+	VALUE IO_Buffer = rb_const_get(rb_cIO, rb_intern("Buffer"));
+	
+	// Initialize type IDs (support both forms for compatibility, but atomic operations work on raw bytes in host endian)
+#define IO_BUFFER_DEFINE_DATA_TYPE(name) RB_IO_BUFFER_DATA_TYPE_##name = rb_intern_const(#name)
+	IO_BUFFER_DEFINE_DATA_TYPE(U8);
+	IO_BUFFER_DEFINE_DATA_TYPE(S8);
+	IO_BUFFER_DEFINE_DATA_TYPE(u16);
+	IO_BUFFER_DEFINE_DATA_TYPE(U16);
+	IO_BUFFER_DEFINE_DATA_TYPE(s16);
+	IO_BUFFER_DEFINE_DATA_TYPE(S16);
+	IO_BUFFER_DEFINE_DATA_TYPE(u32);
+	IO_BUFFER_DEFINE_DATA_TYPE(U32);
+	IO_BUFFER_DEFINE_DATA_TYPE(s32);
+	IO_BUFFER_DEFINE_DATA_TYPE(S32);
+	IO_BUFFER_DEFINE_DATA_TYPE(u64);
+	IO_BUFFER_DEFINE_DATA_TYPE(U64);
+	IO_BUFFER_DEFINE_DATA_TYPE(s64);
+	IO_BUFFER_DEFINE_DATA_TYPE(S64);
+#undef IO_BUFFER_DEFINE_DATA_TYPE
+	
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_increment", atomic_increment, -1);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_decrement", atomic_decrement, -1);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_add", atomic_add, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_subtract", atomic_subtract, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_and", atomic_and, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_or", atomic_or, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_xor", atomic_xor, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_load", atomic_load_method, 2);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_store", atomic_store_method, 3);
+	DEFINE_METHOD_IF_NOT_EXISTS(IO_Buffer, "atomic_compare_and_swap", atomic_compare_and_swap, 4);
+}

data/lib/io/buffer/atomic/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+# @namespace
+class IO
+	# @namespace
+	class Buffer
+		# @namespace
+		module Atomic
+			VERSION = "0.1.0"
+		end
+	end
+end

data/lib/io/buffer/atomic.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "atomic/version"
+
+# Check if Ruby itself provides atomic operations
+if IO.const_defined?(:Buffer) && IO::Buffer.instance_methods.include?(:atomic_increment)
+	# Ruby provides atomic operations, use them
+else
+	# Load native extension (required for shared memory support)
+	begin
+		require "IO_Buffer_Atomic"
+	rescue LoadError => error
+		warn "Could not load native atomic operations: #{error.message}"
+		warn "Atomic operations will not be available."
+	end
+end

data/lib/io/buffer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "buffer/atomic"

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, by Samuel Williams.  
+
+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,41 @@
+# IO::Buffer::Atomic
+
+Provides atomic operations for `IO::Buffer` instances, including increment, decrement, add, subtract, and bitwise operations.
+
+[![Development Status](https://github.com/socketry/io-buffer-atomic/workflows/Test/badge.svg)](https://github.com/socketry/io-buffer-atomic/actions?workflow=Test)
+
+## Features
+
+  - **Atomic Operations**: Thread-safe atomic operations on `IO::Buffer` values.
+  - **Multiple Types**: Supports `:u8`, `:u16`, `:u32`, `:u64`, `:i8`, `:i16`, `:i32`, `:i64`.
+  - **Native Extension**: Uses C11 atomic operations when available for maximum performance.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/io-buffer-atomic/) for more details.
+
+  - [Getting Started](https://socketry.github.io/io-buffer-atomic/guides/getting-started/index) - This guide explains how to use `io-buffer-atomic` for atomic operations on `IO::Buffer` instances.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/io-buffer-atomic/releases/index) for all releases.
+
+### v0.1.0
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,3 @@
+# Releases
+
+## v0.1.0

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: io-buffer-atomic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- agents.md
+- ext/extconf.rb
+- ext/io/buffer/atomic.c
+- lib/io/buffer.rb
+- lib/io/buffer/atomic.rb
+- lib/io/buffer/atomic/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/io-buffer-atomic
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/io-buffer-atomic/
+  funding_uri: https://github.com/sponsors/ioquatix
+  source_code_uri: https://github.com/socketry/io-buffer-atomic.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Atomic operations for IO::Buffer instances.
+test_files: []