MarkFlowy: A Tauri Markdown Editor With a Rust Core and Built-in AI
A high-performance, cross-platform editor that supports WYSIWYG Markdown and general text editing.
At a glance
- What is it?
- MarkFlowy is a cross-platform Markdown and text editor built on Tauri and ProseMirror, with AI features that call DeepSeek and ChatGPT. It is fast on large files and small on disk, but it is still labelled beta and ships under AGPL-3.0.
- Who is it for?
- Adopt MarkFlowy if you want a small Tauri editor with WYSIWYG Markdown, a file tree and optional DeepSeek or ChatGPT integration, and you accept beta software under AGPL-3.0. Skip it if you need a signed macOS build without manual steps, a non-copyleft licence, or a formal stability guarantee.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What MarkFlowy Is For
MarkFlowy targets people who write in Markdown every day and want the file tree, the preview and the source side by side in one window. It is a desktop application for Windows, macOS and Linux, built with Tauri, so the shell is Rust and the interface is a web stack. The README describes it as a "Modern and intelligent Markdown editor" and lists a file tree with drag-and-drop movement and global search as a first-class feature, which puts it in the same working style as a notes workspace rather than a single-file viewer.
The second audience is developers who edit more than Markdown. The feature list states that MarkFlowy also edits JSON and TXT and "other file types", so it can serve as a lightweight scratch editor next to a terminal. The third audience is people who want model assistance inside the writing surface. The README says the built-in AI currently supports Copilot, one-click export of dialogues, translation of articles to any language, and article summaries, and that it works with models such as DeepSeek and ChatGPT.
The project describes itself as beta in the README heading, and the current version line is v0.101.0 from 2026-09-12. That combination matters: the feature set is broad, but the author states in the Contribute section that "there may be some bad experiences or bugs". Treat it as software you evaluate on your own files before you make it a daily driver.
How the Tauri, Rust and ProseMirror Layers Fit Together
The repository is a Yarn workspace monorepo. The root package.json declares workspaces for packages/*, apps/* and docs, and the Cargo.toml at the top level defines a Rust workspace whose members are apps/desktop/src-tauri, crates/* and tools/*. So the desktop application is one Tauri app that depends on shared Rust crates in the same repository, and the front end lives in the JavaScript workspace. Build orchestration is Turbo: the scripts include dev, build, build:web and build:desktop, and build:desktop runs a Turbo build filtered to exclude the web target and then calls the Tauri build through the desktop workspace.
On the editing side, the README states that MarkFlowy uses ProseMirror as its core editor and offers multiple editing modes, naming source code and WYSIWYG. ProseMirror is a document model with a schema, so the WYSIWYG mode is not a rendered preview of the raw text; the document is transformed into a structured tree and edited there. That is the design decision behind the mode switch, and it is also why extensibility is claimed: ProseMirror plugins are the extension point.
The performance claim follows from the same rebuild. The README says the rebuilt editor "dramatically improves opening speed for large documents" and gives one figure: a 2 MB Markdown file opened in around 1 second in testing. That is a single stated measurement from the project, not a published benchmark methodology, so treat it as an indication rather than a guarantee on your hardware. The binary size claim is separate: the README says MarkFlowy is based on Tauri and has a size of less than 20MB, which is the typical consequence of using the system webview instead of bundling a browser engine.
Installing MarkFlowy on Windows, macOS and Linux
There is no package manager entry for the desktop app in the README; the primary route is the latest release page on GitHub, which hosts per-platform artifacts. The Windows section lists x64 builds by filename pattern, including an installer, an offline installer that bundles the WebView2 runtime, and a portable zip that needs no installation. Pick the offline installer if the target machine cannot fetch WebView2 during setup, and the portable zip if you want to run it without touching the system.
macOS gets two disk images, one for Apple silicon and one for Intel. The README carries a note that the macOS aarch64 build cannot be opened directly because of Apple's restrictions on software without developer certification, and it gives the workaround: open a terminal, go to the Applications directory, run the command below, then open the app again. It also says to make sure you download from GitHub releases.
xattr -cr MarkFlowy.appLinux support is x86_64 only at the moment. Two installation paths are documented. The first is Flatpak, from a remote the README calls FlatPark. Running these two commands adds the remote if it is missing and installs the application under the identifier io.github.drl990114.MarkFlowy.
flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
flatpak install flatpark io.github.drl990114.MarkFlowyThe second path is a shell script that detects your distribution and installs the .deb or .rpm, falling back to the AppImage when the distribution is not recognized. The README shows downloading it with curl and running it with sh, and notes that wget works if curl is unavailable. It also documents two flags: --appimage forces the AppImage, and --uninstall removes MarkFlowy.
curl -fsSL https://raw.githubusercontent.com/drl990114/MarkFlowy/main/scripts/install-linux.sh -o install-linux.sh
sh install-linux.shAfter that, the first real use is opening a folder rather than a file: the file tree with drag-and-drop movement and global search is the part that distinguishes MarkFlowy from a plain text editor, so point it at a directory of Markdown notes and switch between the WYSIWYG and source modes on the same document. The README does not document a command-line flag for opening a path directly, and it does not describe a first-run wizard, so the in-app folder picker is the entry point to expect.
Where MarkFlowy Gets in the Way
The macOS signing situation is the clearest limitation. The README states plainly that the aarch64 build cannot be downloaded and used directly, and the documented fix is a terminal command that strips extended attributes. That is acceptable for an individual who reads the instructions, and awkward for anyone distributing the app to colleagues or installing it on a managed machine where users cannot run xattr. Windows and Linux do not have an equivalent documented step.
Beta status is the second constraint. The README heading marks the project as beta, and the Contribute section says the project "is still in its infancy" and apologizes in advance for bad experiences or bugs. A version number at 0.101.0 with three releases inside a week (v0.100.0, v0.100.1 and v0.101.0) suggests rapid iteration, which cuts both ways: fixes arrive quickly, and so do regressions. If your workflow depends on a specific behaviour, pin a release rather than tracking latest.
The AI features are the third place to be careful. The README lists Copilot, dialogue export, translation and summaries, and names DeepSeek and ChatGPT as supported models, but it does not describe how credentials are stored, whether requests go through a proxy, or what happens to document text that is sent to a provider. The README is silent on those points, and it is also silent on offline behaviour for the AI panel. If your documents are confidential, that gap is the thing to resolve before enabling the feature, not after.
Finally, Linux is x86_64 only. On ARM Linux there is no documented artifact, and the install script's fallback logic assumes one of the supported package formats or the AppImage.
MarkFlowy Against Obsidian and VS Code
The nearest comparison is Obsidian. Both give you a folder-based vault and a Markdown-centric workspace, but the architectural difference is the runtime: Obsidian is an Electron application, while MarkFlowy is Tauri and the README claims a size under 20MB. That claim is the whole point of the Tauri choice, because Electron ships a Chromium runtime with every install. The trade-off is that MarkFlowy depends on the system webview, so rendering and behaviour can differ across platforms in ways an Electron app does not have to worry about, and the README does not document webview version requirements.
The second comparison is VS Code with a Markdown extension. VS Code is a general editor that happens to render Markdown; MarkFlowy is a Markdown editor that happens to open JSON and TXT. The README's file tree with drag-and-drop movement and global search is closer to a notes application than to a code editor's explorer, and the WYSIWYG mode built on ProseMirror is a different editing model from a split preview pane. If your Markdown lives inside a code repository and you want the same window for both, VS Code is the better fit and MarkFlowy adds a second application to your day. If your Markdown is a personal corpus of notes, the file tree and global search are the features that matter.
The third comparison is Typora, which pioneered the single-pane WYSIWYG Markdown model. MarkFlowy's addition over that model is the AI panel and the Tauri footprint, and its subtraction is maturity: Typora is a long-shipping commercial product, while MarkFlowy labels itself beta.
Licence, Maintenance and Upgrade Cost
MarkFlowy is licensed AGPL-3.0. For a desktop application you install and use yourself, that is the same practical situation as most copyleft desktop software: you can run it, and you can read and modify the source. The obligation appears when you distribute modified versions or offer the software to others over a network, because the AGPL extends the source-availability requirement to network use in a way GPL-3.0 does not. This is a description of the licence's structure, not legal advice; if you plan to embed MarkFlowy in a product or a hosted service, read the LICENSE file in the repository and get your own advice.
The repository is not archived, and the last push was on 2026-09-13, one day before the most recent release tag v0.101.0 on 2026-09-12. That is a fast cadence. The practical upgrade cost is therefore low friction but non-zero attention: three releases in the space of a week means the changelog is the place to look before you update, and the repository carries a CHANGELOG.md at the top level for exactly that. There is also an updater script in the root package.json, which points at the desktop workspace, so in-app updates are part of the project's tooling rather than something you have to assemble.
For contributors, the build is heavier than a plain web app. The root scripts run Turbo across workspaces, the Rust side builds through Cargo, and the desktop build invokes Tauri, so a working toolchain needs Node, Yarn and Rust together. The repository pins versions with rust-toolchain.toml, .nvmrc and .node-version, which reduces the chance of a toolchain mismatch but does not remove the two-language setup.
Editorial conclusion
Adopt MarkFlowy if you want a small Tauri editor with WYSIWYG Markdown, a file tree and optional DeepSeek or ChatGPT integration, and you accept beta software under AGPL-3.0. Skip it if you need a signed macOS build without manual steps, a non-copyleft licence, or a formal stability guarantee. Before relying on it, verify the large-file behaviour on your own documents, confirm that your AI provider keys work in your network, and read the AGPL-3.0 terms against how you plan to redistribute or host the code.
Frequently asked questions
What is MarkFlowy?
MarkFlowy is a cross-platform Markdown and text editor built with Tauri, with a ProseMirror-based editor that offers source and WYSIWYG modes. It also edits JSON and TXT, includes a file tree with drag-and-drop movement and global search, and ships built-in AI features.
How do I install MarkFlowy on Linux?
The README documents two routes: the Flatpak remote and app id io.github.drl990114.MarkFlowy, or the install-linux.sh script that installs the .deb or .rpm for your distribution and falls back to the AppImage. Linux support is x86_64 only for now.
Is MarkFlowy free and what licence does it use?
The repository is licensed AGPL-3.0, and the README states that MarkFlowy is completely and permanently open source. The AGPL's source-availability condition applies when you distribute modified versions or offer the software over a network.
Why does MarkFlowy not open on macOS?
The README explains that Apple's restrictions on software without developer certification block the macOS aarch64 build from opening directly. The documented workaround is to run xattr -cr MarkFlowy.app from the Applications directory and then open the app again.
Which AI models does MarkFlowy support?
The README says the built-in AI currently supports Copilot and works with large models such as DeepSeek and ChatGPT, covering dialogue export, translation of articles to any language, and article summaries. It does not document how credentials are stored or how document text is transmitted.
How fast is MarkFlowy with large Markdown files?
The README states that a 2 MB Markdown file opened in around 1 second in testing, as part of the editor rebuild. That is the project's own single figure rather than a published benchmark, so results on your hardware and documents may differ.
Community notes