I've created a small weather forecast tool in Elisp, using request.el and the BOM's HTTP API (unofficial documentation here https://trickypr.github.io/bom-weather-docs/).

The full module can be found here in my own configuration, though you might want to change the function names if you intend to copy this into your own config.

theurgy-weather-find-geohash provides an interface for finding your geohash, which is the geographic identifier that BOM uses in it's API. You can search by suburb name or postcode, and it will provide you a list of possible results. The geohash string is stored in theurgy-geohash.

theurgy-weather-fetch-forecast downloads the forecast data for the next few days to a file named forecast in the Emacs user directory. theurgy-start-forecast-timer starts a timer to refetch this forecast every 30 minutes (this request is non-blocking thanks to request.el), and the script itself runs this function on Emacs startup.

theurgy-quick-forecast will prompt for a date, then display the minimum and maximum temperature, as well as a short description ("Sunny", "Cloudy", etc) in the echo area. theurgy-weather will instead display a more detailed weather forecast in a read-only org-mode buffer, for example:

* 29/11/2025 - Sunny.
Sunny. Winds southeasterly 20 to 30 km/h turning easterly 25 to 40 km/h before dawn then tending northeast to southeasterly 15 to 25 km/h in the middle of the day.
- 16-35°C
- 0% Chance of Rain (0-0mm)
- extreme UV
- High Fire Danger

* 30/11/2025 - Sunny.
Sunny. Winds east to northeasterly 25 to 35 km/h tending northwest to northeasterly 20 to 30 km/h in the morning then tending south to southwesterly 15 to 25 km/h in the early afternoon.
- 21-38°C
- 0% Chance of Rain (0-0mm)
- extreme UV
- High Fire Danger

* 1/12/2025 - Partly cloudy.
Partly cloudy. Light winds becoming southwesterly 20 to 30 km/h during the morning then tending southerly 15 to 20 km/h during the evening.
- 17-27°C
- 10% Chance of Rain (0-0mm)
- extreme UV
- High Fire Danger

Patches welcome. If there is enough interest I will move this out of my own config and into it's own package.

So, for this Emacs Carnival, I wanted to solve this problem with Org Babel, because not only can it be used for literate programming in the traditional sense (as I've already talked about in this blog), it can also be used to interact with and manipulate the document the code itself is in. This allows the document to "come alive".

As a proof of concept of how I want this to work, I've mocked up a Fate Accelerated character sheet which does some very simple automations to make rolling dice easier. I've spent only a few hours mocking this up, and no doubt I will expand it, especially to include an oracle system of some sort for solo play as well. Let's have a look at how it works now.

The full sheet can be found here but I'll copy code blocks here as relevant. I won't duplicate the structure, but essentially all the "code" of this sheet is inside it's own code header so that it can be hidden. In that header there is a startup block, which looks like this

#+name: startup
#+begin_src elisp :results silent
  (org-sbe "fae")

  (define-minor-mode srpg-mode
    "Minor mode for solo RPG gameplay."
    :init-value nil
    :keymap (make-keymap))

  (define-key srpg-mode-map (kbd "M-r") 'fae/take-action)
#+end_src

The org-sbe macro evaluates another elisp code block that contains all the Fate system logic that I need. The minor mode is also defined here because I want key mapping, but I don't want to override any keys in the org major mode in other buffers. It's also defined here because I want the whole file to be redistributable.

There is another code block before the Fate code that looks like this:

#+name: prop-tbl-lookup
#+begin_src elisp :var lookup="" target="" :results silent
  (alist-get target
         (mapcar #'(lambda (x) (cons (replace-regexp-in-string "\\(\\[\\[.*\\]\\[\\)\\(.*\\)\\]\\]" "\\2" (cadr x)) (car x)))
                 (cl-remove-if (lambda (x) (not (listp x))) lookup))
         nil
         nil
         (lambda (x y) (let ((z (string-search x y)))
                         (and z (= 0 z)))))
#+end_src

This is a bit disgusting, but essentially what it does is it searches a table (lookup) for a value based on the right column contents (target). In this block, lookup and target are empty strings - the code blocks in the Fate code will set those values when they call this block. This is the least annoying way of fetching values from an org table that I could figure out.

You may be wondering about that regex replace. It converts links to their description, which is useful because the Fate approaches (skills) table for each character looks like this:

#+name: pc1
| +x | Approach |
|----+----------|
| +2 | Careful  |
| +0 | Clever   |
| +8 | Flashy   |
| +3 | Forceful |
| +0 | Quick    |
| +0 | Sneaky   |

If you've never seen elisp: links, I wouldn't blame you, but they are perfect here because they turn an otherwise static table into a bunch of clickable buttons. This is 1 way to roll checks in this sheet, which uses this snippet of code:

(defun fae/roll-approach (table approach)
  "Get careful approach value."
  (+ (fae/roll-ndF 4)
     (or (org-babel-execute-src-block nil (org-babel-lob-get-info `(babel-call (:call "prop-tbl-lookup" :arguments ,(format "%s, \"%s\"" table approach))))) 0)
     (if (y-or-n-p "Any other modifiers?")
       (read-minibuffer "+? ")
       0)))

fae/roll-ndF is just a dice rolling function and not that interesting. The org-babel-execute-src-block may draw your attention instead. What this is doing is constructing a #+call: block in code, which allows us to pass a dynamic table and approach as parameters. We can't use org-sbe here because any arguments passed to it are treated as strings, (org-sbe table) will treat table as a string literal "table" and not as it's actual value.

We have one more way of rolling dice, which is bound the M-r in the minor mode:

(defun fae/get-approach-modifier (approach)
  "Get approach value."
  (let ((table (read-string "For which approach table? ")))
    (or (org-babel-execute-src-block nil (org-babel-lob-get-info `(babel-call (:call "prop-tbl-lookup" :arguments ,(format "%s, \"%s\"" table approach))))) 0)))

(defun fae/take-action ()
  "Say what you're trying to do and insert a roll outcome."
  (interactive)
  (let* ((action (read-string "What are you trying to do? "))
         (dice-roll (fae/roll-ndF 4))
         (approach (completing-read
                  "Select approach: "
                  '("Careful" "Clever" "Flashy" "Forceful" "Quick" "Sneaky")))
         (app-mod (fae/get-approach-modifier approach))
         (add-mod (if (y-or-n-p "Any other modifiers?")
                    (read-minibuffer "+? ")
                  0)))
    (insert (format "%s (Approach %s, Rolled %s+%s+%s=%s)\n" action approach dice-roll app-mod add-mod (+ dice-roll app-mod add-mod)))))

This is used for logging the action at the current point instead of just displaying the result in the minibuffer, which is good because I like to keep track of my rolls and what I was trying to do with them.

And finally, I want this to all set itself up automatically when I open the file, which can be done by putting this at the very bottom to run the startup block when the file opens.

# Local Variables:
# org-confirm-babel-evaluate: nil
# eval: (progn (org-sbe "startup"))
# End:

And that's all for now, until I extend this to include other features from Fate like fate point tracking and aspects/stunts.

Obscured by search results of Emacs Lisp and org-mode timers, I came upon tmr, from Prot. You might be surprised that it exceeded my expectations, purely just because of the tabulated view. It fits cleanly into my setup with the below snippet. I recommend you give it a try.

(use-package tmr)

(add-to-list 'display-buffer-alist
           '("\\\\*tmr-tabulated-view\\\\*"
             (display-buffer-in-side-window)
             (side . top)
             (slot . 4)
             (window-height . 0.1)))

So, that's what I've been working on. Using copious magit-section and a bunch of extremely crappy, poorly formatted Elisp, I'm starting to make my dream a reality.

You can see a video demo of the current functionality here: video demo.

It's quite bare-bones at the moment, and doesn't support a lot of things that are probably necessary for this to be of any serious use. My plan is to "eat my own dogfood" with this and add things as I want them. Contributions are always welcome, and the code is available here.

I'm using whaler.el instead of project.el, because it's important to me to be able to treat arbitrary, non-git repositories as projects. I also like that it's minimal and easy to understand. I've also swapped to using neotree instead of treemacs, and generally I'm trying to build a more tab-oriented workflow for myself.

It would be nice, then, if neotree automatically updated to show the right project directory when I change tabs, but this isn't default functionality with whaler. Here's my solution, copied from my config:

(defvar tab-bar-select-tab-hook nil "Hook for `tab-bar-select-tab'")
(advice-add 'tab-bar-select-tab :after (lambda (x) (run-hooks 'tab-bar-select-tab-hook)))

As far as I can tell, tab-bar-mode doesn't expose any hooks for selecting tabs natively, so this advice does that for me.

To save the working directory as a "tab-local variable", I'm just setting it as the tab bar group name (while keeping it somewhat readable):

(defun theurgy-open-project ()
  "Select a project and update neotree to use it as root."
  (interactive)
  (whaler :action (lambda (dir)
                  (find-file (get-project-default-file dir))
                  (tab-rename (file-name-nondirectory (string-remove-suffix "/" dir)))
                  (tab-bar-change-tab-group (concat "project: " dir))
                  (neotree-dir dir))))

Finally I can use the previous hook to swap back to the right directory after tab change:

(defun theurgy-swap-to-tab-project ()
  "Go to the project dir of the tab group."
  (let ((tab-group-name (tab-bar-tab-group-default (tab-bar--current-tab))))
    (when (string-match-p "^project:" tab-group-name)
      (neotree-dir (string-remove-prefix "project: " tab-group-name)))))

(add-hook 'tab-bar-select-tab-hook #'theurgy-swap-to-tab-project)

There was a point where I realised that swapping between tools was introducing some unnecessary mental overhead (I think it was being forced to use some web text editor within AWS, I don't remember). Unbeknown to me, Emacs was the perfect solution. Not just for text, but for everything I could want. I came to value the consistency of my user interface, and not just for text which was my immediate issue, but also for other applications like Git and note-taking (via org). I don't really evangelise tools, because people will use what they're used to, but if I had to pitch Emacs to someone it would really just be "a consistent interface for almost everything, on any platform".

It's difficult to overstate how useful this one trait of the application is. Being able to keep the same interface and functionality (more or less) whether I'm on my home Linux systems, or my work machines which have been a mix of Windows and Mac is such a boon. I can have an entire development environment functioning on a client device usually with just 1 software approval, as opposed 30 different approvals for an editor, a git interface, etc.

Emacs is a piece of software with a "killer feature" around every corner, but consistency and portability is without question the one that I believe stands before the rest. Even org.

Unfortunately, while it's great for notes, I still prefer to have a proper project structure when I'm building up the world. Generally, I've done this via Kanka because it's free, but as I've started a new worldbuilding project recently I figured I should give it a shot in Org directly. I already had some use with org-novelist (which I have stopped using), and while there isn't a direct equivalent for worldbuilding, I figured that if I structured my articles as if I was using Zettelkasten, then it may work out.

The main reason that I was using Kanka previously is because the end result is easily shareable. I won't go into the project structure of my worldbuilding setup in depth, but I want to show off the "sharing" part - publishing it as a wiki with ox-publish.

As for why I chose to use basic ox-publish over weblorg, which I use for this blog: I want to do some hacky stuff to get some wiki functionality working here, and I want a more free-form directory structure.

One other thing: I'm not using org-roam here, because I don't want to mess with having multiple DBs and I don't want to accidentally "cross-contaminate" from my personal notes to my public facing projects. That's a bad idea security-wise.

Anyhow, System Crafters has a good page on setting up a basic web project, and that's the basis of my build script. The only addition is this list to the org-publish-project-list:

(list "org-static"
      :base-directory "."
      :base-extension "css\\|js\\|json\\|png\\|jpg\\|gif\\|pdf\\|mp3\\|ogg\\|swf"
      :publishing-directory "./export"
      :recursive t
      :publishing-function 'org-publish-attachment
      )

This capture's attachments, and crucially it also captures CSS files, JavaScript files, and JSON files. The CSS is less important here, it's just for styling which can be set like this in the HTML head (base-path here is the base URL of the website):

;; Customize the HTML output
(setq org-html-head (concat "<link rel=\"stylesheet\" href=\"" base-path "/styles.css\" type=\"text/css\">"))

Just this on it's own already gives pretty exports (well, with a good stylesheet anyway). But there are two things which any good wiki needs: searching, and backlinks.

I implemented searching with Fuse: it's one JavaScript file that sits at the root of the project next to the build script. And now we get to the most disgusting Elisp code you'll ever see. I welcome any attempts to clean this up, I know it is terrible. Fuse needs a JSON file containing all the contents it should search, and I'm going to construct one by recursively going down through each org file in the project, fetching the title, filetags, and contents, then writing that to a JSON file.

(with-temp-file
  "search.json"
(insert "searchData = ")
(json-insert (vconcat (seq-filter
                       (lambda (x) x)
                       (mapcar
                        (lambda (f)
                          (when (org-publish-find-property f :title nil)
                            (list
                             :path (concat base-path (string-trim-left f "."))
                             :title (car (org-publish-find-property f :title nil))
                             :tags (vconcat (org-publish-find-property f :filetags nil))
                             :contents (with-temp-buffer
                                         (insert-file-contents f)
                                         (goto-char (point-min))
                                         (flush-lines "^#+")
                                         (org-replace-all-links-by-description)
                                         (goto-char (point-min))
                                         (flush-lines "^$")
                                         (flush-lines "^- $")
                                         (buffer-string))
                             )))
                        (directory-files-recursively "." "\\.org$"))))))

I'm prepending searchData = so that the file can be included in a script tag in the postamble, we'll see this in a bit. The :contents property is a bit confusing, so step by step:

1. In a temporary buffer, insert the current org file, then go to the start of it.
2. Get rid of all property lines.
3. Replace all links with their descriptions, so getting rid of the plaintext syntax.
4. Go back to the start of the buffer, and get rid of all empty lines.
5. Get rid of all lines that are just a single dash - this happens in index cards where I have incomplete bullet lists.
6. Return the whole buffer as a string.

org-replace-all-links-by-description looks like this:

(defun org-replace-all-links-by-description (&optional start end)
  "Find all org links and replace by their descriptions."
  (goto-char (point-min))
  (while (re-search-forward org-link-bracket-re nil t)
    (replace-match (match-string-no-properties 
                    (if (match-end 2) 2 1)))))

And I got that from here. Also, in case it seems a bit weird to be using vconcat to turn the list into an array, json-insert doesn't work on lists. And the seq-filter - it's for getting rid of any random null values.

Ok, all told that gives me a nice JSON file containing all the metadata I want to search. Now to search it.

In the org-html-preamble (I'll come back to this in a second), I have a search box and an empty unordered list.

<input id="search_input" type="text" placeholder="Search for...">
<ul id="search_results">

A simple JavaScript script can read when the search input is submitted, and then searches with Fuse. It will push results to the search results list:

document.getElementById("search_input").addEventListener("keypress", search);

const fuse = new Fuse(searchData, {includeScore: true, ignoreDiacritics: true, includeMatches: true, ignoreLocation: true, useExtendedSearch: true, threshold: 0.3, keys: [{name: 'title', weight: 2},{name: 'tags', weight: 3},{name: 'contents', weight: 1}]});

function search(event) {
    if (event.key == "Enter") {
      var x = document.getElementById("search_input");
      var r = document.getElementById("search_results");
      r.innerHTML = "";
      var sr = fuse.search(x.value);
      console.log(fuse.search(x.value));
      sr.forEach((result) => {
          var c = document.createElement('li');
          var a = document.createElement('a');
          var b = document.createElement('p');
          var h = document.createTextNode(result.item.title);

          a.appendChild(h);
          a.title = result.item.title;
          a.href = result.item.path.replace(/\.[^/.]+$/, ".html");

          const truncate = (input) => input.length > 125 ? `${input.substring(0, 125)}...` : input;

          b.appendChild(document.createTextNode(truncate(result.item.contents)));

          c.appendChild(a);
          c.appendChild(b);
          r.appendChild(c);
      });
    }
}

Again I am aware that this is terrible. But, when I add this, Fuse, and the search data JSON to the post-amble like so:

(setq org-html-postamble (concat
                        (concat "<script type=\"text/javascript\" src=\"" base-path "/search.json\"></script>")
                        (concat "<script src=\"" base-path "/fuse.js\"></script>")
                        (concat "<script src=\"" base-path "/search.js\"></script>")))

It all works! Search results get dredged up from the depths and shown underneath the search input bar.

Now backlinks.

This is actually conceptually simple: iterate through each org file, get a list of all the links inside it, then transpose it so that ((source-1 (target-1 target-2))) becomes ((target-1 (source-1)) (target-2 (source-1))), and write that to the page somewhere.

;; Construct backlink tracker
(defvar backlink-hashmap (make-hash-table :test #'equal))

(dolist (i (mapcar
          (lambda (f)
            (list
             (list :file (string-trim-left f "\\."))
             (list :links (mapcar
                           (lambda (l)
                             (string-trim-left (concat "/" (file-relative-name (expand-file-name l (file-name-parent-directory f)) ".")) "\\."))
                           (with-temp-buffer
                             (insert-file-contents f)
                             (org-element-map (org-element-parse-buffer) 'link
                               (lambda (link)
                                 (when (string= (org-element-property :type link) "file")
                                   (org-element-property :path link)))))))))
          (directory-files-recursively "." "\\.org$")))
  (mapcar
   (lambda (b)
     (let ((new-lst (gethash b backlink-hashmap '())))
       (remhash b backlink-hashmap)
       (puthash b
              (append new-lst (list (cadr (assoc :file i))))
              backlink-hashmap)))
   (cadr (assoc :links i))))

;; Remove duplicates
(maphash
 (lambda (x y)
   (delq nil (delete-dups y)))
 backlink-hashmap)

For the nth time, this is terrible code. You'll particularly cringe at the file name transformation crap. Regardless, it does work, and backlink-hashmap gets populated in the way we want. One thing of note here: I'm using the relative file name as the key for the hash map, which means that setting the test to equal is necessary for queries to work.

Now we can get the backlinks for anyfile with gethash and the name of our file, so we can fetch all of this data in a function for org-html-preamble:

(defun build-navigation (info)
  "Constructs navigation HTML. INFO contain all export options."
  (concat "<nav>
  <ul>
  <li>Project Name</li>
  <li class=\"float-right sticky\"><input id=\"search_input\" type=\"text\" placeholder=\"Search for...\"></li>
  <li><a href=\""
        base-path
        "/home.html\">Home </a></li>
<li><a href=\"#\">Backlinks ▾</a>
      <ul>"
        (mapconcat
         (lambda (x)
           (concat "<li><a href=\"" (concat base-path (string-trim-right x "\\.org") ".html") "\">" (car (org-publish-find-property (expand-file-name (concat "." x) (file-name-directory load-file-name)) :title nil)) "</a></li>"))
         (gethash
          (concat "/" (file-relative-name (plist-get info :input-file) (file-name-directory load-file-name)))
          backlink-hashmap))
        "</ul>
    </li>
  </ul>
  </nav>
<div>
<ul id=\"search_results\">
</ul>
</div>"))

(setq org-html-preamble 'build-navigation)

And that's it. Each page now has a drop down in the navigation bar showing all backlinks. Hopefully you learned something in this process, even if that's that I'm terrible at writing Elisp.

Before looking at what my config looks like currently, let's look at what I'm actually using Emacs to write, since a use case is a good place to start from. When I write in Emacs, 99.9% of the time I'm writing in org-mode (the other 0.01% of the time is in markdown-mode with Emacs Everywhere, but I won't cover that here). By my own self-reflection, this is what I mostly use Emacs for in terms of writing (and in no particular order):

• Fiction Writing:
  • Novels or Short Stories
  • Worldbuilding
• Technical Writing:
  • Essays and Mini-essays
  • Notes, and To-Dos
  • Knowledge Management
  • Literate Programming
• Blog Posts
• Tabletop RPG Rules

The requirements for these are all relatively distinct, and my flow for some is more streamlined than others. For example, I'm quite happy with my RPG rules writing setup, at least for my current project; and I'm also pretty happy with Weblorg and blog writing/publishing. I feel like my main points of contention are essay writing and personal knowledge management. So let's have a look at what I'm doing now before I start thinking how to do it better.

(defun org-mode-init ()
  "This is called through org-mode-hook, so that I don't need to add-hook 20 million times."
  ;; I want org to display pictures inline.
  (org-display-inline-images)
  ;; I don't want monospace text by default.
(variable-pitch-mode))

(add-hook 'org-mode-hook #'org-mode-init)

(setq org-log-done 'time ;; I want to keep track of the time tasks are completed.
    org-return-follows-link t ;; I want to be able to follow links easily.
    org-hide-emphasis-markers t ;; This is a big one: hide markup syntax like ** and //.
    org-pretty-entities t ;; These two variables together render latex entities as UTF8, which means that Greek letters, subscript, and superscript are all rendered correctly.
    org-pretty-entities-include-sub-superscripts t
    org-enforce-todo-dependencies t ;; Prevent changing a parent to DONE if the children aren't
    org-enforce-todo-checkbox-dependencies t
    org-agenda-skip-scheduled-if-done t ;; Don't show done stuff in the agenda view
    org-agenda-skip-deadline-if-done t
    org-agenda-skip-timestamp-if-done t
    org-todo-keywords '((sequence "TODO" "WIP" "DELEGATED" "WAITING" "|" "CANCELLED" "DONE")) ;; Some extra keywords in addition to TODO and DONE
    org-refile-targets '((org-agenda-files :maxlevel . 2)) ;; Allow any agenda files to be refile targets
    )

(setq org-cite-global-bibliography '("~/.org/global.bib") ;; Global bibliography location)

  (use-package org-modern
  :hook ((org-mode . org-modern-mode)
         (org-agenda-finalize . org-modern-agenda)))

(use-package org-modern-indent
  :straight (org-modern-indent :type git :host github :repo "jdtsmith/org-modern-indent")
  :hook ((org-mode . org-modern-indent-mode)))

(use-package wc-mode
  :hook ((org-mode . wc-mode))
  :config (setq wc-modeline-format "WC[%tw]"))

  (defun mark-whole-word ()
  "Marks the whole word underneath the cursor."
  (interactive)
  (forward-word)
  (set-mark-command nil)
  (backward-word))

(defun mark-sentence ()
  "Marks the entire sentence underneath the cursor."
  (interactive)
  (forward-sentence)
  (set-mark-command nil)
  (backward-sentence))

  (defun move-sentence-right (&optional arg)
  "Moves the whole sentence to the right of the next sentence."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (kill-sentence)
    (forward-sentence)
    (yank)
    (backward-sentence)
    (setq arg (1- arg))))

(defun move-sentence-left (&optional arg)
  "Moves the whole sentence to the left of the previous sentence."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (kill-sentence)
    (backward-sentence)
    (left-char) ;; Capture previous space
    (yank)
    (backward-sentence)
    (setq arg (1- arg))))

(defun move-paragraph-up (&optional arg)
  "Moves the whole paragraph above the previous paragraph."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-paragraph)
    (backward-paragraph)
    (kill-paragraph nil)
    (backward-paragraph)
    (yank)
    (backward-paragraph)
    (setq arg (1- arg))))

(defun move-paragraph-down (&optional arg)
  "Moves the whole paragraph above the previous paragraph."
  (interactive "^p")
  (or arg (setq arg 1))
  (while (> arg 0)
    (forward-paragraph)
    (backward-paragraph)
    (kill-paragraph nil)
    (forward-paragraph)
    (yank)
    (backward-paragraph)
    (setq arg (1- arg))))

(defun break-out-sentence ()
  "Breaks a sentence out into it's own buffer for editing."
  (interactive)
  (backward-sentence)
  (kill-sentence)
  (let ((buf (generate-new-buffer "*break-out*"))
      (window (split-window-below -10)))
    (set-window-buffer window buf)
    (select-window window))
  (erase-buffer)
  (yank)
  (org-mode))

(defun break-out-choose-sentence ()
  "Chooses a sentence from the break-out buffer."
  (interactive)
  (backward-sentence)
  (kill-sentence)
  (other-window -1)
  (yank)
  (select-window (get-buffer-window "*break-out*"))
  (kill-buffer-and-window))

(use-package powerthesaurus
  :bind ("C-x t" . powerthesaurus-transient))

  (defun break-out-dwim ()
  "Either break-out or choose sentency depending on buffer name."
  (interactive)
  (if (equal (buffer-name) "*break-out*")
      (break-out-choose-sentence)
    (break-out-sentence)))

(define-key org-mode-map (kbd "C-c o b") #'break-out-dwim)

(define-key org-mode-map (kbd "C-M-<left>") #'move-sentence-left)
(define-key org-mode-map (kbd "C-M-<right>") #'move-sentence-right)
(define-key org-mode-map (kbd "C-M-<up>") #'move-paragraph-up)
(define-key org-mode-map (kbd "C-M-<down>") #'move-paragraph-down)

(define-key org-mode-map (kbd "C-@") #'mark-whole-word)
(define-key org-mode-map (kbd "M-@") #'mark-sentence)

(require 'transient)

(transient-define-prefix reorder-transient ()
  "Transient menu for text re-ordering commands."
  ["Move sentence..." ("l" "Left" move-sentence-left)
   ("r" "Right" move-sentence-right)]
  ["Move paragraph..." ("u" "Up" move-paragraph-up)
   ("d" "Down" move-paragraph-down)])

(transient-define-prefix mark-menu-transient ()
  "Transient menu for marking units of text."
  ["Mark" ("w" "Word" mark-whole-word)
   ("s" "Sentence" mark-sentence)
   ("p" "Paragraph" mark-paragraph)
   ("b" "Buffer" mark-whole-buffer)])

(define-key org-mode-map (kbd "C-c o SPC") #'mark-menu-transient)
(define-key org-mode-map (kbd "C-c o r") #'reorder-transient)

(when (and (not (equal system-type 'windows-nt)) (locate-file "harper-ls" exec-path))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio"))))

  (setq-default eglot-workspace-configuration
              '(:harper-ls (:dialect "Australian")))

  (add-hook 'org-mode-hook 'eglot-ensure))

(global-set-key (kbd "M-g <left>") 'flymake-goto-prev-error)
(global-set-key (kbd "M-g <right>") 'flymake-goto-next-error)
(global-set-key (kbd "C-x M-f") 'eglot-code-actions)

(defun org-mode-company-hook ()
    "Set company backends for `org-mode' usage."
    (setq-local company-backends
            '((company-capf company-dabbrev company-files company-ispell))))
(add-hook 'org-mode-hook #'org-mode-company-hook)

.
├── lore
│   ├── raw
│   └── refined
│       ├── journal
│       └── wiki
└── tasks
    ├── maintenance
    └── projects
	└── career

(setq org-agenda-files (apply 'append (mapcar
                                 (lambda (dir)
                                   (directory-files-recursively dir org-agenda-file-regexp))
                                 '("~/.org/tasks"))))

(defun new-maintenance-file (maintenance-area)
  "Create a new maintenance file for a given `MAINTENANCE-AREA'."
  (interactive "sMaintenance area is: ")
  (find-file (concat "~/.org/tasks/maintenance/" maintenance-area ".org"))
  (insert "\n\n* Calendar\n\n* TO-DO\n\n* Routines\n\n* Archive\n")
  (goto-char (point-min)))

(defun new-project-file (project-name acceptance-criteria)
  "Create a new project file for a given `PROJECT-NAME', with some `ACCEPTANCE-CRITERIA'."
  (find-file (concat "~/.org/tasks/projects/" project-name ".org"))
  (insert (concat "\n\n* Acceptance Criteria\n\n" acceptance-criteria "\n\n* Ideas\n\n* TODO Work\n\n** Calendar\n\n** TO-DO\n\n** Routines\n\n** Archive\n"))
  (goto-char (point-min)))

(defun new-generic-project (project-name acceptance-criteria)
  "Interactive wrapper for `new-project-file', for generic projects."
  (interactive "sProject name is: \nsAcceptance criteria is: ")
  (new-project-file project-name acceptance-criteria))

(defun new-career-project (project-name acceptance-criteria)
  "Interactive wrapper for `new-project-file', for career projects."
  (interactive "sProject name is: \nsAcceptance criteria is: ")
  (new-project-file (concat "career/" project-name) acceptance-criteria))

(require 'subr-x)

(defun select-task-area (location headline)
  "Prompt for a file in ~/.org/tasks/maintenance/ to insert the capture."
  (let* ((files (directory-files (concat "~/.org/tasks/" location) t "\\.org$"))
       (choices (mapcar
                 (lambda (x) (string-remove-suffix ".org" x))
                 (mapcar #'file-name-nondirectory files)))
       (selected (completing-read "Choose a file: " choices nil t)))
  (set-buffer (org-capture-target-buffer (concat "~/.org/tasks/" location selected ".org")))
  (org-capture-put-target-region-and-position)
  (widen)
  (goto-char (point-min))
  (setq headline (org-capture-expand-headline headline))
  (re-search-forward (format org-complex-heading-regexp-format
                             (regexp-quote headline))
                     nil t)
  (forward-line 0)))


(defun select-maintenance-area (headline)
  (select-task-area "maintenance/" headline))

(defun select-project (headline)
  (select-task-area "projects/" headline))

(defun select-career-project (headline)
  (select-task-area "projects/career/" headline))

(setq org-capture-templates
      '(("i" "Idea")
      ("ii" "Generic" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :idea: \n:Created: %T\n%?"
       :empty-lines 1)
      ("ip" "Project" entry
       (function (lambda () (select-project "Ideas")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1)
      ("ic" "Career" entry
       (function (lambda () (select-career-project "Ideas")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1)

      ("t" "Task")
      ("tt" "Generic")
      ("ttt" "Raw" entry
       (file "~/.org/inbox.org")
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} :task:\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttm" "Maintenance" entry
       (function (lambda () (select-maintenance-area "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttp" "Project" entry
       (function (lambda () (select-project "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ttc" "Career" entry
       (function (lambda () (select-career-project "TO-DO")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE}\n:Created: %T\n%?"
       :empty-lines 1)
      ("ts" "Scheduled")
      ("tss" "Raw" entry
       (file "~/.org/inbox.org")
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} :scheduled:\n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsm" "Maintenance" entry
       (function (lambda () (select-maintenance-area "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsp" "Project" entry
       (function (lambda () (select-project "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)
      ("tsc" "Career" entry
       (function (lambda () (select-career-project "Calendar")))
       "* TODO [%^{priority|#A|#B|#C|#D}] %^{TITLE} \n:SCHEDULED: %^T\n%?"
       :empty-lines 1
       :time-prompt t)

      ("n" "Note")
      ("nn" "Raw" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :note: \n:Created: %T\n%?"
       :empty-lines 1)
      ("nm" "Meeting")
      ("nmm" "Raw" entry
       (file "~/.org/inbox.org")
       "* %^{TITLE} :meeting: \n:Created: %T\n%?"
       :clock-in t
       :clock-resume t)
      ("nmc" "Career" entry
       (function (lambda () (select-career-project "Calendar")))
       "* %^{TITLE} \n:Created: %T\n%?"
       :empty-lines 1
       :clock-in t
       :clock-resume t)))

(defun open-inbox ()
  "Opens `~/.org/inbox.org'"
  (interactive)
  (find-file "~/.org/inbox.org"))

(defun open-maintenance ()
  "Opens `~/.org/tasks/maintenance/'"
  (interactive)
  (find-file "~/.org/tasks/maintenance/"))

(defun open-projects ()
  "Opens `~/.org/tasks/projects/'"
  (interactive)
  (find-file "~/.org/tasks/projects/"))

(defun open-career ()
  "Opens `~/.org/tasks/projects/career/'"
  (interactive)
  (find-file "~/.org/tasks/projects/career/"))

(transient-define-prefix task-management-menu ()
  "Transient menu for task management shortcuts."
  ["Go To" ("i" "Inbox" open-inbox)
   ("m" "Maintenance Directory" open-maintenance)
   ("p" "Projects Directory" open-projects)
   ("c" "Career Directory" open-career)]
  ["Create New" ("M" "Maintenance File" new-maintenance-file)
   ("P" "Project" new-generic-project)
   ("C" "Career Project" new-career-project)])

(define-key global-map (kbd "C-c o t") #'task-management-menu)  
(define-key global-map (kbd "C-c a") #'org-agenda)
(define-key global-map (kbd "C-c a") #'org-capture)

(use-package org-roam
  :straight nil
  :ensure t
  :init
  (setq org-roam-v2-ack t)
  :custom
  (org-roam-directory (file-truename "~/.org/lore/raw/"))
  (org-dailies-directory (file-truename "~/.org/refined/journal/"))
  (org-roam-file-exclude-regexp "\\.git/.*\\|logseq/.*$")
  (org-roam-completion-everywhere)
  (org-roam-capture-templates
    '(("d" "default" plain
       "%?"
       :target (file+head "${slug}.org" "#+title: ${title}\n")
       :unnarrowed t)))
  (org-roam-dailies-capture-templates
    '(("d" "default" entry
       "* %?"
       :target (file+head "%<%Y-%m-%d>.org" ;; format matches Logseq
                          "#+title: %<%Y-%m-%d>\n"))))
  :bind (("C-c n f" . org-roam-node-find)
       ("C-c n i" . org-roam-node-insert)
       :map org-roam-dailies-map
       ("Y" . org-roam-dailies-capture-yesterday)
       ("T" . org-roam-dailies-capture-tomorrow))
  :bind-keymap ("C-c n d" . org-roam-dailies-map)
  :config
  (require 'org-roam-dailies) ;; Ensure the keymap is available
  (org-roam-db-autosync-mode))

(use-package logseq-org-roam
  :straight (:host github
          :repo "sbougerel/logseq-org-roam"
          :files ("*.el")))

(defun org-roam-create-note-from-headline ()
  "Create an Org-roam note from the current headline and jump to it.

Normally, insert the headline’s title using the ’#title:’ file-level property
and delete the Org-mode headline. However, if the current headline has a
Org-mode properties drawer already, keep the headline and don’t insert
‘#+title:'. Org-roam can extract the title from both kinds of notes, but using
‘#+title:’ is a bit cleaner for a short note, which Org-roam encourages."
  (interactive)
  (let ((title (nth 4 (org-heading-components)))
        (has-properties (org-get-property-block)))
    (org-cut-subtree)
    (org-roam-find-file title nil nil 'no-confirm)
    (org-paste-subtree)
    (unless has-properties
      (kill-line)
      (while (outline-next-heading)
        (org-promote)))
    (goto-char (point-min))
    (when has-properties
      (kill-line)
      (kill-line))))

(transient-define-prefix org-roam-menu ()
  "Transient menu for task management shortcuts."
  ["Node" ("f" "Capture" org-roam-node-find)
   ("i" "Insert" org-roam-node-insert)
   ("r" "Refile" org-roam-create-node-from-headline)
   ("v" "Visit" org-roam-node-visit)   ]
  ["Dailies" ("t" "Today" org-roam-dailies-capture-today)
   ("y" "Yesterday" org-roam-dailies-capture-yesterday)
   ("n" "Tomorrow" org-roam-dailies-capture-tomorrow)]
  ["Logseq" ("R" "Fix links" logseq-org-roam)])

(define-key global-map (kbd "C-c o n") #'org-roam-menu)

(use-package biblio)

(defun bibtex-online-entry ()
  (interactive)
  (bibtex-entry "Online"))

(defun bibtex-misc-entry ()
  (interactive)
  (bibtex-entry "Misc"))

(defun bibtex-software-entry ()
  (interactive)
  (bibtex-entry "Software"))

(transient-define-prefix bibtex-transient-menu ()
  "Transient menu for task management shortcuts."
  ["Biblio" ("d" "doi.org" doi-insert-bibtex)
   ("x" "arXiv" arxiv-lookup)]
  ["Templates" ("o" "Online Resource" bibtex-online-entry)
   ("m" "Misc" bibtex-misc-entry)
   ("s" "Software" bibtex-software-entry)])

(define-key bibtex-mode-map (kbd "C-c r") #'bibtex-transient-menu)

(use-package org-roam
:straight nil
:ensure t
:init
(setq org-roam-v2-ack t)
:custom
(org-roam-directory (file-truename "~/.org/lore/"))
(org-dailies-directory (file-truename "~/.org/lore/refined/journal/"))
(org-roam-file-exclude-regexp "\\.git/.*\\|logseq/.*$")
(org-roam-completion-everywhere)
(org-roam-capture-templates
 '(("c" "Raw" plain
    "%?"
    :target (file+head "raw/${slug}.org" "#+title: ${title}\n")
    :unnarrowed t)
   ("r" "Refined")
   ("rm" "Mini-essay" plain
    "%?"
    :target (file+head "refined/wiki/${slug}.org" "#+title: ${title}\n#+author: Jakub Nowak")
    :unnarrowed t)))
(org-roam-dailies-capture-templates
 '(("d" "default" entry
    "* %?"
    :target (file+head "%<%Y-%m-%d>.org" ;; format matches Logseq
                       "#+title: %<%Y-%m-%d>\n"))))
:bind (("C-c n l" . org-roam-buffer-toggle)
       ("C-c n f" . org-roam-node-find)
       ("C-c n g" . org-roam-graph)
       ("C-c n i" . org-roam-node-insert)
       ("C-c n c" . org-roam-capture)
       :map org-roam-dailies-map
       ("Y" . org-roam-dailies-capture-yesterday)
       ("T" . org-roam-dailies-capture-tomorrow))
:bind-keymap ("C-c n d" . org-roam-dailies-map)
:config
(require 'org-roam-dailies) ;; Ensure the keymap is available
(org-roam-db-autosync-mode))

If you're unfamiliar, org-babel is a literate programming extension for org-mode. On a surface level, it works similar to a Python notebook. It allows you to specify what major mode to treat a code block as and execute code directly from within your org-mode file. It also allows you to rip code out of code-blocks and place it into another file. So, for example, I can have two code-blocks at different points in my org file, both with a :tangle file.cpp header, and have them both be inserted (in order) into file.cpp. This feature is often used for literate configs within Emacs - where one org file contains all the configuration code, with suitable annotations.

I don't use a literate config (currently). Actually, when it comes to Lisp I'm generally against being too literate in your code, either in code comments or literal literate programming. There's a quote out of Riastradh's Lisp Style Rules that I generally adhere to:

Write comments only where the code is incapable of explaining itself. Prefer self-explanatory code over explanatory comments. Avoid `literate programming' like the plague.

Rationale: If the code is often incapable of explaining itself, then perhaps it should be written in a more expressive language. This may mean using a different programming language altogether, or, since we are talking about Lisp, it may mean simply building a combinator language or a macro language for the purpose. `Literate programming' is the logical conclusion of languages incapable of explaining themselves; it is a direct concession of the inexpressiveness of the computer language implementing the program, to the extent that the only way a human can understand the program is by having it rewritten in a human language.

In Lisp, via macros, we usually have the luxury of completely changing the "language" (not literally) of the code we write, which means that code can, in my opinion, actually be self-documenting. Whenever I feel the impulse to annotate something with a comment, I try to take time to reflect on whether that line could instead be written in a better way that requires less external explanation. There are exceptions, like marking where a section of some logic begins and ends, but that's my general philosophy. It's also why I like Racket so much - being able to switch as required between effectively any syntax you want for a particular problem is very useful for maintaining readability in my opinion. Or just because I want to write something using APL syntax.

However, at work, I don't have the luxury of writing in Lisp. Currently I'm doing data engineering with dbt, and I'm mostly writing in SQL (with Jinja macros sprinkled on top). There's also been a lot of hubbub around code style recently, for a number of reasons I won't get into, and now we are recommended to use sqlfluff to fix up formatting on SQL files. So, my two issues here are:

1. SQL can be very opaque without sufficient commentary (something that is very true for a lot of older dbt models in this codebase).
2. I do not like the standard sqlfluff formatting rules. This is really just a personal grip, but having functions and keywords be CAPITALISED has always seemed a bit pointless to me, as though it's a relic from a time before syntax highlighting.
3. Bonus: dbt tests are often undocumented and (this is a problem with a lot of test suites, not just dbt) are abstracted away from the context of the code they're testing.

org-babel helps me fix all of these issues in one fell swoop. Better yet, it lets me do so without ever bothering other people working in the repository with org-mode or Emacs.

Let's tackle the first issue: opaqueness and literate programming. There is more to this than just explaining that "Oh, line X does Y and Z". The business context of a particular decision can also be very helpful to keep track of, and so is the story or task in Jira that a model or code block is a part of. While the former of these two could be done with just code comments, the latter benefits greatly from org's structural editing. For example, if a bunch of user stories are related and should be (per the system design) in one folder in the tree, we can structure the file like so (DE- is the user story prefix in Jira):

* DE-1: Building some pipeline
** Model 1
** Model 2

Even better, some models are made up of a massive chain of SQL CTEs. We can add those to our structure too:

* DE-1: Building some pipeline
** Model 1
*** CTE 1
*** CTE 2

For each model, we can specify the file we want the model to untangle to via header properties for each code-block.

* DE-1: Building some pipeline
** Model 1
:PROPERTIES:
:header-args:sql: :tangle model_1.sql :comments no :padline no
:header-args:yaml: :tangle _model_1.yml :comments no :padline no
:END:

*** CTE 1
*** CTE 2

This way, every SQL code-block within Model 1 automatically gets tangled into the right file, and the YAML (which is used for test specification in dbt) goes to its own file. I can write as much as I want around a code block, and it will also be ignored during the tangle. But, if I want a specific piece of text to be inserted as a comment in the output file (which I might want to do, since the output is going into version control and no one but me will ever see the 'master file'), I can do that by adding :comments org to the header of the code-block.

OK, so literate programming is solved. Let's look at the bonus issue next since that's still more in the realm of literate programming as a whole. One benefit of this setup is that I can write my YAML tests directly next to the actual SQL source code. For example:

#+begin_src sql
  select something from somewhere
#+end_src

:testing:
This goes to the yaml.
#+begin_src yaml
  - name: some_column
    data_Type: INTEGER
    tests:
      - not_null
#+end_src
:end:

This of course requires setting up the boilerplate for the YAML file, which I do in a separate code-block before the first CTE section. I also use this preface to specify the dbt materialization and table alias, as well as add a general comment as to the purpose of the model.

If you're familiar with YAML, you will know that indentation is used to determine scope, and tangling org files tends to mess up the whitespace rules. The solution here is to set the org-src-preserve-indentation variable to t - but we want this to be on a per-file basis. And we have some other Elisp that we want to run, so that we can fix the second issue of code style. I have an Elisp code block that looks like this at the start of the org file:

#+name: startup
#+begin_src elisp :results silent
  (setq org-src-preserve-identation t)

  (defun sql-format ()
    "Run sqlfluff on the current file."
    (call-process-shell-command (concat "sqlfluff fix --dialect snowflake" buffer-file-name)
                            nil
                            nil))

  (add-hook 'org-babel-post-tangle-hook (lambda () (when (string-match-p ".sql\\" (buffer-file-name))
                                                   (beginning-of-buffer)
                                                   (flush-lines "-- :end:")
                                           (flush-lines "^$")
                                           (save-buffer)
                                           (sql-format))))
#+end_src

The sql-format function just runs sqlfluff over the file of the current buffer, our team is using Snowflake so that's the dialect I've selected. I want a hook to run this function on the output whenever I tangle an SQL file, so that's what the add-hook block is doing. The reason for the two flush-lines calls is to get rid of any :end: comments (which come up when I want a comment after a :testing: section) and to remove any empty lines (since sqlfluff will handle padding on it's own). This means that I can write the SQL however I like, and then not care about formatting the output. In fact, until I send the PR for review, I never even have to read the actual output of the master file. I can just work in it the whole time.

We can run this code-block from within org-mode with C-c C-c, but it's a bit of a chore to do this each time I enter the file. There is a better way: with local variables I can execute this code-block when I enter the file. This is also the reason for #+name: startup at the top:

# Local Variables:
# org-confirm-babel-evaluate: nil
# eval: (progn (org-babel-goto-named-src-block "startup") (org-babel-execute-src-block))
# End:

Chuck this at the end of the org file, and now every time you open it that startup block will run.

That's basically it. There's a few caveats: obviously, once this gets merged into the version control then any changes won't synchronise with the org file. This could be fixed with link comments and org-babel-detangle, but that goes against the making sure no one else in the team ever needs to interact with org. This workflow is supposed to be for myself only, and not interrupt anyone else in their reading or writing of the code. This does mean that once it starts going through review, and especially once any code is actually merged, the master file is essentially useless as it won't stay up to date. But that's OK, because usually any changes that are made after merge are minor, and I can still keep the org file updated with any information that shouldn't be a file comment. Or, I can export the whole thing as a word document to describe the implementation in plain English to the reviewer. Not sure if that will ever come up, but it's nice to have the option.

I won't embarrass myself with a comparison of my LanguageTool config. Just know that it was slow and terrible. Copied from the Harper docs, this is what my config looks like:

(when (and (not (equal system-type 'windows-nt)) (locate-file "harper-ls" exec-path))
  (with-eval-after-load 'eglot
    (add-to-list 'eglot-server-programs
               '(org-mode . ("harper-ls" "--stdio"))))

  (setq-default eglot-workspace-configuration
              '(:harper-ls (:dialect "Australian")))

  (add-hook 'org-mode-hook 'eglot-ensure))

Some caveats: it doesn't look like Harper has support for org-mode specifically yet, but it seems to generally work OK despite that. I have however noticed that it doesn't lint property tags, so for example your #+title: won't be spellchecked. Another minorly annoying little niggle is that straight seems to misbehave with eglot, or eldoc more specifically, printing eldoc error: (invalid-function incf) in the minibuffer instead of an actual error message. I was using lsp-mode before this - although I'm beginning to like the eglot interface more and more as I write this, so I think I may swap over to it where possible - so I never realised this issue. Per that GitHub issue link, (use-package eldoc :straight (:type built-in)) seems to be the solution.

The only thing that's missing, and to be fair LanguageTool doesn't implement this either (in fact to my knowledge nothing implements this, I don't even think there's a Word plugin), is text style metrics analysis. Every so often I get the impulse to try to untangle what the source code for that website is doing, and then write a simple elisp wrapper for it, but I always get sidetracked before I start. Maybe now is the time.

(if (file-exists-p "/usr/bin/hunspell")
    (progn
      (eval-after-load "ispell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))
      (eval-after-load "flyspell"
        '(progn
         (setq ispell-program-name "hunspell"
               ispell-dictionary   "en_AU"
               ispell-alternate-dictionary (file-truename (concat user-emacs-directory "en_AU.dict"))
               ispell-local-dictionary-alist '(("en_AU" "[[:alpha:]]" "[^[:alpha:]]" "[']" nil ("-d" "en_AU,en_AU-med") nil utf-8)))
         (defun ispell-get-coding-system () 'utf-8)))))

I generally follow a Workspace -> Project hierarchy. For example, here's a small snippet of my Treemacs persist file, with two workspaces and some varying projects underneath them.

* Website
** cyan.sh
 - path :: ~/.../cyan.sh
* Extending Emacs
** dotfiles
- path :: ~/.emacs.d
** ouroboros themes
- path :: ~/..../ouroboros-emacs-themes

One thing that I wanted for a while was the ability to show workspaces in Dashboard, because I usually want to go back to my most recent workspace when launching a new client instance. Same reason that people want thier projectile projects to show up. Unfortunately, Dashboard doesn't have any such integration already, so I had to hack some together. If I was smarter, I would do this in a way that's more portable. Currently it requires both Dashboard and Treemacs to be installed via Straight, as per the first two lines.

(load-file (concat user-emacs-directory "straight/build/dashboard/dashboard-widgets.el"))
(load-file (concat user-emacs-directory "straight/build/treemacs/treemacs-workspaces.el"))


(add-to-list 'dashboard-item-generators
           '(workspaces . dashboard-insert-workspaces)
           t)

(add-to-list 'dashboard-item-shortcuts
           '(workspaces . "w")
           t)

(defun dashboard-insert-workspaces (list-size)
  "Add the list of LIST-SIZE items of treemacs workspaces."
  (dashboard-insert-section
   "Workspaces:"
   (dashboard-subseq (mapcar (lambda (x) (cl-struct-slot-value 'treemacs-workspace 'name x)) treemacs--workspaces) list-size)
   list-size
   'workspaces
   (dashboard-get-shortcut 'workspaces)
   `(lambda (&rest _) (treemacs-do-switch-workspace ,el))
   (let* ((workspace-name el))
     workspace-name)))