MarkEdit-app/MarkEdit

MarkEdit is a native macOS text editor and Markdown writer built on a web-based CoreEditor engine that bridges JavaScript and Swift. It provides comprehensive document editing capabilities, including syntax highlighting, AI-assisted writing tools, and a robust extension ecosystem. The system supports advanced features like file versioning, AppleScript automation, and a dedicated Quick Look preview extension.

71 changes.

MarkEdit was released as open-source software, centered on the introduction of the CoreEditor module which provides a CodeMirror 6-based text editing engine with a native web bridge. This period established the foundational architecture for syntax highlighting, theming, and cross-platform communication, while integrating native macOS features like AppleScript, Shortcuts, and an auto-updater.

33 changes.

This period focused on establishing a robust extension infrastructure, including a centralized registry, manager UI, and secure installation mechanisms, alongside significant core editor improvements. Key developments included integrating a comprehensive API, refining syntax parsing for math and links, and enhancing UI components for features like Quick Look and file versioning. The work also involved stabilizing the codebase through extensive testing and performance optimizations for rendering and diffing.

Users can now control MarkEdit via AppleScript, allowing automation of document editing tasks. This new scripting interface exposes properties to read and write the raw markdown source and rich text, select and modify text within the editor, and execute custom JavaScript commands against the document's web view. The implementation includes robust error handling for scripting operations and proper type conversion for AppleScript-compatible descriptors.

MarkEditMac/Sources/Scripting · high confidence

A new internal FontManagerDelegate class has been introduced to manage font changes originating from the system's NSFontManager. This component acts as a shared delegate that captures font modifications and notifies observers via a callback, ensuring thread safety by marking the class and its callback as @MainActor.

MarkEditMac/Modules/Sources/FontPicker/Internal · high confidence

Users can now reopen recently closed tabs using Cmd+Shift+T, with the system intelligently restoring the tab to its original sibling window group when possible. Additionally, the editor now preserves and restores the last cursor/selection position for files, but automatically discards this history if the file has been modified externally (detected via file size changes) to prevent restoring stale positions.

MarkEditMac/Sources/Editor · high confidence

MarkEditMac now supports Apple Shortcuts, allowing users to automate tasks such as creating new documents, evaluating JavaScript, and getting or updating file content directly from the Shortcuts app.

MarkEditMac/Sources/Shortcuts · high confidence

The app now supports Apple Shortcuts integration by adding an AppIntent extension that exposes the current active editor. This allows users to automate editing tasks by accessing the currently focused editor instance within Shortcuts workflows.

MarkEditMac/Sources/Shortcuts/Extensions · high confidence

The application now includes localized UI strings (English, Simplified Chinese, Traditional Chinese) for several new or updated menu items, including 'Float on Top', 'Version History', 'New File from Clipboard', 'Customize Toolbar…', 'Transformations', and 'Last Edited 3 Months Ago'. This ensures these interface elements are properly displayed in supported languages.

MarkEditMac/mul.lproj · high confidence

MarkEdit can now open and save files packaged as TextBundle (org.textbundle.package). The new TextBundle module parses the bundle structure (text file, info.json, assets folder), handles file name resolution for the text content, and manages asset copying with collision avoidance, allowing users to edit these bundled documents directly.

MarkEditMac/Modules/Sources/TextBundle · high confidence

Introduced the \GotoLineView\ and \GotoLineWindow\ classes in the SharedUI module, providing a borderless, tinted window interface that allows users to input a line number and navigate directly to it. The implementation includes visual styling with popover effects and custom tints, along with logic to handle input validation and trigger the navigation handler upon submission.

MarkEditMac/Modules/Sources/SharedUI/GotoLine · high confidence

The text checker module now exposes options to control spellcheck and autocorrect behavior on the editor's content DOM. Users can configure these settings via the TextCheckerOptions interface, which allows enabling or disabling spellcheck and autocorrect, while automatically removing autocomplete and autocapitalize attributes to respect system preferences.

CoreEditor/src/modules/textChecker · high confidence

The editor now includes a new module to detect, set, and normalize line endings (LF, CRLF, CR) within the document. This allows the application to handle pasted content with mixed line endings correctly and ensures consistent formatting by normalizing line breaks according to the user's configured preference or the detected dominant style.

CoreEditor/src/modules/lineEndings · high confidence

A new link module has been introduced to the editor, providing utility functions to extract labels from the document. Specifically, it now supports identifying footnote labels (e.g., \\[^label\]\) and reference link labels (e.g., \\[label\]:\), which enables features like auto-completion for these link types while ensuring footnotes are excluded from standard reference link suggestions.

CoreEditor/src/modules/link · high confidence

The editor now supports rendering line breaks as visible characters, with the specific symbol configurable via the \visibleLineBreakCharacter\ setting (defaulting to '¬'). Additionally, a new preview widget is introduced to display a preview button after content such as mermaid diagrams, allowing users to toggle the preview state directly from the editor view.

CoreEditor/src/styling/views · high confidence

MarkEdit now supports opening Text Bundle files and Mermaid diagrams (.mmd, .mermaid) alongside existing Markdown and plain text formats, with dedicated document type declarations in the app bundle. AppleScript support is enabled via the Info.plist, allowing external automation of document creation and content updates, while new localized strings in AppShortcuts.xcstrings provide the necessary UI labels for these AppleScript actions in English, Simplified Chinese, and Traditional Chinese.

MarkEditMac · high confidence

The FontPicker module now exposes a \fontSizeChanged\ notification, allowing other parts of the application to react when the user adjusts the font size. This change introduces a dedicated notification name and a corresponding publisher, enabling reactive updates to UI elements or settings that depend on the current font size configuration.

MarkEditMac/Modules/Sources/FontPicker/Extensions · high confidence

MarkEdit now includes a built-in self-updater that checks for new versions via the GitHub Releases API. The updater automatically downloads the appropriate update archive (universal or Apple Silicon) and stages it for installation. Users are notified of available updates, can view release notes, and are informed if a new version requires a higher macOS version. The system supports skipping versions, disabling update checks, and handles installation errors gracefully with options to view the release page or retry later.

MarkEditMac/Sources/Updater · high confidence

This change introduces the complete selection management subsystem for the CoreEditor, providing the foundational logic for cursor positioning, text selection, and navigation. It adds utilities to determine if content is selected, retrieve selected text and line/column information, and handle multi-range selections. The module also implements navigation features such as 'Go Back' to restore previous cursors, whole-line selection via gutter clicks, and intelligent scrolling to keep the caret or search matches visible within the viewport. Additionally, it includes helpers to normalize selection bounds, redraw the selection layer, and optimize performance by reducing unnecessary updates for large text payloads.

CoreEditor/src/modules/selection · high confidence

MarkEdit is now available as free and open-source software for macOS. The repository includes the core application code, build configurations (Build.xcconfig), and linting rules (.swiftlint.yml). The README has been updated to reflect the app's focus on performance and native integration, noting support for macOS 26.0+, and provides installation instructions via GitHub releases and Homebrew.

(repo-wide) · high confidence

The CoreEditor now ships with a comprehensive set of 16 syntax-highlighting themes, including GitHub Light/Dark, Xcode Light/Dark, Dracula, Cobalt, Solarized Light/Dark, Rose Pine/Dawn, Night Owl, SynthWave '84, Winter Is Coming Light/Dark, and Minimal Light/Dark. These themes are registered in the theme loader and provide distinct visual styles for code elements such as keywords, strings, and comments, allowing users to choose a preferred aesthetic for their editing experience.

CoreEditor/src/styling/themes · high confidence

This change introduces the initial source code for the CoreEditor module, specifically adding a localization utility in CoreEditor/src/modules/localization that maps CodeMirror UI phrases (such as 'Control character', 'Folded lines', and 'Unfold') to configurable strings with English fallbacks. It also establishes the foundational project workspace configuration for the MarkEdit Xcode project and the MarkEditTools Swift package, which provides platform-independent development tools like SwiftLint.

CoreEditor/src/modules/localization, MarkEdit.xcodeproj/project.xcworkspace, MarkEditTools · high confidence

MarkEditCore is now available as a standalone, embeddable Swift package that provides the core editing engine for the MarkEdit application. This release introduces the foundational infrastructure for the web-based editor, including a dynamic bridge system for sending configuration and state between Swift and JavaScript, and a shared HTML template that is distributed to both the main app and its extensions. The package includes built-in support for loading local images via a custom URL scheme, injecting user-provided scripts and styles, and managing localized UI strings. It exposes a comprehensive configuration model allowing users to control editor behavior such as read-only mode, indentation, smart quotes, and invisible character rendering, along with shared types for handling font faces, selection ranges, and runtime information.

MarkEditCore/Sources · high confidence

This change introduces the initial source code for the MarkEditKit extension layer, providing foundational utilities for the application. It adds helper extensions for standard types (Array, String, URL, UserDefaults, NSObject) and specific WebKit components (WKWebView, WKWebViewConfiguration). Key capabilities include file type detection (binary vs. text, images), URL path normalization, method swizzling for runtime configuration, and a bridge mechanism for invoking JavaScript in WebViews. It also configures WebKit to bypass CORS restrictions for user scripts and sets default text-checker preferences.

MarkEditKit/Sources/Extensions · high confidence

This change introduces the CoreEditor module, providing the foundational text editing engine for the application. It implements a CodeMirror 6-based editor with configurable behaviors including read-only mode, dynamic theming, line wrapping, and custom indentation strategies. The engine supports Markdown and HTML syntax highlighting, auto-completion for links and references, and handles text input features like smart quotes and emoji deletion. It also includes accessibility features such as reduced motion support and proper ARIA attributes, along with performance optimizations for scrolling and selection restoration.

CoreEditor/src · high confidence

This change introduces the initial public source code for the MarkEditKit framework, making the core editing components available for the first time. The release includes the EditorLogger for structured logging, the EditorMessageHandler which manages asynchronous communication between the web view and native modules (restricted to the main frame for security), and the EditorTextEncoding enum which provides support for decoding and encoding text files across a wide range of character sets including UTF-8, UTF-16, ASCII, and various legacy encodings like GB18030 and Shift JIS.

MarkEditKit/Sources · high confidence

This change integrates the markedit-api v0.13.0 interface into the CoreEditor, exposing a comprehensive set of capabilities for extensions and scripts. Users can now interact with the editor's text content via the TextEditable API (get/set text, selections, undo/redo), manage files through the file system API (open, create, delete, move, list, and retrieve file info/content), and access version history (get, restore, and delete file versions). Additionally, the API provides system integration features including a translation service, language model support for generative AI, UI controls (alerts, save panels, context menus), and event listeners for app and editor lifecycle events.

CoreEditor/src/api · high confidence

The editor now tracks recently closed tabs to enable re-opening them with their original window and tab position restored, and preloads an editor view controller in the background to reduce the load time when opening new documents.

MarkEditMac/Sources/Editor/Models · high confidence

Added a new @codegen folder containing mustache templates and configuration for the ts-gyb tool, which generates Swift bridge code from TypeScript interfaces. This infrastructure ensures that native and web bridges are main-actor isolated and that generated configuration and payload types conform to Sendable, enabling safe background processing without sharing bridge or WebKit state.

CoreEditor/src/@codegen · high confidence

A new statistics view has been added to the application, allowing users to view detailed text metrics for both the full document and any current text selection. The view displays character, word, sentence, and paragraph counts, utilizing a syntax tree for paragraph and comment counts and Natural Language processing for words and sentences. It also includes estimated read time and file size information. Additionally, the feature supports custom counting rules defined via regex patterns, enabling users to track specific content patterns (such as emojis) in their documents.

MarkEditMac/Modules/Sources/Statistics, MarkEditMac/Modules/Sources/Statistics/Views · high confidence

The editor now uses a new, dynamic styling infrastructure that allows themes to be swapped and styles to be updated at runtime without reloading the page. This system separates color-independent base styles (such as the macOS Sonoma-style caret, gutter positioning, and font fallbacks) from color-dependent theme data, enabling instant visual updates when the user changes the theme or adjusts settings like font size, line height, or typewriter mode. It also introduces specific CSS classes for Markdown elements (headings, code, lists, tables) and supports dynamic toggling of features like line numbers, active line indicators, and invisible character rendering.

CoreEditor/src/styling · high confidence

This change introduces the foundational state management and utility layer for the CoreEditor. It adds a new \store.ts\ module that defines global state objects for editor colors, context menu timing, gutter hover status, and modal sheet presence, alongside an \editingState\ object to track selection, scroll position, and IME composition status. A key addition is the \isComposing()\ function, which synchronizes the editor's composition state with CodeMirror's internal state to ensure accurate tracking of input method editor activity. Additionally, \utils.ts\ provides critical helper functions, including \tryGetEditor()\ for safely accessing the editor instance without null-reference errors, \focusedEditor()\ for identifying the active editor DOM element, and \isMotionReduced()\ to respect the user's system accessibility settings for reduced motion.

CoreEditor/src/common · high confidence

The UpdateInstaller component adds an XPC service that enables automatic in-place app updates. The service stages downloaded archives, verifies the update's code signature and identity against the installed app using UpdaterCore, and spawns a detached installer process to swap the app bundle once the current process exits. This ensures updates are atomic, secure, and automatically applied without manual intervention.

UpdateInstaller · high confidence

Adds the core backend for a centralized extension ecosystem, including a new \ExtensionConfig\ to persist installed extensions and update preferences (such as automatic or quiet update behaviors), an \ExtensionRegistry\ to fetch and parse a remote index of available extensions with version and compatibility checks, and an \ExtensionDownloader\ to securely fetch, verify (SHA-256), and install extension scripts. This replaces ad-hoc extension handling with a structured system that supports discovery, safe installation, and ordered management of extensions.

MarkEditMac/Modules/Sources/ExtensionCore · high confidence

A new QuickLookMac extension has been added to provide Quick Look previews for Markdown and related text files. The extension uses a sandboxed WebKit view to render content, supporting a wide range of Markdown UTIs (including standard, MarkEdit, Quarto, R Markdown, and others). It includes a context menu option to reset the Quick Look window size, which is now persisted across sessions via UserDefaults. The implementation isolates user scripts to the main frame and disables rich JavaScript and media features for performance and security in the sandboxed environment.

QuickLookMac · high confidence

Users can now manage extensions through a dedicated window that features tabs for Discover, Installed, and Updates. This interface supports searching, filtering, and viewing detailed metadata such as release notes, version history, and official badges. It also provides controls for installing, updating, and uninstalling extensions, with visual feedback for progress and system relaunch requirements.

MarkEditMac/Sources/Extension · high confidence

A new word completion feature has been added to the editor, providing a context-aware completion panel that suggests words as you type. The implementation includes a \TextCompletionContext\ class that manages the panel's visibility, appearance, and selection state, while intelligently positioning the popup near the cursor. The panel automatically adjusts its position to stay within the visible screen area, avoiding overlap with the macOS dock or menu bar, and prevents jarring flips during typing sessions. It also supports dynamic sizing based on the number of suggestions (capped at 25) and allows for tinted themes and localizable strings.

MarkEditMac/Modules/Sources/TextCompletion · high confidence

A new WebModuleBridge struct has been added to centralize access to various web bridge functionalities. This wrapper provides a single entry point to interact with features such as text completion, history management, line endings, selection, formatting, search, table of contents, API access, writing tools, and foundation models, simplifying how these capabilities are exposed and used within the web view context.

MarkEditKit/Sources/Bridge/Web · high confidence

Replaces the system's default file version interface with a new, custom-built FileVersionPicker designed to address performance issues. This change includes a new DiffKit module that wraps the JavaScript diff library to provide fast, client-side comparison of file versions (lines, words, or characters) without relying on external tools. Users will now experience a faster, more responsive version selection and diffing workflow within the editor.

MarkEditMac/Modules/Sources/FileVersion · high confidence

The MarkEditKit now exposes a new NativeModules component that facilitates communication between Swift and JavaScript. This change introduces a NativeBridge protocol and a NativeModules registry, enabling native modules to invoke JavaScript methods asynchronously via the invoke method. This provides a structured way for the editor's native layer to interact with web content, supporting the app's core editing features.

MarkEditKit/Sources/Bridge/Native · high confidence

Users can now navigate between document sections using keyboard shortcuts. The new module adds Ctrl+Mod+ArrowUp and Ctrl+Mod+ArrowDown bindings to move the selection to the previous or next heading, respectively. When jumping to a section, the editor saves the previous selection to allow navigation back, and scrolls the view to the heading (centering in typewriter mode or scrolling to start otherwise).

CoreEditor/src/modules/toc · high confidence

The MarkEdit project file has been updated to include a comprehensive set of new source files and framework dependencies, reflecting the integration of several new capabilities. This includes support for in-app auto-updating (via AppUpdater and UpdateInstaller.xpc), text completion, statistics views, and AppleScript/Shortcuts integration (via EvaluateJavaScriptIntent, CreateNewDocumentIntent, etc.). The project also now references frameworks for file versioning, text bundles, extensions management, and writing tools, alongside UI components for settings, quick look, and closed tab history.

MarkEdit.xcodeproj · high confidence

This change introduces a suite of Swift extensions for AppKit classes in the \AppKitExtensions/UI\ module to streamline UI development. Key additions include Markdown rendering support in \NSAlert\ via a new \markdownBody\ property, improved font handling with CSS weight mapping and recent family tracking in \NSFont\, and semantic color definitions in \NSColor\. The update also adds closure-based action handlers for controls, layer filter utilities, and helper methods for window titlebar introspection, search field bezel customization, and table view row animations.

MarkEditMac/Modules/Sources/AppKitExtensions/UI · high confidence

This update introduces a suite of new extension files in the AppKitExtensions/Foundation module to standardize common operations. Key additions include NSPasteboard extensions for improved pasteboard handling (such as sanitizing line endings and preferring plain text for source code), NSApplication extensions to fix NSOpenPanel re-validation issues on iCloud files, and NSWorkspace extensions to support opening a configurable list of terminal applications. The bundle extension now exposes version and user-agent strings, while NSDocument extensions provide utilities for managing file version history. Additional helpers cover URL handling, run-loop scheduling, and UI path rounding.

MarkEditMac/Modules/Sources/AppKitExtensions/Foundation · high confidence

MarkEdit now supports AppleScript automation, allowing users to control the application and interact with documents via scripts. The new AppleScript dictionary defines commands to evaluate JavaScript within documents and properties to access document source, selection, and rich text. Additionally, the app's localization strings have been updated to include new user-facing text for features like extension installation warnings, update notifications, and search index display, with translations provided for Simplified and Traditional Chinese.

MarkEditMac/Resources · high confidence

The Find panel has been re-implemented to support diacritic-insensitive search, allowing users to find text regardless of accent marks. The search field now includes a menu with options for case sensitivity, whole word, literal search, and regular expressions, and the search icon tints when options are active. Users can navigate through recent searches using arrow keys or the up/down commands, and keyboard navigation has been improved with Tab/Shift-Tab support for moving between find and replace fields, and Enter/Shift-Enter for navigating search results.

MarkEditMac/Sources/Panels/Find · high confidence

The editor now includes a suite of new commands for Markdown formatting, allowing users to toggle bold, italic, strikethrough, inline code, inline math, headings, blockquotes, and various list styles (bullet, numbered, and todo). It also supports inserting code blocks, math blocks, horizontal rules, hyperlinks, and tables via snippet templates. Additionally, a new content formatting command enables users to optionally insert a final newline and trim trailing whitespace from the document, with logic to preserve selections and avoid interfering with ongoing composition or autocomplete sessions.

CoreEditor/src/modules/commands · high confidence

This change introduces four new App Intents to MarkEditMac, enabling automation via the Shortcuts app. Users can now create new documents with optional filenames and initial content (CreateNewDocumentIntent), retrieve the content of the active file (GetFileContentIntent), update file content with options for whole-document or selection granularity and auto-saving (UpdateFileContentIntent), and evaluate JavaScript on the active document, including support for async JavaScript execution (EvaluateJavaScriptIntent).

MarkEditMac/Sources/Shortcuts/Intents · high confidence

The SharedUI module now includes three new SwiftUI extensions to support richer UI rendering. \Color\ gains a hex initializer for easier color definition. \ShapeStyle\ provides a static \spectrum\ method that generates a blue-to-orange linear gradient with configurable direction. \Text\ adds an initializer that automatically highlights occurrences of a search query with a specified tint color, background, and underline, facilitating the display of search results in the extensions UI.

MarkEditMac/Modules/Sources/SharedUI/Extensions · high confidence

The project now includes dedicated Xcode schemes to streamline development workflows: a 'screenshots' scheme that automatically kills lingering debug processes and sets the DEBUG\_TAKING\_SCREENSHOTS environment variable for consistent capture, language-specific schemes for Simplified and Traditional Chinese (zh-Hans, zh-Hant) to launch the app with the correct locale, and a QuickLookMac scheme configured to build and launch the QuickLook extension alongside the main app.

MarkEdit.xcodeproj/xcshareddata · high confidence

The Extensions window now supports installing extensions via deep links (using an ID to reveal the entry or a URL for unreviewed manual installs with a confirmation alert) and provides configurable update behaviors (Never Check, Show Available Updates, Ask Before Updating, or Update Automatically) that control whether updates are surfaced in the window, prompted via alert, or applied silently.

MarkEditMac/Sources/Extension/Core · high confidence

The completion module has been restructured into a new dedicated file that integrates CodeMirror's autocomplete engine with custom logic for Markdown-specific completions. Users now benefit from auto-completion for internal heading anchors (e.g., \#heading), relative file paths (e.g., /docs.md) including directory traversal, footnote references (e.g., ^footnote), and reference-style links (e.g., \[text\]\[ref\]). The system also respects IME composition states to prevent premature triggering and filters out specific keybindings like Option-Backtick on macOS to allow backtick insertion.

CoreEditor/src/modules/completion · high confidence

The CoreEditor bridge now includes a new nativeModule.ts file that creates a proxy for sending messages to the native layer. In release mode, messages are posted via window.webkit.messageHandlers, while in debug mode they are logged to the console. A corresponding webModule.ts interface is also introduced to define wrappers for invoking web functionality from native.

CoreEditor/src/bridge · high confidence

This change introduces a set of new Swift native modules in the MarkEditKit bridge layer to expose core editor capabilities, file system operations, and AI services to the web interface. EditorModuleCore now handles window lifecycle events (resize, move, close) and editor state notifications (idle, background color, viewport scale). EditorModuleAPI provides file management functions including saving, closing, creating, deleting, and moving files, as well as UI interactions like alerts, save panels, and context menus. EditorModuleFoundationModels integrates with Apple's FoundationModels framework to support language model sessions, availability checks, and streaming responses, including Private Cloud Compute support on newer OS versions. EditorModuleTranslation leverages the system Translation framework for text translation. EditorModuleCompletion and EditorModuleTokenizer use NaturalLanguage tokenizers to provide word-based text completion and tokenization for the editor.

MarkEditKit/Sources/Bridge/Native/Modules · high confidence

The application now includes a dedicated Settings UI with four tabs: Editor (font, themes, line numbers, invisibles, typewriter/focus modes, line wrapping, tab/indent behavior), Assistant (file formatting options like final newline and trailing whitespace, word completion sources, and inline predictions), General (appearance, new window behavior, quit window restoration, default filename extension, text encoding, and line endings), and Window (toolbar mode, tabbing mode, and transparency reduction). This provides users with centralized controls for these previously unexposed or less accessible preferences.

MarkEditMac/Sources/Settings · high confidence

The SharedUI module now includes a suite of new UI components to support the extension manager and theme previews. This adds SwiftUI views for actionable info bars, labeled progress indicators with ring animations, and search-style text highlighting. It also introduces AppKit views for custom bezels, hairline dividers, tinted material effect views, and segmented button groups, along with wrappers to embed SwiftUI content in AppKit table rows and cells.

MarkEditMac/Modules/Sources/SharedUI · high confidence

The SharedUI module now includes four new button components: \NonBezelButton\ (AppKit) provides a base class with modern rounded corners and custom focus ring support; \IconOnlyButton\ (AppKit) renders SF Symbols with configurable sizing and accessibility labels; \TitleOnlyButton\ (AppKit) displays text labels with optional font customization; and \PillButton\ (SwiftUI) offers capsule-shaped buttons in prominent (filled) or bordered styles, mimicking App Store aesthetics. These components standardize button appearance across the application.

MarkEditMac/Modules/Sources/SharedUI/Buttons · high confidence

This change introduces dedicated styling and interaction logic for various Markdown elements within the editor. Code blocks and inline code are now styled with monospace fonts and specific wrapper classes, while tables also adopt monospace rendering. Links (standard, reference, and footnotes) are now decorated and become clickable via Cmd/Ctrl+click to open or follow anchors, with a slight delay to prevent accidental activation. Task markers (checkboxes) are now interactive, allowing users to toggle their state with a click. Indentation for lists, blockquotes, and paragraphs is visually rendered using line decorations to align content correctly. Additionally, front matter blocks are styled, and preview buttons are added for Mermaid diagrams, KaTeX math, and GFM tables.

CoreEditor/src/styling/nodes · high confidence

The \CoreEditor/src/bridge/web\ directory now contains a comprehensive set of TypeScript modules (api, completion, config, core, format, foundationModels, history, lineEndings, search, selection, toc, writingTools) that expose the editor's capabilities to the web layer. This new bridge allows external applications to control editor settings (themes, fonts, read-only mode), perform text operations (insert, replace, formatting), manage search and selection, handle undo/redo history, and interact with AI features like text completion and writing tools.

CoreEditor/src/bridge/web · high confidence

The editor now includes a new word completion feature that suggests words from the document, the system dictionary, and spelling guesses, with a dedicated panel for accepting completions. Additionally, the editor view controller now exposes configuration methods for text settings such as font face, size, line wrapping, and smart quotes, allowing these properties to be adjusted programmatically or via settings.

MarkEditMac/Sources/Editor/Controllers · high confidence

A new SwiftLint plugin has been added to the MarkEditTools/Plugins/SwiftLint directory. This plugin integrates SwiftLint into the build process, running lint checks with strict mode and a specific configuration file (.swiftlint.yml) for each target. The plugin uses the XcodeBuildToolPlugin interface to execute SwiftLint as a build command, ensuring code style and quality checks are performed during compilation.

MarkEditTools/Plugins/SwiftLint · high confidence

The native bridge layer now exposes a comprehensive set of TypeScript interfaces that define how the editor communicates with the host application. This includes APIs for document management (saving, closing, creating, deleting, and versioning files), window lifecycle events (resize, move, close), and UI interactions (menus, context menus, alerts, text boxes). It also introduces support for AI-driven features via foundation model integration (session creation, response streaming), text completion requests, CJK-aware word tokenization, and system translation services. These interfaces establish the contract for the native side to implement these specific functionalities.

CoreEditor/src/bridge/native · high confidence

A new View extension is introduced to the TextCompletion module, providing a computed property that calculates the fitting size of a SwiftUI view. This capability enables the completion panel to dynamically adjust its dimensions based on its content, supporting the dynamic sizing behavior described in the associated commit.

MarkEditMac/Modules/Sources/TextCompletion/Extensions · high confidence

The application now includes a dedicated QuickLook view controller interface (Main.xib) and an empty localization strings file (Main.xcstrings) for the QuickLook extension. This establishes the UI structure and localization framework for the QuickLook preview functionality, replacing or supplementing previous 'Preview' terminology as indicated by the commit intent.

QuickLookMac/Base.lproj, QuickLookMac/mul.lproj · low confidence

This change introduces internal Swift extensions to support the visual presentation of the file version picker. It defines specific light and dark mode colors for added and removed text/backgrounds, and provides helper methods to generate attributed strings that display diff results with appropriate styling (such as strikethrough for removed lines and colored backgrounds for changes). These utilities are used to render the diff content and change counters within the picker interface.

MarkEditMac/Modules/Sources/FileVersion/Internal · high confidence

The front matter module now uses the official @codemirror/lang-yaml parser instead of a previous custom or third-party implementation. This change improves the accuracy of detecting and removing YAML front matter blocks by leveraging the parser's native node iteration, ensuring that front matter ranges are identified more reliably within the document structure.

CoreEditor/src/modules/frontMatter · high confidence

The editor's configuration module now provides a unified set of functions to manage runtime settings such as themes, fonts, line heights, and visibility options. Applying these changes immediately updates the visual styling and triggers necessary UI recalculations (like text metrics and gutter positions) to ensure the display reflects the new settings instantly. Additionally, toggling read-only mode now properly manages editor focus and dispatches state effects to enforce the restriction.

CoreEditor/src/modules/config · high confidence

The editor now supports configurable tab key behavior, allowing users to choose between inserting tabs, two spaces, four spaces, or increasing indentation. A key improvement is that pressing Tab always increases indentation when the cursor is near list marks or list items, ensuring consistent list formatting regardless of the global tab setting. Shift-Tab continues to decrease indentation.

CoreEditor/src/modules/indentation · high confidence

The event handling module now supports accepting code completions with comma and period keys, in addition to existing methods. It also improves WebKit IME (Input Method Editor) composition handling to prevent unwanted text deletion and scrolling issues. Additionally, the module leverages the native 'scrollend' event when available for more accurate scroll state notifications, and uses a safer method to retrieve the editor instance to handle potential null references during composition events.

CoreEditor/src/modules/events · high confidence

The editor now features improved input interception and formatting logic. Typing triple backticks (\\\`) automatically inserts a fenced code block on its own lines, while double backticks expand into a code block if two precede an empty cursor. Auto-character pairs (like \, \, \~, $) now wrap selected text, and typing suggestions are triggered contextually. The system also includes specific workarounds for WebKit IME composition bugs, prevents unwanted browser selection of line breaks, and defers native idle notifications to keep formatting and document synchronization consistent.

CoreEditor/src/modules/input · high confidence

The search module now supports diacritic-insensitive searching (e.g., matching 'cafe' with 'café') and allows users to configure custom search normalizers via \window.config.searchNormalizers\. Additionally, the search interface displays the current match index (e.g., '1 of 3') to improve navigation context, and the 'Select Next Occurrence' command now automatically scrolls newly selected matches into view for a smoother editing experience.

CoreEditor/src/modules/search · high confidence

The ExtensionCore module now includes an internal environment configuration that defines the filesystem locations for the extension registry (extensions.json), scripts, and the cached registry index. It also exposes the current app version, which is used to enforce minimum version requirements for extensions, and provides a debug directory for testing the update flow.

MarkEditMac/Modules/Sources/ExtensionCore/Internal · high confidence

The HTML language provider in the core editor has been stripped of its embedded JavaScript and CSS grammars. This vendor copy of @codemirror/lang-html now only includes the core HTML syntax, tag completion, and auto-closing features needed for Markdown editing, removing the ability to parse or highlight code inside \<script\> and \<style\> tags to reduce bundle size.

CoreEditor/src/@vendor/lang-html · high confidence

The QuickLook extension now features a custom scrolling strategy that overrides default event handling, allowing for single-click opening and more reliable dragging behavior within the preview. Additionally, a new setup guidance view is displayed when the preview is not yet prepared, prompting users to open MarkEdit to complete the configuration.

QuickLookMac/Extensions · high confidence

The lines module now implements more robust strategies for aligning line numbers and gutters with code content. It uses a ResizeObserver to snap gutter widths to whole pixels, preventing sub-pixel rendering artifacts like whitespace hiding letters. Additionally, it dynamically adjusts gutter padding and height to account for varying font sizes (such as Markdown headers) and ensures the active line gutter is correctly positioned, fixing issues where line numbers might shift or misalign due to spacers or layout changes.

CoreEditor/src/modules/lines · high confidence

The Writing Tools module now includes logic to ensure the editor selection covers the full line or entire document when activating tools, addressing issues where Apple's Writing Tools might randomly select only a portion of a line. Additionally, a background interval periodically re-selects the current line to prevent unintended selection drift during active use.

CoreEditor/src/modules/writingTools · high confidence

The settings window now features corrected cursor styling and a more robust form layout. A new extension for NSCursor addresses specific cursor style issues, while View extensions introduce helpers for building settings forms with better spacing, alignment, and picker styles, resolving previously tight or awkward UI elements.

MarkEditMac/Modules/Sources/SettingsUI/Extensions · high confidence

The editor now launches the WebKit network and web content processes eagerly and disables App Nap throttling, resulting in faster initial load times and smoother rendering. It also introduces heuristic detection to distinguish binary files from text, handles line endings correctly for pasted content, and provides a more robust fallback mechanism for decoding text files with non-UTF-8 encodings.

MarkEditCore/Sources/Extensions · high confidence

The text completion UI has been replaced with a new SwiftUI implementation that dynamically adjusts the panel width based on content and highlights the matching query text within each suggestion. The panel now uses the Observation framework for state management and features a scrollable list of completions with visual feedback for the selected item, including a tinted background and accent-colored selection highlight.

MarkEditMac/Modules/Sources/TextCompletion/Internal · high confidence

The Replace panel now uses a dedicated set of UI components: \EditorReplacePanel\ manages the layout and delegates for the replacement text field and action buttons, \EditorReplaceTextField\ provides a custom rounded bezel with multi-line support, and \EditorReplaceButtons\ renders the 'Replace Next' and 'Replace All' controls. This change restructures how the replace interface is rendered and handles keyboard navigation (Tab/Enter) within the panel.

MarkEditMac/Sources/Panels/Replace · high confidence

The FontPicker module has been replaced with a new SwiftUI implementation that provides a more native-looking interface for selecting fonts. Users can now quickly switch between system font families (Default, Monospaced, Rounded, Serif) via a menu, view recently used fonts, and access the full font panel. The picker displays the selected font name and size, supports keyboard-driven font size adjustments via a stepper, and respects system-wide font size changes.

MarkEditMac/Modules/Sources/FontPicker · high confidence

This update introduces a comprehensive refactoring of the application's core architecture, including a new safe mode for troubleshooting, a dedicated debug directory for crash logs, and a safer app termination and relaunch mechanism that properly handles unsaved drafts. It also adds support for global hot keys, improves document handling with a preloader to prevent race conditions, and implements runtime swizzling to fix macOS-specific performance regressions and menu crashes.

MarkEditMac/Sources/Main · high confidence

The main menu has been significantly reorganized to improve discoverability and add new capabilities. A new 'Developer' submenu has been added to the MarkEdit menu, providing direct access to debugging and maintenance actions such as 'Inspect Element', 'Open Documents Folder', 'Grant Folder Access', 'Launch Safe Mode', and 'Development Guide'. The 'File' menu now includes a 'New File from Clipboard' option (⌃⌘N) and a 'Reopen Closed Tab' command (⇧⌘T), alongside the existing 'Save All' feature. Additionally, a hidden 'settings.json' entry point has been added to the Preferences menu, accessible via ⇧⌘,, allowing advanced users to edit configuration files directly from the UI.

MarkEditMac/Base.lproj · high confidence

The vendored Markdown language support in CoreEditor now disables the automatic creation of non-tight lists (lists with blank lines between items) when pressing Enter, aligning with the preference to keep lists tight. Additionally, the section folding logic has been updated to only fold ATX-style headings (e.g., \# Heading) and leave Setext-style headings (underlined headings) unfolded, while ensuring empty sections remain foldable.

CoreEditor/src/@vendor/lang-markdown · high confidence

The editor now leverages native platform tokenization (e.g., NLTokenizer on Apple platforms) for word-based interactions, significantly improving accuracy for CJK languages. Double-clicking text now selects words using native logic, and Option+Arrow keys move the caret by word boundaries. Additionally, Backspace and Delete keys delete entire words when the Option key is held, providing more intuitive editing behavior for non-Latin scripts.

CoreEditor/src/modules/tokenizer · high confidence

The history module now exposes explicit undo and redo functions that bind to native application commands, ensuring the editor's undo stack behaves like native apps. It also introduces logic to track whether the document has unsaved changes: saving the document marks the current undo depth as 'clean', and the system detects 'dirty' status by comparing the current undo depth against the saved depth, while also recognizing when the user explicitly navigates the history stack via undo/redo actions.

CoreEditor/src/modules/history · high confidence

The application now features a new settings interface built with SwiftUI and AppKit, organized into a tabbed window layout. This update introduces a lightweight form builder for consistent UI structure and ensures the settings window respects the system's 'Reduce motion' accessibility preference by disabling window resizing and tab-switching animations when enabled. The implementation also includes fixes for proper window centering and cursor style handling within the settings environment.

MarkEditMac/Modules/Sources/SettingsUI · high confidence

The CoreEditor now includes explicit TypeScript interfaces for web-native communication and global editor context. New types such as WebFontFace, WebMenuItem, WebPoint, and WebRect define the structure for font styling, native menu items, and coordinate geometry passed between the web view and native layers. The global.d.ts file expands the Window interface to expose native modules for core functionality, text completion, tokenization, API access, foundation models, and translation, while also adding utility methods for extracting theme styles and highlight specifications.

CoreEditor/src/@types · high confidence

This change introduces several new view components for the editor interface: \EditorPanelView\ for the main panel container, \EditorSaveOptionsView\ to provide save and open panel options (file extension, text encoding, hidden files), \EditorStatusView\ to display line/column information with improved accessibility, and \EditorTextInput\ to abstract text actions like undo/redo/select-all across different text input implementations. Additionally, \EditorWebView\ now features a refined context menu that hides unnecessary WebKit items, adds custom search actions (Find Selection, Select All Occurrences), and conditionally includes text formatting options based on read-only mode.

MarkEditMac/Sources/Editor/Views · high confidence

A new FileDropHandler module has been introduced to standardize how dropped files are inserted into the editor. This change ensures that dropped files generate consistent Markdown links or image syntax, with specific logic to copy assets into text bundles when applicable and properly encode paths and escape special characters in link labels.

MarkEditMac/Modules/Sources/FileDrop · high confidence

The QuickLook preview mode now allows users to zoom in and out using trackpad pinch gestures, scaling the content between 1.0x and 2.5x while maintaining scroll position. Additionally, the extension implements custom scrollbar dragging logic that mirrors native behavior, allowing users to click and drag the scrollbar thumb or click outside the thumb to jump to a specific location in the document. These interactions are driven by mouse events forwarded from the native host, replacing previous scrolling limitations in the read-only preview.

CoreEditor/src/@quicklook · high confidence

The preview module has been re-implemented to render content (Mermaid diagrams, KaTeX math, and tables) inside a sandboxed iframe, improving isolation and security via a strict Content Security Policy. The preview now opens as a modal overlay with a fade-in animation, respects the system's 'Reduce motion' accessibility setting, and dynamically syncs with the editor's color theme. The UI includes a native-like close button, proper keyboard focus management, and scroll-aware styling for better visual integration.

CoreEditor/src/modules/preview · high confidence

The 'Reopen Closed Tab' command (Cmd+Shift+T) has been re-implemented to better respect the user's window tabbing preferences. When reopening a previously closed tab, the editor now intelligently decides whether to open the file as a new standalone window or as a tab within an existing window, based on the configured tabbing mode (disallowed, preferred, or automatic). The implementation also ensures that the reopened tab is inserted at the correct position within the tab group and handles edge cases where automatic window tabbing might interfere with the user's intent.

MarkEditMac/Sources/Main/Application · high confidence

The math module in the CoreEditor has been substantially rewritten to improve the parsing of block math equations (delimited by $$). This change introduces a new \MathInput\ wrapper and a \parseTeX\ mixed parser that overlays TeX syntax highlighting onto the content between delimiters. The parser now strictly requires closing \$$\ delimiters for block math, handling multi-line content and nested markers more robustly than the previous implementation.

CoreEditor/src/modules/math · high confidence

The editor now uses the Lezer syntax tree to calculate paragraph counts and exclude comments from statistics. This change ensures that comment blocks (including HTML-style comments within Markdown) are ignored when counting paragraphs and are stripped from readable content outputs, providing more accurate text metrics for users.

CoreEditor/src/modules/lezer · high confidence

The auto-generated WebKit bridge layer has been updated to expose new editor capabilities and refine existing ones. Users can now configure diacritic-insensitive search via the \SearchOptions\ struct, and the search counter now reports the current index for better navigation feedback. The configuration bridge adds support for smart quotes, inline prediction acceptance, and text completion. Additionally, the formatting bridge now exposes options to control final newline insertion and trailing whitespace trimming, while the history bridge introduces a method to mark content as clean.

MarkEditKit/Sources/Bridge/Web/Generated · high confidence

The Xcode scheme files for MarkEditCore, MarkEditKit, and MarkEditMac modules have been updated to set the LastUpgradeVersion to 2650, reflecting the project's migration to Xcode 16. Additionally, the ModulesTests scheme has been updated to version 1.7 with a LastUpgradeVersion of 2700, and its build action now specifies 'Automatic' for build architectures. These changes ensure the build schemes are correctly configured for the current development environment and toolchain.

MarkEditCore/.swiftpm, MarkEditKit/.swiftpm, MarkEditMac/Modules/.swiftpm · high confidence

The embedded diff.js resource has been updated to a newer build, introducing changes to how whitespace and newlines are processed during file comparisons. Specifically, the logic for the \newlineIsToken\ option has been reverted to improve readability in diff outputs, and the tokenization strategy for whitespace-sensitive comparisons has been refined to better handle trailing whitespace and line endings. This results in more accurate and readable diffs for users comparing text files with varying whitespace or newline conventions.

MarkEditMac/Modules/Sources/DiffKit/Resources · high confidence

The generated native bridge modules in MarkEditKit have been updated to align with markedit-api v0.8.0. This refreshes the interface definitions and bridge implementations for core editor operations, text completion, tokenizer, translation, and foundation models, ensuring the native layer correctly handles the latest API contract changes.

MarkEditKit/Sources/Bridge/Native/Generated · high confidence

The editor now includes a vendored copy of the CodeMirror history module (history.ts), bringing standard undo and redo capabilities (including selection undo/redo and transaction isolation) directly into the CoreEditor commands. This change integrates the history state management and key bindings into the editor's command layer, ensuring that undo/redo operations are handled locally within this vendor directory rather than relying on external or implicit implementations.

CoreEditor/src/@vendor/commands · high confidence

Added concurrency and reliability tests for core editor modules; Added test coverage for core editor modules; Added test utilities and Jest environment setup for CoreEditor; Added tests for EditorDocument lifecycle and printing; Added unit tests for MarkEditCore binary detection, encoding, and messaging; Initial test suite for CoreEditor.

The CoreEditor module has been upgraded to use Yarn version 4.18.0. This change updates the package manager used for dependency resolution and installation within the editor's build environment.

CoreEditor · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 58 (+0.3)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 93 → 93 (-0.1)
• Architecture 78 → 79 (+1.4)
• Maturity 45 → 45 (-0.1)
• Readiness 56 → 53 (-3.2)
• Security 91 → 87 (-3.3)
• Performance 100 (new)

• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no contributor guidance (README.md)
• Documentation: no usage examples (README.md)
• Hotspot: CoreEditor/src/@vendor/lang-html/html.ts (CoreEditor/src/@vendor/lang-html/html.ts)
• Hotspot: CoreEditor/src/modules/completion/index.ts (CoreEditor/src/modules/completion/index.ts)
• Hotspot: MarkEditMac/Sources/Editor/Views/EditorWebView.swift (MarkEditMac/Sources/Editor/Views/EditorWebView.swift)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• MethodTooLong: AppDelegate.saveGrantedFolderAsBookmark (MarkEditMac/Sources/Main/Application/AppDelegate.swift)

• Ambiguous naming for file retrieval operations. getFileContent and getFileObject appear to perform the same domain operation (retrieving file data) but return different types (String vs String? or potentially different semantic meanings like raw bytes vs decoded text). Without distinct documentation, these names are confusingly similar.
• ExtensionRelease.pageURL (cognitive 18) (MarkEditMac/Modules/Sources/ExtensionCore/ExtensionRegistry.swift)
• ExtensionRelease.pageURL (cyclomatic 17) (MarkEditMac/Modules/Sources/ExtensionCore/ExtensionRegistry.swift)
• ExtensionsRowView.body (cognitive 20) (MarkEditMac/Sources/Extension/ExtensionsRowView.swift)
• ExtensionsRowView.body (cyclomatic 16) (MarkEditMac/Sources/Extension/ExtensionsRowView.swift)
• High CVE: [GHSA redacted] (CoreEditor/yarn.lock)
• Hotspot: CoreEditor/src/core.ts (CoreEditor/src/core.ts)
• Hotspot: CoreEditor/src/modules/commands/formatContent.ts (CoreEditor/src/modules/commands/formatContent.ts)
• Hotspot: MarkEditMac/Sources/Extension/ExtensionsRowView.swift (MarkEditMac/Sources/Extension/ExtensionsRowView.swift)
• Hotspot: MarkEditMac/Sources/Extension/ExtensionsWindowController.swift (MarkEditMac/Sources/Extension/ExtensionsWindowController.swift)
• Low cohesion: AppDocumentController (LCOM4 4) (MarkEditMac/Sources/Main/AppDocumentController.swift)
• Low cohesion: Data (LCOM4 6) (MarkEditKit/Sources/EditorTextEncoding.swift)
• Low cohesion: EditorStatusView (LCOM4 4) (MarkEditMac/Sources/Editor/Views/EditorStatusView.swift)
• Low cohesion: NSMenu (LCOM4 4) (MarkEditMac/Sources/Extras/NSMenu+Extras.swift)
• Low cohesion: NSMenuItem (LCOM4 6) (MarkEditMac/Sources/Editor/Views/EditorWebView.swift)
• Low cohesion: NSView (LCOM4 6) (MarkEditMac/Modules/Sources/AppKitExtensions/UI/NSView+Extension.swift)
• Low cohesion: NSWindow (LCOM4 6) (MarkEditMac/Modules/Sources/AppKitExtensions/UI/NSWindow+Extension.swift)
• Low cohesion: String (LCOM4 5) (MarkEditCore/Sources/Extensions/String+Extension.swift)
• Low cohesion: View (LCOM4 6) (MarkEditMac/Modules/Sources/FontPicker/FontPicker.swift)
• Low cohesion: WKWebView (LCOM4 4) (MarkEditCore/Sources/Extensions/WebKit+Extension.swift)
• …and 15 more

• 22 commits — 18 feature/other, 4 fixes

• CoreEditor/src — 12 commits
• MarkEditKit/Sources — 3 commits
• MarkEditMac/Sources — 3 commits
• (root) — 1 commit
• CoreEditor/.yarn — 1 commit
• MarkEdit.xcodeproj/project.pbxproj — 1 commit
• MarkEditMac/Resources — 1 commit

• fix: Fix crash when printing from Finder (#1765)
• fix: Fix unintentional completion panel dismiss (#1766)
• fix: Improve the codemirror scrollbar fix (#1763)
• fix: [macOS 27] Fix scroll position issues for preview (#1769)
• change: Add general.disableDebugFiles (#1773)
• change: Bump version numbers
• change: Compress icon artwork (#1760)
• change: Enable Swift 6 concurrency for Quick Look (#1761)
• change: Handle nested cm editors properly (#1767)
• change: Improve built-in preview UI details (#1757)
• change: Improve rewritten preview renderers (#1753)
• change: Isolate user scripts to main frame only (#1749)
• change: Narrow the wasScrolledToBottom workaround (#1750)
• change: Progressively migrate to strict concurrency (#1759)
• change: Re-implement preview renderers (#1748)
• change: Resolve MarkEdit.moveFile partial failures (#1772)
• change: Rework the math parser (#1752)
• change: Split editor creation and selection restoration (#1756)
• change: Style table delimiters (#1754)
• change: Two-pass initial scroll restoration (#1758)
• …and 2 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

MarkEdit-app/MarkEdit was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.