Search...Search plugins and themes...
⌘K
Sign in
  • Get started
  • Download
  • Pricing
  • Enterprise
  • Account
  • Obsidian
  • Overview
  • Sync
  • Publish
  • Canvas
  • Mobile
  • Web Clipper
  • CLI
  • Learn
  • Help
  • Developers
  • Changelog
  • About
  • Roadmap
  • Blog
  • Resources
  • System status
  • License overview
  • Terms of service
  • Privacy policy
  • Security
  • Community
  • Plugins
  • Themes
  • Discord
  • Forum / 中文论坛
  • Merch store
  • Brand guidelines
Follow us
DiscordTwitterBlueskyThreadsMastodonYouTubeGitHub
© 2026 Obsidian

Kanban Action Planner

Sébastien DuboisSébastien Dubois5k downloads

Render your notes as configurable Kanban boards and calendars inside Bases, with statuses, ordering, relationships, and scheduling.

Add to Obsidian
Kanban Action Planner screenshot
Kanban Action Planner screenshot
Kanban Action Planner screenshot
Kanban Action Planner screenshot
Kanban Action Planner screenshot
  • Overview
  • Scorecard
  • Updates88

An Obsidian plugin that adds a Kanban board view to Obsidian Bases, so you can plan, track, and schedule any set of notes visually.

Pick a status property. It becomes your columns. From there you drag cards between them, reorder them, color them, view and edit the relationships between notes, surface what's blocked, filter as you type, and flip the same board into a calendar to schedule the work. Your existing note properties drive all of it, and every change lands straight back in your frontmatter. Define your note types yourself, or let the Obsidian Starter Kit plugin configure them for you when it's installed.

I built this because I wanted my planning to live in my notes, not in yet another app.

Requires Obsidian 1.13+ (the Bases view API and declarative settings). Works on desktop and mobile.

Video tour

Want the whole picture first? Here's a complete walkthrough (~25 minutes): boards, calendar, timeline, triage, WBS, embeds, and how every change lands in your notes:

Video tour of the Kanban Action Planner

Screenshots

A Base read as a board. Your status property drives the columns, and each card shows the properties you picked in your Bases view:

Kanban board

The same idea on a big task base. Collapse the columns you don't need and the backlog stays out of the way:

Tasks board

Split the board into swimlanes by note type or any property (here, by priority):

Swimlanes

Big boards stay fast. My movie board has 4,888 notes with a poster on each card, and it opens in under 3 seconds: long columns only build the cards near the screen, and covers load as you scroll. Show the whole poster in a 2:3 box, or switch to compact mode for a small thumbnail before each title:

A movie board with 2:3 posters as covers

Color cards by any property, apart from the column colors. Here, tasks are tinted by priority and get a stripe per project:

A task board tinted by priority, with a stripe per project

Flip that exact board into a calendar to schedule the work. Scheduled dates and deadlines, plotted together:

Calendar mode

Or into a Gantt-style timeline that places each card by its start date and estimate, with the Unplanned panel grouping cards by note type and status:

Timeline mode

Break the same work down as a WBS tree. Estimates, progress, and dates roll up the hierarchy (own values win, the rest derives from the children):

WBS mode

Or see what's on your plate right now with the Agenda: a flat, prioritized list of Overdue, Today, and Upcoming items, with a Today/Week window switch and an Available only toggle:

Agenda mode

Shape your ideal week: the recurring time blocks of every active activity and project, on a date-less weekly grid. Drag them, resize them, copy them, nudge them with the keyboard, straight into the notes' time_blocks. Overlaps get refused, every note is listed against its weekly target, and the whole week imports from and exports to JSON or Markdown. Cards and WBS rows then show a weekly budget ring (tracked this week vs target, red above the alarm), and the WBS adds lead, cycle and lateness days per row:

Ideal week mode

The targets table, the other face of the ideal week

When it's time to actually do the work, spotlight one card full-pane in Focus mode. The timer feeds tracked time into your notes:

Focus mode

The pomodoro timer: a ring that drains over the phase, the note it runs on, the cycle count, and the controls in place — in the sidebar, or alone on a full screen for focus stretches and shared screens:

The full-screen pomodoro timer

Card titles drop the note type's decoration ( (Task)), and a collapsed column highlights as a drop target while you drag:

A collapsed column highlighted as the drop target

Filter as you type with a compact query language:

Filter as you type

The ? cheat-sheet keeps the whole query language one click away:

Filter syntax cheat-sheet

Slice any view by GTD contexts (@work, @home, …) from the toolbar @ switcher:

Filter a board by a context

Create cards straight from the board. The dialog shows where the note will land and in which column, before you commit:

Quick capture

It follows the note type the board is about, so the same + creates a goal on a goals board:

Quick capture on a goals board

When a backlog gets overwhelming, work through it one card at a time in Triage mode:

Triage mode

Or triage a single board column Tinder-style: a card stack with every status as a chip below it. Swipe or drag the card to any status (stamp + fly-out animation, confetti on done states), or keep it and move on:

Column triage

Embed the same view in any note, several times in different modes. Here, a board and its calendar in a project note, both pinned to that project. In any project note, ![[Tasks.base#Kanban|mode=board filter=parent:this]] and |mode=calendar … do the same, as this means the note the embed is in:

Embedded views in different modes

The full card menu: scheduling, time tracking, focus mode, statuses, enums, contexts, relationships, and archiving in one place:

Card context menu

Let the board do the bookkeeping with per-note-type automation rules. Enter a done state and the progress, dates, tags, or even the note's folder update themselves:

Automation rules

Configure statuses, colors, relationships, and archiving per note type, synced from the Obsidian Starter Kit when it's present (edits made in the Starter Kit reach open boards live):

Note types

Install

From Community plugins: go to Settings → Community plugins → Browse, search for Kanban Action Planner, install, and enable.

Manually: download main.js, manifest.json, and styles.css from the latest release into <vault>/.obsidian/plugins/kanban-action-planner/, then enable the plugin in Settings → Community plugins.

Then add a Kanban Action Planner view to any Base. That's it. The usage guide walks you through the rest.

Highlights

  • Kanban view in Bases. Add one or more Kanban Action Planner views to any Base. The Base's own filters select the notes.
  • Big boards stay fast. A column with 100 cards or more only builds the cards near the part you can see, and covers load as you scroll, with a placeholder holding their space. A 4,888-card movie board opens in under 3 seconds instead of 8 to 9, and a 2,338-card board game board in 2.3 instead of 5.
  • Embed a board in any note. ![[Tasks.base#Kanban]] renders the view inside a markdown note, sized to its content up to a scrollable height cap. The wikilink alias overrides that one embed (|mode=wbs height=400 filter=status:active) without ever touching the saved view: mode switches and filter edits inside an embed stay in the embed. The same embed works in an Obsidian Canvas card: drag and drop works as usual, and the canvas card's size controls the board (height= is ignored there), so resizing the card resizes the board. columns= and lanes= narrow a board embed to a subset of its columns or swimlanes, by substring, or by whole name with an = prefix, as in columns==doing. In a filter, this means the note the embed is in: parent:this in a project note shows that project's tasks and keeps working after a rename. It works with every relationship and link property (child:this, project:this), matches only the whole note name, and new cards created from the embed get linked to the note. A narrow embed gets a compact toolbar: the date-window chips, then the icon buttons, move into a More (⋯) menu instead of squeezing the filter box, and the mode buttons shrink to the active one, with a ▾ menu of every mode. The toolbar follows the width of the view, not the window, so split panes and phones get the same treatment.
  • Status to columns, defined not guessed. Your status property places cards into columns you define (per view, from the Starter Kit, or in settings), so a typo can never create a stray column. Unmapped notes collect in an "Unmapped" column that hides itself when empty.
  • Move, reorder, sort. Drag a card to another column to change its status, or reorder within a column (written to a configurable manual_order property). Moves show instantly and usually save only the card you moved; missing or duplicate orders are tidied in the background. Send a card straight to the top or bottom of its column from the right-click menu. Auto-sort each column by name or any property, including a base formula like a priority_score, ascending or descending. Full keyboard support (move, reorder, menu) and command-palette commands.
  • Filter as you type. A toolbar search box with a compact, Jira-like query (status:active OR due:overdue, parent:"PKM" -tag:archived), saved per view, in both board and calendar mode, with one-click date-window chips (Today, Next 7 days, Next 30 days, configurable) for what's due or scheduled soon. scheduled:, estimate: (unit-aware: estimate:>4h), progress:, and order: always resolve to the configured properties, whatever they're actually named, just like context: does.
  • GTD contexts. Tag notes with contexts (@work, @home, …) in a contexts list property and filter to any combination from a toolbar @ switcher (or pin one in an embed with context=). Toggle a card's contexts from its right-click menu, and see them color-coded on the calendar and timeline with a click-to-filter legend.
  • Triage mode. Work through an overwhelming backlog one card at a time, setting priority, urgency, effort, and the rest from one-click controls. Full keyboard support (→ next, ← skip, ↑↓ priority, 1-9 status, ⇧↑/⇧↓ top/bottom) and Tinder-style card swipes (right = next, left = skip, up/down = priority). It doubles as a spaced-repetition review queue, surfacing cards whose review is overdue. A per-column triage pass lives on the board too: hit the triage button in any column header for a Tinder-style card stack. Every status shows as a clickable chip under the card, with full-height prev/next rails, swipe or drag-drop onto any target, and a stamp + fly-out animation (confetti on done states) to seal each decision.
  • Relationships, viewable and editable. Parent, sibling, child, and blocked_by via link-properties (plus an optional tag and link heuristic). Navigate them, add or remove them from the card menu, flag and filter blocked items. An archived blocker stops blocking. A role can use several properties, each scoped to the note types it links to (a task with a project parent and a goal parent), mirrored from the Starter Kit when it declares them. Add card on a board filtered by parent:"X" links the new card to X.
  • Focus on a card's children or whole subtree. Zoom into a project (card menu or the ▼ children badge) and the board re-filters to just its children, or all its descendants, in the usual columns. Zoom up from a task via its ▲ parents badge to see the whole project's children (or a goal's entire subtree) at once. A dismissible chip next to the filter box shows the focus; zooming again drills down a level.
  • Swimlanes. Split the board into collapsible lanes by note type or any property, with an Ungrouped lane. Cross-lane drag rewrites the grouping property. A board mixing note types auto-groups by type, and each type's lane gets its own columns, colors, and WIP limits. A card's own note type is authoritative for its status, so a project can never be given a task status.
  • Calendar mode. Flip a board into a scheduling calendar (day, week, month, quarter, year) that plots scheduled dates and deadlines together. Drag cards onto days to set date_scheduled or date_due, with an Unplanned / No-deadline panel and per-day zoom. Or right-click any card (board too) to schedule or set a deadline through a date prompt that understands typed dates (tomorrow, fri, next mon, in 3 days) and previews the exact day it will write. In every scheduling panel (calendar, timeline, WBS), drag a card onto another status group to change its status in place. Cards with an estimate span every covered day (dimmed continuation chips).
  • Timeline mode. A Gantt-style view placing each card by start date + estimate (no end date; days by default, or a per-note-type property/unit override, e.g. tasknotes-style time_estimate minutes, converted via a configurable minutes-per-day): a square without an estimate, a rectangle spanning it with a duration badge (5d). Drag to move the start, resize the right edge to change the estimate, the left edge to shift the start (end stays anchored). The date that will be written shows live on every drag, resize, and drop. Milestone diamonds, a today line, a per-row red deadline line, Week/Month/Quarter/Year axis with Ctrl/Cmd+wheel zoom, a collapsible "Unplanned" side panel of cards grouped by note type and status, and per-type show/hide on mixed boards.
  • WBS mode. A work-breakdown-structure view rendering your parent/child hierarchy as a collapsible tree (goal → projects → tasks) with per-node progress bars, estimates, due-date countdowns, and date spans. One rollup model: a note's own value wins, otherwise it derives from its children. Plan top-down, bottom-up, or both, and persist any rollup to the parent in one click (never double-counted). Give a note type a done state (a property + the value(s) that mean done, e.g. the Completed/Done statuses) and done notes count as 100% in the rollup, so a goal with 2 of 4 tasks done shows 50% without any progress numbers. Siblings with planned dates order themselves chronologically. Works on any view: notes without relationships show as standalone rows, and parents excluded by the view's filters (a tasks-only view whose tasks belong to projects) appear as muted “outside view” context rows so the hierarchy keeps its shape. Drag rows to re-parent or onto the panel to detach (the relationship wikilink is rewritten for you), drag cards from the "Needs planning" backlog into the tree, set status/dates/estimates/progress from any row (click the status dot for a quick status menu; the estimate chip edits inline: type 3, 2h, or 0.5d and press Enter), and distribute a parent's estimate across unestimated children.
  • Focus mode. Spotlight one card full-pane from any view's card menu: title, properties, subtasks, related notes, and a start/stop timer feeding the time-tracking property. Done fires your automations and offers the next card from the same queue; full keyboard support (Esc/→/D/T/O).
  • Ideal week. How you want to spend a week, on a date-less grid. Every active note's time_blocks (mon-fri 09:00-12:00, 15-minute grid, midnight crossing) render per weekday: move and resize them by drag or keyboard, copy them with Alt, create them by click (type-aware picker) or by dragging a note from the rail, which lists every note against its weekly target and asks for a missing target when you first plan a block. Overlaps are refused with the conflicting note named, minutes_planned_per_week is recomputed on every edit, and colour follows the first GTD context. Every edit shows at once and the grid never flickers; drag on the empty grid to draw a block over the cells and days you cover, move a whole selection at once, undo and redo (Ctrl+Z / Ctrl+Shift+Z), right-click an empty cell to plan or paste there, set a note's weekly target from its menu, print the week, and import or export the whole week as JSON or Markdown. Activities and projects then show a weekly budget ring (tracked this ISO week vs target, red above minutes_alarm_per_week, one notice per week) on their cards and WBS rows, goals and plans roll it up, and the WBS adds a lifecycle chip (lead, cycle, lateness, days active). The ideal week's second face is a targets table: every note's weekly target edited in place (5h, Enter moves down), planned minutes and gap, share of the available week, grouped by area or context with subtotals and repartition bars, and a totals row; a target follows the planned blocks when they overshoot it (never lowered), and the rail groups by status, area (areas property) or context, with a filter box for the list. The grid's scale fits a day window (06:00–22:00) to the pane on any window size. And the modes you don't use? Switch them off globally in the settings. Agenda mode

Start/stop a session from any card's menu (one active session; starting elsewhere stops the previous one), or from anywhere: the active note, a switch picker with your recently tracked notes first, or a per-note shortcut you bind a hotkey to, which follows the note when it is renamed or archived. Each session lands as a {startTime, endTime, description} entry in a time_entries list, its minutes are added to the time_spent property (minutes you add by hand or with other tools are kept), and a last-session date is stamped; property names map per note type. Pomodoro mode runs timed work/break periods on a card, records them in the daily note's pomodoros list, and shows a status-bar countdown; phases chain by themselves (work → break → work, skippable, pausable), and a session left running gets idle detection and a cap — end it where the activity stopped, keep it, or discard it — plus an optional description prompt on stop, so one forgotten night never poisons the roll-ups. Rename or move a note (archiving included) and every record in the pomodoros lists that points to it gets the new path, TaskNotes' records too; a pomodoro running on that note follows it as well. A visual timer — a draining ring with the phase, the note, the remaining time and the cycle count, controls in place — lives in the sidebar, with a full-screen variant for focus stretches and shared screens. The pomodoro timer widget and its full-screen variant The WBS rolls tracked time up the tree (own + descendants, actuals add) with a one-click Save total tracked time. Already keep each run, music practice or board game play as a note? Turn on time from linked notes for a note type: each session note that links to an activity adds its own minutes, on its own date, to the weekly budget ring of that activity and of its parents, to its WBS total and to Recompute tracked time. No more time entry per session on the activity (my Walk activity had piled up 725 of them).

  • Quick capture. Every column has a + in its header and an Add card button under its cards: type a name and the note is created in the right folder, with the right template, and lands in that exact column. It reuses what you already configured (an Obsidian Starter Kit note type's folder, template, and name prefix/suffix are picked up automatically — except an affix the Starter Kit marks optional, which is never added unless you ask for it on the board) and applies the template with Templater when you have it, before writing the card's properties, so a template that prompts for a status can never override the column you clicked. Whatever the Base filters on (folder, tag, property) is written onto the note too, so the new card really does show up.
  • Archiving. Move finished cards into a placeholder-driven folder (Archive/{{year}} and more), manually (per card, per selection, or a whole done column from its header) or automatically when a card reaches a given status: at once, or after a grace period counted from the note's done date (a board-load sweep archives aged notes, and stamps a done date on notes that lack one). Folder notes (Foo/Foo.md) take their whole folder along. Links are preserved. Use the Obsidian Starter Kit? When it declares a note type's archive, the planner mirrors it on every archive path (by hand, from a done column, on a status or in the sweep): it adds the tag that archive names, writes the day of the move into the date property it names, then moves the note. A note archived again gets the new date, one already in its archive folder keeps its own, and the date always matches the folder's year and month.
  • Retention. Let one-off notes disappear: a done note is deleted a set number of days after its completion date, from a retention_days property on the note or a default per note type. Off by default, with a review list before anything is deleted, and notes that other notes link to are kept.
  • Automation rules. Per note type: "when a note enters (or leaves) a status, enters a done state, is archived, or a property crosses a condition (progress ≥ 100…), do things": set or remove properties (values take {{date}}-style placeholders), add or remove tags, move the note to a placeholder-driven folder. Mark a task Done and its progress jumps to 100, the due date clears, and date_completed stamps itself. From any write path (drag, menu, bulk, triage), exactly once per transition, with no cascading rules.
  • Cards show your view's properties. Each card renders the properties you've added to the Bases view (the standard Properties selection), labelled and in order. Ordinary properties and base formulas (formula.…) alike, so a computed value shows with no extra setup. Pick a cover property and each card shows an image on top (a URL, a [[wikilink]], a vault path or an image() formula; a formula can prefer a local file over a URL), cropped or whole, as a banner or in a fixed shape such as 2:3 for posters, and as a small thumbnail before the title on compact boards. Cards can also be colored by any property (a background tint or a border), apart from the column colors, and marked with a colored stripe or dot from another property. Enum values are color-coded by rank (warm = top priority or urgency, cool = low) so the board reads like a heatmap, the NN - sort prefix is hidden, and a numeric score shows as an accent badge. The card title can come from any property instead of the note name (per view, with the note name as fallback). Handy when your filenames are IDs or dated slugs. Card titles also drop the note type's name decoration by default ( (Task), AI Wiki - ), so a board of tasks reads Ship the plugin, not Ship the plugin (Task) — presentational only, per-type toggles and extra affixes in Configure board → Card titles.
  • Note types. Reusable per-type config (statuses, colors, relationships, archiving, swimlanes). Define your own by tag, folder, or regex, or mirror them from the Obsidian Starter Kit when present. With it installed the board configures itself (columns, colors, lanes, done states and date-stamping rules, and the folder + template new cards get), with nothing to set up, and writes only the properties each type declares (Check note types against the Starter Kit lists any gap). It stays entirely optional; everything works without it.
  • Productivity touches. Soft per-column WIP limits, per-column aggregates rolling any numeric property up next to the card count (Σ 13, or an average / min / max; estimates roll up as 1d 2h, unit-converted per note type), multi-select with bulk set-status / archive / open, a compact mode showing titles only, overdue and due-today emphasis, an optional due countdown badge (In 3d, 2d overdue, Today, color-coded by urgency and positionable on the title, a chip, the corner, or a footer), native hover preview, and per-view state remembered across reloads.
  • What's new after updates. After a plugin update, a one-time tab opens with the release notes you just received (including any versions you skipped) and ways to support development. It never appears on fresh installs or regular restarts.
  • Your notes stay the source of truth. Status, order, dates, relationships, and grouping ALL land in your frontmatter. Works on desktop and mobile, and respects reduced-motion settings.

Public API

Vault scripts (Templater, QuickAdd, the developer console) can read a note's tracked time with the same rule the plugin uses:

const kap = app.plugins.plugins['kanban-action-planner']
const result = await kap.api.computeTrackedTime('Activities/Run (Activity).md')
// { minutes, entryMinutes, linkedMinutes, lastSession, linkedNotes: [{ path, minutes, date }],
//   storedMinutes, decision: { stored, computed, difference } | null }

computeTrackedTime(path: string): Promise<TrackedTimeReport | null> reads, never writes. minutes (entryMinutes + linkedMinutes) is what Recompute tracked time stores in the duration property and lastSession what it stores as the last-session date (null when there is neither an entry nor a dated linked note). storedMinutes is the duration property as a number (null when empty). decision is set when the stored duration is higher than minutes and the note has entries or session minutes. The plugin never lowers that duration without asking (Keep adds the difference as a Manual adjustment time entry, Drop writes minutes), so your script shouldn't either. Linked notes count only when the note's type has Time from linked notes on. It returns null when no Markdown note exists at path. The rule is in the usage guide.

Development

See DEVELOPMENT.md. The short version: bun install, then bun run dev (watch) or bun run build (production). Quality gate: bun run tsc, bun run lint, bun test, bun run build.

License

MIT License. See LICENSE.

My other Obsidian plugins

Plugin What it does
Agentic Resource Discovery Server Local-first Agentic Resource Discovery publisher and registry that serves your AI skills and tools to agents over a local HTTP and MCP server
Book Exporter Export books (one manifest note + linked chapter notes) to EPUB and PDF via Pandoc
Bookshelf Base Display your notes as a visual bookshelf via a custom Bases view
Dataview Serializer Serialize Dataview queries to Markdown, and keep the Markdown representation up to date
Expander Replace variables across your vault using HTML comment markers. Supports static values and dynamic functions
Ghost Publish Publish your vault notes to a Ghost blog with configurable presets for tags, newsletters, and frontmatter conventions
Graph Explorer Base View A custom Bases view that renders notes as an interactive force-directed graph with explored/unexplored tracking
Hidden Folders Access Index hidden root-level folders (e.g. .claude) so they appear in the file tree, metadata cache, and Bases
Journal Bases Custom Base views for journaling and periodic reviews
Life Tracker Capture and visualize the data that matters in your life
Note Village A 2D pixel art village where your notes become villagers you can explore and chat with using AI
Obsidian Starter Kit Adds strong typing support and powerful automation support for notes
Remarkable Synchronizer Connect to the reMarkable cloud, list, download, and sync notebook pages as images
Replicate Use AI models with ease via the Replicate.com integration
REST and MCP server Exposes CLI commands as RESTful API endpoints and an MCP server for AI tool integration
Time Machine Browse, compare, and restore previous versions of your notes using built-in file-recovery snapshots
Transcriber Transcribe images to markdown using Ollama vision models
Typefully Publish social media posts with ease using the Typefully integration
Update Time Automatically update front matter to include creation and last update times

Everything I build is documented in my newsletter and on my YouTube channel.

News & support

To stay up to date about this plugin, Obsidian in general, personal knowledge management and note-taking:

  • Subscribe to my newsletter
  • Subscribe to my YouTube channel
  • Join the Knowii community and learn to organize your notes and put your knowledge to work, together with fellow knowledge workers

If this plugin is useful to you, here are the best ways to support my work ❤️:

  • Join the Knowii community
  • Become a GitHub Sponsor
  • Buy me a coffee
  • Subscribe to my YouTube channel
  • Check out my products

Found a bug or have an idea? Open an issue.

HealthExcellent
ReviewSatisfactory
About
Add a Kanban board view to any Base to plan, track, and schedule notes visually. Define a status property as columns; drag, reorder and color cards, view relationships, surface blockers, and filter live. Flip the board into a calendar and write changes back to note frontmatter.
Project managementBasesCalendar
Details
Current version
2.15.1
Last updated
Yesterday
Created
5 months ago
Updates
88 releases
Downloads
5k
Compatible with
Obsidian 1.13.0+
Platforms
Desktop, Mobile
License
MIT
Report bugRequest featureReport plugin
Sponsor
Buy Me a Coffee
GitHub Sponsors
Support
Author
Sébastien DuboisSébastien Duboisdsebastien
dsebastien.net
GitHubdsebastien
dsebastien
Xdsebastien
Blueskydsebastien.net
substack.com
  1. Community
  2. Plugins
  3. Project management
  4. Kanban Action Planner

Related plugins

TaskNotes

Note-based task management with calendar, pomodoro and time-tracking integration.

Operon

Task and project management system that unifies inline tasks and file-based tasks in the same workflows with Tables, Filters, Calendars, Kanban boards, Gantt views, Canvas, and time tracking.

Kanban Bases View

A kanban-style drag-and-drop custom view for Bases.

Abyss Tasks

A task management interface for Markdown tasks.

Bases Board

Interactive board view for bases, use as Kanban or Gallery, with grouping for rows and columns.

Copilot

Run AI agents such as Claude Code, Codex, and OpenCode inside your vault. Turn your second brain into a smart assistant that gets knowledge work done.

Tasks

Track tasks across your vault. Supports due dates, recurring tasks, done dates, sub-set of checklist items, and filtering. Maintained by Clare Macrae and Ilyas Landikov, created by Martin Schenck.

Maps

Adds a map layout to bases so you can display notes as an interactive map view.

Day Planner

Turn tasks from daily notes, the Tasks plugin, and calendars into time blocks on an editable timeline, with built-in time tracker.

Full Calendar Remastered

Complete Calendar HUB experience. Work with all your calendars in one place. Analyze your time and take action!