Skip to content

Projects#

A project in FoldNotes is simply a name — like Marketing-Q4 or home/garden — that gathers together the notes and tasks scattered across your collection that belong to it. There's no special "project file" and nothing to set up. A project exists the moment you mention its name, and disappears when you stop.

Because a project is just text in your notes, it travels with them everywhere: it syncs through iCloud, survives export, and you could find it with grep if you ever wanted to. Nothing is locked inside a hidden database.

The one rule worth knowing first#

A task belongs to a project in the most natural way possible:

  • Tag a note with #projects/Marketing-Q4, and every task in that note belongs to Marketing-Q4 automatically — you don't have to label each one.
  • Need a single task to belong somewhere else? Give that task its own label, project:Other-Thing, and it wins.

That's it. Tag the note, write plain tasks, done.

flowchart TD
    A["A task in a note"] --> B{"Does the task have its<br/>own project: label?"}
    B -- "Yes" --> C["It belongs to that project<br/>(explicit always wins)"]
    B -- "No" --> D{"Does the note have exactly<br/>one #projects/ tag?"}
    D -- "Yes" --> E["The task inherits<br/>the note's project"]
    D -- "No tag, or several tags" --> F["The task belongs<br/>to no project"]

Why no project on the third case?

If a note carries several project tags, FoldNotes won't guess which one a plain task belongs to — so it leaves those tasks unlabelled, and you tag them yourself. And a task that genuinely belongs to nothing in particular (a stray "pick up milk" in a project note) simply stays unlabelled.

The two ways to attach a project#

Scope What you write Use it when…
A whole note #projects/Marketing-Q4 — a tag anywhere in the note's body The note is about the project: a hub, a status update, a kickoff, a retro.
A single task project:Marketing-Q4 — written on the task's line One task in an otherwise unrelated note belongs to a project — a stray action item in a meeting note.

They share one name. #projects/Marketing-Q4 on a hub note and project:Marketing-Q4 on a task in a meeting note point at the same project, and FoldNotes brings them together everywhere.

A meeting note is the classic mixed case:

# 1:1 with Alex
- [ ] Update the marketing site project:Marketing-Q4
- [ ] Fix the iOS crash project:Mobile-iOS
- [ ] Pick up groceries

The note itself isn't about any project (no #projects/ tag), but two of its tasks are filed under different projects, and the third stays free.

Names are case-insensitive

Marketing-Q4 and marketing-q4 are the same project — FoldNotes just shows it with the spelling you first used. Use dashes or underscores instead of spaces: Spring-Renovation, not Spring Renovation.

A project note can live in other places too#

A project tag is just a tag, so a project note can also carry ordinary tags and show up wherever those tags lead — it lives in more than one place at once. For example:

# Release planning
#projects/foldnotes/release
#foldnotes/architecture

This note is the project foldnotes/release (so its tasks are filed there automatically), and it appears under your ordinary #foldnotes/architecture tag in the tag browser, in tag queries, and in database views. Add as many ordinary tags as you like — they never interfere with the project.

One project per note

The single thing to avoid is putting two project tags on the same note — e.g. #projects/foldnotes/release and #projects/foldnotes/docs. Then FoldNotes can't tell which one a plain task belongs to, so it stops filing tasks automatically and you'd have to label each task yourself. One project tag plus any number of ordinary tags is completely fine; it's only a second #projects/… tag that creates the ambiguity.

Sub-projects#

Put a / in the name and you get a real hierarchy:

#projects/home
#projects/home/garden
#projects/home/garden/planting
#projects/home/renovation
#projects/work/marketing/launch

flowchart TD
    home["home"] --> garden["garden"]
    home --> renovation["renovation"]
    garden --> planting["planting"]
    work["work"] --> marketing["marketing"]
    marketing --> launch["launch"]

garden and renovation are sub-projects of home; planting sits under garden. This isn't just visual grouping — FoldNotes understands the nesting:

  • A task belongs to exactly one node (its full path, e.g. home/garden/planting). It's never "in" home directly — it's under it.
  • Anywhere you can view or filter by project, you can ask to include sub-projects: scope to home and you'll see everything beneath it, or scope to just home/garden for that branch alone.

There's no limit on how deep you can nest, and you never have to "create" the in-between levels — typing #projects/home/garden/planting brings the whole path into being.

Choosing your own words#

"Project" is just the default word. If you think in a different language, or simply prefer different terminology, you can change it per collection. You set two words — the plural (used for the note tag) and the singular (used for the task label and the on-screen labels):

You set FoldNotes then uses
plural = projekte the note tag #projekte/haus
singular = projekt the task label projekt:haus, and "Projekt" throughout the menus

When you change the words, FoldNotes rewrites every existing tag and task label across your whole collection in one pass, so nothing is left behind. And it keeps quietly understanding the old words (and the standard English project: / #projects/) forever, so anything you paste in or sync from elsewhere still lands in the right place.

Where to change it

The words are set on macOS (Settings ▸ Projects), because that's where the collection-wide rewrite happens. On iOS the current words are shown but not editable — your iPad simply follows whatever the Mac set, the moment it syncs.

Creating and picking a project#

You rarely type a project name by hand. On any task line, open the command palette (press /) and choose Project — a picker appears listing every project you already have, filtered as you type, with New Project… at the top for adding a fresh one. The picker lets you drill into sub-projects, so you can pick home/garden/planting level by level.

The same picker turns up wherever you choose a project — the Task Board's scope selector, the in-place task editor — so it always feels the same.

You can also just type project:newName on a task line, or tag a note with #projects/newName. Either way the name is remembered and starts appearing in the picker.

Seeing all the work for a project#

The Task Board (macOS)#

The Task Board is the cross-note view of everything you have to do. It's a kanban board — the columns are task states (Not Started, In Progress, Done) or, if you prefer, priority or due-date buckets.

Project is a scope, not a column layout. A dropdown at the top narrows the entire board — and its calendar — to one project and its sub-projects. A line just above the columns always spells out what you're looking at, e.g.:

47 tasks in work/marketing and its sub-projects · grouped by Status · 12 undated not shown

flowchart LR
    subgraph Board["Task Board — scoped to work/marketing"]
        NS["Not Started"]
        IP["In Progress"]
        DN["Done"]
    end
    NS -- "drag a card →" --> IP
    IP -- "drag →" --> DN

What you can do here:

  • Scope to a project (with or without its sub-projects) from the dropdown.
  • Drag a card between columns to change a task's status — the change is written straight back into its note.
  • Slide out the calendar and drag a task onto a day to give it a due date (and it moves to "In Progress" at the same time).
  • Edit a task in place — double-click any card to open a small editor for its text, status, priority, due date, project, and comments. You never have to open the note for a quick change. Double-clicking also jumps you to the task in the editor if you'd rather see it in context.

The Project Manager (macOS — View ▸ Project Manager)#

A two-pane window for the bird's-eye view and for tidying up.

  • Left: every project as a tree. Each row shows how many notes and tasks reference it, plus a faint "(+N)" for everything in its sub-projects. Filter by All / Active / Orphaned / Archived, or search by name.
  • Right: pick a project and see every note and task that belongs to it — with a row of sub-project chips to drill in, and an Include sub-projects switch to widen or narrow the list. Edit any task right there, the same way as on the board.

Tidying up#

All housekeeping lives in the Project Manager (macOS):

Action What happens
Rename Renames the project everywhere — every note tag and every task label across the collection — in one pass. Renaming a parent offers to bring its sub-projects along. A preview tells you how many notes and tasks will change before you commit.
Archive Hides a finished project from the pickers and lists without changing a single note. Unarchive any time. Archiving a parent archives its sub-projects too.
Delete Removes the project and strips its tags and task labels from your notes. The confirmation shows exactly how much will be touched first.

Rename and delete edit your notes

These rewrite the text in your note files (that's where projects live). There's no undo button — though a rename can always be reversed by renaming back. FoldNotes shows you the scope before it does anything, and reports anything it couldn't reach (for example, a note that was mid-save) so you can run it again.

Orphans are projects with nothing pointing at them any more — usually a finished project whose references you removed, or a typo. The Project Manager flags them so you can clear them out, and even tells you whether an orphan was one you created deliberately or one that only ever existed as a stray label.

A note that lists projects without joining them#

Because a project tag counts wherever it appears — including inside a table — a dashboard note full of #projects/... links would accidentally join all of them. To list projects without membership, wrap that part of the note in a no-index region:

<!--fn:noindex-->
| Project              | Status   |
|----------------------|----------|
| #projects/home       | active   |
| #projects/work/q3    | wrapping |
<!--/fn:noindex-->

The links still show and stay clickable, but the note doesn't join those projects. (Renames still update the text inside, so your dashboard never goes stale.) For a hands-off list, a saved query or database view filtered with "is under" is even better.

Templates#

Templates can include a Project parameter, so a "Project Kickoff" or "Weekly Status" template asks which project it's for when you use it.

  • On a task line, write project:{{paramName}} and only those tasks get the project.
  • Switch on Auto-tag and the new note is tagged #projects/<name> as a whole — best for templates that are entirely about one project.

Templates are created on macOS but can be used on both macOS and iOS.

macOS and iOS at a glance#

iOS has everything you need to work with projects day to day. The heavier authoring and management tools are macOS-only by design — and changes made on the Mac flow to iOS automatically through iCloud.

macOS iOS
Tag a note #projects/...
Label a task project:...
Tasks inherit their note's project
Sub-projects & "is under" queries
Pick a project with the drill-down picker
Case-insensitive names
Use a template with a Project parameter
See the current project terminology (read-only)
Change the project terminology (set on Mac)
Task Board (scope, calendar, drag, in-place edit)
Project Manager (tree, rename, archive, delete)
Author templates with Project parameters

On iOS, to see all the tasks for a project you can run a saved query or open a database view built on the Mac — both understand projects, including "is under" for sub-projects.

Tips#

Tag the note, not every task

For anything that's mostly about one project — a hub note, a project journal, a sprint board — just tag the note once. Every task inside it is filed automatically, and you only reach for project: on the rare task that belongs elsewhere.

Scope, then work

On the Task Board, set the project scope first and treat the board as your workspace for that project. The columns stay about getting things done (status), while the dropdown answers which project.

Use the hierarchy

Group related efforts under a parent — work/marketing/launch, work/marketing/press — and you can review the whole of work/marketing at once, or drop into a single branch, without re-tagging anything.

Spring-clean now and then

Open the Project Manager occasionally. Archive what's finished (keeps the history, clears the clutter), and delete the true orphans — the typos and abandoned codenames with nothing left to keep.