Your week and your notes, in one calm app for Mac and Windows.
A week planner with times, repeating plans and your Outlook, Teams and Google calendars, task boards for your projects, drawings, and an Obsidian‑like Markdown notes vault with tabs, links, backlinks, Dataview queries, diagrams and a graph. Speak instead of typing, or jot a line from any app with a quick note — local and private.
Made by Calexis Labs.
- What Mufka does
- Install it on a Mac
- Install it on Windows
- Your notes and your data
- Use your notes from AI clients
- Keyboard shortcuts
- For the developer
- License
Mufka has four modes, switched at the top left (Notes | Planner | Tasks | Draw, or ⌃Tab).
- Monday to Sunday in columns: to-dos on top, an hour grid below, a red line for "now".
- New plan asks for everything at once: title, day, start and end time, and Repeat — every day, weekdays, every week, chosen days, or monthly.
- Repeating plans look different (teal, dashed edge, ↻ and their rule), so "this happens every Tuesday" is visible at a glance.
- Missed plans — not done after their time — get a coral edge and a one-click → Today. Nothing moves on its own.
- Your calendars in the week: connect Microsoft (Outlook, Teams) and Google Calendar in Settings (⌘,) and your meetings appear next to your plans, in each calendar's colour; all-day events sit on top. Click one for when, where and who, and Join meeting for Teams, Meet or Zoom links. Read-only: Mufka never changes your calendars. Choose which calendars to show; ↻ refreshes.
- Move plans by dragging (to another day or time; drag the bottom edge to change the end), with the ⋯ menu, or with the keyboard (⌥←/→ a day, ⌥↑/↓ 15 minutes). Every change can be undone with ⌘Z.
- Tasks with a due date from your boards sit on top of their day; click one to open it on its board, or drag it to an hour to plan it then.
- In the menu bar (macOS) the plan or meeting going on now or the next one, with the time left ("Tennis · in 25m"); its menu lists today's plans and calendar events, and the board tasks due today or late (click one to open it). On Windows the tray icon has the same menu. Turn it off in Settings → Appearance.
Today's date, what you planned for it and today's meetings in time order (tick plans off here, Join a meeting), the board tasks due today, late or in progress, and the day's note. Nothing planned yet? Home offers to open the Planner.
- Plain Markdown files in folders — by default in
~/Documents/Mufka, where Finder and iCloud see them, or open any folder, such as an existing Obsidian vault (nothing is copied). - Your sidebar, your way: every folder and note has an icon; give one a
colour or another icon (or any emoji) from its ⋯ menu. A folder's
colour is its guide line's, and the selected row takes it. Drag items
to put them in your own order, or into another folder. Icons, colours and
order are kept in the vault's
.mufka/tree.json, so they travel with your notes. - Write in place: notes always look formatted; click a paragraph to edit it.
Tables, task lists, callouts, footnotes, properties,
==highlights==. [[Links]]with autocomplete, backlinks under every note, page preview on hover,![[embeds]]of other notes and images.- Details panel: outline, outgoing links, unlinked mentions (one click turns a mention into a link) and all tags.
- Dictate with Handy (free, offline): speak and the text goes where the caret is. Use Handy's own shortcut (⌥Space by default) anywhere, or in a note the microphone in its top bar (⇧⌘D). Settings → Voice shows whether Handy and VoiceStudio are there.
- New note from audio (File menu or ⌘P, with Handy or
VoiceStudio): record, or pick an audio file (m4a,
mp3, wav, webm, ogg…); Handy or VoiceStudio writes it down on your computer
and it opens as a note, the recording kept with it (it plays in the note, as
![[memo.m4a]]does anywhere). VoiceStudio is found while it runs and writes it down with the speech-to-text model you chose in it; nothing to set up. - Quick note (⌃⌥N) from any app, without leaving it: a small box; what you type goes to today's daily note with the time, or start with a note's name ("Groceries: oat milk") to add it to that note. Its microphone dictates with Handy: it shows a running Stop while it listens, and the text waits in the box for Enter. Also in the File menu and the menu bar.
- Right-click a note, folder, board or drawing in the sidebar (or use its
⋯): duplicate, move to a folder, copy its path (in the vault or on the
computer) or a
[[link]], reveal it in Finder, rename, delete. Folders also search inside themselves. - Templates: start a note from one of twelve — daily note, meeting notes,
project, project board, book notes, reading shelf, habit tracker, budget, travel plan,
weekly to-do (with a review of the week), job search and job application — or from your own
Templatesfolder (Obsidian-compatible). Copy the built-in ones there to make them yours. - Budget pages: add income and expenses with a small form and a card works out what is left, with a ring of where the money went. The entries are plain Markdown tables, so the file reads the same in Obsidian.
- Habit tracker: a week of habits as a grid; tick a day with one click, today is marked, and a card shows how the week is going against each habit's goal. ‹ › moves between weeks and starts the next one.
- Today gathers the day: its plans and calendar events, the day's part of this week's to-do and habit tracker notes (tick and add there), and the daily note with a mood to pick; a new daily note can start from the Daily note template.
- Projects: a project note shows its status (Planning, Active, Done or on hold, one click to change), how much of its checklist is done and when it is due; a project board shows them all by status, with what is late.
- Books: a book note shows its cover beside the title, the shelf it is on (To read, Reading, Finished), its author and dates, and stars to rate it. The Reading shelf is a bookcase: a shelf per status with the books standing by their covers; drag one to another shelf. A cover is any image you add (kept in the vault, never fetched from the internet).
- Trips: a trip note counts down to it ("12 days to go", "Day 3 of 7") and shows how much of the packing list is packed and how many bookings are done.
- Meetings: a meeting note (and one from Wispr Flow) shows when and who, and how many action items are done; each open one can go on a task board, and one that names a day ("by Friday", "tomorrow at 15:00", "25 Nov") can go in the Planner on that day with one click.
- Weekly to-do: the week as seven columns of tasks; tick, add, change and drag them between days, move what is left to the next day, and start next week with the open ones. In the file they are a heading per day.
- Job search: each application is a note; a board shows them all by stage (drag a card to move it on) with how many heard back, and an application note has a strip to move its stage with one click.
- Icon and cover for any note: hover the top of a page to add them, click
to change (an emoji; a colour or an image). Kept as
icon:andcover:in its properties. - Dataview, like Obsidian's plugin:
```dataviewqueries (TABLE,LIST,TASK,CALENDARwithFROM,WHERE,SORT,GROUP BY,FLATTEN,LIMITand its functions) over frontmatter,key:: valuefields, tasks andfile.*; inline`= this.field`; ticking a task in a result ticks it in its note.```dataviewjsscripts run too — in a sandbox with no files and no network. - Mermaid diagrams (
```mermaid) are drawn in the app's colours, and HTML in notes works for formatting (<kbd>,<details>,<br>,<mark>, tables…); scripts, frames and styles never run. - Bookmarks, drag-and-drop images and files, export to PDF (with Dataview results, diagrams and drawings) or Markdown, sorting by name, last edit or your own order.
- Meeting notes from Wispr Flow: connect your Wispr account in Settings (⌘,) and every meeting its Notetaker records — Zoom, Google Meet, Teams, Slack huddles or in person — arrives in a Meetings folder as a note: summary, tasks, your notes and the transcript. Read-only; it checks every 15 minutes. Wispr Flow's dictation also types straight into any note.
- Columns To do · In progress · Test · Done on every new board. They keep their names; remove one you do not need and Add column puts it back. Columns of your own go before Done and can be renamed (double-click). Drag a heading or use its ⋯ to reorder.
- Done is where tasks are finished: they get a green tick and are struck through (and checked in the file).
- Tasks have a type (Feature, Bug, Chore), a priority
(P1–P3), a due date (red once it has passed), tags, a link (a GitHub
issue or pull request reads as #12) and a description in Markdown whose
- [ ]sub-tasks count up on the task (2/5). - New task at the top, or Add a task under a column, asks for all of that in one dialog. Click a task to edit it in a panel.
- Move by dragging, or on a focused task ⌥←/⌥→ (column) and ⌥↑/⌥↓; Delete removes it, ⌘Z undoes. Filter by text, type, priority or tag.
- Archive Done's tasks from its ⋯ menu; "N archived" at the top lists them, each with Restore.
- Each board is a Markdown note in the
Tasksfolder, in the format of Obsidian's Kanban plugin (the archive too): open it in Obsidian and it is the same board; change it there and Mufka follows.
- Excalidraw in the app: shapes, arrows, pen, text, images and its library, in the app's light or dark theme.
- Each drawing is a note in the
Excalidrawfolder, in the format of Obsidian's Excalidraw plugin, so it opens there too. Changes save as you draw. Images in a drawing are files of their own in the attachments folder (listed under "Embedded Files", as the plugin keeps them). - In notes:
![[Sketch.excalidraw]]shows the drawing; click it to open it in Draw. - Nothing is fetched from the internet: the fonts come with the app.
- Graph shows how notes connect; hover to highlight, click to open, or show just one note's neighbourhood.
- Search at the top of the sidebar (⇧⌘F) finds notes and plans (and
creates a note when nothing matches). It understands
"exact phrase",-word,a OR b,file:,path:,#tag,line:(…),section:(…),task:/task-todo:/task-done:,[property:value]and/regex/, and marks the hits. ⌘O jumps to any note, ⌘P runs any command, ⌘/ lists every shortcut. - Code blocks are coloured by their language (
js,python, ```bash and about 40 more), on screen and in PDF exports. - Pasting from the web, Google Docs or Mail gives Markdown: headings, bold, links, lists, tasks, tables and code. ⇧⌘V pastes plain text.
- Tabs and two panes. A note opened while another is open (from the sidebar, ⌘O or a link) opens beside it in a tab of its own, or goes to the tab already showing it; from Home or the Planner it opens in place. + in the tab strip (⌥⌘T) starts a new note in a new tab. ⌘-click opens anything in a new tab, ⌘W closes one, ⇧⌘[ / ⇧⌘] switch. ⌥⌘-click puts a note in a pane on the right: its links, tasks and queries work there, and clicking its text swaps the panes so you can edit it.
- Properties at the top of a note are edited in place: text, tags and lists
as chips, numbers, dates and checkboxes (⌘; adds one, "Edit YAML" shows
the source). Aliases work:
[[another name]]links to the note, and ⌘O and[[find it by that name too. - Type
/at the start of a line for the insert menu: headings, lists, a task, quote, callout, code block, table, divider, a link or embed, a diagram, a query, today's date, a file or a template. Keep typing to filter. - Light or dark. Mufka follows your system's appearance, or stays light or dark (Settings → Appearance). Diagrams, code, drawings and the graph follow too.
- Find in the note with ⌘F, and replace with ⌥⌘F; replacing all is one undo step.
- Version history keeps a version of each note every few minutes while you edit, for seven days, outside your notes folder. Bring one back from the note's ⋯ menu; Recover deleted notes (⌘P) brings back a deleted note.
Needs: macOS 12 Monterey or later, Apple silicon or Intel.
- Download
Mufka-<version>-universal.dmgfrom the Releases page (or build it yourself, see For the developer). - Open it and drag Mufka onto Applications.
- Open Mufka from Applications. The first time, macOS asks whether to open an app downloaded from the internet — click Open. Mufka is signed by Calexis Labs and notarized by Apple.
- When Mufka asks to send notifications, click Allow — that is how plan reminders reach you. (If you skip it, reminders appear inside the window.)
That's it: Mufka opens on Home. From 1.12 on, Mufka updates itself: it looks for a new version on the Releases page, downloads it in the background, and installs it when you quit or click Restart (Settings → Updates turns the automatic check off). Older versions are updated once by hand — replace the app in Applications; your notes and plans stay.
Updating from 1.5.1 or older? Those were not notarized. After the first signed update macOS may ask once more for notifications and for Mufka's keychain item ("Mufka Safe Storage"): allow both (Always Allow for the keychain) so your calendar and Wispr sign-ins keep working.
Drag Mufka from Applications to the Trash. Your notes stay in
~/Documents/Mufka (or the notes folder you chose) and your plans in
~/Library/Application Support/Mufka until you delete them.
Needs: Windows 10 or 11, 64-bit.
- Download
Mufka-<version>-Setup.exefrom the Releases page. - Edge may say the file "isn't commonly downloaded": open the download's ⋯ menu → Keep. Mufka is not signed with a paid Microsoft certificate yet, so when you run it Windows SmartScreen says "Windows protected your PC": click More info → Run anyway. Then install "only for me" and finish.
- Open Mufka from the Start menu or the desktop shortcut.
Everything works as on a Mac, with Ctrl where the Mac uses ⌘ (Ctrl+O,
Ctrl+P, Ctrl+Shift+P…); the app shows shortcuts the Windows way. Notes are in
Documents\Mufka, plans in %APPDATA%\Mufka. Updates install themselves from
1.12 on, as on a Mac (older versions: run the new installer; your notes and
plans stay). Uninstall from Settings → Apps.
Everything stays on your computer; there is no account and no server. Mufka
asks GitHub, where it is released, whether there is a new version (Settings →
Updates turns that off). The other exceptions
are the connections you turn on yourself in Settings: your Microsoft
and Google calendars (Mufka reads your events; it asks only for calendar
read access) and Wispr Flow (Mufka reads your meetings). Dictation and
notes from audio stay on your computer: Handy and VoiceStudio run there
(VoiceStudio is reached only at 127.0.0.1). Mufka never sends
your notes or plans anywhere; with AI clients
turned on, a client you run reads notes and sends what it reads to its own AI
service. Sign-ins are kept encrypted (in the macOS Keychain, or by Windows for your user account);
Disconnect forgets them. Note scripts (```dataviewjs) and Mermaid
diagrams run in a sandbox that cannot read your files or reach the internet,
and Draw's fonts come with the app. Details: the privacy policy.
| What | Where |
|---|---|
| Notes | ~/Documents/Mufka — or any folder you open with Notes folder at the bottom of the sidebar (for example your Obsidian vault). Plain .md files. |
| Task boards | Notes in the Tasks folder of your notes folder, in the format of Obsidian's Kanban plugin. |
| Drawings | Notes in the Excalidraw folder (*.excalidraw.md), in the format of Obsidian's Excalidraw plugin. |
| Plans | ~/Library/Application Support/Mufka/planlar.json (Windows: %APPDATA%\Mufka\planlar.json) |
| Backups | File → Export Plans… writes a JSON copy; notes are ordinary files, so any backup tool (Time Machine, iCloud Drive, git) works. |
Notes kept by Mufka before 1.4 (in ~/Library/Application Support/Mufka/Notes) move to ~/Documents/Mufka by themselves the first time 1.4 starts; a folder you chose yourself stays where it is.
Claude Desktop, Claude Code, Cursor and other MCP clients can search and read your notes through Mufka's MCP server. It runs on your computer, started by the client; nothing is set up anywhere else.
- In Settings → AI clients (MCP), turn on Let AI clients search and read notes. It is off until you do.
- Click Copy config for Claude Desktop / Cursor and paste it into the client's MCP config (Claude Desktop: Settings → Developer → Edit Config; Cursor: Settings → MCP), or Copy Claude Code command and run it in a terminal. Restart the client.
- Ask it about your notes: "What did I write about the deploy last week?", "Which job applications are waiting for an answer?"
| Tool | What it does |
|---|---|
search_notes |
Mufka's search, with its operators ("phrase", -word, OR, /regex/, #tag, path:, task-todo:, [property:value]…) |
read_note |
A note's text, properties, tags and the notes linking to it |
list_notes |
Notes in a folder or with a tag, newest first or by name |
list_job_applications |
Job applications with company, role, status and date |
list_projects |
Projects with status, progress and due date |
create_note, append_to_note |
Only when you also allow writing: make a new note, or add to the end of one. Nothing is ever changed or deleted. |
In Claude Desktop and on claude.ai, projects, job applications and notes also
appear as Mufka draws them (an MCP App): boards with progress and stages, and
the formatted note; a card opens its note. With Let them tick tasks on (a
separate switch, off by default) you can tick a task right there; that changes
only the [ ] / [x] of that one task, and only if the line is still what
was shown.
The server reads only the notes folder: never anything outside it (symlinks included), and never your plans, settings or sign-ins. It changes a note only to add to it (with writing allowed) or to tick a task (with ticking allowed). The switches apply at once; turning access off makes every tool say so. What a client reads goes to the AI service it uses.
On Windows, Ctrl takes the place of ⌘ and Alt of ⌥.
| Shortcut | Does |
|---|---|
| ⌘T | Home (today) |
| ⌘1 · ⌘3 · ⌘4 · ⌃Tab | Planner · Tasks · Draw · switch Notes / Planner / Tasks / Draw |
| ⇧⌘P | New plan |
| ⌥⌘← / ⌥⌘→ | Previous / next week |
| ⌘N | New note |
| ⌃⌥N | Quick note, from any app |
| ⇧⌘D | Dictate into the note with Handy (start / stop) |
| ⌘O · ⌘P | Open a note · command palette |
| ⌘-click · ⌘↵ in ⌘O | Open in a new tab |
| ⌥⌘-click · ⌥⌘↵ in ⌘O | Open in the right pane |
| ⌥⌘T · ⌘W | New note in a new tab · close tab (⇧⌘W closes the window) |
| ⇧⌘[ · ⇧⌘] | Previous · next tab |
| ⌘F | Find in the open note (⌥⌘F: find and replace) |
| ⇧⌘F | Search all notes and plans |
| ⌘; | Add a property to the note |
/ |
Insert menu (at the start of a line) |
| ⇧⌘V | Paste as plain text |
| ⌘G · ⇧⌘G | Graph · local graph |
| ⌘E | Edit a note's raw Markdown |
| ⌘, | Settings (calendars, Wispr Flow, voice, AI clients), also the gear next to the notes folder |
| ⇧⌘T | Insert a template |
| ⌘[ · ⌘] | Back · forward (within a tab) |
| ⌘\ · ⇧⌘\ | Sidebar · Details panel |
| ⌘Z · ⇧⌘Z | Undo · redo |
| ⌘/ | All shortcuts |
Electron + plain JavaScript (no UI framework; React only inside Draw, for
Excalidraw, loaded when Draw opens), built with
electron-vite. All pure logic lives in lib/*.mjs
and is shared verbatim by the app and the tests: Dataview in lib/dataview/,
HTML in notes in lib/html.mjs, drawings in lib/drawing.mjs. Note scripts and
Mermaid run in src/sandbox.html, a hidden sandboxed window (main.js).
The vault's notes are kept by the main process in lib/vault-cache.mjs (saved
under <userData>/index/, outside the vault): only changed files are read again,
and the window receives the changes, not the whole vault. Note version history
lives under <userData>/history/. The MCP server is mcp/ (built to
out/main/mcp-server.js, started by the client with the app's own binary and
ELECTRON_RUN_AS_NODE=1), on the same lib/ modules plus lib/vaultfs.mjs,
which reads and writes the vault without Electron. Its MCP Apps view is
mcp/ui/, built into one HTML file (out/mcp-ui/view.html) from Mufka's own
renderer, boards and styles. The quick note box (⌃⌥N) is src/quick.js, a
small window loaded from the same index.html (#quick, see src/entry.js).
Voice talks to Handy through its command line and to VoiceStudio through its
local HTTP server (main.js); for Handy a recording is decoded and written as a 16 kHz WAV (lib/audio.mjs).
npm install # dependencies, then downloads Electron (pnpm works too)
npm run dev # develop with hot reload
npm start # build, then run the built app
npm test # unit tests, the MCP eval, then build + the real end-to-end test
npm run eval:mcp # questions to the MCP server about a sample vault (Turkish included)
npm run test:view # the MCP Apps view in a stand-in host: boards, notes, ticking
npm run smoke:packaged # packs the app, starts the MCP server from app.asar: run before a release
npm run dist # build the signed universal .dmg into dist/
npm run dist:public # the same, ad-hoc signed: for sharing / Releases
npm run dist:win # the Windows installer (.exe), on Windows or a Mac
npm run sign:dev # sign the dev Electron so notifications work in npm startEvery push and pull request runs the unit tests and the end-to-end test on macOS and on Windows (GitHub Actions); the Windows run also uploads screenshots and an installer.
npm run distThis writes dist/Mufka-<version>-universal.dmg (one app for Apple silicon and
Intel). The app is signed with the first Developer ID or Apple Development
identity in your keychain (MUFKA_SIGN_IDENTITY overrides it; without one it
is ad-hoc signed), which is what lets macOS show notifications. It is not
notarized, so whoever opens it needs System Settings → Privacy & Security →
Open Anyway once.
npm run dist:public is the same, signed ad-hoc: no certificate (and the
name and email in it) ends up inside the app.
npm run dist:release builds the copy on Releases: signed with Calexis
Labs' Developer ID, hardened runtime, and notarized by Apple
(electron-builder.release.cjs). It needs that identity in the keychain and an
App Store Connect API key in APPLE_API_KEY (path to the .p8),
APPLE_API_KEY_ID and APPLE_API_ISSUER.
Google Calendar needs an OAuth client of type Desktop app (Google Cloud
Console → Google Auth Platform → Clients). Its id and secret are not in this
repository; put them in a git-ignored .env.local before building:
MAIN_VITE_GOOGLE_CLIENT_ID=….apps.googleusercontent.com
MAIN_VITE_GOOGLE_CLIENT_SECRET=…Without it, Settings shows Google as "not set up"; everything else works.
Microsoft uses Mufka's public app registration (lib/calendar.mjs).
Bump version in package.json before building a new copy, so people can
tell versions apart.
Updates come from the GitHub release with the highest version, read by
electron-updater (its address is build.publish in package.json). A
release must carry, next to the installers, latest-mac.yml with the Mac
.zip (and its .blockmap) and latest.yml with the Windows .exe (and its
.blockmap), as the build writes them into dist/; builds never publish by
themselves (--publish never). npm run smoke:update packs this Mufka and a
99.0.0 of it, serves the update locally and checks the first one finds,
downloads and readies it.
UI behaviour is proven by a real end-to-end test (test/e2e.js): it boots the
built app with a throwaway data folder, drives it only through real input
events (clicks, keys, drags, OS file drops) and checks the files on disk. Pure
logic has node:test suites next to each lib/ module. The MCP server is
tested in-process (test/mcp-server.test.mjs) and by an eval of fixed
questions against test/fixtures/mcp-vault (scripts/mcp-eval.mjs).
The name Mufka and the app id are fixed: changing productName would
move the data folder.
Issues and pull requests are welcome. Run npm test (unit tests and the
end-to-end test) before opening a pull request.
MIT © 2026 Calexis Labs.
Mufka includes open-source components under their own licenses (Electron,
mdast/micromark, Lucide icons, highlight.js, turndown and others); see
THIRD_PARTY_NOTICES.md.















