Apple Notes only live in one place: Notes.app or the iCloud web client. They don't provide a documented API to access your notes from anywhere else. That's been a persistent annoyance for me because my husband likes to plan things collaboratively using Apple Notes, and my only Apple product is an iPhone ... so my half of the planning was happening on a phone keyboard or in a clunky web interface while a perfectly good computer running my favorite Markdown editor (Obsidian) sat in front of me. I wanted my notes to be real files that I could edit alongside my other notes, so I built icloud-md: a CLI that clones your notes into a folder of Markdown and syncs your edits back to iCloud as if you'd typed them into Notes.app all along.

icloud-md clone ./my-notes
cd my-notes && vim "Grocery list.md"
icloud-md push

What that gets you:

• Real files: one Markdown file per note — greppable, diffable, git-trackable, editable in whatever you already use. Your Notes folder structure becomes real directories, and mkdir + push creates folders upstream.
• Any OS: it's a plain Node CLI talking to iCloud directly, not an AppleScript wrapper around a live Notes.app or a parser for a database you had to copy off a Mac first. Linux and Windows work great!
• Actually bidirectional: pull does a real three-way merge when a note changed both remotely and locally, only asking you to resolve the parts that overlap. push handles creates, edits, moves, and deletes, and a note that changed remotely since your last sync is reported as a conflict, never silently overwritten.
• Formatting round-trips: headings, nested lists, checklists, blockquotes, tables (yes, edits push back), inline formatting.
• Careful by default: status shows exactly what a push would do first, every write is round-trip verified, and anything the tool can't fully account for in a note's internal format stays read-only rather than getting a hopeful best-effort write.

I'm a Staff Engineer at the company I work at, and I've done a lot of software over the years. I'd wanted to spend some time reverse-engineering the CloudKit protocol, and was honestly never going to find that time. But, as I'm sure you're all aware, the world has changed over the last year, and the fact that a reverse-engineering project provides a really solid, clear feedback loop meant that I had a new approach I could take: coaching an LLM (in this case: Fable 5) into building that feedback loop, and then tasking it with exercising parts of the iCloud (and later: iPhone) Apple Notes UI so that it could reverse-engineer the protocol. This was a surprisingly large amount of fun and it goes to show you that what you get out of AI tooling scales well with what experience the person wielding it brings to the table; neither of us was getting through Apple's protobuf-and-CRDT note format alone on a weekend.

MIT, TypeScript/Node: https://github.com/coddingtonbear/icloud-md & https://coddingtonbear.github.io/icloud-md/

Hey r/sideprojects,

I wanted to share a small milestone for a project I’ve been working on called Marco.

It just passed:

• 100+ GitHub stars
• 219 downloads this month (Windows + Linux)

Repo: https://github.com/Ranrar/Marco

What it is

Marco is a native Markdown editor + viewer built in Rust, with a focus on performance and structured technical writing.

It comes with a companion app called Polo, which is a lightweight Markdown viewer.

Both run on Linux and Windows using GTK4 and WebKit/WebView2.

Why I built it

I work a lot with technical documentation and manuals, and I couldn’t really find a Markdown editor on Linux that felt:

• fast and local-first (no cloud / login)
• stable for long technical docs
• structured enough for complex documentation
• consistent between editing and viewing

So I started building one from scratch.

It turned into a deeper project than expected, including a custom Markdown parser and AST instead of relying fully on existing parsing layers.

What makes it different

Some key things I ended up adding:

• Custom Rust-based Markdown parser (marco-core)
• Live preview with scroll sync
• Full CommonMark compliance + extensions (tables, math, mermaid, etc.)
• RTL + Unicode support (important for international docs)
• Export to PDF + print mode
• Structured document navigation (TOC, bookmarks, cross-file links)
• Designed for technical documentation, not just notes

The idea was: Markdown should behave more like a real document system, not just a text format.

Tech stack

• Rust (core + parser)
• GTK4 (UI)
• WebKit / WebView2 (rendering)
• nom (parser combinators)
• KaTeX + Mermaid rendering
• RON config system

Where it’s going

Still early, but next focus is:

• improving editor intelligence (completion + diagnostics)
• collaborative editing (CRDT experiment)
• optional privacy-first telemetry (opt-in only)
• better packaging + easier install flows

Feedback welcome

If you try it, I’d really appreciate feedback on:

• usability (especially Linux workflow)
• documentation workflows
• what feels missing compared to other editors

If nothing else, thanks for reading 👍

Hey everyone! I wanted to share a CLI tool I've been working on that I think fits this community well.

mado is a general-purpose entry manager that stores everything as markdown files. The key idea is that it's not just another task manager with a rigid schema — it's a flexible system for organizing entries of any kind: tasks, notes, ideas, research snippets, meeting logs, you name it.

Each entry lives in its own timestamped directory with a MAIN.md inside. Want to attach files? Just drop them in the same folder — screenshots, logs, PDFs, whatever. Everything stays organized in one place, and since it's all plain files, it's perfectly git-friendly.

All fields are optional — fill in what you need, skip the rest. For a task you might set priority, deadline, and status. For a note, just write markdown and you're done. You can also hide any fields from the output when listing entries, so notes don't clutter your view with irrelevant columns. That flexibility is what makes it work as both a task manager and a notes system — or anything in between.

It's written with a focus on performance — it handles 100k entries in about a second with parallel mode.

The CLI is designed for both interactive use and scripting: JSON output for pipes, path-only output for grep/fzf, and a query language with logical operators and time macros.

Would love feedback, especially from folks who've used similar file-based tools or have ideas about what would make this genuinely useful.

https://github.com/laserattack/mado

Just like the video demonstration。

I've been building a markdown notes app on weekends (Margin, a local-first notes app where notes stay as plain .md files on disk, so discount everything below accordingly). I assumed markdown would be the easy part: grab a CommonMark parser and move on. The format had other plans. The ones that ate whole weekends:

- Pipes in table cells. A `|` has to be escaped or it splits the cell, but blindly escaping inside inline code spans corrupts them. Getting the serializer to escape cell markup while shielding code spans took embarrassingly long.

- Round-tripping. A live-preview editor parses your text, renders it, and writes it back. The write-back has to reproduce exactly what you typed: if you write `*` bullets and the serializer prefers `-`, the app silently rewrites your file. Since the files are plain markdown that other tools might read, I treat any normalization as data corruption, and holding that line is harder than it sounds.

- Paste. Everything arrives as HTML. Turning a pasted webpage or Google Doc table into markdown that survives a round-trip, with the smart quotes and nested span soup cleaned up, is its own project.

- The cursor. In live preview, `**bold**` renders as bold until the cursor enters it, then the markers reveal. Exactly when they appear and where the cursor lands is a product decision wearing a parsing costume, and you feel every wrong choice within minutes of typing.

Curious what bites other people, whether you hand-write markdown or build tooling for it. And if a local-first Mac notes app that keeps everything as plain files sounds useful, there's a waitlist at https://gomargin.app/mk

I’m a lawyer. I write a lot of formal documents, and they ultimately need to be DOCX files because that is what clients, courts, and colleagues use.. I still prefer writing in Markdown. It is easier to read, edit, review in Git, and work on with an LLM. But the usual workflow is painful. You convert back and forth, fix formatting by hand, and hope the final document contains everything it should.

nowadays I draft my documents a bit like vibecoding.. and I've realized that this works much better when there is a compiler enforcing a contract. I want clear boundaries around what a valid document is. That is why I built docc.

It is not really a Pandoc alternative. Pandoc solves conversion. docc is about verification. A document has a schema, required metadata, explicit structures, and rules that must pass before it can produce a DOCX file. Themes handle layout, while the Markdown file remains the actual prose I edit.

I also did not want a template system where the real content disappears into YAML or template variables. That makes editing more painful than Word. The prose should stay inline and readable, with just enough structure for the compiler to check it.

The result is a useful baseline for an agent too. It can draft the Markdown, but it cannot build a document that breaks the rules. So its a bit like the inversion of templating if you will..

I’m not selling anything. I’m mostly curious whether others have this problem, or whether they are happy with conversion plus manual review.

Repo and docs: https://github.com/kevinzehnder/docc

P.S. I have a Go development background, so this is not my first codebase, but it has also been heavily vibe-coded. It is still very much an MVP. I’m posting partly to find out whether I have reinvented something that already exists, and to be pointed towards the thing I was actually looking for.

I’ve been working on Panorama Markdown, a lightweight Markdown dialect for academic papers.

The goal is to keep the writing experience close to standard Markdown, while adding a few things that are hard to do cleanly in plain Markdown:

• YAML front matter for title, authors, abstract, and keywords
• citations and references
• figures and tables
• cross-references
• PDF export

I built it because I wanted a simpler way to write papers and my thesis without jumping straight into a heavier typesetting workflow.

The project is still in early preview, but the spec and editor are already usable:

https://github.com/panorama-lab/markdown

When I started learning cybersecurity, my notes were everywhere. Random Google Docs. Half-finished PDFs. Screenshots with no context. Bookmarks I never revisited. Nothing connected. Nothing made sense when I came back to it.

So I rebuilt everything as an Obsidian vault — structured as a proper learning path from absolute basics to advanced topics.

What's inside right now:

Networking fundamentals (OSI, TCP/IP, ports, protocols)

Operating systems & Linux basics

Security fundamentals (CIA triad, threats, risk)

Web application security (OWASP Top 10, common vulns)

Cryptography basics (symmetric/asymmetric, hashing, PKI)

SOC / Blue Team / Red Team concepts

Incident response fundamentals

Malware analysis basics

Cloud security intro

Cheat sheets and command references I actually use

The part I didn't expect: Everything is interlinked using Obsidian's graph view. So instead of flat notes, you get a proper knowledge map — click through related concepts as you're learning, and it actually connects.

It's now published as a live site too (built with Quartz), so you can browse it like a proper handbook instead of just a folder of markdown files.

I'm still actively adding to it — if you spot gaps or want a topic added, let me know. Hoping this saves someone the same scattered-notes chaos I went through.

Repo: https://github.com/priyanshu-rawa/Cybersecurity-Handbook
Live site: https://cybersecurity-handbook-lake.vercel.app

Would appreciate a star if this ends up being useful for your learning too 🙏

Hey there!

Building synap.md — a self-hosted, Obsidian-style Markdown notes app. Notes stay plain \`.md\` files on your own disk, no lock-in. Web app (Nuxt) + a native Tauri/Rust desktop client that syncs against your own server, offline-capable.

Still WIP with rough edges, but usable — and I'd genuinely love contributors, especially if local-first sync or Rust interests you.

Repo: https://github.com/BungeeDEV/synap-monorepo (MIT)

Markdown in the terminal usually means one of two things: reading the raw source, or piping it through a tool that dumps one screenful of formatted text and hands you back to less.

I wanted an actual pager. So I wrote mdmost.

• Resize the pane and everything reflows. Tables renegotiate their column widths, diagrams re-lay their boxes, prose re-wraps. One drag, three different behaviors.
• Mermaid diagrams get drawn, not printed as source.
• Select with the mouse and the Markdown source lands on your clipboard, not the rendered text.
• A table too wide for the pane scrolls sideways on its own instead of being mangled.

Written in Rust. No system dependencies beyond a terminal that speaks truecolour. Homebrew, .deb, .rpm, static musl tarballs, or cargo install mdmost.

https://github.com/oetiker/mdmost

While working on an Avalonia-based Launcher App for the Stride Game Engine, I needed to have a markdown renderer for the release notes and announcements.

A while ago, I did a renderer for WPF based on Markdig: Markdig.Wpf which is now archived since I have lost interest in WPF. By the way thanks u/grokys for your contributions to that library.

I decided to make a modern version of that renderer targeting Avalonia instead.

Here it is: https://github.com/Kryptos-FR/MarkView.Avalonia

It supports the fully CommonMark spec thanks to Markdig, as well as most Markdig extensions for emphasis, tables, etc.

I also made a few optional packages to add support for Mermaid (using Mermaider), SVG images and syntax highlighting (using TextMateSharp). I have a LaTeX's math syntax support coming up (using CSharpMath).

Let me know what you think!

Disclosure: I have used AI agents to help me with documentation, refactoring, performance analysis, and integrating the Mermaid and TextMateSharp libraries.

Hey everyone, I just launched Doxy a browser-based editor that combines markdown and HTML. Think Overleaf but without LaTeX.

It's free to write unlimited. Export to PDF. Paid plan adds AI + unlimited cloud storage. Works entirely in the browser.

Would genuinely love feedback from people in this community what's missing, what's broken, what would make you actually use it.

https://trydoxy.com/

I often want the same document in two places:

• Google Docs, where non-technical collaborators can edit and comment
• a real Markdown file, where it can live beside the code and work with Git, editors, and coding agents

Exporting and re-importing quickly became awkward, so I built GDMS: a self-hosted macOS service that keeps explicitly paired Google Docs and Markdown files synchronized in both directions.

It preserves supported formatting such as headings, lists, links, tables, spacing, and standalone images. It can also pair Google Sheets with per-tab CSV files.

This is currently aimed at technically comfortable macOS users. It runs from a source checkout and requires Google OAuth setup; it isn’t yet a polished packaged app. It’s MIT licensed.

I’d especially appreciate feedback on:

• whether this Google Docs/local Markdown workflow is useful to anyone else
• which formatting needs to round-trip reliably for your documents
• whether the current setup burden would prevent you from trying it

GitHub: https://github.com/rsheyd/google-docs-markdown-sync

Here’s the basic workflow:

meeting-notes.md  ↔  Google Doc
budget/*.csv      ↔  Google Sheet (one CSV per tab)

I got tired of getting caught up in Markdown Mayhem and thought it would be nice to create a visual framework for Markdown files. So, I created MD2HD, an open-source MD visualization framework.

Point your favorite LLM at the repo, or add the plugin, and ask it to build a map of whatever concept you want.

If you love it, let me know. If not, its open source and completely free so no harm no foul!

Repo: https://github.com/evan-steinhilb/md2hd
NPM: https://www.npmjs.com/package/md2hd

Claude plugin:
/plugin marketplace add evan-steinhilb/md2hd
/plugin install md2hd@md2hd