@@ -32,7 +32,7 @@ your nodes; the library computes optimal (x, y) coordinates for every node in th
 ```kotlin
 // build.gradle.kts
 dependencies {
-    implementation("io.github.linde9821:treelayout-kmp:0.2.1")
+    implementation("io.github.linde9821:treelayout-kmp:0.3.0")
 }
 ```
 
@@ -158,6 +158,83 @@ val result = WalkerTreeLayout(adapter, config).layout()
 
 Available orientations: `TopToBottom`, `BottomToTop`, `LeftToRight`, `RightToLeft`.
 
+## Radial Layouts
+
+In addition to the linear Walker layout, the library includes two **radial layout algorithms** that arrange nodes in
+concentric circles around the root. These are useful when you want a compact, center-outward visualization — common for
+org charts, file explorers, and dependency graphs.
+
+### Radial Walker Layout
+
+**Package:** `io.github.linde9821.treelayout.radial.walker`
+
+This algorithm runs the Walker algorithm internally to determine sibling ordering and spacing, then maps the across-axis
+(horizontal positions) to angular positions on concentric rings. Each depth level becomes a ring at radius
+`depth × layerDistance`.
+
+```kotlin
+import io.github.linde9821.treelayout.radial.walker.RadialWalkerTreeLayout
+import io.github.linde9821.treelayout.radial.walker.RadialWalkerLayoutConfiguration
+
+val config = RadialWalkerLayoutConfiguration(
+    layerDistance = 80f,
+    margin = 0.5f,    // radians subtracted from full circle to create a gap
+    rotation = 0.0f,  // angular offset in radians
+)
+
+val result = RadialWalkerTreeLayout(
+    adapter = OrgTreeAdapter(ceo),
+    configuration = config,
+).layout()
+
+result.getPositions().forEach { (node, point) ->
+    println("${node.name} -> (${point.x}, ${point.y})")
+}
+```
+
+The constructor accepts an optional `nodeExtentProvider` parameter, which is forwarded to the internal Walker pass for
+variable-width node spacing:
+
+```kotlin
+val result = RadialWalkerTreeLayout(
+    adapter = OrgTreeAdapter(ceo),
+    configuration = config,
+    nodeExtentProvider = OrgExtentProvider(),
+).layout()
+```
+
+### Direct Angular Placement Layout
+
+**Package:** `io.github.linde9821.treelayout.radial.angular`
+
+This algorithm recursively partitions angular space among children proportional to their **subtree weight** (total number
+of descendants including the child itself). It runs in **O(n)** — one pass to compute weights, one pass to assign
+positions. This produces evenly distributed layouts where larger subtrees receive proportionally more angular space.
+
+```kotlin
+import io.github.linde9821.treelayout.radial.angular.DirectAngularPlacementLayout
+import io.github.linde9821.treelayout.radial.angular.DirectAngularPlacementConfiguration
+
+val config = DirectAngularPlacementConfiguration(
+    layerDistance = 80f,
+    rotation = 0.0f,  // angular offset in radians
+)
+
+val result = DirectAngularPlacementLayout(
+    adapter = OrgTreeAdapter(ceo),
+    configuration = config,
+).layout()
+
+result.getPositions().forEach { (node, point) ->
+    println("${node.name} -> (${point.x}, ${point.y})")
+}
+```
+
+> **When to choose which?**  
+> Use **Radial Walker** when you want the Walker algorithm's aesthetic guarantees (symmetry, minimal width) projected
+> onto a circle. Use **Direct Angular Placement** when you want a simpler, weight-proportional distribution with no
+> dependency on the Walker pass.
+
 ## API Reference
 
 ### `TreeAdapter<T>`
@@ -202,6 +279,38 @@ Available orientations: `TopToBottom`, `BottomToTop`, `LeftToRight`, `RightToLef
 Constructor accepts an optional `nodeExtentProvider` parameter. When omitted, nodes are treated as dimensionless points
 (backward compatible).
 
+### `RadialWalkerLayoutConfiguration`
+
+| Property        | Type    | Default | Description                                                    |
+|-----------------|---------|---------|----------------------------------------------------------------|
+| `layerDistance` | `Float` | `1.0f`  | Radial distance between concentric depth rings.                |
+| `margin`        | `Float` | `0.0f`  | Angular margin (in radians) subtracted from the full circle.   |
+| `rotation`      | `Float` | `0.0f`  | Angular offset (in radians) applied to all node positions.     |
+
+### `RadialWalkerTreeLayout<T>`
+
+| Method                          | Description                                          |
+|---------------------------------|------------------------------------------------------|
+| `layout(): TreeLayoutResult<T>` | Executes the algorithm and returns positioned nodes. |
+
+Constructor parameters: `adapter: TreeAdapter<T>`, `configuration: RadialWalkerLayoutConfiguration`,
+`nodeExtentProvider: NodeExtentProvider<T>` (optional, defaults to dimensionless points).
+
+### `DirectAngularPlacementConfiguration`
+
+| Property        | Type    | Default | Description                                                |
+|-----------------|---------|---------|-------------------------------------------------------------|
+| `layerDistance` | `Float` | `1.0f`  | Radial distance between concentric depth rings.             |
+| `rotation`      | `Float` | `0.0f`  | Angular offset (in radians) applied to all node positions.  |
+
+### `DirectAngularPlacementLayout<T>`
+
+| Method                          | Description                                          |
+|---------------------------------|------------------------------------------------------|
+| `layout(): TreeLayoutResult<T>` | Executes the algorithm and returns positioned nodes. |
+
+Constructor parameters: `adapter: TreeAdapter<T>`, `configuration: DirectAngularPlacementConfiguration`.
+
 ### `TreeLayoutResult<T>`
 
 | Method                          | Description                                     |
@@ -242,7 +351,9 @@ Run the benchmark yourself:
 ## Running the Samples
 
 The `sample/` module is a Compose Multiplatform application that visualizes a **prefix tree** built from user-provided
-words. It demonstrates variable node sizes, all four orientations, and interactive layout controls.
+words. It features a dark-themed UI with a **layout type selector** (Walker / RadialWalker / DirectAngular) and
+context-sensitive controls for each algorithm — orientation for Walker, margin and rotation for radial layouts. It
+demonstrates variable node sizes and interactive layout controls.
 
 ### Desktop (JVM)
 
 
@@ -0,0 +1,12 @@
+package io.github.linde9821.treelayout.radial.angular
+
+/**
+ * Configuration for the direct angular placement layout algorithm.
+ *
+ * @property layerDistance Radial distance between concentric depth rings.
+ * @property rotation Angular offset (in radians) applied to all nodes.
+ */
+public data class DirectAngularPlacementConfiguration(
+    public val layerDistance: Float = 1.0f,
+    public val rotation: Float = 0.0f,
+)
@@ -0,0 +1,87 @@
+package io.github.linde9821.treelayout.radial.angular
+
+import io.github.linde9821.treelayout.Point
+import io.github.linde9821.treelayout.TreeAdapter
+import io.github.linde9821.treelayout.TreeLayoutResult
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.max
+import kotlin.math.sin
+
+/**
+ * A radial tree layout using direct angular partitioning.
+ *
+ * Recursively assigns angular ranges to each subtree and places nodes
+ * at the midpoint of their allocated arc on concentric circles based on depth.
+ * Each child receives a share of its parent's angular sector proportional to
+ * its subtree weight (number of descendants including itself).
+ *
+ * @param T The node type of the external tree.
+ * @param adapter Adapter providing tree traversal over the external structure.
+ * @param configuration Layout spacing parameters.
+ */
+public class DirectAngularPlacementLayout<T>(
+    private val adapter: TreeAdapter<T>,
+    private val configuration: DirectAngularPlacementConfiguration = DirectAngularPlacementConfiguration(),
+) {
+    /**
+     * Executes the layout algorithm and returns the result.
+     */
+    public fun layout(): TreeLayoutResult<T> {
+        val weight = HashMap<T, Int>()
+        computeWeights(adapter.root(), weight)
+
+        val positions = HashMap<T, Point>(weight.size)
+        var maxDepth = 0
+
+        fun assignAngles(node: T, depth: Int, start: Float, end: Float) {
+            maxDepth = max(maxDepth, depth)
+
+            if (depth == 0) {
+                positions[node] = Point(0f, 0f)
+            } else {
+                val radius = configuration.layerDistance * depth
+                val theta = (start + end) / 2f + configuration.rotation
+                positions[node] = Point(radius * cos(theta), radius * sin(theta))
+            }
+
+            val children = adapter.children(node)
+            if (children.isEmpty()) return
+
+            val totalChildWeight = children.sumOf { weight[it]!! }
+            val arc = end - start
+            var offset = start
+
+            for (child in children) {
+                val childArc = arc * (weight[child]!!.toFloat() / totalChildWeight.toFloat())
+                assignAngles(child, depth + 1, offset, offset + childArc)
+                offset += childArc
+            }
+        }
+
+        assignAngles(adapter.root(), 0, 0f, 2f * PI.toFloat())
+        return DirectAngularResult(positions, maxDepth)
+    }
+
+    private fun computeWeights(node: T, weight: HashMap<T, Int>): Int {
+        val children = adapter.children(node)
+        var w = 1
+        for (child in children) {
+            w += computeWeights(child, weight)
+        }
+        weight[node] = w
+        return w
+    }
+}
+
+private class DirectAngularResult<T>(
+    private val positions: Map<T, Point>,
+    private val maxDepth: Int,
+) : TreeLayoutResult<T> {
+    override fun getPosition(node: T): Point =
+        positions[node] ?: throw IllegalArgumentException("Node not part of the layout")
+
+    override fun getPositions(): Map<T, Point> = positions
+
+    override fun getMaxDepth(): Int = maxDepth
+}
@@ -0,0 +1,18 @@
+package io.github.linde9821.treelayout.radial.walker
+
+import kotlin.math.PI
+
+/**
+ * Configuration for the radial Walker layout algorithm.
+ *
+ * @property layerDistance Distance between concentric depth rings.
+ * @property margin Angular margin (in radians) subtracted from the full circle to avoid overlap.
+ * @property rotation Angular offset (in radians) applied to all nodes.
+ */
+public data class RadialWalkerLayoutConfiguration(
+    public val layerDistance: Float = 1.0f,
+    public val margin: Float = 0.0f,
+    public val rotation: Float = 0.0f,
+) {
+    internal val usableAngle: Float = 2 * PI.toFloat() - margin
+}
@@ -0,0 +1,99 @@
+package io.github.linde9821.treelayout.radial.walker
+
+import io.github.linde9821.treelayout.NodeExtentProvider
+import io.github.linde9821.treelayout.Point
+import io.github.linde9821.treelayout.TreeAdapter
+import io.github.linde9821.treelayout.TreeLayoutResult
+import io.github.linde9821.treelayout.walker.WalkerLayoutConfiguration
+import io.github.linde9821.treelayout.walker.WalkerTreeLayout
+import kotlin.math.cos
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.sin
+
+/**
+ * A radial variant of the Walker tree layout algorithm.
+ *
+ * Nodes are arranged in concentric circles around the root. Each depth level
+ * forms a ring, and sibling nodes are spaced proportionally along the arc.
+ * Internally delegates to [WalkerTreeLayout] for the initial linear positioning,
+ * then transforms the across-axis into angular coordinates.
+ *
+ * @param T The node type of the external tree.
+ * @param adapter Adapter providing tree traversal over the external structure.
+ * @param configuration Radial layout spacing parameters.
+ * @param nodeExtentProvider Provides node dimensions. Defaults to dimensionless points (0×0).
+ */
+public class RadialWalkerTreeLayout<T>(
+    private val adapter: TreeAdapter<T>,
+    private val configuration: RadialWalkerLayoutConfiguration = RadialWalkerLayoutConfiguration(),
+    private val nodeExtentProvider: NodeExtentProvider<T> = UniformNodeExtentProvider(),
+) {
+    /**
+     * Executes the layout algorithm and returns the result with polar-to-Cartesian positions.
+     */
+    public fun layout(): TreeLayoutResult<T> {
+        val walkerConfig = WalkerLayoutConfiguration(
+            horizontalDistance = 1.0f,
+            verticalDistance = configuration.layerDistance,
+        )
+        val linearResult = WalkerTreeLayout(adapter, walkerConfig, nodeExtentProvider).layout()
+        val linearPositions = linearResult.getPositions()
+
+        val depthOf = HashMap<T, Int>(linearPositions.size)
+        computeDepths(adapter.root(), 0, depthOf)
+
+        var xMin = Float.MAX_VALUE
+        var xMax = Float.MIN_VALUE
+        for ((_, pos) in linearPositions) {
+            xMin = min(xMin, pos.x)
+            xMax = max(xMax, pos.x)
+        }
+
+        val radialPositions = HashMap<T, Point>(linearPositions.size)
+        val xRange = xMax - xMin
+
+        for ((node, pos) in linearPositions) {
+            val depth = depthOf[node]!!
+            val radius = depth * configuration.layerDistance
+
+            val theta = if (xRange == 0f) {
+                configuration.rotation
+            } else {
+                val normalizedX = (pos.x - xMin) / xRange
+                normalizedX * configuration.usableAngle + configuration.rotation
+            }
+
+            radialPositions[node] = Point(
+                x = radius * cos(theta),
+                y = radius * sin(theta),
+            )
+        }
+
+        return RadialLayoutResult(radialPositions, linearResult.getMaxDepth())
+    }
+
+    private fun computeDepths(node: T, depth: Int, depthOf: HashMap<T, Int>) {
+        depthOf[node] = depth
+        for (child in adapter.children(node)) {
+            computeDepths(child, depth + 1, depthOf)
+        }
+    }
+}
+
+private class UniformNodeExtentProvider<T> : NodeExtentProvider<T> {
+    override fun width(node: T): Float = 0.0f
+    override fun height(node: T): Float = 0.0f
+}
+
+private class RadialLayoutResult<T>(
+    private val positions: Map<T, Point>,
+    private val maxDepth: Int,
+) : TreeLayoutResult<T> {
+    override fun getPosition(node: T): Point =
+        positions[node] ?: throw IllegalArgumentException("Node not part of the layout")
+
+    override fun getPositions(): Map<T, Point> = positions
+
+    override fun getMaxDepth(): Int = maxDepth
+}