Get AI summaries of any video or article — Sign up free
How I organize my Logseq Templates thumbnail

How I organize my Logseq Templates

Tools on Tech·
5 min read

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

TL;DR

Logseq templates are triggered by a “template name” property that matches what’s selected after typing `/template`.

Briefing

Logseq templates hinge on two key properties: a “template name” that’s invoked via `/template`, and a “template include parent” toggle that controls whether the parent block is included when the template is inserted. In practice, setting include parent to false makes templates behave like reusable page fragments—useful for generating structured content such as meeting notes inside a journal—while setting it to true turns the template into a more block-centric insert.

A concrete example shows how the template name property becomes the lookup key. When the template is defined with a name like “project,” typing `/template` and selecting that name inserts the template content. The inserted block can include dynamic date logic using Logseq’s human-readable future-date syntax (e.g., “deadline in two months”), which resolves into a fixed date link. That means templates can prefill time-sensitive fields without manual editing each time.

For meeting capture, the template can be structured as a block with sub-blocks. Selecting a “meeting” template inserts a top-level meeting block along with nested content such as tags (e.g., a “meeting” tag), an “attending” property, links to people, and sections for notes and action items. The include-parent setting matters here: keeping the parent out prevents unrelated elements from being pulled into the inserted structure, so the template lands cleanly where it’s meant to be used.

On organization, the creator describes two working systems for managing many templates.

The first system organizes templates by type. Each “type” (like a “book”) has its own page that contains both a table listing elements of that type and the template for creating those elements. To find templates scattered across the graph, a dedicated “templates” page uses a query that selects any block with the `template` property—giving a single consolidated view of all templates.

The second system adds hierarchy so templates are navigable without relying on a catch-all query. It splits into two layers: a page per type (e.g., “project” or “book”) that holds a query for the elements, and separate pages named like `template/<template-name>` (e.g., `template/project`). Those template pages contain only the template itself. This structure enables quick access via partial navigation (typing “tem” then “projects” surfaces the right template page), keeps the type pages clean (no template clutter), and produces a visible hierarchy in the sidebar such as “template meeting” and “template project.”

Both approaches require maintaining template names for discoverability, but the hierarchical method trades a bit more upfront organization for faster, cleaner browsing. The preference currently leans toward the hierarchical structure, with openness to revisiting the type-based approach later as the Logseq setup evolves.

Cornell Notes

Logseq templates are driven by a “template name” property used with `/template`, plus an “template include parent” flag that determines whether the parent block is included when inserting the template. Templates can also prefill fields like deadlines using human-readable future-date syntax that resolves to fixed-date links. For organization, one method groups templates by content type (e.g., a “book” page containing both a type table and its template) and uses a global query page to list all templates via the `template` property. A second method creates a hierarchy: type pages hold only element queries, while dedicated pages named `template/<name>` contain the template blocks, making templates easier to find and keeping pages uncluttered.

What do the two template-related properties control in Logseq, and how do they affect insertion behavior?

Templates rely on a “template name” property that matches what users select after typing `/template`. The “template include parent” property controls whether the parent block is included when the template is inserted: when it’s false, only the template’s bottom blocks appear (useful for inserting structured fragments into existing pages like a journal). When it’s true, the template behaves more like a block template that includes the parent context.

How can templates handle time-based fields like deadlines without manual editing each time?

Templates can embed human-readable future-date syntax (e.g., “deadline in two months”). Logseq converts that into a fixed date link in the future. The same pattern can be used with other human-readable formats such as “today,” “tomorrow,” or specific times (with additional variables available via documentation).

Why does include-parent matter for meeting templates inserted into a journal?

A meeting template is designed as a block with sub-blocks: it inserts a top-level meeting block plus nested fields like tags, an “attending” property, links to people, and sections for notes and action items. Setting include-parent to false helps ensure the inserted meeting structure doesn’t accidentally pull in unrelated parent elements from the journal entry, keeping the inserted content clean and consistent.

How does the “sort by type” organization method work for templates?

Each content type gets its own page (e.g., a “book” page). That page contains elements related to the type (often via a table/query) and places the template for that type nearby. To find templates across the whole graph, a separate “templates” page runs a query that returns any block with the `template` property, producing a single list of all templates.

What changes with the hierarchical organization method, and what benefits does it bring?

Instead of one catch-all listing, templates get their own pages in a structured namespace. Type pages (like “project” or “book”) contain only the element query, while template pages are created at paths like `template/project` or `template/meeting` and contain just the template block. This keeps type pages clean, enables quick navigation (e.g., typing “tem” to find “projects”), and shows a hierarchy in the sidebar such as “template meeting” and “template project.”

Review Questions

  1. How would you decide whether to set “template include parent” to true or false for a new template you plan to insert into existing pages?
  2. Compare the two template discovery strategies: a global query list vs. `template/<name>` hierarchical pages. Which one reduces clutter on type pages, and why?
  3. What role does the “template name” property play in making templates selectable via `/template`, and what additional requirement does the hierarchical system impose?

Key Points

  1. 1

    Logseq templates are triggered by a “template name” property that matches what’s selected after typing `/template`.

  2. 2

    The “template include parent” flag determines whether the parent block is included during insertion; false is useful for inserting clean fragments into existing content.

  3. 3

    Templates can generate fixed future-date links using human-readable date syntax such as “deadline in two months.”

  4. 4

    A meeting template can be built as a block with sub-blocks, including tags, an “attending” property, linked people, and fields for notes and action items.

  5. 5

    One organization approach groups templates by content type on pages like “book,” paired with a global “templates” query page that lists blocks with the `template` property.

  6. 6

    A hierarchical approach creates dedicated pages named `template/<template-name>` so templates appear in a navigable structure and type pages stay uncluttered.

  7. 7

    Both systems depend on consistent template naming for fast retrieval, but the hierarchical method trades extra setup for easier browsing.

Highlights

Setting “template include parent” to false makes templates behave like reusable fragments that drop into existing contexts without dragging along the parent block.
Human-readable date strings inside templates can resolve into fixed future-date links, enabling automatic deadline fields.
The hierarchical scheme—type pages for element queries plus `template/<name>` pages for template blocks—keeps navigation clean and makes templates easy to jump to.
A global query page that searches for blocks with the `template` property provides a simple fallback for finding templates when they’re scattered.

Topics

  • Logseq Templates
  • Template Properties
  • Date Variables
  • Template Organization
  • Query Navigation