Memos is a self-hosted, full-stack memo/note-taking application with a Go backend and React/TypeScript frontend. It provides rich features including markdown editing with inline images and math, attachment management (images, video, audio, motion photos), spaces for collaboration, calendar and map views, AI-powered audio transcription, webhooks, SSO/OAuth2 identity providers, and a CEL-based filter engine for advanced querying. The architecture is layered with enforced import rules: internal utilities, provider interfaces (AI, storage, IDP), core business logic, a store layer with driver abstraction supporting SQLite, MySQL, and PostgreSQL, and a server layer exposing ConnectRPC/gRPC and HTTP APIs. The frontend uses CodeMirror 6 for the editor, TanStack Query for data fetching, and extensive custom hooks and UI primitives. The codebase is well-tested with unit, integration, and benchmark tests across both backend and frontend. Notable engineering highlights include a custom Common Expression Language (CEL) engine that compiles user-defined filters to SQL, a sliding window rate limiter, a thread-safe in-memory cache with TTL, and a protocol abstraction layer that transparently handles gRPC and ConnectRPC headers.
This repository is a VS Code extension that integrates Draw.io (diagrams.net) into the Visual Studio Code editor. It enables users to create, edit, and view Draw.io diagrams directly within VS Code, supporting standalone files (.drawio, .dio) and inline diagrams embedded in Markdown via fenced code blocks or HTML comments. The extension provides offline functionality by bundling a version of Draw.io, with optional online fallback, and includes features like Live Share collaboration, code linking from diagram symbols to source code, diagram export/conversion, and theme synchronization. The architecture follows standard VS Code extension patterns with a main entry point (src/index.ts), extension core (src/Extension.ts), editor service (src/DrawioEditorService.ts), Draw.io client for iframe communication (src/DrawioClient/), and specialized features for Live Share, code linking, and inline Markdown editing. Communication between the extension and the embedded Draw.io iframe occurs via postMessage API, with state management using Mobx and resource cleanup via disposable patterns. The extension handles diagram persistence through file system operations and metadata embedding in SVG/PNG files. Key reusable components include a configuration abstraction utility (VsCodeSetting.ts), a Mobx autorun disposable tracker (autorunTrackDisposables.ts), an event-driven Draw.io client for iframe communication (DrawioClient.ts), a Markdown diagram parser (diagramParser.ts), and a Live Share session manager (LiveshareSession.ts). These components demonstrate loose coupling, clear separation of concerns, and patterns applicable beyond this specific extension. The project is actively maintained with automated workflows for updating the bundled Draw.io submodule, indicating low technical drift and strong ongoing maintenance.
Dillinger is a cloud-enabled, online Markdown editor with live preview, export to Markdown, HTML, and PDF, and synchronization with cloud storage services including GitHub, Dropbox, Google Drive, OneDrive, and Bitbucket. Built with Next.js 14 (App Router), the application uses Monaco Editor for editing, Zustand for client-side state management with localStorage persistence, and markdown-it with a rich plugin chain for rendering. It features a modular architecture with API routes for OAuth flows and file operations per cloud provider, a versioned public REST API (v1) for rendering and export, and separate packages for a CLI tool and an MCP server for LLM integration. The codebase is well-organized with clear component separation (editor, preview, sidebar, modals, UI primitives), custom hooks per integration, and comprehensive unit and E2E test coverage. Auxiliary agent/skill files and design system CSVs exist in the repository but are development tools, not part of the application runtime.
MiaoYan is a local-first macOS Markdown note-taking application (Swift 6, AppKit, macOS 12+) that treats notes as plain .md/.markdown/.txt files in a user-selected folder. In production it is a desktop editor: an FSEvents watcher detects external file changes, cmark-GFM renders Markdown through a single pipeline, and a WebKit preview surface (vendored KaTeX, Mermaid, PlantUML, Markmap, Reveal.js) handles rendering. The app ships wikilinks/backlinks, version history, CJK-aware typography normalization, PDF/HTML/PNG/PPT export, and URL routing (miaoyan://, nv://, nvalt://). There is no server component — cloud sync is deliberately delegated to iCloud Drive/Nutstore/Dropbox. Distribution includes Sparkle auto-update, Homebrew, App Store, a bash CLI (miao), and an agent-facing SKILL.md. The architecture is a monolith with two UI shells: the primary AppKit storyboard window (ViewController, EditTextView, SidebarProjectView) and an in-progress SwiftUI shell launched via -MiaoYanShell YES. Both shells share the Business/ layer, with dedicated parity tests keeping them aligned. A Foundation-only MiaoYanCore package holds platform-agnostic text logic (frontmatter parsing, multi-encoding detection, search matching, preview extraction) shared with an iOS build — the cleanest architectural boundary in the repo. Core domain services include Storage/Note/Project models, NoteVersionManager, WikilinkIndex, CloudSyncManager (NSMetadataQuery-based), and debounced atomic saves using renamex_np RENAME_SWAP. Engineering strengths: an extensive regression-driven test suite (26+ files) covering real incident history (editor buffer ownership #543, storage relocation, save debounce, shell parity), strict CI where SwiftLint and swift-format warnings block merges, tiered highlighting for very large files, xattr-based note metadata, legacy encoding support (UTF-8/UTF-16/GB18030/Big5/CP1252), and localization in five languages. Notable weaknesses: ViewController is a god-class accumulating layout/keyboard/storage/preview/PPT logic; the dual-UI shell carries ongoing parity risk; saveCloudPins/restoreCloudPins are empty stubs (cloud pin sync is unimplemented); large hand-maintained regex sets in NotesTextProcessor; UserDefaults key sprawl; two Package.resolved manifests with a Sparkle version mismatch (2.8.0 vs 2.9.0); and a large vendored DownView.bundle JS payload that is an update/maintenance burden.
ghostwriter is a cross-platform desktop Markdown editor (Qt/C++) focused on distraction-free writing. In production, it provides a rich editing experience with live HTML preview, syntax highlighting for GitHub-Flavored Markdown (via cmark-gfm), LaTeX math rendering (via bundled MathJax), customizable themes, spell checking via KDE Sonnet, find/replace with regex support, document statistics (word count, readability indices, session analytics), and export to HTML, PDF, ODT, EPUB, and LaTeX using external tools like Pandoc or MultiMarkdown. The architecture is a standard Qt desktop application with singleton services (ExporterFactory, AppSettings, CmarkGfmAPI), a factory pattern for exporters, and a signal/slot-driven UI. Key entry points are the MainWindow (orchestrating editor, preview, sidebar, and menus), MarkdownEditor (custom QPlainTextEdit with overridden painting and input handling), and HtmlPreview (QWebEngineView with a QWebChannel bridge for live updates). Data flows: user types Markdown → MarkdownDocument (wraps cmark-gfm AST) → syntax highlighter updates → preview regenerates HTML via exporter → MathJax renders any LaTeX in the preview. External dependencies include Qt (5 or 6), KDE Frameworks (Sonnet, KConfigWidgets, KCoreAddons), and the bundled cmark-gfm and MathJax libraries. Export optionally depends on Pandoc, MultiMarkdown, or cmark command-line tools. The codebase demonstrates solid software engineering practices: clean separation of concerns, use of design patterns (singleton, factory, decorator, proxy), and extensive use of Qt's meta-object system for decoupled communication.
fylepad is a note-taking application built with Vue 3 and Tauri that provides a rich text editing experience with AI integration. It functions as both a web application and cross-platform desktop app, offering features like markdown editing, diagram support (Mermaid, PlantUML), media embeddings (YouTube, Spotify), and AI-powered text assistance. The application uses a local-first approach with IndexedDB/SQLite storage and optional cloud synchronization. The architecture follows a component-based pattern with Vue.js, utilizing Tiptap for the core editor functionality and numerous extensions for specialized features. State management is handled through Vue composables, and the UI is built with @nuxt/ui components. The application includes sophisticated features like offline support, conflict resolution, and a responsive interface that adapts between web and desktop contexts.
MarkText is a cross-platform desktop markdown editor (Electron + Vue 3) powered by the Muya WYSIWYG engine. It provides real-time rendering of CommonMark, GFM, and extended syntax including KaTeX math, mermaid/plantuml diagrams, footnotes, tables, task lists, and 30+ themes. The monorepo contains four packages: `desktop` (Electron shell with IPC, preferences, spellcheck, export), `muya` (TypeScript core editor with block-based state, snabbdom rendering, undo/redo via ot-json1, clipboard, and floating UI components), `muyajs` (legacy JavaScript engine, still present for partial feature parity), and `website` (Next.js documentation site). The architecture follows a block tree pattern where each block type (paragraph, heading, list, table, etc.) is a subclass with consistent parent/content interfaces. Communication between the Electron main and renderer processes uses typed IPC channels. The codebase demonstrates strong software engineering practices with extensive unit and e2e test coverage (Playwright, Vitest), reproducible builds (pnpm monorepo), and a focus on regression testing for edge cases. However, the ongoing migration from the legacy `muyajs` engine to the new `muya` engine introduces some code duplication and technical drift, and some modules retain prototype-style JavaScript alongside modern TypeScript classes.
This repository is the monorepo for Cherry Markdown, a rich, extensible WYSIWYG markdown editor library developed by Tencent. The core package (`packages/cherry-markdown`) provides a modular parsing engine with a plugin-based syntax hook system, a comprehensive toolbar, streaming rendering for AI chat, and support for diagrams (Mermaid, PlantUML, ECharts), math (KaTeX/MathJax), tables, and code blocks. The repository also includes a desktop client built with Tauri (Vue 3 + Pinia + Rust) that adds file management, local versioning, and native integrations; a VS Code extension; a WeChat Mini Program renderer; and various example applications. The architecture is well-structured with clear separation of concerns (engine, previewer, editor, toolbar, addons), extensive unit tests, and a consistent event-driven pattern. While the core library is JavaScript with JSDoc types, the client and plugins are TypeScript. Some technical drift exists due to vendored third-party assets (e.g., drawio library), a partially implemented Milkdown adapter, and a few deprecated code paths. Overall, this is a mature, actively maintained editor framework with high reusability in its hook system, utility classes, and composable patterns.
Mindolph is a desktop knowledge management application built with JavaFX. It provides integrated support for mind maps, markdown, PlantUML diagrams, and CSV files, along with AI-powered features such as text reframing, summarization, and chat via various LLM providers. The application features a modular architecture with core, base, FX, and domain-specific modules, an event-driven communication system, a plugin/extension system for mind map operations, and a preference management system. Users can manage workspaces, search within files, and use reusable snippets.
Readme.so is a Next.js web application that provides an online editor for generating README.md files. Users can select from predefined sections, edit their content using a Monaco Editor (desktop) or textarea (mobile), reorder sections via drag-and-drop, and download the final markdown. The application state is managed in React and persisted to localStorage with debounced saving. The frontend uses TailwindCSS for styling and integrates libraries like dnd-kit for drag-and-drop and react-markdown for preview. The app is statically exported and deployed via GitHub Pages.
QMarkdownTextEdit is a mature C++ Qt library providing a feature-rich markdown text editor widget, QMarkdownTextEdit, which extends QPlainTextEdit with live markdown syntax highlighting, code block syntax highlighting (for dozens of languages via a large hand-curated keyword dataset), line numbers with bookmark indicators, block (rectangular) selection, clickable links, and an integrated search/replace widget. The library is designed to be embedded into larger Qt applications such as QOwnNotes, Notes, and CuteMarkEd-NG. It supports both widget-based (QWidget) and Qt Quick (QML) integration through a registered QML type. The architecture is a single-library module with optional demo and QML example applications. The core components include the main editor widget, the markdown highlighter (which can be used independently on any QTextDocument), a separate search/replace widget (QPlainTextEditSearchWidget), and a line number area (LineNumberArea). The language-specific syntax highlighting data is generated in a single massive C++ file (qownlanguagedata.cpp) using a consistent pattern of init/load functions grouped by language. The library is built and installed via qmake (.pro/.pri) and CMake, with continuous integration across multiple Qt versions (5.9 to 6.10) on Linux, macOS, and Windows. The codebase is well-organized and demonstrates solid engineering practices: clear separation of concerns (highlighter, search widget, editor), support for internationalization (translation files for German, Spanish, Urdu, Chinese), and compatibility with both widget and QML interfaces. While the library is primarily a UI component, it also includes utility patterns like debounced search and regex support. The main risk is the maintenance burden of the enormous hand-curated syntax data file, which contains some minor errors and duplicates, and the lack of automated tests for the highlighting logic. Overall, this is a practical, production-grade text editor component with broad applicability in Qt projects requiring markdown or code editing capabilities.
This repository is the Notes app for ownCloud Server, a distraction-free note-taking plugin that stores notes as plain text files in the user's cloud storage. It provides a web-based editor with markdown support (via mdEdit) and syntax highlighting (via Prism), along with a RESTful API (v0.2) for third-party integration. The backend is PHP 8.3 following ownCloud's app framework: controllers handle HTTP requests, services contain business logic, and a simple entity layer maps files to Note objects. The frontend is an AngularJS 1.8 single-page application using Restangular for API communication, with custom directives for autofocus, debounced saving, and editor integration. Notes are persisted as .txt, .md, .org, or .note files in a per-user 'Notes' folder, with filename collision resolution and directory traversal prevention. The app supports favoriting via ownCloud's tag system and remembers the last viewed note across sessions. The codebase is well-structured with unit tests for both PHP and JavaScript, acceptance tests, and CI/CD pipelines. It has been actively maintained with recent security updates (patched AngularJS, underscore, Prism) and a move to in-repo translations. While the architecture is standard for ownCloud plugins and the frontend uses an older AngularJS version, the implementation is clean, the business logic is robust, and there are a few reusable patterns like the async save queue and a Python duplicate-key checker for translation files.
This repository contains the client-side code for EASYME.md, a web-based markdown editor designed for creating and sharing README files. The application features a split-pane interface with a live markdown preview, a customizable toolbar for applying formatting, and functionality to share documents via a unique URL. Built with React, Redux, and Emotion, it demonstrates a well-structured single-page application with clear separation of concerns. The editor uses a textarea for input and leverages the `text-field-edit` library for precise text manipulations, enabling features like inserting text at the cursor position, wrapping selections, and handling keyboard shortcuts for common markdown syntax. State management is handled by Redux Toolkit with Redux Saga for side effects, such as fetching saved documents from a backend API. The application also supports offline drafting via localStorage and sharing via URL hash compression using `lz-string`. Key components include a dynamic toolbar with buttons for bold, italic, lists, tables, and more, each implemented as isolated, reusable components. The utility modules for URL sharing and draft storage are particularly noteworthy for their potential reuse in other projects. Despite some dependencies being slightly outdated, the codebase remains functional and maintainable.