Hugo -- gohugo.io orgroam on The Neo-Babbage Files 2025-12-29T11:00:32+00:00 Benjamin Slade slade@lambda-y.net https://babbagefiles.xyz/tags/orgroam/ <![CDATA[Using Emacs and Org-Roam/Org-Node on Android (with Termux Extra Keys)]]> https://babbagefiles.xyz/termux-extra-keys-emacs-org-roam-node-android/ Benjamin Slade 2025-01-30T14:15:00-06:00 2025-02-03T11:42:23-06:00 My main use of Emacs on Android (via Termux) is to be able to access and add to my Org-roam library of notes. This post is primarily about some Termux features which improve the user experience for this use case. [Update [2025-02-03 Mon]: added some screenshots throughout to give a sense of what it looks like.]

Trying to Cope with Emacs on mobile

I’ve tried a number of different solutions for managing sync’ed Org files on mobile1, and some of these are useful for some purposes, but to being able to access and add to my Org-Roam notes, I’ve found I really need a full-blooded Emacs instance.2

And dealing with interacting with Emacs on a touchscreen interface/touchscreen keyboard is a bit of a nightmare.

Here, we’ll try to improve it a little. Into the rabbit-hole….

Note about using Termux for Emacs on Android

You’re probably better off installing Termux from F-Droid rather than from the Google Play Store [see the note from the official Termux maintainers at: https://github.com/termux/termux-app/discussions/4000]. This is especially true is you want to use Emacs in Termux for managing Org-roam files which are shared/kept in sync with your Emacs on desktop machines, which you can do with Syncthing (use Catfriend1’s Syncthing-fork [Github]/[F-Droid] on Android), in order to be able to grant Termux (and thus Emacs) access to your shared Org files.

Termux Extra Keys

Termux has a very useful feature adding extra keys above the system keyboard. These are quite useful, including ‘sticky’ CTRL and ALT keys. (In addition, one can hold volume-down and press a key for CTRL + [that-key] or volume-up and press a key for ALT + [that-key]; with volume-up + t inputting TAB. At least on my phone, using the volume keys as modifiers is fairly awkward/uncomfortable, so I prefer these extra keys.)

[Nb.: These keys are toggled on and off by pressing volume-up + k or volume-up + q. This is important to note, for I once toggled them off by accident and couldn’t understand what had happened to them for several months.]

Also worth mentioning is the fact that:

  • swipe left on extra keys brings up swipe-compatible/regular keyboard typing
  • swipe right on regular keyboard typing area (where extra keys was) will get you back to extra keys

The first of these lets you use any of your keyboard’s regular features and so can be quite useful.

See the Termux manual on Extra Keys for a description and basic configuration and usage instructions.

Extra Keys for better Emacs navigation

Here, I explore the possibilities offered by the advanced configuration options for Extra Keys for navigating Emacs in Termux, especially Org-Roam or Org-node 3, to create faster/easier ways of calling commonly used commands since the user-interface to Emacs with an on-screen keyboard is often somewhat frustrating compared to the using Emacs with a physical keyboard. In addition to extra tappable keys, Extra Keys also allows for different outcomes when the user does swipe-up on a key, including the outputting of key sequences, which can include modifier keys like CTRL. This allows the possibility of loading them with Emacs key sequences which would otherwise be much slower to access with an onscreen keyboard.

What I wanted was:

  • An easy, single-key (no modifier) way of doing forward and backward searches. It is painful to either hold volume-down or have to keep on toggling the Extra Keys’ CTRL for each next/previous result. So I recruited ♡ and ♤ for forward and back searches, respectively (because ♡ is sort of pointed down and ♤ is sort of pointing up), and bound these appropriately in my Emacs configuration (see below).

  • other convenient single-key buffer navigation interface features, e.g., arrow keys and page-up and page-down

  • some convenience things like closing all but the current window (delete-other-windows = C-x 1), opening up iBuffer, switch-buffer

  • slashes and - and ~ available immediately to tap insert (not under my keyboard’s symbol toggle or long-hold)

  • ability to call some Org-mode/Org-node commands quickly: including finding nodes, inserting links to nodes, capturing new dailies, committing captures, going to today’s daily entry, moving forward and backwards through the dailies, toggling the org-roam backlinks buffer

Example configuration

The configuration outlined below is partially specific for my Emacs configuration, especially for the C-c (CTRL c) keys, but some things involve default Emacs keybindings and it can at least serve as a model for what one can do. To configure Extra Keys, you need to modify the extra-keys part of ~/.termux/termux.properties in this fashion:

extra-keys = [[ \
  {key: 'ESC', popup: {macro: "CTRL x 1", display: "C-x 1"}}, \
  {key: 'CTRL', popup: {macro: "CTRL c", display: "C-c"}}, \
  {key: 'ALT', popup: {macro: "ALT x", display: "M-x"}}, \
  {key: '♡', popup: {macro: "CTRL x r b", display: "bookmarks"}}, \
  {key: '~', popup: {macro: "CTRL c n d", display: "today"}}, \
  {key: 'UP', popup: {macro: "CTRL c n n", display: "new note"}}, \
  {key: '-', popup: {macro: "CTRL c CTRL k", display: "cancel note"}}, \
  {key: 'PGUP', popup: {macro: "CTRL c n y", display: "prev note"}}], \
  [ \
  {key: 'TAB', popup: {macro: "CTRL x b", display: "alttab"}}, \
  {key: '/', popup: {macro: "CTRL c n f", display: "find node"}}, \
  {key: '\\\\', popup: {macro: "CTRL c n i", display: "insert link"}}, \
  {key: '♤', popup: {macro: "CTRL x CTRL b", display: "ibuffer"}}, \
  {key: 'LEFT', popup: {macro: "CTRL c n l", display: "backlinks"}}, \
  {key: 'DOWN', popup: {macro: "CTRL c CTRL c", display: "commit"}}, \
  {key: 'RIGHT', popup: {macro: "CTRL c n v", display: "goto-date"}}, \
  {key: 'PGDN', popup: {macro: "CTRL c n t", display: "next note"}}]]

Here is a rough summary of what this does:

key do on key tap do on key swipe up display on swipe up what key swipe up does
ESC ‘esc’ C-x 1 “C-x 1” delete-other-windows
CTRL ‘ctrl’ (C-) toggle C-c “C-c” start C-c prefix command
ALT ‘alt’ (M-) toggle M-x “M-x” M-x
♡ isearch-forward C-x r b “bookmarks” bookmark-jump
~ ‘~’ C-c n d “today” org-node-goto-today
↑ ‘up’ C-c n n “new note” org-roam-dailies-capture-today
- ‘-’ C-c C-k “cancel note” C-c C-k to cancel capture
PGUP ‘pageup’ C-c n y “prev note” org-node-goto-next-day
TAB ‘tab key’ C-x b “alttab” consult-buffer (switch-to-buffer)
/ ‘/’ C-c n f “find node” org-node-find
\ ‘\’ C-c n i “insert link” org-node-insert-link*
♤ isearch-backward C-x C-b “ibuffer” ibuffer
← ‘left’ C-c n l “backlinks” org-roam-buffer-toggle
↓ ‘down’ C-c C-c “commit” C-c C-c to ‘commit’
→ ‘right’ C-c n v “goto-date” org-node-goto-daily
PGDN ‘pagedown’ C-c n t “next note” org-node-goto-prev-day

In case you do use Org-node (and, if you’re trying to do Org-roam things on Android, I would again recommend considering Org-node, if only for making interactions fast enough to not be completely frustrating), you could implement the following interactive functions:

(defun org-node-goto-daily ()
  (interactive)
  (org-node-seq--jump "d"))

(defun org-node-goto-today ()
  (interactive)
  (org-node-seq-goto "d" (format-time-string "%F")))

(defun org-node-goto-next-day ()
  (interactive nil org-mode)
  (org-node-seq--goto-next "d"))

(defun org-node-goto-prev-day ()
  (interactive nil org-mode)
  (org-node-seq--goto-previous "d"))

(defun org-roam-dailies-capture-today ()
  (interactive)
  (org-roam-dailies-capture-today nil "d"))

And then bind:

  • org-node-insert-link* to “C-c n i”
  • org-node-find to “C-c n f”
  • org-node-goto-daily to “C-c n v”
  • org-node-goto-today to “C-c n d”
  • org-node-goto-next-day to “C-c n t” ('[t]omorrow’)
  • org-node-goto-prev-day to “C-c n y” ('[y]esterday’)
  • org-roam-dailies-capture-today to “C-c n n”
  • org-roam-buffer-toggle to “C-c n l”

Most of the other keybindings implemented above are default Emacs bindings.

In terms of how this improves the Termux Emacs experience, consider that you could open up Emacs in Termux and then proceed by:

  • swiping up on ↑ to open up a new Org-[roam/node] note in today’s daily journal
  • then swiping left on the extra keys pane to get into normal keyboard entry mode
  • swipe/glide-typing the text of your note quickly, and pressing enter
  • swiping right on the now clear virtual keyboard pane to bring back the extra keys
  • swiping up on \ to insert (‘splice in’) a org-id link to another Org-roam node or two
  • swiping up on ↓ to commit/complete your daily note
  • swiping up on PGUP to see yesterday’s Org-roam daily journal
  • swiping up on / to search for your “Termux” Org-roam node to add notes about Extra Keys to your Termux Org-roam node/file
  • tapping ♡ to search through the entry to see all the places you made reference to “extra keys”
  • swiping up on ← to see what backlinks you have for “Termux”
  • swiping up on ESC to get back to single window view
  • swiping up on ♤ to get to IBuffer to be able to manage your buffers
  • swiping up on ↑ to open another new daily note in today’s journal
  • changing your mind and swiping up on - to cancel the note capture
  • …..

This is all a lot faster than having to tap CTRL and then type c n n to start a new entry in today’s Org-roam daily journal, typing it out (tapping CTRL and then c n i each time you want to link text to another node), and then tapping CTRL and then c and then CTRL and then c to commit it, and so on.

For a bonus reduction in modifier and key tapping, consider using a modal mode in Emacs: I particularly like meow.

Appendix: Key Mnemonics

A potentially useful/emblematic list of mnemonics for the keys. [I use ☝️ to indicate swiping up on a key below.] Some of these mnemonics are stretches, but there are only so many keys and a particular set of things one wants, so stretches are sometimes required.

  • ♡ is a forwards/downwards search because the heart points down
  • ♤ is a backwards/upwards search because the spade points up [and we use these pointy characters indicating card suits in preference to others because I’m not going to be typing them on Android ever]
  • (all other single tap keys just do what it says on the tin, inserting characters, toggling modifiers, &c.)
  • ☝️ ♡ is bookmarks because these are ‘favourites’ because you ‘♡’ them
  • ☝️ ♤ is IBuffer because if you have icons enabled in your IBuffer4 then you’ll see icons and ♤ is like an icon (I know this one is a stretch, but….5)
  • ☝️ ESC is delete-other-windows because you’re ‘escaping’ from them
  • ☝️ CTRL is C-c because C-c starts with CTRL
  • ☝️ ALT is M-x because M-x starts with ALT
  • ☝️ ~ is org-node-goto-today because in Unix ~ is “user’s home directory” and today’s daily Org-roam entry is a sort of a ‘home’ (it makes sense to me anyway)
  • ☝️ - is C-c C-k is which ‘cancel’ in lots of places (like capture templates) and - is a negative sign and so can be understood like “don’t do it!”
  • ☝️ ↑ is org-roam-dailies-capture-today because this is the function to capture a new Org-roam daily note and ↑ is like “opening up something”
  • ☝️ ↓ is C-c C-c which is in many places in Emacs something like ‘commit’, and for capture templates it is the ‘finish capture’ binding and if ↑ is opening a new note, then ↓ is finishing it, putting it ‘down’
  • ☝️ ← is open up Org-roam backlinks buffer because ← is pointing ‘backwards’
  • ☝️ → is org-node-goto-daily because we’re looking ‘forward’ towards a specific date and going to it
  • ☝️ PGUP is org-node-goto-prev-day because we’re going ‘up’/‘backwards’ in the calendar (of daily Org-roam journal entries)
  • ☝️ PGDN is org-node-goto-prev-day because we’re going ‘down’/‘forwards’ in the calendar (of daily Org-roam journal entries)
  • ☝️ TAB is consult-buffer / switch-to-buffer because this function is sort of like Alt-TAB in many window environments
  • ☝️ / is org-node-find because / is the search key in Vim, and also associated with searches elsewhere in Unixland (the marker of beginning/end of regexs, often used for searches) [and because / is the opposite slash from \, which we’re going to use for the complementary operation to insert links]
  • ☝️ \ is org-node-insert-link* because in many environments \ is some sort of ‘splice’ indicator6, and inserting a link to a node is also sort of a splice [and because \ is the opposite slash from / which performs a complementary operation]

  1. E.g., orgzly, organice. ↩︎

  2. There is a full GUI Emacs now on Android, but I don’t know how to get it to be able to access files shared via Syncthing, and, anyway, you wouldn’t be able to do the sort of convenient keyboard hacks there I’m going to discuss in this post. ↩︎

  3. I highly recommend looking at Martin Edström’s Org-node package if you’re trying to manage Org-roam notes on Android; the performance differences between the two packages are especially noticeable on Android (orders of magnitude7). And the two packages can live alongside each other, so you can keep your existing Org-roam set-up going while you set-up/experiment with Org-node. ↩︎

  4. With a package like https://github.com/seagle0128/all-the-icons-ibuffer. On IBuffer itself, see https://www.emacswiki.org/emacs/IbufferMode. ↩︎

  5. Well, okay, so here’s another one: think of IBuffer as trying to right your buffer organisation like Two, Five, and Seven (of Spades) in Alice in Wonderland trying sort out the Queen of Hearts’ rose-bushes (by painting the roses red): ↩︎

  6. From https://port70.net/~nsz/c/c11/n1570.html#5.1.1.2:

    Each instance of a backslash character (\) immediately followed by a new-line character is deleted, splicing physical source lines to form logical source lines. Only the last backslash on any physical source line shall be eligible for being part of such a splice. A source file that is not empty shall end in a new-line character, which shall not be immediately preceded by a backslash character before any such splicing takes place.

    ↩︎

  7. Android 10/11 seems to have introduced which restricts how regular applications/users can interact with the filesystem, for ‘security’ reasons, implemented via Filesystem in Userspace (FUSE), which makes operations which interact with the file system sometimes very sluggish. Accessing directories with lots of files, as one might have in an Org-roam directory, can be amazingly slow. The increases exponentially with the number of Org-roam files.

    Org-node is implemented in such a way [cf. https://github.com/meedstrom/org-node/issues/26] that it caches/stores and accesses many things in ways that avoid directly accessing the file-system (especially in org-node-fakeroam), where Org-roam does not. ↩︎

]]> <![CDATA[Automatically adding information to Org-roam file properties]]> https://babbagefiles.xyz/org-roam-auto-propertise/ Benjamin Slade 2021-08-10T21:12:00-06:00 2021-08-10T21:15:45-06:00 This expands on a feature I included in the setup for using Org-roam on Android/LineageOS in the last post, specifically automatically adding properties to newly created Org-roam files.

Since Org-roam v2 creates a top properties drawer (with an :ID: tag) anyway, it is nice to stick other information there as well. Specifically, information that could be useful in some situation, but which usually we don’t want to see, like :AUTHOR: (it’s probably you, and you know who you are), :CREATION_TIME: (and why not use Unix epoch time?), and so on. I have org drawers fold themselves automatically, so the normally-useless information doesn’t distract me.

We can do this by leveraging Org-roam’s org-roam-capture-new-node-hook, and some org-roam-add-property function calls, as below.

But, while we’re at it, we might also record where a note was made from. There are a number of ways we might do this, but an easy one (only requiring curl and an active Internet connection) is using ipinfo.io. curl ipinfo.io will give you a bunch of information in JSON format about your internet provider, including latitude and longitude, which will likely be at least somewhere near your present location. And curl ipinfo.io/loc will return just latitude,longitude.

  (defun bms/add-other-auto-props-to-org-roam-properties ()
    ;; if the file already exists, don't do anything, otherwise...
    (unless (file-exists-p (buffer-file-name))
      ;; if there's also a CREATION_TIME property, don't modify it
      (unless (org-find-property "CREATION_TIME")
        ;; otherwise, add a Unix epoch timestamp for CREATION_TIME prop
        ;; (this is what "%s" does - see http://doc.endlessparentheses.com/Fun/format-time-string )
        (org-roam-add-property
         (format-time-string "%s"
                             (nth 5
                                  (file-attributes (buffer-file-name))))
         "CREATION_TIME"))
      ;; similarly for AUTHOR and MAIL properties
      (unless (org-find-property "AUTHOR")
        (org-roam-add-property roam-user "AUTHOR"))
      (unless (org-find-property "MAIL")
        (org-roam-add-property roam-email "MAIL"))
      ;; also add the latitude and longitude
      (unless (org-find-property "LAT_LONG")
        ;; recheck location:
        (bms/get-lat-long-from-ipinfo)
        (org-roam-add-property (concat (number-to-string calendar-latitude) "," (number-to-string calendar-longitude)) "LAT-LONG"))))

  ;; hook to be run whenever an org-roam capture completes
  (add-hook 'org-roam-capture-new-node-hook #'bms/add-other-auto-props-to-org-roam-properties)

;; function to find latitude & longitude
;;                      (requires curl to be installed on system)
(setq calendar-latitude 0)
(setq calendar-longitude 0)
(defun bms/get-lat-long-from-ipinfo ()
  (let*
      ((latlong (substring
                 (shell-command-to-string "curl -s 'ipinfo.io/loc'")
                   0 -1))
       (latlong-list (split-string latlong ",")))
    (setq calendar-latitude (string-to-number (car latlong-list)))
    (setq calendar-longitude (string-to-number (cadr latlong-list)))))

You might also calculate/set calendar-latitude and calendar-longitude in other ways. Including just hard-coding them for stationary machines. On Android, we could in theory make use of the Termux command termux-location, which queries the device’s GPS. But unfortunately it doesn’t always work (if it can’t find a good connection to a GPS satellite) and even when it does work it’s slow, so it’s not something you’d want to call every time you made a note. GeoClue would be another possible source.

(If you’re using a VPN, you’ll want to escape from it somehow to get something closer to your real location. How you do this will vary based on your VPN provider and other factors. (If you’re calling from Emacs, and you use something like Mullvad, you may want to revise the shell-command-to-string to call up a bash session/script, then exclude that specific bash session/script from the VPN, and then call curl, so that the call references your “real” IP. E.g. if you’re using Mullvad, then:

#!/bin/bash
PID=`echo $$`
mullvad split-tunnel pid add "${PID}"
curl ipinfo.io/loc # for lat/long ; `curl ipinfo.io` for full info

might give you a start on something.))

Let me know if you think of other properties that could be useful to automatically add to Org-roam file properties.

]]> <![CDATA[Org-roam on Android]]> https://babbagefiles.xyz/org-roam-on-android/ Benjamin Slade 2021-08-09T20:06:00-05:00 2025-02-03T11:32:00-06:00 I’ve been using the note-taking Zettelkasten-ish Org-roam system for a few months and it’s been very useful to me, just as a low-friction way of making more notes and easily finding and/or (re)discovering notes that I’ve made.

It’s pretty useful to be able to have access to these notes, and be able to quickly add notes, on mobile as well. I thought it might be useful to include here some notes on how to do, since (especially since v2 of Org-roam) there are some hurdles.

On Android/LineageOS install the F-Droid app store, and then from there install Termux. Open Termux and install four things we’ll need (strictly speaking you don’t need curl and ripgrep, but they’ll be useful): Emacs, sqlite, curl, and ripgrep via pkg install emacs sqlite curl ripgrep.

You can then open up Emacs via emacs and get started.

I include here a commented partial version of my ~/.emacs.d/init.el configuration file for my Termux/Emacs Org-roam setup:

;; BASIC SETUP:

;; package setup - bootstrap the package system
(require 'package)
(setq package-enable-at-startup nil)
(setq gnutls-algorithm-priority "NORMAL:-VERS-TLS1.3")
(setq package-archives
      '(("GNU ELPA"     . "https://elpa.gnu.org/packages/")
        ("ORG"		. "https://orgmode.org/elpa/")
        ("MELPA Stable" . "https://stable.melpa.org/packages/")
        ("MELPA"        . "https://melpa.org/packages/"))
      package-archive-priorities
      '(("ORG"		. 20)
        ("MELPA"        . 15)
        ("MELPA Stable" . 10)
        ("GNU ELPA"     . 5)))

(package-initialize)

;; Bootstrap `use-package'
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(eval-when-compile
  (require 'use-package))

;; for Termux-specific things; useful if you want to share
;; configs across platforms
(defvar termux-p
  (not (null (getenv "ANDROID_ROOT")))
  "If non-nil, GNU Emacs is running on Termux.")

(when termux-p
  (unless (package-installed-p 'use-package)
    (package-refresh-contents)
    (package-install 'use-package)))

;; This makes Emacs in Termux use your Android browser for opening urls
(setq browse-url-browser-function 'browse-url-xdg-open)

;; mouse
;; enable mouse reporting for terminal emulators
;; this lets you scroll around by swiping
(unless window-system
  (xterm-mouse-mode 1)
  (global-set-key [mouse-4] (lambda ()
                              (interactive)
                              (scroll-down 1)))
  (global-set-key [mouse-5] (lambda ()
                              (interactive)
                              (scroll-up 1))))

;; ORG
(use-package org
  :ensure t
  :ensure org-plus-contrib
  :init
  (setq org-src-fontify-natively t)
  :config
  ;; (add-to-list 'auto-mode-alist '("\\.org\\'" . org-mode))
  (define-key org-mode-map (kbd "M-p") 'org-metaup)
  (define-key org-mode-map (kbd "M-n") 'org-metadown)
  (setq org-catch-invisible-edits 'show-and-error)
  (setq org-cycle-separator-lines -1)
  (setq org-return-follows-link t)
  (setq org-export-with-toc 'nil)
  (setq org-startup-folded 'content)
  (setq org-ellipsis "⇣")
  ;; **** use regular android apps to view pdfs & images *****
  (when termux-p
    (add-to-list 'org-file-apps '("\\.pdf\\'" . "termux-open %s"))
    (add-to-list 'org-file-apps '("\\.png\\'" . "termux-open %s"))
    (add-to-list 'org-file-apps '("\\.jpg\\'" . "termux-open %s"))
    (add-to-list 'org-file-apps '("\\.jpeg\\'" . "termux-open %s")))
  ;; needed for <s etc. expansion of code-blocks
  (require 'org-tempo))

;; define our Org-roam user and their email (set to your desired name/email)
(defvar roam-user "Some User"
  "The name of the Org-roam note author.")
(defvar roam-email "roman@mode.org"
  "The public email of that author.")

(setq org-roam-v2-ack t)

;; we need this package for v2 of Org-oram
(use-package emacsql-sqlite3
  :ensure t)

;; If you've replicated my setup; otherwise change to the Termux
;; local path.
(setq org-roam-directory (file-truename "~/Documents/Org/org-roam/"))

;; org-roam
(use-package org-roam
  :ensure t
  :custom
  (setq org-roam-db-location (file-truename "~"))
  (org-roam-directory (file-truename "~/Documents/Org/org-roam/"))
  :bind (("C-c n l" . org-roam-buffer-toggle)
         ("C-c n f" . org-roam-node-find)
         ("C-c n r" . org-roam-graph)
         ("C-c n i" . org-roam-node-insert)
         ("C-c n c" . org-roam-capture)
         ("C-c n g" . org-id-get-create)
         ;; Dailies
         ("C-c n n" . org-roam-dailies-capture-today)
         ("C-c n d" . org-roam-dailies-goto-today) ; find toDay
         ("C-c n v" . org-roam-dailies-goto-date)
         ("C-c n f" . org-roam-dailies-goto-next-note)
         ("C-c n b" . org-roam-dailies-goto-previous-note))
  :config

  ;; this is a chunglak's hack to get sqlite to work on Android with org-roam v2:
  ;; from: https://github.com/org-roam/org-roam/issues/1605#issuecomment-885997237
  (defun org-roam-db ()
    "Entrypoint to the Org-roam sqlite database.
Initializes and stores the database, and the database connection.
Performs a database upgrade when required."
    (unless (and (org-roam-db--get-connection)
                 (emacsql-live-p (org-roam-db--get-connection)))
      (let ((init-db (not (file-exists-p org-roam-db-location))))
        (make-directory (file-name-directory org-roam-db-location) t)
        (let ((conn (emacsql-sqlite3 org-roam-db-location)))
          (emacsql conn [:pragma (= foreign_keys ON)])
          (set-process-query-on-exit-flag (emacsql-process conn) nil)
          (puthash (expand-file-name org-roam-directory)
                   conn
                   org-roam-db--connection)
          (when init-db
            (org-roam-db--init conn))
          (let* ((version (caar (emacsql conn "PRAGMA user_version")))
                 (version (org-roam-db--upgrade-maybe conn version)))
            (cond
             ((> version org-roam-db-version)
              (emacsql-close conn)
              (user-error
               "The Org-roam database was created with a newer Org-roam version.  "
               "You need to update the Org-roam package"))
             ((< version org-roam-db-version)
              (emacsql-close conn)
              (error "BUG: The Org-roam database scheme changed %s"
                     "and there is no upgrade path")))))))
    (org-roam-db--get-connection))
  (defun org-roam-db--init (db)
    "Initialize database DB with the correct schema and user version."
    (emacsql-with-transaction db
      (emacsql db "PRAGMA foreign_keys = ON") ;; added
      (emacsql db [:pragma (= foreign_keys ON)])
      (pcase-dolist (`(,table ,schema) org-roam-db--table-schemata)
        (emacsql db [:create-table $i1 $S2] table schema))
      (pcase-dolist (`(,index-name ,table ,columns) org-roam-db--table-indices)
        (emacsql db [:create-index $i1 :on $i2 $S3] index-name table columns))
      (emacsql db (format "PRAGMA user_version = %s" org-roam-db-version))))
  ;; end chunglak hack

  (org-roam-setup)
  ;; If using org-roam-protocol
  (require 'org-roam-protocol))

;; These are my capture templates:
(setq org-roam-capture-templates
      `(("d" "default" plain "%?" :if-new
         (file+head "%<%Y%m%d%H%M%S>-${slug}.org"
                    ,(concat "#+title: ${title}\n"
                             "#+date: %U\n\n"))
         :unnarrowed t)))

(setq org-roam-dailies-directory "~/Documents/Org/org-roam/daily")

(setq org-roam-dailies-capture-templates
      `(("d" "default" entry "* %?" :if-new
         (file+head "%(concat org-roam-dailies-directory \"/%<%Y-%m-%d>.org\")"
                    ,(concat "#+title: %<%Y-%m-%d>" "\n"
                             "#+filetags: :daily_journal:\n\n")))))

;; deft - one way to search Org-roam notes, but not the fastest (see below)
(use-package deft
  :ensure t
  :config
  :after org
  :bind
  ("C-c r d" . deft)
  :custom
  (deft-recursive t)
  (deft-use-filter-string-for-filename t)
  (deft-default-extension "org")
  (deft-directory "~/Documents/Org/org-roam/"))

;; Here end the basic setup, but....

;; SOME OTHER THINGS YOU MIGHT ADD

;; bars seems pointless here, but if you like, don't do this
(menu-bar-mode -1)
(tool-bar-mode -1)

;; You could use a different theme
(use-package cyberpunk-theme
  :ensure t
  :config
  (load-theme 'cyberpunk))

;;;;;;;;;;;;;;;;;;;;;
;; Spell-checking ;;;
;;;;;;;;;;;;;;;;;;;;;
(require 'flymake)
(setq ispell-program-name "hunspell") ; could be ispell as well, depending on your preferences
(setq ispell-dictionary "en_GB") ; this can obviously be set to any language your spell-checking program supports
;; I installed the en_GB ones, but these don't come in Termux by default. To add arbitrary hunspell languages, see:
;; https://www.reddit.com/r/termux/comments/k5o6mp/new_hunspell_dictionaries/?
;; in summary:
;; - how to add new: copy .aff and .dic files in /data/data/com.termux/files/usr/share/hunspell/
;; - where to get new: https://www.freeoffice.com/en/download/dictionaries

(dolist (hook '(org-mode-hook))
  (add-hook hook (lambda () (flyspell-mode 1))))
(add-hook 'org-mode-hook (lambda () (setq ispell-parser 'tex))) ; make orgmode recognise LaTeX syntax [from http://stackoverflow.com/questions/11646880/flyspell-in-org-mode-recognize-latex-syntax-like-auctex ]
(add-hook 'text-mode-hook #'flyspell-mode)

;;;;;;;;;;;;;;;
;; Undo-Tree ;; - a new undo package
;;;;;;;;;;;;;;;
(use-package undo-tree
  :ensure t
  :config
  ;; (setq undo-tree-auto-save-history 1)
  ;; Each node in the undo tree should have a timestamp.
  (setq undo-tree-visualizer-timestamps t)
  ;; Show a diff window displaying changes between undo nodes.
  (setq undo-tree-visualizer-diff t)
  (global-undo-tree-mode))

;; display time and date in modeline, if you like
(setq display-time-day-and-date t)
(display-time-mode 1)

;; prettier bullets
(use-package org-bullets
  :ensure t
  :config
  (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
  (setq org-bullets-bullet-list '("⋇" "∴" "∵" "∷" "∺")))

;; A nice way of quickly adding links.
;; (Though in Termux, you first must paste from your
;; Android clipboard and then copy/kill via Emacs before
;; it'll work.)
(use-package org-cliplink
  :ensure t
  :config
  (define-key org-mode-map (kbd "C-c o c") #'org-cliplink))

;; This is also not needed, but adds some (dubiously) useful properties
;; to the Org-roam file's property drawer.

;; First, set up a system for getting location
;; (we could also try to leverage termux's built-in
;; GPS location abilities via `termux-location`, but
;; it seems a bit slow and doesn't even always work if
;; your device can't get a good satellite connection.)
(setq calendar-latitude 0)
(setq calendar-longitude 0)
(defun bms/get-lat-long-from-ipinfo ()
  (let*
      ((latlong (substring
                 (shell-command-to-string "curl -s 'ipinfo.io/loc'") 0 -1))
       (latlong-list (split-string latlong ",")))
    (setq calendar-latitude (string-to-number (car latlong-list)))
    (setq calendar-longitude (string-to-number (cadr latlong-list)))))

(defun bms/add-other-auto-props-to-org-roam-properties ()
  (unless (file-exists-p (buffer-file-name))
    (unless (org-find-property "CREATION_TIME")
      (org-roam-add-property (format-time-string "%s"
                                                 (nth 5
                                                      (file-attributes (buffer-file-name))))
                             "CREATION_TIME"))
    (unless (org-find-property "AUTHOR")
      (org-roam-add-property roam-user "AUTHOR"))
    (unless (org-find-property "MAIL")
      (org-roam-add-property roam-email "MAIL"))
    (unless (org-find-property "LAT_LONG")
      (bms/get-lat-long-from-ipinfo)
      (org-roam-add-property (concat (number-to-string calendar-latitude) "," (number-to-string calendar-longitude)) "LAT-LONG"))))

(add-hook 'org-roam-capture-new-node-hook #'bms/add-other-auto-props-to-org-roam-properties)

;; You could use Ivy or Helm or the default, but I
;; like Selectrum, Consult & friends. Plus we can leverage
;; Consult for a nice alternative to deft for note-searching.
;; You'll need this to use my ripgrep note searching feature below.

;; selectrum
(use-package selectrum
  :ensure t
  :config
  (selectrum-mode +1))

;; ;; prescient  - T9
(use-package prescient
  :ensure t
  :config
  (setq prescient-persist-mode t)
  (setq prescient-filter-method '(literal regexp initialism fuzzy))) ;; added fuzzy

(use-package orderless
  :ensure t
  :init (icomplete-mode)                ; optional but recommended!
  :custom (completion-styles '(orderless))
  :config
  (setq orderless-matching-styles '(orderless-flex))
  ;; This means that the company-capf backend will automatically use orderless, but following issue exists:
  ;; Pressing SPC takes you out of completion, so with the default separator you are limited to one component,
  ;; which is no fun. To fix this add a separator that is allowed to occur in identifiers, for example, for
  ;; Emacs Lisp code you could use an ampersand:
  (setq orderless-component-separator "[ &]")

  ;; The matching portions of candidates aren’t highlighted. But while you can’t get different faces for
  ;; different components, you can at least get the matches highlighted in the sole available face with this configuration
  (defun just-one-face (fn &rest args)
    (let ((orderless-match-faces [completions-common-part]))
      (apply fn args)))

  (advice-add 'company-capf--candidates :around #'just-one-face))

(use-package selectrum-prescient
  :ensure t
  :config
  ;; to make sorting and filtering more intelligent
  (selectrum-prescient-mode +1)

  ;; Filtering with orderless
  (setq selectrum-refine-candidates-function #'orderless-filter)
  (setq selectrum-highlight-candidates-function #'orderless-highlight-matches)

  ;; If you also configure `completion-styles` for orderless you might want to use the
  ;; following advice because orderless isn't well suited for initial gathering of
  ;; candidates by completion in region.
  (advice-add #'completion--category-override :filter-return
              (defun completion-in-region-style-setup+ (res)
                "Fallback to default styles for region completions with orderless."
                (or res
                    ;; Don't use orderless for initial candidate gathering.
                    (and completion-in-region-mode-predicate
                         (not (minibufferp))
                         (equal '(orderless) completion-styles)
                         '(basic partial-completion emacs22)))))

  ;; Minibuffer-actions with embark

  ;; You should bind embark commands like embark-act, embark-act-noexit
  ;; and embark-export in minibuffer-local-map (as embark commands are not selectrum specific).
  ;; For available commands and other embark configurations see the embark documentation and its wiki.

  (defun current-candidate+category ()
    (when selectrum-is-active
      (cons (selectrum--get-meta 'category)
            (selectrum-get-current-candidate))))

  (add-hook 'embark-target-finders #'current-candidate+category)

  (defun current-candidates+category ()
    (when selectrum-is-active
      (cons (selectrum--get-meta 'category)
            (selectrum-get-current-candidates
             ;; Pass relative file names for dired.
             minibuffer-completing-file-name))))

  (add-hook 'embark-candidate-collectors #'current-candidates+category)
  ;; No unnecessary computation delay after injection.
  (add-hook 'embark-setup-hook 'selectrum-set-selected-candidate)

  ;; The following is not selectrum specific but included here for convenience.
  ;; If you don't want to use which-key as a key prompter skip the following code.

  (setq embark-action-indicator
        (lambda (map) (which-key--show-keymap "Embark" map nil nil 'no-paging)
          #'which-key--hide-popup-ignore-command)
        embark-become-indicator embark-action-indicator)

  ;; to save your command history on disk, so the sorting gets more
  ;; intelligent over time
  (prescient-persist-mode +1))

;; Example configuration for Consult
(use-package consult
  ;; Replace bindings. Lazily loaded due by `use-package'.
  :bind (("C-x M-:" . consult-complex-command)
         ("C-c h" . consult-history)
         ("C-c m" . consult-mode-command)
         ("C-x b" . consult-buffer)
         ("C-x 4 b" . consult-buffer-other-window)
         ("C-x 5 b" . consult-buffer-other-frame)
         ("C-x r x" . consult-register)
         ("C-x r b" . consult-bookmark)
         ("M-g g" . consult-goto-line)
         ("M-g M-g" . consult-goto-line)
         ("M-g o" . consult-outline)       ;; "M-s o" is a good alternative.
         ("M-g l" . consult-line)          ;; "M-s l" is a good alternative.
         ("M-g m" . consult-mark)          ;; I recommend to bind Consult navigation
         ("M-g k" . consult-global-mark)   ;; commands under the "M-g" prefix.
         ("M-g r" . consult-ripgrep)      ;; or consult-grep, consult-ripgrep
         ("M-g f" . consult-find)          ;; or consult-locate, my-fdfind
         ("M-g i" . consult-project-imenu) ;; or consult-imenu
         ("M-g e" . consult-error)
         ("M-s m" . consult-multi-occur)
         ("M-y" . consult-yank-pop)
         ("<help> a" . consult-apropos))

  ;; The :init configuration is always executed (Not lazy!)
  :init

  ;; Custom command wrappers. It is generally encouraged to write your own
  ;; commands based on the Consult commands. Some commands have arguments which
  ;; allow tweaking. Furthermore global configuration variables can be set
  ;; locally in a let-binding.
  (defun my-fdfind (&optional dir)
    (interactive "P")
    (let ((consult-find-command '("fdfind" "--color=never" "--full-path")))
      (consult-find dir)))

  ;; Replace `multi-occur' with `consult-multi-occur', which is a drop-in replacement.
  (fset 'multi-occur #'consult-multi-occur)

  ;; Configure other variables and modes in the :config section, after lazily loading the package
  :config

  ;; Configure preview. Note that the preview-key can also be configured on a
  ;; per-command basis via `consult-config'.
  ;; (setq consult-preview-key 'any) ;; any key triggers preview, the default

  ;; Optionally configure narrowing key.
  ;; Both < and C-+ work reasonably well.
  (setq consult-narrow-key "<") ;; (kbd "C-+")
  ;; Optionally make narrowing help available in the minibuffer.
  ;; Probably not needed if you are using which-key.
  ;; (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)

  ;; Optional configure a view library to be used by `consult-buffer'.
  ;; The view library must provide two functions, one to open the view by name,
  ;; and one function which must return a list of views as strings.
  ;; Example: https://github.com/minad/bookmark-view/
  ;; (setq consult-view-open-function #'bookmark-jump
  ;;       consult-view-list-function #'bookmark-view-names)

  ;; Optionally configure a function which returns the project root directory
  ;; (autoload 'projectile-project-root "projectile")
  ;; (setq consult-project-root-function #'projectile-project-root)
  )

;; Optionally add the `consult-flycheck' command.
(use-package consult-flycheck
  :bind (:map flycheck-command-map
              ("!" . consult-flycheck)))

;; Optionally enable richer annotations using the Marginalia package
(use-package marginalia
  :ensure t
  ;; The :init configuration is always executed (Not lazy!)
  :init
  ;; Must be in the :init section of use-package such that the mode gets
  ;; enabled right away. Note that this forces loading the package.
  (marginalia-mode))

(use-package embark
  :ensure t
  :bind
  ("C-S-a" . embark-act)               ; pick some comfortable binding
  :config
  ;; For Selectrum users:
  (defun current-candidate+category ()
    (when selectrum-is-active
      (cons (selectrum--get-meta 'category)
            (selectrum-get-current-candidate))))

  (add-hook 'embark-target-finders #'current-candidate+category)

  (defun current-candidates+category ()
    (when selectrum-is-active
      (cons (selectrum--get-meta 'category)
            (selectrum-get-current-candidates
             ;; Pass relative file names for dired.
             minibuffer-completing-file-name))))

  (add-hook 'embark-candidate-collectors #'current-candidates+category)

  ;; No unnecessary computation delay after injection.
  (add-hook 'embark-setup-hook 'selectrum-set-selected-candidate))

;; org-roam-rg-search - this is a much faster way to search Org-roam notes:
;; requires the Selectrum+Consult setup immediately preceding.
;; Use C-c r r to search notes via consult's ripgrep interface
(defun bms/org-roam-rg-search ()
  "Search org-roam directory using consult-ripgrep. With live-preview."
  (interactive)
  (let ((consult-ripgrep "rg --null --ignore-case --type org --line-buffered --color=always --max-columns=500 --no-heading --line-number . -e ARG OPTS"))
    (consult-ripgrep org-roam-directory)))

(global-set-key (kbd "C-c rr") 'bms/org-roam-rg-search)

;; speed-keys - see https://github.com/alhassy/emacs.d#manipulating-sections
(setq org-use-speed-commands t)

;; On an org-heading, C-a goes to after the star, heading markers. To use speed keys, run C-a C-a to get to the star markers.
;; C-e goes to the end of the heading, not including the tags.
(setq org-special-ctrl-a/e t)

;;drag images into orgmode
(use-package org-download
  :ensure t
  :config
  (add-hook 'dired-mode-hook 'org-download-enable)
  (global-set-key (kbd "C-c o i") #'org-download-yank)
  (setq org-download-method 'attach))

(defun bms/org-attach-insert-link (&optional in-emacs)
  "Insert attachment from list."
  (interactive "P")
  (let ((attach-dir (org-attach-dir)))
    (if attach-dir
        (let* ((file (pcase (org-attach-file-list attach-dir)
                       (`(,file) file)
                       (files (completing-read "Insert attachment: "
                                               (mapcar #'list files) nil t))))
               (path (expand-file-name file attach-dir))
               (desc (file-name-nondirectory path)))
          (let ((initial-input
                 (cond
                  ((not org-link-make-description-function) desc)
                  (t (condition-case nil
                         (funcall org-link-make-description-function link desc)
                       (error
                        (message "Can't get link description from %S"
                                 (symbol-name org-link-make-description-function))
                        (sit-for 2)
                        nil))))))
            (setq desc (if (called-interactively-p 'any)
                           (read-string "Description: " initial-input)
                         initial-input))
            (org-insert-link nil path (concat "attachment:" desc))))
      (error "No attachment directory exist"))))
(define-key org-mode-map (kbd "C-c o l") #'bms/org-attach-insert-link)

;; in case you want some things not in melpa
;; you'll need it for the remaining things below
(use-package quelpa
  :ensure t)

(use-package quelpa-use-package
  :ensure t)

;; A bit of sugar for the visual appearance of Org syntax
;; Use if you like.
(use-package org-appear
  :ensure t
  :quelpa (org-appear :fetcher github :repo "awth13/org-appear")
  :config
  (setq org-hide-emphasis-markers t)
  (add-hook 'org-mode-hook 'org-appear-mode))

;; You don't need this, but it's cool and it does work on Android:
;; see https://github.com/org-roam/org-roam-ui for features
(use-package org-roam-ui
  :ensure t
  :quelpa (org-roam-ui :fetcher github :repo "org-roam/org-roam-ui" :branch "main" :files ("*.el" "out"))
  :after org-roam
  :hook (org-roam . org-roam-ui-mode))

An excellent way of keeping Org notes (and files more generally) in sync between desktop, laptop, and mobile devices is Syncthing. On Android I recommend using the Syncthing-Fork app (via F-Droid), which has various improvements over the default Syncthing app on Android, including better file-access features. (On iOS there is now a third-party solution for syncing via Syncthing: Möbius-Sync. I have no idea how to use Emacs/Org-mode on iOS though, but I recall hearing about some ways of running a Linux shell on iOS like iSH, so possibly there’s some way.)

I have Syncthing sync my Org files to a directory in my main “home” directory on Android Documents/Org and then in Termux created a Documents directory and inside of that directory created a symlink to my actual Org directory via ln -s storage/shared/Documents/Org Org. I’ve found that is easier for allowing Syncthing to have access to the files in order to keep them in sync. (And having my Org files live at ~/Documents/Org in Termux mimics the directory structure on my Linux boxes, which makes lots of things easier in terms of sharing configurations.)

]]>