Kuku Editor: Open-Source Local-First Markdown Note Tool, an Obsidian + Cursor Alternative

Overview

Kuku is a brand-new open-source Markdown editor positioned as "Obsidian + Cursor, but without Electron." Built with the Tauri framework, it delivers a truly native macOS experience while integrating AI Agent capabilities, ushering note editing into the era of intelligence.

Local-First Architecture: No Cloud, No Lock-In

Kuku's design philosophy is crystal clear: local-first, offline-first. All notes are stored as plain Markdown files (.md) on your local machine, with no cloud dependencies and no data lock-in. Users can open their notes at any time with any text editor — data ownership stays entirely in their hands.

"Local-First" is a software design philosophy systematically introduced in a 2019 paper of the same name by the Ink & Switch research team. Its core principle is that the primary copy of data resides on the user's device, not on cloud servers. The typical technical backbone for this philosophy is CRDT (Conflict-free Replicated Data Type) — a data structure that allows multiple nodes to independently modify data and automatically merge changes afterward without conflicts. CRDTs are widely adopted by Notion competitor Linear, the collaborative tool Figma, and others to solve consistency challenges in multi-device, multi-user concurrent editing. However, Kuku takes an even more radically simplified path: using plain Markdown files as the storage layer, treating the file system as the database, completely bypassing complex synchronization protocols. This stands in stark contrast to cloud-based note tools like Notion and Roam Research — where data lives on the provider's servers, and users face the risk of permanent data loss if the service shuts down, accounts get banned, or the company goes bankrupt. The shutdown of several well-known cloud-based note apps in 2023 sparked widespread discussion about "data sovereignty" among knowledge workers and renewed market interest in local-first architectures.

For users who value privacy and data sovereignty, this is an extremely attractive feature. Compared to note apps that store data in proprietary formats or in the cloud, Kuku offers maximum transparency and portability.

Tauri Replaces Electron: A Performance Quantum Leap

Kuku's most notable technical choice is using Tauri rather than Electron as its desktop application framework. Electron apps (such as Obsidian and VS Code), while powerful, embed a complete Chromium browser and often consume significant memory and disk space.

Tauri is a desktop application development framework written in Rust, which officially released version 1.0 in 2021 and is maintained by the open-source community organization Tauri Programme. The core difference from Electron lies in the rendering layer: Electron bundles the complete Chromium browser engine (~150MB) into every application, with each Electron app instance launching an independent browser process. Tauri, by contrast, calls the operating system's built-in WebView component — WKWebView (based on the WebKit engine, maintained by Apple) on macOS, WebView2 (based on Chromium, maintained by Microsoft) on Windows, and WebKitGTK on Linux. Since the WebView component is provided and maintained by the operating system, multiple Tauri apps can share the same rendering engine, completely eliminating redundant bundling. This design results in Tauri app installers typically being only 3-10MB, while equivalent Electron apps often exceed 100MB. Additionally, Tauri's backend logic is written in Rust, which is renowned for "memory safety without garbage collection" — it eliminates memory leaks and data races at compile time through its Ownership and Borrow Checker mechanisms. This is particularly important for note-taking tools that need to run in the background for extended periods, avoiding the common Electron problem of memory usage steadily climbing over time.

Tauri's architecture delivers three tangible advantages:

• Smaller application size (typically one-tenth of an equivalent Electron app)
• Faster startup times
• Lower runtime memory consumption

For a note-taking tool that needs to stay open for long periods, the experience improvements from this lightweight approach are continuous — faster response times and lower system resource consumption. It's worth noting that Tauri's cross-platform consistency is slightly inferior to Electron's (WebView implementations differ subtly across operating systems), which is one reason Kuku currently only supports macOS — on a single platform, WKWebView behavior is highly predictable, allowing Tauri's performance advantages to be fully realized.

Knowledge Graph Capabilities: Building Your Personal Knowledge Network

The field of Personal Knowledge Management (PKM) has undergone a paradigm shift over the past decade, moving from linear notes to networked knowledge graphs. The intellectual roots of this shift trace back to German sociologist Niklas Luhmann's Zettelkasten (slip-box) methodology developed in the 20th century — he used approximately 90,000 cross-referenced index cards to produce over 70 books and 400+ papers across 40 years. The core insight of Zettelkasten is that the value of knowledge lies not in the quality of individual notes, but in the density and quality of connections between them — isolated knowledge fragments are far less valuable than knowledge nodes forming a network. The [[double bracket]] Wikilinks syntax originated from Wikipedia's internal linking mechanism and was introduced to personal note-taking tools by Roam Research in 2020, quickly gaining popularity among knowledge workers. Obsidian subsequently combined it with the local file system, establishing what is now the de facto standard interaction paradigm for PKM tools. The unique value of Backlinks lies in revealing "implicit associations" — when you write down a new concept, the system automatically tells you which historical notes have mentioned it. This passive discovery mechanism often triggers unexpected knowledge connections, providing cognitive gains that linear note-taking tools simply cannot offer.

Kuku supports core features familiar to Obsidian users:

• Wikilinks: Quickly link notes using [[]] syntax
• Backlinks: Automatically track which notes reference the current note
• Graph View: Visualize the network of relationships between notes, helping users discover knowledge gaps and unexpected connections

These features form the infrastructure of Personal Knowledge Management (PKM), helping users build structured knowledge networks rather than isolated document collections. Graph views are typically implemented using force-directed graph algorithms, which simulate attractive and repulsive forces between nodes to automatically arrange the layout, causing closely related notes to naturally cluster together and intuitively revealing the topological structure of the knowledge base.

AI Agent Editing: More Than Just a Chatbot

Kuku's AI capabilities are the key differentiator from traditional note-taking tools. The fundamental distinction between an AI Agent and an ordinary AI chat assistant lies in "Tool Use" (also known as Function Calling) capability. Traditional AI assistants (like early ChatGPT web versions) can only generate text responses, requiring users to manually copy content to the target location. AI Agents, through the Function Calling interface officially introduced by OpenAI in 2023, allow large language models to proactively invoke predefined external functions during reasoning — including reading/writing the file system, executing search queries, calling APIs, and more. The theoretical foundation for this capability is the ReAct (Reasoning + Acting) paradigm: instead of generating a complete answer in one shot, the model alternates between "thinking" (analyzing current state, planning next steps) and "acting" (calling tools, obtaining results), forming multi-round reasoning-execution loops until the task is complete. This architecture enables AI to handle complex tasks requiring multiple steps and cross-resource operations, rather than being limited to single-turn Q&A. The Cursor editor brought this pattern to code editing and achieved enormous commercial success; Kuku migrates the same interaction paradigm to the knowledge management domain, representing an important exploration of agentic workflows in productivity tools.

Unlike most apps that only offer conversational AI, Kuku's AI Agent has actual operational capabilities:

• Intelligent Search: Retrieve relevant content across your note library
• Direct Editing: Modify note content without manual copy-pasting
• Auto-Linking: Discover and establish relationships between notes

More importantly, every modification made by the AI is presented in a Cursor-style diff format. The Diff (difference comparison) view originated from the diff command in the Unix toolchain (1974) and was later popularized by the Git version control system, becoming the standard interface for developers to review code changes. Cursor's key innovation was transforming the Diff view from a "history retrospection tool" into an "AI collaboration interface": the AI proposes modifications, and users review them block by block through green highlights (added lines) and red highlights (deleted lines), with options to accept all, reject all, or decide block by block. This design embodies the "Human-in-the-Loop" (HITL) AI collaboration philosophy — seeking balance between automation efficiency and human control. In the note-taking context, HITL design is particularly critical: personal knowledge bases often contain highly personalized expression habits, private thoughts, and unverified ideas. Users need to maintain complete awareness of and final decision-making authority over every AI modification, rather than entrusting the evolution of their knowledge base entirely to automated systems.

Feature Comparison: Kuku vs. Obsidian vs. Cursor

Feature	Obsidian	Cursor	Kuku
Markdown Editing	✅	✅	✅
Knowledge Graph	✅	❌	✅
AI Agent Editing	❌	✅	✅
Diff Review	❌	✅	✅
Native Performance	❌(Electron)	❌(Electron)	✅(Tauri)
Open Source	❌	❌	✅

Kuku's positioning can be summarized in one sentence: Obsidian's knowledge management capabilities + Cursor's AI editing experience − Electron's performance baggage.

The open-source nature is another major advantage. Open source means not only that the code is transparent and auditable (especially important for privacy-conscious users who can verify that data truly isn't uploaded to the cloud), but also that the community can participate in development, contribute plugins, and fork the project to continue it if the original author stops maintaining it — a long-term sustainability guarantee that closed-source tools like Obsidian simply cannot provide.

Who Is It For?

• Heavy Obsidian users: Knowledge workers seeking better performance and AI capabilities
• Developers and technical writers: Those accustomed to Markdown workflows who also need AI assistance
• Privacy-conscious users: Those unwilling to upload note data to the cloud
• macOS users