Get AI summaries of any video or article — Sign up free
Logseq - A Roam Research Alternative for Notes / PKM / To Do / Journal thumbnail

Logseq - A Roam Research Alternative for Notes / PKM / To Do / Journal

Ed Nico·
5 min read

Based on Ed Nico's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Logseq stores notes locally in an outliner format while syncing them to GitHub as a backup.

Briefing

Logseq positions itself as a Roam Research-style personal knowledge management tool that keeps notes in a local outliner while also syncing them to GitHub for backup. The pitch is straightforward: avoid losing work to siloed folders or fragile workflows, and instead build a network of linked notes that can be navigated like a wiki.

Setup starts with connecting Logseq to GitHub. After authorizing access, Logseq requests a GitHub personal access token. The transcript walks through generating that token in GitHub’s developer settings, emphasizing that the token value must be copied immediately because it can’t be viewed again. With the token in place, Logseq asks which repository should store the notes. A new private repository can be created (no README needed), and the repository link is used so Logseq can clone and begin syncing. Once connected, a green indicator confirms that all notes are syncing to GitHub, and the journal-style pages appear by date.

In day-to-day use, Logseq’s core interface behaves like an outliner: typing creates notes, indentation creates structure, and sections can be focused on by collapsing or selecting a specific “knot” (a note block). As new entries are added to today’s page, they appear immediately, and the system supports expanding and collapsing at multiple levels.

The standout feature is backlinking and transclusions—mechanisms that create relationships between notes without forcing everything into a strict hierarchy. Instead of burying ideas inside nested folders, users can link concepts together so reviewing one page leads to related pages. The transcript demonstrates this with a “fitness” example: typing a bracketed link (e.g., [[fitness]]) turns a term into a clickable page, and subsequent text can populate that page. Clicking the link navigates to the linked note, while shift-click opens it in a side view for editing alongside the current page. This reduces the friction of jumping back and forth to find the right place to write.

Transclusions add another layer: using an embed block (via a slash command) can insert a referenced section—such as “my goals are”—directly into another page. Editing the embedded content updates the source page, letting users reuse structured snippets without duplicating work.

Logseq also supports practical workflows: a “to-do list for a now and later” pattern where unfinished items roll forward to the next day, plus date-based navigation using commands for yesterday and tomorrow. Pages can be created on demand through search (e.g., creating a “how to take notes” page when it doesn’t exist yet), and search can surface all references to a term across existing notes.

Finally, the transcript highlights safety and visibility. Notes are exported in a markdown-style format into the GitHub repository, and the interface provides tools like recent pages, a page graph showing which pages link to which, theme switching, and command help. The overall takeaway is that linking and transclusions keep information findable over time, while GitHub syncing provides a durable backup for the growing network of notes.

Cornell Notes

Logseq combines an outliner-based note system with wiki-style linking so ideas don’t get trapped in rigid folder hierarchies. Setup centers on GitHub syncing: users authorize Logseq with GitHub, generate a personal access token, and point Logseq to a private repository where notes are stored and synced. In daily use, notes appear as date-based journal pages, while “knot” blocks can be focused, collapsed, and expanded. Backlinks and transclusions let users connect related notes via links (e.g., [[fitness]]) and embed reusable sections (via an embed block) that stay editable in the source. A now/later to-do workflow and date commands (yesterday/tomorrow) help tasks and entries roll forward until completed.

How does Logseq prevent notes from becoming “siloed” in hierarchical folders?

It relies on backlinking and transclusions rather than forcing everything into a strict tree. When a term is turned into a link (for example, typing [[fitness]]), Logseq creates or opens a dedicated page for that concept. Clicking the link navigates to the related note, and reviewing linked pages works like a Wikipedia-style trail. This means “eating,” “sleeping,” and “fitness” can all connect to each other even if they don’t fit neatly into one folder path.

What’s the practical workflow difference between a normal link and a transclusion in Logseq?

A normal link creates navigation: clicking the linked page takes the user to that page (and shift-click can open it on the side for simultaneous editing). A transclusion (inserted via an embed block slash command) pulls content—like a block titled “my goals are”—into another page. When the embedded block is edited and the user clicks out, the changes update the original source page, avoiding duplicated text.

How does GitHub syncing work in the setup described, and why does it matter?

Logseq is authorized to access GitHub, then it requests a GitHub personal access token. The transcript emphasizes generating the token in GitHub developer settings, copying the token value immediately because it can’t be retrieved later, and enabling required scopes (including repo and admin org). After selecting a target repository (created as private in the example), Logseq clones it and begins syncing. A green sync indicator confirms notes are being backed up, reducing the risk of losing content.

What does the “now and later” to-do system do when tasks aren’t completed?

Tasks can be written under a now/later to-do structure. Items like “need to eat” or “need to sleep” appear as to-dos; if they aren’t checked off, they carry forward to the next day. Completed items are removed from “now,” since they’re marked done, keeping the daily list focused.

How can users create new pages and find related notes quickly?

Users can create pages on demand through the search bar. If a page doesn’t exist yet (e.g., searching for “how to take notes”), selecting it creates the page. Searching within an existing page (like “fitness”) can surface references such as “today I did some fitness,” showing that linked terms and references are discoverable quickly. The interface also includes an “all files” and “all pages” view, where journal months and separate page contents are organized.

Review Questions

  1. What steps are required to connect Logseq to GitHub, and what information must be saved immediately during token creation?
  2. Explain how backlinks and transclusions differ, using the fitness example and the embedded “my goals are” block.
  3. How does Logseq handle incomplete now/later tasks across days?

Key Points

  1. 1

    Logseq stores notes locally in an outliner format while syncing them to GitHub as a backup.

  2. 2

    GitHub setup requires authorizing Logseq, generating a personal access token, and selecting a target repository for syncing.

  3. 3

    Backlinking turns concepts into navigable pages so notes form a web rather than a rigid folder tree.

  4. 4

    Transclusions let users embed editable blocks from one page into another without duplicating content.

  5. 5

    A now/later to-do workflow carries unfinished tasks forward to the next day and removes items when marked done.

  6. 6

    Date-based commands and journal pages support quick retrieval of yesterday/tomorrow entries and related notes.

Highlights

A green sync indicator confirms that all notes are being pushed to the chosen GitHub repository, turning personal notes into a durable, versioned backup.
Typing [[fitness]] creates a clickable page and links it into the current context, enabling wiki-like navigation across ideas.
Using an embed block (slash command) inserts a reusable section that remains editable—changes propagate back to the source block.

Topics

Mentioned