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.

Fortunately, professor Antonios Kaldellis offered guidance by pointing me to a mirror of a now dead project from the University of the Aegean, for which I found an archive here. This project contains 143 of the 161 volumes of Migne’s Patrologia Graeca, in perfect condition.

You can get the pdfs from the University of the Aegean project here as tar.gz hosted by me.

I’ve now added these texts to Bebliotheca, under the #patristic tag. I will be manually adjusting the titles to a proper Koine Greek translation to follow along the theme of “Library of Constantinople”

Current Corpus Statistics of Bebliotheca

CORPUS STATISTICS:
  Total unique works:       2690
  Greek texts:              2316
  English translations:     757
  Latin texts:              374

TRANSLATION COVERAGE:
  Greek with English:       571 (24%)
  Greek with Latin:         0 (0%)
  All three languages:      0
  Greek without translation:1745 (75%)
  English-only works:       0
  Latin-only works:         188

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.

Why I use GNU Guix for my server

GNU Guix is my preferred system for every machine I use, recently I even switched my home server (back) to Guix. I use my home server to host this blog as well as my cgit instance, so far I recommend using Guix, as a hobbyist, for the following reasons:

• Roll backs
  • I had tried both Gentoo and Debian before for my server, more than once I had one or more of my self hosted services down because an update broke my setup. My time is limited and those breakages would often occur at busy weeks where I didn’t have the time to fix them. With Guix I can just roll back to a previous working generation if an update or a misconfiguration of mine breaks something.
• Reproducibility
  • Define your setup once, run anywhere. I do not want to manually setup anything.
• Simplicity
  • The entirety of Guix code lives in one repo and is almost entirely written in one language, guile scheme. If you find any issues with a service or a package you can redefine it as you like in your configuration.

Why self-host a git server?

Why would you not self-host your own projects? I find it antithetical to the FOSS ethos, and perhaps even ironic, to rely on proprietary platforms for distributing free software.

Hosting a Git server is straightforward and requires minimal resources.

git-http-backend “/” uri issue and fix

Guix has a separate configuration data type for serving Git repositories over HTTP. Currently, the regex it uses does not allow the root "/" to be used a URI for serving (ref archive).

The issue is in the (gnu services version-control) module, specifically in this part:

(define* (git-http-nginx-location-configuration #:optional
                                                (config
                                                 (git-http-configuration)))
  (match config
    (($ <git-http-configuration> package git-root export-all?
                                 uri-path fcgiwrap-socket)
     (nginx-location-configuration
      ;; ISSUE here: regex won't allow for "/"
      (uri (string-append "~ /" (string-trim-both uri-path #\/) "(/.*)"))
      (body
       (list
        (list "fastcgi_pass " fcgiwrap-socket ";")
        (list "fastcgi_param SCRIPT_FILENAME "
              package "/libexec/git-core/git-http-backend"
              ";")
        "fastcgi_param QUERY_STRING $query_string;"
        "fastcgi_param REQUEST_METHOD $request_method;"
        "fastcgi_param CONTENT_TYPE $content_type;"
        "fastcgi_param CONTENT_LENGTH $content_length;"
        (if export-all?
            "fastcgi_param GIT_HTTP_EXPORT_ALL \"\";"
            "")
        (list "fastcgi_param GIT_PROJECT_ROOT " git-root ";")
        (list "fastcgi_param GIT_CONFIG_GLOBAL "
              (plain-file "gitconfig"
                          (string-append "[safe]\n\tdirectory = " git-root "/*\n"))
              ";")
        "fastcgi_param PATH_INFO $1;"))))))

Thankfully, we can easily resolve this by redefining (gnu services version-control).

• My changes (diff) to fix this issue, as well as specify git actions:

diff --git a/gnu/services/version-control.scm b/gnu/services/version-control.scm
index a7f40812a6c..e33e5de21f0 100644
--- a/gnu/services/version-control.scm
+++ b/gnu/services/version-control.scm
@@ -235,7 +235,11 @@ (define* (git-http-nginx-location-configuration #:optional
     (($ <git-http-configuration> package git-root export-all?
                                  uri-path fcgiwrap-socket)
      (nginx-location-configuration
-      (uri (string-append "~ /" (string-trim-both uri-path #\/) "(/.*)"))
+      (uri (string-append "~ "
+			  (if (string=? uri-path "/")
+                              ""
+                              (string-append "/" (string-trim-both uri-path #\/)))
+			  "/(info/refs|git-upload-pack|git-receive-pack)"))
       (body
        (list
         (list "fastcgi_pass " fcgiwrap-socket ";")
@@ -254,7 +258,7 @@ (define* (git-http-nginx-location-configuration #:optional
               (plain-file "gitconfig"
                           (string-append "[safe]\n\tdirectory = " git-root "/*\n"))
               ";")
-        "fastcgi_param PATH_INFO $1;"))))))
+        "fastcgi_param PATH_INFO $uri;"))))))


 ;;;

You can find the full module that I use here in my dotfiles repo.

I’d recommend creating your own module and load it by running the following command:

sudo guix system reocnfigure ~/dotfiles/guix/server-config.scm -L ~/dotfiles/guix

Configuring cgit-service-type

Guix provides a cgit service module (gnu services cgit).

A couple things to note:

• You can provide css and favicon using an external url. You can find the css styling that I use here.

Example cgit-service-type

(define my/git-repos
  (list
   (repository-cgit-configuration
     (url "repo1")
     (name "repo1")
     (desc "Example Repo 1")
     (path "/srv/git/repo1")
     (section "Section 1"))
   (repository-cgit-configuration
     (url "repo2")
     (name "repo2")
     (desc "Example Repo 2")
     (path "/srv/git/repo2")
     (homepage "https://myhomepage")
     (section "Section 2"))))

(service cgit-service-type
         (cgit-configuration
           (package cgit)
           (root-desc "Root Desc")
           (repository-directory "")
           (root-title "Root Title")
           (repositories my/git-repos)
           (enable-index-owner? #f)
           (enable-http-clone? #f)
           (clone-prefix '("https://git.thanosapollo.org")) ;; change this to your own url
           ;; Cache
           (cache-root "/var/cache/cgit")
           ;; 20000 = 5 hours.  Feel free to adjust this.
           (cache-size 20000)
           (cache-static-ttl 20000)
           (cache-dynamic-ttl 20000)
           (cache-repo-ttl 20000)
           (cache-root-ttl 20000)
           (cache-scanrc-ttl 20000)
           (cache-about-ttl 20000)
           (cache-snapshot-ttl 20000)
           (case-sensitive-sort? #f)
           (css "https://thanosapollo.org/cgit.css") ;; My personal css.
           (nginx
            (list
             (nginx-server-configuration
               (server-name '("git.thanosapollo.org"))
               (root cgit)
               (try-files (list "$uri" "@cgit"))
               ;; I use cloudflare tunnel, which handles certs for me.
               (listen '("80"))
               (ssl-certificate #f)
               (ssl-certificate-key #f)
               ;; ;; If you use certbot try the following:
               ;; (listen '("443 ssl"))
               ;; (ssl-certificate
               ;;  "/etc/certs/git.my-host.org/fullchain.pem")
               ;; (ssl-certificate-key
               ;;  "/etc/certs/git.my-host.org/privkey.pem")
               (locations
                (list
                 (nginx-location-configuration
                   (uri "@cgit")
                   (body '("fastcgi_param SCRIPT_FILENAME $document_root/lib/cgit/cgit.cgi;"
                           "fastcgi_param PATH_INFO $uri;"
                           "fastcgi_param QUERY_STRING $args;"
                           "fastcgi_param HTTP_HOST $server_name;"
                           "fastcgi_pass 127.0.0.1:9000;")))
                 (git-http-nginx-location-configuration
                  (git-http-configuration
                    (uri-path "/")
                    (export-all? #t))))))))))

You can find my home server configuration here.

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)

Installing GNU Guix | Using non-free kernel drivers (Nonguix)

Notes shown in the video:

• GNU Guix is a GNU distribution
• Provides an emacs-like operating system, using guile scheme as it’s configuration language.
• Only free software is available OOB, uses linux-libre kernel by default.
  • But since it’s an emacs-like OS, we can configure it however we like, including to use the full linux kernel.

Installing Guix, using NonGuix

• NonGuix is a Guix channel that provides non-free software, such as non-free drivers & games.
• NonGuix also provides an iso image that comes with the full linux kernel

Download nonguix iso

• Visit nonguix releases page
• Download the iso image & write it to a USB stick

Example dd command to use:

$ sudo dd if=/path/to/image.iso of=/dev/sdX bs=4M status=progress

Clone nonguix repo

• After completing the graphical installer
• Clone the nonguix repo from https://gitlab.com/nonguix/nonguix
• Copy the README instructions for channels into /mnt/etc/channels.scm
• Add the NonGuix modules to your system configuration and use the linux-lts kernel on /mnt/etc/config.scm

;; Import nonfree linux module.
(use-modules (nongnu packages linux)
             (nongnu system linux-initrd))

(operating-system
  (kernel linux-lts)
  (initrd microcode-initrd)
  (firmware (list linux-firmware))
  ...
  )

Install Your System

• Run the following command to install your system:

$ guix time-machine -C /mnt/etc/channels.scm -- system init /mnt/etc/config.scm /mnt

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

History

Discovered by Alexander Fleming, in 1928. Accidentally observed that staphylococci did not grow around the mold of Penicillium rubens.

However, it wasn’t until 1941 the Australian pathologist Howard Florey and German-born British biochemist Ernst Boris Chain successfully developed a method to produce a pure form of penicillin on a large scale. This breakthrough eventually led to mass production, with penicillin becoming widely available by the end of World War II.

It revolutionized the medical world, providing an effective treatment for many bacterial infections, and earning Fleming, Florey, and Chain the 1945 Nobel Prize in Physiology of Medicine.

Fun fact:

Amalia Fleming, the wife of Alexander Fleming, was a Greek physician & politician that aided the Greek Resistance against the occupation of Axis powers.

Overview

Structure

Structurally, this class of beta-lactams particularly possesses a distinct 4-membered beta-lactam ring, in addition to a thiazolide ring and an R side chain.

The main distinguishing feature between variants within this family is the R substituent. This side chain is connected to the 6-aminopenicillanic acid residue and results in variations in the antimicrobial spectrum, stability, and susceptibility to beta-lactamases of each individual bactericidal drug.

Mechanism of Action

The mechanism of action for Penicillins primarily focuses on inhibiting bacterial cell wall synthesis, an essential process for bacterial growth and survival. The beta-lactam ring in penicillins mimics the D-Alanyl-D-Alanine terminal structures found in the precursors of bacterial cell walls. This mimicry allows penicillins to bind to penicillin-binding proteins (PBPs), which are enzymes involved in cell wall synthesis.

Upon binding, the normal function of the PBPs is disrupted, leading to faulty cell wall production. As a result of these alterations in cell wall integrity, bacteria can undergo lysis due to imbalances in cellular osmotic pressure, thus achieving the bactericidal effect of penicillins.

Moreover, the R side chain of penicillin allows for its diverse range of action against different types of bacteria, due to variations affecting the antimicrobial spectrum, stability, and resistance to beta-lactamases.

Antibacterial Spectrum & Types

Naturally occurring

Obtained from fermentations of the fungus Penicillum chrysogenum

Penicillin G

Penicillin G is a crucial member of the penicillin family due to its unique characteristics. It doesn’t absorb well through the gastrointestinal tract, so it is predominantly used intravenously. Due to its selectivity, most species of Streptococci show sensitivity towards it, leading to effective infection control in most cases.

However, it is worth noting that the majority of Staphylococcus aureus species have developed resistance to it, rendering the penicillin G less effective in such situations.

Despite this, penicillin G is the drug of choice when it comes to the treatment of gas gangrene brought about by Clostridium perfringens. Similarly, its efficacy is demonstrated in the treatment of infections like syphilis caused by Treponema.

Penicillin G is effective in treating syphilis, one essential thing to note is the potential occurrence of the Jarisch-Herxheimer reaction. This is a systemic reaction, often observed within the first few hours of therapy in patients treated for syphilis. Symptoms may include fever, chills, headache, and myalgia. While it can be alarming, the reaction is typically self-limiting and can be managed symptomatically.

Penicillin V

Penicillin V, a less potent variant of Penicillin G, is typically administered orally due to its acid-stable properties. This makes it highly effective and safe for gastric administration.

While it delivers a milder impact compared to Penicillin G, it is widely utilized in treating less severe infections, making it an essential component in the spectrum of Penicillins.

Antistaphylococcal penicillins

Also known as penicillinase-resistant penicillins, are a subset of penicillins that are particularly effective against Staphylococcus infections. Unlike regular penicillins, they are resistant to penicillinase (beta-lactamase) enzymes secreted by certain bacteria to nullify penicillins’ bactericidal activity.

Methicillin, although no longer commonly used due to allergic reactions and resistance, was one of the first of these penicillins. It paved the way for other, more robust, antistaphylococcal penicillins.

Flucloxacillin, oxacillin, and dicloxacillin, largely have replaced methicillin.

They all have a similar mechanism of action, they inhibit bacterial cell wall synthesis by binding to penicillin-binding proteins, ultimately leading to bacterial cell death. These medications are primarily used for skin and soft tissue infections caused by Staphylococcus aureus, including cellulitis and impetigo.

Although they are generally well-tolerated, they can cause side effects like gastrointestinal issues and allergic reactions. These drugs should be used with caution in patients with a history of penicillin allergy and kidney disease. Oxacillin and dicloxacillin are often more desirable due to their ability to be administered orally compared to flucloxacillin, which is typically given parenterally.

Aminopenicillins

They are classified as broad-spectrum antibiotics due to their utility against both gram-negative and gram-positive bacteria. Amoxicillin and Ampicillin are common examples of Aminopenicillins.

Ampicillin

Ampicillin, exhibits similar antibacterial spectrum as amoxicillin but differs crucially in its pharmacokinetics and mode of administration.

While it is effective against many Gram-positive and select Gram-negative bacteria, it lacks stability in gastric acid, which can lower its systemic absorption when taken orally.

Therefore, it is frequently administered intravenously or intramuscularly in a clinical setting. Ampicillin’s spectrum can be notably widened by the co-administration of a beta-lactamase inhibitor such as sulbactam.

Amoxicillin

Distinguished by its wide usage in treating a variety of bacterial infections. It is favored for its broad-spectrum antibacterial activity against both Gram-positive and Gram-negative microbes, including H. influenzae, E. coli, and S. pneumoniae. Its enhanced stability against gastric acid ensures a higher systemic absorption when administered orally, a major advantage over its contemporaries.

Additionally, amoxicillin is often prescribed in combination with clavulanic acid, a beta-lactamase inhibitor, to tackle bacteria producing beta-lactamase enzymes which can otherwise inactivate amoxicillin.

Extended-spectrum

Piperacillin

Piperacillin is a potent extended-spectrum penicillin developed to counter the rise of resistant bacterial infections.

It has broader antibacterial activity than most other penicillins, particularly effective against Gram-negative bacteria including pseudomonas aeruginosa. Piperacillin also has superior activity against enterococci, however, it remains ineffective against methicillin-resistant Staphylococcus aureus (MRSA). It functions by inhibiting bacterial cell wall synthesis, leading to cell death.

Piperacillin is often combined with tazobactam, a beta-lactamase inhibitor, to overcome resistance caused by beta-lactamase enzymes.

Ticarcillin

Ticarcillin, another extended-spectrum penicillin, has a similar mechanism to piperacillin, targeting bacterial cell wall synthesis. But it differs from piperacillin in its antimicrobial spectrum.

It is less active against Gram-negative bacteria and has minimal activity against pseudomonas aeruginosa. However, it is more effective against staphylococci and streptococci bacteria.

Ticarcillin is frequently used with a beta-lactamase inhibitor, clavulanic acid, to combat beta-lactamase-associated resistance.

Comparison

Comparing both, ticarcillin has a lower sodium load which may be beneficial in patients requiring sodium restriction.

XMPP is a libre decentralized collection of technologies, alternative to closed communication services. I’ve started self hosting my own xmpp server, and begun moving people from my close circle there. This is a summary of my collection of notes that I made for XMPP thus far, published as a short article. If you are interested in learning more on XMPP I recommend reading their official website.

What is XMPP?

XMPP stands for eXtensible Messaging and Presence Protocol, it’s a set of libre technologies that can be used for communication services, such as instant messaging, voice & video calls as well as file transfers. This is done by routing XML data.

XMPP operates similarly to HTTP, with the client initiating a communication socket to an XMPP server and maintaining it open for the entirety of the client’s active session.

XMPP was originally developed in the Jabber community to provide an open decentralized alternative to closed messaging services.

XMPP is used by a few popular platforms, these include WhatsApp, Facebook Messenger & Jitsi.

Why should you use XMPP?

For me, the primary appeal of XMPP lies in its interoperability, versatility, and extensibility. Via transports or gateways, XMPP enables a seamless connection with communities across various platforms including IRC, Matrix, WhatsApp, Telegram all from a single client.

Furthermore, the decentralized nature of XMPP is designed for self hosting, with minimal resources. This gives me the freedom to establish and manage my own server, creating an ecosystem that provides me with freedom & respects my rights, to which I can bring my family and friends.

How to communicate with IRC & Matrix using XMPP?

You can use a gateway that connects to your desired platform/protocol. For example, for IRC you’d use biboumi or btifrost for Matrix.

There are publicly available gateways, for example you can use the the biboumi gateway from jabberfr.org to connect to the emacs IRC channel in libera.chat like this #emacs%irc.libera.chat@irc.jabberfr.org

Self hosting an XMPP server

If you are not interested in self hosting an XMPP server, refer to this list to find servers to register to.

ejabberd

I opted to use ejabberd server for my setup, which I found really simple to setup with voice & video calls.

Setting up an ejabberd server is that simple that it does not really require instructions. I’d recommend you use their RUN Installer or if you are on debian/fedora to check out their releases for an rpm/deb package.

Other server & client options can be found here.

XMPP clients

All in all, XMPP offers user friendly clients in all platforms, that everyone can use, as always refer here for up-to-date recommendations.

This is what I personally have been using this past week with XMPP & recommend.

Mobile

• For android, I’d recommend to use cheogram, it’s based on conversations with a few visual tweaks and additional features.
• For iOS, I’ve installed Monal to my friends & family. I’m not sure if it’s the best one available since the iOS ecosystem is foreign to me, but the people I’ve installed it on found it pleasant to use.

Desktop

• I’d recommend Dino, it’s been really easy to use with full support of most xmpp features (OMEMO encryption etc.)
• There is also emacs-jabber, an emacs jabber extension, that unfortunately does not support any kind of encryption. It’s decent for public unencrypted channels.

Jellyfin can do much more than stream your favorite movies & TV shows. Whether you’re a movie enthusiast, music lover, or photo fanatic, Jellyfin has got you covered.

What is Jellyfin

Jellyfin is a self-hosted multimedia service, which gives you full control of your media. It’s one of the easiest and most useful services to self host, refer to Jellyfin’s installation instructions for up-to-date information.

Why Jellyfin

Jellyfin’s key strength is its multi-platform support. Unlike other media services like Dim, a rust media manager, jellyfin supports a wide range of platforms including iOS & Android. This make it easy to access your content, from any device, at any time.

Accessing Jellyfin

Jellyfin will be available by default on your local network on <host:8096>. I recommend using a VPN service like tailscale or pivpn to access your jellyfin instance when you are not on your local network.

Jellyfin As A Movie & TV Show Streaming Service

Streaming services are going through a weird phase, an era of service specialization has begun, also know as platform decay. Long gone are the days when you subscribe to just one streaming service, it has become a multi-platform journey.

With jellyfin you can bypass geo-restrictions & have complete control & autonomy. Today’s commercial streaming services seem to offer a deteriorating user experience, making it increasingly difficult to justify their subscription fees.

Depending on how you access your Jellyfin instance & the hardware you are using, you can have an improved performance, especially when compared to “free” streaming services.

Jellyfin As A Music Streaming Service

Everybody is making posts about Jellyfin as a Plex/Netflix alternative, but it’s also an even better music player on mobile than Spotify as well, thanks to Gelli, which offers a native music player for Android.

My music collection is precious to me, unfortunately with services like Spotify you do not own it, you cede control over your collection. Spotify, vast in its reach and scale, can alter its terms & user experience at will, such as removing your favorite artists albums or adjusting it’s algorithm recommendations to maximize their profit while disregarding your own taste.

Jellyfin is self-hosted, thereby retaining all choices and decisions lie squarely within your ambit of control.

Jellyfin As A Digital Library

My digital library is crucial to me. Accessibility is key, whether at my university’s library, coffee shop, or even at a lecture hall. Jellyfin facilitates this seamlessly. While the content viewer might not cater to my preferences, I mitigate this by downloading the required book and reading it in Emacs using pdf-tools or nov.el.

Downsides Of Using Jellyfin

Jellyfin’s downside is the potential reliance it might inadvertently create on file sharing services. Depending on the communities you visit, your experience might vary; you might come across toxic individuals or friendly people that share your passion.

I recommend reading torrentfreak to keep yourself up to date on recent developments and suggestions.

Conclusion

Jellyfin is a powerful self-hosting multimedia solution that allows users to manage their movie library, music collection & digital library all within a single service across multiple platforms.

The main downside of using Jellyfin is the reliance on 3rd party file sharing services. Although, relying on a commercial streaming service is an even worse option these days.

Setting up immich is quite simple, just follow the official documentation. They even offer an installation script.

Recommendations

I advise against using services like Cloudflare Tunnel to make Immich accessible publicly for security and privacy concerns. Instead, consider using a VPN service such as tailscale/headscale for a more secure & convenient setup.

If you are using iCloud for your photos, there is a memory leak bug that will cause the iOS app to crash when uploading large amounts of media files. Either first download all your photos from iCloud & then upload to them Imminch, or “babysit” your phone while it’s uploading.

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.

My new setup

For the past ~6 months, I have been relying on a VPS service from Ionos, which offers a decent service for it’s price plans, to host this site & my git server, as well as to occasionally port forward media services such as jellyfin using an ssh tunnel. This weekend, I opted to migrate to an old thinkpad that I had collecting dust plus cloudflare tunnel.

Cloudflare tunnel is ideal for securely connecting a self hosted web server to Cloudflare’s global network. But be aware that cloudflare can decrypt your traffic. I do not recommend using cloudflare tunnel to host sensitive information, or to share large media files.

To share media with friends, I use tailscale, I plan in the future to host headscale, a self hosted implementation of tailscale. Tailscale is a zero config VPN, you can add your family & friends to your account or just “funnel” content to a public address to give someone quick access.

Transition Tips

First of all, evaluate your current VPS usage and identify which services can be easily self hosted. I’d recommend to start slowly migrating your services to your own hardware & use ssh tunnel for port forwarding.

Test out cloudflare tunnel, tailscale and other similar services until you find the one you like the most.

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)

I should also note that I consider Spaced Repetition to be a cheat code for learning, that should be used by every student.

What is Spaced Repetition Learning

Spaced Repetition is based on the following premise: > Repetitive exposure to information contributes to the elongation of memory retention.

Our cognitive faculties are inherently programmed to retain pertinent information while discarding extraneous details, a process contingent upon the frequency by which we encounter such information.

TL;DR: The more frequently you are exposed to information, the longer you retain it

My ‘gripes’ with spaced repetition software

I have chosen to develop my own SRS (Spaced Repetition Software/System) instead of relying on existing, well-established ones. Through my implementation called “gnosis” (GNOH-sis, meaning knowledge in Greek) I aim to address and overcome the challenges and limitations associated with current SRS solutions. With gnosis, I hope to resolve most, if not all, of these issues and provide a more refined and advanced learning experience.

Not libreware

This refers to proprietary software that implements spaced repetition, some of which are even guilty for removing the spaced repetition feature that their users paid for. I had a paid subscription with quizlet only to find out that they removed the spaced repetition feature I had already paid & was using, rendering my then workflow obsolete.

Do not depend on software you don’t own for your work. You don’t “own” proprietary software, despite paying for it.

You should strive to use only libreware for your workflow.

Lack of customization

Good software should fit your workflow like a glove, to do that it has to give a lot of room for user customization. Trivial changes such as color-scheme changes to more advanced feature customization like adding your own custom card types and changing the spaced repetition algorithm should be simple and easy to make. For example, a med student would use a longer time interval for his algorithm than, let’s say, someone trying to expand their Japanese vocabulary.

Since we already established the need for our ideal software to be libreware, making changes to the core components would be trivial. But it should be added that customization to fit different needs & learning styles should be a primary goal when designing a SRS.

Flashcards are an inferior learning method.

Flashcards are quite trivial to make, prototypical spaced repetition methods utilized physical flashcards. Today’s computers allows us for more sophisticated ‘review’ methods, such as using user input.

Utilizing user input to assess the effectiveness of a review is preferable to simply revealing an answer and asking whether it was known or not. This approach ensures not only the comprehension of the answer but also the accurate spelling of it. Moreover, it leads to more efficient retention compared to simply displaying the answer without any active engagement from the user.

Ideally with Gnosis I would also like to implement MCQ type to simulate the USMLEs exams which I will hopefully soon be undertaking. This will make it possible to simulate any other MCQ exam

No self-rating

It is recommended that users do not self-rate their answers. The review process should involve a binary assessment of success or failure, where users either recall the answer correctly or not. This success/failure rating will be used to determine the next interval for the specific note, optimizing the spaced repetition system for effective learning.

Collaboration

Most spaced repetition software relies on databases for storage, but the downside is that databases are not easily readable or editable by humans, hindering sharing and collaboration.

To address this limitation, I intend to incorporate exporting capabilities on gnosis. This feature would enable users to export a deck of notes in a user-friendly format, which can then be easily shared and collaborated on using tools like git repositories.

This collaborative approach would allow us to work together, share, and create valuable learning materials that can be used and modified by everyone involved.

Syncing between devices

Anki makes syncing between devices a breeze! But it gets terrible slow if you are syncing a new device when you have a lot of material in your account, plus you depend on Anki’s servers for it to work.

Since on gnosis I will be using sqlite as my database implementation, I would just be using git to keep my database in sync between different devices.

Gnosis

You can find gnosis on my git server here, read the about section for installation instructions.

It’s still not even in alpha version yet, but it has the fundamental functionality there already for you to test. Feel free to email me if you have any questions or requests for gnosis.

Disclaimer: This post contains a healthy amount of sarcasm, just in case you didn’t catch on.

About

I’ve been an Arch Linux user for a while now, Arch Linux was the first distro I’ve ever installed on hardware. It treated me well over the past year, but after trying out gentoo on a virtual machine I think I’ve found my $HOME. Now I’m running Gentoo on all of my devices for the past 2+ weeks.

What did you enjoy so much about Gentoo?

Gentoo Handbook

The Gentoo Handbook, I can’t really stress this enough, the Gentoo Handbook, is extensively documented with every detail you might need, specifically for using Gentoo. The Arch Wiki is awesome, it includes documentation for a wide range of programs, but it’s a generic documentation that feels more like a general “Linux wiki” rather than specific for Arch Linux. Even the parts that are specific to Arch Linux, such as the installation instructions, are severely lacking, which leads to most of the Arch Linux users to rely on third party guides even on how to install their OS.

No other Linux Distribution has a centralized “book” that takes you “by the hand” from the installation process all the way to working with native software tools that you’ll interact with on a daily basis, that can compare to the Gentoo Handbook.

Community

One thing that I advocate about choosing which software to use is:

Use software projects that you wouldn’t mind / would like contributing to

Gentoo community is the most helpful one that I’ve found so far, specifically I’ve had people on the GURU Project, analogous to the AUR package software that I needed as well as help me on contributing, which has been a rather pleasant & chill experience.

If a project has a “toxic” community that you don’t want to interact with, its a huge red-flag for me.

But… Why would you compile everything from source?

Because someone has too…

Jokes aside, there are many advantages to compiling your system from source rather than installing an already made binary that someone else compiled, hoping that it is compiled the way you want.

Mental Outlaw (Invidious) has made a nice video explaining some important details/reasons for running Gentoo, as well as 10leej (Invidious), if you want to learn more.

It takes way too much time install, nobody has time for that!

It doesn’t really take that much more time from installing Arch Linux, I’ve installed Gentoo on my desktop (Ryzen 7 5800X) the first time, in ~2 hours, most of which I’ve spend reading the handbook. For reference, my compile times are as follows:

output of genlop -t <package>

sys-kernel/gentoo-kernel-6.1.57 merge time: 15 minutes and 40 seconds. www-client/firefox-115.4.0 merge time: 15 minutes and 26 seconds. app-editors/emacs-29.1-r1 merge time: 52 seconds. x11-wm/qtile-0.22.1-r2 merge time: 6 seconds.

The only time consuming compile times I’ve seen were for firefox & linux kernel, both of which are just 30 min combined, you also have the option to use -bin packages instead. With the exception of those 2 packages mentioned above, I haven’t spend more than 2 minutes compiling a package.

I’ve first considered setting up distcc for my ThinkPad x220, but eventually I decided to let firefox & gentoo-kernel compile while I’m on the gym for my workout.

Note: I’ve only installed ~700 packages on ThinkPad, and ~900 on my desktop, most of that difference is due to installing qemu/virt-manager on my desktop & random fonts. I’m not using a DE, if you are planning to use GNOME or KDE etc. you might have a different experience than me in that regard, since many DE’s are quite large and take a lot of time to compile.

Summary

I’ve been enjoying running Gentoo on all my devices for the past weeks. One of the main advantages of Gentoo is the control it provides for tailoring your system to your liking. This is bundled with one of the best documentation, if not the best, available to learn everything you need to know about using your Linux system.

The community is rather chill & friendly that welcomes new contributions and will help you with any issue you might have.

If you are able to read and follow instructions on how to install & use your system, you will find Gentoo to be a simple, reliable Linux Distribution, with a helpful community. If you want a “just works” experience, stay away from Gentoo, it’s a “Nerd’s Only Allowed” place.

About

I’ve first registered this site using thanosapollo.com, .com is the default when it comes to today’s websites, roughly 50% of websites use it and that’s what most users are familiar with.

.com stands for commercial/for profit, although it’s sometimes also used by blogs and nonprofit sites to capture more visitors. On the other hand, .org is associated with nonprofit organizations, or that generally provide free information and resources.

The context of this post refers to .org not just as a top level domain, but as a freely accessible FOSS site.

Why switch to .org and why we need more .org sites

I’m not planning to use this site for any kind of commercial/for profit purpose, having a .org extension implies that this site purpose is non-commercial. Even though it’s less popular, I find that today’s web landscape needs more .org sites and less .com.

About ~10 years ago, when I was 13 years old, the web seemed to be a sanctuary of freely available information. 10 years later, even useless information is behind a javascript pay-wall or login portal. The web’s increased traffic has been followed with lesser valuable content creation, with today’s users being accustomed to using the ‘web’ only through mobile social media apps, making them tied to a proprietary ecosystem where they don’t even own their profiles on said platforms, their webmaster does.

We need more sites that offer free information for all and less people behind proprietary platforms. I hope in the future we have more people actually owning the sites they share their content. They might make blogs or whatever else they like, as long as less of them end up at the mercy of big tech .com companies.

Even if you are after creating only for-profit content, making your business depend entirely on a 3rd party is not the brightest idea.

Difficulties of changing my site to .org

The only issue with changing my site’s extension was updating my project’s git remotes & package recipes as well email services to the new domain name. Although this is more of an inconvenience rather than an actual difficulty.

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

• You can find my SearXNG instance here

About

SearXNG is a meta search engine, aggregates search results from various sources. No search engine today provides adequate results, everything is filled with ads and sites that just optimize for SEO & quantity over quality.

• Most of today’s mainstream sites provide worse content than chat gpt 3.5.

What issues does SearXNG solve?

Finding Good Content & Finding it FAST! I don’t like wasting my time, unless it’s about configuring emacs, I just want to search for something and get the best results ASAP.

But Thanos, what do you mean? It’s a meta search engine, it’s not as fast as something like google or duckduckgo

Yes! Since SearXNG aggregates results from different sources, it’s not as fast as using a single one of them alone. But… let’s see a scenario that you want to search for a video, you’d open your browser, then go to youtube.com or odysee, then search for your video query. If you were using SearXNG all you’d have to do is just type !yt VIDEO-QUERY. Maybe you are looking for a book? just type !aa book-title on the saerch bar and you will get results from annas-archive.org

It’s even more powerful for researching ‘scientific’ topics. I can directly search pubmed for nano-antibiotics in treatment of lung infection by just writing !pub in front of the search query.

I’m using Nyxt as my browser, I had set different keybindings to search pubmed & the archlinux wiki but using a meta search engine like SearXNG is even more powerful than that & way easier to setup, offering ~70 search engines!.

How to setup SearXNG

• I’m using Ionos to host my SearXNG instance, it offers unlimited bandwidth for just 1$/month, the best deal that I’ve found.
• The best guide that I’ve found on setting up SearXNG is at landchad.net by goshawk22, refer to this guide & to the SearXNG docs if you have any issues.

Step 1: Clone the repo & run the installation script

$ git clone https://github.com/searxng/searxng /usr/local/searxng/searxng-src
$ cd /usr/local/searxng/searxng-src
$ ./utils/searxng.sh install all

Step 2: Configure nginx

Create a new file /etc/nginx/sites-available/searxng.conf and add the following:

server {
    # Listens on http
    listen 80;
    listen [::]:80;

    # Your server name
    server_name searx. example.org ;

    # If you want to log user activity, comment these
    access_log /dev/null;
    error_log  /dev/null;

    # X-Frame-Options (XFO) header set to DENY
    add_header X-Frame-Options "DENY";

    # HTTP Strict Transport Security (HSTS) header
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";

    # Content Security Policy (CSP)
    add_header Content-Security-Policy "default-src 'self';";

    location / {
        uwsgi_pass unix:///usr/local/searxng/run/socket;

        include uwsgi_params;

        uwsgi_param    HTTP_HOST             $host;
        uwsgi_param    HTTP_CONNECTION       $http_connection;

        # see flaskfix.py
        uwsgi_param    HTTP_X_SCHEME         $scheme;
        uwsgi_param    HTTP_X_SCRIPT_NAME    /searxng;

        # see limiter.py
        uwsgi_param    HTTP_X_REAL_IP        $remote_addr;
        uwsgi_param    HTTP_X_FORWARDED_FOR  $proxy_add_x_forwarded_for;

    }
}

• Create a symbolic link to enable this site.

$ ln -s /etc/nginx/sites-available/searxng.conf /etc/nginx/sites-enabled/searxng.conf

• Now all you have to do is restart Nginx and SearXNG.

$ systemctl restart nginx
$ service uwsgi restart searxng

• Setting up https connection with certbot optional

$ apt install python3-certbot-nginx # install certbot
$ certbot --nginx

Step 3: Configuring your instance

You will be playing around with those 2 paths:

/etc/searxng/settings.yml & /usr/local/searxng

You can find the default configuration here, although I recommend using the default settings as much as possible if you are just starting out.

Your theming configuration lies at usr/local/searxng/searxng-src/searx/static/themes/simple you can remove & edit the default logos or do whatever fancy stuff you like there.

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")