An idea[idea:idea]

An idea in a rookery is written in Typst. Every idea can be referenced by any other idea or page in the same rookery.

Each idea also gets a standalone page that will show its context—where it was first hatched—and its backlinks—the set of other ideas and pages that reference it—in its footer. Try clicking on this idea’s ID above (the [idea:idea] text), to see its standalone page as an example.

Ideas can be hyperlinked to other ideas, or they can be interpolated as windows onto the original idea. Clicking on the title of a window will unfold the idea within your current context. Clicking on the idea’s ID will take you to the idea’s standalone page.

Try unfolding these windows below by clicking on their title panel to learn more.

[idea:hatching-ideas]

[idea:referencing-ideas]

Homepage

Footnotes[idea:footnotes]

A footnote belongs to the idea in which you write it in, just as citations do. So that rookery can track them correctly, you need to use the footnote function imported from rookery in ideas, rather than the Typst native function:

#import "@rheo/rookery:0.1.0": idea, footnote
#idea("etal")[
  A claim#footnote[The evidence.] worth qualifying.
]

Footnote numbering is idea-local. This means that there may be two footnotes labelled 1 on the same page, if two ideas with footnotes are hatched in that context.¹

Footnote listings occur at the end of each idea.² On a standalone page, footnotes appear before the context and backlinks listings.

A footnote written outside an idea’s context proxies the native Typst function so that it behaves normally.

Footnotes

^ This idea’s own first footnote. The idea below has one too, also numbered 1.
^ Ideas will show footnotes everywhere their content appears: in their hatching context, their standalone page, and their windows 6.A footnote reference is a same-page link, so a window on another page needs its target on that page.

Hyperlinks[idea:hyperlinks]

Hyperlinks are the lowest-touch way to reference an idea in rookery, and are implemented as regular Typst references. Say you have an idea:

#idea("first-idea", title: [My first idea])

The following three bullets all produce the same result: a hyperlink that reads ‘My first idea’ to the idea’s standalone page.

#import "@rheo/rookery:0.1.0": hyperlink
- @idea:first-idea
- @idea:first-idea[My first idea]
- #hyperlink(<first-idea>)[My first idea]

Note that you must use the idea: prefix (which you may customize) when you are using references in the Typst namespace. When using the #hyperlink function imported from rookery, you may omit the prefix if you choose.

If you want your references to link to the anchor in the original context in which your idea was hatched, rather than the idea’s standalone page, pass link-to: "anchor" to an individual call:

- #hyperlink(<first-idea>, link-to: "anchor")[My first idea]

If you want to redirect all @idea:x-style references to anchors, #hyperlink is also @idea:x’s renderer, installed as a show ref: rule — .with() it instead of the default:

#import "@rheo/rookery:0.1.0": hyperlink
#show ref: hyperlink.with(link-to: "anchor")
- @idea:first-idea // will link to anchor

(#set hyperlink.with(...) does not work here — set rules only apply to Typst’s own built-in element functions, not a plain package function like hyperlink.)

Creating a hyperlink to an idea will add it to that idea’s set of backlinks.

Windows[idea:windows]

Windows can be used to interpolate the entirety of an idea’s content into a different context. They are useful in home pages or other sections that aggregate content.

Fundamentally, windows are a form of augmented hyperlink. They take their name from Nelson’s notion of the transpointing window as, when paired with backlinks, they allow you to see the content either side of the link.

Say you have an idea:

#idea("first-idea", title: [My first idea])

You can produce a window on this idea like so:

#import "@rheo/rookery:0.1.0": window
#window(<first-idea>)

Note that we do not need the idea: prefix. Like #hyperlink,#window is a function imported from rookery that already knows which namespace to look in.

By default, this window will be unfolded, showing the full content of the idea. If we want it to instead be folded, we can configure it with arguments. We can also pass an array of ideas to window on multiple ideas, and limit

#window(
  (<first-idea>, <second-idea>, <third-idea>),
  // only show the idea's name and id
  folded: true,
  // limit the number of ideas shown
  limit: 1,
  // include the document date
  show-date: true,
)

Here is an example of a window on the two foundational ideas in rookery, ‘rookery’ and ‘idea’, folded and with date:

[idea:rookery]

[idea:idea]

Adding a window to an idea will include the window’s context in the idea’s backlinks.

An idea’s footnotes travel with it into a window, numbered from 1 again and listed in the window’s own block — open this one and compare it with the same idea further up the page:

[idea:footnotes]

So do its citations: a window carries its own References block, resolving inside the window rather than pointing back at the idea’s own page.

[idea:citations]

Controlling window depth[idea:window-depth]

Windows on ideas that are parents in the idea hierarchy can infinitely recurse. By default they do not: a window written inside an idea you are windowing on collapses to its ID, so you always see one idea rather than a tree of them.

Raise depth to unfurl those inner windows, one level per count:

#window(<first-idea>, depth: 1)

You can configure window depth rookery-wide like so:

#show: rookery.with(window-depth: 1)
#window(<first-idea>)
#window(<second-idea>, depth: 0)

The count is a budget, and it is what makes this safe to ask for. An idea that windows on itself, or two that window on each other, would otherwise unfurl forever; with a budget they bottom out at the ID and stop. Each level also re-renders the idea’s body, so the work multiplies rather than adds — keep the numbers small.

Here is a window on this idea’s own parent, at the default depth. Its own windows show only as ID links:

[idea:windows]

What is the genealogy of idea?[idea:1]

The semantics of an idea is taken from the default Doom Emacs TODO keywords, one of which is IDEA.

An idea in a rookery should be conceptualized as an atomic note, which is why each idea is given its own standalone page. As with notes in other Zettelkasten-inspired systsems, ideas that link to each other produce backlinks

In addition to this sense of an idea (as a ‘Zettel’, or note), it can also be the basis for a ‘todo’ item (as an Org-mode TODO). This is one of the reasons that rookery ships the #todo function as syntactic sugar for an #idea with a "todo" tag. Though there is no inbuilt sense in which one idea can depend on or be blocked by another, you can create a stronger dependency system over tags, i.e. using a blockedby:xxx convention.