# FOSS kanban mining + drag-and-drop primitive selection

audience: AI coding agents first.

## Outcome

Answer owner's 2026-08-14 question: is there a mature FOSS kanban project worth
mining for parts, and which FOSS drag-and-drop primitive should Overdeck's
`/requests` board adopt for card movement. This is NOT a rebuild proposal —
the board (React + Astryx primitives, Bun/SQLite collector, columns/cards/claims/
detail-drawer already live) stays custom. Scope is narrow: what to borrow, what
library to wire in for drag between columns.

## Status

PROPOSED — owner decides adoption. Research complete, nothing implemented.

## Task IDs

- Board row: `manual-f8b44a43c5264051` ("Choose FOSS kanban parts and drag-drop
  primitive") — claimed by `agent@debian3`, project `overdeck`.

## Source request

Owner, 2026-08-14 (recovered from transcript, revived 2026-08-15): "is there
any FOSS solution that is ready to work on cloudflare ... and typescript
backend?" and "is there a drag&drop FOSS primitive we can use?"

## Acceptance criteria

- Evaluate kanban candidates (Kaneo, Planka, Focalboard, Vikunja, plus any
  genuinely better option found) against license, backend fit (TS/Bun),
  maintenance health (commit/issue activity, checked live not assumed),
  Cloudflare-readiness (SaaS-reuse angle only).
- Evaluate drag-and-drop primitives (@dnd-kit, @atlaskit/pragmatic-drag-and-drop,
  native HTML5 DnD, react-dnd) against license, React 19 compat, a11y/keyboard
  support, bundle size, maintenance.
- One recommendation per question, with a named runner-up and reasons.
- No rebuild proposal — only "what we'd adopt" into the existing board.
- Data checked against live repo/registry state (commit/release dates), not
  assumed from training data.

## Method / what was checked

GitHub REST API (`api.github.com/repos/<slug>`) pulled live on 2026-08-15 for
stars, license, `pushed_at`, `archived`, open issue count. npm registry pulled
for `@dnd-kit/core`, `@atlaskit/pragmatic-drag-and-drop`, `react-dnd` latest
version, declared license, and peer dependencies (React version ceiling).
GitHub's `license` field is sometimes `NOASSERTION` (repo has a LICENSE file
GitHub couldn't auto-classify) — those are annotated with the actual license
read from the project's own docs/LICENSE file, not left as unknown.

## Kanban candidates — evaluation table

| Project | License | Backend / stack | Last push (checked 2026-08-15) | Stars | Open issues | Notes |
|---|---|---|---|---|---|---|
| **Kaneo** (`usekaneo/kaneo`) | MIT | TypeScript ~4M chars of the repo (Bun + Hono API, Drizzle ORM, React frontend) | today (2026-08-15) | 8,300 | live | Closest stack match: TS end-to-end, Bun-based backend — same runtime family as the collector. Young project (owner already explored it per memory), smaller community than Planka/Wekan but the only one that's TS/Bun native rather than a foreign-stack import. |
| **Planka** (`plankanban/planka`) | AGPL-3.0 (GitHub shows NOASSERTION; confirmed AGPL-3.0 in repo's own LICENSE/README — "fair-code"/AGPL dual model) | Node.js/Express backend, React frontend, Postgres | 2026-08-10 | 12,377 | 446 | Mature, actively developed, closest to Trello UX. AGPL-3.0 is a real constraint: network-copyleft — mining code (not just running the binary) into a proprietary/closed board would trigger AGPL obligations on the combined work. Fine to study the UX/schema, risky to copy code verbatim. |
| **Focalboard** (`mattermost-community/focalboard`) | Was MIT, now community-maintained fork after Mattermost Inc. discontinued/archived the original in 2024 | Go backend, React frontend | 2026-05-18 (~3 months stale at check time) | 26,402 | 784 (high, thin maintenance) | Highest star count but that reflects its Mattermost-era popularity, not current health. Go backend is a bigger stack mismatch than Planka's Node backend. Discontinuation history + issue backlog make it the weakest maintenance signal here. Avoid as an adoption source. |
| **Vikunja** (`go-vikunja/vikunja`) | AGPL-3.0 | Go backend, Vue frontend | 2026-08-15 (active, pushed hours before check) | 5,065 | live, actively triaged | Actively maintained and well-run, but Go backend + Vue frontend is the worst stack fit of the four (Overdeck is TS/React) and it's task-list-first, kanban-second. Same AGPL copyleft caveat as Planka. |
| **Wekan** (`wekan/wekan`) | MIT | Meteor.js (legacy full-stack framework), MongoDB | active | 21,026 | 336 | Long-running, permissively licensed, but Meteor is a legacy stack with little overlap to Bun/TS/SQLite — adopting patterns means translating Meteor idioms, not a direct lift. |

### Recommendation: kanban

**Mine Kaneo** for board/state-machine patterns (column-transition rules,
claim/assignment schema, card-detail modeling) — it is MIT (no copyleft
friction), TypeScript throughout, and built on Bun, which is the same runtime
family as the collector, so its code reads directly rather than needing stack
translation. **Runner-up: Planka** — richer, more mature UX to reference for
board interaction design (columns, swimlanes, card modals), but its AGPL-3.0
license means treat it as read-only UX reference, not a source to copy code
from, unless the owner is fine placing the combined work under AGPL.

Do not adopt Focalboard (discontinued upstream, Go backend, high unmaintained
issue backlog) or Vikunja/Wekan (stack mismatch: Go+Vue / legacy Meteor) as
code sources. None of the four is a wholesale replacement candidate — the
existing custom board (React + Astryx, Bun/SQLite collector) already covers
what all four kanban tools provide at the board level; the only genuine gap
this research found is drag-and-drop, addressed below.

## Drag-and-drop primitives — evaluation table

Checked live 2026-08-15 via npm registry (`registry.npmjs.org/<pkg>/latest`)
and GitHub repo metadata.

| Library | License | Latest version | React peer dep | Bundle | a11y / keyboard | Maintenance |
|---|---|---|---|---|---|---|
| **@dnd-kit** (`clauderic/dnd-kit`, pkg `@dnd-kit/core` + `@dnd-kit/sortable`) | MIT | 6.3.1 | `react >=16.8.0` (no ceiling — React 19 compatible) | ~10 KB core, tree-shakeable, zero runtime deps | Built-in keyboard sensor + screen-reader announcements, first-class a11y support, purpose-built `sortable` preset for exactly this use case (reordering/moving items between lists) | 17,542 stars, pushed 2026-07-13 (~1 month before check), 124 open issues, most widely adopted React-specific DnD library today |
| **@atlaskit/pragmatic-drag-and-drop** (Atlassian) | Apache-2.0 | 3.0.0 | Framework-agnostic core (no React peer dep on the core package; separate thin React binding packages exist) | Smallest footprint of the four — no virtual DOM diffing, works directly against native DOM events; designed for Atlassian's own large boards (Trello, Jira, Confluence) | Native browser DnD under the hood + documented keyboard/screen-reader patterns shipped as optional modules | 12,725 stars, pushed **2026-08-15** (same day as check — most actively maintained of the four), 103 open issues, backed by a company running it in production at Trello-scale |
| **react-dnd** (`react-dnd/react-dnd`) | MIT | 16.0.1 | `react >=16.14` | Heaviest of the four — pulls in a backend abstraction (HTML5Backend/TouchBackend) plus Redux-like internal state | Weakest built-in a11y story of the four; keyboard support requires manual backend work | 21,633 stars but pushed 2025-07-06 — **over a year stale** at check time, the only candidate showing a real maintenance gap |
| **Native HTML5 Drag and Drop API** | N/A (browser API, no license) | N/A | N/A | Zero bundle cost | Poor out of the box — no keyboard alternative without hand-building one; drag image/ghost styling and touch support are notoriously inconsistent across browsers | N/A — not a library, just the raw browser API |

### Recommendation: drag-and-drop

**@dnd-kit** (`@dnd-kit/core` + `@dnd-kit/sortable`), MIT license. Reasons:
purpose-built `sortable` preset matches the exact interaction (dragging a card
between kanban columns, each column a sortable list) with the least custom
glue code; peer dependency has no React version ceiling so React 19 is
supported today; keyboard sensor and screen-reader announcements are built in
rather than bolted on, which matters for a11y parity with the board's existing
keyboard-navigable claims flow; and it is the most widely adopted React-specific
option, meaning the largest base of examples/maintainers if something breaks.

**Runner-up: @atlaskit/pragmatic-drag-and-drop** (Apache-2.0) — technically
the strongest candidate on raw maintenance signal (commit landed the same day
as this check) and the smallest bundle, and it is what Atlassian runs Trello's
own board on, which is directly relevant prior art for a kanban UI. It loses
the recommendation only because it is framework-agnostic by design: adopting
it means writing more of the column/list wiring by hand versus `@dnd-kit`'s
ready-made `sortable` preset, which is more integration work for the same
outcome given the board's current state (columns/cards/claims live, no drag
code yet). If `@dnd-kit`'s bundle size or its lack of native-DOM performance
ever becomes a real constraint at scale, pragmatic-drag-and-drop is the
documented fallback.

Do not adopt **react-dnd** (over a year without a commit, heavier abstraction,
weaker a11y) or raw **HTML5 DnD** (no accessible keyboard path, inconsistent
cross-browser drag visuals) — both are worse on every axis checked.

## What we'd adopt (if owner approves)

- Card drag between `/requests` board columns: wire `@dnd-kit/core` +
  `@dnd-kit/sortable` around the existing column/card components in
  `apps/web` (Astryx primitives stay the visual layer; `@dnd-kit` supplies
  drag sensors, collision detection, and the sortable list behavior). Each
  drop event feeds the board's existing column-transition/claim state
  machine in the collector — no new state model, no new backend endpoint
  shape, just a new client-side trigger for the mutation path that already
  exists for manual column moves.
- Reference (read-only, not code-copy) Kaneo's column-transition and
  card-detail schema for any gaps in the detail-drawer work in progress,
  given its MIT license and TS/Bun stack makes its code directly legible
  without translation.
- Do not import Planka/Vikunja code verbatim (AGPL-3.0 copyleft) — UX
  reference only.

## What was NOT verified

- Did not run either library inside the actual `apps/web` tree — this is a
  desk evaluation from license/registry/repo metadata, not a working
  integration spike. Bundle-size numbers are the libraries' own published
  figures, not a measured build-size delta for this specific app.
- Did not audit Kaneo's or Planka's actual column-transition code line by
  line — assessed stack/license fit and repo health signals, not code
  quality or security posture of either project.
- Did not test @dnd-kit's keyboard sensor against Astryx's existing
  keyboard-navigation patterns for a conflict — flagged as the first thing
  to check in an implementation spike, not confirmed compatible here.
- GitHub's automatic license detection returned `NOASSERTION` for Planka,
  Focalboard, and Wekan; the licenses stated above were cross-checked
  against each project's own LICENSE/README language, not re-derived from
  a legal reading of the license text itself.

## Next executable action

Owner decides: (1) approve `@dnd-kit` adoption for card drag-and-drop — if
approved, next step is an implementation spike wiring `@dnd-kit/sortable`
into the existing `/requests` board columns, behind the existing collector
mutation path; (2) no action needed on the kanban-mining recommendation
(Kaneo reference) unless/until the detail-drawer work in progress hits a
gap this research can inform.

## Current receipt

2026-08-15: research completed via live GitHub REST API + npm registry
checks (see Method section for exact endpoints/fields pulled). Plan filed,
board task `manual-f8b44a43c5264051` claimed. No code changes made — this
is a read-only research deliverable per task scope.