Setup a personal wiki in Emacs Org-mode

Question

I would like to setup a personal wiki in org-mode.

So far, I have tried this two ways. My first attempt was using a single "Scientific Notebook.org" file. In this went all my notes - each with its own headline, date and tags (same format as a blog post). I then turned on org-velocity to quickly navigate the file.

But this created two problems: first, I use a lot of math in my notes (LaTeX previews are one of the reasons I want to us org). But these take sooooo long to load, I can't images trying to open a file with several thousand entries (all filled with math!!)

The other problem I have is with tags. I like to use a lot of multi-word tags to cross-reference my notes. But the way org-mode wraps these in the buffer, makes my headings completely unintelligible. Also (maybe it's just me but) I find CamelCase really hard to read, especially when faced with something like:

:monotonicTransformations:homogeneousFunctions:orderedSets:proofs:

Now my second attempt is with Deft. Here, I have broken up each note into its own .org file and creating a dedicated ~/org/ folder to hold my wiki. But this is where I am stuck:

1) How do you setup auto linking, so that typing say "foo bar" in one note, creates a link to "foo bar.org"? Can this be done with radio target? If not, can this syntax [[foo bar]] be overridden to search for headlines in all files in the ~/org/ directory? I tried adding Wiki.el as a minor mode but no dice...

2) How do you tag individual files? And how can you then pull up a list of all tags and use this to filter your list of notes? I have read that bookmark+ lets you do file tagging. But I got so lost in the online docs...

I would love to hear how others have solved these problem, what minor modes you are using, workflows and keyboard shortcuts or other mods!

Thanks!

-Adam

Answer 1

Having only one note file is, in my opinion, more flexible and compatible. It tends, however, to get slow for even moderatly sized files. Multiple small files are quick, but they need more effort to set up, and they only work within that setup.

Single File Solution

To speed things up, consider setting org-startup-with-latex-preview to nil (or add #+STARTUP: nolatexpreview to your file).

Tags not only get messy when used for keywords, using them also gets rather slow as your file grows. I've played around with some custom functions, but now avoid tags most of the time. Instead I use flat hierarchies, categories and otherwise rely on occur and org-occur (e.g. M-x org-occur begin_proof).

Multiple Files

The org syntax for linking to other files is rather simple: [[./this idea.org][this idea]]. If that is too much hassle, it should be easy to write a function that replaces the active region with an appropriate link.

If you want to link [[this idea]] to a file "this idea.org", you could add a function to org-open-at-point-functions and handle it yourself.

As for tags, you don't tag a file itself, but rather a single top level headline. This of course means that all your troubles with tags a back as well. Again, I would recommend not using tags. Just make sure the file contains the right keywords at the right places and use occur and friends.

Edit: An Example `org-open-at-point-function'

If you want to search for a fuzzy link in all files in a directory instead of only the current buffer, you can do this by using the org-open-at-point-functions hook. Here is an example:

(defvar my-link-search-directory "/my/notes/directory/")

(defun my-open-link-function ()
  "Open link, interpreting it a the name of a headline."
  (let* ((el (org-element-context))
         (type (first el))
         (link-type (plist-get (cadr el) :type))
         (path (let ((path-1 (plist-get (cadr el) :path)))
                 (when (stringp path-1)
                   (org-link-unescape path-1)))))
    (when (and (eql type 'link)
               path
               (string= link-type "fuzzy"))
      (let* ((path (regexp-quote path))
             (result
                 (delq nil
                       (org-map-entries
                        (lambda ()
                          (when (string-match
                                 path
                                 (org-get-heading))
                            (list (buffer-file-name) (point))))
                        nil
                        ;; Here we set the scope.
                        ;; 'agenda would search in all agenda files.
                        ;; We want a list of all org files in `my-link-search-directory'.
                        (directory-files
                         my-link-search-directory
                         t "[.]org\\'")))))
        (when result
          (when (> (length result) 1)
            (message "Warning: multiple search results for %s" path))
          (let ((file (caar result))
                (pos (cadar result)))
            (find-file file)
            (goto-char pos)))))))


(add-hook 
 'org-open-at-point-functions
 'my-open-link-function)

Note that I haven't tested this much.

Actually, I would recommend against using this unless you really need it. While making fancy extensions is tempting, keeping your notes as simple as possible is preferably. If you have everything in one file, you could edit your notes with notepad or google docs or whatever, should you ever need to.

Answer 2

I'm using a simplistic code for a wiki. Because that's what a wiki is for me: a quick way to categorize things. The structure is a following:

• each subject has its own org file
• each topic of subject has its own heading
• all org files are in single directory
• you can jump to file, or create a new file with helm

That's it. I've found to need to link anything to anything, jump-to-subject functionality is more than enough. Here's how this looks:

And once within a subject, I can jump across topics with worf. Here's how this looks: