I took over as maintainer with the goal of modernizing the protocol support.

Now, jabber.el is the most XEP-complete text-based client in existence.

What Changed

For those, like me, who count XEPs like Pokemon:

• OMEMO encryption (XEP-0384) via a C dynamic module wrapping picomemo
• OMEMO media sharing (XEP-0454)
• OpenPGP for XMPP (XEP-0373) using Emacs’ built-in EPG
• Stream Management (XEP-0198) with session resume
• Message Archive Management (XEP-0313)
• Message Carbons (XEP-0280)
• Delivery Receipts (XEP-0184) and Chat Markers (XEP-0333)
• Message Correction (XEP-0308), Replies (XEP-0461), Moderation (XEP-0424/0425)
• Chat State Notifications (XEP-0085)
• Client State Indication (XEP-0352)
• Blocking Command (XEP-0191)
• HTTP File Upload (XEP-0363)
• Direct TLS (XEP-0368) with dual SRV lookup
• Real Time Text (XEP-0301)
• PubSub (XEP-0060)
• Bookmarks (XEP-0402 with XEP-0048 fallback)
• SQLite message storage replacing flat-file history
• MUC Self-Ping (XEP-0410)

Almost caught them all

No other text-based XMPP client has this level of protocol coverage. jabber.el now rivals Dino and Gajim, the major graphical clients.

OMEMO

OMEMO requires a Signal Protocol implementation. That means C.

jabber-omemo-core.c is 763 lines wrapping picomemo through Emacs' dynamic module API. The Elisp layer handles XMPP integration: PubSub bundle publishing, stanza encryption, session persistence in SQLite, and trust management.

It also provides AES-256-GCM for OMEMO media sharing (XEP-0454).

Why Emacs

Emacs is not just the editor I write jabber.el in. It is the runtime, the test harness, and the application.

I develop in the same instance where I chat. Fix a bug, eval changes, and the fix is live in my running session. Seconds, not minutes.

Emacs provides most of what a chat client needs out of the box: SQLite for storage, GnuTLS for encryption, EPG for OpenPGP, EWOC for list display, Transient for menus.

Distribution is through NonGNU ELPA, which handles everything.

jabber.el is just an M-x package-install RET jabber RET away from install.

Why XMPP

XMPP is the only federated, open-standard messaging protocol that works in practice. I use it for all my daily communication. My friends are on WhatsApp, Discord and IRC – gateways bridge these networks transparently.

One client, one interface, every chat network I need.

More on the gateway setup I use in a future post.

What’s Next

• XEP-0444 Message Reactions
• OMEMO 0.8+ (picomemo supports both; the C layer is ready)
• Roster rework – flat, query-based contact list sorted by activity

The entire Anki ecosystem, thousands of community-maintained decks across every subject, is accessible from Emacs. I can finally keep track of the AnKing deck changes.

If you can’t beat them, import them.

Anki import

gnosis-anki-import reads .apkg files and converts them into gnosis themata. It resolves Anki’s note type templates to extract question/answer pairs, normalizes tags, and strips Anki system tags like marked and leech.

Re-importing the same deck is safe. Each imported note keeps its Anki GUID, so gnosis detects duplicates and skips them. When AnKing pushes an update, I just re-import and only the new notes come in.

Tens of thousands of notes & themata, managed from a text editor. As it should be.

One package, one database

org-gnosis was merged into gnosis. Maintaining two packages with two databases for what is fundamentally one system was, in retrospect, an act of bureaucratic self-harm. Nodes, journal, and themata now share a single gnosis.db. The migration imports existing org-gnosis data automatically.

Export and import

The old org-file export format is gone. Exports are now .gnosis SQLite databases. Importing shows a diff buffer with NEW and CHANGED entries before applying, so you see exactly what will change before committing.

Combined with GUID tracking, this makes gnosis collections maintainable over time rather than one-shot imports. Share a deck with a friend, they modify it, you re-import. No data lost, no duplicates.

Other

• Decks were removed. They were a restriction, not a feature. Existing deck names were converted into tags.
• N+1 queries eliminated throughout the codebase.
• Dashboard rendering is 3-4x faster via a custom gnosis-tl module.
• Review dates stored as integers; due/overdue queries run in SQL.
• Git operations are fully async.
• Saving .org.gpg files no longer triggers redundant decryption.
• Post-failure interval capped at 7 days.
• Interval fuzz prevents review clustering.
• Tag bulk operations: rename, regex rename, merge case duplicates.
• Dropped emacsql for built-in sqlite.

Using decks for themata (flashcards/questions)

Decks will be removed.

Similarly to Anki, decks provided a restriction, not a feature. A thema can only belong to one deck, many-to-one, while tags are many-to-many.

Themata in gnosis are already organized based on tags and you can customize the review algorithm per tag using gnosis-algorithm-custom-values.

Exports for “collections” will now be based on tags. I plan to add tag filters for exports, e.g +anatomy -clinical to export all themata tagged with anatomy, excluding clinical.

Separating gnosis from org-gnosis and org-gnosis-ui

org-gnosis will be merged into gnosis, using a single unified database.

The idea was to have a minimal note taking system with a separate ui package that uses the browser, recreating the workflow I had with org-roam but with support for linking themata to nodes for topic-specific reviews.

In hindsight, this separation was a design mistake:

• Using org-gnosis without gnosis has no real benefits.
• A separate org-gnosis-ui that recreates an obsidian-style graph in the browser provides no real benefit beyond “visualizing” the collection.
  • Using tabulated-list in emacs to display nodes, their backlinks/links and their linked themata provides actual workflow usage. You can start reviews for specific nodes from the dashboard, filter for contents and view relations, all within emacs.
• Maintaining two separate databases for no real value.

Review by topic algorithm

Gnosis supports reviewing all themata linked to a specific node, which means themata are often reviewed before they are due. The interval calculation now uses elapsed time as the basis, but on success keeps the later of the computed/existing scheduled date. The thema’s score and review streak are still updated, so early reviews contribute to progression without distorting the schedule.

This ensures that early successful reviews cannot inflate or deflate intervals. On failure the computed interval is used directly since early failure is genuinely informative.

[New Feature] Exporting themata with their linked nodes

Gnosis exports will optionally include all the linked nodes for the exported themata. This means that current collections, like Unking, will provide ready-to-use collections where users can both review themata and browse the related material.

Finally this project is now evolving into the “all-in-one” knowledge system I’ve envisioned. This version allows for viewing of linked nodes of org-gnosis and their linked themata in a tabulated-list via the gnosis-dashboard with excellent performance.

No more external browsers needed to view my collection. This means the org-gnosis-ui project should be considered deprecated. All functionalities can now be performed within Emacs.

Additionally, I’ve published a gnosis-deck specifically designed for fellow medical students, called Unking, based on the last free version of the Anking deck, Anking V11. This deck is quite comprehensive, featuring over 40,000 themata.

As Gnosis already fulfills my original intentions and beyond, further development will primarily be focused on bug fixes and general maintenance rather than new major features. My priority will now shift towards using the system for my exams rather than continuing active development.

It has been really fun and rewarding working on this project. My goal for learning to program has been to make a knowledge system and to not rely on any 3rd parties for my studying.

Which I’ve finally achieved:) This wouldn’t be possible without all the work that many of you have put into the Emacs ecosystem, so I just want to I extend my heartfelt gratitude to all of you, thank you!

New features

• Auto input-method detection: gnosis detects the script of the expected answer (Greek, Cyrillic, etc.) and activates the appropriate input method during review. Configured via gnosis-script-input-method-alist.
• Change thema type and deck via gnosis-update-thema.
• Dashboard bulk-link action for currently displayed themata.
• Dashboard header-line with entry count and context.
• Asynchronous deck import with gnosis-import-deck-async.
• Demo deck included in decks/demo.org.

Performance

• New gnosis-tl module replaces tabulated-list-print for dashboard rendering (3-4x faster).
• Progressive async rendering for large dashboards.
• Batch-fetch review data instead of per-thema queries.

Bug fixes

• Fix anagnosis event calculation in the algorithm.
• Fix cloze tag removal for edge cases and mc-cloze type.
• Fix vc-pull to run migrations after pull.

New features

• Review topic from dashboard nodes view (r), with configurable forward-link and backlink depth (R or C-u r).
• gnosis-review-topic accepts separate forward/backlink depth to include themata from related nodes.
• gnosis-save-hook runs after saving a thema, called with the thema ID.
• Link integrity detection and repair commands (gnosis-links-check, gnosis-links-sync).
• Dashboard maintenance menu for syncing/rebuilding nodes and link health checks.
• Dashboard shows themata with orphaned links.
• View due org-gnosis nodes linked to themata from dashboard.
• Bulk replace string in keimenon with org-gnosis node link.
• Custom gnosis-center-content-during-review option.
• Delete action available during review.
• Format org-gnosis links in keimenon during review output.
• Export deck option to include or exclude suspended themata.
• Exported decks include a #+THEMATA: header with thema count.
• Importing into an existing deck prompts for confirmation.
• Failed thema imports report the source file line number.

Dashboard

• Added nodes dashboard, view org-gnosis nodes information including backlinks and linked themata as well as start a review session.
• Suspend column displays Yes No instead of 1 0.
• Flatten Actions submenu into the home menu.
• Separate Import/Export into its own menu column.
• Four-column layout: Navigate, Actions, Import/Export, Maintenance.

Algorithm

• Cap gnosis-synolon at gnosis-algorithm-synolon-max (default 3.0), floor at 1.3.
• Add interval fuzz to prevent review clustering.
• Fix lethe event: properly reduce gnosis-plus on consecutive failures.

Performance

• Dashboard suspend, delete, and edit update only the affected entry instead of refreshing the entire buffer.
• Dashboard nodes view uses bulk queries for link counts (2 queries instead of 2N).
• Deck export uses 2 bulk queries instead of 2 per thema (N+1 eliminated).
• Deck export uses plain text insertion instead of per-thema buffer scans (O(n^2) eliminated).
• Deck import wraps all operations in a single transaction with pre-cached IDs (10K fsyncs reduced to 1).
• Review updates use a single DB query.
• Tag output uses a single DB call.
• Average daily reviews computed with a single DB call.

Bug fixes

• Fix gnosis-monkeytype hook leak (now buffer-local).
• Fix vc-pull to reopen database properly after successful pull.
• Pre-load emacsql-sqlite-builtin to fix cl-generic dispatch crash on Emacs 29+.

Documentation

• Update Introduction to describe the intended workflow with org-gnosis (write notes, create themata, link, review).
• Document the two separate databases (gnosis and org-gnosis).
• Update dashboard section for new menu layout.
• Add Import & Export section with export options and import behavior.

Important Changes

Database Changes

• Database version bumped to 3, tracking mtime and hash for both nodes and journal files.
• Automatic database migration prompts when schema is outdated.
• Lazy database initialization - database connections are created only when needed, improving startup time.
• Added org-gnosis-database-file custom variable to specify custom database file location.

Performance Improvements

• Major performance improvements for org-gnosis-db-sync with GC optimization during sync.
• Two-tier incremental sync: fast mtime check, then accurate hash comparison.
  • Only processes files where both modification time and content have changed.
  • Dramatically improves performance for .gpg encrypted files and large repositories.
• Both node files and journal files now use incremental sync with progress reporting showing changed/total file counts.
• To force full resync, call org-gnosis-db-sync with prefix arg C-u. e.g C-u M-x org-gnosis-db-sync RET.

Journaling

• By default, today’s journal entries are created in org-gnosis-journal-file as level 1 headings.
  • When set to nil, creates separate files for each date entry.
  • Creating new entries (e.g., via org-gnosis-journal-find for an event, non-date) creates separate files in org-gnosis-journal-dir regardless of this setting.
  • Single journal file is only used for today’s date entries.
• Added org-gnosis-journal-as-gpg that when non-nil journal files will be created as gpg encrypted files.
• Journal todos now only retrieve checkboxes from today’s heading when using a single journal file, improving performance.

Tag Management

• Automatic cleanup of orphaned tags (tags with no associated nodes) when updating files.
• Improved tag-based node selection with dedicated functions.

Improvements

• Simplified parsing algorithm for better performance and maintainability.
• Better handling of topic titles - only includes parent headings when they have IDs.
• Added org-gnosis-get-nodes-data for retrieving node information with backlink counts.
• Improved test coverage for parsing, title processing, and journal todos.

Contributing to Git Projects with Magit: PRs, Patches & Agit workflow

Quick video guide on contributing to git projects using Magit. Showing an overview of the 3 most commonly used workflows

• Pull Requests

• Agit Workflow

• Git patches

  Video notes:

Introduction

I’m creating this as a tutorial video on how to contribute to bebliotheca, a digital recreation of the Library of Constantinople to host texts that would have been found there during the Greco-Roman Empire.

The steps demonstrated here are applicable to any project.

This is a video guide on contributing to git projects, using Emacs and Magit (the magical Git client). Magit provides the best experience out of the box for a text based interface to git, which makes magit an emacs’ killer feature.

In this video we will start from an example Emacs configuration, adding a theme and installing Magit. Afterwards we will see how to contribute to git projects in 3 ways:

• Pull Requests
• Agit Workflow Pull Requests
  • Supported in forgejo instances, such as codeberg
• Git Patches

I personally use vc, a built-in module. But that’s because I enjoy tinkering and writing my own scripts for it. Magit does by default a lot more that even my ~300 line vc config can do.

Requirements

You will need the following software installed:

• git
• GNU Emacs (version >=29.2)

Additionally, ensure you have a pair of SSH keys already generated and set up for your forge.

Emacs Configuration I will be using

Example init.el file that I will be using:

• Defaults locations for init.el, depending on your system:
  • GNU/Linux: ~/.emacs.d/init.el
  • Windows: C:\Users\<YourUsername>\.emacs.d\init.el

;; Init packages
(package-initialize)

;;;; Do not install keycast as well, I'm only using it to share my
;;;; keystrokes for the video.
;; (use-package keycast
;;  :ensure t)



;; Set and load custom.el
(setf custom-file (locate-user-emacs-file "custom.el"))
(load custom-file 'noerror)

;; Completions
(fido-vertical-mode 1)
(electric-pair-mode 1)

;;; Theming ;;;

(column-number-mode)
(global-display-line-numbers-mode 1)
(tool-bar-mode -1)
(tooltip-mode -1)
(menu-bar-mode -1)
(blink-cursor-mode -1)
(scroll-bar-mode -1)
(set-fringe-mode -1)

;; Add transparency
(add-to-list 'default-frame-alist '(alpha-background . 85))

;; ef-themes package provides a great theme collection, made by Protesilaos.
(use-package ef-themes
  :ensure t)

(defun thanos/load-theme (&optional theme)
  "Disable current theme and load a new THEME.
Emacs can load multiple themes at once.  With this function we make sure we only load one at a time"
  (interactive)
  (let ((theme (or theme (intern (completing-read "Theme: " (custom-available-themes))))))
    (disable-theme (car custom-enabled-themes))
    (load-theme theme t)))

(thanos/load-theme 'ef-dark)


(use-package magit
  :bind ("C-x g" . magit)
  ;; Hook flyspell for autocorrect during commit messages.
  :hook (git-commit-mode . flyspell-mode))

;; Agitjo extends Magit with a new menu for AGit-Flow operations.
(use-package agitjo
  :vc (:url "https://codeberg.org/halvin/agitjo")
  :ensure t)

Pull Requests

• Require an account creation for the forge the project is hosted at. e.g Github or Codeberg.
• Steps to submit a PR
  • Fork repository, through a Web UI.
  • Clone your fork
  • Commit changes, often in a new branch.
  • Push your changes to your fork
  • Submit a Pull Request, through a Web UI.

If you’d rather not use a Web UI, but have to use Pull Requests, consider using forge.

Agit workflow

Note that the agit workflow is not supported by GitHub at the time of making this video. To use agit workflow, you will need to utilize a forgejo instance such as Codeberg.

• Clone repo, using ssh
• Commit changes
• Push
  • From the Magit status buffer, press #
  • Specify a title using -t
    • You can use the same title to push changes to the PR.

Git patches

• Clone repo.
• Commit changes.
• Format patches.

$ git format-patch -{NUM} # where NUM the number of commits.

• Send patches as attachments via email, by pressing C-x C-m.

Notmuch has been incredibly useful for me over the past year, and I hope this guide helps new users overcome initial challenges.

Video notes:

Summary

• Emacs email workflow demo using notmuch.el.
  • Sending mails from multiple addresses, using smtpmail.
  • Auto encrypt emails, if a pgp key is available, using mml-sec.

Why notmuch

• Builtin Emacs support, with notmuch.el.
  • Packages such as ol-notmuch bring integration with the rest of the Emacs ecosystem.
• Notmuch is a tag based system. You do not rely on your email provider for filter rules etc to organize your emails into separate mailboxes.
  • Which is inefficient to begin with when working with thousands++ of emails.
  • This also makes moving to a new email provider easier.
• Locally storing mail.
• Great performance for filtering and searching through hundred of thousand mails.

Assumptions that I make for this video

You have a working Emacs configuration

Your mail providers has support for retrieving and sending mail via 3rd party apps

• You already know how to setup isync/mbsync to retrieve emails from remote server.
• Your mail provider offers smtp credentials to use third party applications.
  • I personally recommend trying out purelymail.com only costs 10$/year and offers good service.

Example isyncrc configuration ~/.config/isyncrc

IMAPAccount gmail
Host imap.gmail.com
Port 993
User user@gmail.com # Change this to your username.
PassCmd "pass gmail/account" # Change this to a command that returns your password.
TLSType IMAPS
TLSVersions +1.2
CertificateFile /etc/ssl/certs/ca-certificates.crt

IMAPStore gmail-remote
Account gmail

MaildirStore gmail-local
Path ~/Mail/gmail/
Inbox ~/Mail/gmail/Inbox
Trash ~/Mail/gmail/Trash
SubFolders Verbatim

Channel gmail
Far :gmail-remote:
Near :gmail-local:
Patterns *
Expunge None
CopyArrivalDate yes
Sync All
Create Both
SyncState *

After adjusting the above configuration, run mbsync -a to sync your remote mailbox locally.

Setting up a notmuch

First time installation

• After installing notmuch for the first time, run notmuch setup for an interactive setup.

Create ~/.scripts/notmuch-hook.sh

• Bash script which will filter/tag your mail

Example:

#!/bin/sh
notmuch new
# Add +inbox tag to a specific alias/address
notmuch tag +inbox -- to:main@address.org

#Sent messages, change this to your mail addresses
notmuch tag -unread -new -inbox +sent -- from:*@mydomain.org or from:*@mydomain.com or from:user@gmail.com

# Example for Emacs-devel
notmuch tag +emacs-devel -new -inbox -- from:emacs-devel@gnu.org or to:emacs-devel@gnu.org

# Example for Github
notmuch tag +github -- from:*github.com

# Filter based on other tags, such as drafts
notmuch tag -inbox -sent -inbox -- tag:draft

Emacs configuration

Notmuch

(use-package notmuch
  :config
  (defun thanos/notmuch-update--command (new-buffer)
    (let ((default-directory "~/.scripts/")) ;; Directory where notmuch script is located.
      (async-shell-command "mbsync -a; ./notmuch-hook.sh" new-buffer)))

  (defun thanos/notmuch-update ()
    (interactive)
    (let* ((buffer (generate-new-buffer "*notmuch update*"))
           (height (max 5 (truncate (* (frame-height) 0.1))))
           (window (split-window-vertically (- height))))
      (with-selected-window window
        (switch-to-buffer buffer)
        (let ((proc (thanos/notmuch-update--command buffer)))
          (set-process-sentinel
           (get-buffer-process buffer)
           (lambda (process event)
             (when (memq (process-status process) '(exit signal))
               (delete-window (get-buffer-window (process-buffer process)))
               (kill-buffer (process-buffer process)))))))))

  (defun thanos/notmuch-search ()
    "Custom notmuch-search wrapper, that makes sure we have newest mail first."
    (interactive)
    (let ((query (notmuch-read-query "Notmuch search: ")))
      (notmuch-search query nil)))

  ;; Configure saved searches to your liking, here's an example:
  (setf notmuch-saved-searches
        `((:name "Week's Inbox" :query "tag:inbox date:7d..today" :sort-order newest-first
                 :key ,(kbd "i"))
          (:name "Inbox" :query "tag:inbox" :sort-order newest-first :key ,(kbd "I"))
          (:name "Unread" :query "tag:unread" :sort-order newest-first :key ,(kbd "u"))
          (:name "Today's message" :query "tag:inbox date:today"
                 :sort-order newest-first :key ,(kbd "t"))
          (:name "sent" :query "tag:sent" :sort-order newest-first :key ,(kbd "s"))
          (:name "drafts" :query "tag:draft" :sort-order newest-first :key ,(kbd "d"))
          (:name "all mail" :query "*" :sort-order oldest-first :key ,(kbd "a"))))
  ;; Tag format configuration
  (setf notmuch-tag-formats
        '(("unread" (propertize tag 'face 'notmuch-tag-unread))))
  :bind (("C-x m" . notmuch-hello)
         :map notmuch-hello-mode-map
         ("u" . notmuch-hello-update)
         ("U" . thanos/notmuch-update)
         ("s" . thanos/notmuch-search)
         :map notmuch-search-mode-map
         ("u" . notmuch-refresh-all-buffers)))

smtpmail

• This configuration is used to send email from multiple addresses, make sure you have your authentication password saved in ~/.authinfo.gpg which emacs is going to use by default.

(use-package smtpmail
  :config
  ;; Default credentials
  (setf smtpmail-smtp-user (auth-source-pass-get "user" "gmail/user") ;; This is not your password, just the username.  Emacs will search for your pw in ~/.authinfo.gpg.
        smtpmail-smtp-server "smtp.gmail.com"
        smtpmail-smtp-service 465 ;; Adjust this to your mail provider port if needed
        smtpmail-stream-type 'ssl
        message-send-mail-function 'smtpmail-send-it
        message-signature "My signature")

  (defun thanos/mail-config-hook ()
    (let ((from (mail-fetch-field "From"))
          (public "<public@thanosapollo.org>")
          (gmail "<104111@students.mu-sofia.bg>"))
      (cond ((string-match public from)
             (setf smtpmail-smtp-user (auth-source-pass-get "user" "purelymail/thanosapollo")
                   smtpmail-smtp-server "smtp.purelymail.com"))
            ((string-match gmail from)
             (setf smtpmail-smtp-user "104111@students.mu-sofia.bg"
                   smtpmail-smtp-server "smtp.gmail.com")))))
  ;; You can use :hook instead, but I prefer add-hook under :config personally.
  (add-hook 'message-send-hook #'thanos/mail-config-hook))

mml-sec

(use-package mml-sec
  :config
  (defun gpg-list-emails-available ()
  "Return a list of trusted emails.
Parses output of `gpg --list-keys --with-colons' command into a
list of emails."
  (let* ((command "gpg --list-keys --with-colons")
         (output (shell-command-to-string command))
         (lines (split-string output "\n" t))
         (emails '()))
    (dolist (line lines)
      (when (string-prefix-p "uid:" line)
        (when (string-match "<\\([^>]+\\)>" line)
          (let ((email (downcase (string-trim (match-string 1 line)))))
            (push email emails)))))
    (delete-dups emails)))

  (defun thanos/mail-list-recipients-from-buffer ()
    "Get the list of recipients from the current email buffer."
    (save-excursion
      (goto-char (point-min))
      (let ((to (or (mail-fetch-field "To") ""))
            (cc (or (mail-fetch-field "Cc") ""))
            (bcc (or (mail-fetch-field "Bcc") ""))
            recipients)
        (setq recipients (concat to ", " cc ", " bcc))
        ;; Remove empty strings from the result
        (delq nil
              (mapcar (lambda (addr)
                        (let ((clean-addr (string-trim addr)))
                          (when (not (string-empty-p clean-addr))
                            (downcase
                             (if (string-match "<\\([^>]+\\)>" clean-addr)
                                 (string-trim (match-string 1 clean-addr))
                               clean-addr)))))
                      (split-string recipients "," t))))))

  (defun thanos/mail-sign-encrypt ()
    "Auto-encrypt if all recipients have keys, else just sign."
    (let ((trusted-emails (gpg-list-emails-available))
          (recipients (thanos/mail-list-recipients-from-buffer)))
      (if (cl-every (lambda (r) (member r trusted-emails)) recipients)
          (progn
            (message "Encrypting message.")
            (mml-secure-message-sign-encrypt))
        (progn
          (message "Just signing message.")
          (mml-secure-message-sign)))))

  (add-hook 'message-send-hook #'thanos/mail-sign-encrypt)
  :custom
  (mml-secure-openpgp-signers '("62B758D0F6719938BC09CECA339F736C3A720928"))) ;; Change this to your own key!

Not anymore :)

TLDR: I switched from a thinkpad x220 to a Raspberry Pi 5, which I use to access my desktop remotely.

Raspberry Pi 5 with 3d printed custom VESA mount on Raspberry Pi Monitor

Project Goals

My aim with this “project” is to have a small, portable, and modular device that I can simply toss in my bag and not worry about it’s battery life throughout the day.

The extra thing that I want, is to prove that you do not need to “sell your kidney” and bow down to a corporation for the ‘privilege’ to use their hardware designed for obsolescence or their bloated software.

Hardware I’m using:

• Things I’ve purchased:

  • Raspberry Pi 5 8GB
  • Raspberry Pi Monitor

• Things I’ve already had:

  • 27000 mAh power bank
  • Keyboard

I bought a Raspberry Pi 5 kit that came with a case fan for 100€. The total cost for this project was 195€, for the Pi and the monitor.

Battery Life

I’m usually out of home for over 7 hours a day for my studies, and I enjoy studying in cafes and libraries. I’ve missed having a device with a battery life of 10+ hours, as my x220 barely lasts more than 4.5 hours.

Using a 27000mAh power bank, I get ~15 hours of battery life. I also carry an extra “emergency” power bank.

With great power (and battery life) comes great productivity

The monitor consumes more energy than my Pi.

Modularity

I strongly dislike laptop keyboards and I insist on using ones with a trackpoint. I’m currently using a shinobi keyboard, which I can simply plug into my Raspberry Pi and use just like on my desktop.

If I do not like something about my Pi setup, it’d be trivial to change, such using a new monitor, a new keyboard or another power bank.

Performance & File Synchronization

Can the Pi outperform a modern laptop of >1000€ price range? Yes and No :)

Now, you might be wondering; how can my Pi deliver better performance than, say, a MacBook Air? A valid question, but as a GNU+Linux user, I’ve come to embrace the possibilities. Anything’s possible with a bit of hackery and FOSS magic.

I use waypipe, a Wayland proxy, to run Emacs remotely over a network. Emacs runs on my desktop, but I access it from my Pi, great performance while seamlessly accessing all my desktop files, such as my notes and PDFs, this also removes any need for syncing files between devices.

I have fiber connection, so there isn’t any latency issues between my devices using a wireguard VPN.

Accessing my desktop Emacs session remotely, opening a PDF and eshell.

Conclusion

I will be using this setup for the rest of the academic year. I might record a more detailed video with tips and tricks for others that want to try something similar.

So far this has been more than an ideal setup for me, since I quite often forget to sync my notes and projects between devices. Not having to worry anymore about the battery life of my device is quite relaxing as well.

Here’s a simple code snippet to launch an emacs temp frame for input instead.

(defun thanos/wtype-text (text)
  "Process TEXT for wtype, handling newlines properly."
  (let* ((has-final-newline (string-match-p "\n$" text))
         (lines (split-string text "\n"))
         (last-idx (1- (length lines))))
    (string-join
     (cl-loop for line in lines
              for i from 0
              collect (cond
                       ;; Last line without final newline
                       ((and (= i last-idx) (not has-final-newline))
                        (format "wtype -s 350 \"%s\""
                                (replace-regexp-in-string "\"" "\\\\\"" line)))
                       ;; Any other line
                       (t
                        (format "wtype -s 350 \"%s\" && wtype -k Return"
                                (replace-regexp-in-string "\"" "\\\\\"" line)))))
     " && ")))

(defun thanos/type ()
  "Launch a temporary frame with a clean buffer for typing."
  (interactive)
  (let ((frame (make-frame '((name . "emacs-float")
                             (fullscreen . 0)
                             (undecorated . t)
                             (width . 70)
                             (height . 20))))
        (buf (get-buffer-create "emacs-float")))
    (select-frame frame)
    (switch-to-buffer buf)
    (erase-buffer)
    (org-mode)
    (setq-local header-line-format
                (format " %s to insert text or %s to cancel."
                        (propertize "C-c C-c" 'face 'help-key-binding)
            (propertize "C-c C-k" 'face 'help-key-binding)))
    (local-set-key (kbd "C-c C-k")
           (lambda () (interactive)
             (kill-new (buffer-string))
             (delete-frame)))
    (local-set-key (kbd "C-c C-c")
           (lambda () (interactive)
             (start-process-shell-command
              "wtype" nil
              (thanos/wtype-text (buffer-string)))
             (delete-frame)))))

Make sure wtype is installed in your system for the above snippet to work.

All you have to do now is just bind emacsclient --eval '(thanos/type)' to a shortcut of your liking.

On my Hyprland setup I’m using the following settings

bind = $mainMod, j, exec, emacsclient --eval '(thanos/type)'
windowrulev2 = float,class:^(emacs)$,title:^(emacs-float)$ # Launch as a floating window.

For xorg users, you can simply rely on the Emacs Everywhere package. Unfortunately it does not support Wayland yet and I have not tried it.

Org Mode Support

After hacking on org-gnosis and gaining a better understanding of how org-mode works, I decided to use org-mode for creating and exporting gnosis notes.

Notes, no matter their note type, will now be as follows:

Cloze type example.

* Thema                      :pharmacology:antimicrobials:penicillin:
:PROPERTIES:
:GNOSIS_ID: NEW
:GNOSIS_TYPE: cloze
:END:
** Keimenon
What is the treatment for Actinomyces infection?

Penicillin

** Hypothesis
- drug type

** Answer
- Penicillin

** Parathema
Sulfonamides → Nocardia
Actinomyces → [[id:680ca944-8ee9-4513-92d6-25696ee01f48][Penicillin]]
(treatment is a SNAP)

Note that anki-like syntax is still supported for clozes.

MCQ example

* Thema                                                            :clinical:
:PROPERTIES:
:GNOSIS_ID: NEW
:GNOSIS_TYPE: mcq
:END:
** Keimenon
A 60-year-old man comes to the physician with chills, nausea, and
diffuse muscle aches for 3 days. His niece had similar symptoms 2
weeks ago and H3N2 influenza strain was isolated from her respiratory
secretions. He received his influenza vaccination 2 months ago. His
temperature is 38.5°C. A rapid influenza test is
positive. Which of the following mechanisms best explains this
patient's infection despite vaccination?

** Hypothesis
- Random point mutations within viral genome
- Complementing with functional viral proteins
- Exchange of viral genes between chromosomes
- Reassortment of viral RNA segments
- Acquisition of viral surface proteins

** Answer
- Random point mutations within viral genome

** Parathema
Random point mutations within the viral genome are responsible for
antigenic drift, which creates a new virus strain.

Each note is a thema consisting of the following components:

• Keimenon; The main text or question.
• Hypothesis; Assumptions/hints for the text to guide to the right answer
  • For example this is used as hints for cloze type or as choices in MCQs
• Answer; The correct response or solution to the keimenon.
• Parathema; expansion of keimenon, that can include links to e.g org-gnosis topics or even files, serving as a way to link org-gnosis topics to current thema.

Optionally, you can use also add tags for each note.

Notes/themas can have multiple hypotheses and answers (depending on their type), separated by gnosis-export-separator, which defaults to "\n-" (a new line followed by a dash).

Support for exporting decks

Support for exporting decks as org files via gnosis-export-deck has been added.

Support for org-gnosis notes

With this update org-gnosis is finally part of gnosis. The goal is not to just have a spaced repetition tool, but an all-in-one learning tool.

With this new update you can do reviews for specific org-gnosis topics.

• Use M-x gnosis-review-topic to select a topic from your org-gnosis notes to review all linked themas.
• You can link a thema to an org-gnosis topic by adding an org id link to either the parathema (recommended) or keimenon, using M-x org-gnosis-insert.

Future versions will further expand on this functionality.

Deprecated support for images

• Image support will be rewritten in the next minor version
  • Support to display file links of images will be added.

Deprecated support for y-or-n notes

With this update your current y-or-n notes will be converted into MCQ type, with “Yes” & “No” choices.

Video notes

Org Gnosis Overview

• Org Gnosis Organization of Gnosis (Knowledge)

• Org Gnosis a a minimal org-mode parsing tool that organizes the data of your notes as atomic nodes in an sqlite database.

  • Org Gnosis provides a roam-like workflow, akin to Roam Research, Logseq and org-roam, with support for journaling.

• In org-gnosis there are 2 types of nodes, gnosis nodes & journal nodes.

Installation & Configuration

• Refer to the project’s website for the latest installation instructions.

(use-package org-gnosis
  :ensure t
  :init
  (define-prefix-command 'thanos/notes-map)
  (define-prefix-command 'thanos/journal-map)
  :config
  ;; I put my databse inside org-gnosis-dir to keep it in sync
  ;; between machines, using git.
  (setf org-gnosis-db (emacsql-sqlite-open
             (expand-file-name "data.db" org-gnosis-dir)))

  (setf org-gnosis-dir "~/Notes"
  org-gnosis-node-templates
  '(("Default" (lambda () "" "#+startup: content\n")))
  org-gnosis-journal-templates
  '(("2050 Plan" journal/plan-2050)
    ("Empty" (lambda () "" "#+startup: content\n")))
  org-gnosis-show-tags t
  org-gnosis-create-as-gpg t
  org-gnosis-completing-read-func #'org-completing-read)

  (defun journal/plan-2050 ()
    "My journaling template for 2050-01-01."
    (let ((days-remaining (- (time-to-days (encode-time 0 0 0 1 1 2050))
               (time-to-days (current-time)))))
      (format
       "\nDays until 2050: *%s* \n\n* Records\n\n* Daily notes\n* Goals\n%s"
       days-remaining (org-gnosis-todos))))

  :bind (("C-c n" . thanos/notes-map)
   ("C-c j" . thanos/journal-map)
   :map thanos/notes-map
         ("f" . org-gnosis-find)
   ("i" . org-gnosis-insert)
   ("t" . org-gnosis-find-by-tag)
   :map thanos/journal-map
   ("j" . org-gnosis-journal)
   ("f" . org-gnosis-journal-find)
   ("i" . org-gnosis-journal-insert)
   :map org-gnosis-mode-map
   ("C-c C-." . org-gnosis-insert-tags)
   ("C-c i" . org-id-get-create)
   ("C-c C-o" . thanos/org-open-at-point)))

EPA (EasyPGP Assistant)

(use-package epa
  :defer t
  :config
  (setf epa-keys-select-method 'minibuffer
  epa-file-encrypt-to '("your-pgp-key")
  ;; Do not prompt for key selection, we are only using the above key.
  epa-file-select-keys 'silent))

Emacs As Your Terminal Emulator [Video]

• Emacs offers an enhanced experience for interacting with shell tools & may be the most extensible terminal emulator available.
• Provides seamless integration between shell tools & editing capabilities.

Using shell commands from within a buffer

shell-command

• M-! CMD <RET>
• Run the shell command CMD and display the output.

async-shell-command

• M-& CMD <RET>
• Run the shell command CMD asynchronously, and display the output

shell-command-on-region

• M-| CMD <RET>
• Run the shell command CMD with region contents as input; optionally replace the region with the output

Emacs as a Terminal Emulator

Shell

• M-x shell
• A subshell with input and output through an Emacs buffer. You can then give commands interactively.

My configuration

(use-package shell
  :config
  (defun thanos/shell (n)
    "Create or switch to a shell buffer."
    (interactive "P")
    (let* ((num (if n (prefix-numeric-value n) nil))
           (buf-name (if num (format "*shell<%d>*" num) "*shell*")))
      (shell buf-name)))
  :bind (("C-c v" . thanos/shell)
         :map shell-mode-map
         ("C-l" . 'comint-clear-buffer))
  :hook ((shell-mode . (lambda () (display-line-numbers-mode -1)))))

Eshell

• M-x eshell
• Shell implemented entirely in Emacs Lisp

My configuration

(use-package eshell
  :config
  ;; Prompt
  (defun eshell-git-info ()
    "Return a string with git info."
    (when (eq (call-process "git" nil nil nil "rev-parse" "--is-inside-work-tree") 0)
      (let* ((branch-raw (shell-command-to-string "git rev-parse --abbrev-ref HEAD"))
             (branch (if (or (string-match-p "^fatal" branch-raw)
                             (string-match-p "^error" branch-raw))
                         "Unknown"
                       (string-trim branch-raw)))
             (dirty (not
                     (string= "" (string-trim (shell-command-to-string "git status --porcelain")))))
             (dirty-info (if dirty " ✎" " ✔")))
        (concat (propertize "⎇ " 'face 'modus-themes-fg-green-warmer)
                (propertize branch 'face 'modus-themes-fg-magenta-warmer)
                (propertize dirty-info 'face
                            (if dirty 'modus-themes-fg-red 'modus-themes-fg-green))))))

  (defun eshell-prompt-multiline ()
    "Eshell Multiline Git prompt."
    (let ((separator (propertize " | " 'face 'font-lock-comment-face))
          (hr (propertize (concat "\n" (make-string (/ (window-total-width) 2) ?─) "\n") 'face 'font-lock-comment-face))
          (dir (propertize (format "%s" (abbreviate-file-name (eshell/pwd))) 'face 'modus-themes-fg-yellow-warmer))
          (git-info (eshell-git-info))
          (time (propertize (format-time-string "%H:%M:%S") 'face 'font-lock-comment-face))
          (sign (if (= (user-uid) 0)
                    (propertize "\n#" 'face 'modus-themes-fg-blue-intense)
                  (propertize "\nλ" 'face 'modus-themes-fg-red-warmer))))
      (concat hr dir separator git-info separator time sign " ")))

  (setf eshell-prompt-function 'eshell-prompt-multiline
        eshell-highlight-prompt nil)
  ;; Aliases
  (defun eshell/o (file)
    "Open FILE."
    (find-file file))

  (defvar thanos/aliases
    '((ll . "ls -lah")
      (clear . clear-scrollback)))

  (defun thanos/set-eshell-aliases (aliases)
    "Set ALIASES as eshell aliases."
    ;; Remove aliases file
    (when (and eshell-aliases-file
               (file-exists-p eshell-aliases-file))
      (delete-file eshell-aliases-file))
    (mapc (lambda (alias)
            (let ((name (symbol-name (car alias)))
                  (command (cdr alias)))
              (eshell/alias name
                            (cond
                             ((stringp command) command)
                             ((symbolp command) (symbol-name command))
                             (t (error "Unsupported alias command type"))))))
          aliases))

  ;; Rebinds
  (defun thanos/eshell-clear ()
    "Interactive call for clear-scrollback."
    (interactive)
    (eshell/clear-scrollback))

  (defun thanos/eshell-preview-insert ()
    (interactive)
    (completion-preview-insert)
    ;; This funciton just deletes the extra space inserted after
    ;; completion.
    (delete-char -1))
  :bind (("C-c e" . eshell)
         :map eshell-mode-map
         ("C-l" . 'thanos/eshell-clear)
         ("<tab>" . 'thanos/eshell-preview-insert)
         ("C-M-i" . 'completion-at-point))
  :hook ((eshell-mode . (lambda ()
                          (thanos/set-eshell-aliases thanos/aliases)
                          (display-line-numbers-mode -1)
                          (eshell-cmpl-mode -1)))))

Eat

Emulate a terminal (Eat)

• xterm-like emulator, written in Emacs Lisp.
• Although it’s a standalone terminal for Emacs, similar to term, I’ve mostly used this package to enhance eshell.

My configuration

(use-package eat
  :ensure t
  :config
  (setf eshell-visual-commands nil
        eat-term-name "xterm-256color")
  :bind (("C-c V" . eat))
  :hook ((eshell-mode . eat-eshell-mode)
         (eshell-mode . eat-eshell-visual-command-mode)
         (eat-mode . (lambda () (visual-line-mode -1)))))

Term & Ansi-Term

• M-x term | M-x ansi-term
  • ansi-term is the same as term, except that it always creates a new buffer and C-x is being marked as an escape-char.
• Runs a subshell with input and output through an Emacs buffer.

How to use

• While in term-mode C-c CHAR is equivalent to C-x CHAR.
  • Example C-c o is the global binding C-x o other-window
• C-c C-j switches to term-line-mode which allows navigation similar to shell
• C-c C-k switches back to term-char-mode

org-gnosis node & my fork of org-roam-ui

Project Name: org-gnosis | Org*anization of *Gnosis

Goals

The goals of org-gnosis are as follows:

• Keep it minimal, only implement parsing & input data to a database.
  • Do not want to exceed 700 lines of code, currently it’s at 490.
• Incorporate nodes as sources for gnosis notes.
  • Having nodes as sources can replace my extras section.
• Make it easily extensible
  • Parsing functionality of org-gnosis should be easily customized to work with other note taking tools.
• Separate journals from note taking

How things are going

The goals above have been achieved, except for the incorporation with my SRS system & it’s customization to parse non org-mode buffers can be kinda tricky. Despite that, it has been a drop-in replacement for my previous org-roam workflow.

I’ve also created a fork of org-roam-ui that I’ve been using to visualize my notes. I will be testing this package and hopefully publishing on either nongnu elpa or melpa soon.

If you are interested, try it out from this repo here. If you find any issues or got any questions feel free to email me.

Emacs 30 Built-in Completion UI & Styles

Video notes:

• When referring to “Emacs Completions”, I refer to Completion Styles & UI
• I’ve often relied on third-party packages to emulate features from other text editors. For instance, I’ve long used vertico, corfu and orderless.
  • While I still recommend these packages, I became curious about using Emacs without depending on third-party options.
  • My current setup tries to emulate my workflow with the packages mentioned above.
• The catalyst that pushed me to try the built-in completion is the addition of completion-preview-mode in Emacs 30.

Mini-buffer completions

• Emacs does not enable “vertical” completions for the mini-buffer by default, but you can enable fido-vertical-mode which comes built-in with Emacs.
  • fido-mode is an enhanced icomplete-mode that emulates ido-mode, also referred to as fake ido-mode.

Completion Styles

• Changing completion-styles example:

(setf completion-styles '(basic flex))

• There is a plethora of completion styles, builtin styles include flex, which provides “fuzzy” completions.

Completion UI & Code completions

• Emacs built-in completions have a distinctive approach.
• Instead of displaying a popup at point, a new Completions buffer appears when invoking completion-at-point.

Example configuration:

(setf completion-styles '(basic flex)
      completion-auto-select t ;; Show completion on first call
      completion-auto-help 'visible ;; Display *Completions* upon first request
      completions-format 'one-column ;; Use only one column
      completions-sort 'historical ;; Order based on minibuffer history
      completions-max-height 20 ;; Limit completions to 15 (completions start at line 5)
      completion-ignore-case t)

Goals of this project

The primary objective is to achieve full compatibility with existing org-roam notes while resolving current database implementation issues. These goals were met successfully on the first day of development.

Given that I plan to use this system for the next several years, performance with large datasets is crucial. I have conducted tests on org-gnosis with a dataset comprising 70,000 nodes, and it has demonstrated flawless performance without any issues. Although, the initialization can take sometime.

Beyond just performance, I want to keep it small and simple, especially in terms of lines of code. The less lines of code I have to maintain the happier I am :)

How to install

This project is only 26 hours old as of now, I have not published it on any ELPA, but you can find it on this git repo, feel free to clone it and try it out.

Example use-package snippet

(use-package org-gnosis
  :load-path "~/Dev/emacs-lisp/org-gnosis"
  :init
  (define-prefix-command 'thanos/notes-map)
  (define-prefix-command 'thanos/journal-map)
  :config
  (setf org-gnosis-dir "~/Notes"
    org-gnosis-show-tags t) ;; Enable this if you use a completion system like vertico
  :bind (("C-c n" . thanos/notes-map)
     ("C-c j" . thanos/journal-map) ;; You can use "C-c n j" if you prefer
     :map thanos/notes-map
         ("f" . org-gnosis-find)
     ("i" . org-gnosis-insert)
     :map thanos/journal-map
     ("j" . org-gnosis-journal)
     ("f" . org-gnosis-journal-find)
     ("i" . org-gnosis-journal-insert)
     :map org-mode-map
     ("C-c i" . org-id-get-create)))

After installing org-gnosis run M-x org-gnosis-db-sync to sync your database, afterwards just use org-gnosis-find similarly to how you’d use org-roam-find-node.

This package is still under development, if you encounter any bugs feel free to email me.

Video notes

What is RSS?

• XML-based web feed that allows users to access updates of websites, without “visiting” the website.
• Hacktivist including Aaron Swartz contributed to the development of RSS

Why use it?

• Having total control over information you consume
  • Filter/Prioritize content from various sources
  • Bypass algorithms
  • Ad-free reading
• Offline Access
• Time saving
• Allows creation of a personalized & decentralized information hub

(+ Emacs RSS) ;; => ’elfeed

No matter what RSS reader you choose, they all get the same job done

• Elfeed is a simple & highly customizable RSS client for Emacs
  • Developed by Christopher Wellons (skeeto)
• It has a well designed database & tagging system

use-package installation example:

(use-package elfeed
  :vc (:url "https://github.com/skeeto/elfeed") ;; vc option is available on Emacs 30
  :config
  (setf elfeed-search-filter "@1-week-ago +unread"
        browse-url-browser-function #'browse-url-default-browser
        elfeed-db-directory (locate-user-emacs-file "elfeed-db"))
  ;; Feeds Example
  (setf elfeed-feeds
        '(("https://hackaday.com/blog/feed/"
           hackaday linux)))

  ;; Play videos from elfeed
  (defun elfeed-mpv (&optional use-generic-p)
    "Play video link with mpv."
    (interactive "P")
    (let ((entries (elfeed-search-selected)))
      (cl-loop for entry in entries
               do (elfeed-untag entry 'unread)
               when (elfeed-entry-link entry)
               do (start-process-shell-command "elfeed-video" nil (format "mpv \"%s\"" it)))
      (mapc #'elfeed-search-update-entry entries)
      (unless (use-region-p) (forward-line))))

  :bind (("C-x f" . elfeed)
         :map elfeed-search-mode-map
         ("v" . 'elfeed-mpv)
         ("U" . 'elfeed-update)))

What to do with websites that do not provide an RSS feed?

• Utilize rss-bridge to generate one.
• RSS Bridge is easy to self host using docker

Example guix service:

(service oci-container-service-type
         (list
          (oci-container-configuration
           (image "rssbridge/rss-bridge")
           (network "host")
           (ports
            '(("3000" . "80"))))))

The video is available on youtube here.

I’d say proper organization of said knowledge, such as with decks for each subject and meaningful tags linking related concepts together across decks, making it easily searchable and accessible.

As I started adding more and more notes into gnosis, I found myself wanting to adjust the review algorithm not only for decks but for tags as well. This led me to overhaul the underlying architecture and reimplement key concepts.

Key Changes Made

• Redesigned gnosis-dashboard with a home-page-like buffer displaying current activity stats such as review streak and today’s due notes.
• Rewritten gnosis algorithm:
  • Added gnosis-score, the current knowledge score for a note.
  • Added epignosis value, that indicates the knowledge accuracy for a given note, as well as agnoia to indicate the lack of knowledge for a note, those values will be used in anagnosis events. The “indication” is the translation of those words from greek.
  • Added special review events; Anagnosis & Lethe
    • Anagnosis refers to the recognition & understanding of a context, anagnosis events are triggered by either consecutive failed or successful recalls. Depending on how it’s triggered, epignosis or agnoia will be applied to gnosis-score
    • Lethe refers to the forgetting of knowledge, it’s triggered by consecutive failures to recall an answer, upon this event the next interval is set to 0
  • Added amnesia, upon failing to recall a note, amnesia value is used to determine the next interval.
  • Added proto, a list that consist of integers, indicating the value for the first intervals. Proto list does not have a limit on length.
• Re-implement the configuration for the above deck values, and added the ability to do the same for tags. Tag configuration takes priority over deck configuration.

Example:

(setq gnosis-custom-values
  '((:deck "demo" (:proto (0 1 3) :anagnosis 3 :epignosis 0.5 :agnoia 0.3 :amnesia 0.5 :lethe 3))
    (:tag "demo-concept" (:proto (1 2) :anagnosis 3 :amnesia 0.7))))

A note under the deck demo tagged with demo-concept will have the demo deck values with the exception of:

• proto value set to (1 2)
• amnesia value set to 0.7

For notes that have multiple tags, the maximum value is retained for most parameters. However, anagnosis and lethe will retain the minimum value.

Next features on the horizon

• Org mode integration
• Deck export & import

Possible Solutions

Emacs needs distributions to shine in this modern digital landscape where everything should “just work” Distros like Doom Emacs can flex the power of Emacs, enticing even those who can’t define it.

Most people start with a text editor and never bother looking for alternatives. Even Lisp learners typically skip Emacs as a starting point. If not them, then who?

An Emacs distribution that just works would draw newcomers or at least be the editor that you can drop on someone to learn programming. Possible also something finely tuned for academics & wordsmiths with org-mode.

Popularity shmopularity!

Popularizing Emacs goes beyond just boosting its own fame; it’s about spreading the gospel of the GNU philosophy & Lisp programming that Emacs embodies.

We’re not just promoting a tool, but a mindset and a way of thinking that challenges the status quo in the world. Embracing Emacs means embracing a hacker ethos of freedom.

About

In this guide I will guide you through setting up mu4e with multiple accounts, using isync & mu, as well as the basics of how to incorporate mu4e into your workflow, plus tips & tricks like using mu4e actions to apply git patches.

To follow this guide, make sure to enable IMAP/SMTP access for your email account. The steps to enable this may vary depending on your specific email provider, so I won’t cover that in this guide.

Why mu4e?

There are multiple options available in GNU Emacs for managing emails, such as rmail, gnus, notmuch, and mu4e.

Each of these options has its own complexities, depending on your specific use case.

In my personal experience, I find mu4e to be preferable due to its ease of setup, particularly when dealing with multiple accounts.

Installing MU & isync

To get started, install mu & isync

• Arch Linux

$ sudo pacman -S mu isync

• Gentoo

$ sudo emerge -av mu isync

NOTE: Make sure you to use emacs USEFLAG for mu

If mu is not packaged for your distro, I recommend changing to a new one. But if you insist, you might have success installing mu from source, using straight.el:

(straight-use-package 'mu4e)

Setting up mbsync

Edit your configuration: ~/.mbsyncrc

Example setup for Fastmail:

IMAPAccount fastmail
Host imap.fastmail.com
Port 993
User myaccount@fastmail.com
PassCmd "emacsclient -e '(password-store-get-field \"fastmail.com/myaccount@fastmail.com\" \"smtp\)'"
SSLType IMAPS
SSLVersions TLSv1.2
CertificateFile /etc/ssl/certs/ca-certificates.crt

IMAPStore fastmail-remote
Account fastmail

MaildirStore fastmail-local
Path ~/Mail/Fastmail/
Inbox ~/Mail/Fastmail/Inbox
Trash ~/Mail/Fastmail/Trash/
SubFolders Verbatim

Channel fastmail
Far :fastmail-remote:
Near :fastmail-local:
Patterns *
Expunge None
CopyArrivalDate yes
Sync All
Create Both
SyncState *

Example setup for Gmail:

IMAPAccount gmail
Host imap.gmail.com
Port 993
User myaccount@gmail.com
PassCmd "pass google/mygmail.com"
SSLType IMAPS
SSLVersions TLSv1.2
CertificateFile /etc/ssl/certs/ca-certificates.crt

IMAPStore gmail-remote
Account gmail

MaildirStore gmail-local
Path ~/Mail/Account-GMAIL/
SubFolders Verbatim

Channel gmail
Far :gmail-remote:
Near :gmail-local:
Patterns * ![Gmail]* "[Gmail]/Sent Mail" "[Gmail]/Starred" "[Gmail]/All Mail" "[Gmail]/Trash"
Expunge None
CopyArrivalDate yes
Sync All
Create Both
SyncState *
Settings you should adjust:

• PassCmd this should output your account password. I personally use pass as my password manager.

In the fastmail example above I get my password with this emacs function:

(password-store-get-field \"fastmail.com/myaccount@fastmail.com\" \"smtp\)

password-store is a pass front-end for Emacs.

NOTE: You can instead of PassCmd, use Pass that just has your password in plain text, but I do not recommend this for security reasons.

• CertificateFile - This location can vary based on your Linux distribution.

• Patterns - Defines which folders will be synced, I personally just define my folders manually, similarly to the fastmail example.

Feel free to define multiple accounts this way.

After configuring isync, start the initial sync by running this command:

$ mbsync -a

Setting up mu & mu4e

First, you have to run the initial index.

mu init --maildir=~/Mail --my-address myaccount@fastmail.com
mu index

NOTE: You may add as many --my-address arguments you want.

Now, it’s time to create your mu4e configuration for Emacs.

You may create this as a module, or just as part of your :config using use-package. I personally define variables in my init.el like this:

(defvar is-desktop (equal (system-name) "desktop-hostname")) ;; your $HOSTNAME
(defvar is-laptop (equal (system-name) "laptop-hostname"))

Create ~/.emacs.d/modules/thanos-mu4e.el for the mu4e module configuration. And add this to my init.el

(add-to-list 'load-path "~/.emacs.d/modules")

(when (or is-desktop is-laptop)
  (require 'thanos-mu4e))

This way I only load my mu4e configuration only when I’m using my laptop or desktop.

Loading Mu4e

Make sure mu4e is on load-path:

(add-to-list 'load-path "/usr/share/emacs/site-lisp/mu4e/") ;; path to mu4e
(require 'mu4e)

The essentials

This is an example configuration to get started with mu4e using multiple accounts:

(setf mu4e-get-mail-command "mbsync -a")

(when (and is-desktop (server-running-p))
  (setf mu4e-update-interval (* 10 60)))

;; Snippet from EmacsWiki
(defun set-mu4e-context (context-name full-name mail-address signature)
  "Return a mu4e context named CONTEXT-NAME with :match-func matching
    folder name CONTEXT-NAME in Maildir. The context's `user-mail-address',
    `user-full-name' and `mu4e-compose-signature'`smtpmail-smpt-server' is set to MAIL-ADDRESS
    FULL-NAME SIGNATURE and SERVER respectively.
    Special folders are set to context specific folders."
  (let ((dir-name (concat "/" context-name)))
    (make-mu4e-context
     :name context-name
     ;; we match based on the maildir of the message
     :match-func
     `(lambda (msg)
    (when msg
      (string-match-p
       ,(concat "^" dir-name)
       (mu4e-message-field msg :maildir))))
     :vars
     `((user-mail-address    . ,mail-address)
       (user-full-name       . ,full-name)
       (mu4e-sent-folder     . ,(concat dir-name "/Sent"))
       (mu4e-drafts-folder   . ,(concat dir-name "/Drafts"))
       (mu4e-trash-folder    . ,(concat dir-name "/Trash"))
       (mu4e-trash-folder    . ,(concat dir-name "/Starred"))
       (mu4e-refile-folder   . ,(concat dir-name "/Archive"))
       (mu4e-compose-signature . ,signature)))))

;;Fixing duplicate UID errors when using mbsync and mu4e
(setf mu4e-change-filenames-when-moving t)

(setf mu4e-maildir-shortcuts
      '(("/Fastmail/Inbox" . ?f)
    ("/Drafts" . ?d)
    ("/Sent" . ?s)
    ("/Gmail-Account/[Gmail]/All Mail" . ?g)

(setf mu4e-contexts
      (list
       (make-mu4e-context
    :name "fastmail"
    :match-func
    (lambda (msg)
      (when msg
        (string-prefix-p "/Fastmail" (mu4e-message-field msg :maildir))))
    :vars '((user-mail-address . "username@fastmail.com")
        (user-full-name    . "User Name")
        (smtpmail-smtp-server . "smtp.fastmail.com")
        (smtpmail-smtp-service . 465)
        (smtpmail-stream-type . ssl)
        (mu4e-drafts-folder  . "/Drafts")
        (mu4e-sent-folder  . "/Sent")
        (mu4e-refile-folder  . "/Archive")
        (mu4e-trash-folder  . "/Trash")))
        ;; You can comment out the second account.
       (make-mu4e-context
    :name "gmail"
    :match-func
    (lambda (msg)
      (when msg
        (string-prefix-p "/Gmail-Account" (mu4e-message-field msg :maildir))))
    :vars '((user-mail-address . "username@gmail.com")
        (user-full-name    . "User Name")
        (smtpmail-smtp-server . "smtp.gmail.com")
        (smtpmail-smtp-service . 465)
        (smtpmail-stream-type . ssl)))))

(setf message-send-mail-function 'smtpmail-send-it
      mu4e-compose-signature "My Signature"
      mu4e-compose-context-policy 'ask)

Extras

Mu4e actions

Mu4e actions makes it really simple to work with git patches, this is an example configuration you may like to use:

(setf mu4e-view-actions
      (delete-dups
       (append
    '(("gapply git patches" . mu4e-action-git-apply-patch)
      ("mgit am patch" . mu4e-action-git-apply-mbox)))))

Sign your emails using pgp

If you have setup your own pgp key, you may sign automatically all your emails using this hook:

(add-hook 'message-send-hook 'mml-secure-message-sign-pgpmime)

Take a look at the functions defined for mml-mode-map for more.

Gnosis does not use flashcard type learning, instead it uses a binary value to rate user input. Meaning you either know the right answer, or you do not, no rating of your own is involved.

About

On my last post, Spaced Repetition Software Gripes, I outlined a blueprint for what I consider to be the optimal design of an SRS, that caters to my personal preferences.

So, I’ve developed my own SRS, gnosis (γνῶσις), pronounced “GNU-sis”, meaning knowledge in Greek. This SRS addresses the concerns that I previously highlighted. Currently, I have found it to be highly beneficial and, as a result, I decided to share it with all of you.

Differences with other SRS

Gnosis does not implement flashcard type review sessions where the user rates his own answer on an arbitrary scale. Instead implements “note” types that require user input. Some of these note types, like the MCQ multiple choice question, even allow for simulating real-life exams.

Unlike other SRS implementations for GNU Emacs, gnosis does not rely on org-mode, which I’ve found not to be an ideal option for a database replacement. Instead opting for an sqlite database with git to track any changes made, enabling efficient data management, manipulation and data integrity.

Furthermore, since Gnosis is built upon Emacs, with Emacs Lisp, it offers a convenient and (hopefully) enjoyable experience for customization according to your individual preferences.

However, one drawback of using Gnosis is that it is not currently supported on mobile devices, as Emacs has yet to extend its compatibility to such platforms.

Installation

You can get gnosis from my personal git server here or using this sourcehut mirror.

Straight.el

(straight-use-package
 '(gnosis :type git
          :host nil
          :repo "https://git.thanosapollo.org/gnosis"))

Manual

$ git clone https://git.thanosapollo.org/gnosis

Add this to your emacs configuration:

(add-to-list 'load-path "/path/to/gnosis")
(load-file "~/path/to/gnosis.el")
(require 'gnosis)

Adding notes

Creating notes for gnosis can be done with a simple M-x gnosis-add-note

Everything is done through the mini-buffer. My personal workflow takes advantage of that by not really leaving gnosis-add-note prompt until I finish studying a chapter/section, using pdf-tools or nov.el.

I think you won’t need much guidance on creating notes for any note type, except cloze.

Creating cloze type notes

Cloze type note questions are formatted similarly to Anki’s syntax, like so: > {c1:Cyproheptadine} is a(n) {c2:5-HT2} receptor antagonist used to treat {c2:serotonin syndrome}

NOTE: You can also format clozes like Anki if you so prefer; e.g {{c1::Cyproheptadine}}

• For each cX-tag there will be created a cloze type note, the above example creates 2 cloze type notes.

• Each cX tag can have multiple clozes, but each cloze must be a UNIQUE word (or a unique combination of words) in given note.

Customizing gnosis algorithm

gnosis-algorithm-interval

This is a list of 2 numbers, for the first 2 intervals after a successful review. For example:

(setq gnosis-algorithm-interval '(1 3))

After first successfully reviewing a note, you will see it again tomorrow, if you successfully review said note again, the next review will be after 3 days.

gnosis-algorithm-ef

This is the value of gnosis “easiness factor”, it’s basically a list that consists of 3 items. The first item is the increase factor, used to increase the easiness factor upon successful review. Second item refers to the decrease factor, used to decrease the easiness factor upon an unsuccessful review. The third item is the (starting) total easiness factor, used to calculate the next interval.

The basic’s of how this is used is that it’s being multiplied with the last interval, e.g if you last reviewed a note 6 days ago, and the easiness factor (total) of this note is 2.0, your next interval would be 6 * 2.0 & the next total ef will be 2.0 + increase-factor.

Example configuration:

(setq gnosis-algorithm-ef '(0.3 0.3 1.3))

gnsois-algorithm-ff

This is the value of gnosis forgetting factor (ff), it needs to be a floating number below 1. This is used to calculate the next interval upon an unsuccessful review, by being multiplied with last interval. If for a note with a value of last-interval of 6 days and a ff of 0.5, upon an unsuccessful review the next interval will be in 6 * 0.5 days

Example configuration:

(setq gnosis-algorithm-ff 0.5)

About

I’m using eshell more than any other shell lately, but it’s lacking in terms of completions when it comes to other shells.

I’ve made this simple package to provide completions for installing & removing packages using yay.

Eshell provides a seamless integration with the rest of the Emacs ecosystem & thanks to the integration it has with Eat it has no issue with visual commands as of now, that previously struggled with. All it’s missing is decent completion features, which I believe we will see more of soon.

Installation

You can get pcomplete-yay by following the instructions on project’s git repo.

About

I love Emacs, but it’s definitely not a viable alternative to modern browsers like firefox. The desire to have an ’emacs-like’ browser lead me to use Nyxt.

Although nyxt is impressive, it has some rough edges and inherent issues. Furthermore, several websites that utilize cloudflare fail to function properly with nyxt, leading to an unending verification loop.

Presently, I have chosen to use Firefox with Emacs-like keybindings through the vimiun extension.

Here is a concise guide on replicating this setup.

Step I: about:config

First visit about:config.

To enable Emacs keybindings while editing text in Firefox, make the following changes:

• Set ui.key.accelKey to 18
• Set ui.key.chromeAccess to 0
• Set devtools.editor.keymap to emacs

Step II: gtk-key-theme

Now, adjust .config/gtk-3.0/settings.ini, make sure you’ve added gtk-key-theme-name = Emacs It should look something like this:

[Settings]
.....
gtk-key-theme-name = Emacs

Step III: Vimium

Install vimium.

Go on Vimium’s Options page to, by clicking the addon, and adjust Custom Key Mappings, here’s an example setup for Emacs.

unmapAll # use emacs-style bindings only
map <c-n> scrollDown
map <c-p> scrollUp
map <c-b> goBack
map <c-f> goForward
map <c-x>. scrollToTop
map <c-x>, scrollToBottom
map <c-V> scrollFullPageUp
map <c-v> scrollFullPageDown
map <c-x><c-r> reload
map <c-x>k removeTab
map <c-c><c-u> copyCurrentUrl
map <c-c><c-l> LinkHints.activateModeToCopyLinkUrl
map <c-c><c-o> openCopiedUrlInCurrentTab
map <c-c><c-O> openCopiedUrlInNewTab
map <c-c><c-i> enterInsertMode
map <c-x><c-f> LinkHints.activateMode
map <c-x><c-F> LinkHints.activateModeToOpenInNewForegroundTab
map <c-x><a-f> LinkHints.activateModeWithQueue
map <c-x>f LinkHints.activateModeToOpenInNewTab
map <c-x><c-d> Vomnibar.activate
map <c-x><c-D> Vomnibar.activateInNewTab
map <c-x>b Vomnibar.activateTabSelection
map <c-x><c-b> Vomnibar.activateBookmarks
map <c-x><c-B> Vomnibar.activateBookmarksInNewTab
map <c-@> Marks.activateCreateMode
map <c-x><c-@> Marks.activateGotoMode
map <c-s> enterFindMode
map <c-S> performFind
map <c-r> performBackwardsFind
map <c-R> performBackwardsFind
map <c-c>b previousTab
map <c-c>f nextTab
map <c-x>4 duplicateTab
map <c-g><c-r> restoreTab
map <c-x>5 moveTabToNewWindow
map <c-g><c-p> togglePinTab
map <a-B> moveTabLeft
map <a-F> moveTabRight
map <c-h> showHelp

You can find a complete vimium configuration that I’m using in my dotfiles repo

Related content

• Raamdev vimium emacs configuration
• emacs-keybinding addon I do not recommend using this addon

Update 2024-02-26: This is an old blog post from when I started working on this project. Check out the Project’s Page for up-to-date information.

This package does not use any kind of an API, just parses html & json using regex.

Motivation

I simple wanted to learn elisp, and decided to not watch any youtube content unless it’s inside emacs. This way I also saved a lot of time that I’d otherwise waste watching random youtube videos.

Watching youtube through youtube.com is way too distracting, the sites purpose is to keep you hooked with recommended videos that do the bare minimum to keep you engaged. Not to mention that the platform is basically proprietary spyware.

Despite that, many academics decide to upload their videos and even lectures there, so other than entertainment it’s a valuable learning resource.

Installation Guide

Project’s repo

You can install yeetube via MELPA

Straight.el

(straight-use-package
 '(yeetube :type git
           :host nil
           :repo "https://git.thanosapollo.org/yeetube"))

Manual

$ git clone https://git.thanosapollo.org/yeetube

Add this to your emacs configuration

(add-to-list 'load-path "/path/to/yeetube")
(load-file "~/path/to/yeetube.el")