diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e12f642..849eb24 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -129,4 +129,6 @@ jobs:
         cache: true
 
     - name: Run fuzz tests
-      run: go test -fuzz=Fuzz -fuzztime=30s ./...
+      run: |
+        go test -fuzz=FuzzAllocFree -fuzztime=30s ./...
+        go test -fuzz=FuzzAllocAligned -fuzztime=30s ./...
diff --git a/AGENTS.md b/AGENTS.md
index 1051d22..c39c9b6 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -22,6 +22,11 @@ if alloc.Failed() {
 }
 // use alloc.Offset
 a.Free(alloc)
+
+// GPU-aligned allocation (e.g., 256-byte for Vulkan uniform buffers)
+aligned := a.AllocateAligned(4096, 256)
+// aligned.Offset % 256 == 0
+a.Free(aligned)
 ```
 
 For concurrent use: `galloc.NewSync(size, maxAllocs)`.
@@ -29,9 +34,9 @@ For concurrent use: `galloc.NewSync(size, maxAllocs)`.
 ## Architecture
 
 ```
-galloc.go       -- Allocator core: Allocate, Free, coalescing, bin management
+galloc.go       -- Allocator core: Allocate, AllocateAligned, Free, coalescing, bin management
 smallfloat.go   -- SmallFloat uint-to-bin encoding (256 bins, 3-bit mantissa)
-sync.go         -- SyncAllocator (mutex-wrapped Allocator)
+sync.go         -- SyncAllocator (mutex-wrapped Allocator + AllocateAligned)
 doc.go          -- Package documentation
 ```
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9b870f7..15a5e30 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-07-27
+
+### Added
+
+- `AllocateAligned(size, alignment)` — per-allocation aligned sub-allocation (TLSF-style over-allocate)
+- `SyncAllocator.AllocateAligned` — thread-safe aligned allocation wrapper
+- GPU alignment support: Vulkan (256), DX12 (4–65536), Metal (64–256)
+- Alignment=0 or 1 fast-paths to `Allocate` with zero overhead
+- Non-power-of-2 alignment panics (programmer error, same as `sync.Pool`)
+- Fuzz testing for aligned allocation (`FuzzAllocAligned`)
+- Benchmarks for aligned allocation (~50ns/op, 0 allocs/op)
+
 ## [0.1.0] - 2026-07-25
 
 ### Added
diff --git a/README.md b/README.md
index 7e0fbb9..5c821c0 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,28 @@ func main() {
 }
 ```
 
+## Aligned Allocation
+
+GPU APIs require buffer offsets to be aligned (e.g., 256 bytes for Vulkan uniform buffers). `AllocateAligned` guarantees the returned offset is a multiple of the given alignment:
+
+```go
+// Vulkan uniform buffer: 256-byte alignment.
+alloc := a.AllocateAligned(4096, 256)
+fmt.Printf("Offset: %d (aligned: %v)\n", alloc.Offset, alloc.Offset%256 == 0)
+
+// DX12 texture data: 512-byte alignment.
+tex := a.AllocateAligned(65536, 512)
+
+// Alignment of 0 or 1 is equivalent to Allocate (zero overhead).
+plain := a.AllocateAligned(100, 1)
+
+a.Free(alloc)
+a.Free(tex)
+a.Free(plain)
+```
+
+Alignment must be a power of two. The implementation over-allocates by up to `alignment - 1` bytes; these padding bytes are reclaimed when the allocation is freed.
+
 ## Algorithm
 
 The allocator is based on [TLSF](http://www.gii.upv.es/tlsf/) (Two-Level Segregated Fit) principles adapted for offset-only allocation (no actual memory management).
diff --git a/ROADMAP.md b/ROADMAP.md
index a842943..23f1d07 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -9,8 +9,9 @@
 - [x] Enterprise CI (3 OS, lint, formatting, fuzz, Codecov)
 - [x] 22 tests, 6 benchmarks, fuzz testing
 
-## v0.2.0 — Integration
+## v0.2.0 — Alignment + Integration
 
+- [ ] **FEAT-001: `AllocateAligned(size, alignment)` — per-allocation alignment** (ADR-001)
 - [ ] Integration with `wgpu` Vulkan memory pools (replace BuddyAllocator)
 - [ ] Integration with `wgpu` DX12 descriptor heaps
 - [ ] Extended statistics (per-bin occupancy, fragmentation metrics)
@@ -18,6 +19,7 @@
 
 ## v0.3.0 — Optimization
 
+- [ ] Trim approach for aligned allocation (zero-waste prefix reclaim)
 - [ ] Benchmark suite vs BuddyAllocator (side-by-side comparison)
 - [ ] Memory layout optimization (cache-friendly node pool)
 - [ ] `usedBins [8]uint32` variant (fewer type casts on hot path)
diff --git a/bench_test.go b/bench_test.go
index ad216a4..c9861ce 100644
--- a/bench_test.go
+++ b/bench_test.go
@@ -87,6 +87,27 @@ func BenchmarkAllocMany(b *testing.B) {
 	}
 }
 
+func BenchmarkAllocateAligned256(b *testing.B) {
+	a := New(1024*1024*256, 1024)
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		alloc := a.AllocateAligned(4096, 256)
+		a.Free(alloc)
+	}
+}
+
+func BenchmarkAllocateAligned1(b *testing.B) {
+	// Fast path: alignment=1 should be identical to Allocate.
+	a := New(1024*1024*256, 1024)
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		alloc := a.AllocateAligned(256, 1)
+		a.Free(alloc)
+	}
+}
+
 func BenchmarkFragmented(b *testing.B) {
 	// Interleaved alloc/free pattern to stress coalescing.
 	const maxAllocs = 4096
diff --git a/fuzz_test.go b/fuzz_test.go
index a76720c..c97cf42 100644
--- a/fuzz_test.go
+++ b/fuzz_test.go
@@ -58,3 +58,57 @@ func FuzzAllocFree(f *testing.F) {
 		}
 	})
 }
+
+func FuzzAllocAligned(f *testing.F) {
+	f.Add(uint32(65536), uint8(20), uint16(256), uint8(8))      // align=256
+	f.Add(uint32(1024), uint8(5), uint16(64), uint8(2))         // align=4
+	f.Add(uint32(1024*1024), uint8(50), uint16(4096), uint8(9)) // align=512
+
+	f.Fuzz(func(t *testing.T, totalSize uint32, numOps uint8, allocSize uint16, alignShift uint8) {
+		if totalSize == 0 || totalSize > 1024*1024*16 {
+			return
+		}
+		// Clamp alignment to [1, 65536] as power of 2.
+		alignShift %= 17 // 0..16 → 1..65536
+		alignment := uint32(1) << alignShift
+
+		maxAllocs := uint32(numOps)*2 + 16
+		if maxAllocs > 65536 {
+			maxAllocs = 65536
+		}
+
+		a := New(totalSize, maxAllocs)
+
+		var live []Allocation
+		for i := uint8(0); i < numOps; i++ {
+			size := uint32(allocSize)
+			if size == 0 {
+				size = 1
+			}
+			alloc := a.AllocateAligned(size, alignment)
+			if !alloc.Failed() {
+				if alloc.Offset%alignment != 0 {
+					t.Fatalf("offset %d not aligned to %d", alloc.Offset, alignment)
+				}
+				live = append(live, alloc)
+			}
+
+			if len(live) > 4 && i%3 == 0 {
+				half := len(live) / 2
+				for _, alloc := range live[:half] {
+					a.Free(alloc)
+				}
+				live = live[half:]
+			}
+		}
+
+		for _, alloc := range live {
+			a.Free(alloc)
+		}
+
+		report := a.StorageReport()
+		if report.TotalFreeSpace != totalSize {
+			t.Errorf("after freeing all: TotalFreeSpace = %d, want %d", report.TotalFreeSpace, totalSize)
+		}
+	})
+}
diff --git a/galloc.go b/galloc.go
index 548f0a8..b0f0c33 100644
--- a/galloc.go
+++ b/galloc.go
@@ -221,6 +221,32 @@ func (a *Allocator) Allocate(size uint32) Allocation {
 	}
 }
 
+// AllocateAligned reserves a contiguous region of the given size at an offset
+// that is a multiple of alignment. Alignment must be a power of two; passing a
+// non-power-of-two value (other than 0) will panic. Alignment of 0 or 1 is
+// equivalent to [Allocate].
+//
+// The implementation over-allocates by up to alignment-1 bytes to guarantee an
+// aligned offset within the block. These padding bytes are reclaimed when the
+// allocation is freed.
+//
+// A size of 0 is treated as a valid allocation (matching [Allocate] behavior).
+func (a *Allocator) AllocateAligned(size, alignment uint32) Allocation {
+	if alignment <= 1 {
+		return a.Allocate(size)
+	}
+	if alignment&(alignment-1) != 0 {
+		panic("galloc: alignment must be a power of two")
+	}
+	padded := size + alignment - 1
+	alloc := a.Allocate(padded)
+	if alloc.Failed() {
+		return alloc
+	}
+	alloc.Offset = (alloc.Offset + alignment - 1) &^ (alignment - 1)
+	return alloc
+}
+
 // Free releases a previously-made allocation, returning its space to the pool.
 // Adjacent free regions are automatically coalesced.
 //
diff --git a/galloc_test.go b/galloc_test.go
index 9d661ef..a2ab142 100644
--- a/galloc_test.go
+++ b/galloc_test.go
@@ -488,6 +488,220 @@ func TestReuseComplex(t *testing.T) {
 	a.Free(validateAll)
 }
 
+func TestAllocateAlignedBasic(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	alloc := a.AllocateAligned(256, 256)
+	if alloc.Failed() {
+		t.Fatal("AllocateAligned(256, 256) failed")
+	}
+	if alloc.Offset%256 != 0 {
+		t.Errorf("offset %d not aligned to 256", alloc.Offset)
+	}
+	a.Free(alloc)
+}
+
+func TestAllocateAlignedVariousAlignments(t *testing.T) {
+	tests := []struct {
+		name      string
+		size      uint32
+		alignment uint32
+	}{
+		{"align4", 100, 4},
+		{"align32", 100, 32},
+		{"align64", 100, 64},
+		{"align256_vulkan_uniform", 4096, 256},
+		{"align512_dx12_texture", 4096, 512},
+		{"align65536_dx12_placed", 65536, 65536},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			a := New(testSize256MB, testMaxAllocs)
+			alloc := a.AllocateAligned(tt.size, tt.alignment)
+			if alloc.Failed() {
+				t.Fatalf("AllocateAligned(%d, %d) failed", tt.size, tt.alignment)
+			}
+			if alloc.Offset%tt.alignment != 0 {
+				t.Errorf("offset %d not aligned to %d", alloc.Offset, tt.alignment)
+			}
+			a.Free(alloc)
+		})
+	}
+}
+
+func TestAllocateAlignedMultiple(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	allocs := make([]Allocation, 8)
+	for i := range allocs {
+		alloc := a.AllocateAligned(1024, 256)
+		if alloc.Failed() {
+			t.Fatalf("alloc[%d] failed", i)
+		}
+		if alloc.Offset%256 != 0 {
+			t.Errorf("alloc[%d] offset %d not aligned to 256", i, alloc.Offset)
+		}
+		allocs[i] = alloc
+	}
+
+	// Verify non-overlapping: each allocation needs at least 1024 bytes.
+	for i := 1; i < len(allocs); i++ {
+		for j := 0; j < i; j++ {
+			if overlap(allocs[j].Offset, 1024, allocs[i].Offset, 1024) {
+				t.Errorf("alloc[%d] (offset=%d) overlaps alloc[%d] (offset=%d)",
+					i, allocs[i].Offset, j, allocs[j].Offset)
+			}
+		}
+	}
+
+	for _, alloc := range allocs {
+		a.Free(alloc)
+	}
+
+	// After freeing all, full coalescing should restore the entire range.
+	validateAll := a.Allocate(testSize256MB)
+	if validateAll.Failed() {
+		t.Fatal("full re-allocation after aligned frees failed")
+	}
+	a.Free(validateAll)
+}
+
+func TestAllocateAlignedFastPaths(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	// alignment=0 → fast path to Allocate.
+	alloc0 := a.AllocateAligned(100, 0)
+	if alloc0.Failed() {
+		t.Fatal("AllocateAligned(100, 0) failed")
+	}
+	a.Free(alloc0)
+
+	// alignment=1 → fast path to Allocate.
+	alloc1 := a.AllocateAligned(100, 1)
+	if alloc1.Failed() {
+		t.Fatal("AllocateAligned(100, 1) failed")
+	}
+	a.Free(alloc1)
+}
+
+func TestAllocateAlignedLargerThanSize(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	// alignment > size is valid (e.g., 16-byte alloc at 256-byte boundary).
+	alloc := a.AllocateAligned(16, 256)
+	if alloc.Failed() {
+		t.Fatal("AllocateAligned(16, 256) failed")
+	}
+	if alloc.Offset%256 != 0 {
+		t.Errorf("offset %d not aligned to 256", alloc.Offset)
+	}
+	a.Free(alloc)
+}
+
+func TestAllocateAlignedNonPowerOfTwoPanics(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	defer func() {
+		if r := recover(); r == nil {
+			t.Error("AllocateAligned with non-power-of-2 alignment should panic")
+		}
+	}()
+
+	a.AllocateAligned(100, 3)
+}
+
+func TestAllocateAlignedExhaustion(t *testing.T) {
+	// Small allocator — aligned allocations waste padding, should exhaust faster.
+	a := New(1024, 256)
+
+	alloc := a.AllocateAligned(512, 256)
+	if alloc.Failed() {
+		t.Fatal("first aligned allocation failed")
+	}
+	if alloc.Offset%256 != 0 {
+		t.Errorf("offset %d not aligned to 256", alloc.Offset)
+	}
+
+	// Second large aligned alloc may fail due to padding overhead.
+	alloc2 := a.AllocateAligned(512, 256)
+	// Whether it succeeds depends on internal layout; just ensure no panic.
+	if !alloc2.Failed() {
+		a.Free(alloc2)
+	}
+	a.Free(alloc)
+}
+
+func TestAllocateAlignedCoalescing(t *testing.T) {
+	a := New(testSize256MB, testMaxAllocs)
+
+	allocs := make([]Allocation, 4)
+	for i := range allocs {
+		allocs[i] = a.AllocateAligned(4096, 256)
+		if allocs[i].Failed() {
+			t.Fatalf("alloc[%d] failed", i)
+		}
+	}
+
+	// Free in reverse order.
+	for i := len(allocs) - 1; i >= 0; i-- {
+		a.Free(allocs[i])
+	}
+
+	// Full coalescing should restore everything.
+	report := a.StorageReport()
+	if report.TotalFreeSpace != testSize256MB {
+		t.Errorf("TotalFreeSpace = %d, want %d", report.TotalFreeSpace, testSize256MB)
+	}
+}
+
+// overlap checks if two ranges [aOff, aOff+aSize) and [bOff, bOff+bSize) overlap.
+func overlap(aOff, aSize, bOff, bSize uint32) bool {
+	return aOff < bOff+bSize && bOff < aOff+aSize
+}
+
+func TestSyncAllocateAligned(t *testing.T) {
+	s := NewSync(testSize256MB, testMaxAllocs)
+
+	alloc := s.AllocateAligned(4096, 256)
+	if alloc.Failed() {
+		t.Fatal("SyncAllocator.AllocateAligned failed")
+	}
+	if alloc.Offset%256 != 0 {
+		t.Errorf("offset %d not aligned to 256", alloc.Offset)
+	}
+	s.Free(alloc)
+}
+
+func TestSyncAllocateAlignedConcurrent(t *testing.T) {
+	s := NewSync(1024*1024, 4096)
+	const goroutines = 8
+	const opsPerGoroutine = 128
+
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+	for g := 0; g < goroutines; g++ {
+		go func() {
+			defer wg.Done()
+			for i := 0; i < opsPerGoroutine; i++ {
+				alloc := s.AllocateAligned(64, 256)
+				if !alloc.Failed() {
+					if alloc.Offset%256 != 0 {
+						t.Errorf("offset %d not aligned to 256", alloc.Offset)
+					}
+					s.Free(alloc)
+				}
+			}
+		}()
+	}
+	wg.Wait()
+
+	report := s.StorageReport()
+	if report.TotalFreeSpace != 1024*1024 {
+		t.Errorf("after concurrent ops TotalFreeSpace = %d, want %d", report.TotalFreeSpace, 1024*1024)
+	}
+}
+
 func TestSyncAllocatorConcurrent(t *testing.T) {
 	s := NewSync(1024*1024, 4096)
 	const goroutines = 8
diff --git a/sync.go b/sync.go
index 7a5362c..fdfad07 100644
--- a/sync.go
+++ b/sync.go
@@ -29,6 +29,14 @@ func (s *SyncAllocator) Allocate(size uint32) Allocation {
 	return s.a.Allocate(size)
 }
 
+// AllocateAligned reserves a contiguous region at an aligned offset.
+// See [Allocator.AllocateAligned] for details.
+func (s *SyncAllocator) AllocateAligned(size, alignment uint32) Allocation {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.a.AllocateAligned(size, alignment)
+}
+
 // Free releases a previously-made allocation.
 // See [Allocator.Free] for details.
 func (s *SyncAllocator) Free(alloc Allocation) {