Bump minor version.

Author: ioquatix

context/getting-started.md

@@ -14,6 +14,8 @@ $ bundle add io-buffer-atomic
 
 `io-buffer-atomic` extends `IO::Buffer` with atomic operations that are safe for concurrent access across threads and processes. When multiple threads or processes share memory (via `IO::Buffer`), you need atomic operations to prevent race conditions and ensure data consistency.
 
+**Important**: Atomic operations work on raw memory bytes in host endian (native byte order). Both `:u32` and `:U32` map to the same atomic operation since they operate on the same raw memory bytes. The endianness distinction only affects how Ruby's `get_value`/`set_value` interpret bytes, not atomic operations.
+
 Use atomic operations when you need:
 - **Thread-safe counters**: Multiple threads updating shared counters without locks.
 - **Process-safe coordination**: Multiple processes coordinating via shared memory.
@@ -77,6 +79,38 @@ result = buffer.atomic_xor(:u32, 0, 0b1111)
 # => 0b0000
 ```
 
+### Atomic Load
+
+Atomic load operations ensure you read a complete, consistent value from shared memory, preventing torn reads:
+
+```ruby
+# Set a value:
+buffer.set_value(:u32, 0, 42)
+
+# Atomically read the value (ensures no torn reads):
+result = buffer.atomic_load(:u32, 0)
+# => 42
+```
+
+Use `atomic_load` instead of `get_value` when reading values that may be modified by other threads or processes, as it provides memory ordering guarantees and prevents data races.
+
+### Atomic Store
+
+Atomic store operations ensure you write a complete value atomically to shared memory:
+
+```ruby
+# Atomically write a value:
+buffer.atomic_store(:u32, 0, 42)
+
+# Read it back:
+result = buffer.atomic_load(:u32, 0)
+# => 42
+```
+
+Use `atomic_store` instead of `set_value` when writing values that may be read by other threads or processes, as it provides memory ordering guarantees and prevents torn writes.
+
+**Note**: `atomic_load` and `atomic_store` work on raw bytes in host endian, matching the atomic operations themselves. Both `:u32` and `:U32` are equivalent for atomic operations.
+
 ### Compare and Swap
 
 Compare-and-swap operations enable lock-free algorithms and optimistic concurrency:
@@ -88,7 +122,7 @@ buffer.set_value(:u32, 0, 10)
 # Atomically swap if current value matches expected:
 swapped = buffer.atomic_compare_and_swap(:u32, 0, 10, 20)
 # => true
-buffer.get_value(:u32, 0)
+buffer.atomic_load(:u32, 0)
 # => 20
 
 # If value doesn't match, swap fails:
@@ -98,6 +132,8 @@ swapped = buffer.atomic_compare_and_swap(:u32, 0, 10, 30)
 
 ## Supported Operations
 
+- `atomic_load(type, offset)` - Atomically read a value (prevents torn reads).
+- `atomic_store(type, offset, value)` - Atomically write a value (prevents torn writes).
 - `atomic_increment(type, offset, value = 1)` - Atomically increment a value.
 - `atomic_decrement(type, offset, value = 1)` - Atomically decrement a value.
 - `atomic_add(type, offset, value)` - Atomically add a value.
@@ -106,8 +142,3 @@ swapped = buffer.atomic_compare_and_swap(:u32, 0, 10, 30)
 - `atomic_or(type, offset, value)` - Atomically perform bitwise OR.
 - `atomic_xor(type, offset, value)` - Atomically perform bitwise XOR.
 - `atomic_compare_and_swap(type, offset, expected, desired)` - Atomically compare and swap.
-
-## Requirements
-
-- Ruby \>= 3.2.6.
-- `IO::Buffer` support (available in Ruby 3.2+).

lib/io/buffer/atomic/version.rb

@@ -9,7 +9,7 @@ class IO
 	class Buffer
 		# @namespace
 		module Atomic
-			VERSION = "0.0.0"
+			VERSION = "0.1.0"
 		end
 	end
 end

readme.md

@@ -20,7 +20,7 @@ Please see the [project documentation](https://socketry.github.io/io-buffer-atom
 
 Please see the [project releases](https://socketry.github.io/io-buffer-atomic/releases/index) for all releases.
 
-### Unreleased
+### v0.1.0
 
 ## Contributing
 

releases.md

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