This manual, written by Protesilaos Stavrou, describes the customization
options for the Emacs package called denote (or denote.el), and
provides every other piece of information pertinent to it.
The documentation furnished herein corresponds to stable version {{{stable-version}}}, released on {{{release-date}}}. Any reference to a newer feature which does not yet form part of the latest tagged commit, is explicitly marked as such.
Current development target is {{{development-version}}}.
- Package name (GNU ELPA):
denote - Official manual: https://protesilaos.com/emacs/denote
- Change log: https://protesilaos.com/emacs/denote-changelog
- Git repositories:
- Video demo: https://protesilaos.com/codelog/2022-06-18-denote-demo/
- Backronyms: Denote Everything Neatly; Omit The Excesses. Don’t Ever Note Only The Epiphenomenal.
If you are viewing the README.org version of this file, please note that the GNU ELPA machinery automatically generates an Info manual out of it.
Copyright (C) 2022-2023 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover Texts being “A GNU Manual,” and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License.”
(a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual.”
Denote aims to be a simple-to-use, focused-in-scope, and effective note-taking and file-naming tool for Emacs.
Denote is based on the idea that files should follow a predictable and descriptive file-naming scheme. The file name must offer a clear indication of what the contents are about, without reference to any other metadata. Denote basically streamlines the creation of such files or file names while providing facilities to link between them (where those files are editable).
Denote’s file-naming scheme is not limited to “notes”. It can be used for all types of file, including those that are not editable in Emacs, such as videos. Naming files in a consistent way makes their filtering and retrieval considerably easier. Denote provides relevant facilities to rename files, regardless of file type.
Denote is based on the following core design principles:
- Predictability
- File names must follow a consistent and descriptive naming convention (The file-naming scheme). The file name alone should offer a clear indication of what the contents are, without reference to any other metadatum. This convention is not specific to note-taking, as it is pertinent to any form of file that is part of the user’s long-term storage (Renaming files).
- Composability
- Be a good Emacs citizen, by integrating with other
packages or built-in functionality instead of re-inventing functions
such as for filtering or greping. The author of Denote (Protesilaos,
aka “Prot”) writes ordinary notes in plain text (
.txt), switching on demand to an Org file only when its expanded set of functionality is required for the task at hand (Points of entry). - Portability
- Notes are plain text and should remain portable. The way Denote writes file names, the front matter it includes in the note’s header, and the links it establishes must all be adequately usable with standard Unix tools. No need for a database or some specialised software. As Denote develops and this manual is fully fleshed out, there will be concrete examples on how to do the Denote-equivalent on the command-line.
- Flexibility
- Do not assume the user’s preference for a note-taking methodology. Denote is conceptually similar to the Zettelkasten Method, which you can learn more about in this detailed introduction: https://zettelkasten.de/introduction/. Notes are atomic (one file per note) and have a unique identifier. However, Denote does not enforce a particular methodology for knowledge management, such as a restricted vocabulary or mutually exclusive sets of keywords. Denote also does not check if the user writes thematically atomic notes. It is up to the user to apply the requisite rigor and/or creativity in pursuit of their preferred workflow (Writing metanotes).
- Hackability
- Denote’s code base consists of small and reusable functions. They all have documentation strings. The idea is to make it easier for users of varying levels of expertise to understand what is going on and make surgical interventions where necessary (e.g. to tweak some formatting). In this manual, we provide concrete examples on such user-level configurations (Keep a journal or diary).
Now the important part… “Denote” is the familiar word, though it also is a play on the “note” concept. Plus, we can come up with acronyms, recursive or otherwise, of increasingly dubious utility like:
- Don’t Ever Note Only The Epiphenomenal
- Denote Everything Neatly; Omit The Excesses
But we’ll let you get back to work. Don’t Eschew or Neglect your Obligations, Tasks, and Engagements.
There are five main ways to write a note with Denote: invoke the
denote, denote-type, denote-date, denote-subdirectory,
denote-template, denote-signature commands, or leverage the
org-capture-templates by setting up a template which calls the
function denote-org-capture. We explain all of those in the
subsequent sections. Other more specialised commands exist as well,
which one shall learn about as they read through this manual. We do
not want to overwhelm the user with options at this stage.
The denote command will prompt for a title. If a region is active,
the text of the region becomes the default at the minibuffer prompt
(meaning that typing RET without any input will use the default
value). Once the title is supplied, the denote command will then ask
for keywords. The resulting note will have a file name as already
explained: The file naming scheme
The denote command runs the hook denote-after-new-note-hook after
creating the new note.
The file type of the new note is determined by the user option
denote-file-type (Front matter).
The keywords’ prompt supports minibuffer completion. Available
candidates are those defined in the user option denote-known-keywords.
More candidates can be inferred from the names of existing notes, by
setting denote-infer-keywords to non-nil (which is the case by
default).
Multiple keywords can be inserted by separating them with a comma (or
whatever the value of the crm-separator is—which should be a comma).
When the user option denote-sort-keywords is non-nil (the default),
keywords are sorted alphabetically (technically, the sorting is done
with string-lessp).
The interactive behaviour of the denote command is influenced by the
user option denote-prompts (The denote-prompts option).
The denote command can also be called from Lisp. Read its doc string
for the technicalities.
In the interest of discoverability, denote is also available under the
alias denote-create-note.
The user option denote-prompts determines how the denote command
will behave interactively (Standard note creation).
The value is a list of symbols, which includes any of the following:
title: Prompt for the title of the new note.keywords: Prompts with completion for the keywords of the new note. Available candidates are those specified in the user optiondenote-known-keywords. If the user optiondenote-infer-keywordsis non-nil, keywords in existing note file names are included in the list of candidates. Thekeywordsprompt usescompleting-read-multiple, meaning that it can accept multiple keywords separated by a comma (or whatever the value ofcrm-sepatoris).file-type: Prompts with completion for the file type of the new note. Available candidates are those specified in the user optiondenote-file-type. Without this prompt,denoteuses the value ofdenote-file-type.subdirectory: Prompts with completion for a subdirectory in which to create the note. Available candidates are the value of the user optiondenote-directoryand all of its subdirectories. Any subdirectory must already exist: Denote will not create it.date: Prompts for the date of the new note. It will expect an input like 2022-06-16 or a date plus time: 2022-06-16 14:30. Without thedateprompt, thedenotecommand uses thecurrent-time.The denote-date-prompt-use-org-read-date option.
template: Prompts for a KEY among thedenote-templates. The value of that KEY is used to populate the new note with content, which is added after the front matter (The denote-templates option).signature: - Prompts for an arbitrary string that can be used to establish a sequential relationship between files (e.g. 1, 1a, 1b, 1b1, 1b2, …). Signatures have no strictly defined function and are up to the user to apply as they see fit. One use-case is to implement Niklas Luhmann’s Zettelkasten system for a sequence of notes (Folgezettel). Signatures are not included in a file’s front matter. They are reserved solely for creating a sequence in a file listing, at least for the time being. To insert a link that includes the signature, use the commanddenote-link-with-signature(Insert link to file with signature).
The prompts occur in the given order.
If the value of this user option is nil, no prompts are used. The
resulting file name will consist of an identifier (i.e. the date and
time) and a supported file type extension (per denote-file-type).
Recall that Denote’s standard file-naming scheme is defined as follows (The file-naming scheme):
DATE--TITLE__KEYWORDS.EXT
If either or both of the title and keywords prompts are not
included in the value of this variable, file names will be any of
those permutations:
DATE.EXT DATE--TITLE.EXT DATE__KEYWORDS.EXT
When in doubt, always include the title and keywords prompts.
Finally, this user option only affects the interactive use of the
denote command (advanced users can call it from Lisp). For ad-hoc
interactive actions that do not change the default behaviour of the
denote command, users can invoke these convenience commands:
denote-type, denote-subdirectory, denote-date,
denote-signature. They are described in the subsequent section
(Convenience commands for note creation).
The user option denote-templates is an alist of content templates for
new notes. A template is arbitrary text that Denote will add to a newly
created note right below the front matter.
Templates are expressed as a (KEY . STRING) association.
- The
KEYis the name which identifies the template. It is an arbitrary symbol, such asreport,memo,statement. - The
STRINGis ordinary text that Denote will insert as-is. It can contain newline characters to add spacing. Below we show some concrete examples.
The user can choose a template either by invoking the command
denote-template or by changing the user option denote-prompts to
always prompt for a template when calling the denote command.
The denote-prompts option.
Convenience commands for note creation.
Templates can be written directly as one large string. For example (the
\n character is read as a newline):
(setq denote-templates
'((report . "* Some heading\n\n* Another heading")
(memo . "* Some heading
* Another heading
")))Long strings may be easier to type but interpret indentation literally.
Also, they do not scale well. A better way is to use some Elisp code to
construct the string. This would typically be the concat function,
which joins multiple strings into one. The following is the same as the
previous example:
(setq denote-templates
`((report . "* Some heading\n\n* Another heading")
(memo . ,(concat "* Some heading"
"\n\n"
"* Another heading"
"\n\n"))))Notice that to evaluate a function inside of an alist we use the
backtick to quote the alist (NOT the straight quote) and then prepend a
comma to the expression that should be evaluated. The concat form
here is not sensitive to indentation, so it is easier to adjust for
legibility.
DEV NOTE: We do not provide more examples at this point, though feel welcome to ask for help if the information provided herein is not sufficient. We shall expand the manual accordingly.
Sometimes the user needs to create a note that has different
requirements from those of denote (Standard note creation). While
this can be achieved globally by changing the denote-prompts user
option, there are cases where an ad-hoc method is the appropriate one
(The denote-prompts option).
To this end, Denote provides the following convenience interactive commands for note creation:
- Create note by specifying file type
- The
denote-typecommand creates a note while prompting for a file type.This is the equivalent to calling
denotewhendenote-promptsis set to'(file-type title keywords). In practical terms, this lets you produce, say, a note in Markdown even though you normally write in Org (Standard note creation).The
denote-create-note-using-typeis an alias ofdenote-type. - Create note using a date
- Normally, Denote reads the current date
and time to construct the unique identifier of a newly created note
(Standard note creation). Sometimes, however, the user needs to set
an explicit date+time value.
This is where the
denote-datecommand comes in. It creates a note while prompting for a date. The date can be in YEAR-MONTH-DAY notation like2022-06-30or that plus the time:2022-06-16 14:30.The denote-date-prompt-use-org-read-date option.
This is the equivalent to calling
denotewhendenote-promptsis set to'(date title keywords).The
denote-create-note-using-dateis an alias ofdenote-date. - Create note in a specific directory
- The
denote-subdirectorycommand creates a note while prompting for a subdirectory. Available candidates include the value of the variabledenote-directoryand any subdirectory thereof (Denote does not create subdirectories).This is equivalent to calling
denotewhendenote-promptsis set to'(subdirectory title keywords).The
denote-create-note-in-subdirectoryis a more descriptive alias ofdenote-subdirectory. - Create note and add a template
- The
denote-templatecommand creates a new note and inserts the specified template below the front matter (The denote-templates option). Available candidates for templates are specified in the user optiondenote-templates.This is equivalent to calling
denotewhendenote-promptsis set to'(template title keywords).The
denote-create-note-with-templateis an alias of the commanddenote-template, meant to help with discoverability. - Create note with a signature
- The
denote-signaturecommand first prompts for an arbitrary string to use in the optionalSIGNATUREfield of the file name and then asks for a title and keywords. Signatures are arbitrary strings of alphanumeric characters which can be used to establish sequential relations between file at the level of their file name (e.g. 1, 1a, 1b, 1b1, 1b2, …).The
denote-create-note-using-signatureis an alias of the commanddenote-signatureintended to make the functionality more discoverable.
The convenience commands we provide only cover some basic use-cases (Convenience commands for note creation). The user may require combinations that are not covered, such as to prompt for a template and for a subdirectory, instead of only one of the two. To this end, we show how to follow the code we use in Denote to write your own variants of those commands.
First let’s take a look at the definition of one of those commands.
They all look the same, but we use denote-subdirectory for this
example:
(defun denote-subdirectory ()
"Create note while prompting for a subdirectory.
Available candidates include the value of the variable
`denote-directory' and any subdirectory thereof.
This is equivalent to calling `denote' when `denote-prompts' is
set to '(subdirectory title keywords)."
(declare (interactive-only t))
(interactive)
(let ((denote-prompts '(subdirectory title keywords)))
(call-interactively #'denote)))The hyphenated word after defun is the name of the function. It has
to be unique. Then we have the documentation string (or “doc string”)
which is for the user’s convenience.
This function is interactive, meaning that it can be called via M-x
or be assigned to a key binding. Then we have the local binding of the
denote-prompts to the desired combination (“local” means specific to
this function without affecting other contexts). Lastly, it calls the
standard denote command interactively, so it uses all the prompts in
their specified order.
Now let’s say we want to have a command that (i) asks for a template and
(ii) for a subdirectory (The denote-templates option). All we need to
do is tweak the let bound value of denote-prompts and give our
command a unique name:
;; Like `denote-subdirectory' but also ask for a template
(defun denote-subdirectory-with-template ()
"Create note while also prompting for a template and subdirectory.
This is equivalent to calling `denote' when `denote-prompts' is
set to '(template subdirectory title keywords)."
(declare (interactive-only t))
(interactive)
(let ((denote-prompts '(template subdirectory title keywords)))
(call-interactively #'denote)))The tweaks to denote-prompts determine how the command will behave
(The denote-prompts option). Use this paradigm to write your own
variants which you can then assign to keys, invoke with M-x, or add
to the list of commands available at the denote-command-prompt
(Choose which commands to prompt for).
By default, Denote uses its own simple prompt for date or date+time
input (The denote-prompts option). This is done when the
denote-prompts option includes a date symbol and/or when the user
invokes the denote-date command.
Users who want to benefit from the more advanced date selection method
that is common in interactions with Org mode, can set the user option
denote-date-prompt-use-org-read-date to a non-nil value.
The commands denote-keywords-add and denote-keywords-remove
streamline the process of interactively updating a file’s keywords in
the front matter and renaming it accordingly.
The denote-keywords-add asks for keywords using the familiar
minibuffer prompt (Standard note creation). It then renames the file
(Rename a single file based on its front matter).
Similarly, the denote-keywords-remove removes one or more keywords
from the list of existing keywords and then renames the file
accordingly.
[ Rewritten as part of {{{development-version}}}. ]
In Org parlance, an entry with all its subheadings and other contents is a “subtree”. Denote can operate on the subtree to extract it from the current file and create a new file out of it. One such workflow is to collect thoughts in a single document and produce longer standalone notes out of them upon review.
The command denote-org-extras-extract-org-subtree (part of the
optional denote-org-extras.el extension) is used for this purpose.
It creates a new Denote note using the current Org subtree. In doing
so, it removes the subtree from its current file and moves its
contents into a new file.
The text of the subtree’s heading becomes the #+title of the new
note. Everything else is inserted as-is.
If the heading has any tags, they are used as the keywords of the new
note. If the Org file has any #+filetags they are taken as well
(Org’s #+filetags are inherited by the headings). If none of these
are true and the user option denote-prompts includes an entry for
keywords, then denote-org-extras-extract-org-subtree prompts for
keywords. Else the new note has no keywords (Add or remove keywords interactively).
If the heading has a PROPERTIES drawer, it is retained for further
review.
If the heading’s PROPERTIES drawer includes a DATE or CREATED
property, or there exists a CLOSED statement with a timestamp value,
use that to derive the date (or date and time) of the new note (if
there is only a date, the time is taken as 00:00). If more than one of
these is present, the order of preference is DATE, then CREATED,
then CLOSED. If none of these is present, the current time is used.
If the denote-prompts includes an entry for a date, then the command
prompts for a date at this stage (also see denote-date-prompt-use-org-read-date).
For the rest, it consults the value of the user option
denote-prompts in the following scenaria:
- To optionally prompt for a subdirectory, otherwise it produces the
new note in the
denote-directory. - To optionally prompt for a file signature, otherwise to not use any.
The new note is an Org file regardless of the user option
denote-file-type.
For integration with org-capture, the user must first add the relevant
template. Such as:
(with-eval-after-load 'org-capture
(add-to-list 'org-capture-templates
'("n" "New note (with Denote)" plain
(file denote-last-path)
#'denote-org-capture
:no-save t
:immediate-finish nil
:kill-buffer t
:jump-to-captured t)))[ In the future, we might develop Denote in ways which do not require such manual intervention. More user feedback is required to identify the relevant workflows. ]
Once the template is added, it is accessed from the specified key. If,
for instance, org-capture is bound to C-c c, then the note creation
is initiated with C-c c n, per the above snippet. After that, the
process is the same as with invoking denote directly, namely: a prompt
for a title followed by a prompt for keywords (Standard note creation).
Users may prefer to leverage org-capture in order to extend file
creation with the specifiers described in the org-capture-templates
documentation (such as to capture the active region and/or create a
hyperlink pointing to the given context).
IMPORTANT. Due to the particular file-naming scheme of Denote, which is
derived dynamically, such specifiers or other arbitrary text cannot be
written directly in the template. Instead, they have to be assigned to
the user option denote-org-capture-specifiers, which is interpreted by
the function denote-org-capture. Example with our default value:
(setq denote-org-capture-specifiers "%l\n%i\n%?")Note that denote-org-capture ignores the denote-file-type: it always
sets the Org file extension for the created note to ensure that the
capture process works as intended, especially for the desired output of
the denote-org-capture-specifiers.
This section assumes knowledge of how Denote+org-capture work, as explained in the previous section (Create note using Org capture).
The previous section shows how to define an Org capture template that
always prompts for a title and keywords. There are, however, cases
where the user wants more control over what kind of input Denote will
prompt for. To this end, we provide the function
denote-org-capture-with-prompts. Below we explain it and then show
some examples of how to use it.
The denote-org-capture-with-prompts is like denote-org-capture but
with optional prompt parameters.
When called without arguments, it does not prompt for anything. It just returns the front matter with title and keyword fields empty and the date and identifier fields specified. It also makes the file name consist of only the identifier plus the Org file name extension.
The file-naming scheme.
Otherwise, it produces a minibuffer prompt for every non-nil value
that corresponds to the TITLE, KEYWORDS, SUBDIRECTORY, DATE,
and TEMPLATE arguments. The prompts are those used by the standard
denote command and all of its utility commands.
Points of entry.
When returning the contents that fill in the Org capture template, the
sequence is as follows: front matter, TEMPLATE, and then the value
of the user option denote-org-capture-specifiers.
Important note: in the case of SUBDIRECTORY actual subdirectories
must exist—Denote does not create them. Same principle for
TEMPLATE as templates must exist and are specified in the user
option denote-templates.
This is how one can incorporate denote-org-capture-with-prompts in
their Org capture templates. Instead of passing a generic t which
makes it hard to remember what the argument means, we use semantic
keywords like :title for our convenience (internally this does not
matter as the value still counts as non-nil, so :foo for TITLE is
treated the same as :title or t).
;; This prompts for TITLE, KEYWORDS, and SUBDIRECTORY
(add-to-list 'org-capture-templates
'("N" "New note with prompts (with denote.el)" plain
(file denote-last-path)
(function
(lambda ()
(denote-org-capture-with-prompts :title :keywords :subdirectory)))
:no-save t
:immediate-finish nil
:kill-buffer t
:jump-to-captured t))
;; This prompts only for SUBDIRECTORY
(add-to-list 'org-capture-templates
'("N" "New note with prompts (with denote.el)" plain
(file denote-last-path)
(function
(lambda ()
(denote-org-capture-with-prompts nil nil :subdirectory)))
:no-save t
:immediate-finish nil
:kill-buffer t
:jump-to-captured t))
;; This prompts for TITLE and SUBDIRECTORY
(add-to-list 'org-capture-templates
'("N" "New note with prompts (with denote.el)" plain
(file denote-last-path)
(function
(lambda ()
(denote-org-capture-with-prompts :title nil :subdirectory)))
:no-save t
:immediate-finish nil
:kill-buffer t
:jump-to-captured t))The command denote-region takes the contents of the active region
and then calls the denote command. Once a new note is created, it
inserts the contents of the region therein. This is useful to
quickly elaborate on some snippet of text or capture it for future
reference.
When the denote-region command is called with an active region, it
finalises its work by calling denote-region-after-new-note-functions.
This is an abnormal hook, meaning that the functions added to it are
called with arguments. The arguments are two, representing the
beginning and end positions of the newly inserted text.
A common use-case for Org mode users is to call the command
org-insert-structure-template after a region is inserted. Emacs
will thus prompt for a structure template, such as the one
corresponding to a source block. In this case the function added to
denote-region-after-new-note-functions does not actually need
aforementioned arguments: it can simply declare those as ignored by
prefixing the argument names with an underscore (an underscore is
enough, but it is better to include a name for clarity). For example,
the following will prompt for a structure template as soon as
denote-region is done:
(defun my-denote-region-org-structure-template (_beg _end)
(when (derived-mode-p 'org-mode)
(activate-mark)
(call-interactively 'org-insert-structure-template)))
(add-hook 'denote-region-after-new-note-functions #'my-denote-region-org-structure-template)Remember that denote-region-after-new-note-functions are not called
if denote-region is used without an active region.
Sometimes it is necessary to briefly interrupt the ongoing writing
session to open an existing note or, if that is missing, to create it.
This happens when a new tangential thought occurs and the user wants
to confirm that an entry for it is in place. To this end, Denote
provides the command denote-open-or-create as well as its more
flexible counterpart denote-open-or-create-with-command.
The denote-open-or-create prompts to visit a file in the
denote-directory. At this point, the user must type in search terms
that match a file name. If the input does not return any matches and
the user confirms their choice to proceed (usually by typing RET
twice, depending on the minibuffer settings), denote-open-or-create
will call the denote command interactively to create a new note. It
will then use whatever prompts denote normally has, per the user
option denote-prompts (Standard note creation). If the title prompt
is involved (the default behaviour), the denote-open-or-create sets
up this prompt to have the previous input as the default title of the
note to-be-created. This means that the user can type RET at the
empty prompt to re-use what they typed in previously. Commands to use
previous inputs from the history are also available (M-p or M-n in
the minibuffer, which call previous-history-element and
next-history-element by default). Accessing the history is helpful
to, for example, make further edits to the available text.
The denote-open-or-create-with-command is like the above, except
when it is about to create the new note it first prompts for the
specific file-creating command to use (Points of entry). For example,
the user may want to specify a signature for this new file, so they
can select the denote-signature command.
Denote provides similar functionality for linking to an existing note or creating a new one (Link to a note or create it if missing).
The user option denote-directory accepts a value that represents the
path to a directory, such as ~/Documents/notes. Normally, the user
will have one place where they store all their notes, in which case this
arrangement shall suffice.
There is, however, the possibility to maintain separate directories of notes. By “separate”, we mean that they do not communicate with each other: no linking between them, no common keywords, nothing. Think of the scenario where one set of notes is for private use and another is for an employer. We call these separate directories “silos”.
To create silos, the user must specify a local variable at the root of
the desired directory. This is done by creating a .dir-locals.el
file, with the following contents:
;;; Directory Local Variables. For more information evaluate:
;;;
;;; (info "(emacs) Directory Variables")
((nil . ((denote-directory . default-directory))))When inside the directory that contains this .dir-locals.el file, all
Denote commands/functions for note creation, linking, the inference of
available keywords, et cetera will use the silo as their point of
reference. They will not read the global value of denote-directory.
The global value of denote-directory is read everywhere else except
the silos.
Use custom commands to select a silo.
In concrete terms, this is a representation of the directory structures
(notice the .dir-locals.el file is needed only for the silos):
;; This is the global value of 'denote-directory' (no need for a .dir-locals.el) ~/Documents/notes |-- 20210303T120534--this-is-a-test__journal_philosophy.txt |-- 20220303T120534--another-sample__journal_testing.md `-- 20220620T181255--the-third-test__keyword.org ;; A silo with notes for the employer ~/different/path/to/notes-for-employer |-- .dir-locals.el |-- 20210303T120534--this-is-a-test__conference.txt |-- 20220303T120534--another-sample__meeting.md `-- 20220620T181255--the-third-test__keyword.org ;; Another silo with notes for my volunteering ~/different/path/to/notes-for-volunteering |-- .dir-locals.el |-- 20210303T120534--this-is-a-test__activism.txt |-- 20220303T120534--another-sample__teambuilding.md `-- 20220620T181255--the-third-test__keyword.org
It is possible to configure other user options of Denote to have a
silo-specific value. For example, this one changes the
denote-known-keywords only for this particular silo:
;;; Directory Local Variables. For more information evaluate:
;;;
;;; (info "(emacs) Directory Variables")
((nil . ((denote-directory . default-directory)
(denote-known-keywords . ("food" "drink")))))This one is like the above, but also disables denote-infer-keywords:
;;; Directory Local Variables. For more information evaluate:
;;;
;;; (info "(emacs) Directory Variables")
((nil . ((denote-directory . default-directory)
(denote-known-keywords . ("food" "drink"))
(denote-infer-keywords . nil))))To expand the list of local variables to, say, cover specific major modes, we can do something like this:
;;; Directory Local Variables. For more information evaluate:
;;;
;;; (info "(emacs) Directory Variables")
((nil . ((denote-directory . default-directory)
(denote-known-keywords . ("food" "drink"))
(denote-infer-keywords . nil)))
(org-mode . ((org-hide-emphasis-markers . t)
(org-hide-macro-markers . t)
(org-hide-leading-stars . t))))IMPORTANT If your silo contains sub-directories of notes, you
should replace default-directory in the above examples with an
absolute path to your silo directory, otherwise links from files
within the sub-directories cannot be made to files in the parent
directory. For example:
;;; Directory Local Variables. For more information evaluate:
;;;
;;; (info "(emacs) Directory Variables")
((nil . ((denote-directory . "~/my-silo")
(denote-known-keywords . ("food" "drink"))
(denote-infer-keywords . nil)))
(org-mode . ((org-hide-emphasis-markers . t)
(org-hide-macro-markers . t)
(org-hide-leading-stars . t))))As not all user options have a “safe” local value, Emacs will ask the
user to confirm their choice and to store it in the Custom code
snippet that is normally appended to init file (or added to the file
specified by the user option custom-file).
Finally, it is possible to have a .dir-locals.el for subdirectories
of any denote-directory. Perhaps to specify a different set of
known keywords, while not making the subdirectory a silo in its own
right. We shall not expand on such an example, as we trust the user
to experiment with the best setup for their workflow.
Feel welcome to ask for help if the information provided herein is not sufficient. The manual shall be expanded accordingly.
[ As part of version 2.1.0, the contents of this section
are formally provided in the file denote-silo-extras.el. We keep
this here for existing users. Otherwise consult the new entry in
the manual (The =denote-silo-extras.el=). ]
We implement silos as directory-local values of the user option
denote-directory. This means that all Denote commands read from the
local value if they are invoked from that context. For example, if
~/Videos/recordings is a silo and ~/Documents/notes is the
default/global value of denote-directory all Denote commands will
read the video’s path when called from there (e.g. by using Emacs’
dired); any other context reads the global value.
Maintain separate directory silos for notes.
There are cases where the user (i) wants to maintain multiple silos and (ii) prefers an interactive way to switch between them without going through Dired. Since this is specific to the user’s workflow, it is easier to have some custom code for it. The following should be added to the user’s Denote configuration:
(defvar my-denote-silo-directories
`("/home/prot/Videos/recordings"
"/home/prot/Documents/books"
;; You don't actually need to include the `denote-directory' here
;; if you use the regular commands in their global context. I am
;; including it for completeness.
,denote-directory)
"List of file paths pointing to my Denote silos.
This is a list of strings.")
(defvar my-denote-commands-for-silos
'(denote
denote-date
denote-subdirectory
denote-template
denote-type)
"List of Denote commands to call after selecting a silo.
This is a list of symbols that specify the note-creating
interactive functions that Denote provides.")
(defun my-denote-pick-silo-then-command (silo command)
"Select SILO and run Denote COMMAND in it.
SILO is a file path from `my-denote-silo-directories', while
COMMAND is one among `my-denote-commands-for-silos'."
(interactive
(list (completing-read "Select a silo: " my-denote-silo-directories nil t)
(intern (completing-read
"Run command in silo: "
my-denote-commands-for-silos nil t))))
(let ((denote-user-enforced-denote-directory silo))
(call-interactively command)))With this in place, M-x my-denote-pick-silo-then-command will use
minibuffer completion to select a silo among the predefined options
and then ask for the command to run in that context.
Note the use of the variable denote-user-enforced-denote-directory.
This variable is specially meant for custom commands to select
silos. When it is set, it overrides the global default value of
denote-directory as well as the value provided by the
.dir-locals.el file. Use it only when writing wrapper functions like
my-denote-pick-silo-then-command.
[ As part of {{{development-version}}}, we fixed an issue where a
C-u prefix argument was needed to select a silo. ]
The denote-silo-extras.el provides optional convenience functions for
working with silos (Maintain separate directory silos for notes).
Start by loading the relevant library:
(require 'denote-silo-extras)The user option denote-silo-extras-directories specifies a list of
directories that the user has set up as denote-directory silos.
The command denote-silo-extras-create-note prompts for a directory
among denote-silo-extras-directories and runs the denote command
from there.
Similar to the above, the command denote-silo-extras-open-or-create
prompts for a directory among denote-silo-extras-directories and runs
the denote-open-or-create command from there.
The command denote-silo-extras-select-silo-then-command prompts with
minibuffer completion for a directory among denote-silo-extras-directories.
Once the user selects a silo, a second prompt asks for a Denote
note-creation command to call from inside that silo (Points of entry).
The user option denote-excluded-directories-regexp instructs all
Denote functions that read or check file/directory names to omit
directories that match the given regular expression. The regexp needs
to match only the name of the directory, not its full path.
Affected operations include file prompts and functions that return the
available files in the value of the user option denote-directory
(Maintain separate directory silos for notes).
File prompts are used by several commands, such as denote-link and
denote-subdirectory.
Functions that check for files include denote-directory-files and
denote-directory-subdirectories.
The match is performed with string-match-p.
For developers or advanced users.
The user option denote-excluded-keywords-regexp omits keywords that
match a regular expression from the list of inferred keywords.
Keywords are inferred from file names and provided at relevant prompts
as completion candidates when the user option denote-infer-keywords
is non-nil.
The match is performed with string-match-p.
Denote registers a submenu for the menu-bar-mode. Users will find
the entry called “Denote”. From there they can use their pointer to
select a command. For a sample of how this looks, read the
development log: https://protesilaos.com/codelog/2023-03-31-emacs-denote-menu/.
The command denote-menu-bar-mode toggles the presentation of the
menu. It is enabled by default. [ The denote-menu-bar-mode is part
of {{{development-version}}}. ]
Emacs also provides support for operations through a context menu.
This is typically the set of actions that are made available via a
right mouse click. Users who enable context-menu-mode can register
the Denote entry for it by adding the following to their configuration
file:
(add-hook 'context-menu-functions #'denote-context-menu)Denote provides commands to rename files and update their front matter where relevant. For Denote to work, only the file name needs to be in order, by following our naming conventions (The file-naming scheme). The linking mechanism, in particular, needs just the identifier in the file name (Linking notes).
We write front matter in notes for the user’s convenience and for other tools to make use of that information (e.g. Org’s export mechanism). The renaming mechanism takes care to keep this data in sync with the file name, when the user performs a change.
Renaming is useful for managing existing files created with Denote, but also for converting older text files to Denote notes. Denote’s file-naming scheme is not specific to notes or text files: it is relevant for all sorts of items, such as multimedia and PDFs that form part of the user’s longer-term storage. While Denote does not manage such files (e.g. doesn’t create links to them), it already has all the mechanisms to facilitate the task of renaming them.
Apart from renaming files, Denote can also rename only the buffer.
The idea is that the underlying file name is correct but it can be
easier to use shorter buffer names when displaying them on the mode
line or switching between then with commands like switch-to-buffer.
Automatically rename Denote buffers.
The denote-rename-file command renames a file and updates existing
front matter if appropriate. It is possible to do the same with
multiple files (Rename multiple files interactively).
If in Dired, consider FILE to be the one at point, else prompt with
minibuffer completion for one. When called from Lisp, FILE is a
filesystem path represented as a string.
If FILE has a Denote-compliant identifier, retain it while updating
the TITLE, KEYWORDS, and SIGNATURE components of the file name.
Else create an identifier based on the following conditions:
- If optional
ASK-DATEis non-nil (such as with a prefix argument), prompt for a date and use it to derive the identifier. - If optional
ASK-DATEis nil (this is the case without a prefix argument), use the file attributes to determine the last modified date and format it as an identifier. - As a fallback, derive an identifier from the current time.
- If the resulting identifier is not unique among the files in the
variable
denote-directory, increment it such that it becomes unique.
Add TITLE to FILE. In interactive use, prompt for user input and
retrieve the default TITLE value from a line starting with a title
field in the file’s contents, depending on the given file type (Front matter).
Else, use the file name as a default value at the minibuffer prompt.
TITLE is a string.
Add SIGNATURE to FILE. In interactive use, prompt for SIGNATURE,
using an existing one as the default value at the minibuffer prompt.
SIGNATURE is a string.
Add KEYWORDS to FILE. In interactive use, prompt for KEYWORDS.
More than one keyword can be inserted when separated by the
`crm-sepator’ (normally a comma). KEYWORDS is a list of strings.
When called interactively, an empty input is converted to an empty list
of keywords.
Read the file type extension (like .txt) from the underlying file
and preserve it through the renaming process. Files that have no
extension are left without one.
Renaming only occurs relative to the current directory. Files are not moved between directories.
As a final step after the FILE, TITLE, KEYWORDS, and SIGNATURE
are collected, ask for confirmation, showing the difference between
old and new file names.
Do not ask for confirmation if the denote-rename-no-confirm option
is set to a non-nil value (The denote-rename-no-confirm option).
If the FILE has Denote-style front matter for the TITLE and
KEYWORDS, ask to rewrite their values in order to reflect the new
input (this step always requires confirmation and the underlying
buffer is not saved, so consider invoking diff-buffer-with-file to
double-check the effect). The rewrite of the TITLE and KEYWORDS in
the front matter should not affect the rest of the front matter.
If the file does not have front matter but is among the supported file
types (per denote-file-type), add front matter at the top of it and
leave the buffer unsaved for further inspection.
For the front matter of each file type, refer to the variables:
denote-org-front-matterdenote-text-front-matterdenote-toml-front-matterdenote-yaml-front-matter
This command is intended to (i) rename existing Denote notes while updating their title and keywords in the front matter, (ii) convert existing supported file types to Denote notes, and (ii) rename non-note files (e.g. PDF) that can benefit from Denote’s file-naming scheme.
The default behaviour of the denote-rename-file command is to ask
for an affirmative answer as a final step before changing the file
name and, where relevant, inserting or updating the corresponding
front matter (Rename a single file).
Remember that denote-rename-file does not save the underlying buffer
it modifies. It leaves it unsaved so that the user can review what
happened, such as by invoking the command diff-buffer-with-file.
Specialised commands that build on top of denote-rename-file may
internally bind this user option to a non-nil value in order to
perform their operation (e.g. denote-dired-rename-files goes through
each marked Dired file, prompting for the information to use, but
carries out the renaming without asking for confirmation (buffers
remain unsaved)).
In the previous section, we covered the more general mechanism of the
command denote-rename-file (Rename a single file). There is also a
way to have the same outcome by making Denote read the data in the
current file’s front matter and use it to construct/update the file
name. The command for this is denote-rename-file-using-front-matter.
It is only relevant for files that (i) are among the supported file
types, per denote-file-type, and (ii) have the requisite front matter
in place.
Suppose you have an .org file with this front matter (Front matter):
#+title: My sample note file #+date: [2022-08-05 Fri 13:10] #+filetags: :testing: #+identifier: 20220805T131044
Its file name reflects this information:
20220805T131044--my-sample-note-file__testing.org
You want to change its title and keywords manually, so you modify it thus:
#+title: My modified sample note file #+date: [2022-08-05 Fri 13:10] #+filetags: :testing:denote:emacs: #+identifier: 20220805T131044
At this stage, the file name still shows the old title and keywords.
You now invoke denote-rename-file-using-front-matter and it updates
the file name to:
20220805T131044--my-modified-sample-note-file__testing_denote_emacs.org
The renaming is subject to a “yes or no” prompt that shows the old and new names, just so the user is certain about the change.
If called interactively with a prefix argument (C-u by default) or
from Lisp with a non-nil AUTO-CONFIRM argument, this “yes or no”
prompt is skipped.
The identifier of the file, if any, is never modified even if it is edited in the front matter: Denote considers the file name to be the source of truth in this case, to avoid potential breakage with typos and the like.
The command denote-dired-rename-files renames the files that are
marked in a Dired buffer. Its behaviour is similar to the
denote-rename-file in that it prompts for a title, keywords, and
signature (Rename a single file). It does so over each marked file,
renaming one after the other.
Unlike denote-rename-file, the command denote-dired-rename-files
does not ask to confirm the changes made to the files: it performs
them outright. This is done to make it easier to rename multiple files
without having to confirm each step. For an even more direct approach,
check the command denote-dired-rename-marked-files-with-keywords.
- Rename by writing only keywords
- Rename multiple files based on their front matter
[ As part of {{{development-version}}} the
denote-dired-rename-marked-files is an alias for
denote-dired-rename-files. ]
The denote-dired-rename-marked-files-with-keywords command renames
marked files in Dired to conform with our file-naming scheme. It does
so by writing keywords to them. Specifically, it does the following:
- retains the file’s existing name and makes it the
TITLEfield, per Denote’s file-naming scheme; - sluggifies the
TITLEand adjusts its letter casing, according to our conventions; - prepends an identifier to the
TITLE, if one is missing; - preserves the file’s extension, if any;
- prompts once for
KEYWORDSand applies the user’s input to the corresponding field in the file name, rewriting any keywords that may exist while removing keywords that do exist ifKEYWORDSis empty; - adds or rewrites existing front matter to the underlying file, if it
is recognized as a Denote note (per the
denote-file-typeuser option), such that it includes the new keywords.
[ Note that the affected buffers are not saved. Users can thus check
them to confirm that the new front matter does not cause any
problems (e.g. with the diff-buffer-with-file command). Multiple
buffers can be saved in one go with save-some-buffers (read its
doc string). ]
As already noted, Denote can rename a file based on the data in its
front matter (Rename a single file based on its front matter). The
command denote-dired-rename-marked-files-using-front-matter extends
this principle to a batch operation which applies to all marked files in
Dired.
Marked files must count as notes for the purposes of Denote, which
means that they at least have an identifier in their file name and use
a supported file type, per denote-file-type. Files that do not meet
this criterion are ignored, because Denote cannot know if they have
front matter and what that may be. For such files, it is still
possible to rename them interactively (Rename multiple files interactively).
The command denote-change-file-type-and-front-matter provides the
convenience of converting a note taken in one file type, say, .txt
into another like .org. It presents a choice among the
denote-file-type options.
The conversion does NOT modify the existing front matter. Instead, it prepends new front matter to the top of the file. We do this as a safety precaution since the user can, in principle, add arbitrary extras to their front matter that we would not want to touch.
If in Dired, denote-change-file-type-and-front-matter operates on
the file at point, else it prompts with minibuffer completion for one.
The title of the file is retrieved from a line starting with a title
field in the file’s front matter, depending on the previous file type
(e.g. #+title for Org). The same process applies for keywords.
As a final step, the command asks for confirmation, showing the difference between old and new file names.
These are the faces used by the various Denote rename commands to style or highlight the old/new/current file shown in the relevant minibuffer prompts:
denote-faces-prompt-current-namedenote-faces-prompt-new-namedenote-faces-prompt-old-name
Notes are stored in the denote-directory. The default path is
~/Documents/notes. The denote-directory can be a flat listing,
meaning that it has no subdirectories, or it can be a directory tree.
Either way, Denote takes care to only consider “notes” as valid
candidates in the relevant operations and will omit other files or
directories.
Every note produced by Denote follows this pattern by default (Points of entry):
DATE==SIGNATURE--TITLE__KEYWORDS.EXTENSION
The DATE field represents the date in year-month-day format followed
by the capital letter T (for “time”) and the current time in
hour-minute-second notation. The presentation is compact:
20220531T091625. The DATE serves as the unique identifier of each
note and, as such, is also known as the file’s ID or identifier.
File names can include a string of alphanumeric characters in the
SIGNATURE field. Signatures have no clearly defined purpose and are up
to the user to define. One use-case is to use them to establish
sequential relations between files (e.g. 1, 1a, 1b, 1b1, 1b2, …).
Signatures are an optional extension to Denote’s file-naming scheme.
They can be added to newly created files on demand, with the command
denote-signature, or by modifying the value of the user option
denote-prompts.
The TITLE field is the title of the note, as provided by the user.
It automatically gets downcased by default and is also hyphenated
(Sluggification of file name components). An entry about “Economics
in the Euro Area” produces an economics-in-the-euro-area string for
the TITLE of the file name.
The KEYWORDS field consists of one or more entries demarcated by an
underscore (the separator is inserted automatically). Each keyword is
a string provided by the user at the relevant prompt which broadly
describes the contents of the entry.
Each of the keywords is a single word, with multiple keywords providing
the multi-dimensionality needed for advanced searches through Denote
files. Users who need to compose a keyword out of multiple words such
as camelCase/CamelCase and are encouraged to use the
denote-file-name-slug-functions user option accordingly
(Sluggification of file name components).
The EXTENSION is the file type. By default, it is .org (org-mode)
though the user option denote-file-type provides support for Markdown
with YAML or TOML variants (.md which runs markdown-mode) and plain
text (.txt via text-mode). Consult its doc string for the minutiae.
While files end in the .org extension by default, the Denote code base
does not actually depend on org.el and/or its accoutrements.
Examples:
20220610T043241--initial-thoughts-on-the-zettelkasten-method__notetaking.org 20220610T062201--define-custom-org-hyperlink-type__denote_emacs_package.md 20220610T162327--on-hierarchy-and-taxis__notetaking_philosophy.txt
The different field separators, namely -- and __ introduce an
efficient way to anchor searches (such as with Emacs commands like
isearch or from the command-line with find and related). A query
for _word always matches a keyword, while a regexp in the form of,
say, "\\([0-9T]+?\\)--\\(.*?\\)_" captures the date in group \1 and
the title in \2 (test any regular expression in the current buffer by
invoking M-x re-builder).
Features of the file-naming scheme for searching or filtering.
The denote-prompts can be configured in such ways to yield the
following file name permutations:
DATE.EXT DATE--TITLE.EXT DATE__KEYWORDS.EXT DATE==SIGNATURE.EXT DATE==SIGNATURE--TITLE.EXT DATE==SIGNATURE--TITLE__KEYWORDS.EXT DATE==SIGNATURE__KEYWORDS.EXT
When in doubt, stick to the default design.
While Denote is an Emacs package, notes should work long-term and not depend on the functionality of a specific program. The file-naming scheme we apply guarantees that a listing is readable in a variety of contexts. The Denote file-naming scheme is, in essence, an effective, low-tech invention.
Files names can contain any character that the file system permits. Denote imposes a few additional restrictions:
- The tokens “==”,
__and--are interpreted by Denote and should appear only once._is the separator for keywords. - The dot character is not allowed in a note’s file name, except to indicate the extension.
By default, Denote enforce other rules to file names through the user
option denote-file-name-slug-functions.
These rules are applied to file names by default:
- What we count as “illegal characters” are removed. The variable
denote-excluded-punctuation-regexpholds the relevant value. - Input for a file title is hyphenated. The original value is preserved in the note’s contents (Front matter).
- Spaces or other delimiters are removed from keywords, meaning that
hello-worldbecomeshelloworld. This is because hyphens in keywords do not work everywhere, such as in Org. - Signatures are like the above, but use the equals sign instead of hyphens.
- All file name components are downcased. Consider a
helloWorldorHelloWorldconvention for those cases where you would want to have a hyphen between constituent words of a keyword.
The user option denote-file-name-slug-functions can be used to control
the sluggification of the components of file names (The file-naming
scheme). The default method is explained in the previous section.
The value of this user option is an alist where each element is a cons
cell of the form (COMPONENT . METHOD). For example, here is the
default value:
'((title . denote-sluggify-title) (signature . denote-sluggify-signature) (keyword . denote-sluggify-keyword))
What these cons cells of (COMPONENT . METHOD) are:
- The
COMPONENTis an unquoted symbol amongtitle,signature,keyword, which refers to the corresponding component of the file name. - The
METHODis the function to be used to format the given component. This function should take a string as its parameter and return the string formatted for the file name. In the case of the `keyword’ component, the function receives a SINGLE string representing a single keyword and return it formatted for the file name. Joining the keywords together is handled by Denote. Note that the `keyword’ function is also applied to the keywords of the front matter.
By default, file names have three fields and two sets of field delimiters between them:
DATE--TITLE__KEYWORDS.EXTENSION
When a signature is present, this becomes:
DATE==SIGNATURE--TITLE__KEYWORDS.EXTENSION
Field delimiters practically serve as anchors for easier searching. Consider this example:
20220621T062327==1a2--introduction-to-denote__denote_emacs.txt
You will notice that there are two matches for the word denote: one
in the title field and another in the keywords’ field. Because of the
distinct field delimiters, if we search for -denote we only match
the first instance while _denote targets the second one. When
sorting through your notes, this kind of specificity is
invaluable—and you get it for free from the file names alone!
Similarly, a search for ==1= will show all notes that are related to
each other by virtue of their signature.
Users can get a lot of value out of this simple yet effective
arrangement, even if they have no knowledge of regular expressions.
One thing to consider, for maximum effect, is to avoid using
multi-word keywords as those can get hyphenated like the title and
will thus interfere with the above: either set the user option
denote-allow-multi-word-keywords to nil or simply insert single
words at the relevant prompts.
Notes have their own “front matter”. This is a block of data at the top of the file, with no empty lines between the entries, which is automatically generated at the creation of a new note. The front matter includes the title and keywords (aka “tags” or “filetags”, depending on the file type) which the user specified at the relevant prompt, as well as the date and unique identifier, which are derived automatically.
This is how it looks for Org mode (when denote-file-type is nil or the
org symbol):
#+title: This is a sample note #+date: [2022-06-30 Thu 16:09] #+filetags: :denote:testing: #+identifier: 20220630T160934
For Markdown with YAML (denote-file-type has the markdown-yaml
value), the front matter looks like this:
--- title: "This is a sample note" date: 2022-06-30T16:09:58+03:00 tags: ["denote", "testing"] identifier: "20220630T160958" ---
For Markdown with TOML (denote-file-type has the markdown-toml
value), it is:
+++ title = "This is a sample note" date = 2022-06-30T16:10:13+03:00 tags = ["denote", "testing"] identifier = "20220630T161013" +++
And for plain text (denote-file-type has the text value), we have
the following:
title: This is a sample note date: 2022-06-30 tags: denote testing identifier: 20220630T161028 ---------------------------
The format of the date in the front matter is controlled by the user
option denote-date-format. When nil, Denote uses a file-type-specific
format:
- For Org, an inactive timestamp is used, such as
[2022-06-30 Wed 15:31]. - For Markdown, the RFC3339 standard is applied:
2022-06-30T15:48:00+03:00. - For plain text, the format is that of ISO 8601:
2022-06-30.
If the value is a string, ignore the above and use it instead. The
string must include format specifiers for the date. These are described
in the doc string of format-time-string..
Per Denote’s design principles, the code is hackable. All front matter is stored in variables that are intended for public use. We do not declare those as “user options” because (i) they expect the user to have some degree of knowledge in Emacs Lisp and (ii) implement custom code.
[ NOTE for tinkerers: code intended for internal use includes double hyphens in its symbol. “Internal use” means that it can be changed without warning and with no further reference in the change log. Do not use any of it without understanding the consequences. ]
The variables which hold the front matter format are:
denote-org-front-matter
denote-text-front-matter
denote-toml-front-matter
denote-yaml-front-matter
These variables have a string value with specifiers that are used by the
format function. The formatting operation passes four arguments which
include the values of the given entries. If you are an advanced user
who wants to edit this variable to affect how front matter is produced,
consider using something like %2$s to control where the Nth argument
is placed.
When editing the value, make sure to:
- Not use empty lines inside the front matter block.
- Insert at least one empty line after the front matter block and do not use any empty line before it.
These help with consistency and might prove useful if we ever need to operate on the front matter as a whole.
With those granted, below are some examples. The approach is the same for all variables.
;; Like the default, but upcase the entries
(setq denote-org-front-matter
"#+TITLE: %s
#+DATE: %s
#+FILETAGS: %s
#+IDENTIFIER: %s
\n")
;; Change the order (notice the %N$s notation)
(setq denote-org-front-matter
"#+title: %1$s
#+filetags: %3$s
#+date: %2$s
#+identifier: %4$s
\n")
;; Remove the date
(setq denote-org-front-matter
"#+title: %1$s
#+filetags: %3$s
#+identifier: %4$s
\n")
;; Remove the date and the identifier
(setq denote-org-front-matter
"#+title: %1$s
#+filetags: %3$s
\n")Note that setq has a global effect: it affects the creation of all new
notes. Depending on the workflow, it may be preferrable to have a
custom command which let binds the different format. We shall not
provide examples at this point as this is a more advanced feature and we
are not yet sure what the user’s needs are. Please provide feedback and
we shall act accordingly.
Sometimes the user needs to produce new front matter for an existing
note. Perhaps because they accidentally deleted a line and could not
undo the operation. The command denote-add-front-matter can be used
for this very purpose.
In interactive use, denote-add-front-matter must be invoked from a
buffer that visits a Denote note. It prompts for a title and then for
keywords. These are the standard prompts we already use for note
creation, so the keywords’ prompt allows minibuffer completion and the
input of multiple entries, each separated by a comma (Points of entry).
The newly created front matter is added to the top of the file.
This command does not rename the file (e.g. to update the keywords). To
rename a file by reading its front matter as input, the user can rely on
denote-rename-file-using-front-matter (Renaming files).
Note that denote-add-front-matter is useful only for existing Denote
notes. If the user needs to convert a generic text file to a Denote
note, they can use one of the command which first rename the file to
make it comply with our file-naming scheme and then add the relevant
front matter.
Denote offers several commands for linking between notes.
All links target files which are Denote notes. This means that they
have our file-naming scheme, are writable/regular (not directory, named
pipe, etc.), and use the appropriate file type extension (per
denote-file-type). Furthermore, the files need to be inside the
denote-directory or one of its subdirectories. No other file is
recognised.
The following sections delve into the details.
The denote-link command inserts a link at point to a file specified
at the minibuffer prompt (The denote-org-store-link-to-heading user option).
Links are formatted depending on the file type of the current note. In
Org and plain text buffers, links are formatted thus:
[[denote:IDENTIFIER][DESCRIPTION]]. While in Markdown they are expressed
as [DESCRIPTION](denote:IDENTIFIER).
When denote-link is called with a prefix argument (C-u by
default), it formats links like [[denote:IDENTIFIER]]. The user
might prefer its simplicity.
By default, the description of the link is taken from the signature of
the file, if present, and the target file’s front matter’s title or, if
that is not available, from the file name. If the region is active, its
text is used as the link’s description instead. If the active region
has no text, the inserted link uses just the identifier, as with the
C-u prefix mentioned above.
Inserted links are automatically buttonized and remain active for as
long as the buffer is available. In Org this is handled by the major
mode: the denote: hyperlink type works exactly like the standard
file:. In Markdown and plain text, Denote performs the buttonization
of those links. To buttonize links in existing files while visiting
them, the user must add this snippet to their setup (it already excludes
Org):
(add-hook 'find-file-hook #'denote-link-buttonize-buffer)The denote-link-buttonize-buffer is also an interactive function in
case the user needs it.
Links are created only for files which qualify as a “note” for our purposes (Linking notes).
Links are styled with the denote-faces-link face, which looks exactly
like an ordinary link by default. This is just a convenience for the
user/theme in case they want denote: links to remain distinct from
other links.
[ The following is part of {{{development-version}}}. ]
In files whose major mode is markdown-mode, the default key binding
C-c C-o (which calls the command markdown-follow-thing-at-point)
correctly resolves denote: links. This method works in addition to
the RET key, which is made available by the aforementioned
buttonization. Interested users can refer to the function
denote-link-markdown-follow for the implementation details.
[ Part of {{{development-version}}}. ]
The user option denote-org-store-link-to-heading determines whether
org-store-link links to the current Org heading (such links are
merely “stored” and need to be inserted afterwards with the command
org-insert-link).
When its value is non-nil, org-store-link stores a link to the
current Org heading inside the Denote file. If the heading does not
have a CUSTOM_ID, it creates it and includes it in the heading’s
PROPERTIES drawer. If a CUSTOM_ID exists, org-store-link use it
as-is.
This make the resulting link a combination of the denote: link type,
pointing to the identifier of the current file, plus the value of the
heading’s CUSTOM_ID, such as:
[[denote:20240118T060608][Some test]][[denote:20240118T060608::#h:eed0fb8e-4cc7-478f-acb6-f0aa1a8bffcd][Some test::Heading text]]
Both lead to the same Denote file, but the latter jumps to the heading
with the given CUSTOM_ID. Notice that the link to the heading also
has a different description, which includes the heading text.
The value of the CUSTOM_ID is determined by the Org user option
org-id-method. The sample shown above uses the default UUID
infrastructure.
If denote-org-store-link-to-heading is set to a nil value, the
command org-store-link only stores links to the Denote file (using
its identifier), but not to the given heading. This is what Denote was
doing in versions prior to 3.0.0.
Note that the optional extension denote-org-extras.el defines the command
denote-org-extras-link-to-heading, which always links to a file+heading
regardless of the aforementioned user option (Insert link to an Org file with a further pointer to a heading).
[ This feature only works in Org mode files, as other file types do
not have a linking mechanism that handles unique identifiers for
headings or other patterns to jump to. If org-store-link is
invoked in one such file, it captures only the Denote identifier of
the file, even if this user option is set to a non-nil value. ]
[ Part of {{{development-version}}}. ]
As part of the optional denote-org-extras.el extension, the command
denote-org-extras-link-to-heading prompts for a link to an Org file
and then asks for a heading therein, using minibuffer completion. Once
the user provides input at the two prompts, the command inserts a link
at point which has the following pattern: [[denote:IDENTIFIER::#ORG-HEADING-CUSTOM-ID]][Description::Heading text]].
Because only Org files can have links to individual headings, the
command denote-org-extras-link-to-heading prompts only for Org files
(i.e. files which include the .org extension). Remember that Denote
works with many file types (The file-naming scheme).
This feature is similar to the concept of the user option denote-org-store-link-to-heading
(The denote-org-store-link-to-heading user option). It is, however,
interactive and differs in the directionality of the action. With that
user option, the command org-store-link will generate a CUSTOM_ID
for the current heading (or capture the value of one as-is), giving
the user the option to then call org-insert-link wherever they see
fit. By contrast, the command denote-org-extras-link-to-heading
prompts for a file, then a heading, and inserts the link at point.
The command denote-add-links adds links at point matching a
regular expression or plain string. The links are inserted as a
typographic list, such as:
- link1 - link2 - link3
Each link is formatted according to the file type of the current note,
as explained further above about the denote-link command. The current
note is excluded from the matching entries (adding a link to itself is
pointless).
When called with a prefix argument (C-u) denote-add-links will
format all links as [[denote:IDENTIFIER]], hence a typographic list:
- [[denote:IDENTIFIER-1]] - [[denote:IDENTIFIER-2]] - [[denote:IDENTIFIER-3]]
Same examples of a regular expression that can be used with this command:
journalmatch all files which includejournalanywhere in their name._journalmatch all files which includejournalas a keyword.^2022.*_journalmatch all file names starting with2022and including the keywordjournal.\.txtmatch all files including.txt. In practical terms, this only applies to the file extension, as Denote automatically removes dots (and other characters) from the base file name.
If files are created with denote-sort-keywords as non-nil (the
default), then it is easy to write a regexp that includes multiple
keywords in alphabetic order:
_denote.*_packagematch all files that include both thedenoteandpackagekeywords, in this order.\(.*denote.*package.*\)\|\(.*package.*denote.*\)is the same as above, but out-of-order.
Remember that regexp constructs only need to be escaped once (like \|)
when done interactively but twice when called from Lisp. What we show
above is for interactive usage.
Links are created only for files which qualify as a “note” for our purposes (Linking notes).
The command denote-link-with-signature prompts for a file among
those that contain a ===SIGNATURE= and inserts a link to it. The
description of the link includes the text of the signature and that of
the file’s title, if any. For example, a link to the following file:
20230925T144303==abc--my-first-signature-note__denote_testing.txt
will get this link: [[denote:20230925T144303][abc My first signature note]].
For more advanced uses, refer to the doc string of the denote-link
function.
The command denote-link-dired-marked-notes is similar to
denote-add-links in that it inserts in the buffer a typographic list
of links to Denote notes (Insert links matching a regexp). Though
instead of reading a regular expression, it lets the user mark files
in Dired and link to them. This should be easier for users of all
skill levels, instead of having to write a potentially complex regular
expression.
If there are multiple buffers that visit a Denote note, this command will ask to select one among them, using minibuffer completion. If there is only one buffer, it will operate in it outright. If there are no buffers, it will produce an error.
With optional ID-ONLY as a prefix argument (C-u by default), the
command inserts links with just the identifier, which is the same
principle as with denote-link and others (Adding a single link).
The command denote-link-dired-marked-notes is meant to be used from a
Dired buffer.
As always, links are created only for files which qualify as a “note” for our purposes (Linking notes).
In one’s note-taking workflow, there may come a point where they are expounding on a certain topic but have an idea about another subject they would like to link to (Linking notes). The user can always rely on the other linking facilities we have covered herein to target files that already exist. Though they may not know whether they already have notes covering the subject or whether they would need to write new ones. To this end, Denote provides two convenience commands:
denote-link-after-creating- Create new note in the background and
link to it directly.
Use
denoteinteractively to produce the new note. Its doc string or this manual explains which prompts will be used and under what conditions (Standard note creation).With optional
ID-ONLYas a prefix argument (this is theC-ukey, by default) create a link that consists of just the identifier. Else try to also include the file’s title. This has the same meaning as indenote-link(Adding a single link).IMPORTANT NOTE: Normally,
denotedoes not save the buffer it produces for the new note. This is a safety precaution to not write to disk unless the user wants it (e.g. the user may choose to kill the buffer, thus cancelling the creation of the note). However, for this command the creation of the note happens in the background and the user may miss the step of saving their buffer. We thus have to save the buffer in order to (i) establish valid links, and (ii) retrieve whatever front matter from the target file.
denote-link-after-creating-with-command- This command is like
denote-link-after-creatingexcept it prompts for a note-creating command (Points of entry). Use this to, for example, calldenote-signatureso that the newly created note has a signature as part of its file name. OptionalID-ONLYhas the same meaning as in the commanddenote-link-after-creating.
denote-link-or-create- Use
denote-linkonTARGETfile, creating it if necessary.If
TARGETfile does not exist, calldenote-link-after-creatingwhich runs thedenotecommand interactively to create the file. The established link will then be targeting that new file.If
TARGETfile does not exist, add the user input that was used to search for it to the history of thedenote-file-prompt. The user can then retrieve and possibly further edit their last input, using it as the newly created note’s actual title. At thedenote-file-prompttypeM-pwith the default key bindings, which callsprevious-history-element.With optional
ID-ONLYas a prefix argument create a link with just the file’s identifier. This has the same meaning as indenote-link.This command has the alias
denote-link-to-existing-or-new-note, which helps with discoverability.
The command denote-backlinks produces a bespoke buffer which
displays backlinks to the current note. A “backlink” is a link back
to the present entry.
By default, the backlinks’ buffer is designed to display the file name of the note linking to the current entry. Each file name is presented on its own line, like this:
Backlinks to "On being honest" (20220614T130812) ------------------------------------------------ 20220614T145606--let-this-glance-become-a-stare__journal.txt 20220616T182958--feeling-butterflies-in-your-stomach__journal.txt
When the user option denote-backlinks-show-context is non-nil, the
backlinks’ buffer displays the line on which a link to the current
note occurs. It also shows multiple occurrences, if present. It looks
like this (and has the appropriate fontification):
Backlinks to "On being honest" (20220614T130812) ------------------------------------------------ 20220614T145606--let-this-glance-become-a-stare__journal.txt 37: growing into it: [[denote:20220614T130812][On being honest]]. 64: As I said in [[denote:20220614T130812][On being honest]] I have never 20220616T182958--feeling-butterflies-in-your-stomach__journal.txt 62: indifference. In [[denote:20220614T130812][On being honest]] I alluded
Note that the width of the lines in the context depends on the
underlying file. In the above example, the lines are split at the
fill-column. Long lines will show up just fine. Also note that the
built-in user option xref-truncation-width can truncate long lines
to a given maximum number of characters.
Speed up backlinks’ buffer creation?
The backlinks’ buffer runs the major-mode denote-backlinks-mode. It
binds keys to move between links with n (next) and p (previous).
These are stored in the denote-backlinks-mode-map (use M-x
describe-mode (C-h m) in an unfamiliar buffer to learn more about
it). When the user option denote-backlinks-show-context is non-nil,
all relevant Xref key bindings are fully functional: again, check
describe-mode.
The backlinking facility uses Emacs’ built-in Xref infrastructure. On some operating systems, the user may need to add certain executables to the relevant environment variable.
Why do I get “Search failed with status 1” when I search for backlinks?
Backlinks to the current file can also be visited by using the
minibuffer completion interface with the denote-find-backlink
command (Visiting linked files via the minibuffer).
The placement of the backlinks’ buffer is subject to the user option
denote-link-backlinks-display-buffer-action. Due to the nature of the
underlying display-buffer mechanism, this inevitably is a relatively
advanced feature. By default, the backlinks’ buffer is displayed below
the current window. The doc string of our user option includes a sample
configuration that places the buffer in a left side window instead.
Reproducing it here for the sake of convenience:
(setq denote-link-backlinks-display-buffer-action
'((display-buffer-reuse-window
display-buffer-in-side-window)
(side . left)
(slot . 99)
(window-width . 0.3)))A “metanote” is an entry that describes other entries who have something in common. Writing metanotes can be part of a workflow where the user periodically reviews their work in search of patterns and deeper insights. For example, you might want to read your journal entries from the past year to reflect on your experiences, evolution as a person, and the like.
The commands denote-add-links, denote-link-dired-marked-notes are
suited for this task.
Insert links matching a regexp.
Insert links from marked files in Dired.
You will create your metanote the way you use Denote ordinarily
(metanotes may have the metanote keyword, among others), write an
introduction or however you want to go about it, invoke the command
which inserts multiple links at once (see the above-cited nodes), and
continue writing.
Metanotes can serve as entry points to groupings of individual notes. They are not the same as a filtered list of files, i.e. what you would do in Dired or the minibuffer where you narrow the list of notes to a given query. Metanotes contain the filtered list plus your thoughts about it. The act of purposefully grouping notes together and contemplating on their shared patterns is what adds value.
Your future self will appreciate metanotes for the function they serve in encapsulating knowledge, while current you will be equipped with the knowledge derived from the deliberate self-reflection.
Denote has a major-mode-agnostic mechanism to collect all linked file
references in the current buffer and return them as an appropriately
formatted list. This list can then be used in interactive commands.
The denote-find-link is such a command. It uses minibuffer
completion to visit a file that is linked to from the current note.
The candidates have the correct metadata, which is ideal for
integration with other standards-compliant tools (Extending Denote).
For instance, a package such as marginalia will display accurate
annotations, while the embark package will be able to work its magic
such as in exporting the list into a filtered Dired buffer (i.e. a
familiar Dired listing with only the files of the current minibuffer
session).
To visit backlinks to the current note via the minibuffer, use
denote-find-backlink. This is an alternative to placing backlinks
in a dedicated buffer (The backlinks’ buffer).
During a writing session, it is possible that a thought occurs which
does not require immediate attention but nonetheless must be linked to
from the current context. Denote can be used in this case to
establish a link to an existing note or, if that is missing, to create
it. The commands are denote-link-after-creating, its more flexible
variant denote-link-after-creating-with-command, the
denote-link-or-create, and denote-link-or-create-with-command.
The command denote-link-or-create prompts for an existing file in
the denote-directory in order to link to it (Linking notes). At
this point, the user must type in search terms that match a file name.
If the input does not return any matches and the user confirms their
choice to proceed (usually by typing RET twice, depending on the
minibuffer settings), denote-link-or-create will call the denote
command interactively to create a new note. It will then use whatever
prompts denote normally has, per the user option denote-prompts
(Standard note creation). If the title prompt is involved (the default
behaviour), the denote-link-or-create sets up this prompt to have
the previous input as the default title of the note to-be-created.
This means that the user can type RET at the empty prompt to re-use
what they typed in previously. Commands to use previous inputs from
the history are also available (M-p or M-n in the minibuffer,
which call previous-history-element and next-history-element by
default). Accessing the history is helpful to, for example, make
further edits to the available text.
In the case where a file is created, the process happens in the background, meaning that the new file is not displayed. It is simply linked to from the current context.
The denote-link-or-create-with-command is like the above, except
when it is about to create the new note it first prompts for the
specific file-creating command to use (Points of entry). For example,
the user may want to specify a signature for this new file, so they
can select the denote-signature command.
The commands denote-link-after-creating and denote-link-or-create-with-command
are conceptually the same as above except they do not have the “or
create” logic: they always create a new file in the backgroun (in
fact, the aforementioned use those two to perform the linking, which
is consistent with the composability and hackability of Denote).
In all of the above, an optional prefix argument (C-u by default)
creates a link that consists of just the identifier. This has the
same meaning as in the regular denote-link command.
Denote provides similar functionality for opening an existing note or creating a new one (Open an existing note or create it if missing).
For convenience, the denote-link command has an alias called
denote-insert-link. The denote-backlinks can also be used as
denote-show-backlinks-buffer. While denote-add-links is
aliased denote-link-insert-links-matching-regexp. The purpose of
these aliases is to offer alternative, more descriptive names of
select commands.
The user option denote-commands-for-new-notes specifies a list of
commands that are available at the denote-command-prompt. This
prompt is used by Denote commands that ask the user how to create a
new note, as described elsewhere in this manual:
- Open an existing note or create it if missing
- Link to a note or create it if missing
The default value includes all the basic file-creating commands (Points of entry). Users may customise this value if (i) they only want to see fewer options and/or (ii) wish to include their own custom command in the list (Write your own convenience commands).
One of the upsides of Denote’s file-naming scheme is the predictable
pattern it establishes, which appears as a near-tabular presentation in
a listing of notes (i.e. in Dired). The denote-dired-mode can help
enhance this impression, by fontifying the components of the file name
to make the date (identifier) and keywords stand out.
There are two ways to set the mode. Either use it for all directories, which probably is not needed:
(add-hook 'dired-mode-hook #'denote-dired-mode)Or configure the user option denote-dired-directories and then set up
the function denote-dired-mode-in-directories:
;; We use different ways to specify a path for demo purposes.
(setq denote-dired-directories
(list denote-directory
(thread-last denote-directory (expand-file-name "attachments"))
(expand-file-name "~/Documents/vlog")))
(add-hook 'dired-mode-hook #'denote-dired-mode-in-directories)The user option denote-dired-directories-include-subdirectories
specifies whether the denote-dired-directories also cover their
subdirectories. By default they do not. Set this option to t to
include subdirectories as well.
The faces we define for this purpose are:
denote-faces-datedenote-faces-delimiterdenote-faces-extensiondenote-faces-keywordsdenote-faces-signaturedenote-faces-subdirectorydenote-faces-timedenote-faces-title
For the time being, the diredfl package is not compatible with this
facility.
The denote-dired-mode does not only fontify note files that were
created by Denote: it covers every file name that follows our naming
conventions (The file-naming scheme). This is particularly useful for
scenaria where, say, one wants to organise their collection of PDFs and
multimedia in a systematic way (and, perhaps, use them as attachments
for the notes Denote produces if you are writing Org notes and are using
its standand attachments’ facility).
The minor mode denote-rename-buffer-mode provides the means to
automatically rename the buffer of a Denote file upon visiting the
file. This applies both to existing Denote files as well as new ones
(Points of entry). Enable the mode thus:
(denote-rename-buffer-mode 1)Buffers are named by applying the function specified in the user
option denote-rename-buffer-function. The default function is
denote-rename-buffer: it renames the buffer based on the template
set in the user option denote-rename-buffer-format. By default, the
formatting template targets only the TITLE component of the file
name (The file-naming scheme). Other fields are explained elsewhere in
this manual (The denote-rename-buffer-format).
Note that renaming a buffer is not the same as renaming a file (Renaming files). The former is just for convenience inside of Emacs. Whereas the latter is for writing changes to disk, making them available to all programs.
The user option denote-rename-buffer-format controls how the
function denote-rename-buffer chooses the name of the
buffer-to-be-renamed.
The value of this user option is a string. The following specifiers are placeholders for Denote file name components (The file-naming scheme):
- The
%tis the DenoteTITLEof the file. - The
%iis the DenoteIDENTIFIERof the file. - The
%dis the same as%i(DATEmnemonic). - The
%sis the DenoteSIGNATUREof the file. - The
%kis the DenoteKEYWORDSof the file. - The
%%is a literal percent sign.
In addition, the following flags are available for each of the specifiers:
0- Pad to the width, if given, with zeros instead of spaces.
-- Pad to the width, if given, on the right instead of the left.
<- Truncate to the width and precision, if given, on the left.
>- Truncate to the width and precision, if given, on the right.
^- Convert to upper case.
_- Convert to lower case.
When combined all together, the above are written thus:
%<flags><width><precision>SPECIFIER-CHARACTER
Any other string it taken as-is. Users may want, for example, to
include some text that makes Denote buffers stand out, such as
a [D] prefix. Examples:
;; Use the title (default)
(setq denote-rename-buffer-format "%t")
;; Use the title and keywords with some emoji in between
(setq denote-rename-buffer-format "%t 🤨 %k")
;; Use the title with a literal "[D]" before it
(setq denote-rename-buffer-format "[D] %t")Users who need yet more flexibility are best served by writing their
own function and assigning it to the denote-rename-buffer-function.
[ As part of version 3.0.0 (currently {{{development-version}}}), all
dynamic blocks are defined in the file denote-org-extras.el. The
file which was once called denote-org-dblock.el contains aliases
for the new function names and dipslays a warning about its
deprecation. There is no need to require the denote-org-extras
feature because all of Denote’s Org dynamic blocks are autoloaded
(meaning that they work as soon as they are used). For backward
compatibility, all dynamic blocks retain their original names as an
alias for the newer one. ]
Denote can optionally integrate with Org mode’s “dynamic blocks”
facility. This means that it can use special blocks that are evaluated
with C-c C-x C-u (org-dblock-update) to generate their contents.
The following subsections describe the types of Org dynamic blocks
provided by Denote.
- Org dynamic blocks to insert links or backlinks
- Org dynamic block to insert file contents
A dynamic block gets its contents by evaluating a function that
corresponds to the type of block. The block type and its parameters
are stated in the opening #+BEGIN line. Typing C-c C-x C-u
(org-dblock-update) with point on that line runs (or re-runs) the
associated function with the given parameters and populates the
block’s contents accordingly.
Dynamic blocks are particularly useful for metanote entries that reflect on the status of earlier notes (Writing metanotes).
The Org manual describes the technicalities of Dynamic Blocks. Evaluate:
(info "(org) Dynamic Blocks")[ As part of version 3.0.0 (currently {{{development-version}}}), all
dynamic blocks are defined in the file denote-org-extras.el. The
file which was once called denote-org-dblock.el contains aliases
for the new function names and dipslays a warning about its
deprecation. There is no need to require the denote-org-extras
feature because all of Denote’s Org dynamic blocks are autoloaded
(meaning that they work as soon as they are used). For backward
compatibility, all dynamic blocks retain their original names as an
alias for the newer one. ]
The denote-links block can be inserted at point with the command
denote-org-extras-dblock-insert-links or by manually including the
following in an Org file:
#+BEGIN: denote-links :regexp "YOUR REGEXP HERE" :sort-by-component nil :reverse-sort nil :id-only nil
:
#+END:
The denote-links block is also registered as an option for the
command org-dynamic-block-insert-dblock.
Type C-c C-x C-u (org-dblock-update) with point on the #+BEGIN
line to update the block.
- The
:regexpparameter is mandatory. Its value is a string and its behaviour is the same as that of thedenote-add-linkscommand (Insert links matching a regexp). Concretely, it produces a typographic list of links to files matching the giving regular expression. The value of the:regexpparameter may also be of the form read by therxmacro (Lisp notation instead of a string), as explained in the Emacs Lisp Reference Manual (evaluate this code to read the documentation:(info "(elisp) Rx Notation")). Note that you do not need to write an actual regular expression to get meaningful results: even something like_journalwill work to include all files that have ajournalkeyword. - The
:sort-by-componentparameter is optional. It sorts the files by the given Denote file name component. The value it accepts is an unquoted symbol amongtitle,keywords,signature,identifier. When using the commanddenote-org-extras-dblock-insert-files, this parameter is automatically inserted together with the (:regexpparameter) and the user is prompted for a file name component. - The
:reverse-sortparameter is optional. It reverses the order in which files appear in. This is meaningful even without the presence of the parameter:sort-by-component, though it also combines with it. - The
:id-onlyparameter is optional. It accepts atvalue, in which case links are inserted without a description text but only with the identifier of the given file. This has the same meaning as with thedenote-linkcommand and related facilities (Linking notes). - An optional
:block-nameparameter can be specified with a string value to add a#+nameto the results. This is useful for further processing using Org facilities (a feature that is outside Denote’s purview).
The same as above except for the :regexp parameter are true for the
denote-backlinks block. The block can be inserted at point with the
command denote-org-extras-dblock-insert-backlinks or by manually writing
this in an Org file:
#+BEGIN: denote-backlinks :sort-by-component nil :reverse-sort nil :id-only nil
:
#+END:
[ The denote-org-extras-dblock-insert-missing-links is part of
{{{development-version}}}. ]
Finally, the denote-missing-links block is available with the
command denote-org-extras-dblock-insert-missing-links. It is like
the aforementioned denote-links block, except it only lists links to
files that are not present in the current buffer. The parameters are
otherwise the same:
#+BEGIN: denote-missing-links :regexp "YOUR REGEXP HERE" :sort-by-component nil :reverse-sort nil :id-only nil
:
#+END:
Remember to type C-c C-x C-u (org-dblock-update) with point on the
#+BEGIN line to update the block.
[ As part of version 3.0.0 (currently {{{development-version}}}), all
dynamic blocks are defined in the file denote-org-extras.el. The
file which was once called denote-org-dblock.el contains aliases
for the new function names and dipslays a warning about its
deprecation. There is no need to require the denote-org-extras
feature because all of Denote’s Org dynamic blocks are autoloaded
(meaning that they work as soon as they are used). For backward
compatibility, all dynamic blocks retain their original names as an
alias for the newer one. ]
Denote can optionally use Org’s dynamic blocks facility to produce a section that lists entire file contents (Use Org dynamic blocks). This works by instructing Org to match a regular expression of Denote files, the same way we do with Denote links (Insert links matching a regexp).
This is useful to, for example, compile a dynamically concatenated
list of scattered thoughts on a given topic, like ^2023.*_emacs for
a long entry that incorporates all the notes written in 2023 with the
keyword emacs.
To produce such a block, call the command denote-org-extras-dblock-insert-files
or manually write the following block in an Org file and then type
C-c C-x C-u (org-dblock-update) on the #+BEGIN line to run it
(do it again to recalculate the block):
#+BEGIN: denote-files :regexp "YOUR REGEXP HERE"
:
#+END:
To fully control the output, include these additional optional parameters, which are described further below:
#+BEGIN: denote-files :regexp "YOUR REGEXP HERE" :sort-by-component nil :reverse-sort nil :no-front-matter nil :file-separator nil :add-links nil
:
#+END:
- The
:regexpparameter is mandatory. Its value is a string, representing a regular expression to match Denote file names. Its value may also be anrxexpression instead of a string, as noted in the previous section (Org dynamic blocks to insert links or backlinks). Note that you do not need to write an actual regular expression to get meaningful results: even something like_journalwill work to include all files that have ajournalkeyword. - The
:sort-by-componentparameter is optional. It sorts the files by the given Denote file name component. The value it accepts is an unquoted symbol amongtitle,keywords,signature,identifier. When using the commanddenote-org-extras-dblock-insert-files, this parameter is automatically inserted together with the (:regexpparameter) and the user is prompted for a file name component. - The
:reverse-sortparameter is optional. It reverses the order in which files appear in. This is meaningful even without the presence of the parameter:sort-by-component, though it also combines with it.
- The
:file-separatorparameter is optional. If it is omitted, then Denote will use no separator between the files it inserts. If the value istthedenote-org-extras-dblock-file-contents-separatoris applied at the end of each file: it introduces some empty lines and a horizontal rule between them to visually distinguish individual files. If the:file-separatorvalue is a string, it is used as the file separator (e.g. use"\n"to insert just one empty new line). - The
:no-front-matterparameter is optional. When set to atvalue, Denote tries to remove front matter from the files it is inserting in the dynamic block. The technique used to perform this operation is by removing all lines from the top of the file until the first empty line. This works with the default front matter that Denote adds, but is not 100% reliable with all sorts of user-level modifications and edits to the file. When the:no-front-matteris set to a natural number, Denote will omit that many lines from the top of the file. - The
:add-linksparameter is optional. When it is set to atvalue, all files are inserted as a typographic list and are indented accordingly. The first line in each list item is a link to the file whose contents are inserted in the following lines. When the value isid-only, then links are inserted without a description text but only with the identifier of the given file. This has the same meaning as with thedenote-linkcommand and related facilities (Linking notes). Remember that Org can fold the items in a typographic list the same way it does with headings. So even long files can be presented in this format without much trouble. - An optional
:block-nameparameter can be specified with a string value to add a#+nameto the results. This is useful for further processing using Org facilities (a feature that is outside Denote’s purview).
The denote-sort.el file is an optional extension to the core
functionality of Denote, which empowers users to sort files by the
given file name component (The file-naming scheme).
The command denote-sort-dired produces a Dired file listing with a
flat, filtered, and sorted set of files from the denote-directory.
It does so by means of three minibuffer prompts:
- It first asks for a regular expression with which to match Denote
files. Remember that due to Denote’s efficient file-naming scheme,
you do not need to write some complex regular expression. Even
something like
_journalwill match only files with ajournalkeyword. - Once the regular expression is provided, the command asks for a
Denote file name component to sort files by. This is a symbol among
title,keywords,signature, andidentifier. - Finally, it asks a “yes or no” on whether to reverse the sort order.
The resulting Dired listing is a regular Dired buffer, unlike that of
dired-virtual-mode (Use dired-virtual-mode for arbitrary file listings).
The dynamic Org blocks that Denote defines to insert file contents also use this feature (Org dynamic block to insert file contents).
DEVELOPMENT NOTE as of 2023-11-30 07:24 +0200: The sort mechanism will be incorporated in more functions on a case-by-case basis, subject to user feedback. For the time being, I am not documenting the functions that are only accessed from Lisp. Do not hesitate to contact me (Protesilaos) in person or on one of the development sources (mailing list or GitHub/GitLab mirror) if you have a use-case where sorting seems useful. I am happy to help but do not want to roll this feature everywhere before eliciting relevant feedback: once we add it, we are not going back.
Denote has a dedicated minibuffer history for each one of its prompts.
This practically means that using M-p (previous-history-element) and
M-n (next-history-element) will only cycle through the relevant
record of inputs, such as your latest titles in the TITLE prompt, and
keywords in the KEYWORDS prompt.
The built-in savehist library saves minibuffer histories. Sample
configuration:
(require 'savehist)
(setq savehist-file (locate-user-emacs-file "savehist"))
(setq history-length 500)
(setq history-delete-duplicates t)
(setq savehist-save-minibuffer-history t)
(add-hook 'after-init-hook #'savehist-mode)Denote is a tool with a narrow scope: create notes and link between them, based on the aforementioned file-naming scheme. For other common operations the user is advised to rely on standard Emacs facilities or specialised third-party packages. This section covers the details.
Denote provides a general-purpose mechanism to create new files that
broadly count as “notes” (Points of entry). Such files can be daily
entries in a journal. While it is possible to use the generic
denote command to maintain a journal, we provide an optional set of
convenience options and commands as part of denote-journal-extras.el.
To use those, add the following the Denote configuration:
(require 'denote-journal-extras)The command denote-journal-extras-new-entry creates a new entry in
the journal. Such a file has the denote-journal-extras-keyword,
which is journal by default (The file-naming scheme). The user can
set this keyword to an arbitrary string (single word is preferred).
New journal entries can be stored in the denote-directory or
subdirectory thereof. To make it easier for the user, the new journal
entry will be placed in denote-journal-extras-directory, which
defaults to a subdirectory of denote-directory called journal.
If denote-journal-extras-directory is nil, the denote-directory is
used. Journal entries will thus be in a flat listing together with
all other notes. They can still be retrieved easily by searching for
the denote-journal-extras-keyword (Features of the file-naming scheme for searching or filtering).
Furthermore, the command denote-journal-extras-new-entry will use
the current date as the title of the new entry. The exact format is
controlled by the user option denote-journal-extras-title-format.
Acceptable values for denote-journal-extras-title-format and their
corresponding styles are:
| Symbol | Style |
|---|---|
| day | Monday |
| day-date-month-year | Monday 19 September 2023 |
| day-date-month-year-24h | Monday 19 September 2023 20:49 |
| day-date-month-year-12h | Monday 19 September 2023 08:49 PM |
For example:
(setq denote-journal-extras-title-format 'day-date-month-year)If the value of this user option is nil, then
denote-journal-extras-new-entry will prompt for a title.
The denote-journal-extras-new-entry command also accepts an optional
DATE argument. When called internactively, this is a universal
prefix (e.g. C-u with the default key bindings). With DATE, it
prompts for a date to create a new journal entry for. The date prompt
can optionally use the Org date+calendar selection interface
(The denote-date-prompt-use-org-read-date option).
In terms of workflow, using the current date as the title is better
for maintaining a daily journal. A prompt for an arbitrary title is
more suitable for those who like to keep a record of something like a
thought or event (though this can also be achieved by the regular
denote command or maybe denote-subdirectory).
The denote-journal-extras-new-entry command calls the normal hook
denote-journal-extras-hook after it is done. The user can leverage
this to produce consequences therefrom, such as to set a timer with
the tmr package from GNU ELPA (Journaling with a timer).
The command denote-journal-extras-new-or-existing-entry locates an
existing journal entry or creates a new one. A journal entry is one
that has denote-journal-extras-keyword as part of its file name. If
there are multiple journal entries for the current date, it prompts
for one among them using minibuffer completion. If there is only one,
it visits it outright. If there is no journal entry, it creates one
by calling denote-journal-extra-new-entry (as described above).
[ The denote-journal-extras-link-or-create-entry is part of
{{{development-version}}}. ]
The command denote-journal-extras-link-or-create-entry links to the
journal entry for today or creates it in the background, if missing,
and then links to it from the current file. If there are multiple
journal entries for the same day, it prompts to select one among them
and then links to it. When called with an optional prefix argument
(such as C-u with default key bindings), the command prompts for a
date and then performs the aforementioned. With a double prefix
argument (C-u C-u), it also produces a link whose description
includes just the file’s identifier.
[ Revised as part of version 2.1.0 to conform with how we now tend to the needs of users who use Denote for journaling purposes (Keep a journal or diary). ]
Sometimes journaling is done with the intent to hone one’s writing skills. Perhaps you are learning a new language or wish to communicate your ideas with greater clarity and precision. As with everything that requires a degree of sophistication, you have to work for it—write, write, write!
One way to test your progress is to set a timer. It helps you gauge
your output and its quality. To use a timer with Emacs, consider the
tmr package. A new timer can be set with something like this:
;; Set 10 minute timer with the given description
(tmr "10" "Practice writing in my journal")To make this timer start as soon as a new journal entry is created
with the command denote-journal-extras-new-entry, add a function to
the denote-journal-extras-hook. For example:
;; Add an anonymous function, which is more difficult to modify after
;; the fact:
(add-hook 'denote-journal-extras-hook (lambda ()
(tmr "10" "Practice writing in my journal")))
;; Or write a small function that you can then modify without
;; revaluating the hook:
(defun my-denote-tmr ()
(tmr "10" "Practice writing in my journal"))
(add-hook 'denote-journal-extras-hook 'my-denote-tmr)
;; Or to make it fully featured, define variables for the duration and
;; the description and set it up so that you only need to modify
;; those:
(defvar my-denote-tmr-duration "10")
(defvar my-denote-tmr-description "Practice writing in my journal")
(defun my-denote-tmr ()
(tmr my-denote-tmr-duration my-denote-tmr-description))
(add-hook 'denote-journal-extras-hook 'my-denote-tmr)Once the timer elapses, stop writing and review your performance. Practice makes perfect!
Sources for tmr:
- Package name (GNU ELPA):
tmr - Official manual: https://protesilaos.com/emacs/tmr
- Change log: https://protesilaos.com/emacs/denote-changelog
- Git repo on SourceHut: https://git.sr.ht/~protesilaos/tmr
- Mirrors:
- GitHub: https://github.com/protesilaos/tmr
- GitLab: https://gitlab.com/protesilaos/tmr
- Mirrors:
- Mailing list: https://lists.sr.ht/~protesilaos/tmr
Emacs’ standard file manager (or directory editor) can read a regular
expression to mark the matching files. This is the command
dired-mark-files-regexp, which is bound to % m by default. For
example, % m _denote will match all files that have the denote
keyword (Features of the file-naming scheme for searching or filtering).
Once the files are matched, the user has two options: (i) narrow the list to the matching items or (ii) exclude the matching items from the list.
For the former, we want to toggle the marks by typing t (calls the
command dired-toggle-marks by default) and then hit the letter k
(for dired-do-kill-lines). The remaining files are those that match
the regexp that was provided earlier.
For the latter approach of filtering out the matching items, simply
involves the use of the k command (dired-do-kill-lines) to omit the
marked files from the list.
These sequences can be combined to incrementally narrow the list. Note
that dired-do-kill-lines does not delete files: it simply hides them
from the current view.
Revert to the original listing with g (revert-buffer).
For a convenient wrapper, consider this example:
(defvar prot-dired--limit-hist '()
"Minibuffer history for `prot-dired-limit-regexp'.")
;;;###autoload
(defun prot-dired-limit-regexp (regexp omit)
"Limit Dired to keep files matching REGEXP.
With optional OMIT argument as a prefix (\\[universal-argument]),
exclude files matching REGEXP.
Restore the buffer with \\<dired-mode-map>`\\[revert-buffer]'."
(interactive
(list
(read-regexp
(concat "Files "
(when current-prefix-arg
(propertize "NOT " 'face 'warning))
"matching PATTERN: ")
nil 'prot-dired--limit-hist)
current-prefix-arg))
(dired-mark-files-regexp regexp)
(unless omit (dired-toggle-marks))
(dired-do-kill-lines))Emacs’ Dired is a powerful file manager that builds its functionality
on top of the Unix ls command. As noted elsewhere in this manual,
the user can update the ls flags that Dired uses to display its
contents (I want to sort by last modified, why won’t Denote let me?).
What Dired cannot do is parse the output of a result that is produced
by piped commands, such as ls -l | sort -t _ -k2. This specific
example targets the second underscore-separated field of the file
name, per our conventions (The file-naming scheme). Conceretely, it
matches the “alpha” as the sorting key in something like this:
20220929T200432--testing-file-one__alpha.txtConsider then, how Dired will sort those files by their identifier:
20220929T200432--testing-file-one__alpha.txt
20220929T200532--testing-file-two__beta.txt
20220929T200632--testing-file-three__alpha.txt
20220929T200732--testing-file-four__beta.txtWhereas on the command line, we can get the following:
$ ls | sort -t _ -k 2 20220929T200432--testing-file-one__alpha.txt 20220929T200632--testing-file-three__alpha.txt 20220929T200532--testing-file-two__beta.txt 20220929T200732--testing-file-four__beta.txt
This is where dired-virtual-mode shows its utility. If we tweak our
command-line invocation to include ls -l, this mode can behave like
Dired on the listed files. (We omit the output of the -l flag from
this tutorial, as it is too verbose.)
What we now need is to capture the output of ls -l | sort -t _ -k 2
in an Emacs buffer and then enable dired-virtual-mode. To do that,
we can rely on either M-x shell or M-x eshell and then manually
copy the relevant contents.
For the user’s convenience, I share what I have for Eshell to quickly capture the last command’s output in a dedicated buffer:
(defcustom prot-eshell-output-buffer "*Exported Eshell output*"
"Name of buffer with the last output of Eshell command.
Used by `prot-eshell-export'."
:type 'string
:group 'prot-eshell)
(defcustom prot-eshell-output-delimiter "* * *"
"Delimiter for successive `prot-eshell-export' outputs.
This is formatted internally to have newline characters before
and after it."
:type 'string
:group 'prot-eshell)
(defun prot-eshell--command-prompt-output ()
"Capture last command prompt and its output."
(let ((beg (save-excursion
(goto-char (eshell-beginning-of-input))
(goto-char (point-at-bol)))))
(when (derived-mode-p 'eshell-mode)
(buffer-substring-no-properties beg (eshell-end-of-output)))))
;;;###autoload
(defun prot-eshell-export ()
"Produce a buffer with output of the last Eshell command.
If `prot-eshell-output-buffer' does not exist, create it. Else
append to it, while separating multiple outputs with
`prot-eshell-output-delimiter'."
(interactive)
(let ((eshell-output (prot-eshell--command-prompt-output)))
(with-current-buffer (get-buffer-create prot-eshell-output-buffer)
(let ((inhibit-read-only t))
(goto-char (point-max))
(unless (eq (point-min) (point-max))
(insert (format "\n%s\n\n" prot-eshell-output-delimiter)))
(goto-char (point-at-bol))
(insert eshell-output)
(switch-to-buffer-other-window (current-buffer))))))Bind prot-eshell-export to a key in the eshell-mode-map and give
it a try (I use C-c C-e). In the produced buffer, activate the
dired-virtual-mode.
embark is a remarkable package that lets you perform relevant,
context-dependent actions using a prefix key (simplifying in the
interest of brevity).
For our purposes, Embark can be used to produce a Dired listing
directly from the minibuffer. Suppose the current note has links to
three other notes. You might use the denote-find-link command to
pick one via the minibuffer. But why not turn those three links into
their own Dired listing? While in the minibuffer, invoke embark-act
which you may have already bound to C-. and then follow it up with
E (for the embark-export command).
This pattern can be repeated with any list of candidates, meaning that you can narrow the list by providing some input before eventually exporting the results with Embark.
Overall, this is very powerful and you might prefer it over doing the same thing directly in Dired, since you also benefit from all the power of the minibuffer (Narrow the list of files in Dired).
Emacs provides built-in commands which are wrappers of standard Unix
tools: M-x grep lets the user input the flags of a grep call and
pass a regular expression to the -e flag.
The author of Denote uses this thin wrapper instead:
(defvar prot-search--grep-hist '()
"Input history of grep searches.")
;;;###autoload
(defun prot-search-grep (regexp &optional recursive)
"Run grep for REGEXP.
Search in the current directory using `lgrep'. With optional
prefix argument (\\[universal-argument]) for RECURSIVE, run a
search starting from the current directory with `rgrep'."
(interactive
(list
(read-from-minibuffer (concat (if current-prefix-arg
(propertize "Recursive" 'face 'warning)
"Local")
" grep for PATTERN: ")
nil nil nil 'prot-search--grep-hist)
current-prefix-arg))
(unless grep-command
(grep-compute-defaults))
(if recursive
(rgrep regexp "*" default-directory)
(lgrep regexp "*" default-directory)))Rather than maintain custom code, consider using the excellent consult
package: it provides commands such as consult-grep and consult-find
which provide live results and are generally easier to use than the
built-in commands.
Part of the reason Denote does not reinvent existing functionality is to encourage you to learn more about Emacs. You do not need a bespoke “jump to my notes” directory because such commands do not scale well. Will you have a “jump to my downloads” then another for multimedia and so on? No.
Emacs has a built-in framework for recording persistent markers to
locations. Visit the denote-directory (or any dir/file for that
matter) and invoke the bookmark-set command (bound to C-x r m by
default). It lets you create a bookmark.
The list of bookmarks can be reviewed with the bookmark-bmenu-list
command (bound to C-x r l by default). A minibuffer interface is
available with bookmark-jump (C-x r b).
If you use the consult package, its default consult-buffer command
has the means to group together buffers, recent files, and bookmarks.
Each of those types can be narrowed to with a prefix key. The package
consult-dir is an extension to consult which provides useful extras
for working with directories, including bookmarks.
Peter Prevos has developed the denote-explore package which provides
four groups of Emacs commands to explore your Denote files:
- Summary statistics
- Count notes, attachments and keywords.
- Random walks
- Generate new ideas using serendipity.
- Janitor
- Manage your denote collection.
- Visualisations
- Visualise your Denote network.
The package’s documentation covers the details: https://lucidmanager.org/productivity/denote-explore/.
Peter Prevos has produced the citar-denote package which makes it
possible to write notes on BibTeX entries with the help of the citar
package. These notes have the citation’s unique key associated with
them in the file’s front matter. They also get a configurable keyword
in their file name, making it easy to find them in Dired and/or
retrieve them with the various Denote methods.
With citar-denote, the user leverages standard minibuffer completion
mechanisms (e.g. with the help of the vertico and embark packages)
to manage bibliographic notes and access those notes with ease. The
package’s documentation covers the details: https://lucidmanager.org/productivity/bibliographic-notes-in-emacs-with-citar-denote/.
If you are using Daniel Mendler’s consult (which is a brilliant
package), you will most probably like its consult-notes extension,
developed by Colin McLear. It uses the familiar mechanisms of Consult
to preview the currently selected entry and to filter searches via a
prefix key. For example:
(setq consult-notes-file-dir-sources
`(("Denote Notes" ?d ,(denote-directory))
("Books" ?b "~/Documents/books/")))With the above, M-x consult-notes will list the files in those two
directories. If you type d and space, it narrows the list to just
the notes, while b does the same for books.
The other approach is to enable the consult-notes-denote-mode. It
takes care to add the denote-directory to the sources that
consult-notes reads from. Denote notes are then filtered by the d
prefix followed by a space.
The minor mode has the extra feature of reformatting the title of
notes shown in the minibuffer. It isolates the TITLE component of
each note and shows it without hyphens, while presenting keywords in
their own column. The user option consult-notes-denote-display-id
can be set to nil to hide the identifier. Depending on how one
searches through their notes, this refashioned presentation may be the
best option (Features of the file-naming scheme for searching or filtering).
Denote’s file-naming scheme is designed to be efficient and to provide valueable meta information about the file. The cost, however, is that it is terse and harder to read, depending on how the user chooses to filter and process their notes.
To this end, the denote-menu package by Mohamed Suliman provides the
convenience of a nice tabular interface for all notes. denote-menu
removes the delimiters that are found in Denote file names and
presents the information in a human-readable format. Furthermore, the
package provides commands to interact with the list of notes, such as
to filter them and to transition from the tabular list to Dired. Its
documentation expands on the technicalities.
Emacs has a built-in library for treating a directory tree as a
“project”. This means that the contents of this tree are seen as part
of the same set, so commands like project-switch-to-buffer (C-x p b
by default) will only consider buffers in the current project
(e.g. three notes that are currently being visited).
Normally, a “project” is a directory tree whose root is under version
control. For our purposes, all you need is to navigate to the
denote-directory (for the shell or via Dired) and use the command-line
to run this (requires the git executable):
git init
From Dired, you can type M-! which invokes dired-smart-shell-command
and then run the git call there.
The project can then be registered by invoking any project-related
command inside of it, such as project-find-file (C-x p f).
It is a good idea to keep your notes under version control, as that
gives you a history of changes for each file. We shall not delve into
the technicalities here, though suffice to note that Emacs’ built-in
version control framework or the exceptionally well-crafted magit
package will get the job done (VC can work with other backends besides
Git).
Older versions of Denote had a file prompt that resembled that of the
standard find-file command (bound to C-x C-f by default). This
means that it used a tree-based method of navigating the filesystem by
selecting the specific directory and then the given file.
Currently, Denote flattens the file prompt so that every file in the
denote-directory and its subdirectories can be matched from anywhere
using the power of Emacs’ minibuffer completion (such as with the help
of the orderless package in addition to built-in options).
Users who need the old behaviour on a per-command basis can define their own wrapper functions as shown in the following code block.
;; This is the old `denote-file-prompt' that we renamed to
;; `denote-file-prompt-original' for clarity.
(defun denote-file-prompt-original (&optional initial-text)
"Prompt for file with identifier in variable `denote-directory'.
With optional INITIAL-TEXT, use it to prepopulate the minibuffer."
(read-file-name "Select note: " (denote-directory) nil nil initial-text
(lambda (f)
(or (denote-file-has-identifier-p f)
(file-directory-p f)))))
;; Our wrapper command that changes the current `denote-file-prompt'
;; to the functionality of `denote-file-prompt-original' only when
;; this command is used.
(defun my-denote-link ()
"Call `denote-link' but use Denote's original file prompt.
See `denote-file-prompt-original'."
(interactive)
(cl-letf (((symbol-function 'denote-file-prompt) #'denote-file-prompt-original))
(call-interactively #'denote-link)))Rename files with Denote using ~dired-preview~
Just as with the denote-dired-rename-marked-files-with-keywords,
we can use Denote in the Image Dired buffer (Rename multiple files at once).
Here is the custom code:
(autoload 'image-dired--with-marked "image-dired")
(autoload 'image-dired-original-file-name "image-dired-util")
(defun my-denote-image-dired-rename-marked-files (keywords)
"Like `denote-dired-rename-marked-files-with-keywords' but for Image Dired.
Prompt for KEYWORDS and rename all marked files in the Image
Dired buffer to have a Denote-style file name with the given
KEYWORDS.
IMPORTANT NOTE: if there are marked files in the corresponding
Dired buffers, those will be targeted as well. This is not the
fault of Denote: it is how Dired and Image Dired work in tandem.
To only rename the marked thumbnails, start by unmarking
everything in Dired. Then mark the items in Image Dired and
invoke this command."
(interactive (list (denote-keywords-prompt)) image-dired-thumbnail-mode)
(image-dired--with-marked
(when-let* ((file (image-dired-original-file-name))
(dir (file-name-directory file))
(id (or (denote-retrieve-filename-identifier file) ""))
(file-type (denote-filetype-heuristics file))
(title (denote--retrieve-title-or-filename file file-type))
(signature (or (denote-retrieve-filename-signature file) "")
(extension (file-name-extension file t))
(new-name (denote-format-file-name dir id keywords title extension signature))
(default-directory dir))
(denote-rename-file-and-buffer file new-name))))While the my-denote-image-dired-rename-marked-files renames files in
the helpful Denote-compliant way, users may still need to not prepend
a unique identifier and not sluggify (hyphenate and downcase) the
image’s existing file name. To this end, the following custom command
can be used instead:
(defun my-image-dired-rename-marked-files (keywords)
"Like `denote-dired-rename-marked-files-with-keywords' but for Image Dired.
Prompt for keywords and rename all marked files in the Image
Dired buffer to have Denote-style keywords, but none of the other
conventions of Denote's file-naming scheme."
(interactive (list (denote-keywords-prompt)) image-dired-thumbnail-mode)
(image-dired--with-marked
(when-let* ((file (image-dired-original-file-name))
(dir (file-name-directory file))
(file-type (denote-filetype-heuristics file))
(title (denote--retrieve-title-or-filename file file-type))
(extension (file-name-extension file t))
(kws (denote--keywords-combine keywords))
(new-name (concat dir title "__" kws extension))
(default-directory dir))
(denote-rename-file-and-buffer file new-name))))The dired-preview package (by me/Protesilaos) automatically displays
a preview of the file at point in Dired. This can be helpful in
tandem with Denote when we want to rename multiple files by taking a
quick look at their contents.
The command denote-dired-rename-marked-files-with-keywords
will generate Denote-style file names based on the keywords it prompts
for. Identifiers are derived from each file’s modification date
(Rename multiple files at once). There is no need for any custom code
in this scenario.
As noted in the section about Image Dired, the user may sometimes not
need a fully fledged Denote-style file name but only append Denote-like
keywords to each file name (e.g. Original Name__denote_test.jpg
instead of 20230710T195843--original-name__denote_test.jpg).
Rename files with Denote in the Image Dired thumbnails buffer
In such a workflow, it is unlikely to be dealing with ordinary text files where front matter can be helpful. A custom command does not need to behave like what Denote provides out-of-the-box, but can instead append keywords to file names without conducting any further actions. We thus have:
(defun my-denote-dired-rename-marked-files-keywords-only ()
"Like `denote-dired-rename-marked-files-with-keywords' but only for keywords in file names.
Prompt for keywords and rename all marked files in the Dired
buffer to only have Denote-style keywords, but none of the other
conventions of Denote's file-naming scheme."
(interactive nil dired-mode)
(if-let ((marks (dired-get-marked-files)))
(let ((keywords (denote-keywords-prompt)))
(dolist (file marks)
(let* ((dir (file-name-directory file))
(file-type (denote-filetype-heuristics file))
(title (denote--retrieve-title-or-filename file file-type))
(extension (file-name-extension file t))
(kws (denote--keywords-combine keywords))
(new-name (concat dir title "__" kws extension)))
(denote-rename-file-and-buffer file new-name)))
(revert-buffer))
(user-error "No marked files; aborting")))When exporting Denote notes to, for example, an HTML or PDF file,
there is a high probability that the same file name is used with a new
extension. This is problematic because it creates files with
duplicate identifiers. The 20230515T085612--example__keyword.org
produces a 20230515T085612--example__keyword.pdf. Any link to the
20230515T085612 will thus break: it does not honor Denote’s
expectation of finding unique identifiers. This is not the fault of
Denote: exporting is done by the user without Denote’s involvement.
Org Mode and Markdown use different approaches to exporting files. No recommended method is available for plain text files as there is no standardised export functionality for this format (the user can always create a new note using the file type they want on a case-by-case basis: Convenience commands for note creation).
Org Mode has a built-in configurable export engine. You can prevent duplicate identifiers when exporting manually for each exported file or by advising the Org export function.
Insert #+export_file_name: FILENAME in the front matter before
exporting to force a filename called whatever the value of FILENAME
is. The FILENAME does not specify the file type extension, such as
.pdf. This is up to the export engine. For example, a Denote note
with a complete file name of 20230515T085612--example__keyword.org
and a front matter entry of #+export_file_name: hello will be
exported as hello.pdf.
The advantage of this manual method is that it gives the user full control over the resulting file name. The disadvantage is that it depends on the user’s behaviour. Forgetting to add a new name can lead to duplicate identifiers, as already noted in the introduction to this section (Export Denote notes).
It is possible to automatically place all exports in another folder by
making Org’s function org-export-output-file-name create the target
directory if needed and move the exported file there. Remember that
advising Elisp code must be handled with care, as it might break the
original function in subtle ways.
(defvar my-org-export-output-directory-prefix "./export_"
"Prefix of directory used for org-mode export.
The single dot means that the directory is created on the same
level as the one where the Org file that performs the exporting
is. Use two dots to place the directory on a level above the
current one.
If this directory is part of `denote-directory', make sure it is
not read by Denote. See `denote-excluded-directories-regexp'.
This way there will be no known duplicate Denote identifiers
produced by the Org export mechanism.")
(defun my-org-export-create-directory (fn extension &rest args)
"Move Org export file to its appropriate directory.
Append the file type EXTENSION of the exported file to
`my-org-export-output-directory-prefix' and, if absent, create a
directory named accordingly.
Install this as advice around `org-export-output-file-name'. The
EXTENSION is supplied by that function. ARGS are its remaining
arguments."
(let ((export-dir (format "%s%s" my-org-export-output-directory-prefix extension)))
(unless (file-directory-p export-dir)
(make-directory export-dir)))
(apply fn extension args))
(advice-add #'org-export-output-file-name :around #'my-org-export-create-directory)The target export directory should not be a subdirectory of
denote-directory, as that will result in duplicate identifiers.
Exclude it with the denote-excluded-directories-regexp user option
(Exclude certain directories from all operations).
[ NOTE: I (Protesilaos) am not a LaTeX user and cannot test the following. ]
Using a different directory will require some additional configuration
when exporting using LaTeX. The export folder cannot be inside the
path of the denote-directory to prevent Denote from recognising it
as an attachment:
https://emacs.stackexchange.com/questions/45751/org-export-to-different-directory.
Org Mode also has a publishing tool for exporting a collection of files. Some user might apply this approach to convert their note collection to a public or private website.
The org-publish-project-alist variable drives the publishing
process, including the publishing directory.
The publishing directory should not be a subdirectory of
denote-directory, as that will result in duplicate identifiers.
Exclude it with the denote-excluded-directories-regexp user option
(Exclude certain directories from all operations).
Exporting from Markdown requires an external processor (e.g.,
Markdown.pl, Pandoc, or MultiMarkdown). The markdown-command
variable defines the command line used in export, for example:
(setq markdown-command "multimarkdown")The export process thus occurs outside of Emacs. Users need to read the documentation of their preferred processor to prevent the creation of duplicate Denote identifiers.
The package is available as denote. Simply do:
M-x package-refresh-contents M-x package-install
And search for it.
GNU ELPA provides the latest stable release. Those who prefer to follow the development process in order to report bugs or suggest changes, can use the version of the package from the GNU-devel ELPA archive. Read: https://protesilaos.com/codelog/2022-05-13-emacs-elpa-devel/.
Assuming your Emacs files are found in ~/.emacs.d/, execute the
following commands in a shell prompt:
cd ~/.emacs.d
# Create a directory for manually-installed packages
mkdir manual-packages
# Go to the new directory
cd manual-packages
# Clone this repo, naming it "denote"
git clone https://git.sr.ht/~protesilaos/denote denoteFinally, in your init.el (or equivalent) evaluate this:
;; Make Elisp files in that directory available to the user.
(add-to-list 'load-path "~/.emacs.d/manual-packages/denote")Everything is in place to set up the package.
(require 'denote)
;; Remember to check the doc strings of those variables.
(setq denote-directory (expand-file-name "~/Documents/notes/"))
(setq denote-known-keywords '("emacs" "philosophy" "politics" "economics"))
(setq denote-infer-keywords t)
(setq denote-sort-keywords t)
(setq denote-file-type nil) ; Org is the default, set others here
(setq denote-prompts '(title keywords))
(setq denote-excluded-directories-regexp nil)
(setq denote-excluded-keywords-regexp nil)
;; Pick dates, where relevant, with Org's advanced interface:
(setq denote-date-prompt-use-org-read-date t)
;; Read this manual for how to specify `denote-templates'. We do not
;; include an example here to avoid potential confusion.
(setq denote-date-format nil) ; read doc string
;; By default, we do not show the context of links. We just display
;; file names. This provides a more informative view.
(setq denote-backlinks-show-context t)
;; Also see `denote-link-backlinks-display-buffer-action' which is a bit
;; advanced.
;; If you use Markdown or plain text files (Org renders links as buttons
;; right away)
(add-hook 'find-file-hook #'denote-link-buttonize-buffer)
;; We use different ways to specify a path for demo purposes.
(setq denote-dired-directories
(list denote-directory
(thread-last denote-directory (expand-file-name "attachments"))
(expand-file-name "~/Documents/books")))
;; Generic (great if you rename files Denote-style in lots of places):
;; (add-hook 'dired-mode-hook #'denote-dired-mode)
;;
;; OR if only want it in `denote-dired-directories':
(add-hook 'dired-mode-hook #'denote-dired-mode-in-directories)
;; Automatically rename Denote buffers using the `denote-rename-buffer-format'.
(denote-rename-buffer-mode 1)
;; Denote DOES NOT define any key bindings. This is for the user to
;; decide. For example:
(let ((map global-map))
(define-key map (kbd "C-c n n") #'denote)
(define-key map (kbd "C-c n c") #'denote-region) ; "contents" mnemonic
(define-key map (kbd "C-c n N") #'denote-type)
(define-key map (kbd "C-c n d") #'denote-date)
(define-key map (kbd "C-c n z") #'denote-signature) ; "zettelkasten" mnemonic
(define-key map (kbd "C-c n s") #'denote-subdirectory)
(define-key map (kbd "C-c n t") #'denote-template)
;; If you intend to use Denote with a variety of file types, it is
;; easier to bind the link-related commands to the `global-map', as
;; shown here. Otherwise follow the same pattern for `org-mode-map',
;; `markdown-mode-map', and/or `text-mode-map'.
(define-key map (kbd "C-c n i") #'denote-link) ; "insert" mnemonic
(define-key map (kbd "C-c n I") #'denote-add-links)
(define-key map (kbd "C-c n b") #'denote-backlinks)
(define-key map (kbd "C-c n f f") #'denote-find-link)
(define-key map (kbd "C-c n f b") #'denote-find-backlink)
;; Note that `denote-rename-file' can work from any context, not just
;; Dired bufffers. That is why we bind it here to the `global-map'.
(define-key map (kbd "C-c n r") #'denote-rename-file)
(define-key map (kbd "C-c n R") #'denote-rename-file-using-front-matter))
;; Key bindings specifically for Dired.
(let ((map dired-mode-map))
(define-key map (kbd "C-c C-d C-i") #'denote-link-dired-marked-notes)
(define-key map (kbd "C-c C-d C-r") #'denote-dired-rename-files)
(define-key map (kbd "C-c C-d C-k") #'denote-dired-rename-marked-files-with-keywords)
(define-key map (kbd "C-c C-d C-R") #'denote-dired-rename-marked-files-using-front-matter))
(with-eval-after-load 'org-capture
(setq denote-org-capture-specifiers "%l\n%i\n%?")
(add-to-list 'org-capture-templates
'("n" "New note (with denote.el)" plain
(file denote-last-path)
#'denote-org-capture
:no-save t
:immediate-finish nil
:kill-buffer t
:jump-to-captured t)))
;; Also check the commands `denote-link-after-creating',
;; `denote-link-or-create'. You may want to bind them to keys as well.
;; If you want to have Denote commands available via a right click
;; context menu, use the following and then enable
;; `context-menu-mode'.
(add-hook 'context-menu-functions #'denote-context-menu)Denote is in a stable state and can be relied upon as the basis for custom extensions. Further below is a list with the functions or variables we provide for public usage. Those are in addition to all user options and commands that are already documented in the various sections of this manual.
In this context “public” is any form with single hyphens in its symbol,
such as denote-directory-files. We expressly support those, meaning
that we consider them reliable and commit to documenting any changes in
their particularities (such as through make-obsolete, a record in the
change log, a blog post on the maintainer’s website, and the like).
By contradistinction, a “private” form is declared with two hyphens in
its symbol such as denote--file-extension. Do not use those as we
might change them without further notice.
- Variable
denote-id-format - Format of ID prefix of a note’s filename. The note’s ID is derived from the date and time of its creation (The file-naming scheme).
- Variable
denote-id-regexp - Regular expression to match
denote-id-format.
- Variable
denote-signature-regexp - Regular expression to match
the
SIGNATUREfield in a file name.
- Variable
denote-title-regexp - Regular expression to match the
TITLEfield in a file name (The file-naming scheme).
- Variable
denote-keywords-regexp - Regular expression to match the
KEYWORDSfield in a file name (The file-naming scheme).
- Variable
denote-excluded-punctuation-regexp - Punctionation that is removed from file names. We consider those characters illegal for our purposes.
- Variable
denote-excluded-punctuation-extra-regexp - Additional
punctuation that is removed from file names. This variable is for
advanced users who need to extend the
denote-excluded-punctuation-regexp. Once we have a better understanding of what we should be omitting, we will update things accordingly.
- Function
denote-file-is-note-p - Return non-nil if
FILEis an actual Denote note. For our purposes, a note must not be a directory, must satisfyfile-regular-p, its path must be part of the variabledenote-directory, it must have a Denote identifier in its name, and use one of the extensions implied bydenote-file-type.
- Function
denote-file-has-identifier-p - Return non-nil if
FILEhas a Denote identifier.
- Function
denote-file-has-signature-p - Return non-nil if
FILEhas a signature.
- Function
denote-file-has-supported-extension-p - Return non-nil
if
FILEhas supported extension. Also account for the possibility of an added.gpgsuffix. Supported extensions are those implied bydenote-file-type.
- Function
denote-file-is-writable-and-supported-p - Return non-nil
if
FILEis writable and has supported extension.
- Function
denote-file-type-extensions - Return all file type
extensions in
denote-file-types.
- Variable
denote-encryption-file-extensions - List of strings specifying file extensions for encryption.
- Function
denote-file-type-extensions-with-encryption - Derive
denote-file-type-extensionsplusdenote-encryption-file-extensions.
- Function
denote-get-file-extension - Return extension of
FILEwith dot included. Account fordenote-encryption-file-extensions. In other words, return something like.org.gpgif it is part of the file, else return.org.
- Function
denote-get-file-extension-sans-encryption - Return
extension of
FILEwith dot included and without the encryption part. Build on top ofdenote-get-file-extensionthough always return something like.orgeven if the actual file extension is.org.gpg.
- Function
denote-keywords - Return appropriate list of keyword
candidates. If
denote-infer-keywordsis non-nil, infer keywords from existing notes and combine them into a list withdenote-known-keywords. Else use only the latter set of keywords (Standard note creation).
- Function
denote-convert-file-name-keywords-to-crm - Make
STRINGwith keywords readable bycompleting-read-multiple.STRINGconsists of underscore-separated words, as those appear in the keywords component of a Denote file name.STRINGis the same as the return value ofdenote-retrieve-filename-keywords. [ Part of {{{development-version}}}. ]
- Function
denote-keywords-sort - Sort
KEYWORDSifdenote-sort-keywordsis non-nil.KEYWORDSis a list of strings, perdenote-keywords-prompt.
- Function
denote-keywords-combine - Combine
KEYWORDSlist of strings into a single string. Keywords are separated by the underscore character, per the Denote file-naming scheme.
- Function
denote-valid-date-p - Return
DATEas a valid date. A validDATEis a value that can be parsed by eitherdecode-timeordate-to-time.Those functions signal an error ifDATEis a value they do not recognise. IfDATEis nil, return nil. [ Part of {{{development-version}}}. ]
- Function
denote-parse-date - Return
DATEas an appropriate value for thedenotecommand. PassDATEthroughdenote-valid-date-pand use its return value. If either that orDATEis nil, returncurrent-time. [ Thedenote-valid-date-pis the new name ofdenote--valid-date, with enhanced functionality. Done as part of {{{development-version}}}. ]
- Function
denote-directory - Return path of the variable
denote-directoryas a proper directory, also because it accepts a directory-local value for what we internally refer to as “silos” (Maintain separate directories for notes). Custom Lisp code canletbind the value of the variabledenote-user-enforced-denote-directoryto override what this function returns.
- Function
denote-directory-files - Return list of absolute file
paths in variable
denote-directory. Files only need to have an identifier. The return value may thus include file types that are not implied bydenote-file-type. Remember that the variabledenote-directoryaccepts a dir-local value, as explained in its doc string (Maintain separate directories for notes). With optionalFILES-MATCHING-REGEXP, restrict files to those matching the given regular expression. With optionalOMIT-CURRENTas a non-nil value, do not include the current Denote file in the returned list. With optionalTEXT-ONLYas a non-nil value, limit the results to text files that satisfydenote-file-is-note-p.
- Function
denote-directory-subdirectories - Return list of
subdirectories in variable
denote-directory. Omit dotfiles (such as .git) unconditionally. Also exclude whatever matchesdenote-excluded-directories-regexp. Note that thedenote-directoryaccepts a directory-local value for what we call “silos” (Maintain separate directories for notes).
- Function
denote-file-name-relative-to-denote-directory - Return
name of
FILErelative to the variabledenote-directory.FILEmust be an absolute path.
- Function
denote-get-path-by-id - Return absolute path of
IDstring indenote-directory-files.
- Function
denote-barf-duplicate-id - Throw a
user-errorifIDENTIFIERalready exists.
- Function
denote-sluggify - Make
STRan appropriate slug for file names and related (Sluggification of file name components).
- Function
denote-sluggify-keyword - Sluggify
STRwhile joining separate words.
- Function
denote-desluggify - Upcase first char in
STRand dehyphenateSTR, invertingdenote-sluggify. Basically, convertthis-is-a-testtoThis is a test.
- Function
denote-sluggify-signature - Make
STRan appropriate slug for signatures (Sluggification of file name components).
- Function
denote-sluggify-keywords - Sluggify
KEYWORDS, which is a list of strings (Sluggification of file name components).
- Function
denote-filetype-heuristics - Return likely file type of
FILE. Use the file extension to detect the file type of the file.If more than one file type correspond to this file extension, use the first file type for which the key-title-kegexp matches in the file or, if none matches, use the first type with this file extension in
denote-file-type.If no file types in
denote-file-typeshas the file extension, the file type is assumed to be the first ofdenote-file-types.
- Function
denote-format-file-name - Format file name.
DIR-PATH,ID,KEYWORDS,TITLE,EXTENSIONandSIGNATUREare expected to be supplied bydenoteor equivalent command.DIR-PATHis a string pointing to a directory. It ends with a forward slash (the functiondenote-directorymakes sure this is the case when returning the value of the variabledenote-directory).DIR-PATHcannot be nil or an empty string.IDis a string holding the identifier of the note. It cannot be nil or an empty string and must matchdenote-id-regexp.DIR-PATHandIDform the base file name.KEYWORDSis a list of strings that is reduced to a single string bydenote-keywords-combine.KEYWORDScan be an empty list or a nil value, in which case the relevant file name component is not added to the base file name.TITLEandSIGNATUREare strings. They can be an empty string, in which case their respective file name component is not added to the base file name.EXTENSIONis a string that contains a dot followed by the file type extension. It can be an empty string or a nil value, in which case it is not added to the base file name.
- Function
denote-extract-keywords-from-path - Extract keywords
from
PATHand return them as a list of strings.PATHmust be a Denote-style file name where keywords are prefixed with an underscore. IfPATHhas no such keywords, which is possible, return nil (The file-naming scheme).
- Function
denote-extract-id-from-string - Return existing Denote
identifier in
STRING, else nil.
- Function
denote-retrieve-filename-identifier - Extract identifier
from
FILEname, if present, else return nil. To create a new one, refer to thedenote-create-unique-file-identifierfunction.
- Function
denote-retrieve-filename-title - Extract Denote title
component from
FILEname, if present, else return nil.
- Function
denote-retrieve-filename-keywords - Extract keywords
from
FILEname, if present, else return nil. Return matched keywords as a single string.
- Function
denote-retrieve-filename-signature - Extract signature
from
FILEname, if present, else return nil.
- Function
denote-get-identifier - Convert
DATEinto a Denote identifier usingdenote-id-format.DATEis parsed bydenote-valid-date-p. IfDATEis nil, use the current time. [ Part of {{{development-version}}}. ]
- Function
denote-create-unique-file-identifier - Create a new unique
FILEidentifier. Test that the identifier is unique amongUSED-IDS. The conditions are as follows:- If
DATEis non-nil, invokedenote-prompt-for-date-return-id. - If
DATEis nil, use the file attributes to determine the last modified date and format it as an identifier. - As a fallback, derive an identifier from the current time.
With optional
USED-IDSas nil, test that the identifier is unique among all files and buffers in variabledenote-directory.To only return an existing identifier, refer to the function
denote-retrieve-filename-identifier. - If
- Function
denote-retrieve-front-matter-title-value - Return title value from
FILEfront matter perFILE-TYPE.
- Function
denote-retrieve-front-matter-title-line - Return title line from
FILEfront matter perFILE-TYPE.
- Function
denote-retrieve-front-matter-keywords-value - Return keywords value
from
FILEfront matter perFILE-TYPE. The return value is a list of strings. To get a combined string the way it would appear in a Denote file name, usedenote-retrieve-front-matter-keywords-value-as-string.
- Function
denote-retrieve-front-matter-keywords-value-as-string - Return
keywords value from
FILEfront matter perFILE-TYPE. The return value is a string, with the underscrore as a separator between individual keywords. To get a list of strings instead, usedenote-retrieve-front-matter-keywords-value(the current function uses that internally).
- Function
denote-retrieve-front-matter-keywords-line - Return keywords line
from
FILEfront matter perFILE-TYPE.
- Function
denote-signature-prompt - Prompt for signature string.
With optional
DEFAULT-SIGNATUREuse it as the initial minibuffer text. With optionalPROMPT-TEXTuse it in the minibuffer instead of the default prompt. Previous inputs at this prompt are available for minibuffer completion. Considersavehist-modeto persist minibuffer histories between sessions.
- Function
denote-file-prompt - Prompt for file with identifier in
variable
denote-directory. With optionalFILES-MATCHING-REGEXP, filter the candidates per the given regular expression.
- Function
denote-keywords-prompt - Prompt for one or more keywords.
Read entries as separate when they are demarcated by the
crm-separator, which typically is a comma. With optionalPROMPT-TEXT, use it to prompt the user for keywords. Else use a generic prompt. With optionalINITIAL-KEYWORDSuse them as the initial minibuffer text. [ The optionalINITIAL-KEYWORDSargument is part of {{{development-version}}}. ]
- Function
denote-title-prompt - Prompt for title string. With
optional
DEFAULT-TITLEuse it as the initial minibuffer text. With optionalPROMPT-TEXTuse it in the minibuffer instead of the default prompt. Previous inputs at this prompt are available for minibuffer completion. Considersavehist-modeto persist minibuffer histories between sessions.
- Variable
denote-title-prompt-current-default - Currently bound
default title for
denote-title-prompt. Set the value of this variable within the lexical scope of a command that needs to supply a default title before callingdenote-title-promptand useunwind-protectto set its value back to nil.
- Function
denote-file-type-prompt - Prompt for
denote-file-type. Note that a non-nil value other thantext,markdown-yaml, andmarkdown-tomlfalls back to an Org file type. We useorghere for clarity.
- Function
denote-date-prompt - Prompt for date, expecting
YYYY-MM-DDor that plusHH:MM(or evenHH:MM:SS). Use Org’s more advanced date selection utility if the user optiondenote-date-prompt-use-org-read-dateis non-nil. It requires Org (The denote-date-prompt-use-org-read-date option).
- Function
denote-command-prompt - Prompt for command among
denote-commands-for-new-notes(Points of entry).
- Function
denote-files-matching-regexp-prompt - Prompt for
REGEXPto filter Denote files by. With optionalPROMPT-TEXTuse it instead of a generic prompt.
- Function
denote-prompt-for-date-return-id - Use
denote-date-promptand return it asdenote-id-format.
- Function
denote-template-prompt - Prompt for template key in
denote-templatesand return its value.
- Function
denote-subdirectory-prompt - Prompt for subdirectory of
the variable
denote-directory. The table uses thefilecompletion category (so it works with packages such asmarginaliaandembark).
- Function
denote-rename-file-prompt - Prompt to rename file named
OLD-NAMEtoNEW-NAME.
- Function
denote-rename-file-and-buffer - Rename file named
OLD-NAMEtoNEW-NAME, updating buffer name.
- Function
denote-rewrite-front-matter - Rewrite front matter of
note after
denote-rename-file(or related) TheFILE,TITLE,KEYWORDS, andFILE-TYPEarguments are given by the renaming command and are used to construct new front matter values if appropriate. With optionalNO-CONFIRM, do not prompt to confirm the rewriting of the front matter. Otherwise produce ay-or-n-pprompt to that effect.
- Function
denote-rewrite-keywords - Rewrite
KEYWORDSinFILEoutright according toFILE-TYPE. Do the same asdenote-rewrite-front-matterfor keywords, but do not ask for confirmation. This is for use indenote-keywords-add,denote-keywords-remove,denote-dired-rename-marked-files-with-keywords, or related.
- Function
denote-update-dired-buffers - Update Dired buffers of
variable
denote-directory. Also revert the current Dired buffer even if it is not inside thedenote-directory. Note that thedenote-directoryaccepts a directory-local value for what we internally refer to as “silos” (Maintain separate directories for notes). [ Refined as part of {{{development-version}}} to also revert the current Dired buffer. ]
- Variable
denote-file-types - Alist of
denote-file-typeand their format properties.Each element is of the form
(SYMBOL PROPERTY-LIST).SYMBOLis one of those specified indenote-file-typeor an arbitrary symbol that defines a new file type.PROPERTY-LISTis a plist that consists of the following elements::extensionis a string with the file extension including the period.:date-functionis a function that can format a date. See the functionsdenote--date-iso-8601,denote--date-rfc3339, anddenote--date-org-timestamp.:front-matteris either a string passed toformator a variable holding such a string. Theformatfunction accepts four arguments, which come fromdenotein this order:TITLE,DATE,KEYWORDS,IDENTIFIER. Read the doc string offormaton how to reorder arguments.:title-key-regexpis a regular expression that is used to retrieve the title line in a file. The first line matching this regexp is considered the title line.:title-value-functionis the function used to format the raw title string for inclusion in the front matter (e.g. to surround it with quotes). Use theidentityfunction if no further processing is required.:title-value-reverse-functionis the function used to retrieve the raw title string from the front matter. It performs the reverse of:title-value-function.:keywords-key-regexpis a regular expression used to retrieve the keywords’ line in the file. The first line matching this regexp is considered the keywords’ line.:keywords-value-functionis the function used to format the keywords’ list of strings as a single string, with appropriate delimiters, for inclusion in the front matter.:keywords-value-reverse-functionis the function used to retrieve the keywords’ value from the front matter. It performs the reverse of the:keywords-value-function.:linkis a string, or variable holding a string, that specifies the format of a link. See the variablesdenote-org-link-format,denote-md-link-format.:link-in-context-regexpis a regular expression that is used to match the aforementioned link format. See the variablesdenote-org-link-in-context-regexp,denote-md-link-in-context-regexp.
If
denote-file-typeis nil, use the first element of this list for new note creation. The default isorg.
- Variable
denote-org-front-matter - Specifies the Org front
matter. It is passed to
formatwith argumentsTITLE,DATE,KEYWORDS,ID(Change the front matter format)
- Variable
denote-yaml-front-matter - Specifies the YAML (Markdown)
front matter. It is passed to
formatwith argumentsTITLE,DATE,KEYWORDS,ID(Change the front matter format)
- Variable
denote-toml-front-matter - Specifies the TOML (Markdown)
front matter. It is passed to
formatwith argumentsTITLE,DATE,KEYWORDS,ID(Change the front matter format)
- Variable
denote-text-front-matter - Specifies the plain text
front matter. It is passed to
formatwith argumentsTITLE,DATE,KEYWORDS,ID(Change the front matter format)
- Variable
denote-org-link-format - Format of Org link to note.
The value is passed to
formatwithIDENTIFIERandTITLEarguments, in this order. Also seedenote-org-link-in-context-regexp.
- Variable
denote-md-link-format - Format of Markdown link to note.
The
%N$snotation used in the default value is forformatas the supplied arguments areIDENTIFIERandTITLE, in this order. Also seedenote-md-link-in-context-regexp.
- Variable
denote-id-only-link-format - Format of identifier-only
link to note. The value is passed to
formatwithIDENTIFIERas its sole argument. Also seedenote-id-only-link-in-context-regexp.
- Variable
denote-org-link-in-context-regexp - Regexp to match an
Org link in its context. The format of such links is
denote-org-link-format.
- Variable
denote-md-link-in-context-regexp - Regexp to match an
Markdown link in its context. The format of such links is
denote-md-link-format.
- Variable
denote-id-only-link-in-context-regexp - Regexp to match
an identifier-only link in its context. The format of such links is
denote-id-only-link-format.
- Function
denote-date-org-timestamp - Format
DATEusing the Org inactive timestamp notation.
- Function
denote-date-rfc3339 - Format
DATEusing the RFC3339 specification.
- Function
denote-date-iso-8601 - Format
DATEaccording to ISO 8601 standard.
- Function
denote-trim-whitespace - Trim whitespace around string
S. This can be used indenote-file-typesto format front mattter.
- Function
denote-trim-whitespace-then-quotes - Trim whitespace
then quotes around string
S. This can be used indenote-file-typesto format front mattter.
- Function
denote-format-string-for-org-front-matter - Return
string
Sas-is for Org or plain text front matter. IfSis not a string, return an empty string. [ Part of {{{development-version}}}. ]
- Function
denote-format-string-for-md-front-matter - Surround
string
Swith quotes. IfSis not a string, return a literal emptry string. This can be used indenote-file-typesto format front mattter. [ Revised as part of {{{development-version}}} and renamed fromdenote-surround-with-quotestodenote-format-string-for-md-front-matter. ]
- Function
denote-format-keywords-for-md-front-matter - Format
front matter
KEYWORDSfor markdown file type.KEYWORDSis a list of strings. Consult thedenote-file-typesfor how this is used.
- Function
denote-format-keywords-for-text-front-matter - Format
front matter
KEYWORDSfor text file type.KEYWORDSis a list of strings. Consult thedenote-file-typesfor how this is used.
- Function
denote-format-keywords-for-org-front-matter - Format
front matter
KEYWORDSfor org file type.KEYWORDSis a list of strings. Consult thedenote-file-typesfor how this is used.
- Function
denote-extract-keywords-from-front-matter - Format front
matter
KEYWORDSfor org file type.KEYWORDSis a list of strings. Consult thedenote-file-typesfor how this is used.
- Function
denote-link-return-links - Return list of links in
current or optional
FILE. Also seedenote-link-return-backlinks.
- Function
denote-link-return-backlinks - Return list of backlinks
in current or optional
FILE. Also seedenote-link-return-links.
Sometimes we get reports on bugs that may not be actually caused by some error in the Denote code base. To help gain insight into what the problem is, we need to be able to reproduce the issue in a minimum viable system. Below is one way to achieve this.
- Find where your
denote.elfile is stored on your filesystem. - Assuming you have already installed the package, one way to do this
is to invoke
M-x find-libraryand search fordenote. It will take you to the source file. There doM-x eval-expression, which will bring up a minibuffer prompt. At the prompt evaluate:
(kill-new (expand-file-name (buffer-file-name)))
- The above will save the full file system path to your kill ring.
- In a terminal emulator or an
M-x shellbuffer execute:
emacs -Q
- This will open a new instance of Emacs in a pristine environment. Only the default settings are loaded.
- In the
*scratch*buffer ofemacs -Q, add your configurations like the following and try to reproduce the issue:
(require 'denote "/full/path/to/what/you/got/denote.el") ;; Your configurations here
Then try to see if your problem still occurs. If it does, then the fault is with Denote. Otherwise there is something external to it that we need to account for. Whatever the case, this exercise helps us get a better sense of the specifics.
Denote is a GNU ELPA package. As such, any significant change to the code requires copyright assignment to the Free Software Foundation (more below).
You do not need to be a programmer to contribute to this package. Sharing an idea or describing a workflow is equally helpful, as it teaches us something we may not know and might be able to cover either by extending Denote or expanding this manual (Things to do). If you prefer to write a blog post, make sure you share it with us: we can add a section herein referencing all such articles. Everyone gets acknowledged (Acknowledgements). There is no such thing as an “insignificant contribution”—they all matter.
- Package name (GNU ELPA):
denote - Official manual: https://protesilaos.com/emacs/denote
- Change log: https://protesilaos.com/emacs/denote-changelog
- Git repo on SourceHut: https://git.sr.ht/~protesilaos/denote
- Mirrors:
- Mailing list: https://lists.sr.ht/~protesilaos/denote
If our public media are not suitable, you are welcome to contact me (Protesilaos) in private: https://protesilaos.com/contact.
Copyright assignment is a prerequisite to sharing code. It is a simple process. Check the request form below (please adapt it accordingly). You must write an email to the address mentioned in the form and then wait for the FSF to send you a legal agreement. Sign the document and file it back to them. This could all happen via email and take about a week. You are encouraged to go through this process. You only need to do it once. It will allow you to make contributions to Emacs in general.
Please email the following information to [email protected], and we will send you the assignment form for your past and future changes. Please use your full legal name (in ASCII characters) as the subject line of the message. REQUEST: SEND FORM FOR PAST AND FUTURE CHANGES [What is the name of the program or package you're contributing to?] GNU Emacs [Did you copy any files or text written by someone else in these changes? Even if that material is free software, we need to know about it.] Copied a few snippets from the same files I edited. Their author, Protesilaos Stavrou, has already assigned copyright to the Free Software Foundation. [Do you have an employer who might have a basis to claim to own your changes? Do you attend a school which might make such a claim?] [For the copyright registration, what country are you a citizen of?] [What year were you born?] [Please write your email address here.] [Please write your postal address here.] [Which files have you changed so far, and which new files have you written so far?]
Denote should work well for what is described in this manual. Though we can always do better. This is a non-exhaustive list with some low-priority ideas you may want to help with (Contributing).
- Support mutually-exclusive sets of tags. For example, a
homekeyword would precludework. Personally, I am not a fan of such arrangements as there may be a case where something applies to both ends of this prefigured binary. Though we can think about it. - Add command that expands the identifier in links to a full file name.
This would be useful for some sort of “export” operation where the
absolute file path is necessary and where the Denote linking mechanism
is not available. Though this could be handled by the exporter, by
doing something like what
denote-find-linkdoes. - Add command that rewrites full names in links, if they are invalid. This would complement the renaming mechanism. Personally, I think old titles in links are not a problem, because they show you what was true at the time and are usually relevant to their context. Again though, it is an option worth exploring.
- Ensure integration between
denote:links and theembarkpackage. The idea is to allow Embark to understand the Denote buttons are links to files and correctly infer the absolute path. I am not sure what a user would want to do with this, but maybe there are some interesting possibilities.
You are welcome to suggest more ideas. If they do not broaden the scope of Denote, they can be added to denote.el. Otherwise we might think of extensions to the core package.
The Emacs community is putting Denote to great use. This section includes publications that show how people configure their note-taking setup. If you have a blog post, video, or configuration file about Denote, feel welcome to tell us about it (Contributing).
- David Wilson (SystemCrafters): Generating a Blog Site from Denote Entries, 2022-09-09, https://www.youtube.com/watch?v=5R7ad5xz5wo
- David Wilson (SystemCrafters): Trying Out Prot’s Denote, an Org Roam Alternative?, 2022-07-15, https://www.youtube.com/watch?v=QcRY_rsX0yY
- Jack Baty: Keeping my Org Agenda updated based on Denote keywords, 2022-11-30, https://baty.net/2022/keeping-my-org-agenda-updated
- Jeremy Friesen: Denote Emacs Configuration, 2022-10-02, https://takeonrules.com/2022/10/09/denote-emacs-configuration/
- Jeremy Friesen: Exploring the Denote Emacs Package, 2022-10-01, https://takeonrules.com/2022/10/01/exploring-the-denote-emacs-package/
- Jeremy Friesen: Migration Plan for Org-Roam Notes to Denote, 2022-10-02, https://takeonrules.com/2022/10/02/migration-plan-for-org-roam-notes-to-denote/
- Jeremy Friesen: Project Dispatch Menu with Org Mode Metadata, Denote, and Transient, 2022-11-19, https://takeonrules.com/2022/11/19/project-dispatch-menu-with-org-mode-metadata-denote-and-transient/
- Mohamed Suliman: Managing a bibliography of BiBTeX entries with Denote, 2022-12-20, https://www.scss.tcd.ie/~sulimanm/posts/denote-bibliography.html
- Peter Prevos: Simulating Text Files with R to Test the Emacs Denote Package, 2022-07-28, https://lucidmanager.org/productivity/testing-denote-package/
- Peter Prevos: Emacs Writing Studio, 2023-10-19. A configuration for authors, using Denote for taking notes, literature reviews and manage collections of images:
- Stefan Thesing: Denote as a Zettelkasten, 2023-03-02, https://www.thesing-online.de/blog/denote-as-a-zettelkasten
- Summer Emacs: An explanation of how I use Emacs, 2023-05-04, https://github.com/summeremacs/howiuseemacs/blob/main/full-explanation-of-how-i-use-emacs.org
What follows is a list of Emacs packages for note-taking. I (Protesilaos) have not used any of them, as I was manually applying my file-naming scheme beforehand and by the time those packages were available I was already hacking on the predecessor of Denote as a means of learning Emacs Lisp (a package which I called “Unassuming Sidenotes of Little Significance”, aka “USLS” which is pronounced as “U-S-L-S” or “useless”). As such, I cannot comment at length on the differences between Denote and each of those packages, beside what I gather from their documentation.
- org-roam
- The de facto standard in the Emacs milieu—and rightly so! It has a massive community, is featureful, and should be an excellent companion to anyone who is invested in the Org ecosystem and/or knows what “Roam” is (I don’t). It has been explained to me that Org Roam uses a database to store a cache about your notes. It otherwise uses standard Org files. The cache helps refer to the same node through aliases which can provide lots of options. Personally, I follow a single-topic-per-note approach, so anything beyond that is overkill. If the database is only for a cache, then maybe that has no downside, though I am careful with any kind of specialised program as it creates a dependency. If you ask me about database software in particular, I have no idea how to use one, let alone debug it or retrieve data from it if something goes awry (I could learn, but that is beside the point).
- zk (or zk.el)
- Reading its documentation makes me think that this is Denote’s sibling—the two projects have a lot of things in common, including the preference to rely on plain files and standard tools. The core difference is that Denote has a strict file-naming scheme. Other differences in available features are, in principle, matters of style or circumstance: both packages can have them. As its initials imply, ZK enables a zettelkasten-like workflow. It does not enforce it though, letting the user adapt the method to their needs and requirements.
- zettelkasten
- This is another one of Denote’s relatives, at least
insofar as the goal of simplicity is concerned. The major difference
is that according to its documentation “the name of the file that is
created is just a unique ID”. This is not consistent with our
file-naming scheme which is all about making sense of your files by
their name alone and being able to visually parse a listing of them
without any kind of specialised tool (e.g.
ls -lorls -Con the command-line from inside thedenote-directorygive you a human-readable set of files names, whilefind * -maxdepth 0 -type fis another approach). - zetteldeft
- This is a zettelkasten note-taking system built on top
of the
deftpackage. Deft provides a search interface to a directory, in this case the one holding the user’szetteldeftnotes. Denote has no such dependency and is not opinionated about how the user prefers to search/access their notes: use Dired, Grep, theconsultpackage, or whatever else you already have set up for all things Emacs, not just your notes.
Searching through M-x list-packages for “zettel” brings up more
matches. zetteldesk is an extension to Org Roam and, as such, I
cannot possibly know what Org Roam truly misses and what the added-value
of this package is. neuron-mode builds on top of an external program
called neuron, which I have never used.
Searching for “note” gives us a few more results. notes-mode has
precious little documentation and I cannot tell what it actually does
(as I said in my presentation for LibrePlanet 2022, inadequate docs are
a bug). side-notes differs from what we try to do with Denote, as it
basically gives you the means to record your thoughts about some other
project you are working on and keep them on the side: so it and Denote
should not be mutually exclusive.
If I missed something, please let me know.
This section covers blog posts and implementations from the Emacs community about the topic of note-taking and file organization. They may refer to some of the packages covered in the previous section or provide their custom code (Alternatives to Denote). The list is unsorted.
- José Antonio Ortega Ruiz (aka “jao”) explains a note-taking method that is simple like Denote but differs in other ways. An interesting approach overall: https://jao.io/blog/simple-note-taking.html.
- Jethro Kuan (the main
org-roamdeveloper) explains their note-taking techniques: https://jethrokuan.github.io/org-roam-guide/. Good ideas all round, regardless of the package/code you choose to use. - Karl Voit’s tools date2name, filetags, appendfilename, and move2archive provide a Python-based implementation to organize individual files which do not require Emacs. His approach (blog post and his presentation at GLT18) has been complemented by memacs to process e.g., the date of creation of photographs, or the log of a phone call in a format compatible to org.
[ Development note: help expand this list. ]
I (Protesilaos) answer some questions I have received or might get. It is assumed that you have read the rest of this manual: I will not go into the specifics of how Denote works.
I wrote Denote because I was using a variant of Denote’s file-naming
scheme before I was even an Emacs user (I switched to Emacs from
Tmux+Vim+CLI in the summer of 2019). I was originally inspired by
Jekyll, the static site generator, which I started using for my website
in 2016 (was on WordPress before). Jekyll’s files follow the
YYYY-MM-DD-TITLE.md pattern. I liked its efficiency relative to the
unstructured mess I had before. Eventually, I started using that scheme
outside the confines of my website’s source code. Over time I refined
it and here we are.
Note-taking is something I take very seriously, as I am a prolific
writer (just check my website, which only reveals the tip of the
iceberg). As such, I need a program that does exactly what I want and
which I know how to extend. I originally tried to use Org capture
templates to create new files with a Denote-style file-naming scheme but
never managed to achieve it. Maybe because org-capture has some
hard-coded assumptions or I simply am not competent enough to hack on
core Org facilities. Whatever the case, an alternative was in order.
The existence of PACKAGE is never a good reason for me not to conduct my own experiments for recreational, educational, or practical purposes. When the question arises of “why not contribute to PACKAGE instead?” the answer is that without me experimenting in the first place, I would lack the skills for such a task. Furthermore, contributing to another package does not guarantee I get what I want in terms of workflow.
Whether you should use Denote or not is another matter altogether: choose whatever you want.
I think Org is one of Emacs’ killer apps. I also believe it is not the right tool for every job. When I write notes, I want to focus on writing. Nothing more. I thus have no need for stuff like org-babel, scheduling to-do items, clocking time, and so on. The more “mental dependencies” you add to your workflow, the heavier the burden you carry and the less focused you are on the task at hand: there is always that temptation to tweak the markup, tinker with some syntactic construct, obsess about what ought to be irrelevant to writing as such.
In technical terms, I also am not fond of Org’s code base (I understand
why it is the way it is—just commenting on the fact). Ever tried to
read it? You will routinely find functions that are tens-to-hundreds of
lines long and have all sorts of special casing. As I am not a
programmer and only learnt to write Elisp through trial and error, I
have no confidence in my ability to make Org do what I want at that
level, hence denote instead of org-denote or something.
Perhaps the master programmer is one who can deal with complexity and keep adding to it. I am of the opposite view, as language—code included—is at its communicative best when it is clear and accessible.
Make no mistake: I use Org for the agenda and also to write technical documentation that needs to be exported to various formats, including this very manual.
My notes form part of my longer-term storage. I do not want to have to rely on a special program to be able to read them or filter them. Unix is universal, at least as far as I am concerned.
Denote streamlines some tasks and makes things easier in general, which is consistent with how Emacs provides a layer of interactivity on top of Unix. Still, Denote’s utilities can, in principle, be implemented as POSIX shell scripts (minus the Emacs-specific parts like fontification in Dired or the buttonization of links).
Portability matters. For example, in the future I might own a smartphone, so I prefer not to require Emacs, Org, or some other executable to access my files on the go.
Furthermore, I might want to share those files with someone. If I make Emacs a requirement, I am limiting my circle to a handful of relatively advanced users.
Please don’t misinterpret this: I am using Emacs full-time for my computing and maintain a growing list of packages for it. This is just me thinking long-term.
I have read that Org favours the latter method. If true, I strongly disagree with it because of the implicit dependency it introduces and the way it favours machine-friendliness over human-readability in terms of accessing information. Notes are long-term storage. I might want to access them on (i) some device with limited features, (ii) print on paper, (iii) share with another person who is not a tech wizard.
There are good arguments for few large files, but all either prioritize machine-friendliness or presuppose the use of sophisticated tools like Emacs+Org.
Good luck using less on a generic TTY to read a file with a zillion
words, headings, sub-headings, sub-sub-headings, property drawers, and
other constructs! You will not get the otherwise wonderful folding of
headings the way you do in Emacs—do not take such features for
granted.
My point is that notes should be atomic to help the user—and potentially the user’s family, friends, acquaintances—make sense of them in a wide range of scenaria. The more program-agnostic your file is, the better for you and/or everyone else you might share your writings with.
Human-readability means that we optimize for what matters to us. If (a)
you are the only one who will ever read your notes, (b) always have
access to good software like Emacs+Org, (c) do not care about printing
on paper, then Denote’s model is not for you. Maybe you need to tweak
some org-capture template to append a new entry to one mega file (I do
that for my Org agenda, by the way, as I explained before about using
the right tool for the job).
Denote does not do anything fancy and has no special requirements: it uses standard tools to accomplish ordinary tasks. If Emacs can cope with lots of files, then that is all you need to know: Denote will work.
To put this to the test, Peter Prevos is running simulations with R that generate large volumes of notes. You can read the technicalities here: https://lucidmanager.org/productivity/testing-denote-package/. Excerpt:
Using this code I generated ten thousands notes and used this to test the Denote package to see it if works at a large scale. This tests shows that Prot’s approach is perfectly capable of working with thousands of notes.
Of course, we are always prepared to make refinements to the code, where necessary, without compromising on the project’s principles.
Yes, many files will slow down the agenda due to how that works. Org
collects all files specified in the org-agenda-files, searches through
their contents for timestamped entries, and then loops through all days
to determine where each entry belongs. The more days and more files,
the longer it takes to build the agenda. Doing this with potentially
hundreds of files will have a noticeable impact on performance.
This is not a deficiency of Denote. It happens with generic Org files. The way the agenda is built is heavily favoring the use of a single file that holds all your timestamped entries (or at least a few such files). Tens or hundreds of files are inefficient for this job. Plus doing so has the side-effect of making Emacs open all those files, which you probably do not need.
If you want my opinion though, be more forceful with the separation of concerns. Decouple your knowledge base from your ephemeral to-do list: Denote (and others) can be used for the former, while you let standard Org work splendidly for the latter—that is what I do, anyway.
Org has a powerful linking facility, whether you use org-store-link or
do it via an org-capture template. If you want a certain note to be
associated with a task, just store the task in a single tasks.org (or
however you name it) and link to the relevant context.
Do not mix your knowledge base with your to-do items. If you need help figuring out the specifics of this workflow, you are welcome to ask for help in our relevant channels (Contributing).
Denote does not control how Dired sorts files. I encourage you to read
the manpage of the ls executable. It will help you in general, while
it applies to Emacs as well via Dired. The gist is that you can update
the ls flags that Dired uses on-the-fly: type C-u M-x
dired-sort-toggle-or-edit (C-u s by default) and append
--sort=time at the prompt. To reverse the order, add the -r flag.
The user option dired-listing-switches sets your default preference.
For an on-demand sorted and filtered Dired listing of Denote files,
use the command denote-sort-dired (Sort files by component).
Denote does not insert any meta data or heading pertaining to edits in the file. I am of the view that these either do not scale well or are not descriptive enough. Suppose you use a “lastmod” heading with a timestamp: which lines where edited and what did the change amount to?
This is where an external program can be helpful. Use a Version Control
System, such as Git, to keep track of all your notes. Every time you
add a new file, record the addition. Same for post-creation edits.
Your VCS will let you review the history of those changes. For
instance, Emacs’ built-in version control framework has a command that
produces a log of changes for the current file: M-x vc-print-log,
bound to C-x v l by default. From there one can access the
corresponding diff output (use M-x describe-mode (C-h m) in an
unfamiliar buffer to learn more about it). With Git in particular,
Emacs users have the option of the all-round excellent magit package.
In short: let Denote (or equivalent) create notes and link between them, the file manager organise and provide access to files, search programs deal with searching and narrowing, and version control software handle the tracking of changes.
Denote leverages the built-in xref library to search for the
identifier of the current file and return any links to it. For users
of Emacs version 28 or higher, there exists a user option to specify
the program that performs this search: xref-search-program. The
default is grep, which can be slow, though one may opt for ugrep,
ripgrep, or even specify something else (read the doc string of that
user option for the details).
Try either for these for better results:
(setq xref-search-program 'ripgrep)
;; OR
(setq xref-search-program 'ugrep)To use whatever executable is available on your system, use something like this:
;; Prefer ripgrep, then ugrep, and fall back to regular grep.
(setq xref-search-program
(cond
((or (executable-find "ripgrep")
(executable-find "rg"))
'ripgrep)
((executable-find "ugrep")
'ugrep)
(t
'grep)))Denote uses Emacs’ Xref to find backlinks. Xref requires xargs and
one of grep or ripgrep, depending on your configuration.
This is usually not an issue on *nix systems, but the necessary
executables are not available on Windows Emacs distributions. Please
ensure that you have both xargs and either grep or ripgrep
available within your PATH environment variable.
If you have git on Windows installed, then you may use the following
code (adjust the git’s installation path if necessary):
(setenv "PATH" (concat (getenv "PATH") ";" "C:\\Program Files\\Git\\usr\\bin"))Doom Emacs provides a set of bespoke templates for Org. One of those
prefills any new Org file with a #+title field. So when Denote
creates a new Org file and inserts front matter to it, it inevitably
adds an extra title to the existing one.
This is not a Denote problem. We can only expect a new file to be empty by default. Check how to disable the relevant module in your Doom Emacs configuration file.
Denote is meant to be a collective effort. Every bit of help matters.
- Author/maintainer
- Protesilaos Stavrou.
- Contributions to code or the manual
- Abin Simon, Adam Růžička, Alan Schmitt, Ashton Wiersdorf, Benjamin Kästner, Bruno Boal, Charanjit Singh, Clemens Radermacher, Colin McLear, Damien Cassou, Eduardo Grajeda, Elias Storms, Eshel Yaron, Florian, Glenna D., Graham Marlow, Hilde Rhyne, Ivan Sokolov, Jack Baty, Jean-Charles Bagneris, Jean-Philippe Gagné Guay, Joseph Turner, Jürgen Hötzel, Kaushal Modi, Kai von Fintel, Kostas Andreadis, Kyle Meyer, Marc Fargas, Matthew Lemon, Noboru Ota (nobiot), Norwid Behrnd, Peter Prevos, Philip Kaludercic, Quiliro Ordóñez, Stephen R. Kifer, Stefan Monnier, Stefan Thesing, Thibaut Benjamin, Tomasz Hołubowicz, Vedang Manerikar, Wesley Harvey, arsaber101, ezchi, leinfink (Henrik), l-o-l-h (Lincoln), maxbrieiev, mentalisttraceur, relict007.
- Ideas and/or user feedback
- Abin Simon, Aditya Yadav, Alan Schmitt, Aleksandr Vityazev, Alfredo Borrás, Ashton Wiersdorf, Benjamin Kästner, Claudiu Tănăselia, Colin McLear, Damien Cassou, Elias Storms, Federico Stilman, Florian, Frédéric Willem Frank Ehmsen, Glenna D., Guo Yong, Hanspeter Gisler, Jack Baty, Jay Rajput, Jean-Charles Bagneris, Jens Östlund, Jeremy Friesen, Jonathan Sahar, Johan Bolmsjö, Jousimies, Juanjo Presa, Kai von Fintel, Kaushal Modi, M. Hadi Timachi, Mark Olson, Mirko Hernandez, Niall Dooley, Paul van Gelder, Peter Prevos, Peter Smith, Suhail Singh, Shreyas Ragavan, Stefan Thesing, Summer Emacs, Sven Seebeck, Taoufik, TJ Stankus, Viktor Haag, Wade Mealing, Yi Liu, Ypot, atanasj, babusri, doolio, drcxd, hpgisler, pRot0ta1p, rbenit68, relict007, sienic, sundar bp.
Special thanks to Peter Povinec who helped refine the file-naming scheme, which is the cornerstone of this project.
Special thanks to Jean-Philippe Gagné Guay for the numerous contributions to the code base.