# Calvin-LL/Reorderable for Jetpack Compose Lists and Grids

> Calvin-LL/Reorderable adds drag-and-drop reordering to common Compose containers, including lazy lists, grids, staggered grids, columns, and rows. It fits Compose applications that need direct item ordering, but its README does not document installation, state callbacks, or accessibility behavior.

**Calvin-LL/Reorderable** — Reorder items in Lists and Grids in Jetpack Compose and Compose Multiplatform with drag and drop.

- Repository: https://github.com/Calvin-LL/Reorderable
- Stars: 1,377 · Forks: 56
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/calvin-ll-reorderable

## What Reorderable Changes in a Compose Interface

Reorderable addresses a narrow interaction problem that appears whenever users need to change the order of visible items. The intended audience is Kotlin developers building interfaces with Jetpack Compose or Compose Multiplatform. Rather than presenting ordering as a text field or a separate settings screen, the library places reordering directly on the collection through drag and drop.

The scope is broader than ordinary lists. The README names `LazyColumn`, `LazyRow`, `LazyVerticalGrid`, and `LazyHorizontalGrid`. It also supports `LazyVerticalStaggeredGrid`, `LazyHorizontalStaggeredGrid`, `Column`, and `Row`. That distinction matters because applications may use one container for large datasets and another for a small fixed panel. Reordering support must therefore match both lazy and non-lazy Compose composition patterns.

The README demonstrates the concept through `LazyColumn` and `LazyGrid` media, but it does not explain how an application commits a new order to its backing collection. It gives no callback name, immutable-state example, persistence instruction, or discussion of equal or unequal item heights. Engineers should treat this as a focused interaction library rather than a complete ordering data layer. User interface order and stored order still have to be connected through application code.

## Supported Container Boundaries in Reorderable

Based on the repository layout, the library source is isolated in the `reorderable/` module while `demoApp/` provides a separate demonstration application. The root also contains Gradle project files, a `gradlew` wrapper, `gradlew.bat`, and Kotlin-related project directories. This is a normal multi-part Kotlin repository rather than a single Android app hidden inside the root module.

The supported-component list reveals the intended abstraction boundary. Reorderable targets Compose containers that arrange children along an axis or grid lanes. Vertical and horizontal variants are both included, as are regular grids, staggered grids, lazy lists, and basic composables. This is useful for Compose Multiplatform projects because the README describes both Jetpack Compose and Compose Multiplatform as supported environments, although it does not identify individual non-Android targets.

The README does not describe support for every Compose container. Items in arbitrary custom layouts, pagers, or application-specific gesture systems are not listed. The library also does not claim automatic ordering for data sources such as databases. Its stated problem is narrower: make supported Compose containers reorderable. An application that depends on a different container, needs arbitrary cross-container movement, or requires a persistent database reorder operation must inspect the source before assuming this library covers that case.

## The Reordering Interaction Documented by the Project

The observable interaction described by the README is drag and drop. A user initiates a drag on an item, and that item can be repositioned among neighboring items. The included media is identified as a video showing an item being reordered in a `LazyColumn` and another showing reordering in a lazy grid. That confirms list displacement as the intended interaction, but it does not expose the internal implementation.

The README does not identify the gesture detectors, state holders, animation APIs, or modifiers used by the library. It does not say whether the dragged item follows the pointer directly, whether other items animate into place, or whether auto-scroll is used near the edge of a lazy container. Those are material details for interface consistency, yet the documentation leaves them unanswered. There is also no documented policy for cancelling a drag, starting a long press, handling keyboard input, or describing the reorder action to assistive technology.

For this reason, the defensible interpretation is that Reorderable supplies the Compose-side interaction around a caller-owned sequence. The exact data flow cannot be confirmed from the README and repository layout alone. Before adoption, inspect the current `reorderable/` module and `demoApp/` to find the state mutation path, especially if ordering must be written to persistent storage as the user releases an item.

## Installing Reorderable and Reaching a First Use

The README does not provide dependency coordinates, Gradle repository configuration, version catalogs, or an installation snippet. The repository includes `gradlew`, `gradlew.bat`, and Gradle build files, so the source can be opened as a Gradle project, but those filenames do not establish a published artifact coordinate or a supported build task. Supplying such a command here would invent an installation step that the README does not state.

For evaluators who need the running demonstration without building a consuming app, the README points to the GitHub releases section. It says the latest demo app APK is attached under "Assets" in the latest release. Based on the release list, that currently means inspecting the assets for `v3.1.0`. A device or emulator must then be able to install that APK. The README does not document minimum Android versions, signing details, or supported screen orientations.

There is consequently no short source-code first-use tutorial that can be reproduced faithfully from the README. It omits the API imports, required Compose setup, item modifier, reorder callback, and sample state mutation. Engineers evaluating the library should open `demoApp/` for the executable integration and `reorderable/` for the current public API before writing application code. The latest demo APK is useful for checking the interaction, but it does not establish how dependency resolution works for a library consumer.

## Constraints for Lazy Lists, Grids, and Multiplatform Builds

Lazy containers introduce constraints that are not visible in a basic drag demonstration. Only part of a `LazyColumn` or grid may be composed, so a drag that crosses the visible boundary can require scrolling to expose another target position. The README claims these containers are supported, but it does not state whether edge auto-scroll, overscroll, nested scrolling, or simultaneous gestures are handled. Those cases need direct source inspection.

Grid reordering also raises questions about direction, span, density, and occupied cells. The supported grid APIs cover fixed and horizontal forms plus staggered grids, but the README gives no rules for items spanning multiple columns or rows. It does not say whether a drag target can change span, whether empty cells affect movement, or how horizontal and vertical drag gestures are distinguished. The safest adoption boundary is a grid whose layout rules are already represented consistently by the application state.

Compose Multiplatform support creates another verification point. The README names Jetpack Compose and Compose Multiplatform, but it provides no target matrix, dependency variant, platform-specific configuration, or sample for desktop and web. That statement alone is not enough to conclude that every Compose target behaves identically. Check the build configuration and public API in the selected release for the exact target in the application. Also verify gesture behavior on each input method the product supports.

## Reorderable Compared With Application-Owned Drag Logic

The practical alternative is to keep the collection layout and implement drag detection, displacement, and order mutation inside the application. That approach uses the normal Compose container and application state directly. It avoids adding a library, but it also leaves the application responsible for gesture arbitration, lazy scrolling, visual displacement, cancellation, and the moment at which a moved item is committed.

Reorderable takes those concerns off the application in exchange for depending on its API and supported container set. Its documented advantage is concrete scope: it already targets eight lazy and non-lazy Compose containers rather than requiring every product team to build the same interaction from scratch. The difference is not a separate data model. Both approaches still need an authoritative list or grid state somewhere in the application.

The README is too thin to compare internals or compatibility costs with another named library, so that comparison would be speculative. Decide based on control. Use Reorderable if its container support matches an existing Compose UI and its current API fits the state model. Choose application-owned logic if reordering must cover unsupported layouts, require specialized persistence transactions, or interact with custom gestures in ways the library does not document.

## Release History, Maintenance Signals, and Apache-2.0

The repository is not archived. Its last push was on 2026-04-20, and the `v3.1.0` release was published on the same calendar date. Earlier listed releases are `v3.0.0` from 2025-08-12 and `v2.5.1` from 2025-06-08. These dates show recent release activity, but the README does not provide a compatibility table for the major versions or a migration guide for moving from `v2.x` to `v3.x`.

That missing migration documentation affects upgrade cost. A major release may change API shape, and the README does not let an engineer determine the exact edits required. The three release entries establish version progression, not whether upgrading is source compatible. Review the release notes and diffs for `v3.1.0` before replacing an earlier dependency, especially if the application stores item order through state types exposed by the library.

The project is licensed under `Apache-2.0`. That license includes standard permissions, conditions, and limitations, including a preservation-of-license obligation. This paragraph is not legal advice. Projects distributing a modified or compiled version should review the included `LICENSE` and applicable notices themselves. The license choice does not by itself establish compatibility with an application's own licensing or distribution policy.

## Conclusion

Compose developers should consider Reorderable when their product already uses the supported lazy or non-lazy containers and needs direct manipulation of item order. Developers needing documented dependency coordinates, explicit persistence callbacks, accessibility guarantees, or rollback procedures should first inspect the current source and release artifacts. For a first adoption decision, verify that v3.1.0 can be resolved by the intended Android or Compose Multiplatform build and that its state update path matches the application model.

## FAQ

### Which Compose containers support drag-and-drop reordering in Calvin-LL/Reorderable?

The README lists `LazyColumn`, `LazyRow`, both standard lazy grids, both lazy staggered grids, `Column`, and `Row`. It does not claim support for arbitrary custom Compose containers.

### Does Calvin-LL/Reorderable work with Compose Multiplatform?

The README states that the library supports Jetpack Compose and Compose Multiplatform. It does not provide a target matrix or platform-specific setup instructions.

### How do I install and configure Calvin-LL/Reorderable?

The README does not give dependency coordinates or a Gradle configuration snippet. It directs readers to the GitHub releases section for the latest demo APK, and the repository contains a `demoApp/` module for examining an integration.

## Sources

- [Calvin-LL/Reorderable on GitHub](https://github.com/Calvin-LL/Reorderable)
- [Issues](https://github.com/Calvin-LL/Reorderable/issues)
- [License: Apache-2.0](https://github.com/Calvin-LL/Reorderable/blob/main/LICENSE)
- [README](https://github.com/Calvin-LL/Reorderable/blob/main/README.md)
- [Releases](https://github.com/Calvin-LL/Reorderable/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/calvin-ll-reorderable