Logseq User Guide

Logseq is a privacy-first, local-first platform for knowledge management, note-taking, and collaboration. Your notes are stored as an outliner — every line is a bullet (a block) that you can nest, link, tag, and query. Everything lives on your own device by default, in open formats, so your knowledge stays yours.

This guide covers everything you can do with Logseq: capturing notes, linking ideas, managing tasks, querying your knowledge base, annotating PDFs, reviewing flashcards, extending the app with plugins, and driving your graph from the command line. It is written against Logseq 2.0.1 (the "Database version").

Note

Logseq is offered as a desktop app (macOS, Windows, Linux), a mobile app (iOS, with Android in development), a web app, and a command-line tool. Most of this guide applies to all of them; platform-specific notes are called out where they matter.

1. Quick Start

Three steps to your first note:

1. Download and install Logseq for your platform (see Installation).
2. Open the app and create or open a graph — your personal knowledge base.
3. Start writing. Type into today's journal. Press Enter for a new bullet, Tab to indent.

- Met with Sarah about the [[Q3 Roadmap]] #meeting
  - She wants the mobile work prioritized
  - TODO Draft the revised timeline

That tiny snippet already uses three of Logseq's core ideas: a page reference ([[Q3 Roadmap]]), a tag (#meeting), and a task (TODO). Each one becomes a connection you can navigate and query later.

Tip

You don't have to "file" notes into folders. Just write into the daily journal and link liberally with [[ ]] and #. Logseq builds the structure for you — every linked page automatically collects everything that references it.

2. Core Concepts

Logseq works differently from a traditional notes app. Five ideas explain almost everything.

Graphs

A graph is a self-contained knowledge base. In Logseq 2.0 there are two kinds:

• DB graphs (the default in 2.0) — stored in a local SQLite database. Faster, support a richer data model (typed properties, tags as first-class nodes, tasks as structured data), and can sync across devices via RTC.
• File graphs (legacy) — stored as plain Markdown or Org-mode files in a folder on disk. Maximum portability and longevity.

Important

The DB version is in beta, and its mobile app and RTC sync are in alpha. Data loss is possible. Keep automated backups and consider using a dedicated test graph before moving important notes.

Blocks and the outliner

Every piece of content is a block — a bullet. Blocks nest infinitely, which is what makes Logseq an outliner rather than a document editor:

- Project Apollo
  - Goals
    - Land by Q4
    - Stay under budget
  - Risks
    - Vendor lead times

You restructure your thinking by indenting (Tab), outdenting (Shift+Tab), and dragging bullets. Collapsing a parent hides its children, so a long outline stays scannable.

References and the power of backlinks

When you write [[Project Apollo]] anywhere, Logseq creates (or links to) a page called Project Apollo. Open that page and you'll see a Linked References section at the bottom listing every block, across your whole graph, that mentions it. This is the heart of Logseq: you never have to remember where you wrote something — the page gathers its own references automatically.

• [[Page name]] — a page reference.
• #tag — a tag (a lightweight page reference; #[[Two words]] for multi-word tags).
• ((block content)) or the block-reference picker — a block reference to a specific bullet.

Properties

Properties attach structured data to a block or page using key:: value:

- Dune
  author:: [[Frank Herbert]]
  rating:: 5
  status:: read

In DB graphs, properties are typed (text, number, date, node reference, checkbox, and more) and can hold one or many values. Properties power queries — you can ask "show me every book with rating 5" and get a live table.

3. Installation

Desktop

Tip

The fastest path is the official download page. Pick the installer for your operating system.

macOS

1. Download the .dmg from the latest release.
2. Open it and drag Logseq to your Applications folder.
3. Launch it. On first run, approve the security prompt (Logseq is notarized).

Windows

1. Download the .exe installer from the latest release.
2. Run it and follow the prompts.
3. Logseq updates itself automatically when new releases ship.

Linux

Use the automated installer script for the smoothest experience:

# Download and run the installer (system-wide)
curl -fsSL https://raw.githubusercontent.com/logseq/logseq/master/scripts/install-linux.sh | bash

# Install a specific version
curl -fsSL https://raw.githubusercontent.com/logseq/logseq/master/scripts/install-linux.sh | bash -s -- 0.10.14

# User-specific installation (no root required)
curl -fsSL https://raw.githubusercontent.com/logseq/logseq/master/scripts/install-linux.sh | bash -s -- --user

AppImage, Snap, and .zip builds are also published on the releases page.

Note

To try the newest DB version desktop builds before they reach the stable channel, download a build from the nightly release.

Mobile

The DB version ships a new mobile app, currently on iOS (Android is in development). It provides most of the desktop features. The alpha is invite-based via the project's sign-up form; check the project README for the current link.

Web

You can run Logseq entirely in a browser:

• The hosted DB test build lives at https://test.logseq.com/.
• You can self-host the web app with Docker (see the Admin Guide).

Warning

The web app uses the browser File System Access API to read and write a local folder. It requires a compatible browser (Chromium-based), and remote access requires HTTPS.

Command-line interface (CLI)

The logseq CLI is a Node.js program for scripting and automating your DB graphs. It is distributed as the logseq npm package. See The Logseq CLI for full usage.

4. Your First Graph

Creating or opening a graph

When Logseq starts, you choose a graph. For a DB graph, create a new one and give it a name (for example, personal). For a legacy file graph, point Logseq at a folder; it will read existing Markdown/Org files and watch that folder for changes.

Tip

Keep one main graph for everything. Logseq's linking makes a single large graph more useful than many small ones — connections only form within a graph.

The interface at a glance

• Left sidebar — navigation: Journals, your favorite/recent pages, and the graph switcher.
• Main area — the page you're editing (the journal by default).
• Right sidebar — a scratch space where you can pin pages, blocks, and search results side-by-side with your main view.
• Toolbar / top bar — global search, the command palette, settings, and graph view.

Journals: write first, organize never

The journal is today's page, named by date. It's the default landing spot and the recommended capture surface. Write meeting notes, ideas, and tasks into the journal as they happen, linking out to topic pages with [[ ]]. Those topic pages then accumulate everything you ever wrote about them, with no manual filing.

5. Everyday Writing

Editing blocks

Tip

Click a bullet to zoom in — Logseq shows only that block and its children as a focused page. This is great for drilling into one branch of a big outline. Use the breadcrumb at the top to zoom back out.

Markdown formatting

Logseq supports standard Markdown inside blocks:

**bold**  *italic*  ~~strikethrough~~  `inline code`
[link text](https://example.com)
> a quote

Fenced code blocks with a language tag get syntax highlighting:

```python
def hello():
    print("hi")
```

Other inline elements:

• Math via KaTeX: $E = mc^2$ inline, or $$ ... $$ for a display block.
• Highlights: ^^highlighted^^.
• Images: paste or drag a file into a block; Logseq stores it in the graph's assets/ folder and inserts a reference.

Linking ideas

Type [[ or # and Logseq pops up an autocomplete list of existing pages so you stay consistent instead of creating near-duplicate pages.

Slash commands

Type / inside a block to open the command menu. From there you can insert almost anything without memorizing syntax: tasks, scheduled/deadline dates, templates, queries, code blocks, embeds, the current time, page/block references, and more. Start typing to filter the menu.

The command palette

Press Ctrl/Cmd+Shift+P to open the command palette (cmdk) — a searchable list of every action in Logseq, including ones triggered by plugins. If you're not sure how to do something, open the palette and search for it.

6. Working With Tasks

Logseq has a full task and to-do system built on blocks.

Task states

Mark any block as a task by starting it with a status keyword:

- TODO Email the vendor
- DOING Write the proposal
- DONE Book the venue

Clicking the checkbox that appears cycles the task through its states. In DB graphs, tasks are first-class structured data: a task block is tagged #Task and carries a typed status and optional priority (low, medium, high, urgent).

Scheduling and deadlines

Give a task a date so it shows up on the right day:

• Scheduled — when you plan to work on it.
• Deadline — when it's due.

Insert these with the slash command (/Scheduled, /Deadline) or by typing the date. Scheduled and deadline tasks surface automatically in your journal and in queries, so today's journal becomes a live agenda.

Tip

Add a /Today or scheduled date to a task and it appears in your daily journal's task queries automatically — no need to copy it forward by hand.

Recurring tasks

Logseq supports repeating tasks with three distinct repeat semantics, modeled on Org-mode's repeater "cookies". When you mark a recurring task DONE, Logseq computes the next occurrence based on which cookie you chose:

Worked examples:

• .+ — A weekly task scheduled 2026-04-01, completed 2026-04-05 → next appears 2026-04-12. If you completed it 2026-04-20, next is 2026-04-27. The clock restarts at completion.
• ++ — A Monday standup scheduled 2026-04-06, completed Wednesday 2026-04-08 → next is Monday 2026-04-13. It keeps the same weekday.
• + — Rent due 2026-04-01, paid 2026-04-05 → next reminder 2026-05-01. Paid 2026-04-25 → still 2026-05-01. The date never shifts when you're late.

Note

A recurring task with no explicit cookie defaults to ++, preserving older behavior — nothing changes on upgrade. Pick a different semantic from the repeat-setting popover that appears when a task's repeat option is enabled.

7. Organizing and Finding Knowledge

Tags and pages

A tag is a page. #books and [[books]] point at the same page. So tagging is just lightweight linking: tag a block #books and it appears in the linked references of the books page. In DB graphs, tags are first-class nodes with their own properties and can define a small schema (which properties their members should have).

Properties as structure

Use properties to turn free-form notes into queryable data:

- The Pragmatic Programmer
  author:: [[Andy Hunt]]
  status:: reading
  rating:: 4

Once a handful of book blocks carry status and rating, you can query for "books I'm currently reading" or "everything rated 5" and get a live, always-current list.

Search

• Global search (Ctrl/Cmd+K) searches across all pages and blocks. As you type, it suggests pages, blocks, and commands.
• Find/replace within a page and block-level navigation are available from the page menu.

Queries: ask your graph questions

Queries are Logseq's superpower. They embed a live, self-updating list of blocks that match criteria, right inside a page.

Simple queries use a readable syntax and are inserted with /Query:

{{query (and (task TODO DOING) (page "Project Apollo"))}}
{{query (property status "reading")}}
{{query (and [[meeting]] (between -7d today))}}

Advanced queries drop down to Datalog (the query language of the underlying DataScript/SQLite database) for full power — arbitrary joins, rules, and result transformation. You write them as a Clojure map with :query (and optionally :result-transform, :inputs) inside a {{query ...}} block. Advanced queries can express anything the data model supports.

Tip

Start with simple queries. Reach for advanced (Datalog) queries only when a simple query can't express what you need — for example, custom sorting, grouping, or cross-property logic.

The graph view

Open the graph view (the global graph icon) to see your knowledge base as an interactive node-link diagram: pages are nodes, references are edges. It's rendered with a force-directed layout, so densely connected clusters of related notes pull together visually. Click a node to jump to that page. Local graph view (on a single page) shows just that page's neighborhood.

8. Power Features

PDF annotation

Open a PDF inside Logseq and highlight passages directly. Each highlight becomes a block in your graph, linked back to the exact location in the PDF. You can write notes under a highlight, reference it elsewhere, and click it to jump straight back to the source page. This turns Logseq into a research and literature-review tool: your annotations live alongside the rest of your notes and show up in references and queries.

Flashcards (spaced repetition)

Logseq has a built-in spaced-repetition system. Turn any block into a flashcard by tagging it #card:

- What year did Logseq's DB version reach beta? #card
  - 2026

A cloze-style card hides the child block (the answer) until you reveal it. Logseq schedules reviews using a spaced-repetition algorithm so you see cards just before you'd forget them. Start a review session from the journal's card widget or with a {{cards ...}} query.

Templates

Save a block (and its children) as a reusable template, then insert it anywhere with /Template. Templates are perfect for recurring structures — meeting notes, daily routines, book notes, project skeletons. A template can include properties and placeholder blocks so every new instance starts consistent.

Embeds and references

• Block embed — insert a live copy of another block (and its children) that stays in sync with the original.
• Page embed — embed an entire page inside another page.
• Use these to build dashboards: a single page that embeds your active projects, today's tasks, and a query of recent meetings.

Whiteboards and visual thinking

Depending on your build and graph type, Logseq offers a spatial canvas for arranging blocks and pages visually alongside the outliner. Where available, it's accessible from the left sidebar; blocks placed on the canvas remain real blocks in your graph.

Note

Feature availability varies between the file version and the DB version, and across desktop/mobile/web. If a feature described here isn't visible in your build, check that you're on a build where it has shipped.

9. The Logseq CLI

The logseq command-line tool lets you read and edit your DB graphs from scripts, terminals, and automation — without opening the app. It's a Node.js program (compiled from ClojureScript) that talks to a local db-worker-node server it manages for you.

Important

The CLI operates on DB graphs stored under your CLI root directory (default ~/logseq, with graph data in ~/logseq/graphs/). It manages the background server automatically — you should not start db-worker-node by hand.

Installing and running

The CLI is shipped as the logseq npm package (binary name logseq). After installation:

logseq graph list

If you built it from source, you can run it directly or link it globally:

node ./dist/logseq.js graph list   # run directly
npm link                           # make `logseq` available globally

Check your build:

logseq --version

Build time: <timestamp>
Revision: <commit>

Configuration and precedence

The CLI reads configuration from <root-dir>/cli.edn (default ~/logseq/cli.edn). Settings can be overridden by environment variables, which are in turn overridden by global flags:

Precedence: global flag > environment variable > config file.

Other useful cli.edn keys: :output-format (:human default, or :json / :edn for scripting), :list-title-max-display-width (default 40), and :custom-queries (named queries you can run with query --name).

Tip

For scripting, set --output json (or --output edn). Human output truncates long titles and renders relative times; JSON/EDN preserve full values and namespaced keys.

Choosing a graph

Most commands act on the current graph (set with graph switch) unless you pass --graph <name>. Graph names are user-facing (for example demo) and map to a directory under <root-dir>/graphs.

Command reference

Graph management

graph create accepts --enable-sync (create, switch, upload, and start sync in one step) and --e2ee-password <password> (only with --enable-sync). EDN export also accepts --include-timestamps, --exclude-built-in-pages, and --exclude-namespaces <csv>.

logseq graph create --graph research
logseq graph export --type sqlite --file ./research-backup.sqlite --graph research

Note

graph create fails with graph-exists if a local graph of that name exists. graph import and backup restore fail if the target graph already exists. Commands that need --graph return graph not exists when the named graph is missing.

Backups

Warning

A backup copies only db.sqlite. The search index (search-db.sqlite) and client-ops log (client-ops-db.sqlite) are intentionally excluded — they rebuild from the main database. Desktop and CLI share the same backup layout, so the CLI can manage Desktop-created backups when it uses the same root directory.

Inspecting your graph

All list commands support --limit, --offset, --sort <field>, --order asc\|desc (default --sort updated-at --order desc), and --fields <csv>. For list node, --tags and --properties use all-of semantics and combine with AND.

logseq list task --status todo --priority high
logseq list node --tags book --properties status
logseq show --page "Project Apollo" --level 3

Searching

logseq search page --content "apollo"      # pages by name (case-insensitive substring)
logseq search block --content "vendor"     # blocks by title
logseq search tag --content "book"         # tag pages
logseq search property --content "status"  # property pages

Note

Search requires the --content flag. A legacy positional query (logseq search page apollo) is rejected with guidance to use --content.

Editing your graph

The upsert family creates or updates content. Without an explicit target, blocks default to today's journal page.

# Add a block to today's journal
logseq upsert block --content "Captured from the terminal"

# Add a child block to a specific page
logseq upsert block --content "Sub-point" --target-page "Project Apollo" --pos last-child

# Create or update a page, with tags and properties
logseq upsert page --page "Dune" --update-tags '[book]' --update-properties '{rating 5}'

# Create a task and attach #Task
logseq upsert task --content "Pay invoice" --scheduled "2026-07-01" --priority high

# Insert a tree of blocks from EDN
logseq upsert block --blocks-file ./outline.edn --target-page "Notes"

Other editing commands:

--pos accepts first-child, last-child, or sibling. For upsert block/upsert page, modify tags and properties with --update-tags, --update-properties, --remove-tags, --remove-properties (EDN values). For tasks, set fields with --status, --priority, --scheduled, --deadline, and clear them with --no-status, --no-priority, --no-scheduled, --no-deadline.

Caution

--status is not valid on upsert block — use upsert task --status .... For the same field, set and clear options are mutually exclusive (--status todo --no-status is rejected).

Querying from the CLI

# Run a Datalog query
logseq query --query '[:find ?b :where [?b :block/title "Apollo"]]'

# Run a named query defined in cli.edn :custom-queries
logseq query --name overdue-tasks

# List available named queries
logseq query list

Cloud sync (RTC)

Logseq's Real-Time Collaboration (RTC) sync keeps a graph in step across devices and lets you collaborate with others. From the CLI:

logseq login                                   # authenticate this machine
logseq sync upload --graph research            # push local graph to the cloud
logseq sync start --graph research --e2ee-password <pw>   # start live sync
logseq sync download --graph research          # pull a remote graph into a new local graph
logseq sync status --graph research            # show sync state
logseq sync remote-graphs                      # list graphs visible to your account
logseq sync grant-access --graph research --graph-id <uuid> --email <email>

Important

RTC graphs are end-to-end encrypted by default. Provide your encryption password via --e2ee-password on sync start (it's verified and persisted) or sync download. A wrong password fails fast without overwriting the stored one. Run logseq login first in headless environments so password persistence works for later sync calls.

logseq logout removes the persisted credentials (~/logseq/auth.json).

Server, diagnostics, and utilities

logseq server list                 # list running db-worker-node servers
logseq doctor                      # runtime diagnostics (runtime bundle, permissions, server readiness)
logseq completion zsh              # shell completion (zsh or bash)
logseq example upsert page         # show runnable examples for a command
logseq skill install               # install the agent skill into ./.agents/skills/

Set up shell completion by adding to your shell config:

# ~/.zshrc
autoload -Uz compinit && compinit
eval "$(logseq completion zsh)"

# ~/.bashrc
eval "$(logseq completion bash)"

Tip

Add --verbose to any command to print structured debug logs to stderr, and --profile to print per-stage timing — useful when a command is slow or behaving unexpectedly.

10. Plugins and Themes

Logseq is extensible. A growing ecosystem of community plugins and themes adds features and changes how the app looks.

Installing plugins and themes

1. Open the Marketplace from Settings → Plugins (or Themes).
2. Browse or search, then click Install.
3. Enable the plugin; some add slash commands, toolbar buttons, or new query types.

Switch themes the same way, or quickly with the theme toggle. Many plugins and themes are catalogued in the community Awesome Logseq list.

Warning

Plugins run with broad access to your graph and the app. Install plugins you trust, from sources you recognize, just as you would any third-party software.

For developers

Logseq exposes a plugin API (@logseq/libs) so you can build your own extensions in JavaScript/TypeScript — register slash commands, render custom UI, read and write blocks, and hook into editor events. Full documentation is at plugins-doc.logseq.com. For the architecture behind the API, see the Admin Guide.

11. Syncing, Backups, and Data Safety

Where your data lives

• DB graphs — a local SQLite database under your graphs directory (~/logseq/graphs/<graph> for the CLI; the app stores desktop graphs under ~/logseq/graphs as well). The disk SQLite file is the source of truth.
• File graphs — plain Markdown/Org files in the folder you chose, plus an assets/ subfolder for attachments.

Because everything is local and in open formats, you can back it up with any tool you already use (Git, a cloud-synced folder, Time Machine, etc.).

Backups

Important

The DB version is in beta — back up regularly. Options:

• Turn on automated backups in settings.
• Use logseq graph backup create for snapshot copies of db.sqlite.
• Use logseq graph export --type sqlite or --type edn for a portable copy.
• For file graphs, version the folder with Git or sync it with your provider of choice.

RTC sync across devices

To use the same graph on several devices, set up RTC sync (alpha): upload the graph once, then start sync on each device. Sync is end-to-end encrypted; you control the password. See the CLI sync commands or the in-app sync settings.

12. Customization

Keyboard shortcuts

Almost every action has a keyboard shortcut, and you can rebind them. Open Settings → Keymap (or Shortcuts) to search and customize. Shortcuts can also be set in configuration using the :shortcuts map, where keys are command identifiers and values are key sequences:

{:shortcuts {:ui/toggle-theme "t z"
             :ui/toggle-brackets "t b"}}

Settings and configuration files

• In-app settings cover the most common preferences (theme, font, journal format, editor behavior).
• Per-graph config lives in the graph's config (for file graphs, logseq/config.edn).
• Global config (global-config.edn) applies to all graphs. A graph's own config overrides global keys, except that maps are merged — so a global :shortcuts map and a per-graph :shortcuts map combine rather than replace each other.

Tip

Use global config for preferences you want everywhere (custom shortcuts, default settings) and per-graph config for anything specific to one knowledge base.

13. Markdown Mirror & Interoperability

DB graphs can produce a Markdown Mirror — a Markdown representation of your DB content, so your notes remain readable and portable outside Logseq. Understanding its conventions helps when you read or sync these files:

• Page identity — mirror files begin with an id marker: id:: 11111111-1111-4111-8111-111111111111. This links the file to its DB page; it is not a normal property.
• Blocks use - list items; two spaces per nested level define the hierarchy.
• Properties use * list items and keep the key:: value marker. Page properties appear before the first block; block properties appear under their block.
• References use [[Page]] syntax (node property values export as [[Node title]], not ((uuid))).
• Tags appear inline on the block line: - Call customer #sales.
• Task status is encoded inline (- TODO Write draft), not as a separate property.

Note

This is the on-disk text representation of a DB graph. For day-to-day use you edit in the app; the mirror exists for portability, diffing, and external tooling.

14. Troubleshooting

Error: Permission is not granted

Cause: The browser/web app needs read-write access to a folder via the File System Access API, and you declined or never granted the permission prompt.

Solution: Re-open the graph and approve the permission dialog. Grant read-write access to the folder.

Prevention: Use a compatible browser and don't dismiss the access prompt.

Logseq is slow to start or open

Cause: Very large graphs, or many heavy plugins, increase startup and load time.

Solution: Disable plugins you don't use; split rarely-touched archives into a separate graph; make sure you're on a recent build. Performance with large graphs is an area of active improvement.

Prevention: Keep an eye on plugin count and avoid embedding extremely large queries on your most-visited pages.

Editing a very large page lags

Cause: Pages with thousands of blocks, or many live queries/embeds, are expensive to re-render.

Solution: Break giant pages into linked sub-pages; collapse large branches; reduce the number of live queries on a single page.

Renderer stuck at 100% CPU / app becomes very slow

Cause: Occasionally a rendering loop or a problematic plugin/extension pins the CPU.

Solution: Restart the app. If it recurs, disable plugins one at a time to find the culprit, and update to the latest build.

Graph fails to load (folder name contains spaces, Windows)

Cause: Certain path edge cases (notably folder names with spaces on Windows in some versions) can prevent a file graph from loading.

Solution: Move the graph to a path without unusual characters, or update to a build where the issue is fixed.

Cannot install plugins (GitHub API check fails)

Cause: The plugin marketplace validates against the GitHub API, which can fail due to rate limits or network restrictions.

Solution: Wait and retry; ensure your network can reach GitHub; install the plugin manually from its release if needed.

CLI: graph not exists

Cause: A command that needs --graph named a graph that isn't in <root-dir>/graphs.

Solution: Run logseq graph list to see available graphs, and pass an existing --graph (or graph switch to set the current one). If you migrated from ~/.logseq, pass --root-dir / --config to point at your old locations.

CLI: e2ee-password-not-found

Cause: A sync command needs your end-to-end encryption password but none is stored.

Solution: Provide --e2ee-password <pw> on sync start or sync download. Run logseq login first so the password can be persisted for later calls.

CLI: graph-db-not-empty on sync download

Cause: The local target database already has data, so importing a remote snapshot would clobber it.

Solution: Download into a fresh graph name, or remove/rename the existing local graph first.

15. FAQ

Q: Is my data private? Where is it stored? Yes — Logseq is privacy-first and local-first. DB graphs are stored in a local SQLite database; file graphs are plain Markdown/Org files on your disk. Nothing leaves your device unless you opt into RTC sync (which is end-to-end encrypted).

Q: What's the difference between a DB graph and a file graph? DB graphs (the 2.0 default) use SQLite, are faster, and support typed properties, structured tasks, and RTC sync. File graphs store everything as Markdown/Org text files for maximum portability and longevity. Choose DB for power, file for plain-text purity.

Q: Is the DB version safe to put my real notes in? It's in beta (with mobile and RTC in alpha), so data loss is possible. Use it with automated backups, and consider a dedicated test graph before migrating critical notes.

Q: Do I have to use Markdown, or can I use Org-mode? File graphs support both Markdown and Org-mode. DB graphs use an internal model with a Markdown Mirror representation. You can write in whichever you prefer for file graphs.

Q: How do I move a note between pages? You usually don't need to — references mean a block is "everywhere" it's linked. To physically relocate a block, drag its bullet, or use the CLI logseq move command.

Q: What's the journal for? It's your daily capture page. Write everything there as it happens and link out with [[ ]]; topic pages then auto-collect their references. It removes the burden of deciding where to file things.

Q: How do queries stay up to date? Queries run live against the underlying database. When you add or change a matching block anywhere, the query result updates automatically — no refresh needed.

Q: Can I script Logseq? Yes. The logseq CLI reads and edits DB graphs from the terminal (list, search, upsert, query, sync, export). It's ideal for automation, bulk edits, and integration with agents and other tools.

Q: How do flashcards work? Tag a block #card (with the answer as a child block). Logseq schedules it with a spaced-repetition algorithm and surfaces it for review when you're about to forget it.

Q: What happens to a recurring task when I finish it? Logseq computes the next occurrence based on the repeat cookie: .+ (from completion), ++ (keep the weekday — the default), or + (fixed calendar date). See Recurring tasks.

Q: Can I use Logseq on my phone and desktop together? Yes, via RTC sync (alpha). The new mobile app is on iOS first, with Android in development.

Q: Where do I get help and find plugins? The official docs are at docs.logseq.com, the community forum at discuss.logseq.com, and the Awesome Logseq list catalogs plugins and themes.