Migrate Logseq notes to local Markdown on Mac

Logseq emerged as one of the most prominent open-source tools for networked thought, attracting developers, academics, researchers, and knowledge workers who wanted the graph-based power of Roam Research combined with local file ownership.

By building on top of local Markdown and Org-mode files on disk, Logseq proved that personal knowledge management did not require trusting proprietary cloud silos. Users embraced Logseq’s daily journals, bidirectional [[WikiLinks]], flashcards, and nested outliner hierarchy.

However, as personal knowledge bases grew over time, many Logseq users encountered significant structural friction:

First, the dogmatic outliner constraint. In Logseq, everything is a bullet point. Every idea, paragraph, sentence, and heading is prefixed with an outliner dash (- ). While outliners excel for rapid task capture and hierarchical brainstorming, they make long-form writing—essays, documentation, customer proposals, and technical briefs—awkward and visually disjointed.

Second, the Logseq 2.0 database rewrite and the loss of file transparency. To solve performance bottlenecks in parsing thousands of raw text files with ClojureScript, Logseq has shifted toward a centralized database architecture (Logseq DB / 2.0). In this new model, notes are no longer simple, transparent text files modified live on disk; they are stored inside a database engine. For users who chose Logseq specifically for plain-text file sovereignty, this shift fundamentally alters the value proposition.

Third, proprietary block metadata clutter. Logseq litters Markdown files with internal metadata tags: id:: 63b9f8..., collapsed:: true, heading:: true, filters:: [...]. When opened in standard text editors, Finder Quick Look, or command-line tools, these files appear cluttered with noisy machine attributes rather than clean, human-readable prose.

Fourth, heavy Electron resource usage and slow indexing. Logseq’s ClojureScript-over-Electron stack can suffer from sluggish startup times, heavy battery consumption on Apple Silicon MacBooks, and periodic graph re-indexing delays on large repositories.

Migrating your Logseq graph to clean CommonMark Markdown (.md) in Oyma restores the simplicity of pure documents: delivering the fluid speed of a native macOS application, pristine typography, associative knowledge graphs, and permanent local sovereignty.

The architectural chasm: outliner blocks vs native documents

Understanding the difference between Logseq’s outliner structure and Oyma‘s document model is essential for a smooth migration:

1. Logseq’s outliner paradigm

• Bullet-first atomic blocks: Every entry is an indented list item. Pressing Enter creates a new bullet rather than a new paragraph.
• Heavy property annotations: Block properties (id::, scheduled::, deadline::) are injected directly below bullet text.
• Dynamic Datalog queries: Pages often rely on dynamic Clojure queries ({{query ...}}) that only execute within Logseq’s custom runtime.
• Namespace file naming: Subpages use URL-encoded slashes in filenames (e.g., projects%2Fapollo.md), creating unwieldy filenames on macOS.

2. Oyma‘s document-first architecture

• Natural, flexible document structure: Write standard paragraphs, headings, bullet lists, or numbered sequences without being forced into an eternal outline.
• Clean CommonMark standard: Zero proprietary syntax tags. Your notes are 100% portable, standard Markdown files.
• High-performance native macOS engineering: Instant launch, minimal memory footprint, and sub-50ms search indexing powered by SQLite FTS5 on Apple Silicon.
• Integrated botless meeting capture: Transcribe Zoom, Google Meet, and Teams calls on-device using ScreenCaptureKit and Whisper without clunky plugins.

Comprehensive transfer matrix: what moves from Logseq

Because Logseq already uses local files, migrating to Oyma is exceptionally clean and requires no loss of text or media:

Logseq Feature	Conversion Status	Result in Oyma & Local Storage
Page-level [[WikiLinks]]	Clean	Fully preserved; bidirectional links and backlinks work natively in Oyma.
Standard Markdown headers	Clean	Converted cleanly from outliner headings into CommonMark #, ##, ### headers.
Body text & lists	Clean	Indented bullets remain functional, or can be converted to standard document paragraphs.
Journal / Daily notes	Clean	journals/ notes carry over seamlessly with dates intact.
Embedded images & PDFs	Clean	Kept in assets/; images render inline and PDFs remain fully accessible.
Hashtags (#tag)	Clean	Preserved as tags and searchable via instant full-text search.
Block properties (id::, etc.)	Partial	Machine attributes can be stripped with a clean regex or preserved as plain text.
Block references (((uuid)))	Partial	Resolved into human-readable text or converted to standard section heading anchors.
Datalog query blocks	Unsupported	Replaced by instant full-text search, tag browsing, and interactive Graph View.

Step-by-step migration playbook: from Logseq to Oyma

Follow these steps to clean and mount your Logseq graph in Oyma:

Step 1: Copy your Logseq graph folder

1. In Logseq, click your graph name in the top left to see its filesystem location.
2. In Finder, navigate to that directory (for example, ~/Documents/Logseq/Personal).
3. Duplicate this folder to create a clean migration working copy:

cp -r ~/Documents/Logseq/Personal ~/Documents/Notes/Logseq-Vault

Step 2: Clean up Logseq block properties and metadata

Logseq frequently leaves id::, collapsed::, and heading:: attributes in Markdown files. You can strip these cleanly across your entire vault using a simple Python script:

#!/usr/bin/env python3
import os
import re

VAULT_DIR = os.path.expanduser("~/Documents/Notes/Logseq-Vault")

# Regex to match Logseq block properties
PROPERTY_REGEX = re.compile(r"^\s*(id|collapsed|heading|created_at|updated_at)::\s*.*$\n?", re.MULTILINE)

def clean_file(path):
    with open(path, "r", encoding="utf-8") as f:
        content = f.read()
    
    cleaned = PROPERTY_REGEX.sub("", content)
    
    if cleaned != content:
        with open(path, "w", encoding="utf-8") as f:
            f.write(cleaned)

for root, _, files in os.walk(VAULT_DIR):
    for file in files:
        if file.endswith(".md"):
            clean_file(os.path.join(root, file))

print("Logseq block properties cleaned successfully!")

Step 3: Optional: Convert top-level bullets into standard paragraphs

If you prefer reading your notes as traditional flowing documents rather than endless bullet lists, you can unindent top-level list items:

#!/usr/bin/env python3
import os
import re

VAULT_DIR = os.path.expanduser("~/Documents/Notes/Logseq-Vault")

def flatten_bullets(path):
    with open(path, "r", encoding="utf-8") as f:
        lines = f.readlines()
    
    new_lines = []
    for line in lines:
        # If line starts with top-level dash, strip the dash and space
        if line.startswith("- "):
            new_lines.append(line[2:])
        else:
            new_lines.append(line)
            
    with open(path, "w", encoding="utf-8") as f:
        f.writelines(new_lines)

for root, _, files in os.walk(VAULT_DIR):
    for file in files:
        if file.endswith(".md"):
            flatten_bullets(os.path.join(root, file))

print("Top-level bullets flattened into standard paragraphs!")

Note: If you love the outliner bullet aesthetic, you can skip this step entirely; Oyma renders standard Markdown bullet lists beautifully with full folding support.

Step 4: Open your vault in Oyma

1. Launch Oyma on your Mac.
2. In the welcome dialog, click Open vault (or press ⌘O).
3. Select your cleaned directory (~/Documents/Notes/Logseq-Vault).

Oyma instantly mounts your knowledge base:

• All pages, daily journals, and assets appear in the sidebar.
• Bidirectional links ([[WikiLinks]]) connect your notes automatically.
• Interactive Graph View displays your conceptual clusters with butter-smooth 60fps animations.
• Fast full-text search indexes your thousands of blocks in milliseconds.

What Oyma adds to your Logseq workflow

Migrating from Logseq to Oyma retains the core benefits of local-first networked thought while dramatically improving everyday usability:

1. Hybrid freedom: outliner lists and rich long-form prose

In Oyma, you are never locked into a single writing mode. Use nested lists and task checkboxes when outlining project specs or sprint tasks, and switch seamlessly to expansive, flowing prose when writing technical documentation, customer narratives, or blog posts.

2. High-performance spreadsheet tables

Logseq’s tables were rudimentary Markdown text or complex query views. Oyma brings spreadsheet-like tables with keyboard cell traversal (Tab/Enter), formula support, column sorting, and instant copy-pasting from Excel and Numbers—all serialized to standard GFM Markdown on disk.

3. Native botless meeting capture and transcription

Knowledge workers spend hours each day in meetings. While Logseq required manual note-taking or third-party web transcription services, Oyma integrates on-device audio recording via macOS ScreenCaptureKit. Capture meeting audio without bots, transcribe it locally with Whisper on the Apple Neural Engine, and extract structured action items directly into your daily note.

4. Native macOS design and zero-lag performance

Say goodbye to sluggish Electron UI lag and graph re-indexing delays. Oyma is built with native macOS craftsmanship: silky-smooth scrolling, instant file switching, and zero cloud background sync overhead.

Keep your graph, upgrade your experience

Your Logseq graph represents months or years of thoughtful knowledge curation. Moving to Oyma does not mean starting from scratch—it means unlocking the full potential of your notes in an environment designed for speed, beauty, and permanent local ownership.

Open your Logseq vault in Oyma today and experience the next generation of personal knowledge management on macOS.

What transfers from Logseq to local Markdown

Migrating from Logseq to sovereign Markdown (.md) preserves your core intellectual property while changing how formatting blocks are stored. Here is our empirically tested fidelity matrix:

Step-by-step migration procedure

Follow this sequence to export your Logseq library safely and open it in Oyma without data loss:

1. Locate your existing Logseq graph folder in Finder

   In Logseq, click your graph name in the top-left sidebar to view its filesystem path. Open Finder and navigate to this directory (typically located in ~/Documents/Logseq or your user home directory). The folder will contain `pages/`, `journals/`, and `assets/` subdirectories.

2. Back up your graph and normalize outliner bullets

   Create a copy of your graph directory. Because Logseq prepends every line with an outliner dash (`- `), decide whether to keep bulleted outlines or run a simple Python or sed script to unindent top-level paragraphs into flowing prose for long-form reading.

3. Clean up proprietary block properties and UUID metadata

   Remove Logseq internal attributes such as `id:: [uuid]`, `collapsed:: true`, and `heading:: true`. If you have namespaced pages containing slashes (e.g., `clients%2Facme.md`), rename them or organize them into corresponding subfolders.

4. Open the folder directly in Oyma

   Launch Oyma, select 'Open vault', and select your cleaned Logseq directory. Oyma instantly scans all pages, indexes your bidirectional links, builds an offline SQLite search index, and presents your knowledge base in our fluid live-preview editor.

Known conversion gaps and practical workarounds

Every proprietary note system utilizes features that have no 1:1 equivalent in plain Markdown. Here is how to navigate Logseq's structural limitations:

• Outliner-first bullet structure: Logseq enforces an outliner paradigm where every paragraph is a bullet point; traditional long-form prose requires converting dashes to paragraphs.
• Datalog dynamic queries: Complex `{{query (and [[project]] (task marker))}}` blocks rely on Logseq's internal Clojure database and do not render natively in standard Markdown editors.
• Block-level UUID references: Links pointing to specific bullet UIDs (`((62a1b2c3...))`) cannot resolve dynamically without specialized parser mapping.

Frequently asked questions

Does Logseq already store notes in Markdown format?

Yes, Logseq 0.10 and earlier store pages as local `.md` files. However, every single line begins with a list bullet (`- `), and files are heavily annotated with proprietary block properties (`id::`, `collapsed::`, `heading::`). Migrating involves cleaning these block markers and deciding whether to keep bullet lists or convert to standard flowing document prose.

What is happening with Logseq 2.0 and the database rewrite?

Logseq is transitioning from a plain-text file-based architecture to a centralized SQLite database model (Logseq 2.0 / DB version). While this improves query speed in Logseq, it sacrifices file system transparency and plain-text file interoperability. Migrating to Oyma ensures your knowledge remains 100% file-based, open, and permanently sovereign.

How are Logseq's [[WikiLinks]] handled in Oyma?

Bidirectional `[[WikiLinks]]` work identically in Oyma. You can navigate between linked concepts, explore incoming backlinks, and visualize your entire graph interactively without changing your link syntax.

Can I keep my daily journals from Logseq in Oyma?

Absolutely. All files in your Logseq `journals/` directory carry over seamlessly. Oyma's fast search, live preview, and daily note workflows allow you to continue your journaling habit without interruption.