# Native macOS / Indie / Personal Kanban & Plain-Text-Adjacent Tools

Scope: this is Lanework's most direct competitive neighborhood — native or near-native macOS kanban apps built by indies, plus the wider ring of plain-text and markdown/file-based task tools (PKM apps with board views, open-source self-hosted kanban, CLI/plain-text ecosystems, and the newly-emerging category of AI-agent-native task trackers). For every app the key axis tracked is data model: does it own a proprietary database, or does it store state as files a human (or agent, or `git`) can read and edit directly. This is a broad first pass, not exhaustive — it's meant to map the neighborhood and surface patterns, not to be a definitive database.

Researched: 2026-08-01

## 1. Native macOS indie kanban apps (direct competitors)

### Kanbanier
One-line: polished native Mac/iOS kanban board app, the closest thing to an "established" indie kanban incumbent on the Mac App Store.
Platform: macOS + iOS, native (Swift/AppKit-family), historically on the Mac App Store.
App Store: **apparently delisted** (checked 2026-08-01) — the widely-cited Mac (id1206854548) and iOS (id1206858343) listings both 404, and the iTunes Search API returns no hits for the app or its developer in either storefront, while kanbanier.com still markets it as live. A quiet delisting is a stronger decline signal than anything else in this entry.
Data model: proprietary — boards live in the app's own storage, exported/synced via iCloud; no user-facing files.
Pricing: one-time purchase, ~$15, with a free tier of limited functionality; in-app purchase unlocks swimlanes/sublanes.
Standout features: swimlanes and hierarchical sub-lanes, tags/colors, iCloud sync, cross-device (iOS+Mac) support, no accounts/subscriptions.
Sync: iCloud only.
Signals: has been around for years (multiple SEO/download-mirror sites index it) and was the closest thing to an established indie incumbent — but the apparent App Store delisting (above) reclassifies it from "mature/low-growth" to likely abandoned or withdrawn; the incumbent slot on the MAS shelf may be effectively vacant.

### Kanbanero
One-line: minimalist native Mac kanban board explicitly built around "boards are files" — the single closest analog to Lanework's own pitch in this whole survey.
Platform: macOS only, native, universal binary, macOS 12+.
App Store: [Mac](https://apps.apple.com/us/app/kanbanero/id1645553955?mt=12)
Data model: **each board is a plain JSON file in a folder you pick** — explicitly pitched as diffable/git-friendly ("check them into your project repo, review changes in diffs, keep task state alongside your code").
Pricing: one-time $8.99 on the Mac App Store, no subscriptions/accounts/IAP.
Standout features: keyboard-driven (⌘N new task, ⌘L switch project), templates, themeable (fonts, accent colors, animated shader backgrounds), sync delegated to whatever the user already uses (iCloud Drive, Dropbox, Syncthing, git) rather than built-in.
Sync: none built-in by design — user puts the folder wherever they already sync.
Signals: small/new, marketed almost entirely on the "no accounts, no cloud, no tracking, your data is a file" pitch — i.e. explicitly courting the same buyer Lanework is courting, but with JSON rather than Markdown+folder-structure, and no first-class git/editor/agent story beyond "it's just a file."

### Sprout
One-line: newer (Dec 2025 Product Hunt launch) "calm," minimalist native Mac kanban app pitched against feature bloat.
Platform: macOS, native, Mac App Store.
App Store: [Mac](https://apps.apple.com/us/app/sprout-kanban-board-tasks/id6752939873?mt=12)
Data model: proprietary — Core Data, not user-facing files.
Pricing: free with an optional Pro/lifetime upgrade.
Standout features: zero onboarding, no accounts, offline-first, iCloud sync across devices, no notifications/ads.
Sync: iCloud.
Signals: fresh Product Hunt launch, positions directly against "everything apps" (implicitly Notion/ClickUp) — validates that "calm, native, boring-in-a-good-way kanban" is a currently-active niche indies are still entering.

### Kanba
One-line: free-with-IAP simple kanban board on the Mac/iOS App Store.
Platform: iOS-first; runs on Mac only via Apple Silicon's "iPad apps on Mac" compatibility (checked 2026-08-01), not a dedicated macOS binary — which explains the macOS 15+/Apple Silicon requirement.
App Store: [Mac + iOS (universal listing)](https://apps.apple.com/us/app/kanba-kanban-project-board/id6499422529)
Data model: proprietary, iCloud-synced.
Pricing: free with in-app purchases (amounts not published on listing).
Standout: clean layout, no sign-in, works offline, dark mode.
Sync: iCloud.
Signals: generic entrant, low differentiation; illustrates how crowded the "simple native kanban" MAS shelf is.

### Truly Simple Kanban
One-line: minimalist single-board-free kanban targeted at makers/students.
Platform: macOS + iPhone, native.
App Store: [Mac + iOS (universal listing)](https://apps.apple.com/us/app/truly-simple-kanban/id6746863668)
Data model: proprietary.
Pricing: free for one board; $4.99 one-time lifetime IAP for unlimited boards.
Standout: deliberately narrow scope, no subscriptions/hidden fees.
Signals: another data point that $0–5 one-time is the going rate for "simple kanban" on MAS.

### TidyCards
One-line: older, once-well-regarded native Mac kanban app now showing its age.
Platform: macOS, native.
App Store: [Mac](https://apps.apple.com/us/app/tidycards-awesome-kanban/id1285199566?mt=12)
Data model: proprietary; supports drag-and-drop file/calendar/email attachments into cards.
Pricing: paid app (legacy MAS pricing).
Standout (historically): considered by some reviewers "the best Mac native, dedicated kanban app" for its native-feel simplicity.
Complaints: reports of the app hanging/freezing after being open a while, requiring force-quit; no updates in ~2 years per App Store listing; developer only sporadically responsive.
Signals: a cautionary tale — a well-loved native indie kanban app that stalled once the solo dev's attention moved on, and users noticed and complained loudly about staleness/bugs. Relevant to Lanework as evidence that in this niche, users will tolerate few features but not bugs/abandonment.

### WipQ – Kanban Projects
One-line: kanban for solo professionals/small teams with an emphasis on WIP limits and full native macOS document model integration.
Platform: macOS + iOS (macOS 11+/iOS 13+), native, uses Apple's document architecture (versioning, tabs, full screen, etc.).
App Store: [Mac](https://apps.apple.com/us/app/wipq-kanban-projects/id1235518457?mt=12)
Data model: proprietary, but **data stored locally on the Mac or in iCloud Drive**, explicitly "not a third party web service."
Pricing: paid MAS app.
Standout: customizable WIP limits, inter-card dependencies, card locking, favorites/priorities, file attachments, multiple card-display themes.
Signals: one of the more feature-rich native entrants (closer to "real" kanban/WIP discipline than most indie boards), but data model is still app-owned files-in-iCloud-Drive rather than user-editable markdown.

### Propel
One-line: open-source, zero-dependency native SwiftUI kanban app for personal task management, tuned for content-creator workflows (blog posts, talks, videos, podcasts).
Platform: macOS 15+, native SwiftUI/Swift 6, no Xcode project (SPM only).
Data model: **human-readable JSON** in `~/Library/Application Support/Propel/`, atomic writes with backup, 1s-debounced autosave — file-based but not markdown, and not a user-chosen folder (it's tucked in Application Support rather than a project folder).
Pricing: free, MIT-licensed, open source.
Standout: global hotkey capture, 3 boards with ⌘1/2/3 switching, weekly review summaries, auto-archive of week-old completed cards, menu bar stats.
Signals: 11 GitHub stars/2 forks — small hobby project, but demonstrates the same instinct (native SwiftUI + plain files) an indie developer would reach for; useful as a build-pattern reference more than a market threat.

### FileBoard: Kanban for Files
One-line: turns any real folder on disk into a kanban board where **columns are subfolders and cards are the actual files in them** — not markdown cards, but literally your files.
Platform: macOS only, released Dec 2025 (very new, v1.1 as of late Dec 2025).
App Store: [Mac](https://apps.apple.com/us/app/fileboard-kanban-for-files/id6745226062?mt=12)
Data model: **the filesystem itself is the board** — no separate database, no card content of its own; dragging a card between columns physically moves the file between subfolders.
Pricing: free to download, "FileBoard Lifetime" IAP at $0.99.
Standout: real-time two-way sync with Finder (no duplication), file preview pane, folder tree browsing, keyboard-first navigation.
Signals: brand new, not enough MAS reviews yet to gauge reception, but conceptually the single closest cousin to Lanework found in this research — same "folder structure IS the board" idea, just applied to arbitrary files/folders rather than a markdown-card-per-task model with frontmatter/metadata. Worth watching as it matures; currently much thinner (no card metadata, tags, dates, etc.) than what Lanework offers.

### Brisqi
One-line: cross-platform "offline-first personal kanban" desktop+mobile app.
Platform: Windows/macOS/Ubuntu desktop + mobile, appears Electron-based.
Data model: local device storage, CSV export, no user-facing markdown/files during normal use.
Pricing: one-time purchase (amount not listed on landing page), pitched explicitly against subscription fatigue.
Standout: markdown-formatted card descriptions, monthly calendar view, "List Focus Mode," card linking, custom backgrounds, bulk paste-to-create.
Sync: none — local only, manual backup.
Signals: same buyer profile as Kanbanero/Sprout (privacy, offline, one-time price) but cross-platform Electron rather than native Mac.

## 2. Freeform / notebook apps with kanban as a feature

### Curio (Zengobi)
One-line: the Mac's long-running "advanced notebook" app — freeform idea-space canvases that include Kanban "Stacks" as one of many card/board tools alongside mind maps, outlines, and tables.
Platform: macOS, native, on the Mac App Store since long before most kanban-specific apps existed.
App Store: [Mac](https://apps.apple.com/us/app/curio-notes-ideas-mind-map/id1475550603?mt=12)
Data model: proprietary Curio project files stored locally on the Mac (offline-capable), not markdown.
Pricing: dual model — Mac App Store subscription (Standard $4.99/mo or $49.99/yr; Professional $6.99/mo or $69.99/yr) **or** a one-time license key purchased directly from Zengobi (current version + 1 year of updates, then owned outright). This "subscribe via MAS or buy a perpetual key direct" dual-track pricing is a notable, still-rare pattern worth flagging.
Standout: kanban is a minor feature inside a much larger freeform PKM/mind-mapping tool; not a kanban-first product.
Signals: long-lived (Zengobi has sold Curio for close to two decades), loyal niche audience of "notebook" power users; not really competing for the "I just want a simple board" buyer.

### Walling
One-line: card-based whiteboard/PKM app that combines a spatial "wall" view with a dedicated Kanban view over the same cards ("bricks").
Platform: web app (cross-platform via browser), not native Mac.
Data model: cloud/proprietary — data stored on Walling's servers, encrypted in transit and at rest; no local-file option.
Pricing: free up to 100 bricks; Premium ~$5–8/month (or $59.99/yr annual); Team plans from $8/user/month.
Standout: dual visual (freeform whiteboard) + kanban views of the same card set, OCR on images, templates.
Signals: this is the opposite end of the spectrum from Lanework — cloud-hosted, subscription, no local-file story — useful mainly as a contrast case (what "modern whiteboard SaaS" pricing/positioning looks like).

### Craft
One-line: polished all-in-one docs/notes app (Notion-adjacent) with a Kanban *view* over any Collection, not a dedicated kanban product.
Platform: native-feeling apps on Mac/iOS/Windows/web, but backed by Craft's own cloud sync.
App Store: [Mac + iOS (universal listing)](https://apps.apple.com/us/app/craft-notes-documents-ai/id1487937127)
Data model: proprietary Craft documents/blocks; Kanban view auto-generates a Status field (To do/In progress/Done) grouping cards by a field value — not files on disk.
Pricing: Free tier (1,500 blocks, 1GB storage, 15 AI credits/mo, 7-day history); Plus ~$8/mo (~$4.80/mo promo annual); Family $15/mo; Team $50/mo.
Standout: kanban is one of several interchangeable views (table, board, gallery) over structured "Collections"; strong design polish.
Signals: represents the "beautiful all-in-one workspace with a kanban view bolted on" category — direct evidence that kanban-as-a-feature inside a bigger subscription product is a well-trodden path Lanework is deliberately not taking.

## 3. File-based / markdown-native local kanban apps (closest philosophical peers)

This cluster is the most important for Lanework: every one of these stores board state as plain files on disk rather than in a database, which is Lanework's core bet.

### Signboard
One-line: local-first desktop kanban app built explicitly on the "file over app" philosophy — **lists are folders, cards are Markdown files**, moving a card between lists literally moves the file between folders.
Platform: macOS/Windows/Linux, **Electron** (not native) — Node.js/TypeScript codebase, universal binary on Mac.
Data model: cards = individual Markdown files with frontmatter for metadata (dates, labels, links); lists = directories; boards can be nested directly inside an Obsidian vault (e.g. `Vault/Project/Signboard/<Board Name>/`).
Pricing: MIT-licensed source; free for personal use, requested $49 one-time "sponsorship" for commercial/work use (honor system), optional tips.
Standout features: multiple views (Kanban drag-and-drop, dense Table view, Planner with Calendar/Week/Day/Agenda), Smart Actions powered by *local* LLMs, an MCP server for AI-agent integration, a CLI for scripting/automation, checklists with progress counters, start/due dates with notifications, Obsidian vault interop.
Sync: none built-in — relies on the folder being placed in iCloud Drive/Dropbox/Obsidian Sync/git, same as Lanework's approach.
Traction: ~83 GitHub stars, 8 forks, actively developed (devlog, v1.6.0 recently shipped with performance work), built by Colin Devroe (a known indie/blogging-world figure), launched publicly in fall 2025.
Deep-dive addendum (2026-08-01): launched Sept 16, 2025 deliberately unfinished ("very early and basic," no app icon) to invite community input; reached 1.6.0 by July 2026 — 1.4 added the Planner workspace (Calendar/This Week/Day/Agenda), 1.5 deepened Obsidian integration (properties, Bases generation, deep links, companion plugin), 1.6 added Smart Actions (local Ollama), start dates, and Table-view bulk actions. Stated principles: open source, performance, *clean markdown with minimal frontmatter*, no heavy frameworks (plain HTML/CSS/JS in Electron), minimal dependencies, zero web requests. Imports from Trello exports, Obsidian markdown boards, and Tasks.md workspaces — it is deliberately positioning as the consolidation point for the whole file-based-board niche. Multiple boards in tabs; labels with colors; card- and task-level due dates; Quick Add; archive/restore; notifications and a local calendar feed; MIT-licensed with honor-system $49 commercial payment plus tip jar. AI/MCP was not part of the original launch pitch (the Sept 2025 launch post doesn't mention agents at all) — it was added along the way, so its agent story is a bolt-on, not the founding thesis. Third-party coverage so far is thin (casual "looks interesting" blog mentions, no substantive reviews found), consistent with the ~83-star count: philosophy-aligned but small.
Schema (from docs/using-signboard.md + MIT source, 2026-08-01): board = folder; list = subfolder with a numeric ordering prefix in the folder name (reorder renames directories); card = single `.md` file named `[order-prefix]-[title]-[random-id].md` (retitle/reorder renames the file); frontmatter is deliberately flat and Obsidian-property-friendly — `title`, `signboard_id`, `signboard_board`, `signboard_list`, `status`, `signboard_uri`, `related`, `linked_objects` — note `signboard_board`/`signboard_list` denormalize location into the file, duplicating what the path already says; checklist-item dates are inline body syntax `(start:|due:|scheduled: YYYY-MM-DD)`; `board-settings.md` at root; archive = `XXX-Archive` folder. No schema version key, no stated round-trip/preservation guarantees, no formal spec document — the format is defined by prose docs plus the MIT code. Key structural contrasts with Lanework: identity lives in mutable filenames (vs immutable UUID folder names), ordering lives in name prefixes causing rename cascades (vs gapped fractional ranks rewriting one file), location is duplicated into frontmatter where hand/agent moves can leave it stale (vs level-is-position with zero redundancy), and cards are single files with reference-style linked objects (vs folder-per-card with real `attachments/`). Full analysis: [07-schema-comparison-signboard.md](07-schema-comparison-signboard.md).
**This is the single most directly comparable competitor found in this research.** Same file-over-app philosophy, same "folder=list, file=card" model, same explicit agent/MCP-friendliness pitch — but Electron rather than native macOS, and a paid-commercial-use/free-personal-use model rather than Lanework's presumed pricing. A native, faster, more Mac-idiomatic Lanework is a legitimate differentiation story against Signboard specifically.

### Tasks.md
One-line: the most established member of this cluster — a **self-hosted web app** where lanes are directories and tasks are Markdown files, no database at all.
Platform: self-hosted via single Docker image (Railway/Zeabur one-click deploys exist); frontend SolidJS, backend Koa/Node; accessed via browser, installable as a PWA.
Data model: filesystem is the database — one directory per lane, one `.md` file per task; subdirectories can be opened as separate "projects."
Pricing: free, MIT-licensed, open source.
Standout: theme support (Adwaita/Nord/Catppuccin) that follows OS light/dark, reverse-proxy subpath support, deliberately narrow feature scope "for long-term sustainability" per the maintainer.
Traction: **2.2k GitHub stars, 105 forks** — by far the most-starred file-based kanban tool found in this survey, suggesting real demand for exactly this "markdown files as kanban" model, just currently served by a self-hosted web tool rather than a native Mac app.
Signals: proves the underlying idea (folder=column, file=card, no DB) has substantial developer-community appetite; a native Mac app doing the same thing with better UX is a clear opportunity, which is exactly Lanework's bet.

### Kanban MD (kanbanmd.lecaro.me)
One-line: tiny desktop app that treats a handful of local text files as a kanban board — free, fast, offline, currently Linux-only.
Data model: plain text files, no cloud.
Signals: another indie solo-dev experiment validating the "text files as board" idea; Linux-only today means no direct macOS overlap yet, but shows the pattern recurring independently across multiple developers (Tasks.md, Signboard, Kanban MD, Kanbanero, banban, KanbanFiles, FileBoard all converged on similar ideas independently in roughly the same 2024-2026 window).

### KanbanFiles
One-line: native Windows desktop app that turns folders and markdown files into a two-way-synced kanban board (cards = markdown files as columns' contents).
Platform: Windows only (per search results) — not currently a Mac threat, but conceptually identical territory.

### kanban.md / Kanban Markdown (VS Code extensions)
One-line: editor extensions ("VS Code meets Kanban") that render a markdown file's nested lists as a draggable board directly inside the code editor.
Signals: shows the pattern extending into "kanban as an editor feature" rather than a standalone app — relevant to Lanework's "text editors are first-class users of a board" thesis, since these tools assume the *editor*, not a bespoke app, is where you'll often view the board.

### MarkdownTaskManager (ioniks)
One-line: small open-source local-first Kanban task manager that turns markdown files into an interactive board, no database or server.
Signals: yet another indie project independently reinventing the same "markdown files → kanban" pattern — further evidence of a real, recurring itch developers keep scratching for themselves.

### banban (two unrelated projects, same name)
One-line: (1) HubertK05/banban — productivity app inspired by GitHub Projects' kanban; (2) m0g/banban — self-hosted kanban board tool. Both small open-source projects, not directly Mac-native, but both part of the same "roll your own lightweight kanban" wave.

### imdone
One-line: the oldest/most mature entry in this space — turns `TODO`/`FIXME` code comments *and* markdown task files into a kanban board, tightly integrated with your editor and codebase.
Platform: Imdone Desktop app, plus VS Code and Obsidian integrations; imdone-core is an open-source "text based kanban processor" npm package.
Data model: **local-first**, markdown + code-comment-based; a CLI can pull Jira/GitHub issues into the repo as markdown files which then render as cards on the board.
Pricing: Imdone Desktop, ~$14.99 (a 2020s TechRepublic piece flagged its price drop to this level).
Standout: bridges the gap between "task tracker" and "code," making TODO comments in source files first-class kanban cards — a different but adjacent take on "the filesystem/repo is the board."
Signals: imdone has existed since well before the current file-based-kanban wave (it's the "OG" of this niche) and is still maintained; worth understanding as the elder statesman of the category, more code-centric than Lanework's general-purpose board.

## 4. Open-source / self-hosted kanban (broader OSS category, mostly team/web-first)

### Kanri
One-line: fully offline, cross-platform (Windows/macOS/Linux) Tauri+Nuxt kanban app, 100% free and open source.
Data model: **entire board state in one local JSON file** — no server, no accounts.
Pricing: free/OSS.
Standout: unlimited boards/columns/cards, zero-latency offline, "if you want no one else looking at your data, this is the way" (paraphrased user sentiment).
Complaints: no attachments, no card-to-card links (per a reviewer).
Signals: HN launch thread existed (id 36745421) showing the "offline-first personal kanban" pitch resonates on HN, though direct thread content wasn't retrievable here; broadly the JSON-file/Tauri sibling of Kanbanero, but cross-platform and free rather than Mac-only and paid.

### Focalboard
One-line: OSS Trello/Notion/Asana alternative from Mattermost, offered both as a team server and as a **standalone single-user "Personal Desktop" app** for Mac/Windows/Linux.
Data model: own database (not markdown files) even in the personal desktop edition.
Pricing: free/OSS; Mattermost Boards cloud/server editions exist for teams.
Signals: mainly a team-collaboration/self-hosted-SaaS play; the personal desktop edition is a lesser-known side door that competes loosely with indie personal-kanban apps, but without the file-based data model. Its Mac App Store listing (id1556908618) appears delisted as of 2026-08-01 — Mattermost's docs still describe a MAS edition, but the listing 404s and store search doesn't surface it — so the desktop edition is effectively direct-download/build-only now.

### Planka
One-line: OSS, Trello-look-alike self-hosted kanban (React/Node/Postgres), known for visual polish and snappy performance.
Data model: own Postgres DB, not files.
Licensing: **not** OSI-approved OSS — a custom "Fair Use License" that bars operating Planka as a hosted service for third parties and cross-company account sharing without a paid Pro tier.
Signals: primarily a self-hosted team tool; Docker-deployed (8M+ pulls) — relevant as market-size evidence for "people want to self-host their own Trello," but not a personal-file-based competitor.

### Wekan
One-line: long-running, MIT-licensed, Meteor/MongoDB OSS kanban, translated into ~50 languages, notable for a rules/automation engine.
Data model: MongoDB, not files.
Signals: mature (multi-year) OSS project, team/self-host oriented, not a Lanework analog but a market-size/longevity data point for "kanban that isn't Trello."

### Vikunja
One-line: OSS (AGPLv3), self-hosted task manager (Go+Vue) offering lists, kanban boards, Gantt charts, and tables, with import from Todoist/Trello/MS To-Do.
Data model: own DB; bootstrapped EU company also offers a hosted "Vikunja Cloud."
Signals: broader task-manager-with-a-kanban-view rather than kanban-first; shows the self-hosted-SaaS-alternative segment is viable as an actual (bootstrapped, non-VC) business, which is encouraging context for indie/solo economics generally.

## 5. PKM / outliner apps with markdown + task/board features

### Obsidian Kanban plugin (mgmeyers, now community-maintained)
One-line: the dominant way Obsidian users get kanban — markdown-backed drag-and-drop boards stored as a single markdown file per board, lists as headings, cards as list items.
Data model: plain markdown, lives in the vault, fully git/editor-compatible.
Pricing: free plugin; Obsidian itself is free for personal use ($50/yr commercial, $8-10/mo Sync/Publish add-ons).
Notable forks/variants: **Plain Text Kanban** plugin renders nested markdown lists as a board while keeping the underlying file dead simple/readable in any editor (no special block syntax); **obsidian-mkanban** goes further, splitting each column/card into its own file in a folder structure — i.e. independently reinventing something close to Lanework's own model, inside Obsidian.
Context: Obsidian shipped a native "Bases" feature (database-like views over notes) in 2025, and a first-party Kanban view for Bases is reportedly coming — which could commoditize the community plugin's core use case over time.
Signals: this is arguably the largest existing user base of "markdown file-backed kanban" today (Obsidian has millions of users, Kanban is a top-tier community plugin), and it's the best evidence that a large audience already wants exactly Lanework's data model — Lanework's differentiation is being a dedicated, native, non-PKM app rather than a feature bolted onto a notes tool.

### Logseq
One-line: open-source, local-first, block-based outliner/PKM (markdown or org-mode files) with kanban available only via community plugins/queries, not a first-class primitive.
Data model: plain markdown/org files on disk, fully local-first, no proprietary format.
Standout: a long-running (multi-year, 100+ reply) feature-request thread "Introduce Kanban boards as a new primitive" shows real, sustained user demand for native kanban that the core team hasn't prioritized — plugins (logseq-kanban-plugin, logseq-plugin-agenda's kanban view) fill the gap by treating parent blocks as columns and child blocks/queries as cards.
Signals: another large local-first/markdown-native user base whose kanban needs are underserved by the core product — a potential adjacent-audience signal for Lanework (Logseq users who want real kanban and don't want to fight plugins for it).

### NotePlan
One-line: markdown notes + calendar + tasks in one app, with each day as a markdown file; not kanban-first but heavily plain-text-native.
Platform: macOS/iPad/iPhone, native-ish (details not fully confirmed), iCloud sync.
App Store: [Mac + iOS (universal listing)](https://apps.apple.com/us/app/noteplan-to-do-list-notes/id1505432629)
Data model: markdown notes/tasks, calendar-integrated, timeblocking.
Pricing: subscription-based (via Setapp and direct), free trial.
Signals: shows the "daily markdown note + tasks" niche is healthy and Mac-native-first; not a kanban competitor per se but a neighboring plain-text productivity app with a loyal following (MacStories/MacSparky coverage).

### Agenda
One-line: date-focused notes app (notes meets calendar) for Mac/iPad/iPhone, not kanban but a well-known example of Mac-indie pricing innovation.
App Store: [Mac](https://apps.apple.com/us/app/agenda-notes-meets-calendar/id1287445660?mt=12) / [iOS](https://apps.apple.com/us/app/agenda-notes-meets-calendar/id1370289240)
Pricing model: notably generous — **free forever core app**, premium features unlocked via one-time-feeling IAP ($34.99/yr covers Mac+iOS, or $14.99/yr iOS-only) that stays unlocked permanently even if you stop paying (only *future* premium features added after your paid year require renewal). This "pay once, keep what you unlocked forever" hybrid is a well-regarded pricing pattern in the Mac indie world worth Lanework considering.
Data model: proprietary, not markdown.

### TaskPaper
One-line: the classic plain-text to-do list app for Mac — projects/tasks/notes/@tags encoded in a deliberately simple, human-readable plain-text syntax.
Platform: macOS, native, Mac App Store, by Hog Bay Software (Jesse Grosjean).
App Store: [Mac](https://apps.apple.com/us/app/taskpaper-plain-text-to-dos/id1090940630?mt=12)
Data model: plain `.taskpaper` text files, explicitly designed to be "future proof," editable in any text editor, with a documented format other developers have built compatible tools around.
Pricing: $24.99 one-time on the Mac App Store.
Signals: TaskPaper is the longest-running proof that "plain text is the file format, and a dedicated Mac app is the good way to interact with it" is a viable, sustainable indie Mac business (TaskPaper 3 dates to 2016, format traces to 2006) — a strong precedent for Lanework's own bet, applied to task lists rather than boards.

### Zavala
One-line: free, open-source, native outliner for Mac/iPad/iPhone.
App Store: [Mac + iOS (universal listing)](https://apps.apple.com/us/app/zavala/id1546457750)
Data model: proprietary outline format internally, but with OPML and Markdown *export*; iCloud sync/sharing.
Pricing: completely free, no ads, no IAP — funded as a personal/open-source project by developer Maurice Parker.
Signals: shows a native Mac indie tool can be given away entirely free and still be well-regarded (multiple positive reviews, MacPowerUsers community coverage) — an important pricing-strategy data point, though a very different economic model (not the developer's primary income) than what an indie kanban app like Lanework likely needs.

## 6. Plain-text / CLI task ecosystems

### todo.txt
One-line: the original minimalist plain-text task format/standard (`(A) Buy milk +groceries @errands`), with a large multi-platform app ecosystem built around it.
Data model: literally just a `.txt` file with a line-per-task convention; the "format" is the product, not any single app.
Ecosystem: mobile apps (Android/iOS) syncing via Dropbox/Google Drive, desktop GUIs (e.g. Sleek), VS Code extensions for syntax highlighting, and a reference CLI with archiving/filtering.
Signals: the longest-running proof that a dead-simple, fully open text convention can sustain a durable multi-app ecosystem for well over a decade — the strongest "format over app" precedent Lanework can point to, albeit for flat task lists rather than boards.

### Taskwarrior
One-line: powerful CLI task manager for developers/power users, with urgency scoring, tags, filtering, and recurring tasks.
Data model: **Taskwarrior 2.x stored plain `.data` files; Taskwarrior 3.x switched to a SQLite database** (`taskchampion.sqlite3`) — an instructive precedent of a plain-text-first tool *moving away* from plain text toward a database as it matured, presumably for performance/sync-conflict reasons. Worth noting as a counter-data-point: file-based purity can have real technical costs at scale that even beloved plain-text tools eventually pay down.
Signals: still has an active, vocal power-user community (HN, multiple 2025-era how-to articles) valuing CLI speed, scriptability, and (formerly) plain text; a useful cautionary tale about the limits of pure flat-file storage as feature/dataset size grows.

## 7. AI-agent-native task/kanban trackers (fast-emerging 2025-2026 category)

This category didn't really exist before AI coding agents did, and it's now moving fast — directly validating Lanework's "AI agents are first-class users of a board" bet, though these tools are aimed at *coding-agent task queues* specifically rather than general personal/team kanban.

- **backlog.md** — MIT-licensed CLI+web tool that turns any git repo into a self-contained project board: every task is a plain `.md` file in the repo, with acceptance criteria, milestones, and dependencies; status is tracked via git history; works with Claude Code, Gemini CLI, Codex, and any MCP-compatible agent; has both an instant terminal kanban view and a web UI. Closest agent-facing analog to Lanework's own repo-embedded, git-diffable philosophy.
- **claude-task-master / TaskMaster AI** — ingests a PRD and generates a dependency-aware task hierarchy for AI agents to work through; wired into Cursor/Windsurf/MCP hosts; markdown-adjacent but oriented around task IDs/dependencies more than a visual board.
- **TaskForge** — task manager built on markdown files living inside an Obsidian vault, explicitly designed to be "editable by Claude or any agent."
- **CodeAgentSwarm** — a literal kanban board (Pending/In Progress/In Testing/Completed) where Claude Code agents themselves read and move their own cards and write completion summaries.
- **Nimbalyst** — a Claude Code session kanban board where each running agent session is a card moving through backlog → planning → implementing → validating → complete; positions itself as the broadest "auto-tracks every session" option.
- **Cursor's Agent Kanban (SDK)** — a drag-and-drop board shipped as part of Cursor's TypeScript SDK where dropping a card into a column causes an agent to write code in a cloud VM and open a PR.
- Windsurf shipped a similar kanban-style view of local/cloud agent sessions in May 2026.

Pattern: across this whole sub-category, "kanban board" has become the default UI metaphor for supervising AI agents' work-in-progress, and markdown files are the default substrate for describing that work — which is strong external validation that Lanework's core thesis (files + boards + agents as first-class users) is not a niche eccentricity but a live, fast-growing design pattern in exactly this moment. The gap: every one of these tools is scoped to *coding-agent task queues inside a repo*, not general personal/creative/life kanban — Lanework's broader "any kind of board, any kind of file" scope is currently unserved by this cluster.

## Patterns

**Pricing norms in this niche.** One-time purchase in the $0–25 range dominates solo/personal-use native Mac kanban apps (Kanbanero $8.99, Truly Simple Kanban $4.99, TaskPaper $24.99, FileBoard $0.99 lifetime, Kanbanier ~$15); free-with-optional-tip/lifetime is common among newer indie entrants (Sprout, Kanri, Zavala); subscriptions appear mainly once an app broadens beyond "just a board" into a full workspace/PKM platform (Craft $8-15/mo, Walling $5-8/mo, Curio $5-7/mo *or* a one-time key). Users in this niche (TidBITS forum thread, App-Store-review sentiment, HN commentary) explicitly and repeatedly express subscription fatigue and a preference for paying once for a tool that "just works" locally — this is a receptive market for Lanework's likely pricing instincts, not a hostile one.

**What indie/native productivity-app buyers in this niche value, in rough order of how often it recurs across research:** (1) local-first / offline-capable / no-account-required, stated almost universally as a selling point rather than a footnote; (2) data ownership — increasingly phrased explicitly as "my data survives the app" (the "file over app" framing popularized by Obsidian's Steph Ango in 2023 has become a widely-cited north star across this whole space, not just inside Obsidian); (3) speed/native feel — repeated complaints about Electron sluggishness and repeated praise for "feels like a real Mac app"; (4) keyboard-first workflows (Kanbanero, TaskPaper, Zavala, Propel all lead with shortcuts); (5) restraint/simplicity as a stated differentiator against "everything apps" like Notion/ClickUp/Monday — nearly every newer entrant (Sprout, Truly Simple Kanban, Kanri) positions itself explicitly against feature bloat; (6) design polish still matters even in a minimalist tool (Kanbanero's animated shader backgrounds, Planka's Trello-grade visual fidelity) — "simple" doesn't mean "ugly is fine."

**Convergent evolution toward "folder = column, file = card."** Independently, and apparently without much cross-awareness, at least six different developers/teams arrived at essentially the same data model Lanework uses — Signboard, Tasks.md, Kanban MD, Kanbanero (JSON variant), banban, and FileBoard all map board structure onto filesystem structure, mostly within a roughly 2024-2026 window. Tasks.md's 2.2k GitHub stars is the clearest signal that real demand exists for this pattern; the fact that no single native, polished, well-funded macOS app has yet claimed this territory (Signboard is Electron; Kanbanero uses JSON not markdown and has no card-body/frontmatter richness; FileBoard is brand-new and thin; Tasks.md requires self-hosting a Docker container) is the whitespace Lanework is aimed at.

**PKM apps are the biggest existing audience for markdown-backed kanban, but treat it as a secondary feature.** Obsidian's Kanban plugin, Logseq's long-requested-but-still-plugin-only kanban, and Curio's "Stacks" all serve real, large user bases who already want exactly this data model, but in every case kanban is bolted onto a broader notes/PKM tool rather than being the product. A dedicated, kanban-first, markdown-native native Mac app is conspicuously not what any of these audiences currently have.

**AI-agent-friendliness has gone from novelty to expected-by-default in months, not years.** As of this research (Aug 2026), a whole cluster of tools (backlog.md, TaskMaster AI, TaskForge, CodeAgentSwarm, Nimbalyst, Cursor's and Windsurf's built-in agent-kanban views) treat "an AI agent can read/write this board" as a baseline requirement, and markdown-files-in-a-repo is their overwhelming default substrate. This validates Lanework's positioning but also means the window to be "the app that got there first" for a general-purpose (not just coding-agent-queue) board is closing — competitors could plausibly add agent/MCP support to existing kanban apps (Signboard already has one) faster than Lanework can build out breadth.

**Where the file-based/plain-text movement stands, 2025-2026.** It's no longer a fringe hobbyist position — "file over app" is now a widely-cited framing (helped enormously by Obsidian's scale and Steph Ango's essay), local-first software has its own annual conference (Local-First Conf, Berlin, July 2026, ~350 attendees) and a maturing technical toolkit (Automerge 3.0, CRDT-based sync engines, SQLite-as-universal-app-database patterns), and the practical proof points are stacking up: todo.txt's decade-plus multi-app ecosystem, TaskPaper's 15+-year survival as a paid product, Obsidian's mainstream success, and now Tasks.md's 2.2k-star validation of markdown-as-kanban specifically. At the same time, there are real technical costs to staying pure-file — Taskwarrior's own move from flat files to SQLite in its 3.x line is a pointed reminder that plain-text storage can hit real limits (query performance, conflict resolution, large datasets) that even a beloved plain-text-native tool eventually has to solve by adding structure back in. Lanework's "filesystem is source of truth, with git/editors/agents as first-class users" position sits close to the leading edge of where this movement currently is, particularly in combining it with native macOS polish (most of the current file-based kanban tools are Electron, self-hosted-web, or CLI-first) and with the newest wave of agent-facing demand.
