Kuku: open source










An open-source local-first second brain is exactly what I've been looking for. Most note-taking tools either lock your data in their cloud or require a subscription for basic features. Kuku keeping everything local and open source is the right approach for developers who care about data ownership.
Plugin/extension ecosystem would be the next big step. The core is solid, but letting the community build on top of it is what made Obsidian stick for so many people.
Obsidian is great but closed source. Notion is cloud-dependent and can feel bloated for personal use. Kuku being open source and local-first means I actually own my notes and can extend it if needed.
I've been using Inkdrop for the last 2 years. Kuku gives me a much better experience when editing markdown files. Love the AI integration and horizontal tabs at the top when working within multiple files. First experience is great so far.
Would love to get some reassurance on security and privacy as I add a lot of private information into my notes apps.
Thanks! Inkdrop is a fantastic app, so that comparison means a lot.
Regarding privacy:
Local-First: Your files stay 100% on your disk. We don't store them in any cloud.
Roadmap: We are preparing to add "Bring Your Own Key" and Other LLM support. This will soon allow you to have complete control over the AI data flow.
Verification: We plan to open-source the code. That way, you won't have to take my word for it—you'll be able to audit the codebase yourself.
@mansuiki Instead of (or additionally to) bring your own key, it would be cool if you had an option for using ACP instead so it can use claude-code/codex headlessly under the hood so we can use our plans. It also lets use the agent's tool use features (for on the fly math with python scripts or whatever else we wanna do with our notes)
@ssor
Sorry for the late reply.
This is a really good suggestion. BYOK is important, but I agree that supporting something like ACP could unlock a much better workflow — especially if users can run Claude Code, Codex, or other agents headlessly and use their existing plans.
We also don’t want Kuku to be tightly coupled to a single model or provider. The ideal direction is that Kuku manages the local-first Markdown vault and memory/context layer, while different models or agents can connect on top of it.
It’s not something we expose today, but ACP-style integration feels very aligned with where we want to go. The tool-use side is especially interesting — using scripts, external tools, or agent workflows directly with your notes would be a powerful direction to explore.

@bigmacfive how does the memory handling compare to obsidian's smart connections plugin or official copilot?
@bigmacfive How does it ensure your personal notes stay truly private and local when feeding context to external AI, without any cloud leakage?
@curiouskitty It works best today for structure-heavy edits: summaries, heading cleanup, wikilinks, splitting messy notes, and turning raw notes into reusable context.
It still struggles with personal nuance and deciding what should be remembered.
That’s why we use reviewable diffs — AI suggests, you stay in control.
@curiouskitty I also think the reviewable part is really important here.
AI is already quite good at general cleanup and writing tasks, but adapting to each person’s own writing habits, structure, and tone still needs a lot of improvement.
That’s why we’re focusing on a flow where AI suggests first, and the user reviews before applying. We’re actively improving this, so any feedback from real usage would be greatly appreciated.
Local-first + plain markdown is the only second-brain shape that survives long-term — closed note apps eventually break trust on either lock-in or pricing, and the migration cost on a 5-year vault is brutal. The portable-memory framing is what most AI-note tools miss; they treat notes as in-app data instead of files you own. I run a podcast (https://open.spotify.com/show/0m1oR8AyQv17DVpc5MmirG) on financial modelling and the listener-feedback I get most is exactly this: "where do I keep the takeaways?" — audio doesn't fold into a closed notes app cleanly, but plain markdown with backlinks does. Curious how Kuku handles AI-edits on existing files: do diffs apply per-paragraph or per-file, and is there a way to reject just one chunk of a multi-edit suggestion?
@samir_asadov
Thanks for the thoughtful question.
Right now, Kuku shows AI edits in a file-diff style, but you can still preview the actual changes in detail — whether that’s a line, a phrase, or a paragraph. The important part for us is that users can clearly review what will change in the real file before applying it.
At the moment, the flow is closer to approving the full suggestion. If something feels off, the user can ask the AI to revise it again.
That said, the idea of accepting or rejecting specific chunks inside a multi-edit suggestion is a really good one. More precise control is definitely important for AI editing, so we’ll take that as a strong improvement direction.
@mansuiki Right — "approve full suggestion, ask AI to revise if off" is the safer default, but the chunk-level accept/reject is where most of the high-trust workflows will eventually land. The parallel I see in financial modeling: when you sensitize a model and the AI proposes a sweep of cell rewrites, you want to keep 4 of the 7 changes, not all-or-nothing. Same trust loop. We've been talking about exactly this kind of granular review on the ModeLoop podcast — the bridge between AI-suggested edits and human-confirmed deltas is going to be where the next round of tooling differentiates.
congrats on the relaunch. the tauri + local-first call is the right one, electron-based note apps always feel like they're fighting the OS. the cursor-style diffs for AI edits is the part that sells it for me, "AI suggests, u review" is way better than the yolo-edit pattern most tools ship with.
curious where ur memory layer goes from here, is the plan to expose it as a context source other AI tools can read from, or keep it inside kuku?
@saad_el_gueddari
Thank you, really appreciate it.
And yes, that’s exactly the direction. We don’t want the memory layer to stay trapped inside Kuku. The goal is for Kuku to become an open, local-first context source that other AI tools can read from, while the user stays in control of what gets exposed.
Kuku starts as the place where your Markdown vault, wikilinks, graph, search, and AI edits live. But longer term, we want it to work more like a portable memory layer: local API, MCP-style bridges, self-hostable sync, and permissioned access for different agents/tools.
So the principle is: your memory lives with you, Kuku organizes it, and AI tools can use it only when you allow them to.
@saad_el_gueddari
From the implementation side, I also think the memory layer loses a lot of value if it stays locked inside Kuku. We wanted the memory format to be easy for humans to read, easy for AI to understand, and simple enough to edit from other tools.
That’s one of the main reasons we chose Markdown as the base format. Even for memory, we want to keep it as close as possible to Markdown or plain text, rather than hiding it behind a closed internal format.
The core idea is that your knowledge and context should not be trapped in a single app. Kuku should organize and connect it, but the user should ultimately own and control it as an AI context layer.
@othman_katim
Great question. We already have an E2EE sync layer in place, but I’d still consider it alpha, so I don’t want to oversell it yet.
If you’re comfortable with Git, setting up a Git repo per vault is a really good approach. Since your notes are local Markdown files, you can sync them across devices, keep history, and handle changes in a way that feels familiar to developers.
One small recommendation: add the .kuku folder to your .gitignore, since it may contain local indexing/cache data that doesn’t need to be synced.
@imad_elkhafi
Totally agree. For personal notes and a second brain, local-first feels like the right default.
On the AI side, we’re trying to avoid being tightly locked to a single model. The idea is to keep your Markdown vault and memory/context layer local, then let different models or tools connect on top of it when needed.
We’re still early and expanding the supported flow, but the principle is: your notes and memory should belong to you, and the AI model should be replaceable.
@mansuiki "The AI model should be replaceable" that's the right philosophy. Your data outlives any single model. Good foundation to build on.
The Tauri-not-Electron call is the part I appreciate most. The Obsidian comparison gets a lot of attention but the bigger story for me is the binary size and idle memory profile when you actually run a markdown editor on a laptop alongside a dozen other apps. Going to try this on my secondary work machine first.
@brainystudy
That’s exactly one of the things we cared about.
A Markdown editor is something you keep open all day, so we think it should feel lightweight and natural on the OS, not just feature-rich. In real work environments where you’re running a dozen other apps, binary size and idle memory usage matter a lot.
Would really appreciate any feedback after you try it on your secondary work machine, especially around performance and UX.


kuku
Thank you for the thoughtful review.
Data ownership, local-first, and open source were exactly the principles we cared about when building Kuku. We believe personal notes and a second brain should be something users can truly own and control over the long term.
I also strongly agree with your point about the plugin / extension ecosystem. Internally, Kuku is already built around a plugin-system approach, but it’s not at the stage where we can expose it publicly yet.
Once that becomes available, I think it could make Kuku much more flexible and community-friendly. We’ll keep stabilizing the core while continuing to treat extensibility as an important direction.